public static ExpressionSyntax GetSyntax(AbstractExpression expression) { if (SyntaxFactoryMap.TryGetValue(expression.GetType(), out var factory)) { return(factory(expression)); } throw new NotSupportedException($"Generating syntax tree from '{expression.GetType().Name}' is not supported."); }
public static void WriteExpression(CodeTextBuilder code, AbstractExpression expression) { if (WriterByExpressionType.TryGetValue(expression.GetType(), out var writer)) { writer(code, expression); } else { throw new NotSupportedException( $"Expression of type '{expression.GetType().Name}' is not supported by {nameof(JavaScriptExpressionWriter)}."); } }
public static ExpressionSyntax EmitSyntax(AbstractExpression expression) { if (expression is ConstantExpression constant) { return(SyntaxHelpers.GetLiteralSyntax(constant.Value)); } if (expression is LocalVariableExpression local) { return(IdentifierName(local.Variable.Name)); } if (expression is MethodCallExpression call) { return(EmitMethodCallSyntax(call)); } if (expression is NewObjectExpression newObject) { return(EmitNewObjectSyntax(newObject)); } if (expression is ThisExpression) { return(ThisExpression()); } if (expression is BaseExpression) { return(BaseExpression()); } if (expression is ParameterExpression argument) { return(IdentifierName(argument.Parameter.Name)); } if (expression is AssignmentExpression assignment) { return(AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, EmitSyntax(assignment.Left), EmitSyntax(assignment.Right))); } if (expression is MemberExpression member) { return(MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, EmitSyntax(member.Target), IdentifierName(member.Member?.Name ?? member.MemberName))); } if (expression is NewArrayExpression newArray) { return(EmitNewArraySyntax(newArray)); } if (expression is IndexerExpression indexer) { return(ElementAccessExpression(EmitSyntax(indexer.Target)).WithArgumentList( BracketedArgumentList( SeparatedList <ArgumentSyntax>( indexer.IndexArguments.Select(arg => Argument(EmitSyntax(arg))))))); } if (expression is BinaryExpression binary) { return(BinaryExpression(GetBinaryOperatorKeyword(binary.Operator), EmitSyntax(binary.Left), EmitSyntax(binary.Right))); } //TODO: support other types of expressions throw new NotSupportedException($"Syntax emitter is not supported for expression node of type '{expression.GetType().Name}'."); }
public static ExpressionSyntax EmitSyntax(AbstractExpression expression) { switch (expression) { case null: throw new ArgumentNullException(nameof(expression)); case ConstantExpression constant: return(SyntaxHelpers.GetLiteralSyntax(constant.Value)); case LocalVariableExpression local: return(SyntaxFactory.IdentifierName(local.Variable.Name)); case MethodCallExpression call: return(EmitMethodCallSyntax(call)); case NewObjectExpression newObject: return(EmitNewObjectSyntax(newObject)); case ThisExpression @this: return(SyntaxFactory.ThisExpression()); case BaseExpression @base: return(SyntaxFactory.BaseExpression()); case ParameterExpression argument: return(SyntaxFactory.IdentifierName(argument.Parameter.Name)); case AssignmentExpression assignment: return(SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, EmitSyntax(assignment.Left.AsExpression()), EmitSyntax(assignment.Right))); case MemberExpression member: var identifierSyntax = SyntaxFactory.IdentifierName(member.Member?.Name ?? member.MemberName); if (member.Target is ThisExpression) { return(identifierSyntax); } return(SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, EmitSyntax(member.Target), identifierSyntax)); case NewArrayExpression newArray: return(EmitNewArraySyntax(newArray)); case IndexerExpression indexer: return(SyntaxFactory.ElementAccessExpression(EmitSyntax(indexer.Target)).WithArgumentList( SyntaxFactory.BracketedArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( indexer.IndexArguments.Select(arg => SyntaxFactory.Argument(EmitSyntax(arg))))))); case BinaryExpression binary: return(SyntaxFactory.BinaryExpression(GetBinaryOperatorKeyword(binary.Operator), EmitSyntax(binary.Left), EmitSyntax(binary.Right))); case UnaryExpression unary: return(EmitUnaryExpression(unary)); case AwaitExpression @await: return(SyntaxFactory.AwaitExpression(EmitSyntax(@await.Expression))); //TODO: support other types of expressions default: throw new NotSupportedException($"Syntax emitter is not supported for expression node of type '{expression.GetType().Name}'."); } }