protected override void Implementation(CodeFileCSharp input, Parameters parameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
foreach (var item in parameters.Types)
{
this.GenerateForClass(item, input.SemanticModel);
}
}
public SyntaxEditor(ISubTreeSnapshot snapshot, CodeFileCSharp input, CodeFileCSharp output, Parameters inputParameters, Settings settings)
{
this.snapshot = snapshot;
this.input = input;
this.output = output;
this.inputParameters = inputParameters;
this.settings = settings;
}
protected override void Implementation(CodeFileCSharp input, Parameters inputParameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
AttributeAdder serializableAttributeAdder = new AttributeAdder(inputParameters.PropertiesToDecorate);
var newRoot = serializableAttributeAdder.Visit(input.SyntaxTree.GetRoot());
var outFile = this.Outputs[OutStreamName].CreateCodeFile(input.Name) as CodeFileCSharp;
outFile.SyntaxTree = CSharpSyntaxTree.Create(newRoot as CSharpSyntaxNode);
}
protected override void Implementation(CodeFileCSharp input, Parameters parameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
foreach (var extensionClass in parameters.ExtensionClasses.Where(c => c.Include))
{
var outputFile = (CodeFileCSharp)this.outputStream.CreateCodeFile($"{extensionClass.ExtensionClassName}.cs");
this.GenerateForClass(extensionClass, input, outputFile, metadataRecorder);
metadataRecorder.SymbolGenerated(outputFile.NodePathService, outputFile.SyntaxTree.GetRoot(), new Dictionary <string, string>());
}
}
protected override void Implementation(CodeFileCSharp input, Parameters parameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
var mappings = this.CreateTypeMappings();
foreach (var enumDeclaration in input.SyntaxTree.GetRoot().DescendantNodes().OfType <EnumDeclarationSyntax>())
{
this.GenerateForEnum(input, enumDeclaration);
}
foreach (var classDeclaration in input.SyntaxTree.GetRoot().DescendantNodes().OfType <ClassDeclarationSyntax>())
{
var declaredSymbol = input.SemanticModel.GetDeclaredSymbol(classDeclaration);
if (this.HasBaseModelNamespace(declaredSymbol))
{
this.GenerateForClass(input, declaredSymbol, mappings);
}
}
}
protected void GenerateForClass(CodeFileCSharp input, INamedTypeSymbol classSymbol, TypeMappings typeMappings)
{
var members = classSymbol.GetMembers()
.Where(m => m.DeclaredAccessibility == Accessibility.Public && !m.IsStatic && m.Kind == SymbolKind.Field)
.OfType <IFieldSymbol>()
.ToArray();
var heritage = new StHeritageClause()
.WithToken(FullSyntaxTree.TransportModel.SyntaxKind.ExtendsKeyword);
var interfaceDefinition = new StInterfaceDeclaration()
.WithModifier(new StExportKeywordToken())
.WithName(new StIdentifier().WithEscapedText(classSymbol.Name));
var addHeritage = false;
if (classSymbol.BaseType != null && typeof(object).FullName != classSymbol.BaseType.GetFullMetadataName())
{
var baseType = this.MapTypeReference(classSymbol.BaseType, typeMappings);
if (baseType != null && baseType is StExpressionWithTypeArguments expressionWithTypeArguments)
{
heritage.WithType(t => expressionWithTypeArguments);
addHeritage = true;
}
}
if (addHeritage)
{
interfaceDefinition.WithHeritageClaus(b => heritage);
}
foreach (var member in members)
{
interfaceDefinition.WithMember(
new StPropertySignature()
.WithName(new StIdentifier().WithEscapedText(member.Name))
.WithType(this.MapTypeReference(member.Type, typeMappings, true)));
}
this.OutputFile.Model.statements.Add(interfaceDefinition);
}
protected override void Implementation(CodeFileCSharp input, Parameters inputParameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
var outFile = this.Outputs[OutStreamName].CreateCodeFile($"{Path.GetFileNameWithoutExtension(input.Name)}.ts") as CodeFileTs;
outFile.Model = new StRoot();
foreach (var name in inputParameters.ClassNames)
{
var definition = new StClassDeclaration()
.WithName(new StIdentifier().WithEscapedText(name))
.WithModifier(new StExportKeywordToken());
outFile.Model.statements.Add(definition);
metadataRecorder.SymbolGenerated(outFile.NodePathService, definition, new Dictionary <string, string>()
{
{ "FROM_CSharp", "true" }
});
}
}
protected override void Implementation(CodeFileCSharp input, Parameters parameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
if (!this.hasExecuted)
{
var csTransportModelEmitter = new CsTransportModelEmitter(this.Settings);
csTransportModelEmitter.Emit(parameters, this.csTransportModelsOutputStream);
var csAstEmitter = new CsAstModelEmitter(this.Settings);
csAstEmitter.Emit(parameters, this.csAstModelsOutputStream);
var csTransportToAstTranslatorEmitter = new CsTransportToAstTranslatorEmitter(this.Settings);
csTransportToAstTranslatorEmitter.Emit(parameters, this.csTransportToAstConverterOutputStream);
var tsAstToTransportTranslatorEmitter = new TsAstToTransportTranslatorEmitter(this.Settings);
tsAstToTransportTranslatorEmitter.Emit(parameters, this.tsModelsOutputStream);
var tsTransportToAstTranslatorEmitter = new TsTransportToAstTranslatorEmitter(this.Settings);
tsTransportToAstTranslatorEmitter.Emit(parameters, this.tsModelsOutputStream);
this.hasExecuted = true;
}
}
private void GenerateForClass(
ExtensionClass extensionClassParameters,
CodeFileCSharp input,
CodeFileCSharp output,
IMetadataRecorder metadataRecorder)
{
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName("System")),
UsingDirective(ParseName("System.Collections.Generic")),
UsingDirective(ParseName("System.Linq")));
var extensionClass = ClassDeclaration(extensionClassParameters.ExtensionClassName);
extensionClass = extensionClass.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.PartialKeyword));
extensionClass = extensionClass
.WithMembers(
List <MemberDeclarationSyntax>(
extensionClassParameters
.Members
.Where(m => m.Include)
.Select(m => this.CreateExtensionMethod(m, input.SemanticModel))));
var nsContainer = NamespaceDeclaration(ParseName(this.Settings.OutputNamespace));
nsContainer = nsContainer.AddMembers(extensionClass);
unit = unit.AddMembers(nsContainer);
output.SyntaxTree = unit.SyntaxTree;
metadataRecorder.SymbolGenerated(
output.NodePathService,
extensionClass,
input.NodePathService,
extensionClassParameters.RelatedClassDeclaration,
new Dictionary <string, string>());
}
protected override void Implementation(CodeFileCSharp input, Parameters inputParameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
var outFile = this.Outputs[OutStreamName].CreateCodeFile($"{Path.GetFileNameWithoutExtension(input.Name)}.vertex.glsl") as CodeFileGlsl;
outFile.ShaderFile = ShaderFile.CreateEmpty();
outFile.ShaderFile.SyntaxTree.Version = ShaderVersion.GlslEs300;
outFile.ShaderFile.SyntaxTree.Declarations.Add(new FunctionDeclaration()
{
Name = new Identifier()
{
Name = "main"
},
TypeSpecifier = new TypeNameSpecifier()
{
Identifier = new Identifier()
{
Name = "void"
}
},
Statement = new StatementCompound()
});
}
protected void GenerateForEnum(CodeFileCSharp input, EnumDeclarationSyntax enumSyntax)
{
var declaredSymbol = input.SemanticModel.GetDeclaredSymbol(enumSyntax);
var enumDefinition = new StEnumDeclaration()
.WithModifier(new StExportKeywordToken())
.WithName(new StIdentifier().WithEscapedText(declaredSymbol.Name));
var members = declaredSymbol.GetMembers()
.Where(m => m.DeclaredAccessibility == Accessibility.Public && m.IsStatic && m.Kind == SymbolKind.Field)
.OfType <IFieldSymbol>()
.Where(f => f.IsConst && f.IsDefinition)
.ToArray();
foreach (var member in members)
{
enumDefinition.WithMember(m =>
m
.WithName(new StIdentifier().WithEscapedText(member.Name)));
}
this.OutputFile.Model.statements.Add(enumDefinition);
}
public SubTreeSnapshot(
CodeFileCSharp codeFileCSharp,
SyntaxTreeMappedVisitor <SyntaxTreeMappedVisitorContext> mappedVisitor)
: base(codeFileCSharp, mappedVisitor)
{
}
public CSharpNodePathService(CodeFileCSharp codeFileCSharp)
{
this.codeFileCSharp = codeFileCSharp;
}
