private static SyntaxNode CreateMethod(SyntaxGenerator generator, Node node, Options options, List <ParameterGenerationInfo> param)
{
return(generator.MethodDeclaration(node.Name == "Type" ? "TypeNode" : node.Name,
param.SelectMany(x => x.Parameters),
null,
SyntaxFactory.ParseTypeName(SharedGeneratorion.RedNodeName(node.Name)),
Accessibility.Public,
DeclarationModifiers.Static,
param.SelectMany(x => x.Code)
.Concat(new[]
{
generator.LocalDeclarationStatement("__green",
generator.ObjectCreationExpression(
SyntaxFactory.ParseTypeName(SharedGeneratorion.GreenNodeName(node.Name)),
param.Select(x => generator.IdentifierName(x.FinalIdentifier)))),
generator.LocalDeclarationStatement("__red", generator.CastExpression(
SyntaxFactory.ParseTypeName(SharedGeneratorion.RedNodeName(node.Name)),
generator.InvocationExpression(
generator.MemberAccessExpression(generator.IdentifierName("__green"),
options.CreateRed), generator.LiteralExpression(null),
generator.LiteralExpression(0)))),
generator.ReturnStatement(generator.IdentifierName("__red"))
})
));
}
public static SyntaxNode CreateGreenNode(SyntaxGenerator generator, Node node, Options options)
{
List <SyntaxNode> classContents = new List <SyntaxNode>();
foreach (Member type in node.Members)
{
classContents.Add(CreateMember(generator, type));
}
classContents.Add(CreateConstructor(generator, node, options));
classContents.Add(CreateGetChild(generator, node, options));
if (!node.Abstract)
{
classContents.Add(CreateCreateRed(generator, node, options));
}
classContents.Add(CreateRepaceChild(generator, node, options));
return(generator.ClassDeclaration(
SharedGeneratorion.GreenNodeName(node.Name),
modifiers: DeclarationModifiers.None.WithIsAbstract(node.Abstract),
accessibility: Accessibility.Internal,
baseType: SyntaxFactory.ParseTypeName(SharedGeneratorion.GreenNodeName(node.BaseClass)),
members: classContents
));
}
private static SyntaxNode CreateRepaceChild(SyntaxGenerator generator, Node node, Options options)
{
List <SyntaxNode> cases = new List <SyntaxNode>();
cases.AddRange(node.AllChildren()
.Select((c, i) => generator.SwitchSection(
generator.LiteralExpression(i),
new[]
{
generator.ReturnStatement(
generator.ObjectCreationExpression(
SyntaxFactory.ParseTypeName(SharedGeneratorion.GreenNodeName(node.Name)),
node.AllProperties()
.Select(x => generator.Argument(generator.IdentifierName(x.Name)))
.Concat(node.AllChildren()
.Select((q, z) => generator.Argument(
z == i
? generator.CastExpression(
SyntaxFactory.ParseTypeName(
SharedGeneratorion.GreenNodeName(q.Type)),
generator.IdentifierName(options.NewChild))
: generator.IdentifierName(q.Name)
)))
)
)
}
)));
cases.Add(generator.DefaultSwitchSection(new[]
{
generator.ThrowStatement(generator.ObjectCreationExpression(
SyntaxFactory.ParseTypeName(options.InvalidChildReplace)))
}));
SyntaxNode switchStatement = generator.SwitchStatement(generator.IdentifierName(options.Index),
cases);
return(generator.MethodDeclaration(
options.WithReplacedChild,
new[]
{
generator.ParameterDeclaration(options.NewChild, options.GreenBase()),
generator.ParameterDeclaration(options.Index, generator.TypeExpression(SpecialType.System_Int32))
},
null,
options.GreenBase(),
Accessibility.Internal,
DeclarationModifiers.Override,
new[]
{
switchStatement
}
));
}
public static TypeSyntax GreenBase(this Options options)
{
return(SyntaxFactory.ParseTypeName(SharedGeneratorion.GreenNodeName(options.BaseName)));
}