Update features to fork solution once instead of forking once per changed document.

src/Analyzers/Core/CodeFixes/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs

@@ -177,18 +177,14 @@ private static async Task<Solution> RemoveAwaitFromCallersAsync(
         var editor = new SyntaxEditor(root, currentSolution.Services);
 
         foreach (var location in group)
-        {
-            RemoveAwaitFromCallerIfPresent(editor, syntaxFactsService, root, location, cancellationToken);
-        }
+            RemoveAwaitFromCallerIfPresent(editor, syntaxFactsService, location, cancellationToken);
 
         var newRoot = editor.GetChangedRoot();
         return currentSolution.WithDocumentSyntaxRoot(document.Id, newRoot);
     }
 
     private static void RemoveAwaitFromCallerIfPresent(
-        SyntaxEditor editor, ISyntaxFactsService syntaxFacts,
-        SyntaxNode root, ReferenceLocation referenceLocation,
-        CancellationToken cancellationToken)
+        SyntaxEditor editor, ISyntaxFactsService syntaxFacts, ReferenceLocation referenceLocation, CancellationToken cancellationToken)
     {
         if (referenceLocation.IsImplicit)
         {

src/EditorFeatures/Core/RenameTracking/RenameTrackingTaggerProvider.RenameTrackingCommitter.cs

@@ -196,12 +196,10 @@ private async Task<Solution> CreateSolutionWithOriginalNameAsync(
 
             // Apply the original name to all linked documents to construct a consistent solution
             var solution = document.Project.Solution;
-            foreach (var documentId in document.GetLinkedDocumentIds().Add(document.Id))
-            {
-                solution = solution.WithDocumentText(documentId, newFullText);
-            }
+            var finalSolution = solution.WithDocumentTexts(
+                document.GetLinkedDocumentIds().Add(document.Id).SelectAsArray(id => (id, newFullText)));
 
-            return solution;
+            return finalSolution;
         }
 
         private async Task<ISymbol> TryGetSymbolAsync(Solution solutionWithOriginalName, DocumentId documentId, CancellationToken cancellationToken)

src/Features/CSharp/Portable/CodeRefactorings/EnableNullable/EnableNullableCodeRefactoringProvider.cs

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings.EnableNullable;
 
@@ -67,14 +68,21 @@ private static async Task<Solution> EnableNullableReferenceTypesAsync(
         Project project, CodeActionPurpose purpose, CodeActionOptionsProvider fallbackOptions, IProgress<CodeAnalysisProgress> _, CancellationToken cancellationToken)
     {
         var solution = project.Solution;
-        foreach (var document in project.Documents)
-        {
-            if (await document.IsGeneratedCodeAsync(cancellationToken).ConfigureAwait(false))
-                continue;
+        var updatedDocumentRoots = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync(
+            source: project.Documents,
+            produceItems: static async (document, callback, fallbackOptions, cancellationToken) =>
+            {
+                if (await document.IsGeneratedCodeAsync(cancellationToken).ConfigureAwait(false))
+                    return;
 
-            var updatedDocumentRoot = await EnableNullableReferenceTypesAsync(document, fallbackOptions, cancellationToken).ConfigureAwait(false);
-            solution = solution.WithDocumentSyntaxRoot(document.Id, updatedDocumentRoot);
-        }
+                var updatedDocumentRoot = await EnableNullableReferenceTypesAsync(
+                    document, fallbackOptions, cancellationToken).ConfigureAwait(false);
+                callback((document.Id, updatedDocumentRoot));
+            },
+            args: fallbackOptions,
+            cancellationToken).ConfigureAwait(false);
+
+        solution = solution.WithDocumentSyntaxRoots(updatedDocumentRoots);
 
         if (purpose is CodeActionPurpose.Apply)
         {

src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs

@@ -24,6 +24,7 @@
 using Microsoft.CodeAnalysis.Recommendations;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.Extensions.ContextQuery;
+using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -414,17 +415,23 @@ private static async Task<ImmutableArray<ReferencedSymbol>> FindChangeSignatureR
         }
 
         // Update the documents using the updated syntax trees
-        foreach (var docId in nodesToUpdate.Keys)
-        {
-            var updatedDoc = currentSolution.GetRequiredDocument(docId).WithSyntaxRoot(updatedRoots[docId]);
-            var cleanupOptions = await updatedDoc.GetCodeCleanupOptionsAsync(context.FallbackOptions, cancellationToken).ConfigureAwait(false);
+        var changedDocuments = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync(
+            source: nodesToUpdate.Keys,
+            produceItems: static async (docId, callback, args, cancellationToken) =>
+            {
+                var updatedDoc = args.currentSolution.GetRequiredDocument(docId).WithSyntaxRoot(args.updatedRoots[docId]);
+                var cleanupOptions = await updatedDoc.GetCodeCleanupOptionsAsync(args.context.FallbackOptions, cancellationToken).ConfigureAwait(false);
 
-            var docWithImports = await ImportAdder.AddImportsFromSymbolAnnotationAsync(updatedDoc, cleanupOptions.AddImportOptions, cancellationToken).ConfigureAwait(false);
-            var reducedDoc = await Simplifier.ReduceAsync(docWithImports, Simplifier.Annotation, cleanupOptions.SimplifierOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
-            var formattedDoc = await Formatter.FormatAsync(reducedDoc, SyntaxAnnotation.ElasticAnnotation, cleanupOptions.FormattingOptions, cancellationToken).ConfigureAwait(false);
+                var docWithImports = await ImportAdder.AddImportsFromSymbolAnnotationAsync(updatedDoc, cleanupOptions.AddImportOptions, cancellationToken).ConfigureAwait(false);
+                var reducedDoc = await Simplifier.ReduceAsync(docWithImports, Simplifier.Annotation, cleanupOptions.SimplifierOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
+                var formattedDoc = await Formatter.FormatAsync(reducedDoc, SyntaxAnnotation.ElasticAnnotation, cleanupOptions.FormattingOptions, cancellationToken).ConfigureAwait(false);
 
-            currentSolution = currentSolution.WithDocumentSyntaxRoot(docId, (await formattedDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false))!);
-        }
+                callback((formattedDoc.Id, await formattedDoc.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false)));
+            },
+            args: (currentSolution, updatedRoots, context),
+            cancellationToken).ConfigureAwait(false);
+
+        currentSolution = currentSolution.WithDocumentSyntaxRoots(changedDocuments);
 
         telemetryTimer.Stop();
         ChangeSignatureLogger.LogCommitInformation(telemetryNumberOfDeclarationsToUpdate, telemetryNumberOfReferencesToUpdate, telemetryTimer.Elapsed);

src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionBatchFixAllProvider.cs

@@ -240,11 +240,8 @@ private static async Task<Solution> TryMergeFixesAsync(
 
         // Finally, apply the changes to each document to the solution, producing the
         // new solution.
-        var currentSolution = oldSolution;
-        foreach (var (documentId, finalText) in documentIdToFinalText)
-            currentSolution = currentSolution.WithDocumentText(documentId, finalText);
-
-        return currentSolution;
+        var finalSolution = oldSolution.WithDocumentTexts(documentIdToFinalText);
+        return finalSolution;
     }
 
     private static async Task<IReadOnlyDictionary<DocumentId, ConcurrentBag<(CodeAction, Document)>>> GetDocumentIdToChangedDocumentsAsync(
@@ -269,7 +266,7 @@ private static async Task<Solution> TryMergeFixesAsync(
         return documentIdToChangedDocuments;
     }
 
-    private static async Task<IReadOnlyDictionary<DocumentId, SourceText>> GetDocumentIdToFinalTextAsync(
+    private static async Task<ImmutableArray<(DocumentId documentId, SourceText newText)>> GetDocumentIdToFinalTextAsync(
         Solution oldSolution,
         IReadOnlyDictionary<DocumentId, ConcurrentBag<(CodeAction, Document)>> documentIdToChangedDocuments,
         ImmutableArray<(Diagnostic diagnostic, CodeAction action)> diagnosticsAndCodeActions,
@@ -291,7 +288,7 @@ private static async Task<IReadOnlyDictionary<DocumentId, SourceText>> GetDocume
         }
 
         await Task.WhenAll(getFinalDocumentTasks).ConfigureAwait(false);
-        return documentIdToFinalText;
+        return documentIdToFinalText.SelectAsArray(kvp => (kvp.Key, kvp.Value));
     }
 
     private static async Task GetFinalDocumentTextAsync(

src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs

@@ -24,6 +24,7 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.RemoveUnnecessaryImports;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -487,32 +488,25 @@ private static SyntaxNode CreateImport(SyntaxGenerator syntaxGenerator, string n
 
         var refLocationGroups = refLocationsInSolution.GroupBy(loc => loc.Document.Id);
 
-        var fixedDocuments = await Task.WhenAll(
-            refLocationGroups.Select(refInOneDocument =>
-                FixReferencingDocumentAsync(
-                    solutionWithChangedNamespace.GetRequiredDocument(refInOneDocument.Key),
+        var fixedDocuments = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync(
+            source: refLocationGroups,
+            produceItems: static async (refInOneDocument, callback, args, cancellationToken) =>
+            {
+                var result = await FixReferencingDocumentAsync(
+                    args.solutionWithChangedNamespace.GetRequiredDocument(refInOneDocument.Key),
                     refInOneDocument,
-                    newNamespace,
-                    fallbackOptions,
-                    cancellationToken))).ConfigureAwait(false);
-
-        var solutionWithFixedReferences = await MergeDocumentChangesAsync(solutionWithChangedNamespace, fixedDocuments, cancellationToken).ConfigureAwait(false);
+                    args.newNamespace,
+                    args.fallbackOptions,
+                    cancellationToken).ConfigureAwait(false);
+                callback((result.Id, await result.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false)));
+            },
+            args: (solutionWithChangedNamespace, newNamespace, fallbackOptions),
+            cancellationToken).ConfigureAwait(false);
 
+        var solutionWithFixedReferences = solutionWithChangedNamespace.WithDocumentSyntaxRoots(fixedDocuments);
         return (solutionWithFixedReferences, refLocationGroups.SelectAsArray(g => g.Key));
     }
 
-    private static async Task<Solution> MergeDocumentChangesAsync(Solution originalSolution, Document[] changedDocuments, CancellationToken cancellationToken)
-    {
-        foreach (var document in changedDocuments)
-        {
-            originalSolution = originalSolution.WithDocumentSyntaxRoot(
-                document.Id,
-                await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false));
-        }
-
-        return originalSolution;
-    }
-
     private readonly struct LocationForAffectedSymbol(ReferenceLocation location, bool isReferenceToExtensionMethod)
     {
         public ReferenceLocation ReferenceLocation { get; } = location;
@@ -773,40 +767,39 @@ private static async Task<Solution> RemoveUnnecessaryImportsAsync(
         CodeCleanupOptionsProvider fallbackOptions,
         CancellationToken cancellationToken)
     {
-        using var _ = PooledHashSet<DocumentId>.GetInstance(out var linkedDocumentsToSkip);
-        var documentsToProcessBuilder = ArrayBuilder<Document>.GetInstance();
+        using var _1 = PooledHashSet<DocumentId>.GetInstance(out var linkedDocumentsToSkip);
+        using var _2 = ArrayBuilder<Document>.GetInstance(out var documentsToProcess);
 
         foreach (var id in ids)
         {
             if (linkedDocumentsToSkip.Contains(id))
-            {
                 continue;
-            }
 
             var document = solution.GetRequiredDocument(id);
             linkedDocumentsToSkip.AddRange(document.GetLinkedDocumentIds());
-            documentsToProcessBuilder.Add(document);
-
-            document = await RemoveUnnecessaryImportsWorkerAsync(
-                document,
-                CreateImports(document, names, withFormatterAnnotation: false),
-                cancellationToken).ConfigureAwait(false);
-            solution = document.Project.Solution;
+            documentsToProcess.Add(document);
         }
 
-        var documentsToProcess = documentsToProcessBuilder.ToImmutableAndFree();
-
-        var changeDocuments = await Task.WhenAll(documentsToProcess.Select(
-                doc => RemoveUnnecessaryImportsWorkerAsync(
+        var changedDocuments = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync(
+            source: documentsToProcess,
+            produceItems: static async (doc, callback, args, cancellationToken) =>
+            {
+                var result = await RemoveUnnecessaryImportsWorkerAsync(
                     doc,
-                    CreateImports(doc, names, withFormatterAnnotation: false),
-                    cancellationToken))).ConfigureAwait(false);
+                    CreateImports(doc, args.names, withFormatterAnnotation: false),
+                    args.fallbackOptions,
+                    cancellationToken).ConfigureAwait(false);
+                callback((result.Id, await result.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false)));
+            },
+            args: (names, fallbackOptions),
+            cancellationToken).ConfigureAwait(false);
 
-        return await MergeDocumentChangesAsync(solution, changeDocuments, cancellationToken).ConfigureAwait(false);
+        return solution.WithDocumentSyntaxRoots(changedDocuments);
 
-        async Task<Document> RemoveUnnecessaryImportsWorkerAsync(
+        async static Task<Document> RemoveUnnecessaryImportsWorkerAsync(
             Document doc,
             IEnumerable<SyntaxNode> importsToRemove,
+            CodeCleanupOptionsProvider fallbackOptions,
             CancellationToken token)
         {
             var removeImportService = doc.GetRequiredLanguageService<IRemoveUnnecessaryImportsService>();

src/Features/Core/Portable/IntroduceParameter/AbstractIntroduceParameterCodeRefactoringProvider.cs

@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Shared.Collections;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.IntroduceParameter;
@@ -241,17 +242,26 @@ private async Task<Solution> IntroduceParameterAsync(Document originalDocument,
         var rewriter = new IntroduceParameterDocumentRewriter(this, originalDocument,
             expression, methodSymbol, containingMethod, selectedCodeAction, fallbackOptions, allOccurrences);
 
-        foreach (var (project, projectCallSites) in methodCallSites.GroupBy(kvp => kvp.Key.Project))
-        {
-            var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
-            foreach (var (document, invocations) in projectCallSites)
+        var changedRoots = await ProducerConsumer<(DocumentId documentId, SyntaxNode newRoot)>.RunParallelAsync(
+            source: methodCallSites.GroupBy(kvp => kvp.Key.Project),
+            produceItems: static async (tuple, callback, rewriter, cancellationToken) =>
             {
-                var newRoot = await rewriter.RewriteDocumentAsync(compilation, document, invocations, cancellationToken).ConfigureAwait(false);
-                modifiedSolution = modifiedSolution.WithDocumentSyntaxRoot(document.Id, newRoot);
-            }
-        }
-
-        return modifiedSolution;
+                var (project, projectCallSites) = tuple;
+                var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
+                await RoslynParallel.ForEachAsync(
+                    projectCallSites,
+                    cancellationToken,
+                    async (tuple, cancellationToken) =>
+                    {
+                        var (document, invocations) = tuple;
+                        var newRoot = await rewriter.RewriteDocumentAsync(compilation, document, invocations, cancellationToken).ConfigureAwait(false);
+                        callback((document.Id, newRoot));
+                    }).ConfigureAwait(false);
+            },
+            args: rewriter,
+            cancellationToken).ConfigureAwait(false);
+
+        return modifiedSolution.WithDocumentSyntaxRoots(changedRoots);
     }
 
     /// <summary>

src/Features/Core/Portable/MoveToNamespace/AbstractMoveToNamespaceService.cs

@@ -288,12 +288,9 @@ private static async Task<Solution> PropagateChangeToLinkedDocumentsAsync(Docume
         var formattedText = await formattedDocument.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
         var solution = formattedDocument.Project.Solution;
 
-        foreach (var documentId in formattedDocument.GetLinkedDocumentIds())
-        {
-            solution = solution.WithDocumentText(documentId, formattedText);
-        }
-
-        return solution;
+        var finalSolution = solution.WithDocumentTexts(
+            formattedDocument.GetLinkedDocumentIds().SelectAsArray(id => (id, formattedText)));
+        return finalSolution;
     }
 
     private static string GetNewSymbolName(ISymbol symbol, string targetNamespace)

src/VisualStudio/Core/Def/CodeCleanup/AbstractCodeCleanUpFixer.cs

@@ -249,7 +249,7 @@ await RoslynParallel.ForEachAsync(
             args: (globalOptions, solution, enabledFixIds, progressTracker),
             cancellationToken).ConfigureAwait(false);
 
-        return solution.WithDocumentSyntaxRoots(changedRoots.SelectAsArray(t => (t.documentId, t.newRoot, PreservationMode.PreserveValue)));
+        return solution.WithDocumentSyntaxRoots(changedRoots);
     }
 
     private static async Task<Document> FixDocumentAsync(

src/Workspaces/Core/Portable/CodeActions/CodeAction_Cleanup.cs

@@ -168,7 +168,7 @@ async Task<Solution> RunParallelCleanupPassAsync(
                 cancellationToken).ConfigureAwait(false);
 
             // Grab all the cleaned roots and produce the new solution snapshot from that.
-            return solution.WithDocumentSyntaxRoots(changedRoots.SelectAsArray(t => (t.documentId, t.newRoot, PreservationMode.PreserveValue)));
+            return solution.WithDocumentSyntaxRoots(changedRoots);
         }
     }
 }

src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/BatchFixAllProvider.cs

@@ -253,15 +253,10 @@ private static Action<CodeAction, ImmutableArray<Diagnostic>> GetRegisterCodeFix
 
     private static async Task<Solution> ApplyChangesAsync(
         Solution currentSolution,
-        ImmutableArray<(DocumentId, TextChangeMerger)> docIdsAndMerger,
+        ImmutableArray<(DocumentId documentId, TextChangeMerger merger)> docIdsAndMerger,
         CancellationToken cancellationToken)
     {
-        foreach (var (documentId, textMerger) in docIdsAndMerger)
-        {
-            var newText = await textMerger.GetFinalMergedTextAsync(cancellationToken).ConfigureAwait(false);
-            currentSolution = currentSolution.WithDocumentText(documentId, newText);
-        }
-
-        return currentSolution;
+        var docIdsAndTexts = await docIdsAndMerger.SelectAsArrayAsync(async t => (t.documentId, await t.merger.GetFinalMergedTextAsync(cancellationToken).ConfigureAwait(false))).ConfigureAwait(false);
+        return currentSolution.WithDocumentTexts(docIdsAndTexts);
     }
 }