public Build GenerateCode(List <SourceFile> sourcefiles,
IEnumerable <Calculation> calculations)
{
// ReSharper disable once CoVariantArrayConversion
MetadataReference[] references = Assembly.GetExecutingAssembly().GetReferencedAssemblies().Select(_ => AssemblyMetadata.CreateFromFile(Assembly.Load(_).Location).GetReference()).ToArray();
references = references.Concat(new[] {
AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(Microsoft.VisualBasic.Constants).Assembly.Location).GetReference()
}).ToArray();
Dictionary <string, Calculation> calculationsLookup = calculations.ToDictionary(_ => _.Id);
using MemoryStream stream = new MemoryStream();
Build build = GenerateCode(sourcefiles, references, stream, calculationsLookup);
if (build.Success)
{
stream.Seek(0L, SeekOrigin.Begin);
byte[] data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
build.Assembly = data;
}
return(build);
}
public BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger)
{
logger.WriteLineInfo($"BuildScript: {generateResult.ArtifactsPaths.BuildScriptFilePath}");
var syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(generateResult.ArtifactsPaths.ProgramCodePath));
var compilationOptions = new CSharpCompilationOptions(
outputKind: OutputKind.ConsoleApplication,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: true,
platform: GetPlatform(buildPartition.Platform),
deterministic: true);
compilationOptions = compilationOptions.WithIgnoreCorLibraryDuplicatedTypes();
var references = Generator
.GetAllReferences(buildPartition.RepresentativeBenchmarkCase)
.Select(assembly => AssemblyMetadata.CreateFromFile(assembly.Location))
.Concat(FrameworkAssembliesMetadata.Value)
.Distinct()
.Select(uniqueMetadata => uniqueMetadata.GetReference())
.ToList();
var(result, missingReferences) = Build(generateResult, syntaxTree, compilationOptions, references);
if (result.IsBuildSuccess || !missingReferences.Any())
{
return(result);
}
var withMissingReferences = references.Union(missingReferences.Select(assemblyMetadata => assemblyMetadata.GetReference()));
return(Build(generateResult, syntaxTree, compilationOptions, withMissingReferences).result);
}
public static Assembly Compile(params string[] sources)
{
var assemblyFileName = "gen" + Guid.NewGuid().ToString().Replace("-", "") + ".dll";
var compilation = CSharpCompilation.Create(assemblyFileName,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary),
syntaxTrees: from source in sources
select CSharpSyntaxTree.ParseText(source),
references: new[]
{
AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(RuntimeBinderException).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(DynamicAttribute).Assembly.Location).GetReference(),
});
EmitResult emitResult;
using (var ms = new MemoryStream())
{
emitResult = compilation.Emit(ms);
if (emitResult.Success)
{
var assembly = Assembly.Load(ms.GetBuffer());
return(assembly);
}
}
var message = string.Join("\r\n", emitResult.Diagnostics);
throw new ApplicationException(message);
}
public void Ctor_Errors()
{
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.CreateFromImage(default(ImmutableArray <byte>)));
IEnumerable <byte> enumerableImage = null;
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.CreateFromImage(enumerableImage));
byte[] arrayImage = null;
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.CreateFromImage(arrayImage));
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.Create((ModuleMetadata)null));
Assert.Throws <ArgumentException>(() => AssemblyMetadata.Create(default(ImmutableArray <ModuleMetadata>)));
Assert.Throws <ArgumentException>(() => AssemblyMetadata.Create(ImmutableArray.Create <ModuleMetadata>()));
var m1 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.MultiModule.MultiModuleDll);
var m2 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.MultiModule.mod2);
var m3 = ModuleMetadata.CreateFromImage(TestResources.SymbolsTests.MultiModule.mod3);
Assert.Throws <ArgumentException>(() => AssemblyMetadata.Create(m1, m2.Copy(), m3));
Assert.Throws <ArgumentException>(() => AssemblyMetadata.Create(new List <ModuleMetadata>(new ModuleMetadata[] { m1.Copy(), m2.Copy(), m3.Copy() })));
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.Create(ImmutableArray.Create(m1, m2, null)));
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.Create(ImmutableArray.Create((ModuleMetadata)null)));
Assert.Throws <ArgumentNullException>(() => AssemblyMetadata.CreateFromFile((string)null));
}
> GetAnalyzerTypeNameMap(
string fullPath,
Type attributeType,
AttributeLanguagesFunc languagesFunc
)
{
using var assembly = AssemblyMetadata.CreateFromFile(fullPath);
// This is longer than strictly necessary to avoid thrashing the GC with string allocations
// in the call to GetFullyQualifiedTypeNames. Specifically, this checks for the presence of
// supported languages prior to creating the type names.
var typeNameMap =
from module in assembly.GetModules()
from typeDefHandle in module.MetadataReader.TypeDefinitions
let typeDef = module.MetadataReader.GetTypeDefinition(typeDefHandle)
let supportedLanguages = GetSupportedLanguages(
typeDef,
module.Module,
attributeType,
languagesFunc
)
where supportedLanguages.Any()
let typeName = GetFullyQualifiedTypeName(typeDef, module.Module)
from supportedLanguage in supportedLanguages
group typeName by supportedLanguage;
return(typeNameMap.ToImmutableSortedDictionary(
g => g.Key,
g => g.ToImmutableSortedSet(StringComparer.OrdinalIgnoreCase),
StringComparer.OrdinalIgnoreCase
));
}
private AssemblyMetadata Compile(string[] source)
{
var assemblyName = Path.GetFileNameWithoutExtension(this.FirstSource);
var cacheFolder = this.AssembliesCachePath;
if (!Directory.Exists(cacheFolder))
{
Directory.CreateDirectory(cacheFolder);
}
var compiled = false;
var dllFilePath = Path.Combine(cacheFolder, string.Concat(assemblyName, ".dll"));
var pdbFilePath = Path.Combine(cacheFolder, string.Concat(assemblyName, ".pdb"));
using (var dllStream = new FileStream(dllFilePath, FileMode.Create))
{
using (var pdbStream = new FileStream(pdbFilePath, FileMode.Create))
{
compiled = CompileTo(source, dllStream, pdbStream);
}
}
if (!compiled)
{
File.Delete(dllFilePath);
File.Delete(pdbFilePath);
return(null);
}
return(AssemblyMetadata.CreateFromFile(dllFilePath));
}
public void BadImageFormat()
{
var invalidModuleName = Temp.CreateFile().WriteAllBytes(TestResources.MetadataTests.Invalid.InvalidModuleName);
var metadata = AssemblyMetadata.CreateFromFile(invalidModuleName.Path);
Assert.Throws <BadImageFormatException>(() => metadata.GetModules());
}
public static void Go(string outDir, IEnumerable <string> extraTranslation, string exePath = "",
IEnumerable <string> cSharp = null, string testName = "")
{
var compilation = CSharpCompilation.Create(testName, cSharp.Select(o => CSharpSyntaxTree.ParseText(o)),
new MetadataReference[]
{
AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(RuntimeBinderException).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(DynamicAttribute).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(Queryable).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(DataTable).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(XmlAttribute).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(CSharpCodeProvider).Assembly.Location).GetReference(),
// AssemblyMetadata.CreateFromFile(typeof(System.ComponentModel.DataAnnotations.DisplayAttribute).Assembly.Location).GetReference(),
// AssemblyMetadata.CreateFromFile(typeof(System.ComponentModel.Composition.ImportAttribute).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(HttpRequest).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(CSharpCodeProvider).Assembly.Location).GetReference()
}, new CSharpCompilationOptions(OutputKind.ConsoleApplication, allowUnsafe: true));
_compilation = compilation;
OutDir = outDir;
Context.Update(compilation);
Task.WaitAll(Task.Run(() => Build(exePath)), Task.Run(() => Generate(extraTranslation)));
}
public Build GenerateCode(List <SourceFile> sourcefiles)
{
MetadataReference[] references =
{
AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference(),
AssemblyMetadata.CreateFromFile(typeof(Microsoft.VisualBasic.Constants).Assembly.Location).GetReference()
};
using (var ms = new MemoryStream())
{
var build = GenerateCode(sourcefiles, references, ms);
if (build.Success)
{
ms.Seek(0L, SeekOrigin.Begin);
byte[] data = new byte[ms.Length];
ms.Read(data, 0, data.Length);
build.Assembly = data;
}
return(build);
}
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
logger.WriteLineInfo($"BuildScript: {generateResult.ArtifactsPaths.BuildScriptFilePath}");
var syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(generateResult.ArtifactsPaths.ProgramCodePath));
var compilationOptions = new CSharpCompilationOptions(
outputKind: OutputKind.ConsoleApplication,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: true,
platform: GetPlatform(benchmark.Job.ResolveValue(EnvMode.PlatformCharacteristic, resolver)),
deterministic: true);
var references = Generator
.GetAllReferences(benchmark)
.Select(assembly => AssemblyMetadata.CreateFromFile(assembly.Location))
.Concat(FrameworkAssembliesMetadata.Value)
.Distinct()
.Select(uniqueMetadata => uniqueMetadata.GetReference());
(var result, var missingReferences) = Build(generateResult, benchmark, syntaxTree, compilationOptions, references);
if (result.IsBuildSuccess || !missingReferences.Any())
{
return(result);
}
var withMissingReferences = references.Union(missingReferences.Select(assemblyMetadata => assemblyMetadata.GetReference()));
return(Build(generateResult, benchmark, syntaxTree, compilationOptions, withMissingReferences).result);
}
private static IEnumerable <MetadataReference> GetCompileTimeReferences()
{
return
(from library in DependencyContext.Default.CompileLibraries
from path in library.ResolveReferencePaths()
select AssemblyMetadata.CreateFromFile(path)
into assembly
select assembly.GetReference());
}
/// <summary>
/// Cache metadata references to avoid loading them between projects
/// </summary>
private MetadataReference GetOrCreateMetaDataReference(string file)
{
if (!_references.TryGetValue(file, out var meta))
{
meta = AssemblyMetadata.CreateFromFile(file);
_references.Add(file, meta);
}
return(meta.GetReference(filePath: file));
}
public static Assembly BuildCode(string filepath)
{
lasterror = "";
var syntaxTree =
CSharpSyntaxTree.ParseText(File.ReadAllText(filepath, Encoding.UTF8), path: filepath,
encoding: Encoding.UTF8);
var assemblyName = Path.GetFileNameWithoutExtension(filepath); //Guid.NewGuid().ToString();
var refs = AppDomain.CurrentDomain.GetAssemblies();
var refFiles = refs.Where(a =>
!a.IsDynamic && !a.FullName.Contains("MissionPlanner.Drawing"))
.Select(a => a.Location);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
refFiles = refs.Where(a => !a.IsDynamic).Select(a => a.Location);
}
var refmeta = refFiles.Select(a =>
{
try
{
if (a == "" || !File.Exists(a))
{
return(null);
}
return(AssemblyMetadata.CreateFromFile(a).GetReference());
}
catch
{
return(null);
}
}).Where(a => a != null).ToArray();
CSharpCompilation compilation = CSharpCompilation.Create(
assemblyName,
new[] { syntaxTree }, refmeta,
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
using (var dllStream = new MemoryStream())
using (var pdbStream = new MemoryStream())
{
var emitResult = compilation.Emit(dllStream, pdbStream);
if (!emitResult.Success)
{
// emitResult.Diagnostics
emitResult.Diagnostics.ForEach(a => Console.WriteLine("CodeGenRoslyn " + Path.GetFileName(filepath) + ": {0}", a.ToString()));
lasterror = emitResult.Diagnostics.Aggregate("", (a, b) => a + b.ToString() + "\n");
}
else
{
return(Assembly.Load(dllStream.ToArray(), pdbStream.ToArray()));
}
return(null);
}
}
public override PortableExecutableReference GetReference(string fullPath, MetadataReferenceProperties properties = default(MetadataReferenceProperties))
{
AssemblyMetadata metadata;
if (_cache.TryGetValue(fullPath, out metadata))
{
return(metadata.GetReference(MakeDocumentationProvider()));
}
_cache.Add(fullPath, metadata = AssemblyMetadata.CreateFromFile(fullPath));
return(metadata.GetReference(MakeDocumentationProvider()));
}
/// <summary>
/// Opens the analyzer dll with the metadata reader and builds a map of language -> analyzer type names.
/// </summary>
/// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
/// <exception cref="IOException">IO error reading the metadata.</exception>
private static ImmutableDictionary <string, ImmutableHashSet <string> > GetAnalyzerTypeNameMap(string fullPath, AttributePredicate attributePredicate)
{
using (AssemblyMetadata assembly = AssemblyMetadata.CreateFromFile(fullPath))
{
IEnumerable <IGrouping <string, string> > typeNameMap = from module in assembly.GetModules()
from typeDefHandle in module.MetadataReader.TypeDefinitions
let typeDef = module.MetadataReader.GetTypeDefinition(typeDefHandle)
let typeName = GetFullyQualifiedTypeName(typeDef, module.Module)
from supportedLanguage in GetSupportedLanguages(typeDef, module.Module, attributePredicate)
group typeName by supportedLanguage;
return(typeNameMap.ToImmutableDictionary(g => g.Key, g => g.ToImmutableHashSet()));
}
}
/*
* Given the path to a solution file, import will open the solution and it internal projects.
* For each of the documents inside this sucessive projects, its going to vist it AST representation
*/
public Repository ImportProject(string solutionPath)
{
//The code that causes the error goes here.
var msWorkspace = MSBuildWorkspace.Create(new Dictionary <string, string>()
{
{ "Configuration", "Debug" }, { "Platform", "AnyCPU" }, { "CheckForSystemRuntimeDependency", "true" }
});
var solution = msWorkspace.OpenSolutionAsync(solutionPath).Result;
ignoreFolder = this.PrivateDirectoryNameFor(solutionPath);
this.InitializeForImport();
MetadataReference mscoreLibReference =
AssemblyMetadata
.CreateFromFile(typeof(string).Assembly.Location)
.GetReference();
var documents = new List <Document>();
for (int i = 0; i < solution.Projects.Count <Project>(); i++)
{
var project = solution.Projects.ElementAt <Project>(i);
var compilationAsync = project.GetCompilationAsync().Result;
compilationAsync.AddReferences(
MetadataReference.CreateFromFile(typeof(object).Assembly.Location)
).AddReferences(
MetadataReference.CreateFromFile(typeof(RequiredAttribute).Assembly.Location));
var diagnostics = compilationAsync.GetDiagnostics();
for (int j = 0; j < project.Documents.Count <Document>(); j++)
{
var document = project.Documents.ElementAt <Document>(j);
if (document.SupportsSyntaxTree)
{
this.log("(project " + (i + 1) + " / " + solution.Projects.Count <Project>() + ")");
this.logln("(document " + (j + 1) + " / " + project.Documents.Count <Document>() + " " + document.FilePath + ")");
var tree = document.GetSyntaxTreeAsync().Result;
var semanticModel = compilationAsync.GetSemanticModel(tree);
var model = semanticModel.GetDiagnostics();
this.Import(tree, semanticModel);
}
}
}
return(_repository);
}
private static CSharpCompilation Compile(string refPath, string source)
{
var dotnetCoreDirectory = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory();
var compilation = CSharpCompilation.Create("test",
syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(source) },
references: new[]
{
AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference(),
MetadataReference.CreateFromFile(Path.Combine(dotnetCoreDirectory, "netstandard.dll")),
MetadataReference.CreateFromFile(Path.Combine(dotnetCoreDirectory, "System.Runtime.dll")),
MetadataReference.CreateFromFile(refPath),
});
return(compilation);
}
public void CreateFromFile()
{
var dir = Temp.CreateDirectory();
var mm = dir.CreateFile("MultiModule.dll").WriteAllBytes(TestResources.SymbolsTests.MultiModule.MultiModuleDll).Path;
dir.CreateFile("mod2.netmodule").WriteAllBytes(TestResources.SymbolsTests.MultiModule.mod2);
dir.CreateFile("mod3.netmodule").WriteAllBytes(TestResources.SymbolsTests.MultiModule.mod3);
using (var a = AssemblyMetadata.CreateFromFile(mm))
{
Assert.Equal(3, a.GetModules().Length);
Assert.Equal("MultiModule.dll", a.GetModules()[0].Name);
Assert.Equal("mod2.netmodule", a.GetModules()[1].Name);
Assert.Equal("mod3.netmodule", a.GetModules()[2].Name);
}
}
/// <summary>
/// Gets or creates metadata for specified file path.
/// </summary>
/// <param name="fullPath">Full path to an assembly manifest module file or a standalone module file.</param>
/// <param name="kind">Metadata kind (assembly or module).</param>
/// <returns>Metadata for the specified file.</returns>
/// <exception cref="IOException">Error reading file <paramref name="fullPath"/>. See <see cref="Exception.InnerException"/> for details.</exception>
public Metadata GetMetadata(string fullPath, MetadataImageKind kind)
{
if (NeedsShadowCopy(fullPath))
{
return(GetMetadataShadowCopyNoCheck(fullPath, kind).Metadata);
}
FileKey key = FileKey.Create(fullPath);
lock (Guard)
{
CacheEntry <Metadata> existing;
if (_noShadowCopyCache.TryGetValue(key, out existing))
{
return(existing.Public);
}
}
Metadata newMetadata;
if (kind == MetadataImageKind.Assembly)
{
newMetadata = AssemblyMetadata.CreateFromFile(fullPath);
}
else
{
newMetadata = ModuleMetadata.CreateFromFile(fullPath);
}
// the files are locked (memory mapped) now
key = FileKey.Create(fullPath);
lock (Guard)
{
CacheEntry <Metadata> existing;
if (_noShadowCopyCache.TryGetValue(key, out existing))
{
newMetadata.Dispose();
return(existing.Public);
}
Metadata publicMetadata = newMetadata.Copy();
_noShadowCopyCache.Add(key, new CacheEntry <Metadata>(publicMetadata, newMetadata));
return(publicMetadata);
}
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
logger.WriteLineInfo($"BuildScript: {generateResult.ArtifactsPaths.BuildScriptFilePath}");
var syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(generateResult.ArtifactsPaths.ProgramCodePath));
var compilationOptions = new CSharpCompilationOptions(
outputKind: OutputKind.ConsoleApplication,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: true,
platform: GetPlatform(benchmark.Job.ResolveValue(EnvMode.PlatformCharacteristic, resolver)),
deterministic: true);
var references = Generator
.GetAllReferences(benchmark)
.Select(assembly => AssemblyMetadata.CreateFromFile(assembly.Location))
.Concat(FrameworkAssembliesMetadata.Value)
.Distinct()
.Select(uniqueMetadata => uniqueMetadata.GetReference());
var compilation = CSharpCompilation
.Create(assemblyName: Path.GetFileName(generateResult.ArtifactsPaths.ExecutablePath))
.AddSyntaxTrees(syntaxTree)
.WithOptions(compilationOptions)
.AddReferences(references);
using (var executable = File.Create(generateResult.ArtifactsPaths.ExecutablePath))
{
var emitResult = compilation.Emit(executable);
if (emitResult.Success)
{
return(BuildResult.Success(generateResult));
}
foreach (var diagnostic in emitResult.Diagnostics
.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error))
{
logger.WriteError($"{diagnostic.Id}: {diagnostic.GetMessage()}");
}
return(BuildResult.Failure(generateResult));
}
}
private static ImmutableDictionary <string, ImmutableHashSet <string> > GetAnalyzerTypeNameMap(string fullPath, AttributePredicate attributePredicate)
{
using (var assembly = AssemblyMetadata.CreateFromFile(fullPath))
{
// This is longer than strictly necessary to avoid thrashing the GC with string allocations
// in the call to GetFullyQualifiedTypeNames. Specifically, this checks for the presence of
// supported languages prior to creating the type names.
var typeNameMap = from module in assembly.GetModules()
from typeDefHandle in module.MetadataReader.TypeDefinitions
let typeDef = module.MetadataReader.GetTypeDefinition(typeDefHandle)
let supportedLanguages = GetSupportedLanguages(typeDef, module.Module, attributePredicate)
where supportedLanguages.Any()
let typeName = GetFullyQualifiedTypeName(typeDef, module.Module)
from supportedLanguage in supportedLanguages
group typeName by supportedLanguage;
return(typeNameMap.ToImmutableDictionary(g => g.Key, g => g.ToImmutableHashSet()));
}
}
// a utility method that creates Roslyn compilation
// for the passed code.
// The compilation references the collection of
// passed "references" arguments plus
// the mscore library (which is required for the basic
// functionality).
public static CSharpCompilation CreateCompilationWithMscorlib
(
string assemblyOrModuleName,
string code,
CSharpCompilationOptions compilerOptions = null,
IEnumerable <MetadataReference> references = null)
{
// create the syntax tree
SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(code, null, "");
// get the reference to mscore library
MetadataReference mscoreLibReference =
AssemblyMetadata
.CreateFromFile(typeof(string).Assembly.Location)
.GetReference();
// create the allReferences collection consisting of
// mscore reference and all the references passed to the method
var allReferences =
new List <MetadataReference>()
{
mscoreLibReference
};
if (references != null)
{
allReferences.AddRange(references);
}
// create and return the compilation
CSharpCompilation compilation = CSharpCompilation.Create
(
assemblyOrModuleName,
new[] { syntaxTree },
options: compilerOptions,
references: allReferences
);
return(compilation);
}
private static Compilation Compile(string source)
{
var opt = new CSharpParseOptions(languageVersion: LanguageVersion.Preview, kind: SourceCodeKind.Regular, documentationMode: DocumentationMode.Parse);
var copt = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
var dotnetCoreDirectory = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory();
var compilation = CSharpCompilation.Create("test",
syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(source, opt) },
references: new[]
{
AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference(),
MetadataReference.CreateFromFile(Path.Combine(dotnetCoreDirectory, "netstandard.dll")),
MetadataReference.CreateFromFile(Path.Combine(dotnetCoreDirectory, "System.Runtime.dll")),
},
options: copt);
// apply the source generator
var driver = new CSharpGeneratorDriver(opt, ImmutableArray.Create <ISourceGenerator>(new MemberAccessGenerator.MemberAccessGenerator()), null, ImmutableArray <AdditionalText> .Empty);
driver.RunFullGeneration(compilation, out var resultCompilation, out _);
return(resultCompilation);
}
private static IEnumerable <MetadataReference> GetApplicationReferences()
{
var references = new List <MetadataReference>();
var depsFiles = AppContext.GetData("APP_CONTEXT_DEPS_FILE") as string;
var files = depsFiles?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
var application = files != null && files.Length > 0 ? files[0] : null;
using (var stream = File.OpenRead(application))
{
var dependencyContext = new DependencyContextJsonReader().Read(stream);
var libraries = dependencyContext
.GetRuntimeAssemblyNames(dependencyContext.Target.Runtime)
.Select(x => Assembly.Load(x.FullName).Location);
foreach (var library in libraries)
{
try
{
var metadata = AssemblyMetadata.CreateFromFile(library);
references.Add(metadata.GetReference());
}
catch (Exception ex)
when(ex is NotSupportedException ||
ex is ArgumentException ||
ex is BadImageFormatException ||
ex is IOException)
{
continue;
}
}
}
return(references);
}
private static CSharpCompilation CreateCompilationWithMscorlib(string assemblyName, string code, CSharpCompilationOptions compilerOptions = null, IEnumerable <MetadataReference> references = null)
{
SourceText sourceText = SourceText.From(code, Encoding.UTF8);
SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sourceText, null, "");
MetadataReference mscoreLibReference = AssemblyMetadata.CreateFromFile(typeof(string).Assembly.Location).GetReference();
IEnumerable <MetadataReference> allReferences = new MetadataReference[] { mscoreLibReference };
if (references != null)
{
allReferences = allReferences.Concat(references);
}
CSharpCompilation compilation = CSharpCompilation.Create
(
assemblyName,
new[] { syntaxTree },
options: compilerOptions,
references: allReferences
);
return(compilation);
}
private BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger, CancellationToken cancellationToken)
{
var syntaxTree = CSharpSyntaxTree.ParseText(
text: File.ReadAllText(generateResult.ArtifactsPaths.ProgramCodePath),
// this version is used to parse the boilerplate code generated by BDN, so th benchmark themselves can use more recent version
options: new CSharpParseOptions(LanguageVersion.CSharp7_3),
cancellationToken: cancellationToken);
var compilationOptions = new CSharpCompilationOptions(
outputKind: OutputKind.ConsoleApplication,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: true,
platform: GetPlatform(buildPartition.Platform),
deterministic: true);
compilationOptions = compilationOptions.WithIgnoreCorLibraryDuplicatedTypes();
var references = Generator
.GetAllReferences(buildPartition.RepresentativeBenchmarkCase)
.Select(assembly => AssemblyMetadata.CreateFromFile(assembly.Location))
.Concat(FrameworkAssembliesMetadata.Value)
.Distinct()
.Select(uniqueMetadata => uniqueMetadata.GetReference())
.ToList();
var(result, missingReferences) = Build(generateResult, syntaxTree, compilationOptions, references, cancellationToken);
if (result.IsBuildSuccess || !missingReferences.Any())
{
return(result);
}
var withMissingReferences = references.Union(missingReferences.Select(assemblyMetadata => assemblyMetadata.GetReference()));
return(Build(generateResult, syntaxTree, compilationOptions, withMissingReferences, cancellationToken).result);
}
public static void Compile(string code, bool isDebug, out Assembly compiledAssembly, out IList <string> errors, out IList <string> warnings)
{
var assemblyName = "CodeGenerationAssembly" + Interlocked.Increment(ref _suffix);
var metadataList =
SerializerDebugging.CodeSerializerDependentAssemblies.Select(
a =>
a is string
?AssemblyMetadata.CreateFromFile(a as string)
: AssemblyMetadata.CreateFromImage(a as byte[])
).ToArray();
try
{
var compilation =
CSharpCompilation.Create(
assemblyName,
new[] { CSharpSyntaxTree.ParseText(code) },
metadataList.Select(m => m.GetReference()),
new CSharpCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
optimizationLevel: isDebug?OptimizationLevel.Debug: OptimizationLevel.Release,
// Suppress CS0436 because gen/*.cs will conflict with testing serializers.
specificDiagnosticOptions: new[] { new KeyValuePair <string, ReportDiagnostic>("CS0436", ReportDiagnostic.Suppress) }
)
);
var emitOptions = new EmitOptions(runtimeMetadataVersion: "v4.0.30319");
EmitResult result;
if (SerializerDebugging.DumpEnabled)
{
var assemblyPath = Path.Combine(SerializerDebugging.DumpDirectory, assemblyName + ".dll");
using (var fileStream = File.OpenWrite(assemblyPath))
{
result = compilation.Emit(fileStream, options: emitOptions);
fileStream.Flush();
}
if (result.Success)
{
compiledAssembly = Assembly.LoadFrom(assemblyPath);
SerializerDebugging.AddCompiledCodeAssembly(assemblyPath);
}
else
{
compiledAssembly = null;
}
}
else
{
using (var buffer = new MemoryStream())
{
result = compilation.Emit(buffer, options: emitOptions);
if (result.Success)
{
var image = buffer.ToArray();
compiledAssembly = Assembly.Load(image);
SerializerDebugging.AddCompiledCodeAssembly(assemblyName, image);
}
else
{
compiledAssembly = null;
}
}
}
errors = BuildCompilationError(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
warnings = BuildCompilationError(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Warning));
}
finally
{
foreach (var metadata in metadataList)
{
metadata.Dispose();
}
}
}
// TODO: implement resources https://stackoverflow.com/a/26853131/2350244
private static VB.VisualBasicCompilation CreateVisualBasicCompilation(
IEnumerable <string> sourceFiles,
string assemblyName,
IEnumerable <string> references,
IEnumerable <KeyValuePair <string, object> > defines,
bool debug,
out List <string> messages
)
{
// parse the source files
var parseOpts =
VB.VisualBasicParseOptions.Default
.WithLanguageVersion(MaxVBLanguageVersion)
.WithPreprocessorSymbols(defines);
// and build syntax tree
List <SyntaxTree> syntaxTrees = new List <SyntaxTree>();
foreach (var sourceFile in sourceFiles)
{
syntaxTrees.Add(
VB.VisualBasicSyntaxTree.ParseText(
text: File.ReadAllText(sourceFile),
options: parseOpts,
path: sourceFile,
encoding: Encoding.UTF8
)
);
}
// collect references
var refs = new List <string>();
// add mscorelib
refs.Add(typeof(object).Assembly.Location);
foreach (var refFile in references)
{
refs.Add(refFile);
}
messages = new List <string>();
messages.Add($"Define: {string.Join(";", defines)}");
var mdataRefs = new List <MetadataReference>();
foreach (var refPath in refs)
{
messages.Add($"Reference: {refPath}");
mdataRefs.Add(
AssemblyMetadata.CreateFromFile(refPath).GetReference()
);
}
// compile options
var compileOpts =
new VB.VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithOverflowChecks(true)
.WithPlatform(Platform.X64)
.WithOptimizationLevel(debug ? OptimizationLevel.Debug : OptimizationLevel.Release);
// create compilation job
return(VB.VisualBasicCompilation.Create(
assemblyName: assemblyName,
syntaxTrees: syntaxTrees,
references: mdataRefs,
options: compileOpts
));
}
// TODO: implement resources https://stackoverflow.com/a/26853131/2350244
private static CSharpCompilation CreateCSharpCompilation(
IEnumerable <string> sourceFiles,
string assemblyName,
IEnumerable <string> references,
IEnumerable <string> defines,
out List <string> messages
)
{
// parse the source files
var parseOpts =
CSharpParseOptions.Default
.WithLanguageVersion(MaxLanguageVersion)
.WithPreprocessorSymbols(defines);
// and build syntax tree
List <SyntaxTree> syntaxTree = new List <SyntaxTree>();
foreach (var sourceFile in sourceFiles)
{
syntaxTree.Add(
CSharpSyntaxTree.ParseText(
text: File.ReadAllText(sourceFile),
options: parseOpts,
path: sourceFile
)
);
}
// collect references
var refs = new List <string>();
// add mscorelib
refs.Add(typeof(object).Assembly.Location);
foreach (var refFile in references)
{
refs.Add(refFile);
}
messages = new List <string>();
var mdataRefs = new List <MetadataReference>();
foreach (var refPath in refs)
{
messages.Add($"Reference: {refPath}");
mdataRefs.Add(
AssemblyMetadata.CreateFromFile(refPath).GetReference()
);
}
// compile options
var compileOpts =
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithOverflowChecks(true)
.WithPlatform(Platform.X64)
.WithOptimizationLevel(OptimizationLevel.Release);
// create compilation job
return(CSharpCompilation.Create(
assemblyName,
syntaxTree,
mdataRefs,
compileOpts
));
}
// 根据生成的类，动态编译把json转成protobuf
private static void ExportExcelProtobuf(ConfigType configType)
{
string classPath = GetClassDir(configType);
List <SyntaxTree> syntaxTrees = new List <SyntaxTree>();
List <string> protoNames = new List <string>();
foreach (string classFile in Directory.GetFiles(classPath, "*.cs"))
{
protoNames.Add(Path.GetFileNameWithoutExtension(classFile));
syntaxTrees.Add(CSharpSyntaxTree.ParseText(File.ReadAllText(classFile)));
}
List <PortableExecutableReference> references = new List <PortableExecutableReference>();
string assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
references.Add(AssemblyMetadata.CreateFromFile(typeof(object).Assembly.Location).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(typeof(ProtoMemberAttribute).Assembly.Location).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(typeof(BsonDefaultValueAttribute).Assembly.Location).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(typeof(IConfig).Assembly.Location).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(typeof(Attribute).Assembly.Location).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(Path.Combine(assemblyPath, "mscorlib.dll")).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(Path.Combine(assemblyPath, "System.dll")).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll")).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(Path.Combine(assemblyPath, "netstandard.dll")).GetReference());
references.Add(AssemblyMetadata.CreateFromFile(typeof(ISupportInitialize).Assembly.Location).GetReference());
CSharpCompilation compilation = CSharpCompilation.Create(
null,
syntaxTrees.ToArray(),
references.ToArray(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
using MemoryStream memSteam = new MemoryStream();
EmitResult emitResult = compilation.Emit(memSteam);
if (!emitResult.Success)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Diagnostic t in emitResult.Diagnostics)
{
stringBuilder.AppendLine(t.GetMessage());
}
throw new Exception($"动态编译失败:\n{stringBuilder}");
}
memSteam.Seek(0, SeekOrigin.Begin);
Assembly ass = Assembly.Load(memSteam.ToArray());
string dir = GetProtoDir(configType);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
foreach (string protoName in protoNames)
{
Type type = ass.GetType($"ET.{protoName}Category");
Type subType = ass.GetType($"ET.{protoName}");
Serializer.NonGeneric.PrepareSerializer(type);
Serializer.NonGeneric.PrepareSerializer(subType);
string json = File.ReadAllText(Path.Combine(string.Format(jsonDir, configType), $"{protoName}.txt"));
object deserialize = BsonSerializer.Deserialize(json, type);
string path = Path.Combine(dir, $"{protoName}Category.bytes");
using FileStream file = File.Create(path);
Serializer.Serialize(file, deserialize);
}
}