Use DefaultExcludeItems globs to determine items to ignore.

Implement watching project, props and targets files.

Author: tmat

src/BuiltInTools/dotnet-watch/EvaluationResult.cs

@@ -9,4 +9,24 @@ internal sealed class EvaluationResult(IReadOnlyDictionary<string, FileItem> fil
 {
     public readonly IReadOnlyDictionary<string, FileItem> Files = files;
     public readonly ProjectGraph? ProjectGraph = projectGraph;
+
+    public readonly FilePathExclusions ItemExclusions
+        = projectGraph != null ? FilePathExclusions.Create(projectGraph) : FilePathExclusions.Empty;
+
+    private readonly Lazy<IReadOnlySet<string>> _lazyBuildFiles
+        = new(() => projectGraph != null ? CreateBuildFileSet(projectGraph) : new HashSet<string>());
+
+    public static IReadOnlySet<string> CreateBuildFileSet(ProjectGraph projectGraph)
+        => projectGraph.ProjectNodes.SelectMany(p => p.ProjectInstance.ImportPaths)
+            .Concat(projectGraph.ProjectNodes.Select(p => p.ProjectInstance.FullPath))
+            .ToHashSet(PathUtilities.OSSpecificPathComparer);
+
+    public IReadOnlySet<string> BuildFiles
+        => _lazyBuildFiles.Value;
+
+    public void WatchFiles(FileWatcher fileWatcher)
+    {
+        fileWatcher.WatchContainingDirectories(Files.Keys, includeSubdirectories: true);
+        fileWatcher.WatchFiles(BuildFiles);
+    }
 }

src/BuiltInTools/dotnet-watch/HotReload/BlazorWebAssemblyDeltaApplier.cs

@@ -42,7 +42,7 @@ public override async Task WaitForProcessRunningAsync(CancellationToken cancella
 
         public override Task<ImmutableArray<string>> GetApplyUpdateCapabilitiesAsync(CancellationToken cancellationToken)
         {
-            var capabilities = project.GetWebAssemblyCapabilities();
+            var capabilities = project.GetWebAssemblyCapabilities().ToImmutableArray();
 
             if (capabilities.IsEmpty)
             {

src/BuiltInTools/dotnet-watch/HotReload/CompilationHandler.cs

@@ -6,7 +6,6 @@
 using Microsoft.Build.Graph;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.ExternalAccess.Watch.Api;
 
 namespace Microsoft.DotNet.Watch

src/BuiltInTools/dotnet-watch/HotReload/FilePathExclusions.cs

@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.Graph;
+using Microsoft.Build.Globbing;
+
+namespace Microsoft.DotNet.Watch;
+
+internal readonly struct FilePathExclusions(
+    IEnumerable<(MSBuildGlob glob, string value, string projectDir)> exclusionGlobs,
+    IReadOnlySet<string> outputDirectories)
+{
+    public static readonly FilePathExclusions Empty = new(exclusionGlobs: [], outputDirectories: new HashSet<string>());
+
+    public static FilePathExclusions Create(ProjectGraph projectGraph)
+    {
+        var outputDirectories = new HashSet<string>(PathUtilities.OSSpecificPathComparer);
+        var globs = new Dictionary<(string fixedDirectoryPart, string wildcardDirectoryPart, string filenamePart), (MSBuildGlob glob, string value, string projectDir)>();
+
+        foreach (var projectNode in projectGraph.ProjectNodes)
+        {
+            if (projectNode.AreDefaultItemsEnabled())
+            {
+                var projectDir = projectNode.ProjectInstance.Directory;
+
+                foreach (var globValue in projectNode.GetDefaultItemExcludes())
+                {
+                    var glob = MSBuildGlob.Parse(projectDir, globValue);
+                    if (glob.IsLegal)
+                    {
+                        // The glob creates regex based on the three parts of the glob.
+                        // Avoid adding duplicate globs that match the same files.
+                        globs.TryAdd((glob.FixedDirectoryPart, glob.WildcardDirectoryPart, glob.FilenamePart), (glob, globValue, projectDir));
+                    }
+                }
+            }
+            else
+            {
+                // If default items are not enabled exclude just the output directories.
+
+                TryAddOutputDir(projectNode.GetOutputDirectory());
+                TryAddOutputDir(projectNode.GetIntermediateOutputDirectory());
+
+                void TryAddOutputDir(string? dir)
+                {
+                    try
+                    {
+                        if (dir != null)
+                        {
+                            // msbuild properties may use '\' as a directory separator even on Unix.
+                            // GetFullPath does not normalize '\' to '/' on Unix.
+                            if (Path.DirectorySeparatorChar == '/')
+                            {
+                                dir = dir.Replace('\\', '/');
+                            }
+
+                            outputDirectories.Add(Path.TrimEndingDirectorySeparator(Path.GetFullPath(dir)));
+                        }
+                    }
+                    catch
+                    {
+                        // ignore
+                    }
+                }
+            }
+        }
+
+        return new FilePathExclusions(globs.Values, outputDirectories);
+    }
+
+    public void Report(IReporter reporter)
+    {
+        foreach (var globsPerDirectory in exclusionGlobs.GroupBy(keySelector: static g => g.projectDir, elementSelector: static g => g.value))
+        {
+            reporter.Verbose($"Exclusion glob: '{string.Join(";", globsPerDirectory)}' under project '{globsPerDirectory.Key}'");
+        }
+
+        foreach (var dir in outputDirectories)
+        {
+            reporter.Verbose($"Excluded directory: '{dir}'");
+        }
+    }
+
+    internal bool IsExcluded(string fullPath, ChangeKind changeKind, IReporter reporter)
+    {
+        if (PathUtilities.ContainsPath(outputDirectories, fullPath))
+        {
+            reporter.Report(MessageDescriptor.IgnoringChangeInOutputDirectory, changeKind, fullPath);
+            return true;
+        }
+
+        foreach (var (glob, globValue, projectDir) in exclusionGlobs)
+        {
+            if (glob.IsMatch(fullPath))
+            {
+                reporter.Report(MessageDescriptor.IgnoringChangeInExcludedFile, fullPath, changeKind, "DefaultItemExcludes", globValue, projectDir);
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/BuiltInTools/dotnet-watch/HotReloadDotNetWatcher.cs

@@ -103,9 +103,8 @@ public override async Task WatchAsync(CancellationToken shutdownCancellationToke
                     compilationHandler = new CompilationHandler(Context.Reporter, Context.ProcessRunner);
                     var scopedCssFileHandler = new ScopedCssFileHandler(Context.Reporter, projectMap, browserConnector);
                     var projectLauncher = new ProjectLauncher(Context, projectMap, browserConnector, compilationHandler, iteration);
-                    var outputDirectories = GetProjectOutputDirectories(evaluationResult.ProjectGraph);
-                    ReportOutputDirectories(outputDirectories);
-                    var changeFilter = new Predicate<ChangedPath>(change => AcceptChange(change, evaluationResult, outputDirectories));
+                    evaluationResult.ItemExclusions.Report(Context.Reporter);
+                    var changeFilter = new Predicate<ChangedPath>(change => AcceptChange(change, evaluationResult));
 
                     var rootProjectNode = evaluationResult.ProjectGraph.GraphRoots.Single();
 
@@ -180,7 +179,7 @@ public override async Task WatchAsync(CancellationToken shutdownCancellationToke
                         return;
                     }
 
-                    fileWatcher.WatchContainingDirectories(evaluationResult.Files.Keys, includeSubdirectories: true);
+                    evaluationResult.WatchFiles(fileWatcher);
 
                     var changedFilesAccumulator = ImmutableList<ChangedPath>.Empty;
 
@@ -426,17 +425,21 @@ async Task<ImmutableList<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableDict
 
                             // When a new file is added we need to run design-time build to find out
                             // what kind of the file it is and which project(s) does it belong to (can be linked, web asset, etc.).
+                            // We also need to re-evaluate the project if any project files have been modified.
                             // We don't need to rebuild and restart the application though.
-                            var hasAddedFile = changedFiles.Any(f => f.Kind is ChangeKind.Add);
+                            var fileAdded = changedFiles.Any(f => f.Kind is ChangeKind.Add);
+                            var projectChanged = !fileAdded && changedFiles.Any(f => evaluationResult.BuildFiles.Contains(f.Item.FilePath));
+                            var evaluationRequired = fileAdded || projectChanged;
 
-                            if (hasAddedFile)
+                            if (evaluationRequired)
                             {
-                                Context.Reporter.Report(MessageDescriptor.FileAdditionTriggeredReEvaluation);
+                                Context.Reporter.Report(fileAdded ? MessageDescriptor.FileAdditionTriggeredReEvaluation : MessageDescriptor.ProjectChangeTriggeredReEvaluation);
 
+                                // TODO: consider re-evaluating only affected projects instead of the whole graph.
                                 evaluationResult = await EvaluateRootProjectAsync(iterationCancellationToken);
 
                                 // additional directories may have been added:
-                                fileWatcher.WatchContainingDirectories(evaluationResult.Files.Keys, includeSubdirectories: true);
+                                evaluationResult.WatchFiles(fileWatcher);
 
                                 await compilationHandler.Workspace.UpdateProjectConeAsync(RootFileSetFactory.RootProjectFile, iterationCancellationToken);
 
@@ -482,7 +485,7 @@ async Task<ImmutableList<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableDict
 
                             ReportFileChanges(changedFiles);
 
-                            if (!hasAddedFile)
+                            if (!evaluationRequired)
                             {
                                 // update the workspace to reflect changes in the file content:
                                 await compilationHandler.Workspace.UpdateFileContentAsync(changedFiles, iterationCancellationToken);
@@ -551,7 +554,7 @@ private async ValueTask WaitForFileChangeBeforeRestarting(FileWatcher fileWatche
             {
                 if (!fileWatcher.WatchingDirectories)
                 {
-                    fileWatcher.WatchContainingDirectories(evaluationResult.Files.Keys, includeSubdirectories: true);
+                    evaluationResult.WatchFiles(fileWatcher);
                 }
 
                 _ = await fileWatcher.WaitForFileChangeAsync(
@@ -571,7 +574,7 @@ private async ValueTask WaitForFileChangeBeforeRestarting(FileWatcher fileWatche
             }
         }
 
-        private bool AcceptChange(ChangedPath change, EvaluationResult evaluationResult, IReadOnlySet<string> outputDirectories)
+        private bool AcceptChange(ChangedPath change, EvaluationResult evaluationResult)
         {
             var (path, kind) = change;
 
@@ -581,21 +584,27 @@ private bool AcceptChange(ChangedPath change, EvaluationResult evaluationResult,
                 return true;
             }
 
-            // Ignore other changes to output and intermediate output directories.
+            if (!AcceptChange(change))
+            {
+                return false;
+            }
+
+            // changes in *.*proj, *.props, *.targets:
+            if (evaluationResult.BuildFiles.Contains(path))
+            {
+                return true;
+            }
+
+            // Ignore other changes that match DefaultItemExcludes glob if EnableDefaultItems is true,
+            // otherwise changes under output and intermediate output directories.
             //
             // Unsupported scenario:
             // - msbuild target adds source files to intermediate output directory and Compile items
             //   based on the content of non-source file.
             //
             // On the other hand, changes to source files produced by source generators will be registered
             // since the changes to additional file will trigger workspace update, which will trigger the source generator.
-            if (PathUtilities.ContainsPath(outputDirectories, path))
-            {
-                Context.Reporter.Report(MessageDescriptor.IgnoringChangeInOutputDirectory, kind, path);
-                return false;
-            }
-
-            return AcceptChange(change);
+            return !evaluationResult.ItemExclusions.IsExcluded(path, kind, Context.Reporter);
         }
 
         private bool AcceptChange(ChangedPath change)
@@ -618,54 +627,6 @@ private bool AcceptChange(ChangedPath change)
         private static bool IsHiddenDirectory(string dir)
             => Path.GetFileName(dir).StartsWith('.');
 
-        private static IReadOnlySet<string> GetProjectOutputDirectories(ProjectGraph projectGraph)
-        {
-            // TODO: https://github.com/dotnet/sdk/issues/45539
-            // Consider evaluating DefaultItemExcludes and DefaultExcludesInProjectFolder msbuild properties using
-            // https://github.com/dotnet/msbuild/blob/37eb419ad2c986ac5530292e6ee08e962390249e/src/Build/Globbing/MSBuildGlob.cs
-            // to determine which directories should be excluded.
-
-            var projectOutputDirectories = new HashSet<string>(PathUtilities.OSSpecificPathComparer);
-
-            foreach (var projectNode in projectGraph.ProjectNodes)
-            {
-                TryAdd(projectNode.GetOutputDirectory());
-                TryAdd(projectNode.GetIntermediateOutputDirectory());
-            }
-
-            return projectOutputDirectories;
-
-            void TryAdd(string? dir)
-            {
-                try
-                {
-                    if (dir != null)
-                    {
-                        // msbuild properties may use '\' as a directory separator even on Unix.
-                        // GetFullPath does not normalize '\' to '/' on Unix.
-                        if (Path.DirectorySeparatorChar == '/')
-                        {
-                            dir = dir.Replace('\\', '/');
-                        }
-
-                        projectOutputDirectories.Add(Path.TrimEndingDirectorySeparator(Path.GetFullPath(dir)));
-                    }
-                }
-                catch
-                {
-                    // ignore
-                }
-            }
-        }
-
-        private void ReportOutputDirectories(IReadOnlySet<string> directories)
-        {
-            foreach (var dir in directories)
-            {
-                Context.Reporter.Verbose($"Output directory: '{dir}'");
-            }
-        }
-
         internal static IEnumerable<ChangedPath> NormalizePathChanges(IEnumerable<ChangedPath> changes)
             => changes
                 .GroupBy(keySelector: change => change.Path)

src/BuiltInTools/dotnet-watch/Internal/IReporter.cs

@@ -85,8 +85,10 @@ public MessageDescriptor ToErrorWhen(bool condition)
         public static readonly MessageDescriptor ConfiguredToUseBrowserRefresh = new("Configuring the app to use browser-refresh middleware", WatchEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor IgnoringChangeInHiddenDirectory = new("Ignoring change in hidden directory '{0}': {1} '{2}'", WatchEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor IgnoringChangeInOutputDirectory = new("Ignoring change in output directory: {0} '{1}'", WatchEmoji, MessageSeverity.Verbose, s_id++);
+        public static readonly MessageDescriptor IgnoringChangeInExcludedFile = new("Ignoring change in excluded file '{0}': {1}. Path matches {2} glob '{3}' set in '{4}'.", WatchEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor FileAdditionTriggeredReEvaluation = new("File addition triggered re-evaluation.", WatchEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor ReEvaluationCompleted = new("Re-evaluation completed.", WatchEmoji, MessageSeverity.Verbose, s_id++);
+        public static readonly MessageDescriptor ProjectChangeTriggeredReEvaluation = new("Project change triggered re-evaluation.", WatchEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor NoCSharpChangesToApply = new("No C# changes to apply.", WatchEmoji, MessageSeverity.Output, s_id++);
         public static readonly MessageDescriptor Exited = new("Exited", WatchEmoji, MessageSeverity.Output, s_id++);
         public static readonly MessageDescriptor ExitedWithUnknownErrorCode = new("Exited with unknown error code", ErrorEmoji, MessageSeverity.Error, s_id++);

src/BuiltInTools/dotnet-watch/Internal/MsBuildFileSetFactory.cs

@@ -1,8 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Text.Json;
+using Microsoft.Build.Evaluation;
+using Microsoft.Build.Execution;
+using Microsoft.Build.FileSystem;
 using Microsoft.Build.Graph;
 
 namespace Microsoft.DotNet.Watch
@@ -121,7 +125,7 @@ void AddFile(string filePath, string? staticWebAssetPath)
                 ProjectGraph? projectGraph = null;
                 if (requireProjectGraph != null)
                 {
-                    projectGraph = TryLoadProjectGraph(requireProjectGraph.Value);
+                    projectGraph = TryLoadProjectGraph(requireProjectGraph.Value, cancellationToken);
                     if (projectGraph == null && requireProjectGraph == true)
                     {
                         return null;
@@ -194,7 +198,11 @@ private static string FindTargetsFile()
         }
 
         // internal for testing
-        internal ProjectGraph? TryLoadProjectGraph(bool projectGraphRequired)
+
+        /// <summary>
+        /// Tries to create a project graph by running the build evaluation phase on the <see cref="rootProjectFile"/>.
+        /// </summary>
+        internal ProjectGraph? TryLoadProjectGraph(bool projectGraphRequired, CancellationToken cancellationToken)
         {
             var globalOptions = new Dictionary<string, string>();
 
@@ -203,9 +211,11 @@ private static string FindTargetsFile()
                 globalOptions[name] = value;
             }
 
+            var entryPoint = new ProjectGraphEntryPoint(rootProjectFile, globalOptions);
+
             try
             {
-                return new ProjectGraph(rootProjectFile, globalOptions);
+                return new ProjectGraph([entryPoint], ProjectCollection.GlobalProjectCollection, projectInstanceFactory: null, cancellationToken);
             }
             catch (Exception e)
             {