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; }