//-----------------------------------------------------------------------------------------------------------------------------------------------------
private EnumMemberDeclarationSyntax ToEnumMemberSyntax(EnumMember member)
{
var syntax = SyntaxFactory.EnumMemberDeclaration(SyntaxFactory.Identifier(member.Name));
if (member.Value != null)
{
syntax = syntax.WithEqualsValue(SyntaxFactory.EqualsValueClause(SyntaxHelpers.GetLiteralSyntax(member.Value)));
}
return(syntax);
}
public static AttributeSyntax EmitSyntax(AttributeDescription description)
{
var syntax = SyntaxFactory.Attribute(SyntaxHelpers.GetTypeFullNameSyntax(description.AttributeType, stripSuffix: "Attribute"));
if (description.ConstructorArguments.Count > 0 || description.PropertyValues.Count > 0)
{
syntax = syntax
.WithArgumentList(
SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(
description.ConstructorArguments.Select(arg =>
SyntaxFactory.AttributeArgument(SyntaxHelpers.GetLiteralSyntax(arg)))
.Concat(description.PropertyValues.Select(pv =>
SyntaxFactory.AttributeArgument(ExpressionSyntaxEmitter.EmitSyntax(pv.Value))
.WithNameEquals(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(pv.Name)))
))
)
)
);
}
return(syntax);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected BaseTypeSyntax ToBaseTypeSyntax(TypeMember baseTypeMember)
{
return(SyntaxFactory.SimpleBaseType(SyntaxHelpers.GetTypeFullNameSyntax(baseTypeMember)));
}
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}'.");
}
}
