public void TopLevelStatements()
{
var original = CreateCompilation(
@"System.Console.WriteLine(""I'm using top-level statements!"");",
options: TestOptions.DebugExe
);
original.VerifyDiagnostics();
var originalBytes = original.EmitToArray(
new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded)
);
var originalPeReader = new PEReader(originalBytes);
var originalPdbReader = originalPeReader.GetEmbeddedPdbMetadataReader() !;
var factory = LoggerFactory.Create(configure => { });
var logger = factory.CreateLogger("Test");
var optionsReader = new CompilationOptionsReader(
logger,
originalPdbReader,
originalPeReader
);
var compilationFactory = CompilationFactory.Create("test.exe", optionsReader);
var sources = original.SyntaxTrees
.Select(x => compilationFactory.CreateSyntaxTree(x.FilePath, x.GetText()))
.ToImmutableArray();
var references = original.References.ToImmutableArray();
var rebuild = compilationFactory.CreateCompilation(
sources,
original.References.ToImmutableArray()
);
rebuild.VerifyEmitDiagnostics();
}
public async Task <Assembly> Compile(string uuid, string code)
{
var compilation = await Task.Run(() => CompilationFactory.Create(uuid, @"using System; using quiz_oj.IndependentNS;" + code));
await using var ms = new MemoryStream();
var emitRes = compilation.Emit(ms);
if (emitRes.Success)
{
ms.Seek(0, SeekOrigin.Begin);
var context = _contexts.GetOrAdd(uuid, s => new AssemblyLoadContext(s, true));
var a = context.LoadFromStream(ms);
return(a);
}
var builder = new StringBuilder();
builder.AppendLine("Compilation was failed.");
foreach (var resDiagnostic in emitRes.Diagnostics)
{
builder.AppendLine(resDiagnostic.ToString()); Console.WriteLine(resDiagnostic.ToString());
}
builder.AppendLine("Please check your code...");
throw new UserException(builder.ToString());
}
public static void VerifyRoundTrip(
MemoryStream peStream,
MemoryStream?pdbStream,
string assemblyFileName,
ImmutableArray <SyntaxTree> syntaxTrees,
ImmutableArray <MetadataReference> metadataReferences,
CancellationToken cancellationToken = default)
{
using var peReader = new PEReader(peStream);
var embeddedPdbReader = peReader.GetEmbeddedPdbMetadataReader();
var portablePdbReader = pdbStream is not null?MetadataReaderProvider.FromPortablePdbStream(pdbStream).GetMetadataReader() : null;
Assert.True(embeddedPdbReader == null ^ portablePdbReader == null);
var pdbReader = embeddedPdbReader ?? portablePdbReader ?? throw ExceptionUtilities.Unreachable;
var factory = LoggerFactory.Create(configure => { });
var logger = factory.CreateLogger("RoundTripVerification");
var optionsReader = new CompilationOptionsReader(logger, pdbReader, peReader);
VerifyMetadataReferenceInfo(optionsReader, metadataReferences);
var compilationFactory = CompilationFactory.Create(
assemblyFileName,
optionsReader);
using var rebuildPeStream = new MemoryStream();
using var rebuildPdbStream = optionsReader.HasEmbeddedPdb ? null : new MemoryStream();
var emitResult = compilationFactory.Emit(rebuildPeStream, rebuildPdbStream, syntaxTrees, metadataReferences, cancellationToken);
Assert.True(emitResult.Success);
Assert.Equal(peStream.ToArray(), rebuildPeStream.ToArray());
Assert.Equal(pdbStream?.ToArray(), rebuildPdbStream?.ToArray());
}
private static void VerifyRoundTrip <TCompilation>(TCompilation original)
where TCompilation : Compilation
{
Assert.True(original.SyntaxTrees.All(x => !string.IsNullOrEmpty(x.FilePath)));
Assert.True(original.Options.Deterministic);
original.VerifyDiagnostics();
var originalBytes = original.EmitToArray(new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded));
var originalReader = new PEReader(originalBytes);
var originalPdbReader = originalReader.GetEmbeddedPdbMetadataReader();
var factory = LoggerFactory.Create(configure => { });
var logger = factory.CreateLogger("RoundTripVerification");
var optionsReader = new CompilationOptionsReader(logger, originalPdbReader, originalReader);
var assemblyFileName = original.AssemblyName !;
if (typeof(TCompilation) == typeof(CSharpCompilation))
{
var assemblyFileExtension = original.Options.OutputKind switch
{
OutputKind.DynamicallyLinkedLibrary => ".dll",
OutputKind.ConsoleApplication => ".exe",
_ => throw new InvalidOperationException(),
};
assemblyFileName += assemblyFileExtension;
}
var compilationFactory = CompilationFactory.Create(assemblyFileName, optionsReader);
var rebuild = compilationFactory.CreateCompilation(
original.SyntaxTrees.Select(x => compilationFactory.CreateSyntaxTree(x.FilePath, x.GetText())).ToImmutableArray(),
original.References.ToImmutableArray());
Assert.IsType <TCompilation>(rebuild);
VerifyCompilationOptions(original.Options, rebuild.Options);
using var rebuildStream = new MemoryStream();
var result = compilationFactory.Emit(
rebuildStream,
rebuild,
embeddedTexts: ImmutableArray <EmbeddedText> .Empty,
CancellationToken.None);
Assert.Empty(result.Diagnostics);
Assert.True(result.Success);
Assert.Equal(originalBytes.ToArray(), rebuildStream.ToArray());
}
