public static ProjectDetails LoadProjectDetails(string projectFile, string configuration)
{
var key = Tuple.Create(projectFile, configuration);
ProjectDetails details;
if (_allProjects.TryGetValue(key, out details))
{
if (!details.HasChanged())
{
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
_log.Debug($"Using cached project file details for [{projectFile}]");
}
return(details);
}
else
{
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
_log.Debug($"Reloading project file details [{projectFile}] as one of its imports has been modified.");
}
}
}
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
_log.Debug($"Loading project file [{projectFile}]");
}
details = new ProjectDetails();
var properties = new Dictionary <string, string>(ImmutableDictionary <string, string> .Empty);
properties["DesignTimeBuild"] = "true"; // this will tell msbuild to not build the dependent projects
properties["BuildingInsideVisualStudio"] = "true"; // this will force CoreCompile task to execute even if all inputs and outputs are up to date
properties["BuildingInsideUnoSourceGenerator"] = "true"; // this will force prevent the task to run recursively
properties["Configuration"] = configuration;
properties["UseHostCompilerIfAvailable"] = "true";
properties["UseSharedCompilation"] = "true";
// Platform is intentionally kept as not defined, to avoid having
// dependent projects being loaded with a platform they don't support.
// properties["Platform"] = _platform;
var xmlReader = XmlReader.Create(projectFile);
var collection = new Microsoft.Build.Evaluation.ProjectCollection();
collection.RegisterLogger(new Microsoft.Build.Logging.ConsoleLogger()
{
Verbosity = LoggerVerbosity.Normal
});
collection.OnlyLogCriticalEvents = false;
var xml = Microsoft.Build.Construction.ProjectRootElement.Create(xmlReader, collection);
// When constructing a project from an XmlReader, MSBuild cannot determine the project file path. Setting the
// path explicitly is necessary so that the reserved properties like $(MSBuildProjectDirectory) will work.
xml.FullPath = Path.GetFullPath(projectFile);
var loadedProject = new Microsoft.Build.Evaluation.Project(
xml,
properties,
toolsVersion: null,
projectCollection: collection
);
var buildTargets = new BuildTargets(loadedProject, "Compile");
// don't execute anything after CoreCompile target, since we've
// already done everything we need to compute compiler inputs by then.
buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: false);
details.Configuration = configuration;
details.LoadedProject = loadedProject;
// create a project instance to be executed by build engine.
// The executed project will hold the final model of the project after execution via msbuild.
details.ExecutedProject = loadedProject.CreateProjectInstance();
var hostServices = new Microsoft.Build.Execution.HostServices();
// connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task.
hostServices.RegisterHostObject(loadedProject.FullPath, "CoreCompile", "Csc", null);
var buildParameters = new Microsoft.Build.Execution.BuildParameters(loadedProject.ProjectCollection);
// This allows for the loggers to
buildParameters.Loggers = collection.Loggers;
var buildRequestData = new Microsoft.Build.Execution.BuildRequestData(details.ExecutedProject, buildTargets.Targets, hostServices);
var result = BuildAsync(buildParameters, buildRequestData);
if (result.Exception == null)
{
ValidateOutputPath(details.ExecutedProject);
var projectFilePath = Path.GetFullPath(Path.GetDirectoryName(projectFile));
details.References = details.ExecutedProject.GetItems("ReferencePath").Select(r => r.EvaluatedInclude).ToArray();
if (details.References.None())
{
LogFailedTargets(projectFile, result);
return(details);
}
}
else
{
LogFailedTargets(projectFile, result);
}
_allProjects.TryAdd(key, details);
details.BuildImportsMap();
return(details);
}
public static ProjectDetails LoadProjectDetails(BuildEnvironment environment)
{
var key = Tuple.Create(environment.ProjectFile, environment.Configuration);
ProjectDetails details;
if (_allProjects.TryGetValue(key, out details))
{
if (!details.HasChanged())
{
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
_log.LogDebug($"Using cached project file details for [{environment.ProjectFile}]");
}
return(details);
}
else
{
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
_log.LogDebug($"Reloading project file details [{environment.ProjectFile}] as one of its imports has been modified.");
}
}
}
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
_log.LogDebug($"Loading project file [{environment.ProjectFile}]");
}
details = new ProjectDetails();
var properties = new Dictionary <string, string>(ImmutableDictionary <string, string> .Empty)
{
["DesignTimeBuild"] = "true", // this will tell msbuild to not build the dependent projects
["BuildingInsideVisualStudio"] = "true", // this will force CoreCompile task to execute even if all inputs and outputs are up to date
["BuildingInsideUnoSourceGenerator"] = "true", // this will force prevent the task to run recursively
["Configuration"] = environment.Configuration,
["UseHostCompilerIfAvailable"] = "true",
["UseSharedCompilation"] = "true",
["VisualStudioVersion"] = environment.VisualStudioVersion,
// Force the intermediate path to be different from the VS default path
// so that the generated files don't mess up the file count for incremental builds.
["IntermediateOutputPath"] = Path.Combine(environment.OutputPath, "obj") + Path.DirectorySeparatorChar
};
// Target framework is required for the MSBuild 15.0 Cross Compilation.
// Loading a project without the target framework results in an empty project, which interatively
// sets the TargetFramework property.
if (environment.TargetFramework.HasValue())
{
properties["TargetFramework"] = environment.TargetFramework;
}
// TargetFrameworkRootPath is used by VS4Mac to determine the
// location of frameworks like Xamarin.iOS.
if (environment.TargetFrameworkRootPath.HasValue())
{
properties["TargetFrameworkRootPath"] = environment.TargetFrameworkRootPath;
}
// Platform is intentionally kept as not defined, to avoid having
// dependent projects being loaded with a platform they don't support.
// properties["Platform"] = _platform;
var xmlReader = XmlReader.Create(environment.ProjectFile);
var collection = new Microsoft.Build.Evaluation.ProjectCollection();
// Change this logger details to troubleshoot project loading details.
collection.RegisterLogger(new Microsoft.Build.Logging.ConsoleLogger()
{
Verbosity = LoggerVerbosity.Minimal
});
// Uncomment this to enable file logging for debugging purposes.
// collection.RegisterLogger(new Microsoft.Build.BuildEngine.FileLogger() { Verbosity = LoggerVerbosity.Diagnostic, Parameters = $@"logfile=c:\temp\build\MSBuild.{Guid.NewGuid()}.log" });
collection.OnlyLogCriticalEvents = false;
var xml = Microsoft.Build.Construction.ProjectRootElement.Create(xmlReader, collection);
// When constructing a project from an XmlReader, MSBuild cannot determine the project file path. Setting the
// path explicitly is necessary so that the reserved properties like $(MSBuildProjectDirectory) will work.
xml.FullPath = Path.GetFullPath(environment.ProjectFile);
var loadedProject = new Microsoft.Build.Evaluation.Project(
xml,
properties,
toolsVersion: null,
projectCollection: collection
);
var buildTargets = new BuildTargets(loadedProject, "Compile");
// don't execute anything after CoreCompile target, since we've
// already done everything we need to compute compiler inputs by then.
buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: true);
details.Configuration = environment.Configuration;
details.LoadedProject = loadedProject;
// create a project instance to be executed by build engine.
// The executed project will hold the final model of the project after execution via msbuild.
details.ExecutedProject = loadedProject.CreateProjectInstance();
var hostServices = new Microsoft.Build.Execution.HostServices();
// connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task.
hostServices.RegisterHostObject(loadedProject.FullPath, "CoreCompile", "Csc", null);
var buildParameters = new Microsoft.Build.Execution.BuildParameters(loadedProject.ProjectCollection);
// This allows for the loggers to
buildParameters.Loggers = collection.Loggers;
var buildRequestData = new Microsoft.Build.Execution.BuildRequestData(details.ExecutedProject, buildTargets.Targets, hostServices);
var result = BuildAsync(buildParameters, buildRequestData);
if (result.Exception == null)
{
ValidateOutputPath(details.ExecutedProject);
var projectFilePath = Path.GetFullPath(Path.GetDirectoryName(environment.ProjectFile));
details.References = details.ExecutedProject.GetItems("ReferencePath").Select(r => r.EvaluatedInclude).ToArray();
if (!details.References.Any())
{
if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error))
{
_log.LogError($"Project has no references.");
}
LogFailedTargets(environment.ProjectFile, result);
details.Generators = new (Type, Func <SourceGenerator>)[0];
private async Task <Tuple <Compilation, Project> > GetCompilation(ProjectDetails details)
{
try
{
var globalProperties = new Dictionary <string, string> {
{ "Configuration", _environment.Configuration },
{ "BuildingInsideVisualStudio", "true" },
{ "BuildingInsideUnoSourceGenerator", "true" },
{ "DesignTimeBuild", "true" },
{ "UseHostCompilerIfAvailable", "false" },
{ "UseSharedCompilation", "false" },
{ "IntermediateOutputPath", Path.Combine(_environment.OutputPath, "obj") + Path.DirectorySeparatorChar },
{ "VisualStudioVersion", _environment.VisualStudioVersion },
// The Platform is intentionally not set here
// as for now, Roslyn applies the properties to all
// loaded projects, directly or indirectly.
// So for now, we rely on the fact that all projects
// have a default platform directive, and that most projects
// don't rely on the platform to adjust the generated code.
// (e.g. _platform may be iPhoneSimulator, but all projects may not
// support this target, and therefore will fail to load.
//{ "Platform", _platform },
};
if (_environment.TargetFramework.HasValue())
{
// Target framework is required for the MSBuild 15.0 Cross Compilation.
// Loading a project without the target framework results in an empty project, which interatively
// sets the TargetFramework property.
globalProperties.Add("TargetFramework", _environment.TargetFramework);
}
// TargetFrameworkRootPath is used by VS4Mac to determine the
// location of frameworks like Xamarin.iOS.
if (_environment.TargetFrameworkRootPath.HasValue())
{
globalProperties["TargetFrameworkRootPath"] = _environment.TargetFrameworkRootPath;
}
var ws = MSBuildWorkspace.Create(globalProperties);
ws.LoadMetadataForReferencedProjects = true;
ws.WorkspaceFailed +=
(s, e) => Console.WriteLine(e.Diagnostic.ToString());
var project = await ws.OpenProjectAsync(_environment.ProjectFile);
var metadataLessProjects = ws
.CurrentSolution
.Projects
.Where(p => !p.MetadataReferences.Any())
.ToArray();
if (metadataLessProjects.Any())
{
// In this case, this may mean that Rolsyn failed to execute some msbuild task that loads the
// references in a UWA project (or NuGet 3.0+ with project.json, more specifically). For these
// projects, references are materialized through a task using a output parameter that injects
// "References" nodes. If this task fails, no references are loaded, and simple type resolution
// such "int?" may fail.
// Additionally, it may happen that projects are loaded using the callee's Configuration/Platform, which
// may not exist in all projects. This can happen if the project does not have a proper
// fallback mecanism in place.
throw new InvalidOperationException(
$"The project(s) {metadataLessProjects.Select(p => p.Name).JoinBy(",")} did not provide any metadata reference. " +
"This may be due to an invalid path, such as $(SolutionDir) being used in the csproj; try using relative paths instead." +
"This may also be related to a missing default configuration directive. Refer to the Uno.SourceGenerator Readme.md file for more details."
);
}
project = RemoveGeneratedDocuments(project);
var compilation = await project
.GetCompilationAsync();
// For some reason, this is required to avoid having a
// unbound NRE later during the execution when calling this exact same method;
SyntaxFactory.ParseStatement("");
return(Tuple.Create(compilation, project));
}
catch (Exception e)
{
var reflectionException = e as ReflectionTypeLoadException;
if (reflectionException != null)
{
var loaderMessages = reflectionException.LoaderExceptions.Select(ex => ex.ToString()).JoinBy("\n");
throw new InvalidOperationException(e.ToString() + "\nLoader Exceptions: " + loaderMessages);
}
else
{
throw new InvalidOperationException(e.ToString());
}
}
}
