public CompilationUnitSyntax Generate(Assembly assembly)
{
var assemblyName = assembly.GetName();
var assemblyVersion = assemblyName.Version;
var compilation = _compilationProvider.Get(
assembly.GetName().Name,
references: new[] { _metadataReferenceLoader.CreateFromFile(assembly.Location) });
var namespaceSymbols = GetNamespaceMembers(compilation.GlobalNamespace);
var compilationSyntax = CompilationUnit();
compilationSyntax = compilationSyntax.AddUsings(UsingDirective(IdentifierName("System.Reflection")))
.WithAttributeLists(List(new[]
{
CreateAssemblyAttributeList("AssemblyTitle", $"{assemblyName.Name}"),
CreateAssemblyAttributeList("AssemblyVersion", $"{assemblyVersion}"),
CreateAssemblyAttributeList("AssemblyFileVersion", $"{assemblyVersion}"),
CreateAssemblyAttributeList("AssemblyInformationalVersion", $"{assemblyVersion}")
}));
foreach (var namespaceSymbol in namespaceSymbols)
{
var classSymbols = CreateNamedTypeDeclaration(namespaceSymbol).ToArray();
if (classSymbols.Any())
{
var namespaceSyntax = NamespaceDeclaration(IdentifierName(namespaceSymbol.ToString())).AddMembers(classSymbols);
compilationSyntax = compilationSyntax.AddMembers(namespaceSyntax);
}
}
return(compilationSyntax);
}
public SyntaxNode Rewrite(CompilationUnitSyntax compilationUnitSyntax, Assembly assembly)
{
var compilation = _compilationProvider.Get(assembly.GetName().Name);
compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.Create(compilationUnitSyntax));
foreach (var metadataRewriterService in _metadataRewriterServices)
{
var rewriterName = metadataRewriterService.GetType().Name;
Logger.Info($"Executing {rewriterName}");
var currentTree = compilation.SyntaxTrees.Single();
var semanticModel = compilation.GetSemanticModel(currentTree);
var rewrittenNode = metadataRewriterService.Rewrite(assembly, semanticModel, currentTree.GetRoot());
compilation = compilation.ReplaceSyntaxTree(currentTree, SyntaxTree(rewrittenNode));
Logger.Info($"Finished execution of {rewriterName}");
}
return(compilation.SyntaxTrees.Single().GetRoot());
}
public GeneratorResult Generate(MetadataGeneratorOptions options)
{
var generatorResult = new GeneratorResult();
var targetFramework = new FrameworkName(options.TargetFramework);
var package = _packageManager.InstallPackage(options.Package, options.PackageVersion, targetFramework);
if (package == null)
{
Logger.Error("Unable to find package {0} {1}", options.Package, options.PackageVersion ?? string.Empty);
return(null);
}
if (!string.IsNullOrWhiteSpace(options.OutputFolder) && !_fileSystem.DirectoryExists(options.OutputFolder))
{
_fileSystem.CreateDirectory(options.OutputFolder);
}
var packages = _dependencyResolver.GetDependenciesAndSelf(package, targetFramework).ToList();
var assemblies = _packageAssemblyResolver.ResolveAssemblies(package, targetFramework);
foreach (var assembly in assemblies)
{
var compilationUnit = _cakeSourceGenerator.Generate(assembly);
var rewrittenNode = _cakeSyntaxRewriterService.Rewrite(compilationUnit, assembly);
var emitedAssemblyName = $"{assembly.GetName().Name}.{MetadataClassSuffix}";
var compilation = _compilationProvider.Get(
emitedAssemblyName,
new[] { SyntaxFactory.ParseSyntaxTree(rewrittenNode.NormalizeWhitespace().ToFullString()) },
_metadataReferenceLoader.CreateFromPackages(packages, targetFramework),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var result = _compiler.Compile(compilation, Path.Combine(options.OutputFolder ?? string.Empty, $"{emitedAssemblyName}.dll"));
generatorResult.EmitedAssemblies.Add(result);
generatorResult.SourceAssemblies.Add(assembly);
}
return(generatorResult);
}
