Report warning when changing file that is only included in stale projects (#78276)

Author: tmat

src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs

@@ -169,6 +169,7 @@ void AddGeneralDiagnostic(EditAndContinueErrorCode code, string resourceName, Di
         AddGeneralDiagnostic(EditAndContinueErrorCode.DocumentIsOutOfSyncWithDebuggee, nameof(FeaturesResources.DocumentIsOutOfSyncWithDebuggee), DiagnosticSeverity.Warning);
         AddGeneralDiagnostic(EditAndContinueErrorCode.UnableToReadSourceFileOrPdb, nameof(FeaturesResources.UnableToReadSourceFileOrPdb));
         AddGeneralDiagnostic(EditAndContinueErrorCode.AddingTypeRuntimeCapabilityRequired, nameof(FeaturesResources.ChangesRequiredSynthesizedType));
+        AddGeneralDiagnostic(EditAndContinueErrorCode.UpdatingDocumentInStaleProject, nameof(FeaturesResources.Changing_source_file_0_in_a_stale_project_has_no_effect_until_the_project_is_rebuit), DiagnosticSeverity.Warning);
 
         s_descriptors = builder.ToImmutable();
     }

src/Features/Core/Portable/EditAndContinue/EditAndContinueErrorCode.cs

@@ -13,4 +13,5 @@ internal enum EditAndContinueErrorCode
     DocumentIsOutOfSyncWithDebuggee = 5,
     UnableToReadSourceFileOrPdb = 6,
     AddingTypeRuntimeCapabilityRequired = 7,
+    UpdatingDocumentInStaleProject = 8,
 }

src/Features/Core/Portable/EditAndContinue/EditSession.cs

@@ -354,7 +354,7 @@ internal static async ValueTask<bool> HasChangedOrAddedDocumentsAsync(Project ol
         foreach (var documentId in newProject.State.DocumentStates.GetChangedStateIds(oldProject.State.DocumentStates, ignoreUnchangedContent: true))
         {
             var document = newProject.GetRequiredDocument(documentId);
-            if (document.State.Attributes.DesignTimeOnly)
+            if (!document.State.SupportsEditAndContinue())
             {
                 continue;
             }
@@ -375,7 +375,7 @@ internal static async ValueTask<bool> HasChangedOrAddedDocumentsAsync(Project ol
         foreach (var documentId in newProject.State.DocumentStates.GetAddedStateIds(oldProject.State.DocumentStates))
         {
             var document = newProject.GetRequiredDocument(documentId);
-            if (document.State.Attributes.DesignTimeOnly)
+            if (!document.State.SupportsEditAndContinue())
             {
                 continue;
             }
@@ -827,6 +827,30 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
             using var _5 = ArrayBuilder<Document>.GetInstance(out var changedOrAddedDocuments);
             using var _6 = ArrayBuilder<(DocumentId, ImmutableArray<RudeEditDiagnostic>)>.GetInstance(out var documentsWithRudeEdits);
             using var _7 = ArrayBuilder<ProjectId>.GetInstance(out var projectsToStale);
+
+            // After all projects have been analyzed "true" value indicates changed document that is only included in stale projects.
+            var changedDocumentsStaleness = new Dictionary<string, bool>(SolutionState.FilePathComparer);
+
+            void UpdateChangedDocumentsStaleness(bool isStale)
+            {
+                foreach (var changedDocument in changedOrAddedDocuments)
+                {
+                    var path = changedDocument.FilePath;
+
+                    // Only documents that support EnC (have paths) are added to the list.
+                    Contract.ThrowIfNull(path);
+
+                    if (isStale)
+                    {
+                        _ = changedDocumentsStaleness.TryAdd(path, true);
+                    }
+                    else
+                    {
+                        changedDocumentsStaleness[path] = false;
+                    }
+                }
+            }
+
             Diagnostic? syntaxError = null;
 
             var oldSolution = DebuggingSession.LastCommittedSolution;
@@ -860,13 +884,6 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     continue;
                 }
 
-                // We don't track document changes in stale projects until they are rebuilt (removed from stale set).
-                if (oldSolution.IsStaleProject(newProject.Id))
-                {
-                    Log.Write($"EnC state of {newProject.Name} '{newProject.FilePath}' queried: project is stale");
-                    continue;
-                }
-
                 await PopulateChangedAndAddedDocumentsAsync(Log, oldProject, newProject, changedOrAddedDocuments, diagnostics, cancellationToken).ConfigureAwait(false);
                 if (changedOrAddedDocuments.IsEmpty)
                 {
@@ -875,6 +892,16 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
 
                 Log.Write($"Found {changedOrAddedDocuments.Count} potentially changed document(s) in project {newProject.Name} '{newProject.FilePath}'");
 
+                var isStaleProject = oldSolution.IsStaleProject(newProject.Id);
+
+                // We don't consider document changes in stale projects until they are rebuilt (removed from stale set).
+                if (isStaleProject)
+                {
+                    Log.Write($"EnC state of {newProject.Name} '{newProject.FilePath}' queried: project is stale");
+                    UpdateChangedDocumentsStaleness(isStale: true);
+                    continue;
+                }
+
                 var (mvid, mvidReadError) = await DebuggingSession.GetProjectModuleIdAsync(newProject, cancellationToken).ConfigureAwait(false);
                 if (mvidReadError != null)
                 {
@@ -891,6 +918,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                 if (mvid == Guid.Empty)
                 {
                     Log.Write($"Changes not applied to {newProject.Name} '{newProject.FilePath}': project not built");
+                    UpdateChangedDocumentsStaleness(isStale: true);
                     continue;
                 }
 
@@ -931,10 +959,15 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     // The project is considered stale as long as it has at least one document that is out-of-sync.
                     // Treat the project the same as if it hasn't been built. We won't produce delta for it until it gets rebuilt.
                     Log.Write($"Changes not applied to {newProject.Name} '{newProject.FilePath}': binaries not up-to-date");
+
                     projectsToStale.Add(newProject.Id);
+                    UpdateChangedDocumentsStaleness(isStale: true);
+
                     continue;
                 }
 
+                UpdateChangedDocumentsStaleness(isStale: false);
+
                 foreach (var changedDocumentAnalysis in changedDocumentAnalyses)
                 {
                     if (changedDocumentAnalysis.SyntaxError != null)
@@ -1160,6 +1193,22 @@ async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cance
                 }
             }
 
+            // Report stale document updates.
+            // We report a warning when a changed/added document is only included in (linked to) stale projects.
+
+            foreach (var (documentPath, isStale) in changedDocumentsStaleness)
+            {
+                if (isStale)
+                {
+                    foreach (var documentId in solution.GetDocumentIdsWithFilePath(documentPath))
+                    {
+                        var descriptor = EditAndContinueDiagnosticDescriptors.GetDescriptor(EditAndContinueErrorCode.UpdatingDocumentInStaleProject);
+                        var diagnostic = Diagnostic.Create(descriptor, Location.Create(documentPath, textSpan: default, lineSpan: default), [documentPath]);
+                        diagnostics.Add(new ProjectDiagnostics(documentId.ProjectId, [diagnostic]));
+                    }
+                }
+            }
+
             // log capabilities for edit sessions with changes or reported errors:
             if (blockUpdates || deltas.Count > 0)
             {

src/Features/Core/Portable/EditAndContinue/EmitSolutionUpdateResults.cs

@@ -98,7 +98,13 @@ internal ImmutableArray<ManagedHotReloadDiagnostic> GetAllDiagnostics()
     public required Solution? Solution { get; init; }
 
     public required ModuleUpdates ModuleUpdates { get; init; }
+
+    /// <summary>
+    /// Reported diagnostics, other than rude edits, per project.
+    /// May contain multiple entries for the same project.
+    /// </summary>
     public required ImmutableArray<ProjectDiagnostics> Diagnostics { get; init; }
+
     public required ImmutableArray<ProjectDiagnostics> RudeEdits { get; init; }
     public required Diagnostic? SyntaxError { get; init; }
 

src/Features/Core/Portable/FeaturesResources.resx

@@ -2681,6 +2681,9 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
   <data name="ChangesRequiredSynthesizedType" xml:space="preserve">
     <value>One or more changes result in a new type being created by the compiler, which requires restarting the application because it is not supported by the runtime</value>
   </data>
+  <data name="Changing_source_file_0_in_a_stale_project_has_no_effect_until_the_project_is_rebuit" xml:space="preserve">
+    <value>Changing source file '{0}' in a stale project has no effect until the project is rebuit.</value>
+  </data>
   <data name="Miscellaneous_Files" xml:space="preserve">
     <value>Miscellaneous Files</value>
   </data>