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}'.");
}
}
