public static CSharpCompilationOptions CreateCompilationOptions(this ProjectFileInfo projectFileInfo)
{
var result = new CSharpCompilationOptions(projectFileInfo.OutputKind);
result = result.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafeCode)
{
result = result.WithAllowUnsafe(true);
}
result = result.WithSpecificDiagnosticOptions(CompilationOptionsHelper.GetDefaultSuppressedDiagnosticOptions(projectFileInfo.SuppressedDiagnosticIds));
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
result = result.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
result = result.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(result);
}
private void UpdateCompilationOption(ProjectState state)
{
var context = state.ProjectContext;
var project = context.ProjectFile;
var option = project.GetCompilerOptions(context.TargetFramework, _compilationConfiguration);
var outputKind = option.EmitEntryPoint.GetValueOrDefault() ? OutputKind.ConsoleApplication :
OutputKind.DynamicallyLinkedLibrary;
var generalDiagnosticOpt = (option.WarningsAsErrors ?? false) ? ReportDiagnostic.Error :
ReportDiagnostic.Default;
var optimize = (option.Optimize ?? false) ? OptimizationLevel.Release : OptimizationLevel.Debug;
var csharpOptions = new CSharpCompilationOptions(outputKind)
.WithAllowUnsafe(option.AllowUnsafe ?? false)
.WithPlatform(ParsePlatfrom(option.Platform))
.WithGeneralDiagnosticOption(generalDiagnosticOpt)
.WithOptimizationLevel(optimize)
.WithSpecificDiagnosticOptions(new Dictionary <string, ReportDiagnostic> {
{ "CS1701", ReportDiagnostic.Suppress },
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress },
})
.WithConcurrentBuild(false); // TODO: actually just need to disable on mono
if (!string.IsNullOrEmpty(option.KeyFile))
{
var cryptoKeyFile = Path.GetFullPath(Path.Combine(project.ProjectDirectory, option.KeyFile));
if (File.Exists(cryptoKeyFile))
{
var strongNameProvider = new DesktopStrongNameProvider(ImmutableArray.Create(project.ProjectDirectory));
csharpOptions = csharpOptions
.WithStrongNameProvider(strongNameProvider)
.WithCryptoPublicKey(SnkUtils.ExtractPublicKey(File.ReadAllBytes(cryptoKeyFile)));
}
}
var parseOptions = new CSharpParseOptions(languageVersion: ParseLanguageVersion(option.LanguageVersion),
preprocessorSymbols: option.Defines);
if (option.GenerateXmlDocumentation ?? false)
{
csharpOptions = csharpOptions.WithXmlReferenceResolver(XmlFileResolver.Default);
parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Diagnose);
}
_omnisharpWorkspace.SetCompilationOptions(state.Id, csharpOptions);
_omnisharpWorkspace.SetParseOptions(state.Id, parseOptions);
}
private static CSharpCompilationOptions CreateCompilationOptions(ProjectFileInfo projectFileInfo)
{
var result = new CSharpCompilationOptions(projectFileInfo.OutputKind);
result = result.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafeCode)
{
result = result.WithAllowUnsafe(true);
}
var specificDiagnosticOptions = new Dictionary <string, ReportDiagnostic>(projectFileInfo.SuppressedDiagnosticIds.Count)
{
// Ensure that specific warnings about assembly references are always suppressed.
{ "CS1701", ReportDiagnostic.Suppress },
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress }
};
if (projectFileInfo.SuppressedDiagnosticIds.Any())
{
foreach (var id in projectFileInfo.SuppressedDiagnosticIds)
{
if (!specificDiagnosticOptions.ContainsKey(id))
{
specificDiagnosticOptions.Add(id, ReportDiagnostic.Suppress);
}
}
}
result = result.WithSpecificDiagnosticOptions(specificDiagnosticOptions);
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
result = result.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
result = result.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(result);
}
public static CSharpCompilationOptions CreateCompilationOptions(this ProjectFileInfo projectFileInfo)
{
var compilationOptions = new CSharpCompilationOptions(projectFileInfo.OutputKind);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default)
.WithSpecificDiagnosticOptions(projectFileInfo.GetDiagnosticOptions())
.WithOverflowChecks(projectFileInfo.CheckForOverflowUnderflow);
if (projectFileInfo.AllowUnsafeCode)
{
compilationOptions = compilationOptions.WithAllowUnsafe(true);
}
if (projectFileInfo.TreatWarningsAsErrors)
{
compilationOptions = compilationOptions.WithGeneralDiagnosticOption(ReportDiagnostic.Error);
}
if (projectFileInfo.NullableContextOptions != compilationOptions.NullableContextOptions)
{
compilationOptions = compilationOptions.WithNullableContextOptions(projectFileInfo.NullableContextOptions);
}
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
compilationOptions = compilationOptions.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
compilationOptions = compilationOptions.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(compilationOptions);
}
public static Result BuildCode(string code, string moduleName, string strongNameKeyFile = null)
{
var metadataref = new List <MetadataReference> {
};
// Detect the file location for the library that defines the object type
var systemRefLocation = typeof(object).GetTypeInfo().Assembly.Location;
// Create a reference to the library
var systemReference = MetadataReference.CreateFromFile(systemRefLocation);
var md = new HashSet <Assembly> {
typeof(int).Assembly, typeof(ITestStep).Assembly
};
try
{
var asm = Assembly.Load("netstandard, Version=2.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("mscorlib");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("System");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("System.Core");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("System.Runtime");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("System.Collections");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("System.ComponentModel.TypeConverter");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("System.ObjectModel");
md.Add(asm);
}
catch { }
try
{
var asm = Assembly.Load("Microsoft.CSharp");
md.Add(asm);
}
catch { }
md.Add(Assembly.GetEntryAssembly());
foreach (var path in md)
{
if (path == null)
{
continue;
}
var r = MetadataReference.CreateFromFile(path.Location);
metadataref.Add(r);
}
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, true, platform: Platform.AnyCpu, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default)
.WithReportSuppressedDiagnostics(true);
if (strongNameKeyFile != null)
{
options = options.WithStrongNameProvider(new DesktopStrongNameProvider(ImmutableArray.Create(Path.GetDirectoryName(Path.GetFullPath(strongNameKeyFile)))))
.WithCryptoKeyFile(Path.GetFileName(strongNameKeyFile));
}
CSharpCompilation compilation = CSharpCompilation.Create(moduleName,
syntaxTrees: new[] { SF.ParseSyntaxTree(code) },
references: metadataref,
options: options
);
using (var ms = new MemoryStream()){
var result = compilation.Emit(ms);
return(new Result {
Success = result.Success, Bytes = ms.ToArray(), Log = string.Join("\n", result.Diagnostics)
});
}
}
public void Initalize(IConfiguration configuration)
{
_options = new MSBuildOptions();
ConfigurationBinder.Bind(configuration, _options);
if (_options.WaitForDebugger)
{
Console.WriteLine($"Attach to process {System.Diagnostics.Process.GetCurrentProcess().Id}");
while (!System.Diagnostics.Debugger.IsAttached)
{
System.Threading.Thread.Sleep(100);
}
}
var solutionFilePath = _env.SolutionFilePath;
if (string.IsNullOrEmpty(solutionFilePath))
{
var solutions = Directory.GetFiles(_env.Path, "*.sln");
var result = SolutionPicker.ChooseSolution(_env.Path, solutions);
if (result.Message != null)
{
_logger.LogInformation(result.Message);
}
if (result.Solution == null)
{
return;
}
solutionFilePath = result.Solution;
}
SolutionFile solutionFile = null;
_context.SolutionPath = solutionFilePath;
using (var stream = File.OpenRead(solutionFilePath))
{
using (var reader = new StreamReader(stream))
{
solutionFile = SolutionFile.Parse(reader);
}
}
_logger.LogInformation($"Detecting projects in '{solutionFilePath}'.");
foreach (var block in solutionFile.ProjectBlocks)
{
if (!_supportsProjectTypes.Contains(block.ProjectTypeGuid))
{
if (UnityTypeGuid(block.ProjectName) != block.ProjectTypeGuid)
{
_logger.LogWarning("Skipped unsupported project type '{0}'", block.ProjectPath);
continue;
}
}
if (_context.ProjectGuidToWorkspaceMapping.ContainsKey(block.ProjectGuid))
{
continue;
}
var projectFilePath = Path.GetFullPath(Path.GetFullPath(Path.Combine(_env.Path, block.ProjectPath.Replace('\\', Path.DirectorySeparatorChar))));
_logger.LogInformation($"Loading project from '{projectFilePath}'.");
var projectFileInfo = CreateProject(projectFilePath);
if (projectFileInfo == null)
{
continue;
}
var compilationOptions = new CSharpCompilationOptions(projectFileInfo.OutputKind);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafe)
{
compilationOptions = compilationOptions.WithAllowUnsafe(true);
}
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.ProjectDirectory, projectFileInfo.AssemblyOriginatorKeyFile);
compilationOptions = compilationOptions.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (projectFileInfo.GenerateXmlDocumentation)
{
compilationOptions = compilationOptions.WithXmlReferenceResolver(XmlFileResolver.Default);
}
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(projectFileInfo.Name),
VersionStamp.Create(),
projectFileInfo.Name,
projectFileInfo.AssemblyName,
LanguageNames.CSharp,
projectFileInfo.ProjectFilePath,
compilationOptions: compilationOptions);
_workspace.AddProject(projectInfo);
projectFileInfo.WorkspaceId = projectInfo.Id;
_context.Projects[projectFileInfo.ProjectFilePath] = projectFileInfo;
_context.ProjectGuidToWorkspaceMapping[block.ProjectGuid] = projectInfo.Id;
_watcher.Watch(projectFilePath, OnProjectChanged);
}
foreach (var projectFileInfo in _context.Projects.Values)
{
UpdateProject(projectFileInfo);
}
}
private void UpdateCompilationOption(ProjectState state)
{
var context = state.ProjectContext;
var project = context.ProjectFile;
var option = project.GetCompilerOptions(context.TargetFramework, _compilationConfiguration);
var outputKind = option.EmitEntryPoint.GetValueOrDefault() ? OutputKind.ConsoleApplication :
OutputKind.DynamicallyLinkedLibrary;
var generalDiagnosticOpt = (option.WarningsAsErrors ?? false) ? ReportDiagnostic.Error :
ReportDiagnostic.Default;
var optimize = (option.Optimize ?? false) ? OptimizationLevel.Release : OptimizationLevel.Debug;
var csharpOptions = new CSharpCompilationOptions(outputKind)
.WithAllowUnsafe(option.AllowUnsafe ?? false)
.WithPlatform(ParsePlatfrom(option.Platform))
.WithGeneralDiagnosticOption(generalDiagnosticOpt)
.WithOptimizationLevel(optimize)
.WithSpecificDiagnosticOptions(new Dictionary<string, ReportDiagnostic> {
{ "CS1701", ReportDiagnostic.Suppress },
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress },
})
.WithConcurrentBuild(false); // TODO: actually just need to disable on mono
if (!string.IsNullOrEmpty(option.KeyFile))
{
var cryptoKeyFile = Path.GetFullPath(Path.Combine(project.ProjectDirectory, option.KeyFile));
if (File.Exists(cryptoKeyFile))
{
var strongNameProvider = new DesktopStrongNameProvider(ImmutableArray.Create(project.ProjectDirectory));
csharpOptions = csharpOptions
.WithStrongNameProvider(strongNameProvider)
.WithCryptoPublicKey(SnkUtils.ExtractPublicKey(File.ReadAllBytes(cryptoKeyFile)));
}
}
var parseOptions = new CSharpParseOptions(languageVersion: ParseLanguageVersion(option.LanguageVersion),
preprocessorSymbols: option.Defines);
_omnisharpWorkspace.SetCompilationOptions(state.Id, csharpOptions);
_omnisharpWorkspace.SetParseOptions(state.Id, parseOptions);
}