Project and package references

tmat · tmat · commit 365ff1f575e2 · 2025-06-30T19:13:32.000-07:00
diff --git a/src/BuiltInTools/DotNetDeltaApplier/StartupHook.cs b/src/BuiltInTools/DotNetDeltaApplier/StartupHook.cs
@@ -3,6 +3,8 @@
 
 using System.Diagnostics;
 using System.IO.Pipes;
+using System.Reflection;
+using System.Runtime.Loader;
 using Microsoft.DotNet.HotReload;
 
 /// <summary>
@@ -19,12 +21,15 @@ internal sealed class StartupHook
     private static PosixSignalRegistration? s_signalRegistration;
 #endif
 
+    private static Func<AssemblyLoadContext, AssemblyName, Assembly?>? s_assemblyResolvingEventHandler;
+
     /// <summary>
     /// Invoked by the runtime when the containing assembly is listed in DOTNET_STARTUP_HOOKS.
     /// </summary>
     public static void Initialize()
     {
         var processPath = Environment.GetCommandLineArgs().FirstOrDefault();
+        var processDir = Path.GetDirectoryName(processPath)!;
 
         Log($"Loaded into process: {processPath} ({typeof(StartupHook).Assembly.Location})");
 
@@ -60,6 +65,14 @@ public static void Initialize()
 
         RegisterPosixSignalHandlers();
 
+        // prepare handler, it will be installed on first managed update:
+        s_assemblyResolvingEventHandler = (_, args) =>
+        {
+            Log($"Resolving {args.Name}");
+            var path = Path.Combine(processDir, args.Name + ".dll");
+            return File.Exists(path) ? AssemblyLoadContext.Default.LoadFromAssemblyPath(path) : null;
+        };
+
         var agent = new HotReloadAgent();
         try
         {
@@ -126,6 +139,14 @@ private static async Task ReceiveAndApplyUpdatesAsync(NamedPipeClientStream pipe
                         // Shouldn't get initial managed code updates when the debugger is attached.
                         // The debugger itself applies these updates when launching process with the debugger attached.
                         Debug.Assert(!Debugger.IsAttached);
+
+                        var handler = s_assemblyResolvingEventHandler;
+                        if (handler != null)
+                        {
+                            AssemblyLoadContext.Default.Resolving += handler;
+                            s_assemblyResolvingEventHandler = null;
+                        }
+
                         await ReadAndApplyManagedCodeUpdateAsync(pipeClient, agent, cancellationToken);
                         break;
 
diff --git a/src/BuiltInTools/dotnet-watch/Build/MsBuildFileSetFactory.cs b/src/BuiltInTools/dotnet-watch/Build/MsBuildFileSetFactory.cs
@@ -154,9 +154,7 @@ private IReadOnlyList<string> GetMSBuildArguments(string watchListFilePath)
                 "/t:" + TargetName
             };
 
-#if !DEBUG
             if (environmentOptions.TestFlags.HasFlag(TestFlags.RunningAsTest))
-#endif
             {
                 arguments.Add($"/bl:{Path.Combine(environmentOptions.TestOutput, "DotnetWatch.GenerateWatchList.binlog")}");
             }
@@ -215,7 +213,9 @@ private static string FindTargetsFile()
 
             try
             {
-                return new ProjectGraph([entryPoint], ProjectCollection.GlobalProjectCollection, projectInstanceFactory: null, cancellationToken);
+                var graph = new ProjectGraph([entryPoint], ProjectCollection.GlobalProjectCollection, projectInstanceFactory: null, cancellationToken);
+                reporter.Verbose($"Project graph loaded ({graph.ProjectNodes.Count} nodes)");
+                return graph;
             }
             catch (Exception e)
             {
diff --git a/src/BuiltInTools/dotnet-watch/HotReload/HotReloadDotNetWatcher.cs b/src/BuiltInTools/dotnet-watch/HotReload/HotReloadDotNetWatcher.cs
@@ -3,6 +3,8 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.Build.Execution;
+using Microsoft.Build.Graph;
 using Microsoft.CodeAnalysis;
 
 namespace Microsoft.DotNet.Watch
@@ -442,11 +444,12 @@ async Task<ImmutableList<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableDict
 
                                 // TODO: consider re-evaluating only affected projects instead of the whole graph.
                                 evaluationResult = await EvaluateRootProjectAsync(iterationCancellationToken);
+                                Debug.Assert(evaluationResult.ProjectGraph != null);
 
                                 // additional directories may have been added:
                                 evaluationResult.WatchFiles(fileWatcher);
 
-                                await compilationHandler.Workspace.UpdateProjectConeAsync(_fileSetFactory.RootProjectFile, iterationCancellationToken);
+                                var solutionChanges = await compilationHandler.Workspace.UpdateProjectConeAsync(_fileSetFactory.RootProjectFile, iterationCancellationToken);
 
                                 if (shutdownCancellationToken.IsCancellationRequested)
                                 {
@@ -458,6 +461,8 @@ async Task<ImmutableList<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableDict
                                 changedFiles = [.. changedFiles
                                     .Select(f => evaluationResult.Files.TryGetValue(f.Item.FilePath, out var evaluatedFile) ? f with { Item = evaluatedFile } : f)];
 
+                                await DeployProjectDependenciesAsync(evaluationResult.ProjectGraph, solutionChanges, iterationCancellationToken);
+
                                 _context.Reporter.Report(MessageDescriptor.ReEvaluationCompleted);
                             }
 
@@ -551,6 +556,64 @@ async Task<ImmutableList<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableDict
             }
         }
 
+        private Task DeployProjectDependenciesAsync(ProjectGraph graph, SolutionChanges solutionChanges, CancellationToken cancellationToken)
+        {
+            // TODO: tfm
+
+            var affectedProjectFilePaths =
+                (from projectChange in solutionChanges.GetProjectChanges()
+                 where projectChange.GetAddedProjectReferences().Any() || projectChange.GetAddedMetadataReferences().Any()
+                 select projectChange.NewProject.FilePath!).ToHashSet();
+
+            foreach (var node in graph.ProjectNodes)
+            {
+                if (affectedProjectFilePaths.Contains(node.ProjectInstance.FullPath))
+                {
+                    // TODO: logger; GenerateBuildDependencyFile?
+                    if (!node.ProjectInstance.Build(["ReferenceCopyLocalPathsOutputGroup"], loggers: [], out var targetOutputs))
+                    {
+                        Context.Reporter.Verbose("ReferenceCopyLocalPathsOutputGroup target failed");
+                        continue;
+                    }
+
+                    var copyLocalItems = targetOutputs.Values.Single();
+                    if (copyLocalItems.ResultCode != TargetResultCode.Success)
+                    {
+                        continue;
+                    }
+
+                    var outDir = Path.Combine(Path.GetDirectoryName(node.ProjectInstance.FullPath)!, node.ProjectInstance.GetPropertyValue("OutDir"));
+
+                    foreach (var item in copyLocalItems.Items)
+                    {
+                        var sourcePath = item.ItemSpec;
+                        var targetPath = Path.Combine(outDir, item.GetMetadata("TargetPath"));
+                        if (!File.Exists(targetPath))
+                        {
+                            Context.Reporter.Verbose($"Deploying project dependency '{targetPath}' from '{sourcePath}'");
+
+                            try
+                            {
+                                var directory = Path.GetDirectoryName(targetPath);
+                                if (directory != null)
+                                {
+                                    Directory.CreateDirectory(directory);
+                                }
+
+                                File.Copy(sourcePath, targetPath, overwrite: false);
+                            }
+                            catch (Exception e)
+                            {
+                                Context.Reporter.Verbose($"Copy failed: {e.Message}");
+                            }
+                        }
+                    }
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+
         private async ValueTask WaitForFileChangeBeforeRestarting(FileWatcher fileWatcher, EvaluationResult? evaluationResult, CancellationToken cancellationToken)
         {
             if (evaluationResult != null)
diff --git a/src/BuiltInTools/dotnet-watch/HotReload/IncrementalMSBuildWorkspace.cs b/src/BuiltInTools/dotnet-watch/HotReload/IncrementalMSBuildWorkspace.cs
@@ -30,7 +30,7 @@ public IncrementalMSBuildWorkspace(IReporter reporter)
         _reporter = reporter;
     }
 
-    public async Task UpdateProjectConeAsync(string rootProjectPath, CancellationToken cancellationToken)
+    public async Task<SolutionChanges> UpdateProjectConeAsync(string rootProjectPath, CancellationToken cancellationToken)
     {
         var oldSolution = CurrentSolution;
 
@@ -91,12 +91,16 @@ public async Task UpdateProjectConeAsync(string rootProjectPath, CancellationTok
                 .WithCompilationOutputInfo(newProjectInfo.CompilationOutputInfo));
         }
 
-        await ReportSolutionFilesAsync(SetCurrentSolution(newSolution), cancellationToken);
+        var finalNewSolution = SetCurrentSolution(newSolution);
+        await ReportSolutionFilesAsync(finalNewSolution, cancellationToken);
         UpdateReferencesAfterAdd();
 
+        return finalNewSolution.GetChanges(oldSolution);
+
         ProjectReference MapProjectReference(ProjectReference pr)
-            // Only C# and VB projects are loaded by the MSBuildProjectLoader, so some references might be missing:
-            => new(projectIdMap.TryGetValue(pr.ProjectId, out var mappedId) ? mappedId : pr.ProjectId, pr.Aliases, pr.EmbedInteropTypes);
+            // Only C# and VB projects are loaded by the MSBuildProjectLoader, so some references might be missing.
+            // When a new project is added along with a new project reference the old project id is also null.
+            => new(projectIdMap.TryGetValue(pr.ProjectId, out var oldProjectId) && oldProjectId != null ? oldProjectId : pr.ProjectId, pr.Aliases, pr.EmbedInteropTypes);
 
         ImmutableArray<DocumentInfo> MapDocuments(ProjectId mappedProjectId, IReadOnlyList<DocumentInfo> documents)
             => documents.Select(docInfo =>
diff --git a/src/BuiltInTools/dotnet-watch/Properties/launchSettings.json b/src/BuiltInTools/dotnet-watch/Properties/launchSettings.json
@@ -2,8 +2,8 @@
   "profiles": {
     "dotnet-watch": {
       "commandName": "Project",
-      "commandLineArgs": "--verbose /bl:DotnetRun.binlog -lp http --non-interactive",
-      "workingDirectory": "C:\\sdk1\\artifacts\\tmp\\Debug\\Aspire_BuildE---04F22750\\WatchAspire.AppHost",
+      "commandLineArgs": "--verbose",
+      "workingDirectory": "C:\\temp\\app\\dir",
       "environmentVariables": {
         "DOTNET_WATCH_DEBUG_SDK_DIRECTORY": "$(RepoRoot)artifacts\\bin\\redist\\$(Configuration)\\dotnet\\sdk\\$(Version)",
         "DCP_IDE_REQUEST_TIMEOUT_SECONDS": "100000",
diff --git a/test/TestAssets/TestProjects/WatchAppWithProjectDeps/AppWithDeps/Program.cs b/test/TestAssets/TestProjects/WatchAppWithProjectDeps/AppWithDeps/Program.cs
@@ -19,9 +19,14 @@ public static void Main(string[] args)
 
             while (true)
             {
-                Lib.Print();
+                CallLib();
                 Thread.Sleep(1000);
             }
         }
+
+        public static void CallLib()
+        {
+            Lib.Print();
+        }
     }
 }
diff --git a/test/TestAssets/TestProjects/WatchAppWithProjectDeps/Dependency/Foo.cs b/test/TestAssets/TestProjects/WatchAppWithProjectDeps/Dependency/Foo.cs
@@ -4,5 +4,6 @@ public class Lib
 {
     public static void Print()
     {
+        System.Console.WriteLine("<Lib>");
     }
 }
diff --git a/test/dotnet-watch.Tests/HotReload/ApplyDeltaTests.cs b/test/dotnet-watch.Tests/HotReload/ApplyDeltaTests.cs
@@ -236,6 +236,77 @@ public static void Print()
             await App.AssertOutputLineStartsWith("BUILD_CONST_IN_PROPS not set");
         }
 
+        [Fact]
+        public async Task ProjectChange_AddProjectReference()
+        {
+            var testAsset = TestAssets.CopyTestAsset("WatchAppWithProjectDeps")
+                .WithSource()
+                .WithProjectChanges(project =>
+                {
+                    foreach (var r in project.Root!.Descendants().Where(e => e.Name.LocalName == "ProjectReference").ToArray())
+                    {
+                        r.Remove();
+                    }
+                });
+
+            var appProjDir = Path.Combine(testAsset.Path, "AppWithDeps");
+            var appProjFile = Path.Combine(appProjDir, "App.WithDeps.csproj");
+            var appFile = Path.Combine(appProjDir, "Program.cs");
+
+            UpdateSourceFile(appFile, code => code.Replace("Lib.Print();", "// Lib.Print();"));
+
+            App.Start(testAsset, [], "AppWithDeps");
+
+            await App.AssertWaitingForChanges();
+
+            UpdateSourceFile(appProjFile, src => src.Replace("""
+                <ItemGroup />
+                """, """
+                <ItemGroup>
+                    <ProjectReference Include="..\Dependency\Dependency.csproj" />
+                </ItemGroup>
+                """));
+
+            UpdateSourceFile(appFile, code => code.Replace("// Lib.Print();", "Lib.Print();"));
+
+            await App.WaitUntilOutputContains("<Lib>");
+
+            App.AssertOutputContains(MessageDescriptor.HotReloadSucceeded, $"AppWithDeps ({ToolsetInfo.CurrentTargetFramework})");
+            App.AssertOutputContains(MessageDescriptor.ProjectChangeTriggeredReEvaluation);
+        }
+
+        [Fact]
+        public async Task ProjectChange_AddPackageReference()
+        {
+            var testAsset = TestAssets.CopyTestAsset("WatchHotReloadApp")
+                .WithSource();
+
+            var projFilePath = Path.Combine(testAsset.Path, "WatchHotReloadApp.csproj");
+            var programFilePath = Path.Combine(testAsset.Path, "Program.cs");
+
+            App.Start(testAsset, []);
+
+            await App.AssertWaitingForChanges();
+            App.Process.ClearOutput();
+
+            UpdateSourceFile(projFilePath, source => source.Replace("""
+                <!-- items placeholder -->
+                """, """
+                <PackageReference Include="Newtonsoft.Json" Version="13.0.3"/>
+                """));
+
+            UpdateSourceFile(programFilePath, source => source.Replace("Console.WriteLine(\".\");", "Console.WriteLine(typeof(Newtonsoft.Json.Linq.JToken));"));
+
+            await App.WaitUntilOutputContains("Newtonsoft.Json.Linq.JToken");
+
+            var binDirDll = Path.Combine(testAsset.Path, "bin", "Debug", ToolsetInfo.CurrentTargetFramework, "Newtonsoft.Json.dll");
+
+            App.AssertOutputContains($"Deploying project dependency '{binDirDll}'");
+            App.AssertOutputContains(MessageDescriptor.HotReloadSucceeded, $"WatchHotReloadApp ({ToolsetInfo.CurrentTargetFramework})");
+            App.AssertOutputContains(MessageDescriptor.ProjectChangeTriggeredReEvaluation);
+            App.AssertOutputContains("Resolving Newtonsoft.Json");
+        }
+
         [Fact]
         public async Task DefaultItemExcludes_DefaultItemsEnabled()
         {
diff --git a/test/dotnet-watch.Tests/HotReload/RuntimeProcessLauncherTests.cs b/test/dotnet-watch.Tests/HotReload/RuntimeProcessLauncherTests.cs

Original file line number	Diff line number	Diff line change
`@@ -154,9 +154,7 @@ private IReadOnlyList<string> GetMSBuildArguments(string watchListFilePath)`
`154`	`154`	`"/t:" + TargetName`
`155`	`155`	`};`
`156`	`156`
`157`		`-#if !DEBUG`
`158`	`157`	`if (environmentOptions.TestFlags.HasFlag(TestFlags.RunningAsTest))`
`159`		`-#endif`
`160`	`158`	`{`
`161`	`159`	`arguments.Add($"/bl:{Path.Combine(environmentOptions.TestOutput, "DotnetWatch.GenerateWatchList.binlog")}");`
`162`	`160`	`}`
`@@ -215,7 +213,9 @@ private static string FindTargetsFile()`
`215`	`213`
`216`	`214`	`try`
`217`	`215`	`{`
`218`		`- return new ProjectGraph([entryPoint], ProjectCollection.GlobalProjectCollection, projectInstanceFactory: null, cancellationToken);`
	`216`	`+ var graph = new ProjectGraph([entryPoint], ProjectCollection.GlobalProjectCollection, projectInstanceFactory: null, cancellationToken);`
	`217`	`+ reporter.Verbose($"Project graph loaded ({graph.ProjectNodes.Count} nodes)");`
	`218`	`+ return graph;`
`219`	`219`	`}`
`220`	`220`	`catch (Exception e)`
`221`	`221`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,14 @@ public static void Main(string[] args)`
`19`	`19`
`20`	`20`	`while (true)`
`21`	`21`	`{`
`22`		`- Lib.Print();`
	`22`	`+ CallLib();`
`23`	`23`	`Thread.Sleep(1000);`
`24`	`24`	`}`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+ public static void CallLib()`
	`28`	`+ {`
	`29`	`+ Lib.Print();`
	`30`	`+ }`
`26`	`31`	`}`
`27`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,5 +4,6 @@ public class Lib`
`4`	`4`	`{`
`5`	`5`	`public static void Print()`
`6`	`6`	`{`
	`7`	`+ System.Console.WriteLine("<Lib>");`
`7`	`8`	`}`
`8`	`9`	`}`