Simplify stale project handling

tmat · tmat · commit adfe920a5fbc · 2025-07-16T15:00:43.000-07:00
diff --git a/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs b/src/Features/Core/Portable/EditAndContinue/CommittedSolution.cs
@@ -66,15 +66,17 @@ internal enum DocumentState
 
     /// <summary>
     /// Tracks stale projects. Changes in these projects are ignored and their representation in the <see cref="_solution"/> does not match the binaries on disk.
+    /// The value is the MVID of the module at the time it was determined to be stale (source code content did not match the PDB).
+    /// A build that updates the binary to new content (that presumably matches the source code) will update the MVID. When that happens we unstale the project.
     /// 
     /// Build of a multi-targeted project that sets <c>SingleTargetBuildForStartupProjects</c> msbuild property (e.g. MAUI) only 
     /// builds TFM that's active. Other TFMs of the projects remain unbuilt or stale (from previous build).
     /// 
     /// A project is removed from this set if it's rebuilt.
     /// 
-    /// Lock <see cref="_guard"/> to access.
+    /// Lock <see cref="_guard"/> to update.
     /// </summary>
-    private readonly HashSet<ProjectId> _staleProjects = [];
+    private ImmutableDictionary<ProjectId, Guid> _staleProjects = ImmutableDictionary<ProjectId, Guid>.Empty;
 
     /// <summary>
     /// Implements workaround for https://github.com/dotnet/project-system/issues/5457.
@@ -142,13 +144,8 @@ public bool HasNoChanges(Solution solution)
     public Project GetRequiredProject(ProjectId id)
         => _solution.GetRequiredProject(id);
 
-    public bool IsStaleProject(ProjectId id)
-    {
-        lock (_guard)
-        {
-            return _staleProjects.Contains(id);
-        }
-    }
+    public ImmutableDictionary<ProjectId, Guid> StaleProjects
+        => _staleProjects;
 
     public ImmutableArray<DocumentId> GetDocumentIdsWithFilePath(string path)
         => _solution.GetDocumentIdsWithFilePath(path);
@@ -458,16 +455,22 @@ await TryGetMatchingSourceTextAsync(log, sourceText, sourceFilePath, currentDocu
         }
     }
 
-    public void CommitChanges(Solution solution, ImmutableArray<ProjectId> projectsToStale, IReadOnlyCollection<ProjectId> projectsToUnstale)
+    public void CommitChanges(Solution solution, ImmutableDictionary<ProjectId, Guid>? staleProjects, ImmutableArray<ProjectId>? projectsToUnstale = null)
     {
-        Debug.Assert(projectsToStale.Intersect(projectsToUnstale).IsEmpty());
+        Contract.ThrowIfTrue(staleProjects is null && projectsToUnstale is null);
 
         lock (_guard)
         {
             _solution = solution;
-            _staleProjects.AddRange(projectsToStale);
-            _staleProjects.RemoveRange(projectsToUnstale);
-            _documentState.RemoveAll(static (documentId, _, projectsToUnstale) => projectsToUnstale.Contains(documentId.ProjectId), projectsToUnstale);
+
+            staleProjects ??= _staleProjects.RemoveRange(projectsToUnstale!);
+
+            var oldStaleProjects = _staleProjects;
+            _staleProjects = staleProjects;
+
+            _documentState.RemoveAll(
+                static (documentId, _, args) => args.oldStaleProjects.ContainsKey(documentId.ProjectId) && !args.staleProjects.ContainsKey(documentId.ProjectId),
+                (oldStaleProjects, staleProjects));
         }
     }
 
diff --git a/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs b/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs
@@ -553,7 +553,7 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(
                 {
                     StorePendingUpdate(new PendingSolutionUpdate(
                         solution,
-                        solutionUpdate.ProjectsToStale,
+                        solutionUpdate.StaleProjects,
                         solutionUpdate.ProjectsToRebuild,
                         solutionUpdate.ProjectBaselines,
                         solutionUpdate.ModuleUpdates.Updates,
@@ -565,7 +565,7 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(
 
                     StorePendingUpdate(new PendingSolutionUpdate(
                         solution,
-                        solutionUpdate.ProjectsToStale,
+                        solutionUpdate.StaleProjects,
                         // if partial updates are not allowed we don't treat rebuild as part of solution update:
                         projectsToRebuild: [],
                         solutionUpdate.ProjectBaselines,
@@ -585,7 +585,7 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(
 
                 // No significant changes have been made.
                 // Commit the solution to apply any insignificant changes that do not generate updates.
-                LastCommittedSolution.CommitChanges(solution, projectsToStale: solutionUpdate.ProjectsToStale, projectsToUnstale: []);
+                LastCommittedSolution.CommitChanges(solution, solutionUpdate.StaleProjects);
                 break;
         }
 
@@ -611,6 +611,8 @@ public void CommitSolutionUpdate()
 
         ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>? newNonRemappableRegions = null;
         using var _ = PooledHashSet<ProjectId>.GetInstance(out var projectsToRebuildTransitive);
+        IEnumerable<ProjectId> baselinesToDiscard = [];
+        Solution? solution = null;
 
         var pendingUpdate = RetrievePendingUpdate();
         if (pendingUpdate is PendingSolutionUpdate pendingSolutionUpdate)
@@ -626,7 +628,7 @@ from region in moduleRegions.Regions
             if (newNonRemappableRegions.IsEmpty)
                 newNonRemappableRegions = null;
 
-            var solution = pendingSolutionUpdate.Solution;
+            solution = pendingSolutionUpdate.Solution;
 
             // Once the project is rebuilt all its dependencies are going to be up-to-date.
             var dependencyGraph = solution.GetProjectDependencyGraph();
@@ -637,7 +639,7 @@ from region in moduleRegions.Regions
             }
 
             // Unstale all projects that will be up-to-date after rebuild.
-            LastCommittedSolution.CommitChanges(solution, projectsToStale: pendingSolutionUpdate.ProjectsToStale, projectsToUnstale: projectsToRebuildTransitive);
+            LastCommittedSolution.CommitChanges(solution, staleProjects: pendingSolutionUpdate.StaleProjects.RemoveRange(projectsToRebuildTransitive));
 
             foreach (var projectId in projectsToRebuildTransitive)
             {
@@ -654,12 +656,14 @@ from region in moduleRegions.Regions
         {
             foreach (var updatedBaseline in pendingUpdate.ProjectBaselines)
             {
-                _projectBaselines[updatedBaseline.ProjectId] = [.. _projectBaselines[updatedBaseline.ProjectId].Select(existingBaseline => existingBaseline.ModuleId == updatedBaseline.ModuleId ? updatedBaseline : existingBaseline)];
+                _projectBaselines[updatedBaseline.ProjectId] = [.. _projectBaselines[updatedBaseline.ProjectId]
+                    .Select(existingBaseline => existingBaseline.ModuleId == updatedBaseline.ModuleId ? updatedBaseline : existingBaseline)];
             }
 
             // Discard any open baseline readers for projects that need to be rebuilt,
             // so that the build can overwrite the underlying files.
-            DiscardProjectBaselinesNoLock(projectsToRebuildTransitive);
+            Contract.ThrowIfNull(solution);
+            DiscardProjectBaselinesNoLock(solution, projectsToRebuildTransitive.Concat(baselinesToDiscard));
         }
 
         _baselineContentAccessLock.ExitWriteLock();
@@ -676,7 +680,7 @@ public void DiscardSolutionUpdate()
         _ = RetrievePendingUpdate();
     }
 
-    private void DiscardProjectBaselinesNoLock(IEnumerable<ProjectId> projects)
+    private void DiscardProjectBaselinesNoLock(Solution solution, IEnumerable<ProjectId> projects)
     {
         foreach (var projectId in projects)
         {
@@ -693,6 +697,8 @@ private void DiscardProjectBaselinesNoLock(IEnumerable<ProjectId> projects)
 
                     _initialBaselineModuleReaders.Remove(projectBaseline.ModuleId);
                 }
+
+                SessionLog.Write($"Baselines discarded: {solution.GetRequiredProject(projectId).GetLogDisplay()}.");
             }
         }
     }
@@ -705,15 +711,15 @@ public void UpdateBaselines(Solution solution, ImmutableArray<ProjectId> rebuilt
         // Make sure the solution snapshot has all source-generated documents up-to-date.
         solution = solution.WithUpToDateSourceGeneratorDocuments(solution.ProjectIds);
 
-        LastCommittedSolution.CommitChanges(solution, projectsToStale: [], projectsToUnstale: rebuiltProjects);
+        LastCommittedSolution.CommitChanges(solution, staleProjects: null, projectsToUnstale: rebuiltProjects);
 
         // Wait for all operations on baseline to finish before we dispose the readers.
 
         _baselineContentAccessLock.EnterWriteLock();
 
         lock (_projectEmitBaselinesGuard)
         {
-            DiscardProjectBaselinesNoLock(rebuiltProjects);
+            DiscardProjectBaselinesNoLock(solution, rebuiltProjects);
         }
 
         _baselineContentAccessLock.ExitWriteLock();
diff --git a/src/Features/Core/Portable/EditAndContinue/EditSession.cs b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
@@ -900,8 +900,9 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(
             using var _1 = ArrayBuilder<ManagedHotReloadUpdate>.GetInstance(out var deltas);
             using var _2 = ArrayBuilder<(Guid ModuleId, ImmutableArray<(ManagedModuleMethodId Method, NonRemappableRegion Region)>)>.GetInstance(out var nonRemappableRegions);
             using var _3 = ArrayBuilder<ProjectBaseline>.GetInstance(out var newProjectBaselines);
-            using var _4 = ArrayBuilder<ProjectId>.GetInstance(out var projectsToStale);
-            using var _5 = PooledDictionary<ProjectId, ArrayBuilder<Diagnostic>>.GetInstance(out var diagnosticBuilders);
+            using var _4 = ArrayBuilder<(ProjectId id, Guid mvid)>.GetInstance(out var projectsToStale);
+            using var _5 = ArrayBuilder<ProjectId>.GetInstance(out var projectsToUnstale);
+            using var _6 = PooledDictionary<ProjectId, ArrayBuilder<Diagnostic>>.GetInstance(out var diagnosticBuilders);
             using var projectDifferences = new ProjectDifferences();
 
             // After all projects have been analyzed "true" value indicates changed document that is only included in stale projects.
@@ -931,6 +932,7 @@ void UpdateChangedDocumentsStaleness(bool isStale)
             ProjectAnalysisSummary? projectSummaryToReport = null;
 
             var oldSolution = DebuggingSession.LastCommittedSolution;
+            var staleProjects = oldSolution.StaleProjects;
 
             var hasPersistentErrors = false;
             foreach (var newProject in solution.Projects)
@@ -978,17 +980,23 @@ void UpdateChangedDocumentsStaleness(bool isStale)
                         Log.Write($"Found {projectDifferences.ChangedOrAddedDocuments.Count} potentially changed, {projectDifferences.DeletedDocuments.Count} deleted document(s) in project {newProject.GetLogDisplay()}");
                     }
 
-                    var isStaleProject = oldSolution.IsStaleProject(newProject.Id);
+                    var (mvid, mvidReadError) = await DebuggingSession.GetProjectModuleIdAsync(newProject, cancellationToken).ConfigureAwait(false);
 
                     // We don't consider document changes in stale projects until they are rebuilt (removed from stale set).
-                    if (isStaleProject)
+                    if (staleProjects.TryGetValue(newProject.Id, out var staleModuleId))
                     {
-                        Log.Write($"EnC state of {newProject.GetLogDisplay()} queried: project is stale");
-                        UpdateChangedDocumentsStaleness(isStale: true);
-                        continue;
+                        // The module hasn't been rebuilt or we are unable to read the MVID -- keep treating the project as stale.
+                        if (mvid == staleModuleId || mvidReadError != null)
+                        {
+                            Log.Write($"EnC state of {newProject.GetLogDisplay()} queried: project is stale");
+                            UpdateChangedDocumentsStaleness(isStale: true);
+
+                            continue;
+                        }
+
+                        staleProjects = staleProjects.Remove(newProject.Id);
                     }
 
-                    var (mvid, mvidReadError) = await DebuggingSession.GetProjectModuleIdAsync(newProject, cancellationToken).ConfigureAwait(false);
                     if (mvidReadError != null)
                     {
                         // The error hasn't been reported by GetDocumentDiagnosticsAsync since it might have been intermittent.
@@ -1030,7 +1038,7 @@ void UpdateChangedDocumentsStaleness(bool isStale)
                         // 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.GetLogDisplay()}: binaries not up-to-date");
 
-                        projectsToStale.Add(newProject.Id);
+                        staleProjects = staleProjects.Add(newProject.Id, mvid);
                         UpdateChangedDocumentsStaleness(isStale: true);
 
                         continue;
@@ -1318,7 +1326,7 @@ async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cance
 
             if (hasPersistentErrors)
             {
-                return SolutionUpdate.Empty(diagnostics, syntaxError, ModuleUpdateStatus.Blocked);
+                return SolutionUpdate.Empty(diagnostics, syntaxError, staleProjects, ModuleUpdateStatus.Blocked);
             }
 
             // syntax error is a persistent error
@@ -1338,7 +1346,7 @@ async ValueTask LogDocumentChangesAsync(int? generation, CancellationToken cance
 
             return new SolutionUpdate(
                 moduleUpdates,
-                projectsToStale.ToImmutable(),
+                staleProjects,
                 nonRemappableRegions.ToImmutable(),
                 newProjectBaselines.ToImmutable(),
                 diagnostics,
diff --git a/src/Features/Core/Portable/EditAndContinue/PendingSolutionUpdate.cs b/src/Features/Core/Portable/EditAndContinue/PendingSolutionUpdate.cs
@@ -18,14 +18,14 @@ internal abstract class PendingUpdate(
 
 internal sealed class PendingSolutionUpdate(
     Solution solution,
-    ImmutableArray<ProjectId> projectsToStale,
+    ImmutableDictionary<ProjectId, Guid> staleProjects,
     ImmutableArray<ProjectId> projectsToRebuild,
     ImmutableArray<ProjectBaseline> projectBaselines,
     ImmutableArray<ManagedHotReloadUpdate> deltas,
     ImmutableArray<(Guid ModuleId, ImmutableArray<(ManagedModuleMethodId Method, NonRemappableRegion Region)>)> nonRemappableRegions) : PendingUpdate(projectBaselines, deltas)
 {
     public readonly Solution Solution = solution;
-    public readonly ImmutableArray<ProjectId> ProjectsToStale = projectsToStale;
+    public readonly ImmutableDictionary<ProjectId, Guid> StaleProjects = staleProjects;
     public readonly ImmutableArray<ProjectId> ProjectsToRebuild = projectsToRebuild;
     public readonly ImmutableArray<(Guid ModuleId, ImmutableArray<(ManagedModuleMethodId Method, NonRemappableRegion Region)> Regions)> NonRemappableRegions = nonRemappableRegions;
 }
diff --git a/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs b/src/Features/Core/Portable/EditAndContinue/SolutionUpdate.cs
@@ -11,7 +11,7 @@ namespace Microsoft.CodeAnalysis.EditAndContinue;
 
 internal readonly struct SolutionUpdate(
     ModuleUpdates moduleUpdates,
-    ImmutableArray<ProjectId> projectsToStale,
+    ImmutableDictionary<ProjectId, Guid> staleProjects,
     ImmutableArray<(Guid ModuleId, ImmutableArray<(ManagedModuleMethodId Method, NonRemappableRegion Region)>)> nonRemappableRegions,
     ImmutableArray<ProjectBaseline> projectBaselines,
     ImmutableArray<ProjectDiagnostics> diagnostics,
@@ -20,7 +20,7 @@ internal readonly struct SolutionUpdate(
     ImmutableArray<ProjectId> projectsToRebuild)
 {
     public readonly ModuleUpdates ModuleUpdates = moduleUpdates;
-    public readonly ImmutableArray<ProjectId> ProjectsToStale = projectsToStale;
+    public readonly ImmutableDictionary<ProjectId, Guid> StaleProjects = staleProjects;
     public readonly ImmutableArray<(Guid ModuleId, ImmutableArray<(ManagedModuleMethodId Method, NonRemappableRegion Region)>)> NonRemappableRegions = nonRemappableRegions;
     public readonly ImmutableArray<ProjectBaseline> ProjectBaselines = projectBaselines;
 
@@ -33,10 +33,11 @@ internal readonly struct SolutionUpdate(
     public static SolutionUpdate Empty(
         ImmutableArray<ProjectDiagnostics> diagnostics,
         Diagnostic? syntaxError,
+        ImmutableDictionary<ProjectId, Guid> staleProjects,
         ModuleUpdateStatus status)
         => new(
             new(status, Updates: []),
-            projectsToStale: [],
+            staleProjects: staleProjects,
             nonRemappableRegions: [],
             projectBaselines: [],
             diagnostics,
diff --git a/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs b/src/Features/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
@@ -4117,6 +4117,10 @@ public async Task MultiTargetedPartiallyBuiltProjects()
 
         CommitSolutionUpdate(debuggingSession);
 
+        // Stale project baselines should get discarded after committing the update.
+        // Unlocks binaries and allows the user to rebuild the project.
+        Assert.False(debuggingSession.GetTestAccessor().HasProjectEmitBaseline(projectBId));
+
         // update source file in the editor (source text is now matching the PDB of project B):
         var text0 = CreateText(source0);
         solution = solution.WithDocumentText(documentA.Id, text0).WithDocumentText(documentB.Id, text0);
@@ -4144,7 +4148,6 @@ public async Task MultiTargetedPartiallyBuiltProjects()
         // Saving is required so that we can fetch the baseline content for the next delta calculation.
         File.WriteAllText(sourcePath, source2, Encoding.UTF8);
         var mvidB2 = EmitAndLoadLibraryToDebuggee(projectBId, source2, sourceFilePath: sourcePath, assemblyName: "A", targetFramework: TargetFramework.Net90);
-        debuggingSession.UpdateBaselines(solution, rebuiltProjects: [projectBId]);
 
         // no changes have been made:
 

Original file line number	Diff line number	Diff line change
`@@ -553,7 +553,7 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(`
`553`	`553`	`{`
`554`	`554`	`StorePendingUpdate(new PendingSolutionUpdate(`
`555`	`555`	`solution,`
`556`		`- solutionUpdate.ProjectsToStale,`
	`556`	`+ solutionUpdate.StaleProjects,`
`557`	`557`	`solutionUpdate.ProjectsToRebuild,`
`558`	`558`	`solutionUpdate.ProjectBaselines,`
`559`	`559`	`solutionUpdate.ModuleUpdates.Updates,`
`@@ -565,7 +565,7 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(`
`565`	`565`
`566`	`566`	`StorePendingUpdate(new PendingSolutionUpdate(`
`567`	`567`	`solution,`
`568`		`- solutionUpdate.ProjectsToStale,`
	`568`	`+ solutionUpdate.StaleProjects,`
`569`	`569`	`// if partial updates are not allowed we don't treat rebuild as part of solution update:`
`570`	`570`	`projectsToRebuild: [],`
`571`	`571`	`solutionUpdate.ProjectBaselines,`
`@@ -585,7 +585,7 @@ public async ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(`
`585`	`585`
`586`	`586`	`// No significant changes have been made.`
`587`	`587`	`// Commit the solution to apply any insignificant changes that do not generate updates.`
`588`		`- LastCommittedSolution.CommitChanges(solution, projectsToStale: solutionUpdate.ProjectsToStale, projectsToUnstale: []);`
	`588`	`+ LastCommittedSolution.CommitChanges(solution, solutionUpdate.StaleProjects);`
`589`	`589`	`break;`
`590`	`590`	`}`
`591`	`591`
`@@ -611,6 +611,8 @@ public void CommitSolutionUpdate()`
`611`	`611`
`612`	`612`	`ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>? newNonRemappableRegions = null;`
`613`	`613`	`using var _ = PooledHashSet<ProjectId>.GetInstance(out var projectsToRebuildTransitive);`
	`614`	`+ IEnumerable<ProjectId> baselinesToDiscard = [];`
	`615`	`+ Solution? solution = null;`
`614`	`616`
`615`	`617`	`var pendingUpdate = RetrievePendingUpdate();`
`616`	`618`	`if (pendingUpdate is PendingSolutionUpdate pendingSolutionUpdate)`
`@@ -626,7 +628,7 @@ from region in moduleRegions.Regions`
`626`	`628`	`if (newNonRemappableRegions.IsEmpty)`
`627`	`629`	`newNonRemappableRegions = null;`
`628`	`630`
`629`		`- var solution = pendingSolutionUpdate.Solution;`
	`631`	`+ solution = pendingSolutionUpdate.Solution;`
`630`	`632`
`631`	`633`	`// Once the project is rebuilt all its dependencies are going to be up-to-date.`
`632`	`634`	`var dependencyGraph = solution.GetProjectDependencyGraph();`
`@@ -637,7 +639,7 @@ from region in moduleRegions.Regions`
`637`	`639`	`}`
`638`	`640`
`639`	`641`	`// Unstale all projects that will be up-to-date after rebuild.`
`640`		`- LastCommittedSolution.CommitChanges(solution, projectsToStale: pendingSolutionUpdate.ProjectsToStale, projectsToUnstale: projectsToRebuildTransitive);`
	`642`	`+ LastCommittedSolution.CommitChanges(solution, staleProjects: pendingSolutionUpdate.StaleProjects.RemoveRange(projectsToRebuildTransitive));`
`641`	`643`
`642`	`644`	`foreach (var projectId in projectsToRebuildTransitive)`
`643`	`645`	`{`
`@@ -654,12 +656,14 @@ from region in moduleRegions.Regions`
`654`	`656`	`{`
`655`	`657`	`foreach (var updatedBaseline in pendingUpdate.ProjectBaselines)`
`656`	`658`	`{`
`657`		`- _projectBaselines[updatedBaseline.ProjectId] = [.. _projectBaselines[updatedBaseline.ProjectId].Select(existingBaseline => existingBaseline.ModuleId == updatedBaseline.ModuleId ? updatedBaseline : existingBaseline)];`
	`659`	`+ _projectBaselines[updatedBaseline.ProjectId] = [.. _projectBaselines[updatedBaseline.ProjectId]`
	`660`	`+ .Select(existingBaseline => existingBaseline.ModuleId == updatedBaseline.ModuleId ? updatedBaseline : existingBaseline)];`
`658`	`661`	`}`
`659`	`662`
`660`	`663`	`// Discard any open baseline readers for projects that need to be rebuilt,`
`661`	`664`	`// so that the build can overwrite the underlying files.`
`662`		`- DiscardProjectBaselinesNoLock(projectsToRebuildTransitive);`
	`665`	`+ Contract.ThrowIfNull(solution);`
	`666`	`+ DiscardProjectBaselinesNoLock(solution, projectsToRebuildTransitive.Concat(baselinesToDiscard));`
`663`	`667`	`}`
`664`	`668`
`665`	`669`	`_baselineContentAccessLock.ExitWriteLock();`
`@@ -676,7 +680,7 @@ public void DiscardSolutionUpdate()`
`676`	`680`	`_ = RetrievePendingUpdate();`
`677`	`681`	`}`
`678`	`682`
`679`		`- private void DiscardProjectBaselinesNoLock(IEnumerable<ProjectId> projects)`
	`683`	`+ private void DiscardProjectBaselinesNoLock(Solution solution, IEnumerable<ProjectId> projects)`
`680`	`684`	`{`
`681`	`685`	`foreach (var projectId in projects)`
`682`	`686`	`{`
`@@ -693,6 +697,8 @@ private void DiscardProjectBaselinesNoLock(IEnumerable<ProjectId> projects)`
`693`	`697`
`694`	`698`	`_initialBaselineModuleReaders.Remove(projectBaseline.ModuleId);`
`695`	`699`	`}`
	`700`	`+`
	`701`	`+ SessionLog.Write($"Baselines discarded: {solution.GetRequiredProject(projectId).GetLogDisplay()}.");`
`696`	`702`	`}`
`697`	`703`	`}`
`698`	`704`	`}`
`@@ -705,15 +711,15 @@ public void UpdateBaselines(Solution solution, ImmutableArray<ProjectId> rebuilt`
`705`	`711`	`// Make sure the solution snapshot has all source-generated documents up-to-date.`
`706`	`712`	`solution = solution.WithUpToDateSourceGeneratorDocuments(solution.ProjectIds);`
`707`	`713`
`708`		`- LastCommittedSolution.CommitChanges(solution, projectsToStale: [], projectsToUnstale: rebuiltProjects);`
	`714`	`+ LastCommittedSolution.CommitChanges(solution, staleProjects: null, projectsToUnstale: rebuiltProjects);`
`709`	`715`
`710`	`716`	`// Wait for all operations on baseline to finish before we dispose the readers.`
`711`	`717`
`712`	`718`	`_baselineContentAccessLock.EnterWriteLock();`
`713`	`719`
`714`	`720`	`lock (_projectEmitBaselinesGuard)`
`715`	`721`	`{`
`716`		`- DiscardProjectBaselinesNoLock(rebuiltProjects);`
	`722`	`+ DiscardProjectBaselinesNoLock(solution, rebuiltProjects);`
`717`	`723`	`}`
`718`	`724`
`719`	`725`	`_baselineContentAccessLock.ExitWriteLock();`