public override void Translate(ForStatement model, TranslationContext context)
{
context.EnsureLineBreak();
context.Write("for(");
if (model.VariableDeclaration != null && model.VariableDeclaration.Variables.Any())
{
context.Write("var ");
context.WriteModels(model.VariableDeclaration.Variables, ", ");
}
else if (model.Initializers != null && model.Initializers.Any())
{
context.WriteModels(model.Initializers, ", ");
}
// write condition
context.Write("; ");
context.WriteModel(model.Condition);
// write incrementors
context.Write("; ");
context.WriteModels(model.Incrementors, ", ");
// write body
context.WriteLine(") {");
context.Indent();
context.WriteModelBody(model.Statement);
context.Unindent();
context.WriteLine("}");
}
public override void Translate(LambdaExpression model, TranslationContext context)
{
if (context.IsWritingGlobalStatements)
{
// write function declaration, with params
context.Write("function(");
context.WriteModels(model.Parameters, ", ");
context.WriteLine(") {");
// write inner body
context.Indent();
context.WriteModelBody(model.Body);
context.Unindent();
// close function declaration
context.Write("}");
}
else
{
// write function declaration, with params
context.Write("Blade.del(this, function(");
context.WriteModels(model.Parameters, ", ");
context.WriteLine(") {");
// write inner body
context.Indent();
context.WriteModelBody(model.Body);
context.Unindent();
// close function declaration
context.Write("})");
}
}
public override void Translate(ElementAccessExpression model, TranslationContext context)
{
context.WriteModel(model.Expression);
context.Write("[");
context.WriteModels(model.Arguments.Select(a => a.Expression), ", ");
context.Write("]");
}
public override void Translate(MethodDeclaration model, TranslationContext context)
{
if (model == null)
{
return;
}
context.WriteDeclaration(model);
context.Write(" = function (");
if (model.HasParameters)
{
context.WriteModels(model.Parameters, ", ");
}
// begin method
context.WriteLine(") {");
context.Indent();
// set optional params to defaults
foreach (var param in model.Parameters.Where(p => p.Definition.HasDefaultValue))
{
context.Write(String.Format("{0} = ({0} !== undefined) ? {0} : ", param.Name));
context.WriteModel(param.DefaultExpression);
context.WriteLine(";");
}
// write method body
context.WriteModelBody(model.Body);
context.Unindent();
context.EnsureLineBreak();
context.WriteLine("};");
}
public override void Translate(LocalDeclarationStatement model, TranslationContext context)
{
context.EnsureLineBreak();
context.Write("var ");
context.WriteModels(model.VariableDeclaration.Variables, ", " + Environment.NewLine);
context.WriteLine(";");
}
public override void Translate(NewExpression model, TranslationContext context)
{
if (HandleSpecialCases(model, context))
{
return;
}
var hasInit = model.Initializer != null &&
model.Initializer.Expressions.Any();
if (hasInit)
{
// wrap in function
context.Write("(function($0) { ");
foreach (AssignmentExpression item in model.Initializer.Expressions)
{
// work around for Roslyn object initializers not supported
if (item.Assignee.Definition is EmptyDefinition)
{
var typeDef = ((ContainerTypeDefinition)model.Type);
if (typeDef != null)
{
var memberDef = typeDef.Properties.FirstOrDefault(p => p.Name == item.Assignee.Name) as IMemberDefinition ??
typeDef.Fields.FirstOrDefault(f => f.Name == item.Assignee.Name) as IMemberDefinition;
if (memberDef != null)
{
item.Assignee.Definition = memberDef;
item.LeftExpression = item.Assignee;
}
}
}
// end Roslyn object initializer workaround
context.Write("$0.");
context.WriteModel(item);
context.Write("; ");
}
context.Write("return $0; })(");
}
// always create types by full name
context.Write("new " + model.Type.GetFullName() + "(");
if (model.HasArguments)
{
context.WriteModels(model.Arguments.Select(a => a.Expression), ", ");
}
context.Write(hasInit ? "))" : ")");
}
public override void Translate(ImplicitArrayCreationExpression model, TranslationContext context)
{
// implicit array creation should always have an initializer
if (model.Initializer == null)
{
throw new CompilationException("Compiler error: Implicit array creation expected an intializer.", model);
}
// write as initialized array.
context.Write("[");
context.WriteModels(model.Initializer.Expressions, ", ");
context.Write("]");
}
public override void Translate(AnonymousMethodExpression model, TranslationContext context)
{
// write function declaration, with params
context.Write("Blade.del(this, function(");
context.WriteModels(model.Parameters, ", ");
context.WriteLine(") {");
// write inner body
context.Indent();
context.WriteModelBody(model.Body);
context.Unindent();
// close function declaration
context.Write("})");
}
public override void Translate(ArrayCreationExpression model, TranslationContext context)
{
if (model.TypeExpression.RankExpressions.Count > 1)
{
throw new CompilationException("Multidimensional arrays are not supported.", model);
}
if (model.Initializer != null)
{
// write as initialized array.
context.Write("[");
context.WriteModels(model.Initializer.Expressions, ", ");
context.Write("]");
}
else
{
// write an new empty array (repecting default values)
if (model.TypeExpression.RankExpressions.Count == 1)
{
var rankExp = model.TypeExpression.RankExpressions[0];
if (rankExp.Rank > 1)
{
throw new CompilationException("Multidimensional arrays are not supported.", model);
}
if (rankExp.Sizes.Any())
{
context.Write("new Array(");
context.WriteModel(rankExp.Sizes[0]);
context.Write(")");
}
else
{
context.Write("[]");
}
}
else
{
context.Write("[]");
}
}
}
public override void Translate(InvocationExpression model, TranslationContext context)
{
context.WriteModel(model.Expression);
var args = GetArguments(model);
// when invoking explicitly, use 'call' and
// explicity pass the 'this' context in
if (context.UsingExplicitCall)
{
// use an explicit invocation call
var hasArgs = args.Any() || context.ExtensionMethodTarget != null;
context.Write(".call(this" + (hasArgs ? ", " : ""));
// reset explicit call flag
context.UsingExplicitCall = false;
}
else
{
context.Write("(");
}
// handle extension methods
if (context.ExtensionMethodTarget != null)
{
// capture and set target to null, otherwise another
// invocation expression will result in an infinite loop
var target = context.ExtensionMethodTarget;
context.ExtensionMethodTarget = null;
context.WriteModel(target);
if (args.Any())
{
context.Write(", ");
}
}
context.WriteModels(args, ", ");
context.Write(")");
}
public override void Translate(SwitchStatement model, TranslationContext context)
{
// begin switch statement
context.EnsureLineBreak();
context.Write("switch (");
context.WriteModel(model.Expression);
context.WriteLine(") {");
context.Indent();
// write sections
foreach (var section in model.Sections)
{
foreach (var label in section.Labels)
{
// labels
context.EnsureLineBreak();
context.Write("case ");
context.WriteModel(label);
context.WriteLine(":");
}
if (section.IsDefault)
{
context.WriteLine("default:");
}
// write statements
context.Indent();
context.WriteModels(section.Statements, "");
context.Unindent();
}
// end statement
context.Unindent();
context.WriteLine("}");
}
public override void Translate(ClassDeclaration model, TranslationContext context)
{
if (model == null)
{
return;
}
// make sure the namespace is available
context.EnsureNamespace(model.Definition.Namespace);
// begin the class closure
context.WriteLine();
context.WriteLine(model.Definition.GetFullName() + " = (function() {");
context.Indent();
if (model.IsDerived)
{
var baseName = model.Definition.BaseClass.GetFullName();
// derive from base, and create a local variable to access base
context.WriteLine(String.Format("Blade.derive({0}, {1});", model.Definition.Name, baseName));
context.WriteLine("var $base = " + baseName + ".prototype;");
}
// write the class constructor
var instanceCtors = model.Constructors.Where(c => !c.IsStatic);
if (instanceCtors.Count() > 1)
{
throw new CompilationException("Constructor overloading is not supported.", model.Constructors[1]);
}
var ctor = instanceCtors.FirstOrDefault() ?? new ConstructorDeclaration();
var paramsText = String.Join(", ", ctor.Parameters.Select(p => p.Definition.Name));
// write the ctor
context.WriteLine(String.Format("function {0}({1}) {{", model.Definition.Name, paramsText));
context.Indent();
// write initialized fields, and return remaining fields
// those remaining may safely be attached to the prototype
var pFields = WriteCtorInitializers(model.Fields, context);
if (model.IsDerived)
{
// write explicit call to base class ctor
context.Write("$base.constructor.call(this");
if (ctor.HasExplicitBaseCall)
{
// check for arguments to the base ctor
var baseCtor = model.Definition.BaseClass.Constructors.FirstOrDefault();
if (baseCtor != null && baseCtor.Parameters.Any())
{
var baseArgs = TranslationHelper.GetInvocationArgs(baseCtor.Parameters, ctor.BaseArguments);
if (baseArgs.Any())
{
// write base ctor args
context.Write(", ");
context.WriteModels(baseArgs, ", ");
}
}
}
context.WriteLine(");");
}
context.WriteModelBody(ctor.Body);
context.Unindent();
context.WriteLine("}");
// group all members
var members = Enumerable.Empty <IMemberDeclarationModel>()
.Concat(pFields).Concat(model.Events)
.Concat(model.Properties).Concat(model.Methods);
var instanceMembers = new List <IMemberDeclarationModel>();
var staticMembers = new List <IMemberDeclarationModel>();
// separate instance and static members
foreach (var item in members)
{
if (item.IsStatic)
{
staticMembers.Add(item);
}
else
{
instanceMembers.Add(item);
}
}
// write instance members
if (instanceMembers.Any())
{
context.PrepareForDeclarations(model.Definition.Name);
context.EnsureLineBreak();
foreach (var item in instanceMembers)
{
context.WriteModel(item);
}
}
// apply interfaces
if (model.Definition.Interfaces.Any())
{
context.Write("Blade.impl(" + model.Definition.Name);
foreach (var def in model.Definition.Interfaces)
{
context.Write(", '" + def.GetFullName() + "'");
}
context.WriteLine(");");
}
// return class constructor and end closure
context.EnsureLineBreak();
context.WriteLine("return " + model.Definition.Name + ";");
context.Unindent();
context.WriteLine("})();");
// write static members as global statements
foreach (var item in staticMembers)
{
CompilationContext.Current.Model.GlobalStatements.Add(item);
context.WriteModel(item);
}
// if the class has a static constructor, add to globals
var staticCtor = model.Constructors.FirstOrDefault(c => c.IsStatic);
if (staticCtor != null)
{
staticCtor.Body.HasBraces = false;
CompilationContext.Current.Model.GlobalStatements.Add(staticCtor.Body);
}
}
public override void Translate(InitializerExpression model, TranslationContext context)
{
context.Write("[");
context.WriteModels(model.Expressions, ", ");
context.Write("]");
}
