Revert "Update methods to be async."

src/Analyzers/CSharp/CodeFixes/AddBraces/CSharpAddBracesCodeFixProvider.cs

@@ -22,12 +22,13 @@ internal sealed class CSharpAddBracesCodeFixProvider() : SyntaxEditorBasedCodeFi
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.AddBracesDiagnosticId];
 
-    public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Add_braces, nameof(CSharpAnalyzersResources.Add_braces));
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document, ImmutableArray<Diagnostic> diagnostics,
         SyntaxEditor editor, CancellationToken cancellationToken)
     {
@@ -46,5 +47,7 @@ protected override async Task FixAllAsync(
                 return embeddedStatement is null ? currentStatement : currentStatement.ReplaceNode(embeddedStatement, SyntaxFactory.Block(embeddedStatement));
             });
         }
+
+        return Task.CompletedTask;
     }
 }

src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs

@@ -28,7 +28,7 @@ internal sealed class ConvertNamespaceCodeFixProvider() : SyntaxEditorBasedCodeF
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.UseBlockScopedNamespaceDiagnosticId, IDEDiagnosticIds.UseFileScopedNamespaceDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var diagnostic = context.Diagnostics.First();
 
@@ -41,6 +41,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             });
 
         RegisterCodeFix(context, title, equivalenceKey);
+        return Task.CompletedTask;
     }
 
     protected override async Task FixAllAsync(

src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs

@@ -32,9 +32,10 @@ internal sealed partial class ConvertSwitchStatementToExpressionCodeFixProvider(
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.ConvertSwitchStatementToExpressionDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Convert_switch_statement_to_expression, nameof(CSharpAnalyzersResources.Convert_switch_statement_to_expression));
+        return Task.CompletedTask;
     }
 
     protected override async Task FixAllAsync(

src/Analyzers/CSharp/CodeFixes/FixIncorrectConstraint/CSharpFixIncorrectConstraintCodeFixProvider.cs

@@ -60,7 +60,7 @@ private static bool TryGetConstraint(
         return enumOrDelegateKeyword.Kind() is SyntaxKind.EnumKeyword or SyntaxKind.DelegateKeyword;
     }
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var cancellationToken = context.CancellationToken;
 
@@ -69,6 +69,8 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
             RegisterCodeFix(context, CSharpCodeFixesResources.Fix_constraint, nameof(CSharpFixIncorrectConstraintCodeFixProvider));
         }
+
+        return Task.CompletedTask;
     }
 
     protected override async Task FixAllAsync(

src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs

@@ -36,9 +36,10 @@ internal sealed partial class CSharpInlineDeclarationCodeFixProvider() : SyntaxE
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.InlineDeclarationDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Inline_variable_declaration, nameof(CSharpAnalyzersResources.Inline_variable_declaration));
+        return Task.CompletedTask;
     }
 
     protected override async Task FixAllAsync(

src/Analyzers/CSharp/CodeFixes/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessCodeFixProvider.cs

@@ -35,12 +35,13 @@ internal sealed partial class InvokeDelegateWithConditionalAccessCodeFixProvider
     protected override bool IncludeDiagnosticDuringFixAll(Diagnostic diagnostic)
         => !diagnostic.Properties.ContainsKey(WellKnownDiagnosticTags.Unnecessary);
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Simplify_delegate_invocation, nameof(CSharpAnalyzersResources.Simplify_delegate_invocation));
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document, ImmutableArray<Diagnostic> diagnostics,
         SyntaxEditor editor, CancellationToken cancellationToken)
     {
@@ -49,6 +50,8 @@ protected override async Task FixAllAsync(
             cancellationToken.ThrowIfCancellationRequested();
             AddEdits(editor, diagnostic, cancellationToken);
         }
+
+        return Task.CompletedTask;
     }
 
     private static void AddEdits(

src/Analyzers/CSharp/CodeFixes/Iterator/CSharpAddYieldCodeFixProvider.cs

@@ -81,7 +81,7 @@ public override ImmutableArray<string> FixableDiagnosticIds
 
         return CodeAction.Create(
             CSharpCodeFixesResources.Replace_return_with_yield_return,
-            async _ => document.WithSyntaxRoot(root),
+            _ => Task.FromResult(document.WithSyntaxRoot(root)),
             nameof(CSharpCodeFixesResources.Replace_return_with_yield_return));
     }
 

src/Analyzers/CSharp/CodeFixes/Iterator/CSharpChangeToIEnumerableCodeFixProvider.cs

@@ -104,7 +104,7 @@ internal sealed class CSharpChangeToIEnumerableCodeFixProvider() : AbstractItera
             type.ToMinimalDisplayString(model, node.SpanStart),
             ienumerableGenericSymbol.ToMinimalDisplayString(model, node.SpanStart));
 
-        return CodeAction.Create(title, async _ => newDocument, title);
+        return CodeAction.Create(title, _ => Task.FromResult(newDocument), title);
     }
 
     private static bool TryGetIEnumerableSymbols(

src/Analyzers/CSharp/CodeFixes/MakeAnonymousFunctionStatic/CSharpMakeAnonymousFunctionStaticCodeFixProvider.cs

@@ -24,16 +24,18 @@ internal sealed class CSharpMakeAnonymousFunctionStaticCodeFixProvider() : Synta
     public override ImmutableArray<string> FixableDiagnosticIds { get; } =
         [IDEDiagnosticIds.MakeAnonymousFunctionStaticDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(
             context,
             CSharpAnalyzersResources.Make_anonymous_function_static,
             nameof(CSharpAnalyzersResources.Make_anonymous_function_static),
             context.Diagnostics[0].Severity > DiagnosticSeverity.Hidden ? CodeActionPriority.Default : CodeActionPriority.Low);
+
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
+    protected override Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
     {
         var generator = editor.Generator;
 
@@ -42,5 +44,7 @@ protected override async Task FixAllAsync(Document document, ImmutableArray<Diag
             var anonymousFunction = diagnostic.Location.FindNode(getInnermostNodeForTie: true, cancellationToken);
             editor.ReplaceNode(anonymousFunction, static (node, generator) => generator.WithModifiers(node, generator.GetModifiers(node).WithIsStatic(true)));
         }
+
+        return Task.CompletedTask;
     }
 }

src/Analyzers/CSharp/CodeFixes/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeFixProvider.cs

@@ -22,16 +22,19 @@ internal sealed class MakeLocalFunctionStaticCodeFixProvider() : SyntaxEditorBas
     public override ImmutableArray<string> FixableDiagnosticIds { get; } =
         [IDEDiagnosticIds.MakeLocalFunctionStaticDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Make_local_function_static, nameof(CSharpAnalyzersResources.Make_local_function_static));
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
     {
         var localFunctions = diagnostics.SelectAsArray(d => d.AdditionalLocations[0].FindNode(getInnermostNodeForTie: true, cancellationToken));
         foreach (var localFunction in localFunctions)
             editor.ReplaceNode(localFunction, MakeLocalFunctionStaticCodeFixHelper.AddStaticModifier);
+
+        return Task.CompletedTask;
     }
 }

src/Analyzers/CSharp/CodeFixes/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs

@@ -35,14 +35,16 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
         return WrapFixAsync(
             context.Document,
             [diagnostic],
-            async (document, localFunction, captures) =>
+            (document, localFunction, captures) =>
             {
                 context.RegisterCodeFix(
                     CodeAction.Create(
                         CSharpCodeFixesResources.Pass_in_captured_variables_as_arguments,
                         cancellationToken => MakeLocalFunctionStaticCodeFixHelper.MakeLocalFunctionStaticAsync(document, localFunction, captures, cancellationToken),
                         nameof(CSharpCodeFixesResources.Pass_in_captured_variables_as_arguments)),
                     diagnostic);
+
+                return Task.CompletedTask;
             },
             context.CancellationToken);
     }

src/Analyzers/CSharp/CodeFixes/MakeMemberRequired/CSharpMakeMemberRequiredCodeFixProvider.cs

@@ -103,7 +103,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         };
     }
 
-    protected override async Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
+    protected override Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
     {
         var root = editor.OriginalRoot;
         var generator = editor.Generator;
@@ -138,5 +138,7 @@ protected override async Task FixAllAsync(Document document, ImmutableArray<Diag
             var newDeclarationModifiers = declarationModifiers.WithIsRequired(true);
             editor.ReplaceNode(memberDeclarator, generator.WithModifiers(memberDeclarator, newDeclarationModifiers));
         }
+
+        return Task.CompletedTask;
     }
 }

src/Analyzers/CSharp/CodeFixes/MakeStatementAsynchronous/CSharpMakeStatementAsynchronousCodeFixProvider.cs

@@ -44,7 +44,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         RegisterCodeFix(context, CSharpCodeFixesResources.Add_await, nameof(CSharpCodeFixesResources.Add_await));
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document, ImmutableArray<Diagnostic> diagnostics,
         SyntaxEditor editor, CancellationToken cancellationToken)
     {
@@ -57,6 +57,8 @@ protected override async Task FixAllAsync(
                 MakeStatementAsynchronous(editor, statementToFix);
             }
         }
+
+        return Task.CompletedTask;
     }
 
     private static void MakeStatementAsynchronous(SyntaxEditor editor, SyntaxNode statementToFix)

src/Analyzers/CSharp/CodeFixes/MakeStructFieldsWritable/CSharpMakeStructFieldsWritableCodeFixProvider.cs

@@ -25,12 +25,13 @@ internal sealed class CSharpMakeStructFieldsWritableCodeFixProvider() : SyntaxEd
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.MakeStructFieldsWritable];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Make_readonly_fields_writable, nameof(CSharpAnalyzersResources.Make_readonly_fields_writable));
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document,
         ImmutableArray<Diagnostic> diagnostics,
         SyntaxEditor editor,
@@ -60,5 +61,7 @@ protected override async Task FixAllAsync(
                 }
             }
         }
+
+        return Task.CompletedTask;
     }
 }

src/Analyzers/CSharp/CodeFixes/MakeStructMemberReadOnly/CSharpMakeStructMemberReadOnlyCodeFixProvider.cs

@@ -26,12 +26,13 @@ internal sealed class CSharpMakeStructMemberReadOnlyCodeFixProvider() : SyntaxEd
     public override ImmutableArray<string> FixableDiagnosticIds { get; } =
         [IDEDiagnosticIds.MakeStructMemberReadOnlyDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Make_member_readonly, nameof(CSharpAnalyzersResources.Make_member_readonly));
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document,
         ImmutableArray<Diagnostic> diagnostics,
         SyntaxEditor editor,
@@ -94,7 +95,7 @@ protected override async Task FixAllAsync(
             }
         }
 
-        return;
+        return Task.CompletedTask;
 
         TNode UpdateReadOnlyModifier<TNode>(TNode node, bool add) where TNode : SyntaxNode
         {

src/Analyzers/CSharp/CodeFixes/MakeStructReadOnly/CSharpMakeStructReadOnlyCodeFixProvider.cs

@@ -24,12 +24,13 @@ internal sealed class CSharpMakeStructReadOnlyCodeFixProvider() : SyntaxEditorBa
     public override ImmutableArray<string> FixableDiagnosticIds { get; } =
         [IDEDiagnosticIds.MakeStructReadOnlyDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         RegisterCodeFix(context, CSharpAnalyzersResources.Make_struct_readonly, nameof(CSharpAnalyzersResources.Make_struct_readonly));
+        return Task.CompletedTask;
     }
 
-    protected override async Task FixAllAsync(
+    protected override Task FixAllAsync(
         Document document,
         ImmutableArray<Diagnostic> diagnostics,
         SyntaxEditor editor,
@@ -44,5 +45,7 @@ protected override async Task FixAllAsync(
                 typeDeclaration,
                 (current, generator) => generator.WithModifiers(current, generator.GetModifiers(current).WithIsReadOnly(true)));
         }
+
+        return Task.CompletedTask;
     }
 }

src/Analyzers/CSharp/CodeFixes/NewLines/ArrowExpressionClausePlacement/ArrowExpressionClausePlacementCodeFixProvider.cs

@@ -27,7 +27,7 @@ internal sealed class ArrowExpressionClausePlacementCodeFixProvider() : CodeFixP
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.ArrowExpressionClausePlacementDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var document = context.Document;
         var diagnostic = context.Diagnostics.First();
@@ -37,6 +37,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 c => UpdateDocumentAsync(document, [diagnostic], c),
                 nameof(CSharpCodeFixesResources.Place_token_on_following_line)),
             context.Diagnostics);
+        return Task.CompletedTask;
     }
 
     private static async Task<Document> UpdateDocumentAsync(

src/Analyzers/CSharp/CodeFixes/NewLines/ConditionalExpressionPlacement/ConditionalExpressionPlacementCodeFixProvider.cs

@@ -27,7 +27,7 @@ internal sealed class ConditionalExpressionPlacementCodeFixProvider() : CodeFixP
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.ConditionalExpressionPlacementDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var document = context.Document;
         var diagnostic = context.Diagnostics.First();
@@ -37,6 +37,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 c => UpdateDocumentAsync(document, [diagnostic], c),
                 nameof(CSharpCodeFixesResources.Place_token_on_following_line)),
             context.Diagnostics);
+        return Task.CompletedTask;
     }
 
     private static async Task<Document> UpdateDocumentAsync(

src/Analyzers/CSharp/CodeFixes/NewLines/ConsecutiveBracePlacement/ConsecutiveBracePlacementCodeFixProvider.cs

@@ -28,7 +28,7 @@ internal sealed class ConsecutiveBracePlacementCodeFixProvider() : CodeFixProvid
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.ConsecutiveBracePlacementDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var document = context.Document;
         var diagnostic = context.Diagnostics.First();
@@ -38,6 +38,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 c => UpdateDocumentAsync(document, diagnostic, c),
                 nameof(CSharpCodeFixesResources.Remove_blank_lines_between_braces)),
             context.Diagnostics);
+        return Task.CompletedTask;
     }
 
     private static Task<Document> UpdateDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)

src/Analyzers/CSharp/CodeFixes/NewLines/ConstructorInitializerPlacement/ConstructorInitializerPlacementCodeFixProvider.cs

@@ -27,7 +27,7 @@ internal sealed class ConstructorInitializerPlacementCodeFixProvider() : CodeFix
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.ConstructorInitializerPlacementDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var document = context.Document;
         var diagnostic = context.Diagnostics.First();
@@ -37,6 +37,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 c => UpdateDocumentAsync(document, [diagnostic], c),
                 nameof(CSharpCodeFixesResources.Place_token_on_following_line)),
             context.Diagnostics);
+        return Task.CompletedTask;
     }
 
     private static async Task<Document> UpdateDocumentAsync(

src/Analyzers/CSharp/CodeFixes/NewLines/EmbeddedStatementPlacement/EmbeddedStatementPlacementCodeFixProvider.cs

@@ -30,7 +30,7 @@ internal sealed class EmbeddedStatementPlacementCodeFixProvider() : CodeFixProvi
     public override ImmutableArray<string> FixableDiagnosticIds
         => [IDEDiagnosticIds.EmbeddedStatementPlacementDiagnosticId];
 
-    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         var document = context.Document;
         var diagnostic = context.Diagnostics.First();
@@ -40,6 +40,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 c => FixAllAsync(document, [diagnostic], c),
                 nameof(CSharpCodeFixesResources.Place_statement_on_following_line)),
             context.Diagnostics);
+        return Task.CompletedTask;
     }
 
     public static async Task<Document> FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, CancellationToken cancellationToken)