Switch to HotReloadMSBuildWorkspace

Author: tmat

Directory.Packages.props

@@ -37,6 +37,7 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.VisualBasic.Workspaces" Version="$(MicrosoftCodeAnalysisPackageVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="$(MicrosoftCodeAnalysisPackageVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="$(MicrosoftCodeAnalysisWorkspacesMSBuildPackageVersion)" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost" Version="$(MicrosoftCodeAnalysisWorkspacesMSBuildBuildHostPackageVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.ExternalAccess.HotReload" Version="$(MicrosoftCodeAnalysisExternalAccessHotReloadPackageVersion)" />
 
     <!-- roslyn-sdk dependencies-->

eng/Version.Details.props

@@ -112,6 +112,7 @@ This file should be imported by eng/Versions.props
     <MicrosoftCodeAnalysisPublicApiAnalyzersPackageVersion>5.3.0-2.25610.11</MicrosoftCodeAnalysisPublicApiAnalyzersPackageVersion>
     <MicrosoftCodeAnalysisWorkspacesCommonPackageVersion>5.3.0-2.25610.11</MicrosoftCodeAnalysisWorkspacesCommonPackageVersion>
     <MicrosoftCodeAnalysisWorkspacesMSBuildPackageVersion>5.3.0-2.25610.11</MicrosoftCodeAnalysisWorkspacesMSBuildPackageVersion>
+    <MicrosoftCodeAnalysisWorkspacesMSBuildBuildHostPackageVersion>5.3.0-2.25610.11</MicrosoftCodeAnalysisWorkspacesMSBuildBuildHostPackageVersion>
     <MicrosoftNetCompilersToolsetPackageVersion>5.3.0-2.25610.11</MicrosoftNetCompilersToolsetPackageVersion>
     <MicrosoftNetCompilersToolsetFrameworkPackageVersion>5.3.0-2.25610.11</MicrosoftNetCompilersToolsetFrameworkPackageVersion>
     <!-- nuget/nuget.client dependencies -->

eng/Version.Details.xml

@@ -124,6 +124,10 @@
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>46a48b8c1dfce7c35da115308bedd6a5954fd78a</Sha>
     </Dependency>
+    <Dependency Name="Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost" Version="5.3.0-2.25610.11">
+      <Uri>https://github.com/dotnet/roslyn</Uri>
+      <Sha>46a48b8c1dfce7c35da115308bedd6a5954fd78a</Sha>
+    </Dependency>
     <Dependency Name="Microsoft.Build.NuGetSdkResolver" Version="7.1.0-preview.1.42">
       <Uri>https://github.com/nuget/nuget.client</Uri>
       <Sha>b5efdd1f17df11700c9383def6ece79a40218ccd</Sha>

src/BuiltInTools/Watch/Build/EvaluationResult.cs

@@ -9,7 +9,11 @@
 
 namespace Microsoft.DotNet.Watch;
 
-internal sealed class EvaluationResult(ProjectGraph projectGraph, IReadOnlyDictionary<string, FileItem> files, IReadOnlyDictionary<ProjectInstanceId, StaticWebAssetsManifest> staticWebAssetsManifests)
+internal sealed class EvaluationResult(
+    ProjectGraph projectGraph,
+    ImmutableArray<ProjectInstance> restoredProjectInstances,
+    IReadOnlyDictionary<string, FileItem> files,
+    IReadOnlyDictionary<ProjectInstanceId, StaticWebAssetsManifest> staticWebAssetsManifests)
 {
     public readonly IReadOnlyDictionary<string, FileItem> Files = files;
     public readonly ProjectGraph ProjectGraph = projectGraph;
@@ -31,6 +35,9 @@ public IReadOnlySet<string> BuildFiles
     public IReadOnlyDictionary<ProjectInstanceId, StaticWebAssetsManifest> StaticWebAssetsManifests
         => staticWebAssetsManifests;
 
+    public ImmutableArray<ProjectInstance> RestoredProjectInstances
+        => restoredProjectInstances;
+
     public void WatchFiles(FileWatcher fileWatcher)
     {
         fileWatcher.WatchContainingDirectories(Files.Keys, includeSubdirectories: true);
@@ -94,15 +101,19 @@ public static ImmutableDictionary<string, string> GetGlobalBuildOptions(IEnumera
             }
         }
 
+        // Capture the snapshot of original project instances after Restore target has been run.
+        // These instances can be used to evaluate additional targets (e.g. deployment) if needed.
+        var restoredProjectInstances = projectGraph.ProjectNodesTopologicallySorted.Select(node => node.ProjectInstance.DeepCopy()).ToImmutableArray();
+
         var fileItems = new Dictionary<string, FileItem>();
         var staticWebAssetManifests = new Dictionary<ProjectInstanceId, StaticWebAssetsManifest>();
 
+        // Update the project instances of the graph with design-time build results.
+        // The properties and items set by DTB will be used by the Workspace to create Roslyn representation of projects.
+
         foreach (var project in projectGraph.ProjectNodesTopologicallySorted)
         {
-            // Deep copy so that we can reuse the graph for building additional targets later on.
-            // If we didn't copy the instance the targets might duplicate items that were already
-            // populated by design-time build.
-            var projectInstance = project.ProjectInstance.DeepCopy();
+            var projectInstance = project.ProjectInstance;
 
             // skip outer build project nodes:
             if (projectInstance.GetPropertyValue(PropertyNames.TargetFramework) == "")
@@ -189,7 +200,7 @@ void AddFile(string relativePath, string? staticWebAssetRelativeUrl)
 
         buildReporter.ReportWatchedFiles(fileItems);
 
-        return new EvaluationResult(projectGraph, fileItems, staticWebAssetManifests);
+        return new EvaluationResult(projectGraph, restoredProjectInstances, fileItems, staticWebAssetManifests);
     }
 
     private static string[] GetBuildTargets(ProjectInstance projectInstance, EnvironmentOptions environmentOptions)

src/BuiltInTools/Watch/Build/FilePathExclusions.cs

@@ -39,7 +39,7 @@ public static FilePathExclusions Create(ProjectGraph projectGraph)
             {
                 // If default items are not enabled exclude just the output directories.
 
-                TryAddOutputDir(projectNode.GetOutputDirectory());
+                TryAddOutputDir(projectNode.ProjectInstance.GetOutputDirectory());
                 TryAddOutputDir(projectNode.ProjectInstance.GetIntermediateOutputDirectory());
 
                 void TryAddOutputDir(string? dir)

src/BuiltInTools/Watch/Build/ProjectGraphUtilities.cs

@@ -51,8 +51,8 @@ public static bool IsNetCoreApp(this ProjectGraphNode projectNode, Version minVe
     public static bool IsWebApp(this ProjectGraphNode projectNode)
         => projectNode.GetCapabilities().Any(static value => value is ProjectCapability.AspNetCore or ProjectCapability.WebAssembly);
 
-    public static string? GetOutputDirectory(this ProjectGraphNode projectNode)
-        => projectNode.ProjectInstance.GetPropertyValue(PropertyNames.TargetPath) is { Length: >0 } path ? Path.GetDirectoryName(Path.Combine(projectNode.ProjectInstance.Directory, path)) : null;
+    public static string? GetOutputDirectory(this ProjectInstance project)
+        => project.GetPropertyValue(PropertyNames.TargetPath) is { Length: >0 } path ? Path.GetDirectoryName(Path.Combine(project.Directory, path)) : null;
 
     public static string GetAssemblyName(this ProjectGraphNode projectNode)
         => projectNode.ProjectInstance.GetPropertyValue(PropertyNames.TargetName);

src/BuiltInTools/Watch/FileWatcher/ChangeKind.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.CodeAnalysis.ExternalAccess.HotReload.Api;
+
 namespace Microsoft.DotNet.Watch;
 
 internal enum ChangeKind
@@ -10,6 +12,18 @@ internal enum ChangeKind
     Delete
 }
 
+internal static class ChangeKindExtensions
+{
+    public static HotReloadFileChangeKind Convert(this ChangeKind changeKind) =>
+        changeKind switch
+        {
+            ChangeKind.Update => HotReloadFileChangeKind.Update,
+            ChangeKind.Add => HotReloadFileChangeKind.Add,
+            ChangeKind.Delete => HotReloadFileChangeKind.Delete,
+            _ => throw new InvalidOperationException()
+        };
+}
+
 internal readonly record struct ChangedFile(FileItem Item, ChangeKind Kind);
 
 internal readonly record struct ChangedPath(string Path, ChangeKind Kind);

src/BuiltInTools/Watch/HotReload/CompilationHandler.cs

@@ -15,7 +15,7 @@ namespace Microsoft.DotNet.Watch
 {
     internal sealed class CompilationHandler : IDisposable
     {
-        public readonly IncrementalMSBuildWorkspace Workspace;
+        public readonly HotReloadMSBuildWorkspace Workspace;
         private readonly DotNetWatchContext _context;
         private readonly HotReloadService _hotReloadService;
 
@@ -38,11 +38,19 @@ internal sealed class CompilationHandler : IDisposable
         private ImmutableList<HotReloadService.Update> _previousUpdates = [];
 
         private bool _isDisposed;
+        private int _solutionUpdateId;
+
+        /// <summary>
+        /// Current set of project instances indexed by <see cref="ProjectInstance.FullPath"/>.
+        /// Updated whenever the project graph changes.
+        /// </summary>
+        private ImmutableDictionary<string, ImmutableArray<ProjectInstance>> _projectInstances = [];
 
         public CompilationHandler(DotNetWatchContext context)
         {
             _context = context;
-            Workspace = new IncrementalMSBuildWorkspace(context.Logger);
+            _processRunner = processRunner;
+            Workspace = new HotReloadMSBuildWorkspace(logger, projectFile => (instances: _projectInstances.GetValueOrDefault(projectFile, []), project: null));
             _hotReloadService = new HotReloadService(Workspace.CurrentSolution.Services, () => ValueTask.FromResult(GetAggregateCapabilities()));
         }
 
@@ -798,5 +806,70 @@ private static Task ForEachProjectAsync(ImmutableDictionary<string, ImmutableArr
 
         private static ImmutableArray<HotReloadManagedCodeUpdate> ToManagedCodeUpdates(ImmutableArray<HotReloadService.Update> updates)
             => [.. updates.Select(update => new HotReloadManagedCodeUpdate(update.ModuleId, update.MetadataDelta, update.ILDelta, update.PdbDelta, update.UpdatedTypes, update.RequiredCapabilities))];
+
+        private static ImmutableDictionary<string, ImmutableArray<ProjectInstance>> CreateProjectInstanceMap(ProjectGraph graph)
+            => graph.ProjectNodes
+                .GroupBy(static node => node.ProjectInstance.FullPath)
+                .ToImmutableDictionary(
+                    keySelector: static group => group.Key,
+                    elementSelector: static group => group.Select(static node => node.ProjectInstance).ToImmutableArray());
+
+        public async Task UpdateProjectConeAsync(ProjectGraph projectGraph, string projectPath, CancellationToken cancellationToken)
+        {
+            _logger.LogInformation("Loading projects ...");
+            var stopwatch = Stopwatch.StartNew();
+
+            _projectInstances = CreateProjectInstanceMap(projectGraph);
+
+            var solution = await Workspace.UpdateProjectConeAsync(projectPath, cancellationToken);
+            await SolutionUpdatedAsync(solution, "project update", cancellationToken);
+
+            _logger.LogInformation("Projects loaded in {Time}s.", stopwatch.Elapsed.TotalSeconds.ToString("0.0"));
+        }
+
+        public async Task UpdateFileContentAsync(ImmutableList<ChangedFile> changedFiles, CancellationToken cancellationToken)
+        {
+            var solution = await Workspace.UpdateFileContentAsync(changedFiles.Select(static f => (f.Item.FilePath, f.Kind.Convert())), cancellationToken);
+            await SolutionUpdatedAsync(solution, "document update", cancellationToken);
+        }
+
+        private Task SolutionUpdatedAsync(Solution newSolution, string operationDisplayName, CancellationToken cancellationToken)
+            => ReportSolutionFilesAsync(newSolution, Interlocked.Increment(ref _solutionUpdateId), operationDisplayName, cancellationToken);
+
+        private async Task ReportSolutionFilesAsync(Solution solution, int updateId, string operationDisplayName, CancellationToken cancellationToken)
+        {
+            _logger.LogDebug("Solution after {Operation}: v{Version}", operationDisplayName, updateId);
+
+            if (!_logger.IsEnabled(LogLevel.Trace))
+            {
+                return;
+            }
+
+            foreach (var project in solution.Projects)
+            {
+                _logger.LogDebug("  Project: {Path}", project.FilePath);
+
+                foreach (var document in project.Documents)
+                {
+                    await InspectDocumentAsync(document, "Document").ConfigureAwait(false);
+                }
+
+                foreach (var document in project.AdditionalDocuments)
+                {
+                    await InspectDocumentAsync(document, "Additional").ConfigureAwait(false);
+                }
+
+                foreach (var document in project.AnalyzerConfigDocuments)
+                {
+                    await InspectDocumentAsync(document, "Config").ConfigureAwait(false);
+                }
+            }
+
+            async ValueTask InspectDocumentAsync(TextDocument document, string kind)
+            {
+                var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                _logger.LogDebug("    {Kind}: {FilePath} [{Checksum}]", kind, document.FilePath, Convert.ToBase64String(text.GetChecksum().ToArray()));
+            }
+        }
     }
 }

src/BuiltInTools/Watch/HotReload/HotReloadDotNetWatcher.cs

@@ -167,7 +167,7 @@ public async Task WatchAsync(CancellationToken shutdownCancellationToken)
                         return;
                     }
 
-                    await compilationHandler.Workspace.UpdateProjectConeAsync(rootProjectOptions.ProjectPath, iterationCancellationToken);
+                    await compilationHandler.UpdateProjectConeAsync(evaluationResult.ProjectGraph, rootProjectOptions.ProjectPath, iterationCancellationToken);
 
                     // Solution must be initialized after we load the solution but before we start watching for file changes to avoid race condition
                     // when the EnC session captures content of the file after the changes has already been made.
@@ -370,7 +370,7 @@ void FileChangedCallback(ChangedPath change)
                         // Deploy dependencies after rebuilding and before restarting.
                         if (!projectsToRedeploy.IsEmpty)
                         {
-                            DeployProjectDependencies(evaluationResult.ProjectGraph, projectsToRedeploy, iterationCancellationToken);
+                            DeployProjectDependencies(evaluationResult.RestoredProjectInstances, projectsToRedeploy, iterationCancellationToken);
                             _context.Logger.Log(MessageDescriptor.ProjectDependenciesDeployed, projectsToRedeploy.Length);
                         }
 
@@ -443,7 +443,7 @@ async Task<ImmutableArray<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableArr
                                 // additional files/directories may have been added:
                                 evaluationResult.WatchFiles(fileWatcher);
 
-                                await compilationHandler.Workspace.UpdateProjectConeAsync(rootProjectOptions.ProjectPath, iterationCancellationToken);
+                                await compilationHandler.UpdateProjectConeAsync(evaluationResult.ProjectGraph, rootProjectOptions.ProjectPath, iterationCancellationToken);
 
                                 if (shutdownCancellationToken.IsCancellationRequested)
                                 {
@@ -495,7 +495,7 @@ async Task<ImmutableArray<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableArr
                             {
                                 // Update the workspace to reflect changes in the file content:.
                                 // If the project was re-evaluated the Roslyn solution is already up to date.
-                                await compilationHandler.Workspace.UpdateFileContentAsync(changedFiles, iterationCancellationToken);
+                                await compilationHandler.UpdateFileContentAsync(changedFiles, iterationCancellationToken);
                             }
 
                             return [.. changedFiles];
@@ -554,6 +554,7 @@ async Task<ImmutableArray<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableArr
             }
         }
 
+<<<<<<< HEAD
         private void AnalyzeFileChanges(
             List<ChangedFile> changedFiles,
             EvaluationResult evaluationResult,
@@ -652,35 +653,38 @@ private static bool MatchesStaticWebAssetFilePattern(EvaluationResult evaluation
             return false;
         }
 
-        private void DeployProjectDependencies(ProjectGraph graph, ImmutableArray<string> projectPaths, CancellationToken cancellationToken)
+        private void DeployProjectDependencies(ImmutableArray<ProjectInstance> restoredProjectInstances, ImmutableArray<string> projectPaths, CancellationToken cancellationToken)
         {
             var projectPathSet = projectPaths.ToImmutableHashSet(PathUtilities.OSSpecificPathComparer);
             var buildReporter = new BuildReporter(_context.Logger, _context.Options, _context.EnvironmentOptions);
             var targetName = TargetNames.ReferenceCopyLocalPathsOutputGroup;
 
-            foreach (var node in graph.ProjectNodes)
+            foreach (var restoredProjectInstance in restoredProjectInstances)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
-                var projectPath = node.ProjectInstance.FullPath;
+                // Avoid modification of the restored snapshot.
+                var projectInstance = restoredProjectInstance.DeepCopy();
+
+                var projectPath = projectInstance.FullPath;
 
                 if (!projectPathSet.Contains(projectPath))
                 {
                     continue;
                 }
 
-                if (!node.ProjectInstance.Targets.ContainsKey(targetName))
+                if (!projectInstance.Targets.ContainsKey(targetName))
                 {
                     continue;
                 }
 
-                if (node.GetOutputDirectory() is not { } relativeOutputDir)
+                if (projectInstance.GetOutputDirectory() is not { } relativeOutputDir)
                 {
                     continue;
                 }
 
                 using var loggers = buildReporter.GetLoggers(projectPath, targetName);
-                if (!node.ProjectInstance.Build([targetName], loggers, out var targetOutputs))
+                if (!projectInstance.Build([targetName], loggers, out var targetOutputs))
                 {
                     _context.Logger.LogDebug("{TargetName} target failed", targetName);
                     loggers.ReportOutput();