private static void WriteOverride(IIndentedTextWriterWrapper textWriter, IMethodSymbol symbol)
{
if (symbol.IsOverride)
{
textWriter.WriteLine("override = true,");
}
}
private static void WriteIsParams(IIndentedTextWriterWrapper textWriter, IMethodSymbol symbol)
{
if (symbol.Parameters.LastOrDefault()?.IsParams == true)
{
textWriter.WriteLine("isParams = true,");
}
}
public static void Write(this TryStatementSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.WriteLine("_M.Try(");
textWriter.Indent++;
textWriter.WriteLine("function()");
syntax.Block.Write(textWriter, context);
textWriter.WriteLine("end,");
textWriter.WriteLine("{");
textWriter.Indent++;
syntax.Catches.Write(Write, textWriter, context);
textWriter.Indent--;
textWriter.WriteLine("},");
if (syntax.Finally != null)
{
textWriter.WriteLine("function()");
syntax.Finally.Write(textWriter, context);
textWriter.WriteLine("end");
}
else
{
textWriter.WriteLine("nil");
}
textWriter.Indent--;
textWriter.WriteLine(");");
}
public static void Write(this AccessorDeclarationSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
if (syntax.Body == null)
{
return;
}
textWriter.Write(syntax.Keyword.Text);
textWriter.Write(" = function(element");
var indexerDeclaration = syntax.Parent.Parent as IndexerDeclarationSyntax;
if (indexerDeclaration != null)
{
textWriter.Write(", ");
indexerDeclaration.ParameterList.Parameters.Write(Write, textWriter, context);
}
if (syntax.Keyword.Kind() == SyntaxKind.SetKeyword)
{
textWriter.Write(", value");
}
textWriter.WriteLine(")");
syntax.Body.Write(textWriter, context);
textWriter.WriteLine("end,");
}
private static void WriteGenerics(MethodDeclarationSyntax syntax, IIndentedTextWriterWrapper textWriter)
{
if (syntax.TypeParameterList != null)
{
textWriter.WriteLine("generics = methodGenericsMapping,");
}
}
private static void WriteInitialize(ClassDeclarationSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
if (context.PartialElementState.IsFirst)
{
textWriter.WriteLine("local initialize = function(element, values)");
textWriter.Indent++;
textWriter.WriteLine("if baseInitialize then baseInitialize(element, values); end");
}
foreach (var property in syntax.Members.OfType <PropertyDeclarationSyntax>())
{
property.WriteInitializeValue(textWriter, context);
}
foreach (var field in syntax.Members.OfType <FieldDeclarationSyntax>())
{
field.WriteInitializeValue(textWriter, context);
}
if (context.PartialElementState.IsLast)
{
textWriter.Indent--;
textWriter.WriteLine("end");
}
}
public static void Write(this ElementAccessExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("(");
syntax.Expression.Write(textWriter, context);
textWriter.Write(" % _M.DOT)");
syntax.ArgumentList.Write(textWriter, context);
}
public void WriteInteractionElementReference(T type, IIndentedTextWriterWrapper textWriter)
{
if (this.semanticAdaptor.IsArray(type))
{
textWriter.Write("System.Array[{");
this.WriteTypeReference(this.semanticAdaptor.GetArrayGeneric(type), textWriter);
textWriter.Write("}]");
return;
}
if (this.semanticAdaptor.IsGenericType(type))
{
if (this.semanticAdaptor.IsMethodGeneric(type))
{
textWriter.Write("methodGenerics[methodGenericsMapping['{0}']]", this.semanticAdaptor.GetName(type));
return;
}
textWriter.Write("generics[genericsMapping['{0}']]", this.semanticAdaptor.GetName(type));
return;
}
textWriter.Write(this.semanticAdaptor.GetFullName(type));
if (this.semanticAdaptor.HasTypeGenerics(type))
{
var generics = this.semanticAdaptor.GetGenerics(type);
this.WriteTypeReferences(generics, textWriter);
}
}
private static void TryWriteNameOfOrTypeOf(
this InvocationExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context)
{
switch (syntax.Expression.ToFullString())
{
case "nameof":
var symbol = context.SemanticModel.GetSymbolInfo(syntax.ArgumentList.Arguments.Single().Expression).Symbol;
var typeSymbol = symbol as ITypeSymbol;
if (typeSymbol == null)
{
typeSymbol = ((IParameterSymbol)symbol).Type;
}
if (context.SemanticAdaptor.IsGenericType(typeSymbol))
{
context.TypeReferenceWriter.WriteTypeReference(typeSymbol, textWriter);
textWriter.Write(".name");
}
else
{
textWriter.Write($"\"{context.SemanticAdaptor.GetName(typeSymbol)}\"");
}
break;
case "typeof":
break;
default:
throw new Exception("No symbol found for invocation expression.");
}
}
private static void WriteAsExtensionMethodCall(
InvocationExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context,
IMethodSymbol symbol)
{
textWriter.Write("(({0} % _M.DOT).", context.SemanticAdaptor.GetFullName(symbol.ContainingType));
var signatureTextWriter = textWriter.CreateTextWriterAtSameIndent();
var signatureHasGenerics =
context.SignatureWriter.WriteSignature(
symbol.ReducedFrom.Parameters.Select(p => p.Type).ToArray(),
signatureTextWriter);
if (signatureHasGenerics)
{
textWriter.Write("['");
}
textWriter.Write("{0}_M_{1}_", symbol.Name, symbol.TypeArguments.Length);
if (signatureHasGenerics)
{
textWriter.Write("'..(");
}
textWriter.AppendTextWriter(signatureTextWriter);
if (signatureHasGenerics)
{
textWriter.Write(")]");
}
if (symbol.TypeArguments.Any())
{
context.TypeReferenceWriter.WriteTypeReferences(symbol.TypeArguments.ToArray(), textWriter);
}
textWriter.Write(" % _M.DOT)");
var argWriter = textWriter.CreateTextWriterAtSameIndent();
syntax.ArgumentList.Write(argWriter, context);
var targetWriter = textWriter.CreateTextWriterAtSameIndent();
syntax.Expression.Write(targetWriter, context);
var targetStr = targetWriter.ToString();
textWriter.Write(targetStr.Substring(0, targetStr.LastIndexOf(" % _M.DOT)")));
var argStr = argWriter.ToString();
if (argStr.Length > 2)
{
textWriter.Write(", ");
}
textWriter.Write(argStr.Substring(1)); // Skip the opening (
}
public static void Write(this ConditionalAccessExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context)
{
textWriter.Write("_M.CA(");
syntax.Expression.Write(textWriter, context);
textWriter.Write(",function(obj) return ");
var stringWriter = new StringWriter();
var newTextWriter = new IndentedTextWriterWrapper(stringWriter);
syntax.WhenNotNull.Write(newTextWriter, context);
if (stringWriter.ToString().StartsWith("("))
{
textWriter.Write("((obj % _M.DOT)");
textWriter.Write(newTextWriter.ToString().Substring(1));
}
else
{
textWriter.Write("(obj % _M.DOT)");
textWriter.AppendTextWriter(newTextWriter);
}
textWriter.Write("; end)");
}
public static void Write(PrefixUnaryExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var kind = syntax.Kind();
if (kind == SyntaxKind.UnaryMinusExpression)
{
textWriter.Write("-");
syntax.Operand.Write(textWriter, context);
}
else if (kind == SyntaxKind.UnaryPlusExpression)// TODO handle LogicalNotExpression as well.
{
textWriter.Write("+");
syntax.Operand.Write(textWriter, context);
}
else if (kind == SyntaxKind.LogicalNotExpression)
{
textWriter.Write("not(");
syntax.Operand.Write(textWriter, context);
textWriter.Write(")");
}
else
{
throw new Exception($"Unhandled PrefixUnaryExpressionSyntax kind {kind}.");
}
}
public static void Write(this ConstructorInitializerSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var symbol = (IMethodSymbol)context.SemanticModel.GetSymbolInfo(syntax).Symbol;
if (syntax.Kind() == SyntaxKind.BaseConstructorInitializer)
{
textWriter.Write("(element % _M.DOT_LVL(typeObject.Level - 1))._C_0_");
context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), textWriter);
}
else if (syntax.Kind() == SyntaxKind.ThisConstructorInitializer)
{
textWriter.Write("(element % _M.DOT_LVL(typeObject.Level))");
var signatureWriter = textWriter.CreateTextWriterAtSameIndent();
var hasGenericComponents = context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), signatureWriter);
if (hasGenericComponents)
{
textWriter.Write("['_C_0_'..(");
textWriter.AppendTextWriter(signatureWriter);
textWriter.Write(")]");
}
else
{
textWriter.Write("._C_0_");
textWriter.AppendTextWriter(signatureWriter);
}
}
syntax.ArgumentList.Write(textWriter, context);
textWriter.WriteLine(";");
}
private static void WriteAccessExpression(
MemberAccessExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context)
{
var symbol = context.SemanticModel.GetSymbolInfo(syntax).Symbol;
if (symbol == null)
{
syntax.Expression.Write(textWriter, context);
return;
}
if (symbol is ITypeSymbol)
{
context.TypeReferenceWriter.WriteInteractionElementReference((ITypeSymbol)symbol, textWriter);
return;
}
if (!symbol.IsStatic)
{
syntax.Expression.Write(textWriter, context);
return;
}
context.TypeReferenceWriter.WriteInteractionElementReference(symbol.ContainingType, textWriter);
}
private static void WriteBodyFunc(MethodDeclarationSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context, IMethodSymbol symbol)
{
if (syntax.Body == null)
{
return;
}
textWriter.Write("func = function(element");
if (syntax.TypeParameterList != null)
{
textWriter.Write(", methodGenericsMapping, methodGenerics");
}
syntax.ParameterList.Write(textWriter, context);
textWriter.WriteLine(")");
if (symbol.Parameters.LastOrDefault()?.IsParams == true)
{
textWriter.Indent++;
WriteParamVariableInit(textWriter, context, symbol);
textWriter.Indent--;
}
syntax.Body.Write(textWriter, context);
textWriter.WriteLine("end");
}
private static void WriteBaseInheritance(ITypeSymbol symbol, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("local baseTypeObject, getBaseMembers, baseConstructors, baseElementGenerator, implements, baseInitialize = ");
context.TypeReferenceWriter.WriteInteractionElementReference(symbol.BaseType, textWriter);
textWriter.WriteLine(".__meta(staticValues);");
}
public static void Write(this DefaultExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("_M.DV(");
var symbol = (ITypeSymbol)context.SemanticModel.GetSymbolInfo(syntax.Type).Symbol;
context.TypeReferenceWriter.WriteTypeReference(symbol, textWriter);
textWriter.Write(")");
}
public static void Write(this SwitchStatementSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("local switchValue = ");
syntax.Expression.Write(textWriter, context);
textWriter.WriteLine(";");
syntax.Sections.Write(Write, textWriter, context, () => textWriter.Write("else"));
textWriter.WriteLine("end");
}
public void WriteTypeReference(T type, IIndentedTextWriterWrapper textWriter)
{
this.WriteInteractionElementReference(type, textWriter);
if (!this.semanticAdaptor.IsGenericType(type))
{
textWriter.Write(".__typeof");
}
}
public static void Write(this WhileStatementSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("while (");
syntax.Condition.Write(textWriter, context);
textWriter.WriteLine(") do");
syntax.Statement.Write(textWriter, context);
textWriter.WriteLine("end");
}
private static void WriteClose(IIndentedTextWriterWrapper textWriter, IContext context)
{
if (context.PartialElementState.IsLast)
{
textWriter.WriteLine("return 'Class', typeObject, getMembers, constructors, elementGenerator, nil, initialize;");
textWriter.Indent--;
textWriter.WriteLine("end,");
}
}
public static void Write(this ImplicitArrayCreationExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var typeInfo = context.SemanticModel.GetTypeInfo(syntax);
textWriter.Write("(");
context.TypeReferenceWriter.WriteInteractionElementReference(typeInfo.Type, textWriter);
textWriter.Write("._C_0_0() % _M.DOT)");
syntax.Initializer.Write(textWriter, context);
}
private void WriteFooter(IEnumerable <NamespaceMember> members, IIndentedTextWriterWrapper textWriter)
{
foreach (var classMember in members.Where(member => member.Syntax is ClassDeclarationSyntax))
{
this.context.SemanticModel = classMember.SemanticModel;
this.context.PartialElementState.CurrentState = (int)ClassState.Footer;
classMember.Syntax.Write(textWriter, this.context);
}
}
public static void Write(this SwitchSectionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("if (");
syntax.Labels.Write(Write, textWriter, context, () => textWriter.Write(" or "));
textWriter.WriteLine(") then");
textWriter.Indent++;
syntax.Statements.Write(StatementExtensions.Write, textWriter, context, null, s => !(s is BreakStatementSyntax));
textWriter.Indent--;
}
public static void Write(
this InitializerExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context)
{
// Note, there are 4 different implementations using InitializerExpressionSyntax
if (syntax.Kind() == SyntaxKind.ComplexElementInitializerExpression)
{
textWriter.Write("[");
syntax.Expressions.First().Write(textWriter, context);
textWriter.Write("] = ");
syntax.Expressions.Last().Write(textWriter, context);
return;
}
textWriter.Write(".__Initialize({");
if (syntax.Kind() == SyntaxKind.ArrayInitializerExpression)
{
if (syntax.Expressions.Any())
{
textWriter.Write("[0] = ");
}
}
else if (syntax.Expressions.Count > 1 || GetKind(syntax) == SyntaxKind.CollectionInitializerExpression)
{
textWriter.WriteLine();
}
textWriter.Indent++;
if (GetKind(syntax) == SyntaxKind.CollectionInitializerExpression)
{
syntax.Expressions.Write(
ExpressionExtensions.Write,
textWriter,
context,
() => textWriter.WriteLine(","));
}
else
{
syntax.Expressions.Write(ExpressionExtensions.Write, textWriter, context);
}
textWriter.Indent--;
if (syntax.Kind() == SyntaxKind.ArrayInitializerExpression)
{
}
else if (syntax.Expressions.Count > 1 || GetKind(syntax) == SyntaxKind.CollectionInitializerExpression)
{
textWriter.WriteLine();
}
textWriter.Write("})");
}
public static void Write(
ParenthesizedExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context)
{
textWriter.Write("(");
syntax.Expression.Write(textWriter, context);
textWriter.Write(")");
}
public static void Write(ArrayTypeSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var symbol = (ITypeSymbol)context.SemanticModel.GetSymbolInfo(syntax.ElementType).Symbol;
textWriter.Write("System.Array[{");
context.TypeReferenceWriter.WriteTypeReference(symbol, textWriter);
textWriter.Write("}]");
syntax.RankSpecifiers.Single().Write(textWriter, context);
}
public static void Write(this ForEachStatementSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("for _,{0} in (", syntax.Identifier.Text);
syntax.Expression.Write(textWriter, context);
textWriter.WriteLine(" % _M.DOT).GetEnumerator() do");
syntax.Statement.Write(textWriter, context);
textWriter.WriteLine("end");
}
public static void Write(this ParameterListSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
if (syntax.Parameters.Any() && (syntax.Parent is ConstructorDeclarationSyntax || syntax.Parent is MethodDeclarationSyntax))
{
textWriter.Write(", ");
}
syntax.Parameters.Write(SyntaxNodeExtensions.Write, textWriter, context);
}
private static void WriteSignatureHash(
IIndentedTextWriterWrapper textWriter,
IContext context,
IMethodSymbol symbol)
{
textWriter.Write("signatureHash = ");
context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), textWriter);
textWriter.WriteLine(",");
}
