Run final fix-all code-cleanup phase out of process.

src/Workspaces/Core/Portable/CaseCorrection/CaseCorrector.cs

@@ -8,7 +8,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 

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

@@ -45,7 +45,7 @@ public abstract partial class CodeAction
         static (document, options, cancellationToken) => CleanupSyntaxAsync(document, options, cancellationToken),
     ];
 
-    private static async Task<Document> CleanupSyntaxAsync(Document document, CodeCleanupOptions options, CancellationToken cancellationToken)
+    internal static async Task<Document> CleanupSyntaxAsync(Document document, CodeCleanupOptions options, CancellationToken cancellationToken)
     {
         Contract.ThrowIfFalse(document.SupportsSyntaxTree);
 

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

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixesAndRefactorings;

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

@@ -73,6 +73,7 @@ public partial class FixAllContext : IFixAllContext
     public IProgress<CodeAnalysisProgress> Progress { get; }
 
     #region IFixAllContext implementation
+
     IFixAllState IFixAllContext.State => this.State;
 
     IFixAllProvider IFixAllContext.FixAllProvider => this.FixAllProvider;
@@ -88,6 +89,7 @@ IFixAllContext IFixAllContext.With(
         Optional<string?> codeActionEquivalenceKey,
         Optional<CancellationToken> cancellationToken)
         => this.With(documentAndProject, scope, codeActionEquivalenceKey, cancellationToken);
+
     #endregion
 
     /// <summary>

src/Workspaces/Core/Portable/CodeFixesAndRefactorings/IFixAllContext.cs

@@ -4,7 +4,9 @@
 
 using System;
 using System.Threading;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.CodeFixesAndRefactorings;
 

src/Workspaces/Core/Portable/CodeFixesAndRefactorings/IRemoteFixAllProviderService.cs

@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeCleanup;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CodeFixesAndRefactorings;
+
+internal interface IRemoteFixAllProviderService
+{
+    ValueTask<string> PerformSemanticCleanupAsync(
+        Checksum solutionChecksum, DocumentId documentId, CodeCleanupOptions codeCleanupOptions,
+        Dictionary<TextSpan, List<string>> nodeAnnotations, Dictionary<TextSpan, List<string>> tokenAnnotations,
+        CancellationToken cancellationToken);
+}

src/Workspaces/Core/Portable/Formatting/Formatter.cs

@@ -28,7 +28,7 @@ public static class Formatter
     /// <summary>
     /// The annotation used to mark portions of a syntax tree to be formatted.
     /// </summary>
-    public static SyntaxAnnotation Annotation { get; } = new SyntaxAnnotation();
+    public static SyntaxAnnotation Annotation { get; } = new();
 
     /// <summary>
     /// Gets the formatting rules that would be applied if left unspecified.

src/Workspaces/Core/Portable/Remote/IRemoteKeepAliveService.cs

@@ -116,4 +116,11 @@ public static async Task<RemoteKeepAliveSession> CreateAsync(
         var client = await RemoteHostClient.TryGetClientAsync(compilationState.Services, cancellationToken).ConfigureAwait(false);
         return new RemoteKeepAliveSession(compilationState, client);
     }
+
+    /// <inheritdoc cref="CreateAsync(Solution, CancellationToken)"/>
+    public static RemoteKeepAliveSession Create(
+        SolutionCompilationState compilationState, RemoteHostClient? client)
+    {
+        return new RemoteKeepAliveSession(compilationState, client);
+    }
 }

src/Workspaces/Core/Portable/Simplification/Simplifier.cs

@@ -42,19 +42,19 @@ public static partial class Simplifier
     /// The annotation the reducer uses to identify sub trees to be reduced.
     /// The Expand operations add this annotation to nodes so that the Reduce operations later find them.
     /// </summary>
-    public static SyntaxAnnotation Annotation { get; } = new SyntaxAnnotation();
+    public static SyntaxAnnotation Annotation { get; } = new();
 
     /// <summary>
     /// This is the annotation used by the simplifier and expander to identify Predefined type and preserving
     /// them from over simplification
     /// </summary>
-    public static SyntaxAnnotation SpecialTypeAnnotation { get; } = new SyntaxAnnotation();
+    public static SyntaxAnnotation SpecialTypeAnnotation { get; } = new();
 
     /// <summary>
     /// The annotation <see cref="CodeAction.CleanupDocumentAsync"/> used to identify sub trees to look for symbol annotations on.
     /// It will then add import directives for these symbol annotations.
     /// </summary>
-    public static SyntaxAnnotation AddImportsAnnotation { get; } = new SyntaxAnnotation();
+    public static SyntaxAnnotation AddImportsAnnotation { get; } = new();
 
     /// <summary>
     /// Expand qualifying parts of the specified subtree, annotating the parts using the <see cref="Annotation" /> annotation.

src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs

@@ -194,6 +194,7 @@ public InProcRemoteServices(SolutionServices workspaceServices, TraceListener? t
                 RegisterRemoteBrokeredService(new RemoteEncapsulateFieldService.Factory());
                 RegisterRemoteBrokeredService(new RemoteExtensionMethodImportCompletionService.Factory());
                 RegisterRemoteBrokeredService(new RemoteFindUsagesService.Factory());
+                RegisterRemoteBrokeredService(new RemoteFixAllProviderService.Factory());
                 RegisterRemoteBrokeredService(new RemoteFullyQualifyService.Factory());
                 RegisterRemoteBrokeredService(new RemoteGlobalNotificationDeliveryService.Factory());
                 RegisterRemoteBrokeredService(new RemoteInheritanceMarginService.Factory());

src/Workspaces/Remote/Core/RemoteWorkspacesResources.resx

@@ -231,4 +231,7 @@
   <data name="FeatureName_SemanticSearch" xml:space="preserve">
     <value>Semantic search</value>
   </data>
+  <data name="FeatureName_FixAllProvider" xml:space="preserve">
+    <value>Fix all provider</value>
+  </data>
 </root>

src/Workspaces/Remote/Core/ServiceDescriptors.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.AddImport;
 using Microsoft.CodeAnalysis.Classification;
 using Microsoft.CodeAnalysis.CodeFixes.FullyQualify;
+using Microsoft.CodeAnalysis.CodeFixesAndRefactorings;
 using Microsoft.CodeAnalysis.CodeLens;
 using Microsoft.CodeAnalysis.Completion.Providers;
 using Microsoft.CodeAnalysis.ConvertTupleToStruct;
@@ -66,6 +67,7 @@ internal sealed class ServiceDescriptors
             (typeof(IRemoteEncapsulateFieldService), typeof(IRemoteEncapsulateFieldService.ICallback)),
             (typeof(IRemoteExtensionMethodImportCompletionService), null),
             (typeof(IRemoteFindUsagesService), typeof(IRemoteFindUsagesService.ICallback)),
+            (typeof(IRemoteFixAllProviderService), null),
             (typeof(IRemoteFullyQualifyService), null),
             (typeof(IRemoteGlobalNotificationDeliveryService), null),
             (typeof(IRemoteInheritanceMarginService), null),

src/Workspaces/Remote/ServiceHub/Services/CodeFixesAndRefactorings/RemoteFixAllProviderService.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeCleanup;
+using Microsoft.CodeAnalysis.CodeFixesAndRefactorings;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.Remote;
+
+internal sealed partial class RemoteFixAllProviderService(in BrokeredServiceBase.ServiceConstructionArguments arguments)
+    : BrokeredServiceBase(arguments), IRemoteFixAllProviderService
+{
+    internal sealed class Factory : FactoryBase<IRemoteFixAllProviderService>
+    {
+        protected override IRemoteFixAllProviderService CreateService(in ServiceConstructionArguments arguments)
+            => new RemoteFixAllProviderService(arguments);
+    }
+
+    public ValueTask<string> PerformSemanticCleanupAsync(
+        Checksum solutionChecksum, DocumentId documentId, CodeCleanupOptions codeCleanupOptions,
+        Dictionary<TextSpan, List<string>> nodeAnnotations, Dictionary<TextSpan, List<string>> tokenAnnotations,
+        CancellationToken cancellationToken)
+    {
+        return RunServiceAsync(solutionChecksum, async solution =>
+        {
+            var document = solution.GetRequiredDocument(documentId);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+            // Add the annotations into our local document.
+            var updatedRoot = DocumentBasedFixAllProviderHelpers.WithAnnotations(root, nodeAnnotations, tokenAnnotations);
+            var updatedDocument = document.WithSyntaxRoot(updatedRoot);
+
+            var sourceText = await DocumentBasedFixAllProviderHelpers.PerformSemanticCleanupInCurrentProcessAsync(
+                updatedDocument, codeCleanupOptions, cancellationToken).ConfigureAwait(false);
+            return sourceText.ToString();
+        }, cancellationToken);
+    }
+}

src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs

@@ -8,13 +8,10 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Internal.Log;
-using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Remote.Diagnostics;
 using Microsoft.CodeAnalysis.Shared.Collections;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Telemetry;
-using Roslyn.Utilities;
 using RoslynLogger = Microsoft.CodeAnalysis.Internal.Log.Logger;
 
 namespace Microsoft.CodeAnalysis.Remote

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs

@@ -234,6 +234,14 @@ public static bool CanRemoveParentheses(
         if (expression.IsKind(SyntaxKind.ThisExpression))
             return true;
 
+        // (typeof(int)) -> typeof(int)
+        // (default(int)) -> default(int)
+        // (checked(1)) -> checked(1)
+        // (unchecked(1)) -> unchecked(1)
+        // (sizeof(int)) -> sizeof(int)
+        if (expression is TypeOfExpressionSyntax or DefaultExpressionSyntax or CheckedExpressionSyntax or SizeOfExpressionSyntax)
+            return true;
+
         // x ?? (throw ...) -> x ?? throw ...
         if (expression.IsKind(SyntaxKind.ThrowExpression) &&
             nodeParent is BinaryExpressionSyntax(SyntaxKind.CoalesceExpression) binary &&