private static ScriptCompilationResult BuildScriptCompilationResult(AsmDetail detailsToUseForTarget, EmitResult emitResult,
PreparedCompilation compilationPrep)
{
var result = new ScriptCompilationResult {
CompilationResult = emitResult
};
if (emitResult.Diagnostics.Count(d => d.Severity == DiagnosticSeverity.Error) == 0)
{
result.IsCompiled = true;
result.AssemblyFilePath = detailsToUseForTarget.AsmPath;
result.PdbFilePath = detailsToUseForTarget.PdbPath;
result.FoundNamespaces.AddRange(compilationPrep.Usings);
result.FoundMetadataReferences.AddRange(compilationPrep.MetadataReferences);
}
return(result);
}
public static ScriptCompilationResult CompileAndWriteScript(SyntaxTree compilationSource, AsmDetail detailsToUseForTarget,
IEnumerable <string> additionalUsings = null, IEnumerable <MetadataReference> additionalReferences = null)
{
var compilationPrep = PrepareScriptCompilation(compilationSource, detailsToUseForTarget, additionalUsings, additionalReferences);
var emitResult = compilationPrep.Compilation.Emit(detailsToUseForTarget.AsmPath, detailsToUseForTarget.PdbPath);
return(BuildScriptCompilationResult(detailsToUseForTarget, emitResult, compilationPrep));
}
public static ScriptCompilationResult CompileScript(ImmutableList <SyntaxTree> compilationSources, AsmDetail detailsToUseForTarget,
IEnumerable <string> additionalUsings = null, IEnumerable <MetadataReference> additionalReferences = null)
{
var compilationPrep = PrepareCompilation(compilationSources, detailsToUseForTarget, additionalUsings, additionalReferences);
var scriptCompilation = new ScriptCompilationResult();
using (var dllStream = new MemoryStream())
using (var pdbStream = new MemoryStream())
{
var emitResult = compilationPrep.Compilation.Emit(dllStream, pdbStream);
//success sometimes was false when there are warnings, but i didnt write it down
// so maybe it was a specific kind. Or I should pay more attention.
scriptCompilation.CompilationResult = emitResult;
if (emitResult.Diagnostics.Count(d => d.Severity == DiagnosticSeverity.Error) == 0)
{
scriptCompilation.IsCompiled = true;
dllStream.Seek(0, SeekOrigin.Begin);
pdbStream.Seek(0, SeekOrigin.Begin);
scriptCompilation.AssemblyBytes = dllStream.ToArray();
scriptCompilation.PdbBytes = pdbStream.ToArray();
scriptCompilation.AssemblyFilePath = detailsToUseForTarget.AsmPath;
scriptCompilation.PdbFilePath = detailsToUseForTarget.PdbPath;
scriptCompilation.FoundNamespaces.AddRange(compilationPrep.Usings);
scriptCompilation.FoundMetadataReferences.AddRange(compilationPrep.MetadataReferences);
}
}
return(scriptCompilation);
}
private static PreparedCompilation PrepareScriptCompilation(SyntaxTree compilationSource, AsmDetail detailsToUseForTarget,
IEnumerable <string> additionalUsings = null, IEnumerable <MetadataReference> additionalReferences = null)
{
var commonDetails = BuildCommonCompilationDetails(additionalUsings, additionalReferences);
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithUsings(commonDetails.ListOfUsings);
var compilation = CSharpCompilation.CreateScriptCompilation(detailsToUseForTarget.AsmName)
//.WithReferences(commonDetails.MetadataReferences)
.AddReferences(commonDetails.MetadataReferences)
.WithOptions(options)
.AddSyntaxTrees(compilationSource);
return(new PreparedCompilation
{
Options = options,
Compilation = compilation,
MetadataReferences = commonDetails.MetadataReferences,
Usings = commonDetails.ListOfUsings
});
}
private static PreparedCompilation PrepareCompilation(ImmutableList <SyntaxTree> compilationSources, AsmDetail detailsToUseForTarget,
IEnumerable <string> additionalUsings = null, IEnumerable <MetadataReference> additionalReferences = null, OutputKind?outputKind = null)
{
var commonDetails = BuildCommonCompilationDetails(additionalUsings, additionalReferences);
var outputKindForOptions = OutputKind.DynamicallyLinkedLibrary;
if (outputKind.HasValue)
{
outputKindForOptions = outputKind.Value;
}
var options = new CSharpCompilationOptions(outputKindForOptions)
.WithUsings(commonDetails.ListOfUsings)
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
var compilation = CSharpCompilation.Create(detailsToUseForTarget.AsmName,
compilationSources.ToArray(), commonDetails.MetadataReferences);
return(new PreparedCompilation
{
Options = options,
Compilation = compilation,
MetadataReferences = commonDetails.MetadataReferences,
Usings = commonDetails.ListOfUsings
});
}
public static ScriptCompilationResult GetCompilationForLoadDirective(CompileDirection compileDirection, string path, AsmDetail asmDetail,
List <string> namespaces, IEnumerable <MetadataReference> metadataReferences)
{
var targetType = GetResolutionTargetType(path);
var referencedCompilation = new ScriptCompilationResult();
if (compileDirection == CompileDirection.EverythingBuiltAsClassesAndReffed)
{
if (targetType == ResolutionTargetType.Cs)
{
var compilationUnit = GetRootMainCompilationUnit(FileUtilities.GetFileContent(path), CsRewriter.DefaultParseOptions);
referencedCompilation = CompileAndWriteAssembly(ImmutableList.Create(compilationUnit.SyntaxTree),
asmDetail, namespaces, metadataReferences);
}
}
else //compileDirection == CompileDirection.OnlyClassesBuiltAsScriptsAndReffed
{
if (targetType == ResolutionTargetType.Cs)
{
var extraction = CsRewriter.ExtractCompilationDetailFromClassFile(path);
referencedCompilation = CompileAndWriteScript(extraction.CompilationTargets.First(),
asmDetail, namespaces, metadataReferences);
}
else
{
var compilationUnit = GetRootMainCompilationUnit(FileUtilities.GetFileContent(path));
referencedCompilation = CompileAndWriteAssembly(ImmutableList.Create(compilationUnit.SyntaxTree),
asmDetail, namespaces, metadataReferences);
}
}
Debug.Assert(referencedCompilation != null, "load directive compilation should not be null",
$"path '{path}' - compileDirection {compileDirection} - targetType {targetType}\n\n\n");
return(referencedCompilation);
}
/// <summary>
/// Compiles the and writes to a PE.
/// </summary>
/// <param name="compilationSources">The compilation sources.</param>
/// <param name="detailsToUseForTarget">The details to use for target.</param>
/// <param name="additionalUsings">The additional usings.</param>
/// <param name="additionalReferences">The additional references.</param>
/// <param name="outputKind">Defaults to Dll if not specified</param>
/// <returns></returns>
public static ScriptCompilationResult CompileAndWriteAssembly(ImmutableList <SyntaxTree> compilationSources, AsmDetail detailsToUseForTarget,
IEnumerable <string> additionalUsings = null, IEnumerable <MetadataReference> additionalReferences = null,
OutputKind?outputKind = null)
{
var compilationPrep = PrepareCompilation(compilationSources, detailsToUseForTarget, additionalUsings, additionalReferences, outputKind);
var emitResult = compilationPrep.Compilation.Emit(detailsToUseForTarget.AsmPath, detailsToUseForTarget.PdbPath);
return(BuildScriptCompilationResult(detailsToUseForTarget, emitResult, compilationPrep));
}
