public static void EmitInsideNamespace(this JavascriptFormatter formatter, TypeDefinition typedef, bool isTopLevel, Action <bool> inner)
{
var fullNamespace = DefinitelyTypedUtilities.GetFullNamespace(typedef);
foreach (var part in fullNamespace)
{
if (isTopLevel)
{
formatter.WriteRaw("export");
formatter.Space();
formatter.WriteRaw("declare");
formatter.Space();
isTopLevel = false;
}
formatter.WriteRaw("namespace");
formatter.Space();
formatter.Identifier(part);
formatter.Space();
formatter.OpenBrace();
}
inner(isTopLevel);
foreach (var part in fullNamespace)
{
formatter.CloseBrace();
}
}
public DefinitelyTypedEmptyAstEmitter(
JavascriptFormatter output, JSILIdentifier jsil,
TypeSystem typeSystem, ITypeInfoSource typeInfo,
Configuration configuration
)
{
//Configuration = configuration;
//Output = output;
//JSIL = jsil;
TypeSystem = typeSystem;
//TypeInfo = typeInfo;
//IncludeTypeParens.Push(false);
//PassByRefStack.Push(false);
//OverflowCheckStack.Push(false);
//VisitNestedFunctions = true;
/*if (output.SourceMapBuilder != null)
* {
* BeforeNodeProcessed += AddSourceMapInfo;
* //AfterNodeProcessed += AddSourceMapInfoEnd;
* }*/
ReferenceContext = new TypeReferenceContext();
}
public static void ConditionalNewLine(this JavascriptFormatter formatter)
{
if (!formatter.PreviousWasLineBreak)
{
formatter.NewLine();
}
}
private void EmitArgumentList <TArgs> (JavascriptFormatter formatter, TArgs arguments, bool interiorLineBreak = false)
where TArgs : IEnumerable <JSNode>
{
var first = true;
foreach (var arg in arguments)
{
// FIXME: Should we put something else here?
if (arg == null)
{
continue;
}
if (!first && !formatter.PreviousWasLineBreak)
{
if (interiorLineBreak)
{
formatter.NewLine();
}
else
{
formatter.Space();
}
}
Visit(arg);
first = false;
}
}
public static void WriteSExpr(
this JavascriptFormatter formatter, string keyword,
Action <JavascriptFormatter> interior = null,
bool lineBreakInside = false, bool lineBreakAfter = false
)
{
formatter.WriteRaw("({0} ", keyword);
formatter.Indent();
if (lineBreakInside)
{
formatter.NewLine();
}
if (interior != null)
{
interior(formatter);
}
if (lineBreakInside && !formatter.PreviousWasLineBreak)
{
formatter.NewLine();
}
formatter.Unindent();
formatter.WriteRaw(")");
if (lineBreakAfter)
{
formatter.NewLine();
}
}
public JavascriptAssemblyEmitter (
AssemblyTranslator assemblyTranslator,
JavascriptFormatter formatter
) {
Translator = assemblyTranslator;
Formatter = formatter;
}
/// <summary>
/// Writes a method signature to the output.
/// </summary>
public void WriteSignatureToOutput(
JavascriptFormatter output, JSFunctionExpression enclosingFunction,
MethodReference methodReference, MethodSignature methodSignature,
TypeReferenceContext referenceContext,
bool forConstructor
)
{
int index;
var record = new CachedSignatureRecord(methodReference, methodSignature, forConstructor);
if ((enclosingFunction.Method != null) && (enclosingFunction.Method.Method != null))
{
var functionIdentifier = enclosingFunction.Method.Method.Identifier;
CacheSet localSignatureSet;
if (LocalCachedSets.TryGetValue(functionIdentifier, out localSignatureSet))
{
if (localSignatureSet.Signatures.TryGetValue(record, out index))
{
output.WriteRaw("$s{0:X2}", index);
return;
}
}
}
if (!Global.Signatures.TryGetValue(record, out index))
{
output.Signature(methodReference, methodSignature, referenceContext, forConstructor, true);
}
else
{
output.WriteRaw("$S{0:X2}()", index);
}
}
public static void WriteSelfReference(this JavascriptFormatter formatter, TypeDefinition typeDefinition, Facade facade)
{
switch (facade)
{
case Facade.Instance:
formatter.Identifier("Instance");
formatter.WriteGenericArgumentsIfNeed(typeDefinition.GenericParameters, null);
break;
case Facade.TIn:
formatter.Identifier("TIn");
formatter.WriteGenericArgumentsIfNeed(typeDefinition.GenericParameters, null);
break;
case Facade.TOut:
formatter.Identifier("TOut");
formatter.WriteGenericArgumentsIfNeed(typeDefinition.GenericParameters, null);
break;
case Facade.Static:
formatter.Identifier("Static");
formatter.WriteGenericArgumentsIfNeed(typeDefinition.GenericParameters, null);
break;
case Facade.Factory:
formatter.Identifier("Factory");
break;
default:
throw new ArgumentOutOfRangeException("facade", facade, null);
}
}
public IAssemblyEmitter MakeAssemblyEmitter(AssemblyTranslator translator, AssemblyDefinition assembly, JavascriptFormatter formatter)
{
if (translator.IsStubbed(assembly) || translator.IsIgnored(assembly))
return new NullAssemblyEmitter();
else
return new WasmSExprAssemblyEmitter(translator, assembly, formatter);
}
public JavascriptAssemblyEmitter(
AssemblyTranslator assemblyTranslator,
JavascriptFormatter formatter
)
{
Translator = assemblyTranslator;
Formatter = formatter;
}
public JavascriptAstEmitter(JavascriptFormatter output, JSILIdentifier jsil, TypeSystem typeSystem, ITypeInfoSource typeInfo)
{
Output = output;
JSIL = jsil;
TypeSystem = typeSystem;
TypeInfo = typeInfo;
IncludeTypeParens.Push(false);
}
public JavascriptAssemblyEmitter (
AssemblyTranslator assemblyTranslator,
JavascriptFormatter formatter,
IDictionary<AssemblyManifest.Token, string> referenceOverrides
) {
Translator = assemblyTranslator;
Formatter = formatter;
_referenceOverrides = referenceOverrides;
}
/// <summary>
/// Writes a method signature to the output.
/// </summary>
public void WriteSignatureToOutput(
JavascriptFormatter output, JSFunctionExpression enclosingFunction,
MethodReference methodReference, MethodSignature methodSignature,
TypeReferenceContext referenceContext,
bool forConstructor
)
{
int index;
CachedSignatureRecord cacheRecord;
GenericParameter[] rewrittenGenericParameters = null;
if (LocalCachingEnabled && PreferLocalCacheForGenericMethodSignatures)
{
cacheRecord = new CachedSignatureRecord(methodReference,
GenericTypesRewriter.NormalizedConstructorSignature(methodReference, methodSignature, forConstructor),
forConstructor);
}
else
{
RewritedCacheRecord <MethodSignature> rewritten = GenericTypesRewriter.Normalized(methodReference,
methodSignature, forConstructor);
cacheRecord = new CachedSignatureRecord(methodReference, rewritten.CacheRecord, forConstructor,
rewritten.RewritedGenericParameters.Length);
rewrittenGenericParameters = rewritten.RewritedGenericParameters;
}
if ((enclosingFunction.Method != null) && (enclosingFunction.Method.Method != null))
{
var functionIdentifier = enclosingFunction.Method.Method.Identifier;
CacheSet localSignatureSet;
if (LocalCachedSets.TryGetValue(functionIdentifier, out localSignatureSet))
{
if (localSignatureSet.Signatures.TryGetValue(cacheRecord, out index))
{
output.WriteRaw("$s{0:X2}", index);
return;
}
}
}
if (!Global.Signatures.TryGetValue(cacheRecord, out index))
{
output.Signature(methodReference, methodSignature, referenceContext, forConstructor, true);
}
else
{
output.WriteRaw("$S{0:X2}", index);
output.LPar();
if (rewrittenGenericParameters != null)
{
output.CommaSeparatedList(rewrittenGenericParameters, referenceContext);
}
output.RPar();
}
}
/// <summary>
/// Writes an interface member reference to the output.
/// </summary>
public void WriteInterfaceMemberToOutput(
JavascriptFormatter output, Compiler.Extensibility.IAstEmitter astEmitter,
JSFunctionExpression enclosingFunction,
JSMethod jsMethod, JSExpression method,
TypeReferenceContext referenceContext
)
{
int index;
CachedInterfaceMemberRecord record;
GenericParameter[] rewrittenGenericParameters = null;
if (LocalCachingEnabled && PreferLocalCacheForGenericInterfaceMethodSignatures)
{
record = new CachedInterfaceMemberRecord(jsMethod.Reference.DeclaringType, jsMethod.Identifier);
}
else
{
var rewritten = GenericTypesRewriter.Normalized(jsMethod.Reference.DeclaringType);
record = new CachedInterfaceMemberRecord(rewritten.CacheRecord, jsMethod.Identifier,
rewritten.RewritedGenericParameters.Length);
rewrittenGenericParameters = rewritten.RewritedGenericParameters;
}
if (enclosingFunction.Method != null && enclosingFunction.Method.Method != null)
{
var functionIdentifier = enclosingFunction.Method.Method.Identifier;
CacheSet localSignatureSet;
if (LocalCachedSets.TryGetValue(functionIdentifier, out localSignatureSet))
{
if (localSignatureSet.InterfaceMembers.TryGetValue(record, out index))
{
output.WriteRaw("$im{0:X2}", index);
return;
}
}
}
if (!Global.InterfaceMembers.TryGetValue(record, out index))
{
output.Identifier(jsMethod.Reference.DeclaringType, referenceContext, false);
output.Dot();
astEmitter.Emit(method);
}
else
{
output.WriteRaw("$IM{0:X2}", index);
output.LPar();
if (rewrittenGenericParameters != null)
{
output.CommaSeparatedList(rewrittenGenericParameters, referenceContext);
}
output.RPar();
}
}
public JavascriptAssemblyEmitter(
AssemblyTranslator assemblyTranslator,
JavascriptFormatter formatter,
IDictionary <AssemblyManifest.Token, string> referenceOverrides
)
{
Translator = assemblyTranslator;
Formatter = formatter;
_referenceOverrides = referenceOverrides;
}
public void WriteTo(JavascriptFormatter output)
{
if ((Arguments != null) && (Arguments.Length > 0))
{
output.WriteRaw(Format, Arguments);
}
else
{
output.WriteRaw(Format);
}
}
public static void WriteGenericArgumentsIfNeed(this JavascriptFormatter formatter, IEnumerable <string> genericParameterNames)
{
var items = genericParameterNames.ToList();
if (items.Count > 0)
{
formatter.WriteRaw("<");
formatter.CommaSeparatedList(items, item => { formatter.Identifier(item); });
formatter.WriteRaw(">");
}
}
public IAssemblyEmitter MakeAssemblyEmitter(
AssemblyTranslator translator,
AssemblyDefinition assembly,
JavascriptFormatter formatter,
IDictionary<AssemblyManifest.Token, string> referenceOverrides
)
{
if (translator.IsStubbed(assembly) || translator.IsIgnored(assembly))
return new NullAssemblyEmitter();
else
return new WasmSExprAssemblyEmitter(translator, assembly, formatter);
}
public AstEmitter(
JavascriptFormatter formatter, JSILIdentifier jsil,
TypeSystem typeSystem, TypeInfoProvider typeInfoProvider,
Configuration configuration, bool isTopLevel
)
: base()
{
Formatter = formatter;
TypeSystem = typeSystem;
TypeInfo = typeInfoProvider;
Configuration = configuration;
IsTopLevel = isTopLevel;
JSIL = jsil;
}
public static void WriteGenericMethodSignatureWithoutResultType(this JavascriptFormatter formatter, IEnumerable <GenericParameter> args, IEnumerable <GenericParameter> additionalArgsForNameCalculation)
{
formatter.WriteGenericArgumentsIfNeed(args, additionalArgsForNameCalculation);
formatter.WriteRaw("(");
formatter.CommaSeparatedList(DefinitelyTypedUtilities.BuildGenericParemetersMap(args, additionalArgsForNameCalculation), pair => {
formatter.Identifier("__" + pair.Value);
formatter.Space();
formatter.WriteRaw(":");
formatter.Space();
formatter.WriteRaw("$Type");
formatter.WriteGenericArgumentsIfNeed(new[] { DefinitelyTypedUtilities.GetGenericParameterInstanceParameterName(pair.Value), DefinitelyTypedUtilities.GetGenericParameterInParameterName(pair.Value), DefinitelyTypedUtilities.GetGenericParameterOutParameterName(pair.Value) });
});
formatter.WriteRaw(")");
}
public IAssemblyEmitter MakeAssemblyEmitter(
AssemblyTranslator translator,
AssemblyDefinition assembly,
JavascriptFormatter formatter,
IDictionary <AssemblyManifest.Token, string> referenceOverrides
)
{
if (translator.IsStubbed(assembly) || translator.IsIgnored(assembly))
{
return(new NullAssemblyEmitter());
}
else
{
return(new WasmSExprAssemblyEmitter(translator, assembly, formatter));
}
}
public static void CommaSeparatedList <T> (this JavascriptFormatter formatter, IEnumerable <T> list, Action <T> process)
{
bool first = true;
foreach (var item in list)
{
if (first)
{
first = false;
}
else
{
formatter.Comma();
}
process(item);
}
}
private static void TRSuffix(this JavascriptFormatter formatter, ReplaceMode replaceMode)
{
switch (replaceMode)
{
case ReplaceMode.In:
formatter.Dot();
formatter.Identifier("TIn");
break;
case ReplaceMode.Out:
formatter.Dot();
formatter.Identifier("TOut");
break;
case ReplaceMode.Instance:
formatter.Dot();
formatter.Identifier("Instance");
break;
default:
throw new ArgumentOutOfRangeException("replaceMode");
}
}
/// <summary>
/// Writes an interface member reference to the output.
/// </summary>
public void WriteInterfaceMemberToOutput(
JavascriptFormatter output, Compiler.Extensibility.IAstEmitter astEmitter, JSFunctionExpression enclosingFunction,
JSMethod jsMethod, JSExpression method,
TypeReferenceContext referenceContext
)
{
int index;
var record = new CachedInterfaceMemberRecord(jsMethod.Reference.DeclaringType, jsMethod.Identifier);
if ((enclosingFunction.Method != null) || (enclosingFunction.Method.Method != null))
{
var functionIdentifier = enclosingFunction.Method.Method.Identifier;
CacheSet localSignatureSet;
if (LocalCachedSets.TryGetValue(functionIdentifier, out localSignatureSet))
{
if (localSignatureSet.InterfaceMembers.TryGetValue(record, out index))
{
output.WriteRaw("$im{0:X2}", index);
return;
}
}
}
if (!Global.InterfaceMembers.TryGetValue(record, out index))
{
output.Identifier(jsMethod.Reference.DeclaringType, referenceContext, false);
output.Dot();
astEmitter.Emit(method);
}
else
{
output.WriteRaw("$IM{0:X2}()", index);
}
}
public DefinitelyTypedBaseEmitter(JavascriptFormatter formatter)
{
Formatter = formatter;
}
public DefinitelyTypedModuleEmitter(
AssemblyTranslator assemblyTranslator,
JavascriptFormatter formatter) : base(formatter)
{
Translator = assemblyTranslator;
}
public MapReduceMapFunctionBuilder()
{
_formatter = new JavascriptFormatter();
}
public WasmSExprAssemblyEmitter(AssemblyTranslator translator, AssemblyDefinition assembly, JavascriptFormatter formatter)
{
Translator = translator;
Assembly = assembly;
Formatter = formatter;
}
protected void TranslateModule(DecompilerContext context, JavascriptFormatter output, ModuleDefinition module, List<Action> initializer, HashSet<TypeDefinition> sealedTypes, bool stubbed)
{
var moduleInfo = TypeInfoProvider.GetModuleInformation(module);
if (moduleInfo.IsIgnored)
return;
context.CurrentModule = module;
var js = new JSSpecialIdentifiers(context.CurrentModule.TypeSystem);
var jsil = new JSILIdentifier(context.CurrentModule.TypeSystem, js);
// Probably should be an argument, not a member variable...
AstEmitter = new JavascriptAstEmitter(
output, jsil, context.CurrentModule.TypeSystem, this.TypeInfoProvider
);
foreach (var typedef in module.Types)
ForwardDeclareType(context, output, typedef);
foreach (var typedef in module.Types) {
TranslateTypeDefinition(context, output, typedef, initializer, stubbed);
SealType(context, output, typedef, sealedTypes);
}
}
protected void TranslateTypeStaticConstructor(DecompilerContext context, JavascriptFormatter output, TypeDefinition typedef, MethodDefinition cctor, bool stubbed)
{
var typeSystem = context.CurrentModule.TypeSystem;
var fieldsToEmit =
(from f in typedef.Fields
where f.IsStatic && NeedsStaticConstructor(f.FieldType)
select f).ToArray();
// We initialize all static fields in the cctor to avoid ordering issues
Action<JSFunctionExpression> fixupCctor = (f) => {
int insertPosition = 0;
foreach (var field in fieldsToEmit) {
var expr = TranslateField(field);
if (expr != null) {
var stmt = new JSExpressionStatement(expr);
f.Body.Statements.Insert(insertPosition++, stmt);
}
}
};
// Default values for instance fields of struct types are handled
// by the instance constructor.
// Default values for static fields of struct types are handled
// by the cctor.
// Everything else is emitted inline.
foreach (var f in typedef.Fields) {
if (f.IsStatic && NeedsStaticConstructor(f.FieldType))
continue;
if (EmulateStructAssignment.IsStruct(f.FieldType))
continue;
var expr = TranslateField(f);
if (expr != null)
AstEmitter.Visit(new JSExpressionStatement(expr));
}
if ((cctor != null) && !stubbed) {
TranslateMethod(context, output, cctor, cctor, false, null, null, fixupCctor);
} else if (fieldsToEmit.Length > 0) {
var fakeCctor = new MethodDefinition(".cctor", Mono.Cecil.MethodAttributes.Static, typeSystem.Void);
fakeCctor.DeclaringType = typedef;
var typeInfo = TypeInfoProvider.GetTypeInformation(typedef);
typeInfo.StaticConstructor = fakeCctor;
var identifier = MemberIdentifier.New(fakeCctor);
typeInfo.Members[identifier] = new Internal.MethodInfo(
typeInfo, identifier, fakeCctor, new ProxyInfo[0], false
);
// Generate the fake constructor, since it wasn't created during the analysis pass
TranslateMethodExpression(context, fakeCctor, fakeCctor);
TranslateMethod(context, output, fakeCctor, fakeCctor, false, null, null, fixupCctor);
}
}
public static void WriteGenericArgumentsIfNeed(this JavascriptFormatter formatter, IEnumerable <GenericParameter> args, IEnumerable <GenericParameter> additionalArgsForNameCalculation)
{
formatter.WriteGenericArgumentsIfNeed(
DefinitelyTypedUtilities.BuildGenericParemetersMap(args, additionalArgsForNameCalculation)
.SelectMany(pair => new[] { DefinitelyTypedUtilities.GetGenericParameterInstanceParameterName(pair.Value), DefinitelyTypedUtilities.GetGenericParameterInParameterName(pair.Value), DefinitelyTypedUtilities.GetGenericParameterOutParameterName(pair.Value) }));
}
protected void TranslateInterface(DecompilerContext context, JavascriptFormatter output, TypeDefinition iface)
{
output.Identifier("JSIL.MakeInterface", null);
output.LPar();
output.NewLine();
output.Value(Util.EscapeIdentifier(iface.FullName, EscapingMode.String));
output.Comma();
output.OpenBracket();
output.CommaSeparatedList(
(from p in iface.GenericParameters select p.Name), ListValueType.Primitive
);
output.CloseBracket();
output.Comma();
output.OpenBrace();
bool isFirst = true;
foreach (var m in iface.Methods) {
var methodInfo = TypeInfoProvider.GetMethod(m);
if ((methodInfo != null) && methodInfo.IsIgnored)
continue;
if (!isFirst) {
output.Comma();
output.NewLine();
}
output.Value(Util.EscapeIdentifier(m.Name));
output.Token(": ");
output.Identifier("Function");
isFirst = false;
}
foreach (var p in iface.Properties) {
var propertyInfo = TypeInfoProvider.GetProperty(p);
if ((propertyInfo != null) && propertyInfo.IsIgnored)
continue;
if (!isFirst) {
output.Comma();
output.NewLine();
}
output.Value(Util.EscapeIdentifier(p.Name));
output.Token(": ");
output.Identifier("Property");
isFirst = false;
}
output.NewLine();
output.CloseBrace(false);
output.RPar();
output.Semicolon();
output.NewLine();
}
protected void TranslateEnum(DecompilerContext context, JavascriptFormatter output, TypeDefinition enm)
{
output.Identifier("JSIL.MakeEnum", null);
output.LPar();
output.NewLine();
output.Value(Util.EscapeIdentifier(enm.FullName, EscapingMode.String));
output.Comma();
output.OpenBrace();
var typeInformation = TypeInfoProvider.GetTypeInformation(enm);
if (typeInformation == null)
throw new InvalidOperationException();
bool isFirst = true;
foreach (var em in typeInformation.EnumMembers.Values) {
if (!isFirst) {
output.Comma();
output.NewLine();
}
output.Identifier(em.Name);
output.Token(": ");
output.Value(em.Value);
isFirst = false;
}
output.NewLine();
output.CloseBrace(false);
output.Comma();
output.Value(typeInformation.IsFlagsEnum);
output.NewLine();
output.RPar();
output.Semicolon();
output.NewLine();
}
public static bool WriteTypeReference(this JavascriptFormatter formatter, TypeReference typeReference, TypeDefinition context, ReplaceMode replaceMode, bool useStandartSubstitution = true)
{
if (typeReference is ArrayType)
{
var arrayType = (ArrayType)typeReference;
formatter.WriteRaw("$asmJsilCore.System.");
formatter.Identifier(arrayType.IsVector ? "Vector" : "Array");
formatter.TRSuffix(replaceMode);
formatter.WriteRaw("<");
formatter.WriteTypeReference(arrayType.ElementType, context, ReplaceMode.Instance);
formatter.Comma();
formatter.WriteTypeReference(arrayType.ElementType, context, ReplaceMode.In);
formatter.Comma();
formatter.WriteTypeReference(arrayType.ElementType, context, ReplaceMode.Out);
if (!arrayType.IsVector)
{
formatter.Comma();
formatter.WriteRaw("\"");
formatter.Value(arrayType.Dimensions.Count.ToString(CultureInfo.InvariantCulture));
formatter.WriteRaw("\"");
}
formatter.WriteRaw(">");
}
else if (typeReference is ByReferenceType)
{
var byRefType = (ByReferenceType)typeReference;
formatter.WriteRaw("$asmJsilCore.JSIL.Reference");
formatter.TRSuffix(replaceMode);
formatter.WriteRaw("<");
formatter.WriteTypeReference(byRefType.ElementType, context, ReplaceMode.Instance);
formatter.Comma();
formatter.WriteTypeReference(byRefType.ElementType, context, ReplaceMode.In);
formatter.Comma();
formatter.WriteTypeReference(byRefType.ElementType, context, ReplaceMode.Out);
formatter.WriteRaw(">");
}
else if (typeReference is GenericParameter)
{
var gp = (GenericParameter)typeReference;
DefinitelyTypedUtilities.GenericParemetersKeyedCollection map;
if (gp.Owner is TypeDefinition)
{
map = DefinitelyTypedUtilities.BuildGenericParemetersMap(((TypeDefinition)gp.Owner).GenericParameters, null);
}
else if (gp.Owner is MethodDefinition)
{
map = DefinitelyTypedUtilities.BuildGenericParemetersMap(((MethodDefinition)gp.Owner).GenericParameters, ((MethodDefinition)gp.Owner).DeclaringType.GenericParameters);
}
else
{
throw new Exception("Unexpected generic parameter owner");
}
var name = map[gp].Value;
switch (replaceMode)
{
case ReplaceMode.Instance:
formatter.Identifier(DefinitelyTypedUtilities.GetGenericParameterInstanceParameterName(name));
break;
case ReplaceMode.Out:
formatter.Identifier(DefinitelyTypedUtilities.GetGenericParameterOutParameterName(name));
break;
case ReplaceMode.In:
formatter.Identifier(DefinitelyTypedUtilities.GetGenericParameterInParameterName(name));
break;
default:
throw new ArgumentOutOfRangeException("replaceMode", replaceMode, null);
}
}
else if (typeReference is GenericInstanceType)
{
var genericType = (GenericInstanceType)typeReference;
if (formatter.WriteTypeReference(genericType.ElementType, context, replaceMode)) /*TODO*/
{
formatter.WriteRaw("<");
formatter.CommaSeparatedList(genericType.GenericArguments, genericArgument => {
formatter.WriteTypeReference(genericArgument, context, ReplaceMode.Instance);
formatter.Comma();
formatter.WriteTypeReference(genericArgument, context, ReplaceMode.In);
formatter.Comma();
formatter.WriteTypeReference(genericArgument, context, ReplaceMode.Out);
});
formatter.WriteRaw(">");
}
}
else if (typeReference is PointerType || typeReference is OptionalModifierType || typeReference is RequiredModifierType || typeReference is PinnedType || typeReference is SentinelType || typeReference is FunctionPointerType ||
(!_coreTypes.Contains(typeReference.FullName) && formatter.TypeInfo.Get(typeReference).IsSuppressDeclaration))
{
formatter.WriteRaw("Object"); // TODO!
return(false);
}
else
{
string rawType;
if (useStandartSubstitution && _rawTypes.TryGetValue(typeReference.FullName, out rawType))
{
formatter.WriteRaw(rawType);
}
else
{
var definition = typeReference.Resolve();
var targetAssembly = JavascriptFormatter.GetContainingAssemblyName(typeReference);
string assemblyRef;
if (_coreTypes.Contains(definition.FullName))
{
assemblyRef = "$asmJsilCore";
}
else if (targetAssembly == formatter.Assembly.FullName)
{
assemblyRef = string.Empty;
}
else
{
assemblyRef = formatter.Manifest.Entries.FirstOrDefault(item => item.Value == targetAssembly).Key;
}
if (definition != null && assemblyRef != null)
{
if (assemblyRef != string.Empty)
{
formatter.Identifier(assemblyRef);
formatter.Dot();
}
else
{
formatter.Identifier("$private");
formatter.Dot();
}
foreach (var part in DefinitelyTypedUtilities.GetFullNamespace(definition))
{
formatter.Identifier(part);
formatter.Dot();
}
formatter.Identifier(DefinitelyTypedUtilities.GetClassName(definition));
/* Hack to solve ciruclar refrence in generics.
* It could be improved, by we really need generic variance support or support of:
* type T = something & I<T> (see Microsoft/TypeScript#6230)
*/
var fixedMode = (replaceMode != ReplaceMode.Instance && context == definition) ? ReplaceMode.Instance : replaceMode;
formatter.TRSuffix(fixedMode);
}
else
{
//TODO: We was unable to resolve assembly. Think about JSIL Proxies
formatter.WriteRaw("Object");
return(false);
}
}
}
return(true);
}
protected void SealType(DecompilerContext context, JavascriptFormatter output, TypeDefinition typedef, HashSet<TypeDefinition> sealedTypes)
{
var typeInfo = TypeInfoProvider.GetTypeInformation(typedef);
if ((typeInfo == null) || typeInfo.IsIgnored)
return;
context.CurrentType = typedef;
if (typedef.IsInterface)
return;
else if (typedef.IsEnum)
return;
foreach (var nestedTypedef in typedef.NestedTypes)
SealType(context, output, nestedTypedef, sealedTypes);
if (
(typeInfo.StaticConstructor != null) ||
(typedef.BaseType is GenericInstanceType)
) {
sealedTypes.Add(typedef);
}
}
protected void ForwardDeclareType(DecompilerContext context, JavascriptFormatter output, TypeDefinition typedef)
{
var typeInfo = TypeInfoProvider.GetTypeInformation(typedef);
if ((typeInfo == null) || typeInfo.IsIgnored || typeInfo.IsProxy)
return;
if (DeclaredTypes.Contains(typedef.FullName)) {
Debug.WriteLine("Cycle in type references detected: {0}", typedef);
return;
}
context.CurrentType = typedef;
output.DeclareNamespace(typedef.Namespace);
DeclaredTypes.Add(typedef.FullName);
if (typedef.IsInterface) {
TranslateInterface(context, output, typedef);
return;
} else if (typedef.IsEnum) {
TranslateEnum(context, output, typedef);
return;
} else if (typeInfo.IsDelegate) {
TranslateDelegate(context, output, typedef, typeInfo);
return;
}
var declaringType = typedef.DeclaringType;
if (declaringType != null) {
if (!DeclaredTypes.Contains(declaringType.FullName))
ForwardDeclareType(context, output, declaringType);
}
var baseClass = typedef.Module.TypeSystem.Object;
if (typedef.BaseType != null) {
baseClass = typedef.BaseType;
var resolved = baseClass.Resolve();
if (
(resolved != null) &&
!DeclaredTypes.Contains(resolved.FullName) &&
(resolved.Module.Assembly == typedef.Module.Assembly)
) {
ForwardDeclareType(context, output, resolved);
}
}
bool isStatic = typedef.IsAbstract && typedef.IsSealed;
if (isStatic) {
output.Identifier("JSIL.MakeStaticClass", null);
output.LPar();
output.Value(Util.EscapeIdentifier(typedef.FullName, EscapingMode.String));
output.Comma();
output.Value(typedef.IsPublic);
if (typedef.HasGenericParameters) {
output.Comma();
output.OpenBracket();
output.CommaSeparatedList(
(from p in typedef.GenericParameters select p.Name), ListValueType.Primitive
);
output.CloseBracket();
}
output.RPar();
output.Semicolon();
} else {
if (typedef.IsValueType)
output.Identifier("JSIL.MakeStruct", null);
else
output.Identifier("JSIL.MakeClass", null);
output.LPar();
if (!typedef.IsValueType) {
output.TypeReference(baseClass);
output.Comma();
}
output.Value(Util.EscapeIdentifier(typedef.FullName, EscapingMode.String));
output.Comma();
output.Value(typedef.IsPublic);
if (typedef.HasGenericParameters) {
output.Comma();
output.OpenBracket();
output.CommaSeparatedList(
(from p in typedef.GenericParameters select p.Name), ListValueType.Primitive
);
output.CloseBracket();
}
output.RPar();
output.Semicolon();
}
foreach (var nestedTypeDef in typedef.NestedTypes) {
if (!DeclaredTypes.Contains(nestedTypeDef.FullName))
ForwardDeclareType(context, output, nestedTypeDef);
}
output.NewLine();
}
protected void TranslateMethod(
DecompilerContext context, JavascriptFormatter output,
MethodReference methodRef, MethodDefinition method,
bool stubbed,
HashSet<string> externalMemberNames,
HashSet<string> staticExternalMemberNames,
Action<JSFunctionExpression> bodyTransformer = null
)
{
var methodInfo = TypeInfoProvider.GetMemberInformation<Internal.MethodInfo>(method);
if (methodInfo == null)
return;
bool isReplaced = methodInfo.Metadata.HasAttribute("JSIL.Meta.JSReplacement");
bool methodIsProxied = (methodInfo.IsFromProxy && methodInfo.Member.HasBody) &&
!methodInfo.IsExternal && !isReplaced;
if (methodInfo.IsExternal || (stubbed && !methodIsProxied)) {
if (isReplaced)
return;
if (externalMemberNames == null)
throw new ArgumentNullException("externalMemberNames");
if (staticExternalMemberNames == null)
throw new ArgumentNullException("staticExternalMemberNames");
var isProperty = methodInfo.DeclaringProperty != null;
if (!isProperty || !methodInfo.Member.IsCompilerGenerated()) {
(method.IsStatic ? staticExternalMemberNames : externalMemberNames)
.Add(Util.EscapeIdentifier(methodInfo.GetName(true)));
return;
}
}
if (methodInfo.IsIgnored)
return;
if (!method.HasBody)
return;
if (methodIsProxied) {
output.Comment("Implementation from {0}", methodInfo.Member.DeclaringType.FullName);
output.NewLine();
}
output.Identifier(method.DeclaringType);
if (!method.IsStatic) {
output.Dot();
output.Keyword("prototype");
}
output.Dot();
output.Identifier(methodInfo.GetName(true));
output.Token(" = ");
if (method.HasGenericParameters) {
output.Identifier("JSIL.GenericMethod", null);
output.LPar();
output.NewLine();
output.OpenBracket();
output.CommaSeparatedList((from p in method.GenericParameters select p.Name), ListValueType.Primitive);
output.CloseBracket();
output.Comma();
output.NewLine();
}
JSFunctionExpression function;
function = FunctionCache.GetExpression(new QualifiedMemberIdentifier(
methodInfo.DeclaringType.Identifier,
methodInfo.Identifier
));
if (bodyTransformer != null)
bodyTransformer(function);
if (function != null) {
AstEmitter.Visit(function);
} else {
output.Identifier("JSIL.UntranslatableFunction", null);
output.LPar();
output.Value(method.FullName);
output.RPar();
}
if (method.HasGenericParameters) {
output.NewLine();
output.RPar();
}
output.Semicolon();
}
public void WriteTo(JavascriptFormatter output)
{
if ((Arguments != null) && (Arguments.Length > 0))
output.WriteRaw(Format, Arguments);
else
output.WriteRaw(Format);
}
protected void TranslateMethodGroup(DecompilerContext context, JavascriptFormatter output, MethodGroupInfo methodGroup)
{
var methods = (from m in methodGroup.Methods where !m.IsIgnored select m).ToArray();
if (methods.Length < 1)
return;
foreach (var method in methods) {
foreach (var p in method.Member.Parameters) {
var resolved = p.ParameterType.Resolve();
if ((resolved != null) &&
!DeclaredTypes.Contains(resolved.FullName) &&
(resolved.Module.Assembly == methodGroup.DeclaringType.Definition.Module.Assembly)
) {
ForwardDeclareType(context, output, resolved);
}
}
}
output.Identifier(
(methods.First().IsGeneric) ? "JSIL.OverloadedGenericMethod" : "JSIL.OverloadedMethod", null
);
output.LPar();
output.Identifier(methodGroup.DeclaringType.Definition);
if (!methodGroup.IsStatic) {
output.Dot();
output.Keyword("prototype");
}
output.Comma();
output.Value(Util.EscapeIdentifier(methodGroup.Name));
output.Comma();
output.OpenBracket(true);
bool isFirst = true;
foreach (var method in methods) {
if (!isFirst) {
output.Comma();
output.NewLine();
}
output.OpenBracket();
output.Value(Util.EscapeIdentifier(method.GetName(true)));
output.Comma();
output.OpenBracket();
output.CommaSeparatedList(
from p in method.Member.Parameters select p.ParameterType, ListValueType.TypeIdentifier
);
output.CloseBracket();
output.CloseBracket();
isFirst = false;
}
output.CloseBracket(true, () => {
output.RPar();
output.Semicolon();
});
}
protected void Translate(DecompilerContext context, AssemblyDefinition assembly, Stream outputStream)
{
bool stubbed = IsStubbed(assembly);
var initializer = new List<Action>();
var tw = new StreamWriter(outputStream, Encoding.ASCII);
var formatter = new JavascriptFormatter(tw, this.TypeInfoProvider, assembly);
var version = Assembly.GetExecutingAssembly().GetName().Version;
formatter.Comment(
"Generated by JSIL v{0}.{1}.{2} build {3}. See http://jsil.org/ for more information.",
version.Major, version.Minor, version.Build, version.Revision
);
formatter.NewLine();
if (stubbed) {
formatter.Comment("Generating type stubs only");
formatter.NewLine();
}
formatter.DeclareAssembly();
var sealedTypes = new HashSet<TypeDefinition>();
// Important to clear this because types with the exact same full names can be defined in multiple assemblies
DeclaredTypes.Clear();
foreach (var module in assembly.Modules)
TranslateModule(context, formatter, module, initializer, sealedTypes, stubbed);
if (sealedTypes.Count > 0) {
var groups = (from st in sealedTypes
let parent = JavascriptFormatter.GetParent(st, null)
group st by parent);
initializer.Add(() => {
foreach (var g in groups) {
formatter.Identifier("JSIL.SealTypes", null);
formatter.LPar();
formatter.Identifier(formatter.PrivateToken);
formatter.Comma();
formatter.Value(g.Key);
formatter.Comma();
formatter.NewLine();
formatter.CommaSeparatedList(
(from typedef in g select typedef.Name), ListValueType.Primitive
);
formatter.NewLine();
formatter.RPar();
formatter.Semicolon();
}
});
}
foreach (var init in initializer) {
formatter.Identifier("JSIL.QueueInitializer", null);
formatter.LPar();
formatter.OpenFunction(null, null);
init();
formatter.CloseBrace(false);
formatter.RPar();
formatter.Semicolon();
}
tw.Flush();
}
public WasmSExprAssemblyEmitter(AssemblyTranslator translator, AssemblyDefinition assembly, JavascriptFormatter formatter)
{
Translator = translator;
Assembly = assembly;
Formatter = formatter;
}
protected void TranslateProperty(DecompilerContext context, JavascriptFormatter output, PropertyDefinition property)
{
var propertyInfo = TypeInfoProvider.GetMemberInformation<Internal.PropertyInfo>(property);
if ((propertyInfo == null) || propertyInfo.IsIgnored)
return;
var isStatic = (property.SetMethod ?? property.GetMethod).IsStatic;
if (property.DeclaringType.HasGenericParameters && isStatic)
output.Identifier("JSIL.MakeGenericProperty", null);
else
output.Identifier("JSIL.MakeProperty", null);
output.LPar();
output.Identifier(property.DeclaringType);
if (!isStatic) {
output.Dot();
output.Keyword("prototype");
}
output.Comma();
output.Value(Util.EscapeIdentifier(propertyInfo.Name));
output.Comma();
output.NewLine();
if (property.GetMethod != null) {
output.Identifier(property.DeclaringType);
if (!isStatic) {
output.Dot();
output.Keyword("prototype");
}
output.Dot();
output.Identifier(property.GetMethod, false);
} else {
output.Keyword("null");
}
output.Comma();
if (property.SetMethod != null) {
output.Identifier(property.DeclaringType);
if (!isStatic) {
output.Dot();
output.Keyword("prototype");
}
output.Dot();
output.Identifier(property.SetMethod, false);
} else {
output.Keyword("null");
}
output.RPar();
output.Semicolon();
}
protected void TranslateDelegate(DecompilerContext context, JavascriptFormatter output, TypeDefinition del, TypeInfo typeInfo)
{
output.Identifier("JSIL.MakeDelegate", null);
output.LPar();
output.Value(Util.EscapeIdentifier(del.FullName, EscapingMode.String));
output.RPar();
output.Semicolon();
output.NewLine();
}
public IAssemblyEmitter MakeAssemblyEmitter(AssemblyTranslator translator, AssemblyDefinition assembly, JavascriptFormatter formatter)
{
if (translator.IsStubbed(assembly) || translator.IsIgnored(assembly))
{
return(new NullAssemblyEmitter());
}
else
{
return(new WasmSExprAssemblyEmitter(translator, assembly, formatter));
}
}
protected void TranslateTypeDefinition(DecompilerContext context, JavascriptFormatter output, TypeDefinition typedef, List<Action> initializer, bool stubbed)
{
var typeInfo = TypeInfoProvider.GetTypeInformation(typedef);
if (!ShouldTranslateMethods(typedef))
return;
context.CurrentType = typedef;
var externalMemberNames = new HashSet<string>();
var staticExternalMemberNames = new HashSet<string>();
foreach (var method in typedef.Methods) {
// We translate the static constructor explicitly later, and inject field initialization
if (method.Name == ".cctor")
continue;
TranslateMethod(
context, output, method, method,
stubbed, externalMemberNames, staticExternalMemberNames
);
}
Action initializeOverloadsAndProperties = () => {
foreach (var methodGroup in typeInfo.MethodGroups)
TranslateMethodGroup(context, output, methodGroup);
foreach (var property in typedef.Properties)
TranslateProperty(context, output, property);
};
if (!stubbed)
initializeOverloadsAndProperties();
Func<TypeReference, bool> isInterfaceIgnored = (i) => {
var interfaceInfo = TypeInfoProvider.GetTypeInformation(i);
if (interfaceInfo != null)
return interfaceInfo.IsIgnored;
else
return true;
};
var interfaces = (from i in typeInfo.Interfaces
where !i.IsIgnored
select i).ToArray();
if (interfaces.Length > 0) {
initializer.Add(() => {
output.Identifier("JSIL.ImplementInterfaces", null);
output.LPar();
output.Identifier(typedef);
output.Comma();
output.OpenBracket(true);
output.CommaSeparatedList(interfaces, ListValueType.TypeReference);
output.CloseBracket(true, () => {
output.RPar();
output.Semicolon();
});
});
}
Func<FieldDefinition, bool> isFieldIgnored = (f) => {
IMemberInfo memberInfo;
if (typeInfo.Members.TryGetValue(MemberIdentifier.New(f), out memberInfo))
return memberInfo.IsIgnored;
else
return true;
};
var structFields =
(from field in typedef.Fields
where !isFieldIgnored(field) &&
!field.HasConstant &&
EmulateStructAssignment.IsStruct(field.FieldType) &&
!field.IsStatic
select field).ToArray();
if (structFields.Length > 0) {
initializer.Add(() => {
output.Identifier(typedef);
output.Dot();
output.Identifier("prototype");
output.Dot();
output.Identifier("__StructFields__");
output.Token(" = ");
output.OpenBracket(true);
bool isFirst = true;
foreach (var sf in structFields) {
if (!isFirst) {
output.Comma();
output.NewLine();
}
output.OpenBracket();
output.Value(sf.Name);
output.Comma();
output.Identifier(sf.FieldType);
output.CloseBracket();
isFirst = false;
}
output.CloseBracket(true, output.Semicolon);
});
}
TranslateTypeStaticConstructor(context, output, typedef, typeInfo.StaticConstructor, stubbed);
if (externalMemberNames.Count + staticExternalMemberNames.Count > 0) {
initializer.Add(() => {
if (externalMemberNames.Count > 0) {
output.Identifier("JSIL.ExternalMembers", null);
output.LPar();
output.Identifier(typedef);
output.Dot();
output.Keyword("prototype");
output.Comma();
output.NewLine();
output.CommaSeparatedList(externalMemberNames, ListValueType.Primitive);
output.NewLine();
output.RPar();
output.Semicolon();
}
if (staticExternalMemberNames.Count > 0) {
output.Identifier("JSIL.ExternalMembers", null);
output.LPar();
output.Identifier(typedef);
output.Comma();
output.NewLine();
output.CommaSeparatedList(staticExternalMemberNames, ListValueType.Primitive);
output.NewLine();
output.RPar();
output.Semicolon();
}
});
}
if (stubbed &&
(typeInfo.MethodGroups.Count + typedef.Properties.Count) > 0
) {
initializer.Add(initializeOverloadsAndProperties);
}
output.NewLine();
foreach (var nestedTypedef in typedef.NestedTypes)
TranslateTypeDefinition(context, output, nestedTypedef, initializer, stubbed);
}
