private void EmitInterface(TransportModelInterface model, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(model, ModelType.Transport)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var entityInterface = InterfaceDeclaration(CsEmitterHelper.GetCSharpModelShortName(model, ModelType.Transport));
entityInterface = entityInterface.AddModifiers(Token(SyntaxKind.PublicKeyword));
if (model.GenericParameters.Count > 0)
{
entityInterface = entityInterface.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(model.GenericParameters.Select(p => TypeParameter(p.Key)))));
entityInterface = entityInterface.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(
model.GenericParameters.Select(p =>
TypeParameterConstraintClause(
IdentifierName(p.Key),
SeparatedList <TypeParameterConstraintSyntax>(new[] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetModelGenericParameterConstraintTypeName(p.Value, ModelType.Transport))) })))));
}
List <string> baseTypes = new List <string>();
foreach (var interfaceModel in model.Interfaces)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelFullyQualifiedName(interfaceModel, this.settings, ModelType.Transport));
}
if (baseTypes.Count > 0)
{
entityInterface = entityInterface.WithBaseList(BaseList(SeparatedList <BaseTypeSyntax>(baseTypes.Select(t => SimpleBaseType(ParseTypeName(t))))));
}
entityInterface = entityInterface.WithMembers(List <MemberDeclarationSyntax>(model.Members.Select(m =>
PropertyDeclaration(ParseTypeName(CsEmitterHelper.GetPropertyTypeName(m.Value, this.settings, ModelType.Transport)), NameHelper.GetSafeVariableName(m.Value.Name))
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})))
)));
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsTransportModelNamespace));
nsContainer = nsContainer.AddMembers(entityInterface);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
public void Emit(Parameters parameters, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{ConverterClassName}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var converterClass = ClassDeclaration(ConverterClassName);
converterClass = converterClass.AddModifiers(Token(SyntaxKind.PublicKeyword));
var baseNodeEntity = parameters.TransportModel.TransportModelEntities.First(e => e.Key == settings.AstNodeBaseTypeQualified.Split('.').Last());
var baseNodeInterface = parameters.TransportModel.TransportModelInterfaces.First(e => e.Key == settings.AstNodeBaseTypeQualified.Split('.').Last());
var syntaxKindEnum = parameters.TransportModel.TransportModelEnums.First(e => e.Key == "SyntaxKind");
var conversionMethod = MethodDeclaration(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(baseNodeInterface.Value, this.settings, ModelType.Ast)), this.convertFromNodeMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithParameterList(ParameterList(SeparatedList <ParameterSyntax>(new[] { Parameter(Identifier(this.nodeParameterName)).WithType(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(baseNodeInterface.Value, this.settings, ModelType.Transport))) })))
.WithBody(Block());
conversionMethod = conversionMethod.AddBodyStatements(
IfStatement(
BinaryExpression(SyntaxKind.EqualsExpression, IdentifierName(this.nodeParameterName), IdentifierName("null")),
ReturnStatement(IdentifierName("null")))
);
foreach (var entityModel in parameters.TransportModel.TransportModelEntities.Where(e => e.Value.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind))
{
conversionMethod = conversionMethod.AddBodyStatements(this.EmitForEntity(entityModel.Value, syntaxKindEnum.Value));
}
conversionMethod = conversionMethod.AddBodyStatements(
ExpressionStatement(
ThrowExpression(
ObjectCreationExpression(ParseTypeName(typeof(InvalidOperationException).FullName),
ArgumentList(SeparatedList <ArgumentSyntax>(new[] { Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal("Unable to convert node."))) })),
null
))));
converterClass = converterClass.AddMembers(conversionMethod);
converterClass = converterClass.AddMembers(this.EmitCollectionConversionMethod(baseNodeInterface.Value));
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsAstModelNamespace));
nsContainer = nsContainer.AddMembers(converterClass);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
public static string CreateModelTypeName(ITransportModelTypeReferenceTransportModelItem <TransportModelItem> reference, Settings settings, ModelType modelType, bool useSimpleCollections = false)
{
var typeName = CsEmitterHelper.GetCSharpModelFullyQualifiedName(reference.TransportModelItem, settings, modelType);
if (reference.GenericArguments.Count > 0)
{
typeName += "<" + string.Join(",", reference.GenericArguments.Select(a => GetCSharpModelReferenceName(a, settings, modelType))) + ">";
}
if (reference.IsCollection)
{
string collectionType = settings.CsTransportModelCollectionType;
if (!useSimpleCollections && modelType == ModelType.Ast && !(reference.TransportModelItem is TransportModelEnum))
{
collectionType = settings.CsAstModelNodeCollectionType;
}
typeName = $"{collectionType}<{typeName}>";
}
return(typeName);
}
private void EmitEntity(TransportModelEntity entityModel, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Transport)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var entityClass = ClassDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Transport));
entityClass = entityClass.AddModifiers(Token(SyntaxKind.PublicKeyword));
if (entityModel.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind kindDiscriminant)
{
entityClass = entityClass.AddMembers(
ConstructorDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Transport))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithBody(Block().AddStatements(
ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName("kind")),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName($"{this.settings.CsTransportModelNamespace}.SyntaxKind"),
IdentifierName(kindDiscriminant.SyntaxKindValueName)))))));
}
if (entityModel.GenericParameters.Count > 0)
{
entityClass = entityClass.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(entityModel.GenericParameters.Select(p => TypeParameter(p.Key)))));
entityClass = entityClass.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(
entityModel.GenericParameters.Select(p =>
TypeParameterConstraintClause(
IdentifierName(p.Key),
SeparatedList <TypeParameterConstraintSyntax>(new[] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetModelGenericParameterConstraintTypeName(p.Value, ModelType.Transport))) })))));
}
List <string> baseTypes = new List <string>();
if (entityModel.BaseEntity != null)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelReferenceName(entityModel.BaseEntity, this.settings, ModelType.Transport));
}
foreach (var interfaceModel in entityModel.Interfaces)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelFullyQualifiedName(interfaceModel, this.settings, ModelType.Transport));
}
if (baseTypes.Count > 0)
{
entityClass = entityClass.WithBaseList(BaseList(SeparatedList <BaseTypeSyntax>(baseTypes.Select(t => SimpleBaseType(ParseTypeName(t))))));
}
entityClass = entityClass.AddMembers(entityModel.Members.Select(m =>
PropertyDeclaration(ParseTypeName(CsEmitterHelper.GetPropertyTypeName(m.Value, this.settings, ModelType.Transport)), NameHelper.GetSafeVariableName(m.Value.Name))
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
).ToArray <MemberDeclarationSyntax>());
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsTransportModelNamespace));
nsContainer = nsContainer.AddMembers(entityClass);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
private MethodDeclarationSyntax GenerateConversionMethod(TransportModelEntity entityModel)
{
var members = CsEmitterHelper.GetMembers(entityModel, null, true);
List <ExpressionSyntax> initializers = new List <ExpressionSyntax>();
foreach (var member in members)
{
var propertyName = NameHelper.GetSafeVariableName(member.Key);
if (member.Value.Type is ITransportModelTypeReferenceTransportModelItem <TransportModelItem> itemReference &&
!(itemReference.TransportModelItem is TransportModelEnum))
{
if (itemReference.IsCollection)
{
initializers.Add(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(propertyName),
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
GenericName(
Identifier("GetTransportModelNodes"),
TypeArgumentList(
SeparatedList <TypeSyntax>(
new[]
{
ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(itemReference.TransportModelItem, this.settings, ModelType.Transport))
})))))
.WithArgumentList(ArgumentList(SeparatedList <ArgumentSyntax>(new[] { Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(propertyName))) })))
));
}
else
{
initializers.Add(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(propertyName),
ConditionalExpression(
BinaryExpression(SyntaxKind.NotEqualsExpression, MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(propertyName)), IdentifierName("null")),
CastExpression(ParseTypeName(CsEmitterHelper.GetPropertyTypeName(member.Value, this.settings, ModelType.Transport)),
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(propertyName)),
IdentifierName("GetTransportModelNode")))
.WithArgumentList(ArgumentList())),
IdentifierName("null")
)));
}
}
else
{
initializers.Add(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(propertyName),
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(propertyName))));
}
}
return(MethodDeclaration(ParseTypeName(typeof(object).FullName), "GetTransportModelNode")
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.OverrideKeyword)))
.WithParameterList(ParameterList())
.WithBody(
Block(
List <StatementSyntax>(
new[] {
ReturnStatement(
ObjectCreationExpression(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(entityModel, this.settings, ModelType.Transport)))
.WithArgumentList(ArgumentList())
.WithInitializer(
InitializerExpression(SyntaxKind.ObjectInitializerExpression, SeparatedList <ExpressionSyntax>(initializers))))
}))));
}
private void EmitEntity(TransportModelEntity entityModel, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var entityClass = ClassDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast));
entityClass = entityClass.AddModifiers(Token(SyntaxKind.PublicKeyword));
if (entityModel.TsDiscriminant == null || !(entityModel.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind))
{
entityClass = entityClass.AddModifiers(Token(SyntaxKind.AbstractKeyword));
}
List <StatementSyntax> propertyInitializers = null;
List <ArgumentSyntax> baseConstructorArguments = null;
var constructorDeclaration =
ConstructorDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithParameterList(ParameterList(SeparatedList <ParameterSyntax>(this.GetConstructorParameters(entityModel, out propertyInitializers, out baseConstructorArguments))));
if (baseConstructorArguments != null && baseConstructorArguments.Count > 0)
{
constructorDeclaration = constructorDeclaration.WithInitializer(
ConstructorInitializer(SyntaxKind.BaseConstructorInitializer)
.AddArgumentListArguments(baseConstructorArguments.ToArray()));
}
var constructorBody = Block();
constructorBody = this.PopulateRequiredConstructorBodyInitializers(constructorBody, entityModel);
if (propertyInitializers != null && propertyInitializers.Count > 0)
{
constructorBody = constructorBody.AddStatements(propertyInitializers.ToArray());
}
constructorDeclaration = constructorDeclaration.WithBody(constructorBody);
entityClass = entityClass.AddMembers(constructorDeclaration);
if (constructorDeclaration.ParameterList.Parameters.Count > 0)
{
var parameterlessConstructorDeclaration =
ConstructorDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast))
.AddModifiers(Token(SyntaxKind.PublicKeyword));
var parameterlessConstructorBody = Block();
parameterlessConstructorBody = this.PopulateRequiredConstructorBodyInitializers(parameterlessConstructorBody, entityModel);
parameterlessConstructorDeclaration = parameterlessConstructorDeclaration.WithBody(parameterlessConstructorBody);
entityClass = entityClass.AddMembers(parameterlessConstructorDeclaration);
}
if (entityModel.GenericParameters.Count > 0)
{
entityClass = entityClass.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(entityModel.GenericParameters.Select(p => TypeParameter(p.Key)))));
entityClass = entityClass.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(
entityModel.GenericParameters.Select(p =>
TypeParameterConstraintClause(
IdentifierName(p.Key),
SeparatedList <TypeParameterConstraintSyntax>(new[] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetModelGenericParameterConstraintTypeName(p.Value, ModelType.Ast))) })))));
}
List <string> baseTypes = new List <string>();
if (entityModel.Name == this.settings.AstNodeBaseTypeQualified.Split('.').Last())
{
baseTypes.Add($"{settings.CsAstModelNamespace}.{baseNodeType}");
}
if (entityModel.BaseEntity != null)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelReferenceName(entityModel.BaseEntity, this.settings, ModelType.Ast));
}
foreach (var interfaceModel in entityModel.Interfaces)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelFullyQualifiedName(interfaceModel, this.settings, ModelType.Ast));
}
if (baseTypes.Count > 0)
{
entityClass = entityClass.WithBaseList(BaseList(SeparatedList <BaseTypeSyntax>(baseTypes.Select(t => SimpleBaseType(ParseTypeName(t))))));
}
entityClass = entityClass.AddMembers(
entityModel
.Members
.Where(m => !CsEmitterHelper.IsNodeCollection(m.Value.Type))
.Select(m =>
FieldDeclaration(VariableDeclaration(ParseTypeName(CsEmitterHelper.GetAstModelPropertyTypeName(m.Value, this.settings)), SeparatedList <VariableDeclaratorSyntax>(new[] { VariableDeclarator(this.GetFieldName(m.Key)) })))
).ToArray <MemberDeclarationSyntax>());
entityClass = entityClass.AddMembers(entityModel.Members.Select(m => this.CreatePropertyDeclaration(m.Value)).ToArray <MemberDeclarationSyntax>());
if (entityModel.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind)
{
entityClass = entityClass.AddMembers(this.GenerateConversionMethod(entityModel));
}
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsAstModelNamespace));
nsContainer = nsContainer.AddMembers(entityClass);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
private void EmitTypeMarkerFunction(Parameters parameters, CodeFileTs output)
{
var name = "TypeMarker";
var nodeParameterName = "node";
var typescriptModuleName = "typescript";
var typescriptAliasName = "T";
var typePropertyName = "$type";
var importStatement = new StImportDeclaration()
.WithModuleSpecifier(new StStringLiteral().WithText(typescriptModuleName))
.WithImportClause(c =>
c
.WithNamedBindings(new StNamespaceImport().WithName(new StIdentifier().WithEscapedText(typescriptAliasName)))
);
var classDefinition = new StClassDeclaration()
.WithModifier(new StExportKeywordToken())
.WithName(new StIdentifier().WithEscapedText(name));
var markerFunction = new StMethodDeclaration()
.WithName(new StIdentifier().WithEscapedText("Mark"))
.WithModifier(new StPublicKeywordToken())
.WithType(new StKeywordTypeNodeBooleanKeyword())
.WithBody(b => b)
.WithParameter(p =>
p
.WithName(new StIdentifier().WithEscapedText(nodeParameterName))
.WithType(new StKeywordTypeNodeAnyKeyword()));
foreach (var entity in parameters.TransportModel.TransportModelEntities.Where(e => e.Value.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind))
{
markerFunction.body.WithStatement(
new StIfStatement()
.WithExpression(
new StBinaryExpression()
.WithLeft(new StPropertyAccessExpression()
.WithExpression(new StIdentifier().WithEscapedText(nodeParameterName))
.WithName(new StIdentifier().WithEscapedText("kind")))
.WithOperatorToken(new StEqualsEqualsTokenToken())
.WithRight(new StPropertyAccessExpression()
.WithExpression(new StPropertyAccessExpression().WithExpression(new StIdentifier().WithEscapedText(typescriptAliasName)).WithName(new StIdentifier().WithEscapedText("SyntaxKind")))
.WithName(new StIdentifier().WithEscapedText(((TransportModelEntityTsDiscriminantSyntaxKind)entity.Value.TsDiscriminant).SyntaxKindValueName))))
.WithThenStatement(new StBlock()
.WithStatement(
new StExpressionStatement()
.WithExpression(
new StBinaryExpression()
.WithLeft(
new StPropertyAccessExpression()
.WithExpression(new StIdentifier().WithEscapedText(nodeParameterName))
.WithName(new StIdentifier().WithEscapedText(typePropertyName)))
.WithOperatorToken(new StEqualsTokenToken())
.WithRight(new StStringLiteral()
.WithText($"{CsEmitterHelper.GetCSharpModelFullyQualifiedName(entity.Value, this.settings, ModelType.Transport)}, {this.settings.CsTransportModelAssemblyName}"))))
.WithStatement(
new StReturnStatement()
.WithExpression(new StBooleanLiteralTrueKeyword()))));
}
markerFunction.body
.WithStatement(new StReturnStatement()
.WithExpression(new StBooleanLiteralFalseKeyword()));
classDefinition.members.Add(markerFunction);
output.Model = new StRoot()
.WithStatement(importStatement)
.WithStatement(classDefinition);
}
private MethodDeclarationSyntax EmitCollectionConversionMethod(TransportModelInterface baseNodeInterface)
{
var resultVarName = "result";
var astNodeCollection = $"{this.settings.CsTransportModelCollectionType}<T>";
var ienumerableTypeName = typeof(IEnumerable <>).FullName.Substring(0, typeof(IEnumerable <>).FullName.IndexOf('`'));
var baseNodeIEnumerable = $"{ienumerableTypeName}<{CsEmitterHelper.GetCSharpModelFullyQualifiedName(baseNodeInterface, this.settings, ModelType.Transport)}>";
var conversionMethod = MethodDeclaration(ParseTypeName(astNodeCollection), this.convertFromNodeCollectionMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithParameterList(ParameterList(SeparatedList <ParameterSyntax>(new[] { Parameter(Identifier(this.nodesParameterName)).WithType(ParseTypeName(baseNodeIEnumerable)) })))
.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(new[] { TypeParameter("T") })))
.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(new[]
{
TypeParameterConstraintClause(
IdentifierName("T"),
SeparatedList <TypeParameterConstraintSyntax>(new [] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(baseNodeInterface, this.settings, ModelType.Ast))) }))
}))
.WithBody(Block());
conversionMethod = conversionMethod.AddBodyStatements(
IfStatement(
BinaryExpression(SyntaxKind.EqualsExpression, IdentifierName(this.nodesParameterName), IdentifierName("null")),
ReturnStatement(IdentifierName("null")))
);
conversionMethod = conversionMethod.AddBodyStatements(
LocalDeclarationStatement(
VariableDeclaration(
ParseTypeName(astNodeCollection),
SeparatedList <VariableDeclaratorSyntax>(
new[]
{
VariableDeclarator(resultVarName)
.WithInitializer(
EqualsValueClause(ObjectCreationExpression(ParseTypeName(astNodeCollection)).WithArgumentList(ArgumentList())))
})
))
);
var iteratorVarName = "node";
conversionMethod = conversionMethod.AddBodyStatements(
ForEachStatement(
ParseTypeName("var"),
iteratorVarName,
IdentifierName(this.nodesParameterName),
Block().AddStatements(
ExpressionStatement(
InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName(resultVarName), IdentifierName("Add")),
ArgumentList(SeparatedList <ArgumentSyntax>(
new []
{
Argument(
CastExpression(
ParseTypeName("T"),
InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName(this.convertFromNodeMethodName)),
ArgumentList(SeparatedList <ArgumentSyntax>(new [] { Argument(IdentifierName(iteratorVarName)) }))
)))
})))
)
)));
conversionMethod = conversionMethod.AddBodyStatements(ReturnStatement(IdentifierName(resultVarName)));
return(conversionMethod);
}
public StatementSyntax EmitForEntity(TransportModelEntity entity, TransportModelEnum syntaxKindEnum)
{
var discriminant = entity.TsDiscriminant as TransportModelEntityTsDiscriminantSyntaxKind;
var recognizedNodeVarName = "concreteNode";
var block = Block();
List <ArgumentSyntax> constructorArguments = new List <ArgumentSyntax>();
block = block.AddStatements(
LocalDeclarationStatement(
VariableDeclaration(
ParseTypeName("var"),
SeparatedList <VariableDeclaratorSyntax>(new[]
{
VariableDeclarator(recognizedNodeVarName)
.WithInitializer(EqualsValueClause(CastExpression(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(entity, this.settings, ModelType.Transport)), IdentifierName(this.nodeParameterName))))
})))
);
foreach (var member in CsEmitterHelper.GetMembers(entity))
{
if (member.Key != "kind")
{
if (CsEmitterHelper.IsNode(member.Value.Type))
{
if (member.Value.Type.IsCollection)
{
constructorArguments.Add(
Argument(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
GenericName(
Identifier(this.convertFromNodeCollectionMethodName),
TypeArgumentList(SeparatedList <TypeSyntax>(new[]
{
ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(((ITransportModelTypeReferenceTransportModelItem <TransportModelItem>)member.Value.Type).TransportModelItem, this.settings, ModelType.Ast))
})))),
ArgumentList(SeparatedList <ArgumentSyntax>(new[]
{
Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(recognizedNodeVarName),
IdentifierName(NameHelper.GetSafeVariableName(member.Key))))
})))
));
}
else
{
constructorArguments.Add(
Argument(
CastExpression(
ParseTypeName(CsEmitterHelper.GetAstModelPropertyTypeName(member.Value, this.settings, true)),
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName(this.convertFromNodeMethodName)),
ArgumentList(SeparatedList <ArgumentSyntax>(new[]
{
Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(recognizedNodeVarName),
IdentifierName(NameHelper.GetSafeVariableName(member.Key))))
})))
)
));
}
}
else
{
constructorArguments.Add(
Argument(
CastExpression(
ParseTypeName(CsEmitterHelper.GetAstModelPropertyTypeName(member.Value, this.settings, true)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(recognizedNodeVarName),
IdentifierName(NameHelper.GetSafeVariableName(member.Key))))));
}
}
}
block = block.AddStatements(
LocalDeclarationStatement(
VariableDeclaration(
ParseTypeName("var"),
SeparatedList <VariableDeclaratorSyntax>(new[]
{
VariableDeclarator("result")
.WithInitializer(
EqualsValueClause(
ObjectCreationExpression(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(entity, this.settings, ModelType.Ast)))
.WithArgumentList(ArgumentList(SeparatedList <ArgumentSyntax>(constructorArguments)))))
}))
));
block = block.AddStatements(ReturnStatement(IdentifierName("result")));
var result = IfStatement(
BinaryExpression(
SyntaxKind.EqualsExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName(this.nodeParameterName), IdentifierName("kind")),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(syntaxKindEnum, this.settings, ModelType.Transport)),
IdentifierName(discriminant.SyntaxKindValueName))),
block);
return(result);
}