public bool Compile(ProjectContext context, string config, string probingFolderPath)
{
var compilationlock = _compilationlocks.GetOrAdd(context.ProjectName(), id => new object());
lock (compilationlock)
{
return CompileInternal(context, config, probingFolderPath);
}
}
private void CollectCheckPathProbingPreconditions(ProjectContext project, IncrementalPreconditions preconditions)
{
var pathCommands = CompilerUtil.GetCommandsInvokedByCompile(project)
.Select(commandName => Command.CreateDotNet(commandName, Enumerable.Empty<string>(), project.TargetFramework))
.Where(c => c.ResolutionStrategy.Equals(CommandResolutionStrategy.Path));
foreach (var pathCommand in pathCommands)
{
preconditions.AddPathProbingPrecondition(project.ProjectName(), pathCommand.CommandName);
}
}
private void CollectCompilerNamePreconditions(ProjectContext project, IncrementalPreconditions preconditions)
{
if (project.ProjectFile != null)
{
var compilerOptions = project.ProjectFile.GetCompilerOptions(project.TargetFramework, null);
var projectCompiler = compilerOptions.CompilerName;
if (!KnownCompilers.Any(knownCompiler => knownCompiler.Equals(projectCompiler, StringComparison.Ordinal)))
{
preconditions.AddUnknownCompilerPrecondition(project.ProjectName(), projectCompiler);
}
}
}
private void CollectScriptPreconditions(ProjectContext project, IncrementalPreconditions preconditions)
{
var preCompileScripts = project.ProjectFile.Scripts.GetOrEmpty(ScriptNames.PreCompile);
var postCompileScripts = project.ProjectFile.Scripts.GetOrEmpty(ScriptNames.PostCompile);
if (preCompileScripts.Any())
{
preconditions.AddPrePostScriptPrecondition(project.ProjectName(), ScriptNames.PreCompile);
}
if (postCompileScripts.Any())
{
preconditions.AddPrePostScriptPrecondition(project.ProjectName(), ScriptNames.PostCompile);
}
}
private void CollectCompilerNamePreconditions(ProjectContext project, IncrementalPreconditions preconditions)
{
var projectCompiler = CompilerUtil.ResolveCompilerName(project);
if (!KnownCompilers.Any(knownCompiler => knownCompiler.Equals(projectCompiler, StringComparison.Ordinal)))
{
preconditions.AddUnknownCompilerPrecondition(project.ProjectName(), projectCompiler);
}
}
private static void AddLockFile(ProjectContext project, CompilerIO compilerIO)
{
if (project.LockFile == null)
{
var errorMessage = $"Project {project.ProjectName()} does not have a lock file.";
Reporter.Error.WriteLine(errorMessage);
throw new InvalidOperationException(errorMessage);
}
compilerIO.Inputs.Add(project.LockFile.LockFilePath);
}
internal void CompileProject(ProjectContext context)
{
var compiler = new CSharpExtensionCompiler();
var success = compiler.Compile(context, Configuration, _probingFolderPath);
var diagnostics = compiler.Diagnostics;
if (success)
{
if (_logger.IsEnabled(LogLevel.Information) && !diagnostics.Any())
{
_logger.LogInformation($"{0} was successfully compiled", context.ProjectName());
}
else if (_logger.IsEnabled(LogLevel.Warning))
{
_logger.LogWarning($"{0} was compiled but has warnings", context.ProjectName());
foreach (var diagnostic in diagnostics)
{
_logger.LogWarning(diagnostic);
}
}
}
else
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError($"{0} compilation failed", context.ProjectName());
foreach (var diagnostic in diagnostics)
{
_logger.LogError(diagnostic);
}
}
}
}
internal bool CompileInternal(ProjectContext context, string config, string probingFolderPath)
{
// Check if ambient library
if (AmbientLibraries.Contains(context.ProjectName()))
{
return true;
}
bool compilationResult;
// Check if already compiled
if (_compiledLibraries.TryGetValue(context.ProjectName(), out compilationResult))
{
return compilationResult;
}
// Get compilation options and source files
var compilationOptions = context.ResolveCompilationOptions(config);
var projectSourceFiles = CompilerUtility.GetCompilationSources(context, compilationOptions);
// Check if precompiled
if (!projectSourceFiles.Any())
{
return _compiledLibraries[context.ProjectName()] = true;
}
// Set up Output Paths
var outputPaths = context.GetOutputPaths(config);
var outputPath = outputPaths.CompilationOutputPath;
var intermediateOutputPath = outputPaths.IntermediateOutputDirectoryPath;
Directory.CreateDirectory(outputPath);
Directory.CreateDirectory(intermediateOutputPath);
// Create the library exporter
var exporter = context.CreateExporter(config);
// Gather exports for the project
var dependencies = exporter.GetDependencies().ToList();
// Get compilation options
var outputName = outputPaths.CompilationFiles.Assembly;
// 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 references = new List<string>();
var sourceFiles = new List<string>();
var resources = new List<string>();
// Get the runtime directory
var runtimeDirectory = Path.GetDirectoryName(EntryAssembly.Location);
foreach (var dependency in dependencies)
{
sourceFiles.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);
resources.Add($"\"{transformedResource}\",{resourceName}");
}
var library = dependency.Library as ProjectDescription;
var package = dependency.Library as PackageDescription;
// Compile other referenced libraries
if (library != null && !AmbientLibraries.Contains(library.Identity.Name) && dependency.CompilationAssemblies.Any())
{
if (!_compiledLibraries.ContainsKey(library.Identity.Name))
{
var projectContext = GetProjectContextFromPath(library.Project.ProjectDirectory);
if (projectContext != null)
{
// Right now, if !success we try to use the last build
var success = Compile(projectContext, config, probingFolderPath);
}
}
}
// Check for an unresolved library
if (library != null && !library.Resolved)
{
var fileName = GetAssemblyFileName(library.Identity.Name);
// Search in the runtime directory
var path = Path.Combine(runtimeDirectory, fileName);
if (!File.Exists(path))
{
// Fallback to the project output path or probing folder
path = ResolveAssetPath(outputPath, probingFolderPath, fileName);
}
if (!String.IsNullOrEmpty(path))
{
references.Add(path);
}
}
// Check for an unresolved package
else if (package != null && !package.Resolved)
{
var runtimeAssets = new HashSet<string>(package.RuntimeAssemblies.Select(x => x.Path), StringComparer.OrdinalIgnoreCase);
foreach (var asset in package.CompileTimeAssemblies)
{
var assetFileName = Path.GetFileName(asset.Path);
var isRuntimeAsset = runtimeAssets.Contains(asset.Path);
// Search in the runtime directory
var path = isRuntimeAsset ? Path.Combine(runtimeDirectory, assetFileName)
: Path.Combine(runtimeDirectory, CompilerUtility.RefsDirectoryName, assetFileName);
if (!File.Exists(path))
{
// Fallback to the project output path or probing folder
var relativeFolderPath = isRuntimeAsset ? String.Empty : CompilerUtility.RefsDirectoryName;
path = ResolveAssetPath(outputPath, probingFolderPath, assetFileName, relativeFolderPath);
}
if (!String.IsNullOrEmpty(path))
{
references.Add(path);
}
}
}
// Check for a precompiled library
else if (library != null && !dependency.CompilationAssemblies.Any())
{
var projectContext = GetProjectContextFromPath(library.Project.ProjectDirectory);
if (projectContext != null)
{
var fileName = GetAssemblyFileName(library.Identity.Name);
// Search in the precompiled project output path
var path = Path.Combine(projectContext.GetOutputPaths(config).CompilationOutputPath, fileName);
if (!File.Exists(path))
{
// Fallback to this project output path or probing folder
path = ResolveAssetPath(outputPath, probingFolderPath, fileName);
}
if (!String.IsNullOrEmpty(path))
{
references.Add(path);
}
}
}
// Check for a resolved but ambient library (compiled e.g by VS)
else if (library != null && AmbientLibraries.Contains(library.Identity.Name))
{
// Search in the regular project bin folder, fallback to the runtime directory
references.AddRange(dependency.CompilationAssemblies.Select(r => File.Exists(r.ResolvedPath)
? r.ResolvedPath : Path.Combine(runtimeDirectory, r.FileName)));
}
else
{
references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath));
}
}
// Check again if already compiled, here through the dependency graph
if (_compiledLibraries.TryGetValue(context.ProjectName(), out compilationResult))
{
return compilationResult;
}
var sw = Stopwatch.StartNew();
string depsJsonFile = null;
DependencyContext dependencyContext = null;
// Add dependency context as a resource
if (compilationOptions.PreserveCompilationContext == true)
{
var allExports = exporter.GetAllExports().ToList();
var exportsLookup = allExports.ToDictionary(e => e.Library.Identity.Name);
var buildExclusionList = context.GetTypeBuildExclusionList(exportsLookup);
var filteredExports = allExports
.Where(e => e.Library.Identity.Type.Equals(LibraryType.ReferenceAssembly) ||
!buildExclusionList.Contains(e.Library.Identity.Name));
dependencyContext = new DependencyContextBuilder().Build(compilationOptions,
filteredExports,
filteredExports,
false, // For now, just assume non-portable mode in the legacy deps file (this is going away soon anyway)
context.TargetFramework,
depsJsonFile = Path.Combine(intermediateOutputPath, compilationOptions.OutputName + "dotnet-compile.deps.json"));
resources.Add($"\"{depsJsonFile}\",{compilationOptions.OutputName}.deps.json");
}
// Add project source files
sourceFiles.AddRange(projectSourceFiles);
// Add non culture resources
var resgenFiles = CompilerUtility.GetNonCultureResources(context.ProjectFile, intermediateOutputPath, compilationOptions);
AddNonCultureResources(resources, resgenFiles);
var translated = TranslateCommonOptions(compilationOptions, outputName);
var allArgs = new List<string>(translated);
allArgs.AddRange(GetDefaultOptions());
// Add assembly info
var assemblyInfo = Path.Combine(intermediateOutputPath, $"dotnet-compile.assemblyinfo.cs");
allArgs.Add($"\"{assemblyInfo}\"");
if (!String.IsNullOrEmpty(outputName))
{
allArgs.Add($"-out:\"{outputName}\"");
}
allArgs.AddRange(references.Select(r => $"-r:\"{r}\""));
allArgs.AddRange(resources.Select(resource => $"-resource:{resource}"));
allArgs.AddRange(sourceFiles.Select(s => $"\"{s}\""));
// Gather all compile IO
var inputs = new List<string>();
var outputs = new List<string>();
inputs.Add(context.ProjectFile.ProjectFilePath);
if (context.LockFile != null)
{
inputs.Add(context.LockFile.LockFilePath);
}
if (context.LockFile.ExportFile != null)
{
inputs.Add(context.LockFile.ExportFile.ExportFilePath);
}
inputs.AddRange(sourceFiles);
inputs.AddRange(references);
inputs.AddRange(resgenFiles.Select(x => x.InputFile));
var cultureResgenFiles = CompilerUtility.GetCultureResources(context.ProjectFile, outputPath, compilationOptions);
inputs.AddRange(cultureResgenFiles.SelectMany(x => x.InputFileToMetadata.Keys));
outputs.AddRange(outputPaths.CompilationFiles.All());
outputs.AddRange(resgenFiles.Where(x => x.OutputFile != null).Select(x => x.OutputFile));
//outputs.AddRange(cultureResgenFiles.Where(x => x.OutputFile != null).Select(x => x.OutputFile));
// Locate RSP file
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile-csc.rsp");
// Check if there is no need to compile
if (!CheckMissingIO(inputs, outputs) && !TimestampsChanged(inputs, outputs))
{
if (File.Exists(rsp))
{
// Check if the compilation context has been changed
var prevInputs = new HashSet<string>(File.ReadAllLines(rsp));
var newInputs = new HashSet<string>(allArgs);
if (!prevInputs.Except(newInputs).Any() && !newInputs.Except(prevInputs).Any())
{
PrintMessage($"{context.ProjectName()}: Previously compiled, skipping dynamic compilation.");
return _compiledLibraries[context.ProjectName()] = true;
}
}
else
{
// Write RSP file for the next time
File.WriteAllLines(rsp, allArgs);
PrintMessage($"{context.ProjectName()}: Previously compiled, skipping dynamic compilation.");
return _compiledLibraries[context.ProjectName()] = true;
}
}
if (!CompilerUtility.GenerateNonCultureResources(context.ProjectFile, resgenFiles, Diagnostics))
{
return _compiledLibraries[context.ProjectName()] = false;
}
PrintMessage(String.Format($"{context.ProjectName()}: Dynamic compiling for {context.TargetFramework.DotNetFrameworkName}"));
// Write the dependencies file
if (dependencyContext != null)
{
var writer = new DependencyContextWriter();
using (var fileStream = File.Create(depsJsonFile))
{
writer.Write(dependencyContext, fileStream);
}
}
// Write assembly info and RSP files
var assemblyInfoOptions = AssemblyInfoOptions.CreateForProject(context);
File.WriteAllText(assemblyInfo, AssemblyInfoFileGenerator.GenerateCSharp(assemblyInfoOptions, sourceFiles));
File.WriteAllLines(rsp, allArgs);
// Locate runtime config files
var runtimeConfigPath = Path.Combine(runtimeDirectory, EntryAssembly.GetName().Name + FileNameSuffixes.RuntimeConfigJson);
var cscRuntimeConfigPath = Path.Combine(runtimeDirectory, "csc" + FileNameSuffixes.RuntimeConfigJson);
// Automatically create the csc runtime config file
if (File.Exists(runtimeConfigPath) && (!File.Exists(cscRuntimeConfigPath)
|| File.GetLastWriteTimeUtc(runtimeConfigPath) > File.GetLastWriteTimeUtc(cscRuntimeConfigPath)))
{
lock (_syncLock)
{
if (!File.Exists(cscRuntimeConfigPath)
|| File.GetLastWriteTimeUtc(runtimeConfigPath) > File.GetLastWriteTimeUtc(cscRuntimeConfigPath))
{
File.Copy(runtimeConfigPath, cscRuntimeConfigPath, true);
}
}
}
// Locate csc.dll and the csc.exe asset
var cscDllPath = Path.Combine(runtimeDirectory, GetAssemblyFileName("csc"));
// Search in the runtime directory
var cscRelativePath = Path.Combine("runtimes", "any", "native", "csc.exe");
var cscExePath = Path.Combine(runtimeDirectory, cscRelativePath);
// Fallback to the packages storage
if (!File.Exists(cscExePath) && !String.IsNullOrEmpty(context.PackagesDirectory))
{
cscExePath = Path.Combine(context.PackagesDirectory, CscLibrary?.Name ?? String.Empty,
CscLibrary?.Version ?? String.Empty, cscRelativePath);
}
// Automatically create csc.dll
if (File.Exists(cscExePath) && (!File.Exists(cscDllPath)
|| File.GetLastWriteTimeUtc(cscExePath) > File.GetLastWriteTimeUtc(cscDllPath)))
{
lock (_syncLock)
{
if (!File.Exists(cscDllPath)
|| File.GetLastWriteTimeUtc(cscExePath) > File.GetLastWriteTimeUtc(cscDllPath))
{
File.Copy(cscExePath, cscDllPath, true);
}
}
}
// Execute CSC!
var result = Command.Create("csc.dll", new string[] { $"-noconfig", "@" + $"{rsp}" })
.WorkingDirectory(runtimeDirectory)
.OnErrorLine(line => Diagnostics.Add(line))
.OnOutputLine(line => Diagnostics.Add(line))
.Execute();
compilationResult = result.ExitCode == 0;
if (compilationResult)
{
compilationResult &= CompilerUtility.GenerateCultureResourceAssemblies(context.ProjectFile, cultureResgenFiles, references, Diagnostics);
}
PrintMessage(String.Empty);
if (compilationResult && Diagnostics.Count == 0)
{
PrintMessage($"{context.ProjectName()}: Dynamic compilation succeeded.");
PrintMessage($"0 Warning(s)");
PrintMessage($"0 Error(s)");
}
else if (compilationResult && Diagnostics.Count > 0)
{
PrintMessage($"{context.ProjectName()}: Dynamic compilation succeeded but has warnings.");
PrintMessage($"0 Error(s)");
}
else
{
PrintMessage($"{context.ProjectName()}: Dynamic compilation failed.");
}
foreach (var diagnostic in Diagnostics)
{
PrintMessage(diagnostic);
}
PrintMessage($"Time elapsed {sw.Elapsed}");
PrintMessage(String.Empty);
return _compiledLibraries[context.ProjectName()] = compilationResult;
}
private static void AddLockFile(ProjectContext project, List<string> inputs)
{
if (project.LockFile == null)
{
var errorMessage = $"Project {project.ProjectName()} does not have a lock file. Please run \"dotnet restore\" to generate a new lock file.";
Reporter.Error.WriteLine(errorMessage);
throw new InvalidOperationException(errorMessage);
}
inputs.Add(project.LockFile.LockFilePath);
if (project.LockFile.ExportFile != null)
{
inputs.Add(project.LockFile.ExportFile.ExportFilePath);
}
}
private bool NeedsRebuilding(ProjectContext project, ProjectDependenciesFacade dependencies)
{
var compilerIO = GetCompileIO(project, _args.ConfigValue, _args.OutputValue, _args.IntermediateValue, dependencies);
// rebuild if empty inputs / outputs
if (!(compilerIO.Outputs.Any() && compilerIO.Inputs.Any()))
{
Reporter.Output.WriteLine($"\nProject {project.ProjectName()} will be compiled because it either has empty inputs or outputs");
return true;
}
//rebuild if missing inputs / outputs
if (AnyMissingIO(project, compilerIO.Outputs, "outputs") || AnyMissingIO(project, compilerIO.Inputs, "inputs"))
{
return true;
}
// find the output with the earliest write time
var minOutputPath = compilerIO.Outputs.First();
var minDate = File.GetLastWriteTime(minOutputPath);
foreach (var outputPath in compilerIO.Outputs)
{
if (File.GetLastWriteTime(outputPath) >= minDate)
{
continue;
}
minDate = File.GetLastWriteTime(outputPath);
minOutputPath = outputPath;
}
// find inputs that are older than the earliest output
var newInputs = compilerIO.Inputs.FindAll(p => File.GetLastWriteTime(p) > minDate);
if (!newInputs.Any())
{
Reporter.Output.WriteLine($"\nProject {project.ProjectName()} was previoulsy compiled. Skipping compilation.");
return false;
}
Reporter.Output.WriteLine($"\nProject {project.ProjectName()} will be compiled because some of its inputs were newer than its oldest output.");
Reporter.Verbose.WriteLine($"Oldest output item was written at {minDate} : {minOutputPath}");
Reporter.Verbose.WriteLine($"Inputs newer than the oldest output item:");
foreach (var newInput in newInputs)
{
Reporter.Verbose.WriteLine($"\t{File.GetLastWriteTime(newInput)}\t:\t{newInput}");
}
return true;
}
private static bool AnyMissingIO(ProjectContext project, IEnumerable<string> items, string itemsType)
{
var missingItems = items.Where(i => !File.Exists(i)).ToList();
if (!missingItems.Any())
{
return false;
}
Reporter.Output.WriteLine($"\nProject {project.ProjectName()} will be compiled because expected {itemsType} are missing. ");
foreach (var missing in missingItems)
{
Reporter.Verbose.WriteLine($"\t {missing}");
}
Reporter.Output.WriteLine();
return true;
}
private void CheckPathProbing(ProjectContext project, IncrementalPreconditions preconditions)
{
var pathCommands = CompilerUtil.GetCommandsInvokedByCompile(project)
.Select(commandName => Command.Create(commandName, "", project.TargetFramework))
.Where(c => Command.CommandResolutionStrategy.Path.Equals(c.ResolutionStrategy));
foreach (var pathCommand in pathCommands)
{
preconditions.AddPathProbingPrecondition(project.ProjectName(), pathCommand.CommandName);
}
}
