public static Dictionary <string, string> GetCsScalaAttribute(SyntaxNode node)
{
AttributeSyntax attr = null;
while (node != null)
{
if (node is BaseMethodDeclarationSyntax || node is BaseTypeDeclarationSyntax || node is BaseFieldDeclarationSyntax)
{
var list = node is BaseMethodDeclarationSyntax?node.As <BaseMethodDeclarationSyntax>().AttributeLists
: node is BaseTypeDeclarationSyntax?node.As <BaseTypeDeclarationSyntax>().AttributeLists
: node.As <BaseFieldDeclarationSyntax>().AttributeLists;
attr = list.SelectMany(o => o.Attributes).SingleOrDefault(o => o.Name.ToString() == "CsScala");
if (attr != null)
{
break;
}
}
node = node.Parent;
}
if (attr == null || attr.ArgumentList == null)
{
return(new Dictionary <string, string>());
}
return(attr.ArgumentList.Arguments.ToDictionary(GetAttributeName, o => o.Expression.As <LiteralExpressionSyntax>().Token.ValueText));
}
public static AttributeSyntax GetAttribute(this SyntaxNode node, INamedTypeSymbol name)
{
AttributeSyntax attr = null;
if (node is BaseMethodDeclarationSyntax || node is BaseTypeDeclarationSyntax ||
node is BaseFieldDeclarationSyntax)
{
var list = (node is BaseMethodDeclarationSyntax
? node.As <BaseMethodDeclarationSyntax>().AttributeLists
: node is BaseTypeDeclarationSyntax
? node.As <BaseTypeDeclarationSyntax>().AttributeLists
: node.As <BaseFieldDeclarationSyntax>().AttributeLists).ToList();
if (list.Count > 0)
{
attr =
list.SelectMany(o => o.Attributes)
.SingleOrDefault(o => TypeProcessor.TryGetTypeSymbol(o) == name);
if (attr != null)
{
return(attr);
}
}
}
return(null);
}
public static string Descriptor(SyntaxNode node)
{
var sb = new StringBuilder();
sb.Append(node.Span.ToString() + " ");
while (node != null)
{
if (node is BaseTypeDeclarationSyntax)
{
sb.Append("Type: " + node.As <BaseTypeDeclarationSyntax>().Identifier.ValueText + ", ");
}
else if (node is MethodDeclarationSyntax)
{
sb.Append("Method: " + node.As <MethodDeclarationSyntax>().Identifier.ValueText + ", ");
}
else if (node is PropertyDeclarationSyntax)
{
sb.Append("Property: " + node.As <PropertyDeclarationSyntax>().Identifier.ValueText + ", ");
}
node = node.Parent;
}
if (sb.Length > 2)
{
sb.Remove(sb.Length - 2, 2);
}
return(sb.ToString());
}
public static ParameterSyntax FindParameterSyntax(this SyntaxNode node)
{
return((node as ParameterSyntax)
?? (node.As <TypeSyntax>()?.Parent.As <ParameterSyntax>())
?? (node.As <TypeSyntax>()?.As <TypeSyntax>()?.Parent.As <ParameterSyntax>())
?? (node.As <IdentifierNameSyntax>()?.Parent.As <ParameterSyntax>())
?? (node.As <SimpleNameSyntax>()?.Parent.As <ParameterSyntax>()));
}
public static string GetValue(this SyntaxNode node, SyntaxNode root)
{
if (node == null)
{
return(null);
}
switch (node.Type)
{
case SyntaxNodes.Identifier:
var referencedNode = root.GetIdentifierNode(node.As <Identifier>().Name);
if (referencedNode != null)
{
return(referencedNode.GetValue(root));
}
break;
case SyntaxNodes.Literal:
return(((Literal)node).Value as string);
default:
throw new ArgumentOutOfRangeException(nameof(node.Type));
}
return(null);
}
private IEnumerable <string> ExtractReferencesFromArgument(string fromModule, SyntaxNode expression)
{
if (expression == null)
{
return(Enumerable.Empty <string>());
}
var array = expression.As <ArrayExpression>();
return(array.Elements
.Where(element => element.Type == SyntaxNodes.Literal)
.Select(element => GetAbsoluteReference(fromModule, element))
.Where(referencedScript => referencedScript != null));
}
public static string HaxeLiteral(this SyntaxNode literal)
{
if (literal is ArgumentSyntax)
{
return(HaxeLiteral(literal.As <ArgumentSyntax>().Expression));
}
else if (literal is LiteralExpressionSyntax)
{
return(literal.ToString());
}
else
{
throw new Exception("Need handler for " + literal.GetType().Name);
}
}
private static void FindReturnStatements(SyntaxNode node, List <ReturnStatementSyntax> ret)
{
if (node is ParenthesizedLambdaExpressionSyntax || node is SimpleLambdaExpressionSyntax)
{
return; //any returns in a sub-lambda will be for that lambda. Ignore them.
}
if (node is ReturnStatementSyntax)
{
ret.Add(node.As <ReturnStatementSyntax>());
}
foreach (var child in node.ChildNodes())
{
FindReturnStatements(child, ret);
}
}
public static T FindParent <T>(this SyntaxNode syntaxNode) where T : SyntaxNode
{
if (syntaxNode == null)
{
throw new ArgumentNullException(nameof(syntaxNode));
}
var currentNode = syntaxNode;
var result = syntaxNode.As <T>();
while (result == null && currentNode != null)
{
result = currentNode.Parent.As <T>();
currentNode = currentNode.Parent;
}
return(result);
}
internal static T StatementAs <T>(this SyntaxNode node) where T : ExpressionSyntax
{
var expression = node.As <ExpressionStatementSyntax>().Expression;
return(expression.As <T>());
}
private static void Factory(OutputWriter writer, SyntaxNode node, bool isConst)
{
if (node is ConstructorInitializerSyntax)
{
WriteConstructorInitializer.Go(writer, node.As <ConstructorInitializerSyntax>());
}
else if (node is CheckedExpressionSyntax)
{
WriteChecked.Go(writer, node.As <CheckedExpressionSyntax>());
}
else if (node is CheckedStatementSyntax)
{
WriteChecked.Go(writer, node.As <CheckedStatementSyntax>());
}
else if (node is UnsafeStatementSyntax)
{
WriteUnsafeStatement.Go(writer, node.As <UnsafeStatementSyntax>());
}
else if (node is InitializerExpressionSyntax)
{
WriteInitializer.Go(writer, node.As <InitializerExpressionSyntax>());
}
else if (node is GotoStatementSyntax)
{
WriteGoto.Go(writer, node.As <GotoStatementSyntax>());
}
else if (node is CaseSwitchLabelSyntax)
{
WriteLabel.Go(writer, node.As <CaseSwitchLabelSyntax>());
}
else if (node is LabeledStatementSyntax)
{
WriteLabel.Go(writer, node.As <LabeledStatementSyntax>());
}
else if (node is OperatorDeclarationSyntax)
{
WriteOperatorDeclaration.Go(writer, node.As <OperatorDeclarationSyntax>());
}
else if (node is MethodDeclarationSyntax)
{
WriteMethod.Go(writer, node.As <MethodDeclarationSyntax>());
}
else if (node is PropertyDeclarationSyntax)
{
WriteProperty.Go(writer, node.As <PropertyDeclarationSyntax>());
}
else if (node is EventDeclarationSyntax)
{
WriteEvent.Go(writer, node.As <EventDeclarationSyntax>());
}
else if (node is FieldDeclarationSyntax)
{
WriteField.Go(writer, node.As <FieldDeclarationSyntax>());
}
else if (node is EventFieldDeclarationSyntax)
{
WriteField.Go(writer, node.As <EventFieldDeclarationSyntax>());
}
else if (node is ConstructorDeclarationSyntax)
{
WriteConstructorBody.Go(writer, node.As <ConstructorDeclarationSyntax>());
}
else if (node is ExpressionStatementSyntax)
{
WriteStatement(writer, node.As <ExpressionStatementSyntax>());
}
else if (node is FixedStatementSyntax)
{
WriteFixedStatement(writer, node.As <FixedStatementSyntax>());
}
else if (node is LocalDeclarationStatementSyntax)
{
WriteLocalDeclaration.Go(writer, node.As <LocalDeclarationStatementSyntax>());
}
else if (node is VariableDeclarationSyntax)
{
WriteVariableDeclaration.Go(writer, node.As <VariableDeclarationSyntax>());
}
else if (node is BlockSyntax)
{
WriteBlock(writer, node.As <BlockSyntax>());
}
else if (node is InvocationExpressionSyntax)
{
WriteInvocationExpression.Go(writer, node.As <InvocationExpressionSyntax>());
}
else if (node is LiteralExpressionSyntax)
{
WriteLiteralExpression.Go(writer, node.As <LiteralExpressionSyntax>(), isConst);
}
else if (node is IdentifierNameSyntax)
{
WriteIdentifierName.Go(writer, node.As <IdentifierNameSyntax>());
}
else if (node is ImplicitArrayCreationExpressionSyntax)
{
WriteArrayCreationExpression.Go(writer, node.As <ImplicitArrayCreationExpressionSyntax>());
}
else if (node is ArrayCreationExpressionSyntax)
{
WriteArrayCreationExpression.Go(writer, node.As <ArrayCreationExpressionSyntax>());
}
else if (node is MemberAccessExpressionSyntax)
{
WriteMemberAccessExpression.Go(writer, node.As <MemberAccessExpressionSyntax>());
}
else if (node is ParenthesizedLambdaExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <ParenthesizedLambdaExpressionSyntax>());
}
else if (node is SimpleLambdaExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <SimpleLambdaExpressionSyntax>());
}
else if (node is AnonymousMethodExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <AnonymousMethodExpressionSyntax>());
}
else if (node is ReturnStatementSyntax)
{
WriteReturnStatement.Go(writer, node.As <ReturnStatementSyntax>());
}
else if (node is ObjectCreationExpressionSyntax)
{
WriteObjectCreationExpression.Go(writer, node.As <ObjectCreationExpressionSyntax>());
}
else if (node is ElementAccessExpressionSyntax)
{
WriteElementAccessExpression.Go(writer, node.As <ElementAccessExpressionSyntax>());
}
else if (node is ForEachStatementSyntax)
{
WriteForEachStatement.Go(writer, node.As <ForEachStatementSyntax>());
}
else if (node is IfStatementSyntax)
{
WriteIfStatement.Go(writer, node.As <IfStatementSyntax>());
}
else if (node is BinaryExpressionSyntax)
{
WriteBinaryExpression.Go(writer, node.As <BinaryExpressionSyntax>());
}
else if (node is AssignmentExpressionSyntax)
{
WriteAssignmentExpression.Go(writer, node.As <AssignmentExpressionSyntax>());
}
else if (node is ConditionalExpressionSyntax)
{
WriteConditionalExpression.Go(writer, node.As <ConditionalExpressionSyntax>());
}
else if (node is BaseExpressionSyntax)
{
WriteBaseExpression.Go(writer, node.As <BaseExpressionSyntax>());
}
else if (node is ThisExpressionSyntax)
{
WriteThisExpression.Go(writer, node.As <ThisExpressionSyntax>());
}
else if (node is CastExpressionSyntax)
{
WriteCastExpression.Go(writer, node.As <CastExpressionSyntax>());
}
else if (node is ThrowStatementSyntax)
{
WriteThrowStatement.Go(writer, node.As <ThrowStatementSyntax>());
}
else if (node is EqualsValueClauseSyntax)
{
WriteEqualsValueClause.Go(writer, node.As <EqualsValueClauseSyntax>());
}
else if (node is ForStatementSyntax)
{
WriteForStatement.Go(writer, node.As <ForStatementSyntax>());
}
else if (node is WhileStatementSyntax)
{
WriteWhileStatement.Go(writer, node.As <WhileStatementSyntax>());
}
else if (node is BreakStatementSyntax)
{
WriteBreakStatement.Go(writer, node.As <BreakStatementSyntax>());
}
else if (node is ContinueStatementSyntax)
{
WriteContinueStatement.Go(writer, node.As <ContinueStatementSyntax>());
}
else if (node is DoStatementSyntax)
{
WriteDoStatement.Go(writer, node.As <DoStatementSyntax>());
}
else if (node is SwitchStatementSyntax)
{
WriteSwitchStatement.Go(writer, node.As <SwitchStatementSyntax>());
}
else if (node is TryStatementSyntax)
{
WriteTryStatement.Go(writer, node.As <TryStatementSyntax>());
}
else if (node is UsingStatementSyntax)
{
WriteUsingStatement.Go(writer, node.As <UsingStatementSyntax>());
}
else if (node is ParenthesizedExpressionSyntax)
{
WriteParenthesizedExpression.Go(writer, node.As <ParenthesizedExpressionSyntax>());
}
else if (node is LockStatementSyntax)
{
WriteLockStatement.Go(writer, node.As <LockStatementSyntax>());
}
else if (node is TypeOfExpressionSyntax)
{
WriteTypeOfExpression.Go(writer, node.As <TypeOfExpressionSyntax>());
}
else if (node is AnonymousObjectCreationExpressionSyntax)
{
WriteAnonymousObjectCreationExpression.Go(writer, node.As <AnonymousObjectCreationExpressionSyntax>());
}
else if (node is EmptyStatementSyntax)
{
return; //ignore empty statements
}
else if (node is DelegateDeclarationSyntax)
{
return; //don't write delegates - TypeProcessor converts them to function types directly
}
else if (node is DefaultExpressionSyntax)
{
WriteDefaultExpression.Go(writer, node.As <DefaultExpressionSyntax>());
}
else if (node is GenericNameSyntax)
{
WriteGenericName.Go(writer, node.As <GenericNameSyntax>());
}
else if (node is ConversionOperatorDeclarationSyntax)
{
WriteConversionOperatorDeclaration.Go(writer, node.As <ConversionOperatorDeclarationSyntax>());
}
else if (node is PrefixUnaryExpressionSyntax)
{
WriteUnaryExpression.WritePrefix(writer, node.As <PrefixUnaryExpressionSyntax>());
}
else if (node is PostfixUnaryExpressionSyntax)
{
WriteUnaryExpression.WritePostfix(writer, node.As <PostfixUnaryExpressionSyntax>());
}
else if (node is SizeOfExpressionSyntax)
{
WriteSizeOfExpression.Go(writer, node.As <SizeOfExpressionSyntax>());
}
else if (node is DestructorDeclarationSyntax)
{
WriteDestructorBody.WriteDestructor(writer, node.As <DestructorDeclarationSyntax>());
}
else if (node is IndexerDeclarationSyntax)
{
WriteIndexer.Go(writer, node.As <IndexerDeclarationSyntax>());
}
else if (node is StackAllocArrayCreationExpressionSyntax)
{
WriteStackArrayCreation.Go(writer, node.As <StackAllocArrayCreationExpressionSyntax>());
}
// writer.Write(node.ToFullString() + "//TODO: StackAlloc not supported yet");
else if (node is YieldStatementSyntax)
{
WriteYieldStatement.Go(writer, node.As <YieldStatementSyntax>());
}
else
{
throw new NotImplementedException(node.GetType().Name + " is not supported. " + Utility.Descriptor(node));
}
}
private string GetAbsoluteReference(string sourceReference, SyntaxNode required)
{
return(_referenceResolver.ResolveToModule(sourceReference, required.As <Literal>().Value as string));
}
private string GetAbsoluteReference(string sourceReference, SyntaxNode required)
{
return _referenceResolver.ResolveToModule(sourceReference, required.As<Literal>().Value as string);
}
private IEnumerable<string> ExtractReferencesFromArgument(string fromModule, SyntaxNode expression)
{
if (expression == null)
{
return Enumerable.Empty<string>();
}
var array = expression.As<ArrayExpression>();
return array.Elements
.Where(element => element.Type == SyntaxNodes.Literal)
.Select(element => GetAbsoluteReference(fromModule, element))
.Where(referencedScript => referencedScript != null);
}
private static void Go(ScalaWriter writer, IEnumerable <ParameterSyntax> parameters, SyntaxNode body, TypeInfo type)
{
var methodSymbol = type.ConvertedType.As <INamedTypeSymbol>().DelegateInvokeMethod.As <IMethodSymbol>();
writer.Write("(");
for (int pi = 0; pi < parameters.Count(); pi++)
{
var parameter = parameters.ElementAt(pi);
if (pi > 0)
{
writer.Write(", ");
}
writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Identifier.ValueText));
if (parameter.Type != null)
{
writer.Write(TypeProcessor.ConvertTypeWithColon(parameter.Type));
}
else
{
writer.Write(TypeProcessor.ConvertTypeWithColon(methodSymbol.Parameters[pi].Type));
}
}
writer.Write(") => ");
bool returnsVoid = methodSymbol.ReturnType.ToString() == "void";
if (body is BlockSyntax)
{
writer.Write("\r\n");
writer.WriteOpenBrace();
var statements = body.As <BlockSyntax>().Statements;
var lastStatement = statements.LastOrDefault() as ReturnStatementSyntax;
var returnStatements = FindReturnStatements(body);
if (returnStatements.Count > 0 && (lastStatement == null || returnStatements.Except(lastStatement).Any()))
{
//Lambda has branching returns. We must use a breakable block since scala can't return from a lambda like C# can
TypeState.Instance.InLambdaBreakable++;
writer.WriteLine("val __lambdabreak = new Breaks;");
if (!returnsVoid)
{
writer.WriteIndent();
writer.Write("var __lambdareturn:");
writer.Write(TypeProcessor.ConvertType(methodSymbol.ReturnType));
writer.Write(" = ");
writer.Write(TypeProcessor.DefaultValue(methodSymbol.ReturnType));
writer.Write(";\r\n");
}
writer.WriteLine("__lambdabreak.breakable");
writer.WriteOpenBrace();
foreach (var statement in statements)
{
if (statement == lastStatement && !returnsVoid)
{
//Manually write it so we avoid the final break that WriteReturnStatement does
writer.WriteIndent();
writer.Write("__lambdareturn = ");
Core.Write(writer, lastStatement.Expression);
writer.Write(";\r\n");
}
else
{
Core.Write(writer, statement);
}
}
TriviaProcessor.ProcessTrivias(writer, body.DescendantTrivia());
writer.WriteCloseBrace();
if (!returnsVoid)
{
writer.WriteLine("__lambdareturn;");
}
TypeState.Instance.InLambdaBreakable--;
}
else
{
foreach (var statement in statements)
{
if (statement == lastStatement)
{
writer.WriteIndent();
Core.Write(writer, lastStatement.Expression);
writer.Write(";\r\n");
}
else
{
Core.Write(writer, statement);
}
}
}
writer.Indent--;
writer.WriteIndent();
writer.Write("}");
}
else
{
writer.Write(" { ");
Core.Write(writer, body);
writer.Write("; }");
}
if (!returnsVoid)
{
writer.Write(TypeProcessor.ConvertTypeWithColon(methodSymbol.ReturnType));
}
}
private static void Factory(HaxeWriter writer, SyntaxNode node)
{
if (node is MethodDeclarationSyntax)
{
WriteMethod.Go(writer, node.As <MethodDeclarationSyntax>());
}
else if (node is PropertyDeclarationSyntax)
{
WriteProperty.Go(writer, node.As <PropertyDeclarationSyntax>());
}
else if (node is FieldDeclarationSyntax)
{
WriteField.Go(writer, node.As <FieldDeclarationSyntax>());
}
else if (node is ConstructorDeclarationSyntax)
{
WriteConstructor.Go(writer, node.As <ConstructorDeclarationSyntax>());
}
else if (node is ExpressionStatementSyntax)
{
WriteStatement(writer, node.As <ExpressionStatementSyntax>());
}
else if (node is LocalDeclarationStatementSyntax)
{
WriteLocalDeclaration.Go(writer, node.As <LocalDeclarationStatementSyntax>());
}
else if (node is BlockSyntax)
{
WriteBlock(writer, node.As <BlockSyntax>());
}
else if (node is InvocationExpressionSyntax)
{
WriteInvocationExpression.Go(writer, node.As <InvocationExpressionSyntax>());
}
else if (node is LiteralExpressionSyntax)
{
WriteLiteralExpression.Go(writer, node.As <LiteralExpressionSyntax>());
}
else if (node is IdentifierNameSyntax)
{
WriteIdentifierName.Go(writer, node.As <IdentifierNameSyntax>());
}
else if (node is ImplicitArrayCreationExpressionSyntax)
{
WriteArrayCreationExpression.Go(writer, node.As <ImplicitArrayCreationExpressionSyntax>());
}
else if (node is ArrayCreationExpressionSyntax)
{
WriteArrayCreationExpression.Go(writer, node.As <ArrayCreationExpressionSyntax>());
}
else if (node is MemberAccessExpressionSyntax)
{
WriteMemberAccessExpression.Go(writer, node.As <MemberAccessExpressionSyntax>());
}
else if (node is ParenthesizedLambdaExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <ParenthesizedLambdaExpressionSyntax>());
}
else if (node is SimpleLambdaExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <SimpleLambdaExpressionSyntax>());
}
else if (node is ReturnStatementSyntax)
{
WriteReturnStatement.Go(writer, node.As <ReturnStatementSyntax>());
}
else if (node is ObjectCreationExpressionSyntax)
{
WriteObjectCreationExpression.Go(writer, node.As <ObjectCreationExpressionSyntax>());
}
else if (node is ElementAccessExpressionSyntax)
{
WriteElementAccessExpression.Go(writer, node.As <ElementAccessExpressionSyntax>());
}
else if (node is ForEachStatementSyntax)
{
WriteForEachStatement.Go(writer, node.As <ForEachStatementSyntax>());
}
else if (node is IfStatementSyntax)
{
WriteIfStatement.Go(writer, node.As <IfStatementSyntax>());
}
else if (node is BinaryExpressionSyntax)
{
WriteBinaryExpression.Go(writer, node.As <BinaryExpressionSyntax>());
}
else if (node is ConditionalExpressionSyntax)
{
WriteConditionalExpression.Go(writer, node.As <ConditionalExpressionSyntax>());
}
else if (node is BaseExpressionSyntax)
{
WriteBaseExpression.Go(writer, node.As <BaseExpressionSyntax>());
}
else if (node is ThisExpressionSyntax)
{
WriteThisExpression.Go(writer, node.As <ThisExpressionSyntax>());
}
else if (node is CastExpressionSyntax)
{
WriteCastExpression.Go(writer, node.As <CastExpressionSyntax>());
}
else if (node is ThrowStatementSyntax)
{
WriteThrowStatement.Go(writer, node.As <ThrowStatementSyntax>());
}
else if (node is ThrowExpressionSyntax)
{
WriteThrowStatement.GoExpression(writer, node.As <ThrowExpressionSyntax>());
}
else if (node is PrefixUnaryExpressionSyntax)
{
WriteUnaryExpression.Go(writer, node.As <PrefixUnaryExpressionSyntax>());
}
else if (node is PostfixUnaryExpressionSyntax)
{
WriteUnaryExpression.Go(writer, node.As <PostfixUnaryExpressionSyntax>());
}
else if (node is EqualsValueClauseSyntax)
{
WriteEqualsValueClause.Go(writer, node.As <EqualsValueClauseSyntax>());
}
else if (node is ForStatementSyntax)
{
WriteForStatement.Go(writer, node.As <ForStatementSyntax>());
}
else if (node is WhileStatementSyntax)
{
WriteWhileStatement.Go(writer, node.As <WhileStatementSyntax>());
}
else if (node is BreakStatementSyntax)
{
WriteBreakStatement.Go(writer, node.As <BreakStatementSyntax>());
}
else if (node is DoStatementSyntax)
{
WriteDoStatement.Go(writer, node.As <DoStatementSyntax>());
}
else if (node is SwitchStatementSyntax)
{
WriteSwitchStatement.Go(writer, node.As <SwitchStatementSyntax>());
}
else if (node is TryStatementSyntax)
{
WriteTryStatement.Go(writer, node.As <TryStatementSyntax>());
}
else if (node is UsingStatementSyntax)
{
WriteUsingStatement.Go(writer, node.As <UsingStatementSyntax>());
}
else if (node is ParenthesizedExpressionSyntax)
{
WriteParenthesizedExpression.Go(writer, node.As <ParenthesizedExpressionSyntax>());
}
else if (node is LockStatementSyntax)
{
WriteLockStatement.Go(writer, node.As <LockStatementSyntax>());
}
else if (node is ContinueStatementSyntax)
{
WriteContinueStatement.Go(writer, node.As <ContinueStatementSyntax>());
}
else if (node is TypeOfExpressionSyntax)
{
WriteTypeOfExpression.Go(writer, node.As <TypeOfExpressionSyntax>());
}
else if (node is AnonymousObjectCreationExpressionSyntax)
{
WriteAnonymousObjectCreationExpression.Go(writer, node.As <AnonymousObjectCreationExpressionSyntax>());
}
else if (node is EmptyStatementSyntax)
{
return; //ignore empty statements
}
else if (node is DelegateDeclarationSyntax)
{
return; //don't write delegates - we convert them to types directly
}
else if (node is EventFieldDeclarationSyntax)
{
WriteEventFieldDeclaration.Go(writer, node.As <EventFieldDeclarationSyntax>());
}
else if (node is DefaultExpressionSyntax)
{
WriteDefaultExpression.Go(writer, node.As <DefaultExpressionSyntax>());
}
else if (node is GenericNameSyntax)
{
WriteGenericName.Go(writer, node.As <GenericNameSyntax>());
}
else if (node is ConversionOperatorDeclarationSyntax)
{
WriteConversionOperatorDeclaration.Go(writer, node.As <ConversionOperatorDeclarationSyntax>());
}
else if (node is AssignmentExpressionSyntax)
{
WriteAssignmentExpressionSyntax.Go(writer, node.As <AssignmentExpressionSyntax>());
}
else if (node is OperatorDeclarationSyntax)
{
WriteMethod.WriteOperatorDeclaration(writer, node.As <OperatorDeclarationSyntax>());
}
else if (node is IndexerDeclarationSyntax)
{
WriteMethod.WriteIndexerDeclaration(writer, node.As <IndexerDeclarationSyntax>());
}
else
{
throw new NotImplementedException(node.GetType().Name + " is not supported. " + Utility.Descriptor(node));
}
}
private static void Go(OutputWriter writer, IEnumerable <ParameterSyntax> parameters, SyntaxNode body,
TypeInfo type)
{
var methodSymbol = type.ConvertedType.As <INamedTypeSymbol>().DelegateInvokeMethod.As <IMethodSymbol>();
var typeStringNoPtr = TypeProcessor.ConvertType(type.ConvertedType);
if (type.ConvertedType.TypeKind == TypeKind.TypeParameter)
{
writer.Write(" __TypeNew!(" + typeStringNoPtr + ")(");
}
else
{
writer.Write("new " + typeStringNoPtr + "(");
}
writer.Write("(");
var parameterSyntaxs = parameters as ParameterSyntax[] ?? parameters.ToArray();
for (int pi = 0; pi < parameterSyntaxs.Count(); pi++)
{
var parameter = parameterSyntaxs.ElementAt(pi);
if (pi > 0)
{
writer.Write(", ");
}
if (parameter.Type != null)
{
writer.Write(TypeProcessor.ConvertType(parameter.Type) + " ");
}
else
{
writer.Write(TypeProcessor.ConvertType(methodSymbol.Parameters[pi].Type) + " ");
}
writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Identifier.Text));
}
writer.Write(")");
bool returnsVoid = methodSymbol.ReturnType.ToString() == "void";
if (body is BlockSyntax)
{
writer.Write("\r\n");
writer.OpenBrace();
var statements = body.As <BlockSyntax>().Statements;
var lastStatement = statements.LastOrDefault() as ReturnStatementSyntax;
var returnStatements = FindReturnStatements(body);
{
foreach (var statement in statements)
{
if (statement == lastStatement)
{
writer.WriteIndent();
Core.Write(writer, lastStatement);
// writer.Write(";\r\n");
}
else
{
Core.Write(writer, statement);
}
}
}
writer.Indent--;
writer.WriteIndent();
writer.Write("}");
}
else
{
if (!returnsVoid)
{
writer.Write("=> ");
Core.Write(writer, body);
}
else
{
writer.Write(" { ");
Core.Write(writer, body);
writer.Write("; }");
}
//writer.Write(" { ");
//if (!returnsVoid)
// writer.Write ("return ");
// writer.Write("; }");
}
// if (!returnsVoid)
// writer.Write(TypeProcessor.ConvertTypeWithColon(methodSymbol.ReturnType));
writer.Write(")");
}
public static void Walk <T>(this SyntaxNode node, Action <T> f) where T : SyntaxNode
{
while (true)
{
if (node == null)
{
return;
}
var matchingType = node as T;
if (matchingType != null)
{
f?.Invoke(matchingType);
}
switch (node.Type)
{
case SyntaxNodes.AssignmentExpression:
var assignment = node.As <AssignmentExpression>();
Walk(assignment.Left, f);
node = assignment.Right;
continue;
case SyntaxNodes.ArrayExpression:
var array = node.As <ArrayExpression>();
Walk(array.Elements, f);
break;
case SyntaxNodes.BinaryExpression:
var binaryExpression = node.As <BinaryExpression>();
Walk(binaryExpression.Left, f);
node = binaryExpression.Right;
continue;
case SyntaxNodes.CallExpression:
var callExpr = node.As <CallExpression>();
Walk(callExpr.Callee, f);
Walk(callExpr.Arguments, f);
break;
case SyntaxNodes.CatchClause:
var catchClause = node.As <CatchClause>();
Walk(catchClause.Param, f);
node = catchClause.Body;
continue;
case SyntaxNodes.ConditionalExpression:
var conditional = node.As <ConditionalExpression>();
Walk(conditional.Test, f);
Walk(conditional.Alternate, f);
node = conditional.Consequent;
continue;
case SyntaxNodes.FunctionDeclaration:
var function = node.As <FunctionDeclaration>();
Walk(function.Defaults, f);
Walk(function.Body, f);
Walk(function.Rest, f);
Walk(function.Defaults, f);
Walk(function.Parameters, f);
Walk(function.FunctionDeclarations, f);
Walk(function.VariableDeclarations, f);
break;
case SyntaxNodes.FunctionExpression:
var functionExpr = node.As <FunctionExpression>();
Walk(functionExpr.Defaults, f);
Walk(functionExpr.Body, f);
Walk(functionExpr.Rest, f);
Walk(functionExpr.Defaults, f);
Walk(functionExpr.Parameters, f);
Walk(functionExpr.FunctionDeclarations, f);
Walk(functionExpr.VariableDeclarations, f);
break;
case SyntaxNodes.Identifier:
break;
case SyntaxNodes.Literal:
case SyntaxNodes.RegularExpressionLiteral:
break;
case SyntaxNodes.LogicalExpression:
var logicalExpr = node.As <LogicalExpression>();
Walk(logicalExpr.Left, f);
node = logicalExpr.Right;
continue;
case SyntaxNodes.MemberExpression:
var memberExpr = node.As <MemberExpression>();
Walk(memberExpr.Object, f);
node = memberExpr.Property;
continue;
case SyntaxNodes.NewExpression:
var newExpr = node.As <NewExpression>();
Walk(newExpr.Arguments, f);
node = newExpr.Callee;
continue;
case SyntaxNodes.ObjectExpression:
var objExpr = node.As <ObjectExpression>();
Walk(objExpr.Properties.Select(p => p.Value), f);
break;
case SyntaxNodes.Program:
var program = node.As <Program>();
Walk(program.FunctionDeclarations, f);
Walk(program.VariableDeclarations, f);
Walk(program.Body, f);
break;
case SyntaxNodes.Property:
var property = node.As <Property>();
node = property.Value;
continue;
case SyntaxNodes.SequenceExpression:
var sequence = node.As <SequenceExpression>();
Walk(sequence.Expressions, f);
break;
case SyntaxNodes.SwitchCase:
break;
case SyntaxNodes.ThisExpression:
break;
case SyntaxNodes.UnaryExpression:
var unary = node.As <UnaryExpression>();
node = unary.Argument;
continue;
case SyntaxNodes.UpdateExpression:
var update = node.As <UpdateExpression>();
node = update.Argument;
continue;
case SyntaxNodes.VariableDeclaration:
var variable = node.As <VariableDeclaration>();
Walk(variable.Declarations, f);
break;
case SyntaxNodes.VariableDeclarator:
var declarator = node.As <VariableDeclarator>();
node = declarator.Init;
continue;
case SyntaxNodes.BlockStatement:
var block = node.As <BlockStatement>();
Walk(block.Body, f);
break;
case SyntaxNodes.BreakStatement:
break;
case SyntaxNodes.ContinueStatement:
break;
case SyntaxNodes.DoWhileStatement:
var doWhile = node.As <DoWhileStatement>();
Walk(doWhile.Test, f);
node = doWhile.Body;
continue;
case SyntaxNodes.DebuggerStatement:
break;
case SyntaxNodes.EmptyStatement:
break;
case SyntaxNodes.ExpressionStatement:
var expr = node.As <ExpressionStatement>();
node = expr.Expression;
continue;
case SyntaxNodes.ForStatement:
var forStatement = node.As <ForStatement>();
Walk(forStatement.Init, f);
Walk(forStatement.Test, f);
node = forStatement.Update;
continue;
case SyntaxNodes.ForInStatement:
var forInStatement = node.As <ForInStatement>();
Walk(forInStatement.Right, f);
Walk(forInStatement.Left, f);
node = forInStatement.Body;
continue;
case SyntaxNodes.IfStatement:
var ifStatement = node.As <IfStatement>();
Walk(ifStatement.Test, f);
Walk(ifStatement.Alternate, f);
node = ifStatement.Consequent;
continue;
case SyntaxNodes.LabeledStatement:
var labeledStatement = node.As <LabelledStatement>();
node = labeledStatement.Body;
continue;
case SyntaxNodes.ReturnStatement:
var returnStatement = node.As <ReturnStatement>();
node = returnStatement.Argument;
continue;
case SyntaxNodes.SwitchStatement:
var switchStatement = node.As <SwitchStatement>();
Walk(switchStatement.Discriminant, f);
foreach (var switchCase in switchStatement.Cases)
{
Walk(switchCase.Test, f);
Walk(switchCase.Consequent, f);
}
break;
case SyntaxNodes.ThrowStatement:
var throwStatement = node.As <ThrowStatement>();
node = throwStatement.Argument;
continue;
case SyntaxNodes.TryStatement:
var tryStatement = node.As <TryStatement>();
Walk(tryStatement.Block, f);
Walk(tryStatement.Finalizer, f);
Walk(tryStatement.GuardedHandlers, f);
Walk(tryStatement.Handlers, f);
break;
case SyntaxNodes.WhileStatement:
var whileStatement = node.As <WhileStatement>();
Walk(whileStatement.Test, f);
node = whileStatement.Body;
continue;
case SyntaxNodes.WithStatement:
var withStatement = node.As <WithStatement>();
Walk(withStatement.Object, f);
node = withStatement.Body;
continue;
default:
throw new ArgumentOutOfRangeException(nameof(node.Type));
}
// NOTE(cbond): Anything that needed further inspection already used 'continue' instead of break
break;
}
}
