public static void CloneContent(CodeFileTs source, CodeFileTs target, IMetadataRecorder metadataRecorder)
{
if (source.Model != null)
{
var transport = (Node)source.Model.GetTransportModelNode();
ModelConverter converter = new ModelConverter();
target.Model = (StRoot)converter.ConvertFromNode(transport);
metadataRecorder.SymbolSourcingFrom(source.NodePathService, source.Model, target.NodePathService, target.Model, new Dictionary <string, string>());
}
}
public override void Execute(IEnumerable <CodeFile> input, IMetadataRecorder metadataRecorder, IMetadataReader metadataReader, ILogger logger)
{
foreach (var file in input)
{
if (!(file is TCodeFile))
{
throw new InvalidOperationException($"Plugin supports only {typeof(TCodeFile)} as input.");
}
var codeFile = (TCodeFile)file;
var parameters = this.Preprocessor.GenerateParameters(codeFile, this.Settings, metadataReader, logger);
this.Implementation(codeFile, parameters, metadataRecorder, logger);
}
}
public override void Execute(IEnumerable <CodeFile> input, IMetadataRecorder metadataRecorder, IMetadataReader metadataReader, ILogger logger)
{
if (input.Any(file => !(file is TCodeFile)))
{
throw new InvalidOperationException($"Plugin supports only {typeof(TCodeFile)} as input.");
}
var inputConcrete = input.Cast <TCodeFile>();
List <IFileGroup <TCodeFile, GroupItemDetails> > groups = null;
if (this.InputAggregator != null)
{
groups = new List <IFileGroup <TCodeFile, GroupItemDetails> >(this.InputAggregator.Aggregate(inputConcrete));
}
else
{
var defaultGroup = new FileGroup <TCodeFile, GroupItemDetails>()
{
Name = DefaultGroupName
};
foreach (var i in inputConcrete)
{
defaultGroup.Files.Add(i, new GroupItemDetails());
}
groups = new List <IFileGroup <TCodeFile, GroupItemDetails> >()
{
defaultGroup
};
}
foreach (var group in groups)
{
var inputGroup = new FileGroup <TCodeFile, GroupItemDetailsParametrized <TInputParameters> >();
inputGroup.Name = group.Name;
foreach (var file in group.Files)
{
var metadata = this.Preprocessor.GenerateParameters(file.Key, this.Settings, metadataReader, logger, group);
inputGroup.Files.Add(file.Key, new GroupItemDetailsParametrized <TInputParameters>(metadata, file.Value.GroupingTags));
}
this.Implementation(inputGroup, metadataRecorder, logger);
}
}
public static void CloneContent(CodeFileGlsl source, CodeFileGlsl target, IMetadataRecorder metadataRecorder)
{
if (source.ShaderFile != null)
{
CloningAstVisitor cloner = new CloningAstVisitor();
if (target.ShaderFile == null)
{
target.ShaderFile = ShaderFile.CreateEmpty(source.ShaderFile.SyntaxTree.Version);
}
target.ShaderFile.SyntaxTree.Version = source.ShaderFile.SyntaxTree.Version;
foreach (var declaration in source.ShaderFile.SyntaxTree.Declarations)
{
var targetNode = cloner.CloneNode(declaration);
target.ShaderFile.SyntaxTree.Declarations.Add(targetNode);
metadataRecorder.SymbolSourcingFrom(source.NodePathService, declaration, target.NodePathService, targetNode, new Dictionary <string, string>());
}
}
}
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 abstract void Implementation(FileGroup <TCodeFile, GroupItemDetailsParametrized <TInputParameters> > group, IMetadataRecorder metadataRecorder, ILogger logger);
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)
{
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;
}
}
protected override void Implementation(CodeFileCSharp input, TestPluginMetadata metadata, IMetadataRecorder metadataRecorder, ILogger logger)
{
var code = this.Outputs[outputStreamName].CreateCodeFile("Output.cs") as CodeFileCSharp;
}
protected override void Implementation(CodeFileCSharp input, Parameters parameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
foreach (var item in parameters.Types)
{
this.GenerateForClass(item, input.SemanticModel);
}
}
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 abstract void Implementation(TCodeFile input, TInputParameters inputParameters, IMetadataRecorder metadataRecorder, ILogger logger);
public abstract void Execute(IEnumerable <CodeFile> input, IMetadataRecorder metadataRecorder, IMetadataReader metadataReader, ILogger logger);
protected override void Implementation(CodeFileCSharp input, Parameters inputParameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
var unit = SyntaxFactory.CompilationUnit();
foreach (var nsUsage in input.SyntaxTree.GetRoot().DescendantNodes().OfType <UsingDirectiveSyntax>())
{
unit = unit.AddUsings(nsUsage);
}
var nsContainer = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(this.Settings.OutputNamespace));
foreach (var member in input.SyntaxTree.GetRoot().DescendantNodes().OfType <TypeDeclarationSyntax>())
{
nsContainer = nsContainer.AddMembers(member);
}
var outFile = this.Outputs[OutStreamName].CreateCodeFile(input.Name) as CodeFileCSharp;
unit = unit.AddMembers(nsContainer);
outFile.SyntaxTree = unit.SyntaxTree;
PropertyAdder adder = new PropertyAdder(new Dictionary <string, string>()
{
{ "AddedProp", "int" },
{ "OtherAddedProp", "string" },
});
var newRoot = adder.Visit(outFile.SyntaxTree.GetRoot());
outFile.SyntaxTree = CSharpSyntaxTree.Create(newRoot as CSharpSyntaxNode);
foreach (var added in outFile.SyntaxTree.GetRoot().DescendantNodes().Where((n) => n.GetAnnotations(adder.AnnotationKey).Any()))
{
metadataRecorder.SymbolGenerated <SyntaxNode>(outFile.NodePathService, added, 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()
});
}
public static void CloneContent(CodeFileCSharp source, CodeFileCSharp target, IMetadataRecorder metadataRecorder, Dictionary <string, string> metadataTags = null, object metadataObject = null)
{
if (source.SyntaxTree != null)
{
var sourceRoot = (CSharpSyntaxNode)source.SyntaxTree.GetRoot();
var targetTree = CSharpSyntaxTree.Create(sourceRoot);
var targetRoot = targetTree.GetRoot();
target.SyntaxTree = targetTree;
metadataRecorder.SymbolSourcingFrom(source.NodePathService, sourceRoot, target.NodePathService, targetRoot, metadataTags ?? new Dictionary <string, string>(), metadataObject);
}
}
protected override void Implementation(CodeFileTs input, Parameters inputParameters, IMetadataRecorder metadataRecorder, ILogger logger)
{
var outFile = this.Outputs[OutStreamName].CreateCodeFile(input.Name) as CodeFileTs;
TsSyntaxUtils.CloneContent(input, outFile, metadataRecorder);
foreach (var c in outFile.Model.statements.OfType <StClassDeclaration>())
{
c.WithMember(
new StPropertyDeclaration()
.WithModifier(new StPublicKeywordToken())
.WithName(new StIdentifier().WithEscapedText("f"))
.WithType(new StKeywordTypeNodeNumberKeyword()));
if (inputParameters.AdditionalProperty)
{
c.WithMember(
new StPropertyDeclaration()
.WithModifier(new StPublicKeywordToken())
.WithName(new StIdentifier().WithEscapedText("additionalF"))
.WithType(new StKeywordTypeNodeNumberKeyword()));
}
}
}
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(FileGroup <CodeFileCSharp, GroupItemDetailsParametrized <Parameters> > group, IMetadataRecorder metadataRecorder, ILogger logger)
{
foreach (var inputFile in group.Files)
{
var input = inputFile.Key;
var inputParameters = inputFile.Value.Parameters;
var outFile = this.passThroughStream.CreateCodeFile(input.Name) as CodeFileCSharp;
CSharpSyntaxUtils.CloneContent(input, outFile, metadataRecorder);
var snapshot = outFile.NodePathService.GetSubTreeSnapshot(outFile.SyntaxTree.GetRoot());
var editor = new SyntaxEditor(snapshot, input, outFile, inputParameters, this.Settings);
var newRoot = editor.Visit(outFile.SyntaxTree.GetRoot());
outFile.SyntaxTree = CSharpSyntaxTree.Create(newRoot as CSharpSyntaxNode);
foreach (var added in outFile.SyntaxTree.GetRoot().DescendantNodes().Where((n) => n.GetAnnotations(editor.AnnotationKey).Any()))
{
metadataRecorder.SymbolGenerated <SyntaxNode>(outFile.NodePathService, added, new Dictionary <string, string>());
}
}
}