Fix updating committed solution with insignificant changes (#77648)

tmat · web-flow · commit 38f239fb81b7 · 2025-03-21T07:32:27.000-07:00
diff --git a/src/EditorFeatures/Core/EditAndContinue/EditAndContinueLanguageService.cs b/src/EditorFeatures/Core/EditAndContinue/EditAndContinueLanguageService.cs
@@ -378,10 +378,19 @@ public async ValueTask<ManagedHotReloadUpdates> GetUpdatesAsync(ImmutableArray<s
         var runningProjectIds = solution.Projects.Where(p => p.FilePath != null && runningProjectPaths.Contains(p.FilePath)).Select(static p => p.Id).ToImmutableHashSet();
         var result = await GetDebuggingSession().EmitSolutionUpdateAsync(solution, runningProjectIds, activeStatementSpanProvider, cancellationToken).ConfigureAwait(false);
 
-        // Only store the solution if we have any changes to apply, otherwise CommitUpdatesAsync/DiscardUpdatesAsync won't be called.
-        if (result.ModuleUpdates.Status == ModuleUpdateStatus.Ready)
+        switch (result.ModuleUpdates.Status)
         {
-            _pendingUpdatedDesignTimeSolution = designTimeSolution;
+            case ModuleUpdateStatus.Ready:
+                // We have updates to be applied. The debugger will call Commit/Discard on the solution
+                // based on whether the updates will be applied successfully or not.
+                _pendingUpdatedDesignTimeSolution = designTimeSolution;
+                break;
+
+            case ModuleUpdateStatus.None:
+                // No significant changes have been made.
+                // Commit the solution to apply any changes in comments that do not generate updates.
+                _committedDesignTimeSolution = designTimeSolution;
+                break;
         }
 
         UpdateApplyChangesDiagnostics(result.Diagnostics);
diff --git a/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs b/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs
@@ -511,13 +511,27 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(
         solutionUpdate.Log(SessionLog, updateId);
         _lastModuleUpdatesLog = solutionUpdate.ModuleUpdates.Updates;
 
-        if (solutionUpdate.ModuleUpdates.Status == ModuleUpdateStatus.Ready)
+        switch (solutionUpdate.ModuleUpdates.Status)
         {
-            StorePendingUpdate(new PendingSolutionUpdate(
-                solution,
-                solutionUpdate.ProjectBaselines,
-                solutionUpdate.ModuleUpdates.Updates,
-                solutionUpdate.NonRemappableRegions));
+            case ModuleUpdateStatus.Ready:
+                // We have updates to be applied. The debugger will call Commit/Discard on the solution
+                // based on whether the updates will be applied successfully or not.
+                StorePendingUpdate(new PendingSolutionUpdate(
+                    solution,
+                    solutionUpdate.ProjectBaselines,
+                    solutionUpdate.ModuleUpdates.Updates,
+                    solutionUpdate.NonRemappableRegions));
+
+                break;
+
+            case ModuleUpdateStatus.None:
+                Contract.ThrowIfFalse(solutionUpdate.ModuleUpdates.Updates.IsEmpty);
+                Contract.ThrowIfFalse(solutionUpdate.NonRemappableRegions.IsEmpty);
+
+                // No significant changes have been made.
+                // Commit the solution to apply any changes in comments that do not generate updates.
+                LastCommittedSolution.CommitSolution(solution);
+                break;
         }
 
         using var _ = ArrayBuilder<ProjectDiagnostics>.GetInstance(out var rudeEditDiagnostics);
diff --git a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
@@ -166,8 +166,8 @@ void AddGeneralDiagnostic(EditAndContinueErrorCode code, string resourceName, Di
         AddGeneralDiagnostic(EditAndContinueErrorCode.ErrorReadingFile, nameof(FeaturesResources.ErrorReadingFile));
         AddGeneralDiagnostic(EditAndContinueErrorCode.CannotApplyChangesUnexpectedError, nameof(FeaturesResources.CannotApplyChangesUnexpectedError));
         AddGeneralDiagnostic(EditAndContinueErrorCode.ChangesDisallowedWhileStoppedAtException, nameof(FeaturesResources.ChangesDisallowedWhileStoppedAtException));
-        AddGeneralDiagnostic(EditAndContinueErrorCode.DocumentIsOutOfSyncWithDebuggee, nameof(FeaturesResources.DocumentIsOutOfSyncWithDebuggee), DiagnosticSeverity.Warning);
-        AddGeneralDiagnostic(EditAndContinueErrorCode.UnableToReadSourceFileOrPdb, nameof(FeaturesResources.UnableToReadSourceFileOrPdb), DiagnosticSeverity.Warning);
+        AddGeneralDiagnostic(EditAndContinueErrorCode.DocumentIsOutOfSyncWithDebuggee, nameof(FeaturesResources.DocumentIsOutOfSyncWithDebuggee));
+        AddGeneralDiagnostic(EditAndContinueErrorCode.UnableToReadSourceFileOrPdb, nameof(FeaturesResources.UnableToReadSourceFileOrPdb));
         AddGeneralDiagnostic(EditAndContinueErrorCode.AddingTypeRuntimeCapabilityRequired, nameof(FeaturesResources.ChangesRequiredSynthesizedType));
 
         s_descriptors = builder.ToImmutable();
diff --git a/src/Features/Core/Portable/EditAndContinue/EditSession.cs b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
@@ -821,8 +821,9 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
 
             var oldSolution = DebuggingSession.LastCommittedSolution;
 
-            var isBlocked = false;
+            var blockUpdates = false;
             var hasEmitErrors = false;
+            var hadDocumentReadError = false;
             foreach (var newProject in solution.Projects)
             {
                 if (!newProject.SupportsEditAndContinue(Log))
@@ -866,7 +867,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     diagnostics.Add(new(newProject.Id, [mvidReadError]));
 
                     Telemetry.LogProjectAnalysisSummary(ProjectAnalysisSummary.ValidChanges, newProject.State.ProjectInfo.Attributes.TelemetryId, ImmutableArray.Create(mvidReadError.Descriptor.Id));
-                    isBlocked = true;
+                    blockUpdates = true;
                     continue;
                 }
 
@@ -899,6 +900,11 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     // If in future the file is updated so that its content matches the PDB checksum, the document transitions to a matching state,
                     // and we consider any further changes to it for application.
                     diagnostics.Add(new(newProject.Id, documentDiagnostics));
+
+                    if (documentDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
+                    {
+                        blockUpdates = hadDocumentReadError = true;
+                    }
                 }
 
                 foreach (var changedDocumentAnalysis in changedDocumentAnalyses)
@@ -935,12 +941,12 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                 if (isModuleEncBlocked)
                 {
                     diagnostics.Add(new(newProject.Id, moduleDiagnostics));
-                    isBlocked = true;
+                    blockUpdates = true;
                 }
 
                 if (projectSummary is ProjectAnalysisSummary.SyntaxErrors or ProjectAnalysisSummary.RudeEdits)
                 {
-                    isBlocked = true;
+                    blockUpdates = true;
                 }
 
                 // Report rude edit diagnostics - these can be blocking (errors) or non-blocking (warnings):
@@ -972,7 +978,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     diagnostics.Add(new(newProject.Id, createBaselineErrors));
                     Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, createBaselineErrors);
 
-                    isBlocked = true;
+                    blockUpdates = true;
                     await LogDocumentChangesAsync(generation: null, cancellationToken).ConfigureAwait(false);
                     continue;
                 }
@@ -1050,7 +1056,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     if (!emitResult.Success)
                     {
                         // error
-                        isBlocked = hasEmitErrors = true;
+                        blockUpdates = hasEmitErrors = true;
                         emitDiagnostics = emitResult.Diagnostics;
                         break;
                     }
@@ -1062,7 +1068,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                     {
                         emitDiagnostics = [unsupportedChangesDiagnostic];
                         diagnostics.Add(new(newProject.Id, emitDiagnostics));
-                        isBlocked = true;
+                        blockUpdates = true;
                         break;
                     }
 
@@ -1127,13 +1133,17 @@ async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cance
             }
 
             // log capabilities for edit sessions with changes or reported errors:
-            if (isBlocked || deltas.Count > 0)
+            if (blockUpdates || deltas.Count > 0)
             {
                 Telemetry.LogRuntimeCapabilities(await Capabilities.GetValueAsync(cancellationToken).ConfigureAwait(false));
             }
 
-            var update = isBlocked
-                ? SolutionUpdate.Blocked(diagnostics.ToImmutable(), documentsWithRudeEdits.ToImmutable(), syntaxError, hasEmitErrors)
+            var update = blockUpdates
+                ? SolutionUpdate.Empty(
+                    diagnostics.ToImmutable(),
+                    documentsWithRudeEdits.ToImmutable(),
+                    syntaxError,
+                    syntaxError != null || hasEmitErrors || hadDocumentReadError ? ModuleUpdateStatus.Blocked : ModuleUpdateStatus.RestartRequired)
                 : new SolutionUpdate(
                     new ModuleUpdates(
                         (deltas.Count > 0) ? ModuleUpdateStatus.Ready : ModuleUpdateStatus.None,
diff --git a/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs b/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs
@@ -24,13 +24,13 @@ internal readonly struct SolutionUpdate(
     public readonly ImmutableArray<(DocumentId DocumentId, ImmutableArray<RudeEditDiagnostic> Diagnostics)> DocumentsWithRudeEdits = documentsWithRudeEdits;
     public readonly Diagnostic? SyntaxError = syntaxError;
 
-    public static SolutionUpdate Blocked(
+    public static SolutionUpdate Empty(
         ImmutableArray<ProjectDiagnostics> diagnostics,
         ImmutableArray<(DocumentId, ImmutableArray<RudeEditDiagnostic>)> documentsWithRudeEdits,
         Diagnostic? syntaxError,
-        bool hasEmitErrors)
+        ModuleUpdateStatus status)
         => new(
-            new(syntaxError != null || hasEmitErrors ? ModuleUpdateStatus.Blocked : ModuleUpdateStatus.RestartRequired, []),
+            new(status, Updates: []),
             nonRemappableRegions: [],
             projectBaselines: [],
             diagnostics,
diff --git a/src/Features/Core/Portable/ExternalAccess/Watch/Api/WatchHotReloadService.cs b/src/Features/Core/Portable/ExternalAccess/Watch/Api/WatchHotReloadService.cs
@@ -190,7 +190,9 @@ public async Task<Updates> GetUpdatesAsync(Solution solution, IImmutableSet<Proj
 
         var results = await _encService.EmitSolutionUpdateAsync(sessionId, solution, runningProjects, s_solutionActiveStatementSpanProvider, cancellationToken).ConfigureAwait(false);
 
-        if (results.ModuleUpdates.Status == ModuleUpdateStatus.Ready)
+        // If the changes fail to apply dotnet-watch fails.
+        // We don't support discarding the changes and letting the user retry.
+        if (!results.ModuleUpdates.Updates.IsEmpty)
         {
             _encService.CommitSolutionUpdate(sessionId);
         }
@@ -241,6 +243,9 @@ internal readonly struct TestAccessor(WatchHotReloadService instance)
     {
         public DebuggingSessionId SessionId
             => instance._sessionId;
+
+        public IEditAndContinueService EncService
+            => instance._encService;
     }
 }
 #endif
diff --git a/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs b/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
@@ -153,9 +153,9 @@ public async Task StartDebuggingSession_CapturingDocuments(bool captureAllDocume
         EnterBreakState(debuggingSession);
 
         var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
-        Assert.Equal(ModuleUpdateStatus.None, updates.Status);
+        Assert.Equal(ModuleUpdateStatus.Blocked, updates.Status);
         Assert.Empty(updates.Updates);
-        AssertEx.Equal([$"P.csproj: (0,0)-(0,0): Warning ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFileB.Path)}"], InspectDiagnostics(emitDiagnostics));
+        AssertEx.Equal([$"P.csproj: (0,0)-(0,0): Error ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFileB.Path)}"], InspectDiagnostics(emitDiagnostics));
 
         EndDebuggingSession(debuggingSession);
     }
@@ -595,9 +595,9 @@ public async Task ErrorReadingPdbFile()
 
         // an error occurred so we need to call update to determine whether we have changes to apply or not:
         var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
-        Assert.Equal(ModuleUpdateStatus.None, updates.Status);
+        Assert.Equal(ModuleUpdateStatus.Blocked, updates.Status);
         Assert.Empty(updates.Updates);
-        AssertEx.Equal([$"proj.csproj: (0,0)-(0,0): Warning ENC1006: {string.Format(FeaturesResources.UnableToReadSourceFileOrPdb, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
+        AssertEx.Equal([$"proj.csproj: (0,0)-(0,0): Error ENC1006: {string.Format(FeaturesResources.UnableToReadSourceFileOrPdb, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
 
         EndDebuggingSession(debuggingSession);
 
@@ -642,9 +642,9 @@ public async Task ErrorReadingSourceFile()
 
         // an error occurred so we need to call update to determine whether we have changes to apply or not:
         var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
-        Assert.Equal(ModuleUpdateStatus.None, updates.Status);
+        Assert.Equal(ModuleUpdateStatus.Blocked, updates.Status);
         Assert.Empty(updates.Updates);
-        AssertEx.Equal([$"test.csproj: (0,0)-(0,0): Warning ENC1006: {string.Format(FeaturesResources.UnableToReadSourceFileOrPdb, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
+        AssertEx.Equal([$"test.csproj: (0,0)-(0,0): Error ENC1006: {string.Format(FeaturesResources.UnableToReadSourceFileOrPdb, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
 
         fileLock.Dispose();
 
@@ -1168,9 +1168,9 @@ public async Task RudeEdits_DocumentOutOfSync(bool breakMode)
 
         // since the document is out-of-sync we need to call update to determine whether we have changes to apply or not:
         var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
-        Assert.Equal(ModuleUpdateStatus.None, updates.Status);
+        Assert.Equal(ModuleUpdateStatus.Blocked, updates.Status);
         Assert.Empty(updates.Updates);
-        AssertEx.Equal([$"proj.csproj: (0,0)-(0,0): Warning ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
+        AssertEx.Equal([$"proj.csproj: (0,0)-(0,0): Error ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
 
         // update the file to match the build:
         sourceFile.WriteAllText(source0, Encoding.UTF8);
@@ -2312,8 +2312,8 @@ public async Task ValidSignificantChange_FileUpdateNotObservedBeforeDebuggingSes
 
         // since the document is out-of-sync we need to call update to determine whether we have changes to apply or not:
         var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
-        Assert.Equal(ModuleUpdateStatus.None, updates.Status);
-        AssertEx.Equal([$"test.csproj: (0,0)-(0,0): Warning ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
+        Assert.Equal(ModuleUpdateStatus.Blocked, updates.Status);
+        AssertEx.Equal([$"test.csproj: (0,0)-(0,0): Error ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFile.Path)}"], InspectDiagnostics(emitDiagnostics));
 
         // undo:
         solution = solution.WithDocumentText(documentId, CreateText(source1));
@@ -3111,6 +3111,44 @@ public async Task ValidSignificantChange_SourceGenerators_DocumentRemove()
         EndDebuggingSession(debuggingSession);
     }
 
+    [Fact]
+    public async Task ValidInsignificantChange()
+    {
+        var sourceV1 = "class C1 { void M() { /* System.Console.WriteLine(1); */ } }";
+        var sourceV2 = "class C1 { void M() { /* System.Console.WriteLine(2); */ } }";
+
+        using var _ = CreateWorkspace(out var solution, out var service);
+        (solution, var document1) = AddDefaultTestProject(solution, sourceV1);
+
+        var moduleId = EmitAndLoadLibraryToDebuggee(sourceV1);
+
+        var debuggingSession = await StartDebuggingSessionAsync(service, solution);
+
+        // change the source (valid edit):
+        solution = solution.WithDocumentText(document1.Id, CreateText(sourceV2));
+        var document2 = solution.GetDocument(document1.Id);
+
+        var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
+        AssertEx.Empty(diagnostics1);
+
+        // validate solution update status and emit:
+        var (updates, emitDiagnostics) = await EmitSolutionUpdateAsync(debuggingSession, solution);
+        Assert.Empty(emitDiagnostics);
+        Assert.Equal(ModuleUpdateStatus.None, updates.Status);
+
+        // solution has been updated:
+        var text = await debuggingSession.LastCommittedSolution.GetRequiredProject(document1.Project.Id).GetDocument(document1.Id).GetTextAsync();
+        Assert.Equal(sourceV2, text.ToString());
+
+        EndDebuggingSession(debuggingSession);
+
+        AssertEx.SequenceEqual(
+        [
+            "Debugging_EncSession: SolutionSessionId={00000000-AAAA-AAAA-AAAA-000000000000}|SessionId=1|SessionCount=0|EmptySessionCount=0|HotReloadSessionCount=1|EmptyHotReloadSessionCount=0",
+            "Debugging_EncSession_EditSession: SessionId=1|EditSessionId=2|HadCompilationErrors=False|HadRudeEdits=False|HadValidChanges=False|HadValidInsignificantChanges=True|RudeEditsCount=0|EmitDeltaErrorIdCount=0|InBreakState=False|Capabilities=0|ProjectIdsWithAppliedChanges=|ProjectIdsWithUpdatedBaselines="
+        ], _telemetryLog);
+    }
+
     [Fact]
     public async Task RudeEdit()
     {
diff --git a/src/Features/Test/EditAndContinue/WatchHotReloadServiceTests.cs b/src/Features/Test/EditAndContinue/WatchHotReloadServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -821,8 +821,9 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`821`	`821`
`822`	`822`	`var oldSolution = DebuggingSession.LastCommittedSolution;`
`823`	`823`
`824`		`- var isBlocked = false;`
	`824`	`+ var blockUpdates = false;`
`825`	`825`	`var hasEmitErrors = false;`
	`826`	`+ var hadDocumentReadError = false;`
`826`	`827`	`foreach (var newProject in solution.Projects)`
`827`	`828`	`{`
`828`	`829`	`if (!newProject.SupportsEditAndContinue(Log))`
`@@ -866,7 +867,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`866`	`867`	`diagnostics.Add(new(newProject.Id, [mvidReadError]));`
`867`	`868`
`868`	`869`	`Telemetry.LogProjectAnalysisSummary(ProjectAnalysisSummary.ValidChanges, newProject.State.ProjectInfo.Attributes.TelemetryId, ImmutableArray.Create(mvidReadError.Descriptor.Id));`
`869`		`- isBlocked = true;`
	`870`	`+ blockUpdates = true;`
`870`	`871`	`continue;`
`871`	`872`	`}`
`872`	`873`
`@@ -899,6 +900,11 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`899`	`900`	`// If in future the file is updated so that its content matches the PDB checksum, the document transitions to a matching state,`
`900`	`901`	`// and we consider any further changes to it for application.`
`901`	`902`	`diagnostics.Add(new(newProject.Id, documentDiagnostics));`
	`903`	`+`
	`904`	`+ if (documentDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))`
	`905`	`+ {`
	`906`	`+ blockUpdates = hadDocumentReadError = true;`
	`907`	`+ }`
`902`	`908`	`}`
`903`	`909`
`904`	`910`	`foreach (var changedDocumentAnalysis in changedDocumentAnalyses)`
`@@ -935,12 +941,12 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`935`	`941`	`if (isModuleEncBlocked)`
`936`	`942`	`{`
`937`	`943`	`diagnostics.Add(new(newProject.Id, moduleDiagnostics));`
`938`		`- isBlocked = true;`
	`944`	`+ blockUpdates = true;`
`939`	`945`	`}`
`940`	`946`
`941`	`947`	`if (projectSummary is ProjectAnalysisSummary.SyntaxErrors or ProjectAnalysisSummary.RudeEdits)`
`942`	`948`	`{`
`943`		`- isBlocked = true;`
	`949`	`+ blockUpdates = true;`
`944`	`950`	`}`
`945`	`951`
`946`	`952`	`// Report rude edit diagnostics - these can be blocking (errors) or non-blocking (warnings):`
`@@ -972,7 +978,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`972`	`978`	`diagnostics.Add(new(newProject.Id, createBaselineErrors));`
`973`	`979`	`Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, createBaselineErrors);`
`974`	`980`
`975`		`- isBlocked = true;`
	`981`	`+ blockUpdates = true;`
`976`	`982`	`await LogDocumentChangesAsync(generation: null, cancellationToken).ConfigureAwait(false);`
`977`	`983`	`continue;`
`978`	`984`	`}`
`@@ -1050,7 +1056,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`1050`	`1056`	`if (!emitResult.Success)`
`1051`	`1057`	`{`
`1052`	`1058`	`// error`
`1053`		`- isBlocked = hasEmitErrors = true;`
	`1059`	`+ blockUpdates = hasEmitErrors = true;`
`1054`	`1060`	`emitDiagnostics = emitResult.Diagnostics;`
`1055`	`1061`	`break;`
`1056`	`1062`	`}`
`@@ -1062,7 +1068,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution`
`1062`	`1068`	`{`
`1063`	`1069`	`emitDiagnostics = [unsupportedChangesDiagnostic];`
`1064`	`1070`	`diagnostics.Add(new(newProject.Id, emitDiagnostics));`
`1065`		`- isBlocked = true;`
	`1071`	`+ blockUpdates = true;`
`1066`	`1072`	`break;`
`1067`	`1073`	`}`
`1068`	`1074`
`@@ -1127,13 +1133,17 @@ async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cance`
`1127`	`1133`	`}`
`1128`	`1134`
`1129`	`1135`	`// log capabilities for edit sessions with changes or reported errors:`
`1130`		`- if (isBlocked \|\| deltas.Count > 0)`
	`1136`	`+ if (blockUpdates \|\| deltas.Count > 0)`
`1131`	`1137`	`{`
`1132`	`1138`	`Telemetry.LogRuntimeCapabilities(await Capabilities.GetValueAsync(cancellationToken).ConfigureAwait(false));`
`1133`	`1139`	`}`
`1134`	`1140`
`1135`		`- var update = isBlocked`
`1136`		`- ? SolutionUpdate.Blocked(diagnostics.ToImmutable(), documentsWithRudeEdits.ToImmutable(), syntaxError, hasEmitErrors)`
	`1141`	`+ var update = blockUpdates`
	`1142`	`+ ? SolutionUpdate.Empty(`
	`1143`	`+ diagnostics.ToImmutable(),`
	`1144`	`+ documentsWithRudeEdits.ToImmutable(),`
	`1145`	`+ syntaxError,`
	`1146`	`+ syntaxError != null \|\| hasEmitErrors \|\| hadDocumentReadError ? ModuleUpdateStatus.Blocked : ModuleUpdateStatus.RestartRequired)`
`1137`	`1147`	`: new SolutionUpdate(`
`1138`	`1148`	`new ModuleUpdates(`
`1139`	`1149`	`(deltas.Count > 0) ? ModuleUpdateStatus.Ready : ModuleUpdateStatus.None,`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,9 @@ public async Task<Updates> GetUpdatesAsync(Solution solution, IImmutableSet<Proj`
`190`	`190`
`191`	`191`	`var results = await _encService.EmitSolutionUpdateAsync(sessionId, solution, runningProjects, s_solutionActiveStatementSpanProvider, cancellationToken).ConfigureAwait(false);`
`192`	`192`
`193`		`- if (results.ModuleUpdates.Status == ModuleUpdateStatus.Ready)`
	`193`	`+ // If the changes fail to apply dotnet-watch fails.`
	`194`	`+ // We don't support discarding the changes and letting the user retry.`
	`195`	`+ if (!results.ModuleUpdates.Updates.IsEmpty)`
`194`	`196`	`{`
`195`	`197`	`_encService.CommitSolutionUpdate(sessionId);`
`196`	`198`	`}`
`@@ -241,6 +243,9 @@ internal readonly struct TestAccessor(WatchHotReloadService instance)`
`241`	`243`	`{`
`242`	`244`	`public DebuggingSessionId SessionId`
`243`	`245`	`=> instance._sessionId;`
	`246`	`+`
	`247`	`+ public IEditAndContinueService EncService`
	`248`	`+ => instance._encService;`
`244`	`249`	`}`
`245`	`250`	`}`
`246`	`251`	`#endif`