protected static bool AddNonCultureResources(Project project, List <string> compilerArgs, string intermediateOutputPath)
{
var resgenFiles = CompilerUtil.GetNonCultureResources(project, intermediateOutputPath);
foreach (var resgenFile in resgenFiles)
{
if (ResourceUtility.IsResxFile(resgenFile.InputFile))
{
var arguments = new[]
{
$"{resgenFile.InputFile}",
$"-o:{resgenFile.OutputFile}",
$"-v:{project.Version.Version}"
};
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-resgen-resx.rsp");
File.WriteAllLines(rsp, arguments);
var result = Resgen.ResgenCommand.Run(new[] { $"@{rsp}" });
if (result != 0)
{
return(false);
}
compilerArgs.Add($"--resource:\"{resgenFile.OutputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
}
else
{
compilerArgs.Add($"--resource:\"{resgenFile.InputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
}
}
return(true);
}
private static bool AddNonCultureResources(Project project, List <string> compilerArgs, string intermediateOutputPath)
{
var resgenFiles = CompilerUtil.GetNonCultureResources(project, intermediateOutputPath);
foreach (var resgenFile in resgenFiles)
{
if (ResourceUtility.IsResxFile(resgenFile.InputFile))
{
var result =
Command.Create("dotnet-resgen",
$"\"{resgenFile.InputFile}\" -o \"{resgenFile.OutputFile}\" -v \"{project.Version.Version}\"")
.ForwardStdErr()
.ForwardStdOut()
.Execute();
if (result.ExitCode != 0)
{
return(false);
}
compilerArgs.Add($"--resource:\"{resgenFile.OutputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
}
else
{
compilerArgs.Add($"--resource:\"{resgenFile.InputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
}
}
return(true);
}
protected static bool GenerateCultureResourceAssemblies(
Project project,
List <LibraryExport> dependencies,
string outputPath,
CommonCompilerOptions compilationOptions)
{
var referencePaths = CompilerUtil.GetReferencePathsForCultureResgen(dependencies);
List <CompilerUtil.CultureResgenIO> cultureResgenFiles = null;
if (compilationOptions.EmbedInclude == null)
{
cultureResgenFiles = CompilerUtil.GetCultureResources(project, outputPath);
}
else
{
cultureResgenFiles = CompilerUtil.GetCultureResourcesFromIncludeEntries(project, outputPath, compilationOptions);
}
foreach (var resgenFile in cultureResgenFiles)
{
var resourceOutputPath = Path.GetDirectoryName(resgenFile.OutputFile);
if (!Directory.Exists(resourceOutputPath))
{
Directory.CreateDirectory(resourceOutputPath);
}
var result = Resgen.ResgenCommand.Run(
resgenFile.InputFileToMetadata.Select(fileToMetadata => $"{fileToMetadata.Key},{fileToMetadata.Value}"),
resgenFile.Culture,
resgenFile.OutputFile,
project.Version.Version.ToString(),
referencePaths);
if (result != 0)
{
return(false);
}
}
return(true);
}
protected static bool AddNonCultureResources(
Project project,
List <string> compilerArgs,
string intermediateOutputPath,
CommonCompilerOptions compilationOptions)
{
List <CompilerUtil.NonCultureResgenIO> resgenFiles = null;
if (compilationOptions.EmbedInclude == null)
{
resgenFiles = CompilerUtil.GetNonCultureResources(project, intermediateOutputPath);
}
else
{
resgenFiles = CompilerUtil.GetNonCultureResourcesFromIncludeEntries(project, intermediateOutputPath, compilationOptions);
}
foreach (var resgenFile in resgenFiles)
{
if (ResourceUtility.IsResxFile(resgenFile.InputFile))
{
var result = Resgen.ResgenCommand.Run(
new[] { resgenFile.InputFile },
culture: null,
outputFile: resgenFile.OutputFile,
version: project.Version.Version.ToString(),
compilationReferences: null);
if (result != 0)
{
return(false);
}
compilerArgs.Add($"--resource:\"{resgenFile.OutputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
}
else
{
compilerArgs.Add($"--resource:\"{resgenFile.InputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
}
}
return(true);
}
private static bool GenerateCultureResourceAssemblies(
Project project,
List <LibraryExport> dependencies,
string intermediateOutputPath,
string outputPath)
{
var referencePaths = CompilerUtil.GetReferencePathsForCultureResgen(dependencies);
var resgenReferenceArgs = referencePaths.Select(path => $"-r:{path}").ToList();
var cultureResgenFiles = CompilerUtil.GetCultureResources(project, outputPath);
foreach (var resgenFile in cultureResgenFiles)
{
var resourceOutputPath = Path.GetDirectoryName(resgenFile.OutputFile);
if (!Directory.Exists(resourceOutputPath))
{
Directory.CreateDirectory(resourceOutputPath);
}
var arguments = new List <string>();
arguments.AddRange(resgenReferenceArgs);
arguments.Add($"-o:{resgenFile.OutputFile}");
arguments.Add($"-c:{resgenFile.Culture}");
arguments.Add($"-v:{project.Version.Version}");
arguments.AddRange(resgenFile.InputFileToMetadata.Select(fileToMetadata => $"{fileToMetadata.Key},{fileToMetadata.Value}"));
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-resgen.rsp");
File.WriteAllLines(rsp, arguments);
var result = Command.CreateDotNet("resgen", new[] { $"@{rsp}" })
.ForwardStdErr()
.ForwardStdOut()
.Execute();
if (result.ExitCode != 0)
{
return(false);
}
}
return(true);
}
private static bool AddNonCultureResources(Project project, List <string> compilerArgs, string intermediateOutputPath)
{
var resgenFiles = CompilerUtil.GetNonCultureResources(project, intermediateOutputPath);
foreach (var resgenFile in resgenFiles)
{
if (ResourceUtility.IsResxFile(resgenFile.InputFile))
{
var arguments = new[]
{
resgenFile.InputFile,
$"-o:{resgenFile.OutputFile}",
$"-v:{project.Version.Version}"
};
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-resgen-resx.rsp");
File.WriteAllLines(rsp, arguments);
var result =
Command.CreateDotNet("resgen", new[] { $"@{rsp}" })
.ForwardStdErr()
.ForwardStdOut()
.Execute();
if (result.ExitCode != 0)
{
return(false);
}
compilerArgs.Add($"--resource:\"{resgenFile.OutputFile},{Path.GetFileName(resgenFile.MetadataName)}\"");
}
else
{
compilerArgs.Add($"--resource:\"{resgenFile.InputFile},{Path.GetFileName(resgenFile.MetadataName)}\"");
}
}
return(true);
}
private static bool GenerateCultureResourceAssemblies(Project project, List <LibraryExport> dependencies, string outputPath)
{
var referencePaths = CompilerUtil.GetReferencePathsForCultureResgen(dependencies);
var resgenReferenceArgs = referencePaths.Select(referencePath => $"-r \"{referencePath}\"").ToList();
var cultureResgenFiles = CompilerUtil.GetCultureResources(project, outputPath);
foreach (var resgenFile in cultureResgenFiles)
{
var resourceOutputPath = Path.GetDirectoryName(resgenFile.OutputFile);
if (!Directory.Exists(resourceOutputPath))
{
Directory.CreateDirectory(resourceOutputPath);
}
var arguments = new List <string>();
arguments.AddRange(resgenReferenceArgs);
arguments.Add($"-o \"{resgenFile.OutputFile}\"");
arguments.Add($"-c {resgenFile.Culture}");
arguments.Add($"-v {project.Version.Version}");
arguments.AddRange(resgenFile.InputFileToMetadata.Select(fileToMetadata => $"\"{fileToMetadata.Key}\",{fileToMetadata.Value}"));
var result = Command.Create("dotnet-resgen", arguments)
.ForwardStdErr()
.ForwardStdOut()
.Execute();
if (result.ExitCode != 0)
{
return(false);
}
}
return(true);
}
public override bool Compile(ProjectContext context, BuildCommandApp args)
{
// Set up Output Paths
var outputPaths = context.GetOutputPaths(args.ConfigValue, args.BuildBasePathValue);
var outputPath = outputPaths.CompilationOutputPath;
var intermediateOutputPath = outputPaths.IntermediateOutputDirectoryPath;
Directory.CreateDirectory(outputPath);
Directory.CreateDirectory(intermediateOutputPath);
// Create the library exporter
var exporter = context.CreateExporter(args.ConfigValue, args.BuildBasePathValue);
// Gather exports for the project
var dependencies = exporter.GetDependencies().ToList();
Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}");
var sw = Stopwatch.StartNew();
var diagnostics = new List <DiagnosticMessage>();
var missingFrameworkDiagnostics = new List <DiagnosticMessage>();
// Collect dependency diagnostics
foreach (var diag in context.LibraryManager.GetAllDiagnostics())
{
if (diag.ErrorCode == ErrorCodes.DOTNET1011 ||
diag.ErrorCode == ErrorCodes.DOTNET1012)
{
missingFrameworkDiagnostics.Add(diag);
}
diagnostics.Add(diag);
}
if (diagnostics.Any(d => d.Severity == DiagnosticMessageSeverity.Error))
{
// We got an unresolved dependency or missing framework. Don't continue the compilation.
PrintSummary(diagnostics, sw);
return(false);
}
// Get compilation options
var outputName = outputPaths.CompilationFiles.Assembly;
// Assemble args
var compilerArgs = new List <string>()
{
$"--temp-output:{intermediateOutputPath}",
$"--out:{outputName}"
};
var compilationOptions = context.ResolveCompilationOptions(args.ConfigValue);
// Set default platform if it isn't already set and we're on desktop
if (compilationOptions.EmitEntryPoint == true && string.IsNullOrEmpty(compilationOptions.Platform) && context.TargetFramework.IsDesktop())
{
// See https://github.com/dotnet/cli/issues/2428 for more details.
compilationOptions.Platform = RuntimeInformation.ProcessArchitecture == Architecture.X64 ?
"x64" : "anycpu32bitpreferred";
}
var languageId = CompilerUtil.ResolveLanguageId(context);
var references = new List <string>();
// Add compilation options to the args
compilerArgs.AddRange(compilationOptions.SerializeToArgs());
// Add metadata options
compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context)));
foreach (var dependency in dependencies)
{
references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath));
compilerArgs.AddRange(dependency.SourceReferences.Select(s => s.GetTransformedFile(intermediateOutputPath)));
foreach (var resourceFile in dependency.EmbeddedResources)
{
var transformedResource = resourceFile.GetTransformedFile(intermediateOutputPath);
var resourceName = ResourceManifestName.CreateManifestName(
Path.GetFileName(resourceFile.ResolvedPath), compilationOptions.OutputName);
compilerArgs.Add($"--resource:\"{transformedResource}\",{resourceName}");
}
// Add analyzer references
compilerArgs.AddRange(dependency.AnalyzerReferences
.Where(a => a.AnalyzerLanguage == languageId)
.Select(a => $"--analyzer:{a.AssemblyPath}"));
}
compilerArgs.AddRange(references.Select(r => $"--reference:{r}"));
if (compilationOptions.PreserveCompilationContext == true)
{
var allExports = exporter.GetAllExports().ToList();
var dependencyContext = new DependencyContextBuilder().Build(compilationOptions,
allExports,
allExports,
false, // For now, just assume non-portable mode in the legacy deps file (this is going away soon anyway)
context.TargetFramework,
context.RuntimeIdentifier ?? string.Empty);
var writer = new DependencyContextWriter();
var depsJsonFile = Path.Combine(intermediateOutputPath, compilationOptions.OutputName + "dotnet-compile.deps.json");
using (var fileStream = File.Create(depsJsonFile))
{
writer.Write(dependencyContext, fileStream);
}
compilerArgs.Add($"--resource:\"{depsJsonFile}\",{compilationOptions.OutputName}.deps.json");
}
if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath, compilationOptions))
{
return(false);
}
// Add project source files
var sourceFiles = CompilerUtil.GetCompilationSources(context, compilationOptions);
compilerArgs.AddRange(sourceFiles);
var compilerName = compilationOptions.CompilerName;
// Write RSP file
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.rsp");
File.WriteAllLines(rsp, compilerArgs);
// Run pre-compile event
var contextVariables = new Dictionary <string, string>()
{
{ "compile:TargetFramework", context.TargetFramework.GetShortFolderName() },
{ "compile:FullTargetFramework", context.TargetFramework.DotNetFrameworkName },
{ "compile:Configuration", args.ConfigValue },
{ "compile:OutputFile", outputName },
{ "compile:OutputDir", outputPath.TrimEnd('\\', '/') },
{ "compile:ResponseFile", rsp }
};
if (context.ProjectFile.HasRuntimeOutput(args.ConfigValue))
{
var runtimeContext = args.Workspace.GetRuntimeContext(context, args.GetRuntimes());
var runtimeOutputPath = runtimeContext.GetOutputPaths(args.ConfigValue, args.BuildBasePathValue, args.OutputValue);
contextVariables.Add(
"compile:RuntimeOutputDir",
runtimeOutputPath.RuntimeOutputPath.TrimEnd('\\', '/'));
contextVariables.Add(
"compile:RuntimeIdentifier",
runtimeContext.RuntimeIdentifier);
}
_scriptRunner.RunScripts(context, ScriptNames.PreCompile, contextVariables);
// Cache the reporters before invoking the command in case it is a built-in command, which replaces
// the static Reporter instances.
Reporter errorReporter = Reporter.Error;
Reporter outputReporter = Reporter.Output;
CommandResult result = _commandFactory.Create($"compile-{compilerName}", new[] { $"@{rsp}" })
.WorkingDirectory(context.ProjectDirectory)
.OnErrorLine(line => HandleCompilerOutputLine(line, context, diagnostics, errorReporter))
.OnOutputLine(line => HandleCompilerOutputLine(line, context, diagnostics, outputReporter))
.Execute();
// Run post-compile event
contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString();
_scriptRunner.RunScripts(context, ScriptNames.PostCompile, contextVariables);
var success = result.ExitCode == 0;
if (!success)
{
Reporter.Error.WriteLine($"{result.StartInfo.FileName} {result.StartInfo.Arguments} returned Exit Code {result.ExitCode}");
}
if (success)
{
success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, outputPath, compilationOptions);
}
return(PrintSummary(diagnostics, sw, success));
}
private static bool CompileProject(ProjectContext context, CompilerCommandApp args)
{
// Set up Output Paths
string outputPath = context.GetOutputPath(args.ConfigValue, args.OutputValue);
string intermediateOutputPath = context.GetIntermediateOutputPath(args.ConfigValue, args.IntermediateValue, outputPath);
Directory.CreateDirectory(outputPath);
Directory.CreateDirectory(intermediateOutputPath);
// Create the library exporter
var exporter = context.CreateExporter(args.ConfigValue);
// Gather exports for the project
var dependencies = exporter.GetDependencies().ToList();
Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}");
var sw = Stopwatch.StartNew();
var diagnostics = new List <DiagnosticMessage>();
var missingFrameworkDiagnostics = new List <DiagnosticMessage>();
// Collect dependency diagnostics
foreach (var diag in context.LibraryManager.GetAllDiagnostics())
{
if (diag.ErrorCode == ErrorCodes.DOTNET1011 ||
diag.ErrorCode == ErrorCodes.DOTNET1012)
{
missingFrameworkDiagnostics.Add(diag);
}
diagnostics.Add(diag);
}
if (missingFrameworkDiagnostics.Count > 0)
{
// The framework isn't installed so we should short circuit the rest of the compilation
// so we don't get flooded with errors
PrintSummary(missingFrameworkDiagnostics, sw);
return(false);
}
// Get compilation options
var outputName = GetProjectOutput(context.ProjectFile, context.TargetFramework, args.ConfigValue, outputPath);
// Assemble args
var compilerArgs = new List <string>()
{
$"--temp-output:{intermediateOutputPath}",
$"--out:{outputName}"
};
var compilationOptions = context.ProjectFile.GetCompilerOptions(context.TargetFramework, args.ConfigValue);
// Path to strong naming key in environment variable overrides path in project.json
var environmentKeyFile = Environment.GetEnvironmentVariable(EnvironmentNames.StrongNameKeyFile);
if (!string.IsNullOrWhiteSpace(environmentKeyFile))
{
compilationOptions.KeyFile = environmentKeyFile;
}
else if (!string.IsNullOrWhiteSpace(compilationOptions.KeyFile))
{
// Resolve full path to key file
compilationOptions.KeyFile = Path.GetFullPath(Path.Combine(context.ProjectFile.ProjectDirectory, compilationOptions.KeyFile));
}
var references = new List <string>();
// Add compilation options to the args
compilerArgs.AddRange(compilationOptions.SerializeToArgs());
// Add metadata options
compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context)));
foreach (var dependency in dependencies)
{
var projectDependency = dependency.Library as ProjectDescription;
if (projectDependency != null)
{
if (projectDependency.Project.Files.SourceFiles.Any())
{
var projectOutputPath = GetProjectOutput(projectDependency.Project, projectDependency.Framework, args.ConfigValue, outputPath);
references.Add(projectOutputPath);
}
}
else
{
references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath));
}
compilerArgs.AddRange(dependency.SourceReferences);
}
compilerArgs.AddRange(references.Select(r => $"--reference:{r}"));
if (compilationOptions.PreserveCompilationContext == true)
{
var dependencyContext = DependencyContextBuilder.Build(compilationOptions,
exporter,
args.ConfigValue,
context.TargetFramework,
context.RuntimeIdentifier);
var writer = new DependencyContextWriter();
var depsJsonFile = Path.Combine(intermediateOutputPath, context.ProjectFile.Name + "dotnet-compile.deps.json");
using (var fileStream = File.Create(depsJsonFile))
{
writer.Write(dependencyContext, fileStream);
}
compilerArgs.Add($"--resource:\"{depsJsonFile}\",{context.ProjectFile.Name}.deps.json");
var refsFolder = Path.Combine(outputPath, "refs");
if (Directory.Exists(refsFolder))
{
Directory.Delete(refsFolder, true);
}
Directory.CreateDirectory(refsFolder);
foreach (var reference in references)
{
File.Copy(reference, Path.Combine(refsFolder, Path.GetFileName(reference)));
}
}
if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath))
{
return(false);
}
// Add project source files
var sourceFiles = context.ProjectFile.Files.SourceFiles;
compilerArgs.AddRange(sourceFiles);
var compilerName = CompilerUtil.ResolveCompilerName(context);
// Write RSP file
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.{context.ProjectFile.Name}.rsp");
File.WriteAllLines(rsp, compilerArgs);
// Run pre-compile event
var contextVariables = new Dictionary <string, string>()
{
{ "compile:TargetFramework", context.TargetFramework.DotNetFrameworkName },
{ "compile:Configuration", args.ConfigValue },
{ "compile:OutputFile", outputName },
{ "compile:OutputDir", outputPath },
{ "compile:ResponseFile", rsp }
};
RunScripts(context, ScriptNames.PreCompile, contextVariables);
var result = Command.Create($"dotnet-compile-{compilerName}", $"@\"{rsp}\"")
.OnErrorLine(line =>
{
var diagnostic = ParseDiagnostic(context.ProjectDirectory, line);
if (diagnostic != null)
{
diagnostics.Add(diagnostic);
}
else
{
Reporter.Error.WriteLine(line);
}
})
.OnOutputLine(line =>
{
var diagnostic = ParseDiagnostic(context.ProjectDirectory, line);
if (diagnostic != null)
{
diagnostics.Add(diagnostic);
}
else
{
Reporter.Output.WriteLine(line);
}
}).Execute();
// Run post-compile event
contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString();
RunScripts(context, ScriptNames.PostCompile, contextVariables);
var success = result.ExitCode == 0;
if (success)
{
success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, outputPath);
}
if (success && !args.NoHostValue && compilationOptions.EmitEntryPoint.GetValueOrDefault())
{
var rids = PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers();
var runtimeContext = ProjectContext.Create(context.ProjectDirectory, context.TargetFramework, rids);
runtimeContext
.MakeCompilationOutputRunnable(outputPath, args.ConfigValue);
}
return(PrintSummary(diagnostics, sw, success));
}
private static bool CompileNative(
ProjectContext context,
CompilerCommandApp args)
{
var outputPath = context.GetOutputPath(args.ConfigValue, args.OutputValue);
var nativeOutputPath = Path.Combine(outputPath, "native");
var intermediateOutputPath =
context.GetIntermediateOutputPath(args.ConfigValue, args.IntermediateValue, outputPath);
var nativeIntermediateOutputPath = Path.Combine(intermediateOutputPath, "native");
Directory.CreateDirectory(nativeOutputPath);
Directory.CreateDirectory(nativeIntermediateOutputPath);
var compilationOptions = context.ProjectFile.GetCompilerOptions(context.TargetFramework, args.ConfigValue);
var managedOutput =
CompilerUtil.GetCompilationOutput(context.ProjectFile, context.TargetFramework, args.ConfigValue, outputPath);
var nativeArgs = new List <string>();
// Input Assembly
nativeArgs.Add($"{managedOutput}");
// ILC Args
if (!string.IsNullOrWhiteSpace(args.IlcArgsValue))
{
nativeArgs.Add("--ilcargs");
nativeArgs.Add($"{args.IlcArgsValue}");
}
// ILC Path
if (!string.IsNullOrWhiteSpace(args.IlcPathValue))
{
nativeArgs.Add("--ilcpath");
nativeArgs.Add(args.IlcPathValue);
}
// ILC SDK Path
if (!string.IsNullOrWhiteSpace(args.IlcSdkPathValue))
{
nativeArgs.Add("--ilcsdkpath");
nativeArgs.Add(args.IlcSdkPathValue);
}
// AppDep SDK Path
if (!string.IsNullOrWhiteSpace(args.AppDepSdkPathValue))
{
nativeArgs.Add("--appdepsdk");
nativeArgs.Add(args.AppDepSdkPathValue);
}
// CodeGen Mode
if (args.IsCppModeValue)
{
nativeArgs.Add("--mode");
nativeArgs.Add("cpp");
}
if (!string.IsNullOrWhiteSpace(args.CppCompilerFlagsValue))
{
nativeArgs.Add("--cppcompilerflags");
nativeArgs.Add(args.CppCompilerFlagsValue);
}
// Configuration
if (args.ConfigValue != null)
{
nativeArgs.Add("--configuration");
nativeArgs.Add(args.ConfigValue);
}
// Architecture
if (args.ArchValue != null)
{
nativeArgs.Add("--arch");
nativeArgs.Add(args.ArchValue);
}
// Intermediate Path
nativeArgs.Add("--temp-output");
nativeArgs.Add($"{nativeIntermediateOutputPath}");
// Output Path
nativeArgs.Add("--output");
nativeArgs.Add($"{nativeOutputPath}");
// Write Response File
var rsp = Path.Combine(nativeIntermediateOutputPath, $"dotnet-compile-native.{context.ProjectFile.Name}.rsp");
File.WriteAllLines(rsp, nativeArgs);
// TODO Add -r assembly.dll for all Nuget References
// Need CoreRT Framework published to nuget
// Do Native Compilation
var result = Command.Create("dotnet-compile-native", $"--rsp \"{rsp}\"")
.ForwardStdErr()
.ForwardStdOut()
.Execute();
return(result.ExitCode == 0);
}
private static bool CompileProject(ProjectContext context, CompilerCommandApp args)
{
// Set up Output Paths
var outputPathCalculator = context.GetOutputPathCalculator(args.OutputValue);
var outputPath = outputPathCalculator.GetOutputDirectoryPath(args.ConfigValue);
var intermediateOutputPath =
outputPathCalculator.GetIntermediateOutputDirectoryPath(args.ConfigValue, args.IntermediateValue);
Directory.CreateDirectory(outputPath);
Directory.CreateDirectory(intermediateOutputPath);
// Create the library exporter
var exporter = context.CreateExporter(args.ConfigValue);
// Gather exports for the project
var dependencies = exporter.GetDependencies().ToList();
Reporter.Output.WriteLine($"Compiling {context.RootProject.Identity.Name.Yellow()} for {context.TargetFramework.DotNetFrameworkName.Yellow()}");
var sw = Stopwatch.StartNew();
var diagnostics = new List <DiagnosticMessage>();
var missingFrameworkDiagnostics = new List <DiagnosticMessage>();
// Collect dependency diagnostics
foreach (var diag in context.LibraryManager.GetAllDiagnostics())
{
if (diag.ErrorCode == ErrorCodes.DOTNET1011 ||
diag.ErrorCode == ErrorCodes.DOTNET1012)
{
missingFrameworkDiagnostics.Add(diag);
}
diagnostics.Add(diag);
}
if (missingFrameworkDiagnostics.Count > 0)
{
// The framework isn't installed so we should short circuit the rest of the compilation
// so we don't get flooded with errors
PrintSummary(missingFrameworkDiagnostics, sw);
return(false);
}
// Get compilation options
var outputName = outputPathCalculator.GetAssemblyPath(args.ConfigValue);
// Assemble args
var compilerArgs = new List <string>()
{
$"--temp-output:\"{intermediateOutputPath}\"",
$"--out:\"{outputName}\""
};
var compilationOptions = CompilerUtil.ResolveCompilationOptions(context, args.ConfigValue);
var languageId = CompilerUtil.ResolveLanguageId(context);
var references = new List <string>();
// Add compilation options to the args
compilerArgs.AddRange(compilationOptions.SerializeToArgs());
// Add metadata options
compilerArgs.AddRange(AssemblyInfoOptions.SerializeToArgs(AssemblyInfoOptions.CreateForProject(context)));
foreach (var dependency in dependencies)
{
references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath));
compilerArgs.AddRange(dependency.SourceReferences.Select(s => $"\"{s}\""));
// Add analyzer references
compilerArgs.AddRange(dependency.AnalyzerReferences
.Where(a => a.AnalyzerLanguage == languageId)
.Select(a => $"--analyzer:\"{a.AssemblyPath}\""));
}
compilerArgs.AddRange(references.Select(r => $"--reference:\"{r}\""));
if (compilationOptions.PreserveCompilationContext == true)
{
var dependencyContext = DependencyContextBuilder.Build(compilationOptions,
exporter,
args.ConfigValue,
context.TargetFramework,
context.RuntimeIdentifier);
var writer = new DependencyContextWriter();
var depsJsonFile = Path.Combine(intermediateOutputPath, context.ProjectFile.Name + "dotnet-compile.deps.json");
using (var fileStream = File.Create(depsJsonFile))
{
writer.Write(dependencyContext, fileStream);
}
compilerArgs.Add($"--resource:\"{depsJsonFile},{context.ProjectFile.Name}.deps.json\"");
}
if (!AddNonCultureResources(context.ProjectFile, compilerArgs, intermediateOutputPath))
{
return(false);
}
// Add project source files
var sourceFiles = CompilerUtil.GetCompilationSources(context);
compilerArgs.AddRange(sourceFiles);
var compilerName = CompilerUtil.ResolveCompilerName(context);
// Write RSP file
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile.rsp");
File.WriteAllLines(rsp, compilerArgs);
// Run pre-compile event
var contextVariables = new Dictionary <string, string>()
{
{ "compile:TargetFramework", context.TargetFramework.DotNetFrameworkName },
{ "compile:Configuration", args.ConfigValue },
{ "compile:OutputFile", outputName },
{ "compile:OutputDir", outputPath },
{ "compile:ResponseFile", rsp }
};
RunScripts(context, ScriptNames.PreCompile, contextVariables);
var result = Command.CreateDotNet($"compile-{compilerName}", new[] { "@" + $"{rsp}" })
.OnErrorLine(line =>
{
var diagnostic = ParseDiagnostic(context.ProjectDirectory, line);
if (diagnostic != null)
{
diagnostics.Add(diagnostic);
}
else
{
Reporter.Error.WriteLine(line);
}
})
.OnOutputLine(line =>
{
var diagnostic = ParseDiagnostic(context.ProjectDirectory, line);
if (diagnostic != null)
{
diagnostics.Add(diagnostic);
}
else
{
Reporter.Output.WriteLine(line);
}
}).Execute();
// Run post-compile event
contextVariables["compile:CompilerExitCode"] = result.ExitCode.ToString();
RunScripts(context, ScriptNames.PostCompile, contextVariables);
var success = result.ExitCode == 0;
if (!success)
{
Reporter.Error.WriteLine($"{result.StartInfo.FileName} {result.StartInfo.Arguments} returned Exit Code {result.ExitCode}");
}
if (success)
{
success &= GenerateCultureResourceAssemblies(context.ProjectFile, dependencies, intermediateOutputPath, outputPath);
}
return(PrintSummary(diagnostics, sw, success));
}