public void ClassWithSameNameAsVariable2()
{
var someAsm = Common.CreateMockAssembly();
var actual = Process(new JsStatement[] {
JsStatement.Function("f", new[] { "x" }, JsStatement.Block(
JsStatement.Var("y", JsExpression.Number(0)),
JsExpression.FunctionDefinition(new string[0],
JsExpression.Binary(ExpressionNodeType.Add, JsExpression.Member(new JsTypeReferenceExpression(Common.CreateMockTypeDefinition("x", someAsm)), "a"), JsExpression.Member(new JsTypeReferenceExpression(Common.CreateMockTypeDefinition("y", someAsm)), "a"))
),
JsExpression.FunctionDefinition(new string[0], JsStatement.Block(
JsStatement.Var("z", JsExpression.Binary(ExpressionNodeType.Add, JsExpression.Identifier("x"), JsExpression.Identifier("y")))
))
))
}, new[] { Common.CreateMockAssembly(), someAsm }, new MockMetadataImporter {
GetTypeSemantics = t => TypeScriptSemantics.NormalType(t.Name)
}, namer: new Namer());
AssertCorrect(actual,
@"(function() {
'use strict';
var $asm = {};
function f(x1) {
var y1 = 0;
(function() {
x.a + y.a;
});
(function() {
var z = x1 + y1;
});
}
})();
");
}
public override JsExpression VisitFunctionDefinitionExpression(JsFunctionDefinitionExpression expression, IDictionary <string, string> data)
{
IDictionary <string, string> newData;
if (!_renames.TryGetValue(expression, out newData))
{
newData = data;
}
bool renamed = false;
var paramNames = expression.ParameterNames.Select(n => { string s; if (newData.TryGetValue(n, out s))
{
renamed = true; return(s);
}
else
{
return(n);
} }).ToList();
if (renamed)
{
return(JsExpression.FunctionDefinition(paramNames, VisitStatement(expression.Body, newData), expression.Name));
}
else
{
return(base.VisitFunctionDefinitionExpression(expression, newData));
}
}
public void RenamedVariableClashWithImplicitGlobal()
{
var someAsm = Common.CreateMockAssembly();
var actual = Process(new JsStatement[] {
JsStatement.Function("f", new[] { "x" }, JsStatement.Block(
JsExpression.FunctionDefinition(new string[0],
JsExpression.Member(new JsTypeReferenceExpression(Common.CreateMockTypeDefinition("x", someAsm)), "a")
),
JsExpression.FunctionDefinition(new string[0], JsStatement.Block(
JsExpression.Add(JsExpression.Identifier("x"), JsExpression.Identifier("x1"))
))
))
}, new[] { Common.CreateMockAssembly(), someAsm }, new MockMetadataImporter {
GetTypeSemantics = t => TypeScriptSemantics.NormalType(t.Name)
}, namer: new Namer());
AssertCorrect(actual,
@"(function() {
'use strict';
var $asm = {};
function f(x2) {
(function() {
x.a;
});
(function() {
x2 + x1;
});
}
})();
");
}
public void FunctionIsParenthesizedWhenInvokedDirectly()
{
AssertCorrect(JsExpression.Invocation(
JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement, null)
),
"(function() {\r\n})()");
}
public JsFunctionDefinitionExpression CompileAutoPropertySetter(IProperty property, PropertyScriptSemantics impl, string backingFieldName)
{
try {
string valueName = _namer.GetVariableName(property.Setter.Parameters[0].Name, new HashSet <string>(property.DeclaringTypeDefinition.TypeParameters.Select(p => _namer.GetTypeParameterName(p))));
CreateCompilationContext(null, null, property.DeclaringTypeDefinition, null);
if (property.IsStatic)
{
var jsType = _runtimeLibrary.InstantiateType(Utils.SelfParameterize(property.DeclaringTypeDefinition), _statementCompiler);
return(JsExpression.FunctionDefinition(new[] { valueName }, JsExpression.Assign(JsExpression.Member(jsType, backingFieldName), JsExpression.Identifier(valueName))));
}
else if (impl.SetMethod.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument)
{
return(JsExpression.FunctionDefinition(new[] { _namer.ThisAlias, valueName }, JsExpression.Assign(JsExpression.Member(JsExpression.Identifier(_namer.ThisAlias), backingFieldName), JsExpression.Identifier(valueName))));
}
else
{
return(JsExpression.FunctionDefinition(new[] { valueName }, JsExpression.Assign(JsExpression.Member(JsExpression.This, backingFieldName), JsExpression.Identifier(valueName))));
}
}
catch (Exception ex) {
_errorReporter.Region = property.Setter.Region;
_errorReporter.InternalError(ex);
return(JsExpression.FunctionDefinition(new string[0], JsStatement.EmptyBlock));
}
}
public JsFunctionDefinitionExpression CompileAutoEventRemover(IEvent @event, EventScriptSemantics impl, string backingFieldName)
{
try {
string valueName = _namer.GetVariableName(@event.RemoveAccessor.Parameters[0].Name, new HashSet <string>(@event.DeclaringTypeDefinition.TypeParameters.Select(p => _namer.GetTypeParameterName(p))));
CreateCompilationContext(null, null, @event.DeclaringTypeDefinition, null);
JsExpression target;
string[] args;
if (@event.IsStatic)
{
target = _runtimeLibrary.InstantiateType(Utils.SelfParameterize(@event.DeclaringTypeDefinition), _statementCompiler);
args = new[] { valueName };
}
else if (impl.RemoveMethod.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument)
{
target = JsExpression.Identifier(_namer.ThisAlias);
args = new[] { _namer.ThisAlias, valueName };
}
else
{
target = JsExpression.This;
args = new[] { valueName };
}
var bfAccessor = JsExpression.Member(target, backingFieldName);
var combineCall = _statementCompiler.CompileDelegateRemoveCall(@event.RemoveAccessor.Region, bfAccessor, JsExpression.Identifier(valueName));
return(JsExpression.FunctionDefinition(args, JsStatement.Block(JsExpression.Assign(bfAccessor, combineCall))));
}
catch (Exception ex) {
_errorReporter.Region = @event.Region;
_errorReporter.InternalError(ex);
return(JsExpression.FunctionDefinition(new string[0], JsStatement.EmptyBlock));
}
}
private JsExpression GenerateStructCloneMethod(ITypeDefinition type, string typevarName, bool hasCreateInstance)
{
var stmts = new List <JsStatement>()
{
JsStatement.Var("r", hasCreateInstance ? (JsExpression)JsExpression.Invocation(JsExpression.Member(JsExpression.Identifier(typevarName), "createInstance")) : JsExpression.New(JsExpression.Identifier(typevarName)))
};
var o = JsExpression.Identifier("o");
var r = JsExpression.Identifier("r");
foreach (var f in type.Fields.Where(f => !f.IsStatic))
{
var sem = _metadataImporter.GetFieldSemantics(f);
if (sem.Type == FieldScriptSemantics.ImplType.Field)
{
var def = f.ReturnType.GetDefinition();
JsExpression value = JsExpression.Member(o, sem.Name);
if (def != null && def.Kind == TypeKind.Struct && _metadataImporter.GetTypeSemantics(def).Type == TypeScriptSemantics.ImplType.MutableValueType)
{
value = _runtimeLibrary.CloneValueType(value, f.ReturnType, new DefaultRuntimeContext(type, _metadataImporter, _errorReporter, _namer));
}
stmts.Add(JsExpression.Assign(JsExpression.Member(r, sem.Name), value));
}
}
foreach (var p in type.Properties.Where(p => !p.IsStatic))
{
var sem = _metadataImporter.GetPropertySemantics(p);
if ((sem.Type == PropertyScriptSemantics.ImplType.GetAndSetMethods && MetadataUtils.IsAutoProperty(p) == true) || sem.Type == PropertyScriptSemantics.ImplType.Field)
{
var def = p.ReturnType.GetDefinition();
var fieldName = sem.Type == PropertyScriptSemantics.ImplType.GetAndSetMethods ? _metadataImporter.GetAutoPropertyBackingFieldName(p) : sem.FieldName;
JsExpression value = JsExpression.Member(o, fieldName);
if (def != null && def.Kind == TypeKind.Struct && _metadataImporter.GetTypeSemantics(def).Type == TypeScriptSemantics.ImplType.MutableValueType)
{
value = _runtimeLibrary.CloneValueType(value, p.ReturnType, new DefaultRuntimeContext(type, _metadataImporter, _errorReporter, _namer));
}
stmts.Add(JsExpression.Assign(JsExpression.Member(r, fieldName), value));
}
}
foreach (var e in type.Events.Where(e => !e.IsStatic && MetadataUtils.IsAutoEvent(e) == true))
{
var sem = _metadataImporter.GetEventSemantics(e);
if (sem.Type == EventScriptSemantics.ImplType.AddAndRemoveMethods)
{
var def = e.ReturnType.GetDefinition();
var fieldName = _metadataImporter.GetAutoEventBackingFieldName(e);
JsExpression value = JsExpression.Member(o, fieldName);
if (def != null && def.Kind == TypeKind.Struct && _metadataImporter.GetTypeSemantics(def).Type == TypeScriptSemantics.ImplType.MutableValueType)
{
value = _runtimeLibrary.CloneValueType(value, e.ReturnType, new DefaultRuntimeContext(type, _metadataImporter, _errorReporter, _namer));
}
stmts.Add(JsExpression.Assign(JsExpression.Member(r, fieldName), value));
}
}
stmts.Add(JsStatement.Return(r));
return(JsExpression.FunctionDefinition(new[] { "o" }, JsStatement.Block(stmts)));
}
private JsExpression GenerateStructEqualsMethod(ITypeDefinition type, string typeVariableName)
{
var o = JsExpression.Identifier("o");
var parts = new List <JsExpression>();
foreach (var f in type.Fields.Where(f => !f.IsStatic))
{
var expr = GenerateFieldCompare(f, o);
if (expr != null)
{
parts.Add(expr);
}
}
JsExpression typeCompare = JsExpression.Invocation(JsExpression.Member(_systemScript, "isInstanceOfType"), o, JsExpression.Identifier(typeVariableName));
if (parts.Count == 0)
{
return(JsExpression.FunctionDefinition(new[] { "o" }, JsStatement.Return(typeCompare)));
}
else
{
return(JsExpression.FunctionDefinition(new[] { "o" }, JsStatement.Block(
JsStatement.If(JsExpression.LogicalNot(typeCompare),
JsStatement.Return(JsExpression.False),
null
),
JsStatement.Return(parts.Aggregate((old, p) => old == null ? p : JsExpression.LogicalAnd(old, p)))
)));
}
}
public void ProgramWithEntryPointWorks()
{
var type = CreateMockTypeDefinition("MyClass");
var main = new Mock <IMethod>(MockBehavior.Strict);
main.SetupGet(_ => _.DeclaringTypeDefinition).Returns(type);
main.SetupGet(_ => _.Name).Returns("Main");
main.SetupGet(_ => _.Parameters).Returns(EmptyList <IParameter> .Instance);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// MyClass
var $MyClass = function() {
};
$MyClass.$main = function() {
X;
};
{Type}.registerClass(global, 'MyClass', $MyClass);
{MyClass}.$Main();
", new MockScriptSharpMetadataImporter()
{
GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name)
},
main.Object,
new JsClass(type, JsClass.ClassTypeEnum.Class, null, null, null)
{
StaticMethods = { new JsMethod(main.Object, "$main", new string[0], JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Identifier("X")))) }
});
}
private JsBlockStatement ProcessAsyncMethod(JsBlockStatement statement, string stateMachineMethodName, string doFinallyBlocksVariableName, JsVariableDeclaration taskCompletionSource, Func <JsExpression, JsExpression> makeSetResult, Func <JsExpression, JsExpression> makeSetException, Func <JsExpression> getTask, Func <JsExpression, JsExpression, JsExpression> bindToContext)
{
_stateMachineMethodName = stateMachineMethodName;
_doFinallyBlocksVariableName = doFinallyBlocksVariableName;
_makeSetResult = taskCompletionSource != null ? makeSetResult : null;
_needDoFinallyBlocksVariable = new HasAwaitInsideTryWithFinallyVisitor().Analyze(statement);
var result = Process(statement, isIteratorBlock: false, isAsync: true);
var hoistResult = VariableHoistingVisitor.Process(result);
string catchVariable = _allocateTempVariable();
JsStatement body;
if (taskCompletionSource != null && (statement.Statements.Count == 0 || IsNextStatementReachable(statement.Statements[statement.Statements.Count - 1]))) // If we return the task, and if we risk falling out of the original method, we need to add a setResult call.
{
body = JsStatement.Block(hoistResult.Item1.Statements.Concat(new JsStatement[] { makeSetResult(null) }));
}
else
{
body = hoistResult.Item1;
}
if (taskCompletionSource != null)
{
body = JsStatement.Try(body, JsStatement.Catch(catchVariable, JsStatement.Block(makeSetException(JsExpression.Identifier(catchVariable)))), null);
}
IEnumerable <JsVariableDeclaration> declarations = new[] { JsStatement.Declaration(_stateVariableName, JsExpression.Number(0)) };
if (taskCompletionSource != null)
{
declarations = declarations.Concat(new[] { taskCompletionSource });
}
declarations = declarations.Concat(hoistResult.Item2.Select(v => JsStatement.Declaration(v, null)));
if (_needDoFinallyBlocksVariable)
{
body = JsStatement.Block(new[] { JsStatement.Var(_doFinallyBlocksVariableName, JsExpression.True) }.Concat(body is JsBlockStatement ? ((JsBlockStatement)body).Statements : (IEnumerable <JsStatement>) new[] { body }));
}
var stateMachine = JsExpression.FunctionDefinition(new string[0], body);
var boundStateMachine = UsesThisVisitor.Analyze(stateMachine.Body) ? bindToContext(stateMachine, JsExpression.This) : stateMachine;
IEnumerable <JsStatement> stmts = new JsStatement[] { JsStatement.Var(declarations),
JsStatement.Var(stateMachineMethodName, boundStateMachine),
JsExpression.Invocation(JsExpression.Identifier(stateMachineMethodName)) };
if (taskCompletionSource != null)
{
stmts = stmts.Concat(new[] { JsStatement.Return(getTask()) });
}
return(JsStatement.Block(stmts));
}
private JsType ConvertType(JsClass type)
{
if (type.InstanceMethods.Any(m => m.Name == "runTests"))
{
_errorReporter.Region = type.CSharpTypeDefinition.Region;
_errorReporter.Message(MessageSeverity.Error, 7019, string.Format("The type {0} cannot define a method named 'runTests' because it has a [TestFixtureAttribute].", type.CSharpTypeDefinition.FullName));
return(type);
}
var instanceMethods = new List <JsMethod>();
var tests = new List <Tuple <string, string, bool, int?, JsFunctionDefinitionExpression> >();
foreach (var method in type.InstanceMethods)
{
var testAttr = _attributeStore.AttributesFor(method.CSharpMember).GetAttribute <TestAttribute>();
if (testAttr != null)
{
if (!method.CSharpMember.IsPublic || !method.CSharpMember.ReturnType.IsKnownType(KnownTypeCode.Void) || ((IMethod)method.CSharpMember).Parameters.Count > 0 || ((IMethod)method.CSharpMember).TypeParameters.Count > 0)
{
_errorReporter.Region = method.CSharpMember.Region;
_errorReporter.Message(MessageSeverity.Error, 7020, string.Format("Method {0}: Methods decorated with a [TestAttribute] must be public, non-generic, parameterless instance methods that return void.", method.CSharpMember.FullName));
}
tests.Add(Tuple.Create(testAttr.Description ?? method.CSharpMember.Name, testAttr.Category, testAttr.IsAsync, testAttr.ExpectedAssertionCount >= 0 ? (int?)testAttr.ExpectedAssertionCount : null, method.Definition));
}
else
{
instanceMethods.Add(method);
}
}
var testInvocations = new List <JsExpression>();
foreach (var category in tests.GroupBy(t => t.Item2).Select(g => new { Category = g.Key, Tests = g.Select(x => new { Description = x.Item1, IsAsync = x.Item3, ExpectedAssertionCount = x.Item4, Function = x.Item5 }) }).OrderBy(x => x.Category))
{
if (category.Category != null)
{
testInvocations.Add(JsExpression.Invocation(JsExpression.Member(JsExpression.Identifier("QUnit"), "module"), JsExpression.String(category.Category)));
}
testInvocations.AddRange(category.Tests.Select(t => JsExpression.Invocation(JsExpression.Identifier(t.IsAsync ? "asyncTest" : "test"), t.ExpectedAssertionCount != null ? new JsExpression[] { JsExpression.String(t.Description), JsExpression.Number(t.ExpectedAssertionCount.Value), _runtimeLibrary.Bind(t.Function, JsExpression.This, this) } : new JsExpression[] { JsExpression.String(t.Description), _runtimeLibrary.Bind(t.Function, JsExpression.This, this) })));
}
instanceMethods.Add(new JsMethod(null, "runTests", null, JsExpression.FunctionDefinition(new string[0], JsStatement.Block(testInvocations.Select(t => (JsStatement)t)))));
var result = type.Clone();
result.InstanceMethods.Clear();
foreach (var m in instanceMethods)
{
result.InstanceMethods.Add(m);
}
return(result);
}
public static IList <JsStatement> Process(IMetadataImporter metadataImporter, INamer namer, ICompilation compilation, IList <JsStatement> statements)
{
var usedSymbols = UsedSymbolsGatherer.Analyze(statements);
var importer = new ImportVisitor(metadataImporter, namer, compilation.MainAssembly, usedSymbols);
var body = statements.Select(s => importer.VisitStatement(s, null)).ToList();
var moduleDependencies = importer._moduleAliases.Concat(MetadataUtils.GetAdditionalDependencies(compilation.MainAssembly));
if (MetadataUtils.IsAsyncModule(compilation.MainAssembly))
{
body.InsertRange(0, new[] { JsStatement.UseStrict, JsStatement.Var("exports", JsExpression.ObjectLiteral()) });
body.Add(JsStatement.Return(JsExpression.Identifier("exports")));
var pairs = new[] { new KeyValuePair <string, string>("mscorlib", namer.GetVariableName("_", usedSymbols)) }
.Concat(moduleDependencies.OrderBy(x => x.Key))
.ToList();
body = new List <JsStatement> {
JsExpression.Invocation(
JsExpression.Identifier("define"),
JsExpression.ArrayLiteral(pairs.Select(p => JsExpression.String(p.Key))),
JsExpression.FunctionDefinition(
pairs.Select(p => p.Value),
JsStatement.Block(body)
)
)
};
}
else if (moduleDependencies.Any())
{
// If we require any module, we require mscorlib. This should work even if we are a leaf module that doesn't include any other module because our parent script will do the mscorlib require for us.
body.InsertRange(0, new[] { JsStatement.UseStrict, JsExpression.Invocation(JsExpression.Identifier("require"), JsExpression.String("mscorlib")) }
.Concat(moduleDependencies
.OrderBy(x => x.Key).OrderBy(x => x.Key)
.Select(x => JsStatement.Var(
x.Value,
JsExpression.Invocation(
JsExpression.Identifier("require"),
JsExpression.String(x.Key))))
.ToList()));
}
else
{
body.Insert(0, JsStatement.UseStrict);
body = new List <JsStatement> {
JsExpression.Invocation(JsExpression.FunctionDefinition(new string[0], JsStatement.Block(body)))
};
}
return(body);
}
public static JsExpression ConstructAttribute(IAttribute attr, ITypeDefinition currentType, ICompilation compilation, IMetadataImporter metadataImporter, INamer namer, IRuntimeLibrary runtimeLibrary, IErrorReporter errorReporter)
{
errorReporter.Region = attr.Region;
var initializerStatements = attr.NamedArguments.Select(a => new OperatorResolveResult(a.Key.ReturnType, ExpressionType.Assign, new MemberResolveResult(new InitializedObjectResolveResult(attr.AttributeType), a.Key), a.Value)).ToList <ResolveResult>();
var constructorResult = CompileConstructorInvocation(attr.Constructor, initializerStatements, currentType, null, attr.PositionalArguments, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, null, null);
if (constructorResult.AdditionalStatements.Count > 0)
{
return(JsExpression.Invocation(JsExpression.FunctionDefinition(new string[0], JsStatement.Block(constructorResult.AdditionalStatements.Concat(new[] { JsStatement.Return(constructorResult.Expression) })))));
}
else
{
return(constructorResult.Expression);
}
}
public JsExpression GetExpressionForLocal(string name, JsExpression accessor, IType type, IRuntimeContext context)
{
var scriptType = TypeOf(type, context);
JsExpression getterDefinition = JsExpression.FunctionDefinition(new string[0], JsStatement.Return(accessor));
JsExpression setterDefinition = JsExpression.FunctionDefinition(new[] { "$" }, JsExpression.Assign(accessor, JsExpression.Identifier("$")));
if (UsesThisVisitor.Analyze(accessor))
{
getterDefinition = JsExpression.Invocation(JsExpression.Member(getterDefinition, "bind"), JsExpression.This);
setterDefinition = JsExpression.Invocation(JsExpression.Member(setterDefinition, "bind"), JsExpression.This);
}
return(JsExpression.ObjectLiteral(
new JsObjectLiteralProperty("ntype", JsExpression.Number((int)ExpressionType.MemberAccess)),
new JsObjectLiteralProperty("type", scriptType),
new JsObjectLiteralProperty("expression", JsExpression.ObjectLiteral(
new JsObjectLiteralProperty("ntype", JsExpression.Number((int)ExpressionType.Constant)),
new JsObjectLiteralProperty("type", scriptType),
new JsObjectLiteralProperty("value", JsExpression.ObjectLiteral())
)),
new JsObjectLiteralProperty("member", JsExpression.ObjectLiteral(
new JsObjectLiteralProperty("typeDef", new JsTypeReferenceExpression(_compilation.FindType(KnownTypeCode.Object).GetDefinition())),
new JsObjectLiteralProperty("name", JsExpression.String(name)),
new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Property)),
new JsObjectLiteralProperty("returnType", scriptType),
new JsObjectLiteralProperty("getter", JsExpression.ObjectLiteral(
new JsObjectLiteralProperty("typeDef", new JsTypeReferenceExpression(_compilation.FindType(KnownTypeCode.Object).GetDefinition())),
new JsObjectLiteralProperty("name", JsExpression.String("get_" + name)),
new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Method)),
new JsObjectLiteralProperty("returnType", scriptType),
new JsObjectLiteralProperty("params", JsExpression.ArrayLiteral()),
new JsObjectLiteralProperty("def", getterDefinition)
)),
new JsObjectLiteralProperty("setter", JsExpression.ObjectLiteral(
new JsObjectLiteralProperty("typeDef", new JsTypeReferenceExpression(_compilation.FindType(KnownTypeCode.Object).GetDefinition())),
new JsObjectLiteralProperty("name", JsExpression.String("set_" + name)),
new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Method)),
new JsObjectLiteralProperty("returnType", new JsTypeReferenceExpression(_compilation.FindType(KnownTypeCode.Void).GetDefinition())),
new JsObjectLiteralProperty("params", JsExpression.ArrayLiteral(scriptType)),
new JsObjectLiteralProperty("def", setterDefinition)
))
))
));
}
public static IList <JsStatement> Process(IScriptSharpMetadataImporter metadataImporter, INamer namer, IAssembly mainAssembly, IList <JsStatement> statements)
{
var usedSymbols = UsedSymbolsGatherer.Analyze(statements);
var importer = new ImportVisitor(metadataImporter, namer, mainAssembly, usedSymbols);
var body = statements.Select(s => importer.VisitStatement(s, null)).ToList();
if (metadataImporter.IsAsyncModule)
{
body.Insert(0, new JsVariableDeclarationStatement("exports", JsExpression.ObjectLiteral()));
body.Add(new JsReturnStatement(JsExpression.Identifier("exports")));
var pairs = new[] { new KeyValuePair <string, string>("mscorlib", namer.GetVariableName("_", usedSymbols)) }.Concat(importer._moduleAliases.OrderBy(x => x.Key)).ToList();
body = new List <JsStatement> {
new JsExpressionStatement(
JsExpression.Invocation(
JsExpression.Identifier("define"),
JsExpression.ArrayLiteral(pairs.Select(p => JsExpression.String(p.Key))),
JsExpression.FunctionDefinition(
pairs.Select(p => p.Value),
new JsBlockStatement(body)
)
)
)
};
}
else if (importer._moduleAliases.Count > 0)
{
// If we require any module, we require mscorlib. This should work even if we are a leaf module that doesn't include any other module because our parent script will do the mscorlib require for us.
body.InsertRange(0, new[] { (JsStatement) new JsExpressionStatement(JsExpression.Invocation(JsExpression.Identifier("require"), JsExpression.String("mscorlib"))) }
.Concat(importer._moduleAliases.OrderBy(x => x.Key)
.Select(x => new JsVariableDeclarationStatement(
x.Value,
JsExpression.Invocation(
JsExpression.Identifier("require"),
JsExpression.String(x.Key))))
.ToList()));
}
return(body);
}
private JsFunctionDefinitionExpression GenerateStructGetHashCodeMethod(ITypeDefinition type)
{
JsExpression h = JsExpression.Identifier("h");
var stmts = new List <JsStatement>();
foreach (var f in type.Fields.Where(f => !f.IsStatic))
{
var expr = GetFieldHashCode(f);
if (expr != null)
{
if (stmts.Count == 0)
{
stmts.Add(JsStatement.Var("h", expr));
}
else
{
stmts.Add(JsExpression.Assign(h, JsExpression.BitwiseXor(JsExpression.Multiply(h, JsExpression.Number(397)), expr)));
}
}
}
switch (stmts.Count)
{
case 0:
stmts.Add(JsStatement.Return(JsExpression.Number(0)));
break;
case 1:
stmts[0] = JsStatement.Return(JsExpression.BitwiseOr(((JsVariableDeclarationStatement)stmts[0]).Declarations[0].Initializer, JsExpression.Number(0)));
break;
default:
stmts.Add(JsStatement.Return(h));
break;
}
return(JsExpression.FunctionDefinition(EmptyList <string> .Instance, JsStatement.Block(stmts)));
}
public JsFunctionDefinitionExpression CompileAutoPropertyGetter(IProperty property, PropertyScriptSemantics impl, string backingFieldName)
{
try {
CreateCompilationContext(null, null, property.DeclaringTypeDefinition, null);
if (property.IsStatic)
{
var jsType = _runtimeLibrary.InstantiateType(Utils.SelfParameterize(property.DeclaringTypeDefinition), _statementCompiler);
return(JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.Member(jsType, backingFieldName))));
}
else if (impl.GetMethod.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument)
{
return(JsExpression.FunctionDefinition(new[] { _namer.ThisAlias }, new JsReturnStatement(JsExpression.Member(JsExpression.Identifier(_namer.ThisAlias), backingFieldName))));
}
else
{
return(JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.Member(JsExpression.This, backingFieldName))));
}
}
catch (Exception ex) {
_errorReporter.Region = property.Getter.Region;
_errorReporter.InternalError(ex);
return(JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement));
}
}
private JsExpression RewriteMethod(JsMethod method)
{
return(method.TypeParameterNames.Count == 0 ? method.Definition : JsExpression.FunctionDefinition(method.TypeParameterNames, new JsReturnStatement(method.Definition)));
}
private static JsExpression ConstructMemberInfo(IMember m, ICompilation compilation, IMetadataImporter metadataImporter, INamer namer, IRuntimeLibrary runtimeLibrary, IErrorReporter errorReporter, Func <IType, JsExpression> instantiateType, bool includeDeclaringType, MethodScriptSemantics semanticsIfAccessor)
{
if (m is IMethod && ((IMethod)m).IsConstructor)
{
return(ConstructConstructorInfo((IMethod)m, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType));
}
var properties = GetCommonMemberInfoProperties(m, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType);
if (m.IsStatic)
{
properties.Add(new JsObjectLiteralProperty("isStatic", JsExpression.True));
}
if (m is IMethod)
{
var method = (IMethod)m;
var sem = semanticsIfAccessor ?? metadataImporter.GetMethodSemantics(method);
if (sem.Type != MethodScriptSemantics.ImplType.NormalMethod && sem.Type != MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument && sem.Type != MethodScriptSemantics.ImplType.InlineCode)
{
errorReporter.Message(Messages._7201, m.FullName, "method");
return(JsExpression.Null);
}
if ((sem.Type == MethodScriptSemantics.ImplType.NormalMethod || sem.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument) && sem.ExpandParams)
{
properties.Add(new JsObjectLiteralProperty("exp", JsExpression.True));
}
properties.Add(new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Method)));
if (sem.Type == MethodScriptSemantics.ImplType.InlineCode)
{
var usedNames = new HashSet <string>();
var parameters = new List <IVariable>();
var variables = new Dictionary <IVariable, VariableData>();
var arguments = new List <ResolveResult>();
foreach (var p in method.Parameters)
{
string name = namer.GetVariableName(p.Name, usedNames);
usedNames.Add(name);
var variable = new SimpleVariable(p.Type, p.Name, DomRegion.Empty);
parameters.Add(variable);
variables.Add(variable, new VariableData(name, null, false));
arguments.Add(new LocalResolveResult(variable));
}
var tokens = InlineCodeMethodCompiler.Tokenize(method, sem.LiteralCode, _ => {});
var compileResult = Compile(CreateMethodInvocationResolveResult(method, method.IsStatic ? (ResolveResult) new TypeResolveResult(method.DeclaringType) : new ThisResolveResult(method.DeclaringType), arguments), method.DeclaringTypeDefinition, method, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, true, variables, usedNames);
var definition = JsExpression.FunctionDefinition(parameters.Select(p => variables[p].Name), JsStatement.Block(compileResult.AdditionalStatements.Concat(new[] { JsStatement.Return(compileResult.Expression) })));
if (tokens.Any(t => t.Type == InlineCodeToken.TokenType.TypeParameter && t.OwnerType == SymbolKind.Method))
{
definition = JsExpression.FunctionDefinition(method.TypeParameters.Select(namer.GetTypeParameterName), JsStatement.Return(definition));
properties.Add(new JsObjectLiteralProperty("tpcount", JsExpression.Number(method.TypeParameters.Count)));
}
properties.Add(new JsObjectLiteralProperty("def", definition));
}
else
{
if (IsJsGeneric(method, metadataImporter))
{
properties.Add(new JsObjectLiteralProperty("tpcount", JsExpression.Number(method.TypeParameters.Count)));
}
if (sem.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument)
{
properties.Add(new JsObjectLiteralProperty("sm", JsExpression.True));
}
properties.Add(new JsObjectLiteralProperty("sname", JsExpression.String(sem.Name)));
}
properties.Add(new JsObjectLiteralProperty("returnType", instantiateType(method.ReturnType)));
properties.Add(new JsObjectLiteralProperty("params", JsExpression.ArrayLiteral(method.Parameters.Select(p => instantiateType(p.Type)))));
}
else if (m is IField)
{
var field = (IField)m;
var sem = metadataImporter.GetFieldSemantics(field);
if (sem.Type != FieldScriptSemantics.ImplType.Field)
{
errorReporter.Message(Messages._7201, m.FullName, "field");
return(JsExpression.Null);
}
properties.Add(new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Field)));
properties.Add(new JsObjectLiteralProperty("returnType", instantiateType(field.ReturnType)));
properties.Add(new JsObjectLiteralProperty("sname", JsExpression.String(sem.Name)));
}
else if (m is IProperty)
{
var prop = (IProperty)m;
var sem = metadataImporter.GetPropertySemantics(prop);
properties.Add(new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Property)));
properties.Add(new JsObjectLiteralProperty("returnType", instantiateType(prop.ReturnType)));
if (prop.Parameters.Count > 0)
{
properties.Add(new JsObjectLiteralProperty("params", JsExpression.ArrayLiteral(prop.Parameters.Select(p => instantiateType(p.Type)))));
}
switch (sem.Type)
{
case PropertyScriptSemantics.ImplType.GetAndSetMethods:
if (sem.GetMethod != null && sem.GetMethod.Type != MethodScriptSemantics.ImplType.NormalMethod && sem.GetMethod.Type != MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument && sem.GetMethod.Type != MethodScriptSemantics.ImplType.InlineCode)
{
errorReporter.Message(Messages._7202, m.FullName, "property", "getter");
return(JsExpression.Null);
}
if (sem.SetMethod != null && sem.SetMethod.Type != MethodScriptSemantics.ImplType.NormalMethod && sem.SetMethod.Type != MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument && sem.SetMethod.Type != MethodScriptSemantics.ImplType.InlineCode)
{
errorReporter.Message(Messages._7202, m.FullName, "property", "setter");
return(JsExpression.Null);
}
if (sem.GetMethod != null)
{
properties.Add(new JsObjectLiteralProperty("getter", ConstructMemberInfo(prop.Getter, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType, sem.GetMethod)));
}
if (sem.SetMethod != null)
{
properties.Add(new JsObjectLiteralProperty("setter", ConstructMemberInfo(prop.Setter, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType, sem.SetMethod)));
}
break;
case PropertyScriptSemantics.ImplType.Field:
if (prop.CanGet)
{
properties.Add(new JsObjectLiteralProperty("getter", ConstructFieldPropertyAccessor(prop.Getter, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, sem.FieldName, instantiateType, isGetter: true, includeDeclaringType: includeDeclaringType)));
}
if (prop.CanSet)
{
properties.Add(new JsObjectLiteralProperty("setter", ConstructFieldPropertyAccessor(prop.Setter, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, sem.FieldName, instantiateType, isGetter: false, includeDeclaringType: includeDeclaringType)));
}
properties.Add(new JsObjectLiteralProperty("fname", JsExpression.String(sem.FieldName)));
break;
default:
errorReporter.Message(Messages._7201, m.FullName, "property");
return(JsExpression.Null);
}
}
else if (m is IEvent)
{
var evt = (IEvent)m;
var sem = metadataImporter.GetEventSemantics(evt);
if (sem.Type != EventScriptSemantics.ImplType.AddAndRemoveMethods)
{
errorReporter.Message(Messages._7201, m.FullName, "event");
return(JsExpression.Null);
}
if (sem.AddMethod.Type != MethodScriptSemantics.ImplType.NormalMethod && sem.AddMethod.Type != MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument && sem.AddMethod.Type != MethodScriptSemantics.ImplType.InlineCode)
{
errorReporter.Message(Messages._7202, m.FullName, "event", "add accessor");
return(JsExpression.Null);
}
if (sem.RemoveMethod.Type != MethodScriptSemantics.ImplType.NormalMethod && sem.RemoveMethod.Type != MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument && sem.RemoveMethod.Type != MethodScriptSemantics.ImplType.InlineCode)
{
errorReporter.Message(Messages._7202, m.FullName, "event", "remove accessor");
return(JsExpression.Null);
}
properties.Add(new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Event)));
properties.Add(new JsObjectLiteralProperty("adder", ConstructMemberInfo(evt.AddAccessor, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType, sem.AddMethod)));
properties.Add(new JsObjectLiteralProperty("remover", ConstructMemberInfo(evt.RemoveAccessor, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType, sem.RemoveMethod)));
}
else
{
throw new ArgumentException("Invalid member " + m);
}
return(JsExpression.ObjectLiteral(properties));
}
private static JsExpression ConstructConstructorInfo(IMethod constructor, ICompilation compilation, IMetadataImporter metadataImporter, INamer namer, IRuntimeLibrary runtimeLibrary, IErrorReporter errorReporter, Func <IType, JsExpression> instantiateType, bool includeDeclaringType)
{
var properties = GetCommonMemberInfoProperties(constructor, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, instantiateType, includeDeclaringType);
var sem = metadataImporter.GetConstructorSemantics(constructor);
if (sem.Type == ConstructorScriptSemantics.ImplType.NotUsableFromScript)
{
errorReporter.Message(Messages._7200, constructor.FullName);
return(JsExpression.Null);
}
properties.Add(new JsObjectLiteralProperty("type", JsExpression.Number((int)MemberTypes.Constructor)));
properties.Add(new JsObjectLiteralProperty("params", JsExpression.ArrayLiteral(constructor.Parameters.Select(p => instantiateType(p.Type)))));
if (sem.Type == ConstructorScriptSemantics.ImplType.NamedConstructor || sem.Type == ConstructorScriptSemantics.ImplType.StaticMethod)
{
properties.Add(new JsObjectLiteralProperty("sname", JsExpression.String(sem.Name)));
}
if (sem.Type == ConstructorScriptSemantics.ImplType.StaticMethod)
{
properties.Add(new JsObjectLiteralProperty("sm", JsExpression.True));
}
if ((sem.Type == ConstructorScriptSemantics.ImplType.UnnamedConstructor || sem.Type == ConstructorScriptSemantics.ImplType.NamedConstructor || sem.Type == ConstructorScriptSemantics.ImplType.StaticMethod) && sem.ExpandParams)
{
properties.Add(new JsObjectLiteralProperty("exp", JsExpression.True));
}
if (sem.Type == ConstructorScriptSemantics.ImplType.Json || sem.Type == ConstructorScriptSemantics.ImplType.InlineCode)
{
var usedNames = new HashSet <string>();
var parameters = new List <IVariable>();
var variables = new Dictionary <IVariable, VariableData>();
IList <ResolveResult> constructorParameters = null;
IList <ResolveResult> initializerStatements = null;
if (sem.Type == ConstructorScriptSemantics.ImplType.Json && constructor.DeclaringType.Kind == TypeKind.Anonymous)
{
initializerStatements = new List <ResolveResult>();
foreach (var p in constructor.DeclaringType.GetProperties())
{
string paramName = MakeCamelCase(p.Name);
string name = namer.GetVariableName(paramName, usedNames);
usedNames.Add(name);
var variable = new SimpleVariable(p.ReturnType, paramName, DomRegion.Empty);
parameters.Add(variable);
variables.Add(variable, new VariableData(name, null, false));
initializerStatements.Add(new OperatorResolveResult(p.ReturnType, ExpressionType.Assign, new MemberResolveResult(new InitializedObjectResolveResult(constructor.DeclaringType), p), new LocalResolveResult(variable)));
}
}
else
{
constructorParameters = new List <ResolveResult>();
foreach (var p in constructor.Parameters)
{
string name = namer.GetVariableName(p.Name, usedNames);
usedNames.Add(name);
var variable = new SimpleVariable(p.Type, p.Name, DomRegion.Empty);
parameters.Add(variable);
variables.Add(variable, new VariableData(name, null, false));
constructorParameters.Add(new LocalResolveResult(variable));
}
}
var compileResult = CompileConstructorInvocation(constructor, initializerStatements, constructor.DeclaringTypeDefinition, constructor, constructorParameters, compilation, metadataImporter, namer, runtimeLibrary, errorReporter, variables, usedNames);
var definition = JsExpression.FunctionDefinition(parameters.Select(p => variables[p].Name), JsStatement.Block(compileResult.AdditionalStatements.Concat(new[] { JsStatement.Return(compileResult.Expression) })));
properties.Add(new JsObjectLiteralProperty("def", definition));
}
return(JsExpression.ObjectLiteral(properties));
}
private void AddClassMembers(JsClass c, JsExpression typeRef, ICompilation compilation, List <JsStatement> stmts)
{
ICollection <JsMethod> instanceMethods;
if (_metadataImporter.IsTestFixture(c.CSharpTypeDefinition))
{
var tests = new List <Tuple <string, string, bool, int?, JsFunctionDefinitionExpression> >();
var instanceMethodList = new List <JsMethod>();
foreach (var m in c.InstanceMethods)
{
var td = (m.CSharpMember is IMethod ? _metadataImporter.GetTestData((IMethod)m.CSharpMember) : null);
if (td != null)
{
tests.Add(Tuple.Create(td.Description, td.Category, td.IsAsync, td.ExpectedAssertionCount, m.Definition));
}
else
{
instanceMethodList.Add(m);
}
}
var testInvocations = new List <JsExpression>();
foreach (var category in tests.GroupBy(t => t.Item2).Select(g => new { Category = g.Key, Tests = g.Select(x => new { Description = x.Item1, IsAsync = x.Item3, ExpectedAssertionCount = x.Item4, Function = x.Item5 }) }).OrderBy(x => x.Category))
{
if (category.Category != null)
{
testInvocations.Add(JsExpression.Invocation(JsExpression.Identifier("module"), JsExpression.String(category.Category)));
}
testInvocations.AddRange(category.Tests.Select(t => JsExpression.Invocation(JsExpression.Identifier(t.IsAsync ? "asyncTest" : "test"), t.ExpectedAssertionCount != null ? new JsExpression[] { JsExpression.String(t.Description), JsExpression.Number(t.ExpectedAssertionCount.Value), _runtimeLibrary.Bind(t.Function, JsExpression.This) } : new JsExpression[] { JsExpression.String(t.Description), _runtimeLibrary.Bind(t.Function, JsExpression.This) })));
}
instanceMethodList.Add(new JsMethod(null, "runTests", null, JsExpression.FunctionDefinition(new string[0], new JsBlockStatement(testInvocations.Select(t => new JsExpressionStatement(t))))));
instanceMethods = instanceMethodList;
}
else
{
instanceMethods = c.InstanceMethods;
}
if (instanceMethods.Count > 0)
{
stmts.Add(new JsExpressionStatement(JsExpression.Assign(JsExpression.MemberAccess(typeRef, Prototype), JsExpression.ObjectLiteral(instanceMethods.Select(m => new JsObjectLiteralProperty(m.Name, m.Definition != null ? RewriteMethod(m) : JsExpression.Null))))));
}
if (c.NamedConstructors.Count > 0)
{
stmts.AddRange(c.NamedConstructors.Select(m => new JsExpressionStatement(JsExpression.Assign(JsExpression.MemberAccess(typeRef, m.Name), m.Definition))));
stmts.Add(new JsExpressionStatement(c.NamedConstructors.Reverse().Aggregate((JsExpression)JsExpression.MemberAccess(typeRef, Prototype), (right, ctor) => JsExpression.Assign(JsExpression.MemberAccess(JsExpression.MemberAccess(typeRef, ctor.Name), Prototype), right)))); // This generates a statement like {C}.ctor1.prototype = {C}.ctor2.prototype = {C}.prototoype
}
var defaultConstructor = c.CSharpTypeDefinition.GetConstructors().SingleOrDefault(x => x.Parameters.Count == 0 && x.IsPublic);
if (defaultConstructor != null)
{
JsExpression createInstance = CreateDefaultConstructorInvocation(defaultConstructor, typeRef);
if (createInstance != null)
{
stmts.Add(new JsExpressionStatement(
JsExpression.Assign(
JsExpression.MemberAccess(typeRef, "createInstance"),
JsExpression.FunctionDefinition(new string[0],
new JsReturnStatement(createInstance)))));
}
}
stmts.AddRange(c.StaticMethods.Select(m => new JsExpressionStatement(JsExpression.Assign(JsExpression.MemberAccess(typeRef, m.Name), RewriteMethod(m)))));
if (c.TypeArgumentNames.Count > 0)
{
if (c.ClassType == JsClass.ClassTypeEnum.Interface)
{
stmts.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.MemberAccess(typeRef, RegisterGenericInterfaceInstance),
typeRef,
new JsTypeReferenceExpression(compilation.MainAssembly, c.Name),
JsExpression.ArrayLiteral(c.TypeArgumentNames.Select(JsExpression.Identifier)),
JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.ArrayLiteral(c.ImplementedInterfaces))))));
}
else
{
stmts.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.MemberAccess(typeRef, RegisterGenericClassInstance),
typeRef,
new JsTypeReferenceExpression(compilation.MainAssembly, c.Name),
JsExpression.ArrayLiteral(c.TypeArgumentNames.Select(JsExpression.Identifier)),
JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(c.BaseClass)),
JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.ArrayLiteral(c.ImplementedInterfaces))))));
}
}
}
private IteratorStateMachine ProcessIteratorBlock(JsBlockStatement statement, Func <string> allocateFinallyHandler, Func <JsExpression, JsExpression> makeSetCurrent)
{
_allocateFinallyHandler = allocateFinallyHandler;
_makeSetCurrent = makeSetCurrent;
var result = Process(statement, isIteratorBlock: true, isAsync: false);
var stateFinallyHandlers = _allStates.Where(s => !s.FinallyStack.IsEmpty).Select(s => Tuple.Create(s.StateValue, s.FinallyStack.Select(x => x.Item2).Reverse().ToList())).ToList();
var hoistResult = VariableHoistingVisitor.Process(result);
return(new IteratorStateMachine(hoistResult.Item1,
new[] { JsStatement.Declaration(_stateVariableName, JsExpression.Number(0)) }.Concat(hoistResult.Item2.Select(v => JsStatement.Declaration(v, null))),
_finallyHandlers.Select(h => Tuple.Create(h.Item1, JsExpression.FunctionDefinition(new string[0], h.Item2))),
stateFinallyHandlers.Count > 0 ? DisposeGenerator.GenerateDisposer(_stateVariableName, stateFinallyHandlers) : null));
}
public void FunctionDefinitionExpressionIsOutputCorrectly()
{
AssertCorrect(JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.Null)), "function(){return null;}");
AssertCorrect(JsExpression.FunctionDefinition(new [] { "a", "b" }, new JsReturnStatement(JsExpression.Null)), "function(a,b){return null;}");
AssertCorrect(JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.Null), name: "myFunction"), "function myFunction(){return null;}");
}
public void ObjectLiteralWithFunctionValuesAreNotOutputOnMultipleLines()
{
AssertCorrect(JsExpression.ObjectLiteral(new JsObjectLiteralProperty("x", JsExpression.Number(1)),
new JsObjectLiteralProperty("y", JsExpression.FunctionDefinition(new string[0], new JsReturnStatement())),
new JsObjectLiteralProperty("z", JsExpression.Number(3))),
"{x:1,y:function(){return;},z:3}");
}
public IList <JsStatement> Rewrite(IEnumerable <JsType> types, ICompilation compilation)
{
var netSystemType = compilation.FindType(KnownTypeCode.Type).GetDefinition();
var systemType = new JsTypeReferenceExpression(netSystemType.ParentAssembly, _metadataImporter.GetTypeSemantics(netSystemType).Name);
var result = new List <JsStatement>();
var orderedTypes = OrderByNamespace(types, t => t.Name).ToList();
string currentNs = "";
foreach (var t in orderedTypes)
{
try {
var globalMethodsPrefix = _metadataImporter.GetGlobalMethodsPrefix(t.CSharpTypeDefinition);
string ns = GetNamespace(t.Name);
if (ns != currentNs && globalMethodsPrefix == null)
{
result.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.MemberAccess(systemType, RegisterNamespace), JsExpression.String(ns))));
currentNs = ns;
}
result.Add(new JsComment("//////////////////////////////////////////////////////////////////////////////" + Environment.NewLine + " " + t.CSharpTypeDefinition.FullName));
var typeRef = new JsTypeReferenceExpression(compilation.MainAssembly, t.Name);
if (t is JsClass)
{
var c = (JsClass)t;
if (globalMethodsPrefix != null)
{
if (globalMethodsPrefix == "")
{
result.AddRange(c.StaticMethods.Select(m => new JsExpressionStatement(JsExpression.Binary(ExpressionNodeType.Assign, JsExpression.MemberAccess(JsExpression.Identifier("window"), m.Name), m.Definition))));
}
else
{
result.AddRange(c.StaticMethods.Select(m => new JsExpressionStatement(JsExpression.Assign(MakeNestedMemberAccess(globalMethodsPrefix + "." + m.Name), m.Definition))));
}
}
else if (_metadataImporter.IsResources(t.CSharpTypeDefinition))
{
result.Add(GenerateResourcesClass(c));
}
else
{
var unnamedCtor = c.UnnamedConstructor ?? JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement);
if (c.TypeArgumentNames.Count == 0)
{
result.Add(new JsExpressionStatement(JsExpression.Assign(typeRef, unnamedCtor)));
AddClassMembers(c, typeRef, compilation, result);
}
else
{
var stmts = new List <JsStatement> {
new JsVariableDeclarationStatement(InstantiatedGenericTypeVariableName, unnamedCtor)
};
AddClassMembers(c, JsExpression.Identifier(InstantiatedGenericTypeVariableName), compilation, stmts);
stmts.AddRange(c.StaticInitStatements);
stmts.Add(new JsReturnStatement(JsExpression.Identifier(InstantiatedGenericTypeVariableName)));
result.Add(new JsExpressionStatement(JsExpression.Assign(typeRef, JsExpression.FunctionDefinition(c.TypeArgumentNames, new JsBlockStatement(stmts)))));
result.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.MemberAccess(typeRef, c.ClassType == JsClass.ClassTypeEnum.Interface ? RegisterGenericInterface : RegisterGenericClass), JsExpression.String(c.Name), JsExpression.Number(c.TypeArgumentNames.Count))));
}
}
}
else if (t is JsEnum)
{
var e = (JsEnum)t;
bool flags = GetAttributePositionalArgs(t.CSharpTypeDefinition, FlagsAttribute, "System") != null;
result.Add(new JsExpressionStatement(JsExpression.Assign(typeRef, JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement))));
result.Add(new JsExpressionStatement(JsExpression.Assign(JsExpression.MemberAccess(typeRef, Prototype), JsExpression.ObjectLiteral(e.Values.Select(v => new JsObjectLiteralProperty(v.Name, (_metadataImporter.IsNamedValues(t.CSharpTypeDefinition) ? JsExpression.String(v.Name) : JsExpression.Number(v.Value))))))));
result.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.MemberAccess(typeRef, RegisterEnum), JsExpression.String(t.Name), JsExpression.Boolean(flags))));
}
}
catch (Exception ex) {
_errorReporter.Region = t.CSharpTypeDefinition.Region;
_errorReporter.InternalError(ex, "Error formatting type " + t.CSharpTypeDefinition.FullName);
}
}
var typesToRegister = orderedTypes.OfType <JsClass>()
.Where(c => c.TypeArgumentNames.Count == 0 &&
_metadataImporter.GetGlobalMethodsPrefix(c.CSharpTypeDefinition) == null &&
!_metadataImporter.IsResources(c.CSharpTypeDefinition))
.ToList();
result.AddRange(TopologicalSortTypesByInheritance(typesToRegister)
.Select(c => {
try {
var typeRef = new JsTypeReferenceExpression(compilation.MainAssembly, c.Name);
if (c.ClassType == JsClass.ClassTypeEnum.Interface)
{
return(JsExpression.Invocation(JsExpression.MemberAccess(typeRef, RegisterInterface), JsExpression.String(c.Name), JsExpression.ArrayLiteral(c.ImplementedInterfaces)));
}
else
{
return(CreateRegisterClassCall(JsExpression.String(c.Name), c.BaseClass, c.ImplementedInterfaces, typeRef));
}
}
catch (Exception ex) {
_errorReporter.Region = c.CSharpTypeDefinition.Region;
_errorReporter.InternalError(ex, "Error formatting type " + c.CSharpTypeDefinition.FullName);
return(JsExpression.Number(0));
}
})
.Select(expr => new JsExpressionStatement(expr)));
result.AddRange(orderedTypes.OfType <JsClass>().Where(c => c.TypeArgumentNames.Count == 0 && !_metadataImporter.IsResources(c.CSharpTypeDefinition)).SelectMany(t => t.StaticInitStatements));
return(result);
}
public void ExpressionStatementsContainingOnlyAFunctionDefinitionParenthesizesThatDefinition()
{
AssertCorrect(new JsExpressionStatement(JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement)), "(function() {\r\n});\r\n");
}
public void TheOverallStructureIsCorrect()
{
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// OuterNamespace.InnerNamespace.SomeEnum
var $OuterNamespace_InnerNamespace_SomeEnum = function() {
};
$OuterNamespace_InnerNamespace_SomeEnum.prototype = { Value1: 1, Value2: 2, Value3: 3 };
{Type}.registerEnum(global, 'OuterNamespace.InnerNamespace.SomeEnum', $OuterNamespace_InnerNamespace_SomeEnum, false);
////////////////////////////////////////////////////////////////////////////////
// OuterNamespace.InnerNamespace.SomeType
var $OuterNamespace_InnerNamespace_SomeType = function() {
this.a = 0;
};
$OuterNamespace_InnerNamespace_SomeType.prototype = {
method1: function(x) {
return x;
},
method2: function(x, y) {
return x + y;
}
};
$OuterNamespace_InnerNamespace_SomeType.staticMethod = function() {
};
////////////////////////////////////////////////////////////////////////////////
// OuterNamespace.InnerNamespace.SomeType2
var $OuterNamespace_InnerNamespace_SomeType2 = function() {
this.b = 0;
};
$OuterNamespace_InnerNamespace_SomeType2.prototype = {
method1: function(x) {
return x;
}
};
$OuterNamespace_InnerNamespace_SomeType2.otherStaticMethod = function() {
};
////////////////////////////////////////////////////////////////////////////////
// OuterNamespace.InnerNamespace2.OtherInterface
var $OuterNamespace_InnerNamespace2_OtherInterface = function() {
};
$OuterNamespace_InnerNamespace2_OtherInterface.prototype = { interfaceMethod: null };
////////////////////////////////////////////////////////////////////////////////
// OuterNamespace.InnerNamespace2.OtherType
var $OuterNamespace_InnerNamespace2_OtherType = function() {
};
$OuterNamespace_InnerNamespace2_OtherType.prototype = {
method1: function(x) {
return x;
}
};
{Type}.registerClass(global, 'OuterNamespace.InnerNamespace.SomeType', $OuterNamespace_InnerNamespace_SomeType);
{Type}.registerClass(global, 'OuterNamespace.InnerNamespace.SomeType2', $OuterNamespace_InnerNamespace_SomeType2);
{Type}.registerInterface(global, 'OuterNamespace.InnerNamespace2.OtherInterface', $OuterNamespace_InnerNamespace2_OtherInterface, []);
{Type}.registerClass(global, 'OuterNamespace.InnerNamespace2.OtherType', $OuterNamespace_InnerNamespace2_OtherType, {SomeType2});
y = 1;
x = 1;
",
new JsClass(CreateMockTypeDefinition("OuterNamespace.InnerNamespace.SomeType"), JsClass.ClassTypeEnum.Class, null, null, null)
{
UnnamedConstructor = JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Assign(JsExpression.Member(JsExpression.This, "a"), JsExpression.Number(0)))),
InstanceMethods = { new JsMethod(CreateMockMethod("Method1"), "method1", null, JsExpression.FunctionDefinition(new[] { "x" }, new JsReturnStatement(JsExpression.Identifier("x")))),
new JsMethod(CreateMockMethod("Method2"), "method2", null, JsExpression.FunctionDefinition(new[] { "x", "y"}, new JsReturnStatement(JsExpression.Binary(ExpressionNodeType.Add, JsExpression.Identifier("x"), JsExpression.Identifier("y"))))) },
StaticMethods = { new JsMethod(CreateMockMethod("StaticMethod"), "staticMethod", null, JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement)) },
},
new JsClass(CreateMockTypeDefinition("OuterNamespace.InnerNamespace.SomeType2"), JsClass.ClassTypeEnum.Class, null, null, null)
{
UnnamedConstructor = JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Assign(JsExpression.Member(JsExpression.This, "b"), JsExpression.Number(0)))),
InstanceMethods = { new JsMethod(CreateMockMethod("Method1"), "method1", null, JsExpression.FunctionDefinition(new[] { "x" }, new JsReturnStatement(JsExpression.Identifier("x")))) },
StaticMethods = { new JsMethod(CreateMockMethod("OtherStaticMethod"), "otherStaticMethod", null, JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement)) },
StaticInitStatements = { new JsExpressionStatement(JsExpression.Assign(JsExpression.Identifier("y"), JsExpression.Number(1))) }
},
new JsEnum(CreateMockTypeDefinition("OuterNamespace.InnerNamespace.SomeEnum"), new[] {
new JsEnumValue("Value1", 1),
new JsEnumValue("Value2", 2),
new JsEnumValue("Value3", 3),
}),
new JsClass(CreateMockTypeDefinition("OuterNamespace.InnerNamespace2.OtherType"), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("OuterNamespace.InnerNamespace.SomeType2")), null)
{
UnnamedConstructor = JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement),
InstanceMethods = { new JsMethod(CreateMockMethod("Method1"), "method1", null, JsExpression.FunctionDefinition(new[] { "x" }, new JsReturnStatement(JsExpression.Identifier("x")))), },
StaticInitStatements = { new JsExpressionStatement(JsExpression.Assign(JsExpression.Identifier("x"), JsExpression.Number(1))) }
},
new JsClass(CreateMockTypeDefinition("OuterNamespace.InnerNamespace2.OtherInterface"), JsClass.ClassTypeEnum.Interface, null, null, null)
{
UnnamedConstructor = JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement),
InstanceMethods = { new JsMethod(CreateMockMethod("InterfaceMethod"), "interfaceMethod", null, null) },
StaticInitStatements = {}
});
}
private void AddClassMembers(JsClass c, JsExpression typeRef, List <JsStatement> stmts)
{
if (c.InstanceMethods.Count > 0)
{
stmts.Add(new JsExpressionStatement(JsExpression.Assign(JsExpression.Member(typeRef, Prototype), JsExpression.ObjectLiteral(c.InstanceMethods.Select(m => new JsObjectLiteralProperty(m.Name, m.Definition != null ? RewriteMethod(m) : JsExpression.Null))))));
}
if (c.NamedConstructors.Count > 0)
{
stmts.AddRange(c.NamedConstructors.Select(m => new JsExpressionStatement(JsExpression.Assign(JsExpression.Member(typeRef, m.Name), m.Definition))));
stmts.Add(new JsExpressionStatement(c.NamedConstructors.Reverse().Aggregate((JsExpression)JsExpression.Member(typeRef, Prototype), (right, ctor) => JsExpression.Assign(JsExpression.Member(JsExpression.Member(typeRef, ctor.Name), Prototype), right)))); // This generates a statement like {C}.ctor1.prototype = {C}.ctor2.prototype = {C}.prototoype
}
var defaultConstructor = Saltarelle.Compiler.Utils.SelfParameterize(c.CSharpTypeDefinition).GetConstructors().SingleOrDefault(x => x.Parameters.Count == 0 && x.IsPublic);
if (defaultConstructor != null)
{
var sem = _metadataImporter.GetConstructorSemantics(defaultConstructor);
if (sem.Type != ConstructorScriptSemantics.ImplType.UnnamedConstructor && sem.Type != ConstructorScriptSemantics.ImplType.NotUsableFromScript)
{
var createInstance = MetadataUtils.CompileConstructorInvocation(defaultConstructor, null, c.CSharpTypeDefinition, null, EmptyList <ResolveResult> .Instance, _compilation, _metadataImporter, _namer, _runtimeLibrary, _errorReporter, null, null);
stmts.Add(new JsExpressionStatement(
JsExpression.Assign(
JsExpression.Member(typeRef, "createInstance"),
JsExpression.FunctionDefinition(new string[0], new JsBlockStatement(createInstance.AdditionalStatements.Concat(new[] { new JsReturnStatement(createInstance.Expression) }))))));
}
}
stmts.AddRange(c.StaticMethods.Select(m => new JsExpressionStatement(JsExpression.Assign(JsExpression.Member(typeRef, m.Name), RewriteMethod(m)))));
if (MetadataUtils.IsSerializable(c.CSharpTypeDefinition))
{
string typeCheckCode = MetadataUtils.GetSerializableTypeCheckCode(c.CSharpTypeDefinition);
if (!string.IsNullOrEmpty(typeCheckCode))
{
var oldReg = _errorReporter.Region;
_errorReporter.Region = c.CSharpTypeDefinition.Attributes.Single(a => a.AttributeType.FullName == typeof(SerializableAttribute).FullName).Region;
var method = MetadataUtils.CreateTypeCheckMethod(Saltarelle.Compiler.Utils.SelfParameterize(c.CSharpTypeDefinition), _compilation);
var errors = new List <string>();
var tokens = InlineCodeMethodCompiler.Tokenize(method, typeCheckCode, errors.Add);
if (errors.Count == 0)
{
var context = new DefaultRuntimeContext(c.CSharpTypeDefinition, _metadataImporter, _errorReporter, _namer);
var result = InlineCodeMethodCompiler.CompileInlineCodeMethodInvocation(method, tokens, JsExpression.Identifier("obj"), new JsExpression[0],
n => {
var type = ReflectionHelper.ParseReflectionName(n).Resolve(_compilation);
if (type.Kind == TypeKind.Unknown)
{
errors.Add("Unknown type '" + n + "' specified in inline implementation");
return(JsExpression.Null);
}
return(_runtimeLibrary.InstantiateType(type, context));
},
t => _runtimeLibrary.InstantiateTypeForUseAsTypeArgumentInInlineCode(t, context),
errors.Add);
stmts.Add(new JsExpressionStatement(
JsExpression.Assign(
JsExpression.Member(typeRef, "isInstanceOfType"),
JsExpression.FunctionDefinition(new[] { "obj" }, new JsReturnStatement(result)))));
foreach (var e in errors)
{
_errorReporter.Message(Messages._7157, c.CSharpTypeDefinition.FullName, e);
}
}
_errorReporter.Region = oldReg;
}
}
if (MetadataUtils.IsJsGeneric(c.CSharpTypeDefinition, _metadataImporter))
{
var args = new List <JsExpression> {
typeRef, new JsTypeReferenceExpression(c.CSharpTypeDefinition), JsExpression.ArrayLiteral(c.CSharpTypeDefinition.TypeParameters.Select(tp => JsExpression.Identifier(_namer.GetTypeParameterName(tp))))
};
if (c.CSharpTypeDefinition.Kind == TypeKind.Class)
{
args.Add(JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(GetBaseClass(c.CSharpTypeDefinition) ?? JsExpression.Null)));
}
args.Add(JsExpression.FunctionDefinition(new string[0], new JsReturnStatement(JsExpression.ArrayLiteral(GetImplementedInterfaces(c.CSharpTypeDefinition)))));
var metadata = GetMetadataDescriptor(c.CSharpTypeDefinition, true);
if (metadata != null)
{
args.Add(metadata);
}
stmts.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.Member(_systemScript, c.CSharpTypeDefinition.Kind == TypeKind.Class ? RegisterGenericClassInstance : RegisterGenericInterfaceInstance), args)));
}
}
public void AnErrorIsIssuedIfTheMainMethodIsNotImplementedAsANormalMethod()
{
var type = CreateMockTypeDefinition("MyClass");
var main = new Mock <IMethod>(MockBehavior.Strict);
main.SetupGet(_ => _.DeclaringTypeDefinition).Returns(type);
main.SetupGet(_ => _.Name).Returns("Main");
main.SetupGet(_ => _.FullName).Returns("MyClass.Main");
main.SetupGet(_ => _.Parameters).Returns(EmptyList <IParameter> .Instance);
main.SetupGet(_ => _.Region).Returns(DomRegion.Empty);
var er = new MockErrorReporter();
Process(
new[] {
new JsClass(type, JsClass.ClassTypeEnum.Class, null, null, null)
{
StaticMethods = { new JsMethod(main.Object, "$Main", new string[0], JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Identifier("X")))) }
}
},
new MockScriptSharpMetadataImporter()
{
GetMethodSemantics = m => ReferenceEquals(m, main.Object) ? MethodScriptSemantics.InlineCode("X") : MethodScriptSemantics.NormalMethod("$" + m.Name)
},
er,
main.Object
);
Assert.That(er.AllMessages, Has.Count.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7801 && (string)m.Args[0] == "MyClass.Main"));
}
public IList <JsStatement> Process(IEnumerable <JsType> types, IMethod entryPoint)
{
var result = new List <JsStatement>();
var orderedTypes = OrderByNamespace(types, t => _metadataImporter.GetTypeSemantics(t.CSharpTypeDefinition).Name).ToList();
foreach (var t in orderedTypes)
{
try {
string name = _metadataImporter.GetTypeSemantics(t.CSharpTypeDefinition).Name;
bool isGlobal = string.IsNullOrEmpty(name);
bool isMixin = MetadataUtils.IsMixin(t.CSharpTypeDefinition);
result.Add(new JsComment("//////////////////////////////////////////////////////////////////////////////" + Environment.NewLine + " " + t.CSharpTypeDefinition.FullName));
var typeRef = JsExpression.Identifier(_namer.GetTypeVariableName(name));
if (t is JsClass)
{
var c = (JsClass)t;
if (isGlobal)
{
result.AddRange(c.StaticMethods.Select(m => new JsExpressionStatement(JsExpression.Binary(ExpressionNodeType.Assign, JsExpression.Member(GetRoot(t.CSharpTypeDefinition, exportNonPublic: true), m.Name), m.Definition))));
}
else if (isMixin)
{
result.AddRange(c.StaticMethods.Select(m => new JsExpressionStatement(JsExpression.Assign(MakeNestedMemberAccess(name + "." + m.Name), m.Definition))));
}
else if (MetadataUtils.IsResources(c.CSharpTypeDefinition))
{
result.Add(GenerateResourcesClass(c));
}
else
{
var unnamedCtor = c.UnnamedConstructor ?? JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement);
if (MetadataUtils.IsJsGeneric(c.CSharpTypeDefinition, _metadataImporter))
{
var typeParameterNames = c.CSharpTypeDefinition.TypeParameters.Select(tp => _namer.GetTypeParameterName(tp)).ToList();
var stmts = new List <JsStatement> {
new JsVariableDeclarationStatement(InstantiatedGenericTypeVariableName, unnamedCtor)
};
AddClassMembers(c, JsExpression.Identifier(InstantiatedGenericTypeVariableName), stmts);
stmts.AddRange(c.StaticInitStatements);
stmts.Add(new JsReturnStatement(JsExpression.Identifier(InstantiatedGenericTypeVariableName)));
var replacer = new GenericSimplifier(c.CSharpTypeDefinition, typeParameterNames, JsExpression.Identifier(InstantiatedGenericTypeVariableName));
for (int i = 0; i < stmts.Count; i++)
{
stmts[i] = replacer.Process(stmts[i]);
}
result.Add(new JsVariableDeclarationStatement(typeRef.Name, JsExpression.FunctionDefinition(typeParameterNames, new JsBlockStatement(stmts))));
var args = new List <JsExpression> {
GetRoot(t.CSharpTypeDefinition), JsExpression.String(name), typeRef, JsExpression.Number(c.CSharpTypeDefinition.TypeParameterCount)
};
var metadata = GetMetadataDescriptor(t.CSharpTypeDefinition, false);
if (metadata != null)
{
args.Add(metadata);
}
result.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.Member(_systemScript, c.CSharpTypeDefinition.Kind == TypeKind.Interface ? RegisterGenericInterface : RegisterGenericClass), args)));
}
else
{
result.Add(new JsVariableDeclarationStatement(typeRef.Name, unnamedCtor));
AddClassMembers(c, typeRef, result);
}
}
}
else if (t is JsEnum)
{
var e = (JsEnum)t;
result.Add(new JsVariableDeclarationStatement(typeRef.Name, JsExpression.FunctionDefinition(new string[0], JsBlockStatement.EmptyStatement)));
var values = new List <JsObjectLiteralProperty>();
foreach (var v in e.CSharpTypeDefinition.Fields)
{
if (v.ConstantValue != null)
{
var sem = _metadataImporter.GetFieldSemantics(v);
if (sem.Type == FieldScriptSemantics.ImplType.Field)
{
values.Add(new JsObjectLiteralProperty(sem.Name, JsExpression.Number(Convert.ToDouble(v.ConstantValue))));
}
else if (sem.Type == FieldScriptSemantics.ImplType.Constant && sem.Name != null)
{
values.Add(new JsObjectLiteralProperty(sem.Name, sem.Value is string?JsExpression.String((string)sem.Value) : JsExpression.Number(Convert.ToDouble(sem.Value))));
}
}
else
{
_errorReporter.Region = v.Region;
_errorReporter.InternalError("Enum field " + v.FullName + " is not constant.");
}
}
result.Add(new JsExpressionStatement(JsExpression.Assign(JsExpression.Member(typeRef, Prototype), JsExpression.ObjectLiteral(values))));
}
}
catch (Exception ex) {
_errorReporter.Region = t.CSharpTypeDefinition.Region;
_errorReporter.InternalError(ex, "Error formatting type " + t.CSharpTypeDefinition.FullName);
}
}
var typesToRegister = orderedTypes
.Where(c => !(c is JsClass && MetadataUtils.IsJsGeneric(c.CSharpTypeDefinition, _metadataImporter)) &&
!string.IsNullOrEmpty(_metadataImporter.GetTypeSemantics(c.CSharpTypeDefinition).Name) &&
(!MetadataUtils.IsResources(c.CSharpTypeDefinition) || c.CSharpTypeDefinition.IsExternallyVisible()) && // Resources classes are only exported if they are public.
!MetadataUtils.IsMixin(c.CSharpTypeDefinition))
.ToList();
result.AddRange(TopologicalSortTypesByInheritance(typesToRegister)
.Select(c => {
try {
string name = _metadataImporter.GetTypeSemantics(c.CSharpTypeDefinition).Name;
if (c.CSharpTypeDefinition.Kind == TypeKind.Enum)
{
return(CreateRegisterEnumCall(c.CSharpTypeDefinition, name, JsExpression.Identifier(_namer.GetTypeVariableName(name))));
}
if (MetadataUtils.IsResources(c.CSharpTypeDefinition))
{
return(JsExpression.Invocation(JsExpression.Member(_systemScript, RegisterType), GetRoot(c.CSharpTypeDefinition), JsExpression.String(name), JsExpression.Identifier(_namer.GetTypeVariableName(name))));
}
if (c.CSharpTypeDefinition.Kind == TypeKind.Interface)
{
return(CreateRegisterInterfaceCall(c.CSharpTypeDefinition,
name,
JsExpression.Identifier(_namer.GetTypeVariableName(name)),
GetImplementedInterfaces(c.CSharpTypeDefinition.GetDefinition()).ToList()));
}
else
{
return(CreateRegisterClassCall(c.CSharpTypeDefinition,
name,
JsExpression.Identifier(_namer.GetTypeVariableName(name)),
GetBaseClass(c.CSharpTypeDefinition),
GetImplementedInterfaces(c.CSharpTypeDefinition).ToList()));
}
}
catch (Exception ex) {
_errorReporter.Region = c.CSharpTypeDefinition.Region;
_errorReporter.InternalError(ex, "Error formatting type " + c.CSharpTypeDefinition.FullName);
return(JsExpression.Number(0));
}
})
.Select(expr => new JsExpressionStatement(expr)));
result.AddRange(GetStaticInitializationOrder(orderedTypes.OfType <JsClass>(), 1)
.Where(c => !MetadataUtils.IsJsGeneric(c.CSharpTypeDefinition, _metadataImporter) && !MetadataUtils.IsResources(c.CSharpTypeDefinition))
.SelectMany(c => c.StaticInitStatements));
if (entryPoint != null)
{
if (entryPoint.Parameters.Count > 0)
{
_errorReporter.Region = entryPoint.Region;
_errorReporter.Message(Messages._7800, entryPoint.FullName);
}
else
{
var sem = _metadataImporter.GetMethodSemantics(entryPoint);
if (sem.Type != MethodScriptSemantics.ImplType.NormalMethod)
{
_errorReporter.Region = entryPoint.Region;
_errorReporter.Message(Messages._7801, entryPoint.FullName);
}
else
{
result.Add(new JsExpressionStatement(JsExpression.Invocation(JsExpression.Member(new JsTypeReferenceExpression(entryPoint.DeclaringTypeDefinition), sem.Name))));
}
}
}
return(result);
}
