Cleanup AspNetCoreAnalyzers (#42757)

* Cleanup AspNetCoreAnalyzers

* Fix typo

Co-authored-by: Safia Abdalla <[email protected]>

src/Framework/AspNetCoreAnalyzers/src/Analyzers/RenderTreeBuilder/RenderTreeBuilderAnalyzer.cs

@@ -12,48 +12,53 @@ namespace Microsoft.AspNetCore.Analyzers.RenderTreeBuilder;
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public partial class RenderTreeBuilderAnalyzer : DiagnosticAnalyzer
 {
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(new[]
-    {
-        DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers,
-    });
+    private const int SequenceParameterOrdinal = 0;
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
-        context.RegisterCompilationStartAction(compilationStartAnalysisContext =>
+        context.RegisterCompilationStartAction(context =>
         {
-            var compilation = compilationStartAnalysisContext.Compilation;
+            var compilation = context.Compilation;
 
             if (!WellKnownTypes.TryCreate(compilation, out var wellKnownTypes))
             {
                 return;
             }
 
-            compilationStartAnalysisContext.RegisterOperationAction(operationAnalysisContext =>
+            context.RegisterOperationAction(context =>
             {
-                var invocation = (IInvocationOperation)operationAnalysisContext.Operation;
+                var invocation = (IInvocationOperation)context.Operation;
 
                 if (!IsRenderTreeBuilderMethodWithSequenceParameter(wellKnownTypes, invocation.TargetMethod))
                 {
                     return;
                 }
 
-                var sequenceArgument = invocation.Arguments[0];
-
-                if (!sequenceArgument.Value.Syntax.IsKind(SyntaxKind.NumericLiteralExpression))
+                foreach (var argument in invocation.Arguments)
                 {
-                    operationAnalysisContext.ReportDiagnostic(Diagnostic.Create(
-                        DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers,
-                        sequenceArgument.Syntax.GetLocation(),
-                        sequenceArgument.Syntax.ToString()));
+                    if (argument.Parameter.Ordinal == SequenceParameterOrdinal)
+                    {
+                        if (!argument.Value.Syntax.IsKind(SyntaxKind.NumericLiteralExpression))
+                        {
+                            context.ReportDiagnostic(Diagnostic.Create(
+                                DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers,
+                                argument.Syntax.GetLocation(),
+                                argument.Syntax.ToString()));
+                        }
+
+                        break;
+                    }
                 }
+
             }, OperationKind.Invocation);
         });
     }
 
     private static bool IsRenderTreeBuilderMethodWithSequenceParameter(WellKnownTypes wellKnownTypes, IMethodSymbol targetMethod)
         => SymbolEqualityComparer.Default.Equals(wellKnownTypes.RenderTreeBuilder, targetMethod.ContainingType)
-        && targetMethod.Parameters.Length != 0
-        && targetMethod.Parameters[0].Name == "sequence";
+        && targetMethod.Parameters.Length > SequenceParameterOrdinal
+        && targetMethod.Parameters[SequenceParameterOrdinal].Name == "sequence";
 }

src/Framework/AspNetCoreAnalyzers/src/Analyzers/RouteHandlers/DetectMismatchedParameterOptionality.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -21,7 +22,16 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
             return;
         }
 
-        var value = invocation.Arguments[1].Value;
+        IOperation? value = null;
+        foreach (var argument in invocation.Arguments)
+        {
+            if (argument.Parameter.Ordinal == 1)
+            {
+                value = argument.Value;
+            }
+        }
+
+        Debug.Assert(value is not null);
         if (value.ConstantValue is not { HasValue: true } constant ||
             constant.Value is not string routeTemplate)
         {

src/Framework/AspNetCoreAnalyzers/src/Analyzers/RouteHandlers/DetectMisplacedLambdaAttribute.cs

@@ -13,7 +13,6 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
 {
     private static void DetectMisplacedLambdaAttribute(
         in OperationAnalysisContext context,
-        IInvocationOperation invocation,
         IAnonymousFunctionOperation lambda)
     {
         // This analyzer will only process invocations that are immediate children of the
@@ -23,29 +22,21 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
         //    Hello();
         //    return "foo";
         // }
-        InvocationExpressionSyntax? targetInvocation = null;
+        IMethodSymbol? methodSymbol = null;
 
         // () => Hello() has a single child which is a BlockOperation so we check to see if
         // expression associated with that operation is an invocation expression
         if (lambda.ChildOperations.FirstOrDefault().Syntax is InvocationExpressionSyntax innerInvocation)
         {
-            targetInvocation = innerInvocation;
+            methodSymbol = lambda.Symbol;
         }
 
         if (lambda.ChildOperations.FirstOrDefault().ChildOperations.FirstOrDefault() is IReturnOperation returnOperation
             && returnOperation.ReturnedValue is IInvocationOperation returnedInvocation)
         {
-            targetInvocation = (InvocationExpressionSyntax)returnedInvocation.Syntax;
+            methodSymbol = returnedInvocation.TargetMethod;
         }
 
-        if (targetInvocation is null)
-        {
-            return;
-        }
-
-        var methodOperation = invocation.SemanticModel.GetSymbolInfo(targetInvocation);
-        var methodSymbol = methodOperation.Symbol ?? methodOperation.CandidateSymbols.FirstOrDefault();
-
         // If no method definition was found for the lambda, then abort.
         if (methodSymbol is null)
         {

src/Framework/AspNetCoreAnalyzers/src/Analyzers/RouteHandlers/DisallowReturningActionResultFromMapMethods.cs

@@ -14,9 +14,10 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
         in OperationAnalysisContext context,
         WellKnownTypes wellKnownTypes,
         IInvocationOperation invocationOperation,
-        IAnonymousFunctionOperation anonymousFunction)
+        IAnonymousFunctionOperation anonymousFunction,
+        SyntaxNode nodeForError)
     {
-        DisallowReturningActionResultFromMapMethods(in context, wellKnownTypes, invocationOperation, anonymousFunction.Symbol, anonymousFunction.Body);
+        DisallowReturningActionResultFromMapMethods(in context, wellKnownTypes, invocationOperation, anonymousFunction.Symbol, anonymousFunction.Body, nodeForError);
     }
 
     private static void DisallowReturningActionResultFromMapMethods(
@@ -24,7 +25,8 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
         WellKnownTypes wellKnownTypes,
         IInvocationOperation invocationOperation,
         IMethodSymbol methodSymbol,
-        IBlockOperation? methodBody)
+        IBlockOperation? methodBody,
+        SyntaxNode nodeForError)
     {
         var returnType = UnwrapPossibleAsyncReturnType(methodSymbol.ReturnType);
 
@@ -41,7 +43,7 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
             // if we don't have a method body, and the action is IResult or ActionResult<T> returning, produce diagnostics for the entire method.
             context.ReportDiagnostic(Diagnostic.Create(
                 DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers,
-                invocationOperation.Arguments[2].Syntax.GetLocation(),
+                nodeForError.GetLocation(),
                 invocationOperation.TargetMethod.Name));
             return;
         }

src/Framework/AspNetCoreAnalyzers/src/Analyzers/RouteHandlers/RouteHandlerAnalyzer.cs

@@ -14,38 +14,47 @@ namespace Microsoft.AspNetCore.Analyzers.RouteHandlers;
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
 {
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(new[]
-    {
+    private const int DelegateParameterOrdinal = 2;
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
         DiagnosticDescriptors.DoNotUseModelBindingAttributesOnRouteHandlerParameters,
         DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers,
         DiagnosticDescriptors.DetectMisplacedLambdaAttribute,
         DiagnosticDescriptors.DetectMismatchedParameterOptionality
-    });
+    );
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
 
-        context.RegisterCompilationStartAction(static compilationStartAnalysisContext =>
+        context.RegisterCompilationStartAction(static context =>
         {
-            var compilation = compilationStartAnalysisContext.Compilation;
+            var compilation = context.Compilation;
             if (!WellKnownTypes.TryCreate(compilation, out var wellKnownTypes))
             {
                 Debug.Fail("One or more types could not be found. This usually means you are bad at spelling C# type names.");
                 return;
             }
 
-            compilationStartAnalysisContext.RegisterOperationAction(operationAnalysisContext =>
+            context.RegisterOperationAction(context =>
             {
-                var invocation = (IInvocationOperation)operationAnalysisContext.Operation;
+                var invocation = (IInvocationOperation)context.Operation;
                 var targetMethod = invocation.TargetMethod;
                 if (!IsRouteHandlerInvocation(wellKnownTypes, invocation, targetMethod))
                 {
                     return;
                 }
 
-                var delegateCreation = invocation.Arguments[2].Descendants().OfType<IDelegateCreationOperation>().FirstOrDefault();
+                IDelegateCreationOperation? delegateCreation = null;
+                foreach (var argument in invocation.Arguments)
+                {
+                    if (argument.Parameter.Ordinal == DelegateParameterOrdinal)
+                    {
+                        delegateCreation = argument.Descendants().OfType<IDelegateCreationOperation>().FirstOrDefault();
+                        break;
+                    }
+                }
+
                 if (delegateCreation is null)
                 {
                     return;
@@ -53,42 +62,44 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
 
                 if (delegateCreation.Target.Kind == OperationKind.AnonymousFunction)
                 {
-                    var lambda = ((IAnonymousFunctionOperation)delegateCreation.Target);
-                    DisallowMvcBindArgumentsOnParameters(in operationAnalysisContext, wellKnownTypes, invocation, lambda.Symbol);
-                    DisallowReturningActionResultFromMapMethods(in operationAnalysisContext, wellKnownTypes, invocation, lambda);
-                    DetectMisplacedLambdaAttribute(operationAnalysisContext, invocation, lambda);
-                    DetectMismatchedParameterOptionality(in operationAnalysisContext, invocation, lambda.Symbol);
+                    var lambda = (IAnonymousFunctionOperation)delegateCreation.Target;
+                    DisallowMvcBindArgumentsOnParameters(in context, wellKnownTypes, invocation, lambda.Symbol);
+                    DisallowReturningActionResultFromMapMethods(in context, wellKnownTypes, invocation, lambda, delegateCreation.Syntax);
+                    DetectMisplacedLambdaAttribute(context, lambda);
+                    DetectMismatchedParameterOptionality(in context, invocation, lambda.Symbol);
                 }
                 else if (delegateCreation.Target.Kind == OperationKind.MethodReference)
                 {
                     var methodReference = (IMethodReferenceOperation)delegateCreation.Target;
-                    DisallowMvcBindArgumentsOnParameters(in operationAnalysisContext, wellKnownTypes, invocation, methodReference.Method);
-                    DetectMismatchedParameterOptionality(in operationAnalysisContext, invocation, methodReference.Method);
+                    DisallowMvcBindArgumentsOnParameters(in context, wellKnownTypes, invocation, methodReference.Method);
+                    DetectMismatchedParameterOptionality(in context, invocation, methodReference.Method);
 
                     var foundMethodReferenceBody = false;
                     if (!methodReference.Method.DeclaringSyntaxReferences.IsEmpty)
                     {
                         var syntaxReference = methodReference.Method.DeclaringSyntaxReferences[0];
-                        var methodOperation = invocation.SemanticModel.GetOperation(syntaxReference.GetSyntax(operationAnalysisContext.CancellationToken));
+                        var methodOperation = invocation.SemanticModel.GetOperation(syntaxReference.GetSyntax(context.CancellationToken));
                         if (methodOperation is ILocalFunctionOperation { Body: not null } localFunction)
                         {
                             foundMethodReferenceBody = true;
                             DisallowReturningActionResultFromMapMethods(
-                                in operationAnalysisContext,
+                                in context,
                                 wellKnownTypes,
                                 invocation,
                                 methodReference.Method,
-                                localFunction.Body);
+                                localFunction.Body,
+                                delegateCreation.Syntax);
                         }
                         else if (methodOperation is IMethodBodyOperation methodBody)
                         {
                             foundMethodReferenceBody = true;
                             DisallowReturningActionResultFromMapMethods(
-                                in operationAnalysisContext,
+                                in context,
                                 wellKnownTypes,
                                 invocation,
                                 methodReference.Method,
-                                methodBody.BlockBody ?? methodBody.ExpressionBody);
+                                methodBody.BlockBody ?? methodBody.ExpressionBody,
+                                delegateCreation.Syntax);
                         }
                     }
 
@@ -97,11 +108,12 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
                         // it's possible we couldn't find the operation for the method reference. In this case,
                         // try and provide less detailed diagnostics to the extent we can
                         DisallowReturningActionResultFromMapMethods(
-                                in operationAnalysisContext,
+                                in context,
                                 wellKnownTypes,
                                 invocation,
                                 methodReference.Method,
-                                methodBody: null);
+                                methodBody: null,
+                                delegateCreation.Syntax);
 
                     }
                 }
@@ -118,6 +130,6 @@ public partial class RouteHandlerAnalyzer : DiagnosticAnalyzer
             SymbolEqualityComparer.Default.Equals(wellKnownTypes.EndpointRouteBuilderExtensions, targetMethod.ContainingType) &&
             invocation.Arguments.Length == 3 &&
             targetMethod.Parameters.Length == 3 &&
-            SymbolEqualityComparer.Default.Equals(wellKnownTypes.Delegate, targetMethod.Parameters[2].Type);
+            SymbolEqualityComparer.Default.Equals(wellKnownTypes.Delegate, targetMethod.Parameters[DelegateParameterOrdinal].Type);
     }
 }

src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs

@@ -16,24 +16,23 @@ namespace Microsoft.AspNetCore.Analyzers.WebApplicationBuilder;
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
 {
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(new[]
-    {
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
         DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder,
         DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder,
         DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder,
         DiagnosticDescriptors.DoNotUseHostConfigureLogging,
         DiagnosticDescriptors.DoNotUseHostConfigureServices,
         DiagnosticDescriptors.DisallowConfigureAppConfigureHostBuilder
-    });
+    );
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
 
-        context.RegisterCompilationStartAction(compilationStartAnalysisContext =>
+        context.RegisterCompilationStartAction(context =>
         {
-            var compilation = compilationStartAnalysisContext.Compilation;
+            var compilation = context.Compilation;
             if (!WellKnownTypes.TryCreate(compilation, out var wellKnownTypes))
             {
                 Debug.Fail("One or more types could not be found. This usually means you are bad at spelling C# type names.");
@@ -66,22 +65,22 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
             };
             INamedTypeSymbol[] configureHostTypes = { wellKnownTypes.ConfigureHostBuilder };
 
-            compilationStartAnalysisContext.RegisterOperationAction(operationAnalysisContext =>
+            context.RegisterOperationAction(context =>
             {
-                var invocation = (IInvocationOperation)operationAnalysisContext.Operation;
+                var invocation = (IInvocationOperation)context.Operation;
                 var targetMethod = invocation.TargetMethod;
 
                 // var builder = WebApplication.CreateBuilder();
                 // builder.Host.ConfigureWebHost(x => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureHostBuilder,
                         "ConfigureWebHost",
                         configureWebHostTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder,
                             invocation));
@@ -90,14 +89,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder();
                 // builder.WebHost.Configure(x => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureWebHostBuilder,
                         "Configure",
                         configureTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder,
                             invocation));
@@ -106,14 +105,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder();
                 // builder.WebHost.UseStartup<Startup>();
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureWebHostBuilder,
                         "UseStartup",
                         userStartupTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder,
                             invocation));
@@ -122,14 +121,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 //var builder = WebApplication.CreateBuilder(args);
                 //builder.Host.ConfigureLogging(x => {})
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureHostBuilder,
                         "ConfigureLogging",
                         configureLoggingTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseHostConfigureLogging,
                             invocation));
@@ -138,14 +137,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 //var builder = WebApplication.CreateBuilder(args);
                 //builder.WebHost.ConfigureLogging(x => {})
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureWebHostBuilder,
                         "ConfigureLogging",
                         configureLoggingTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseHostConfigureLogging,
                             invocation));
@@ -154,14 +153,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder(args);
                 // builder.Host.ConfigureServices(x => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureHostBuilder,
                         "ConfigureServices",
                         configureServicesTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseHostConfigureServices,
                             invocation));
@@ -170,14 +169,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder(args);
                 // builder.WebHost.ConfigureServices(x => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureWebHostBuilder,
                         "ConfigureServices",
                         configureServicesTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DoNotUseHostConfigureServices,
                             invocation));
@@ -186,14 +185,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder();
                 // builder.WebHost.ConfigureAppConfiguration(builder => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureWebHostBuilder,
                         "ConfigureAppConfiguration",
                         configureAppTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DisallowConfigureAppConfigureHostBuilder,
                             invocation));
@@ -202,14 +201,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder();
                 // builder.Host.ConfigureAppConfiguration(builder => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureHostBuilder,
                         "ConfigureAppConfiguration",
                         configureAppTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DisallowConfigureAppConfigureHostBuilder,
                             invocation));
@@ -218,14 +217,14 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer
                 // var builder = WebApplication.CreateBuilder();
                 // builder.Host.ConfigureHostConfiguration(builder => {});
                 if (IsDisallowedMethod(
-                        operationAnalysisContext,
+                        context,
                         invocation,
                         targetMethod,
                         wellKnownTypes.ConfigureHostBuilder,
                         "ConfigureHostConfiguration",
                         configureHostTypes))
                 {
-                    operationAnalysisContext.ReportDiagnostic(
+                    context.ReportDiagnostic(
                         CreateDiagnostic(
                             DiagnosticDescriptors.DisallowConfigureAppConfigureHostBuilder,
                             invocation));

src/Framework/AspNetCoreAnalyzers/src/CodeFixes/DetectMismatchedParameterOptionalityFixer.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Immutable;
+using System.Composition;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
@@ -13,6 +14,7 @@ using Microsoft.CodeAnalysis.Editing;
 
 namespace Microsoft.AspNetCore.Analyzers.RouteHandlers.Fixers;
 
+[ExportCodeFixProvider(LanguageNames.CSharp), Shared]
 public class DetectMismatchedParameterOptionalityFixer : CodeFixProvider
 {
     public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(DiagnosticDescriptors.DetectMismatchedParameterOptionality.Id);
@@ -35,7 +37,6 @@ public class DetectMismatchedParameterOptionalityFixer : CodeFixProvider
 
     private static async Task<Document> FixMismatchedParameterOptionality(Diagnostic diagnostic, Document document, CancellationToken cancellationToken)
     {
-        DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken);
         var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
         if (root == null)
@@ -47,9 +48,9 @@ public class DetectMismatchedParameterOptionalityFixer : CodeFixProvider
         if (param is ParameterSyntax { Type: { } parameterType } parameterSyntax)
         {
             var newParam = parameterSyntax.WithType(SyntaxFactory.NullableType(parameterType));
-            editor.ReplaceNode(parameterSyntax, newParam);
+            return document.WithSyntaxRoot(root.ReplaceNode(parameterSyntax, newParam));
         }
 
-        return editor.GetChangedDocument();
+        return document;
     }
 }