Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        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());
                }
            }
        }