Add RequestDelegate analyzer

Author: JamesNK

eng/Versions.props

@@ -207,9 +207,9 @@
     -->
     <Analyzer_MicrosoftCodeAnalysisCSharpVersion>3.3.1</Analyzer_MicrosoftCodeAnalysisCSharpVersion>
     <Analyzer_MicrosoftCodeAnalysisCSharpWorkspacesVersion>3.3.1</Analyzer_MicrosoftCodeAnalysisCSharpWorkspacesVersion>
-    <MicrosoftCodeAnalysisCommonVersion>4.2.0-2.22128.1</MicrosoftCodeAnalysisCommonVersion>
-    <MicrosoftCodeAnalysisCSharpVersion>4.2.0-2.22128.1</MicrosoftCodeAnalysisCSharpVersion>
-    <MicrosoftCodeAnalysisCSharpWorkspacesVersion>4.2.0-2.22128.1</MicrosoftCodeAnalysisCSharpWorkspacesVersion>
+    <MicrosoftCodeAnalysisCommonVersion>4.4.0-2.22458.3</MicrosoftCodeAnalysisCommonVersion>
+    <MicrosoftCodeAnalysisCSharpVersion>4.4.0-2.22458.3</MicrosoftCodeAnalysisCSharpVersion>
+    <MicrosoftCodeAnalysisCSharpWorkspacesVersion>4.4.0-2.22458.3</MicrosoftCodeAnalysisCSharpWorkspacesVersion>
     <MicrosoftCodeAnalysisPublicApiAnalyzersVersion>3.3.3</MicrosoftCodeAnalysisPublicApiAnalyzersVersion>
     <MicrosoftCodeAnalysisCSharpAnalyzerTestingXUnitVersion>1.1.2-beta1.22276.1</MicrosoftCodeAnalysisCSharpAnalyzerTestingXUnitVersion>
     <MicrosoftCodeAnalysisCSharpCodeFixTestingXUnitVersion>1.1.2-beta1.22276.1</MicrosoftCodeAnalysisCSharpCodeFixTestingXUnitVersion>

src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs

@@ -115,4 +115,13 @@ internal static class DiagnosticDescriptors
         DiagnosticSeverity.Warning,
         isEnabledByDefault: true,
         helpLinkUri: "https://aka.ms/aspnet/analyzers");
+
+    internal static readonly DiagnosticDescriptor DoNotReturnValueFromRequestDelegate = new(
+        "ASP0015",
+        "Do not return a value from RequestDelegate",
+        "The method used to create a RequestDelegate returns Task<{0}>. RequestDelegate discards this value. If this isn't intended then don't return a value or change the method signature to not match RequestDelegate.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        helpLinkUri: "https://aka.ms/aspnet/analyzers");
 }

src/Framework/AspNetCoreAnalyzers/src/Analyzers/Http/RequestDelegateReturnTypeAnalyzer.cs

@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Microsoft.AspNetCore.Analyzers.Http;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public partial class RequestDelegateReturnTypeAnalyzer : DiagnosticAnalyzer
+{
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotReturnValueFromRequestDelegate);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterCompilationStartAction(context =>
+        {
+            var compilation = context.Compilation;
+
+            if (!WellKnownTypes.TryCreate(compilation, out var wellKnownTypes))
+            {
+                return;
+            }
+            context.RegisterOperationAction(context =>
+            {
+                var methodReference = (IMethodReferenceOperation)context.Operation;
+                if (methodReference.Parent is { } parent &&
+                    parent.Kind == OperationKind.DelegateCreation &&
+                    SymbolEqualityComparer.Default.Equals(parent.Type, wellKnownTypes.RequestDelegate))
+                {
+                    // Inspect return type of method signature for Task<T>.
+                    var returnType = methodReference.Method.ReturnType;
+
+                    if (SymbolEqualityComparer.Default.Equals(returnType.OriginalDefinition, wellKnownTypes.TaskOfT))
+                    {
+                        AddDiagnosticWarning(context, methodReference.Syntax.GetLocation(), returnType);
+                    }
+                }
+            }, OperationKind.MethodReference);
+            context.RegisterOperationAction(context =>
+            {
+                var anonymousFunction = (IAnonymousFunctionOperation)context.Operation;
+                if (anonymousFunction.Parent is { } parent &&
+                    parent.Kind == OperationKind.DelegateCreation &&
+                    SymbolEqualityComparer.Default.Equals(parent.Type, wellKnownTypes.RequestDelegate))
+                {
+                    // Inspect contents of anonymous function and search for return statements.
+                    // Return statement of Task<T> means a value was returned.
+                    foreach (var item in anonymousFunction.Body.Descendants())
+                    {
+                        if (item.Kind == OperationKind.Return &&
+                            item is IReturnOperation returnOperation &&
+                            returnOperation.ReturnedValue is { } returnedValue)
+                        {
+                            var resolvedOperation = WalkDownConversion(returnedValue);
+                            var returnType = resolvedOperation.Type;
+
+                            if (SymbolEqualityComparer.Default.Equals(returnType.OriginalDefinition, wellKnownTypes.TaskOfT))
+                            {
+                                AddDiagnosticWarning(context, anonymousFunction.Syntax.GetLocation(), returnType);
+                                return;
+                            }
+                        }
+                    }
+                }
+            }, OperationKind.AnonymousFunction);
+        });
+    }
+
+    private static void AddDiagnosticWarning(OperationAnalysisContext context, Location location, ITypeSymbol returnType)
+    {
+        context.ReportDiagnostic(Diagnostic.Create(
+            DiagnosticDescriptors.DoNotReturnValueFromRequestDelegate,
+            location,
+            ((INamedTypeSymbol)returnType).TypeArguments[0].ToString()));
+    }
+
+    private static IOperation WalkDownConversion(IOperation operation)
+    {
+        while (operation is IConversionOperation conversionOperation)
+        {
+            operation = conversionOperation.Operand;
+        }
+
+        return operation;
+    }
+}

src/Framework/AspNetCoreAnalyzers/src/Analyzers/Http/WellKnownTypes.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.AspNetCore.Analyzers.Http;
+
+internal sealed class WellKnownTypes
+{
+    public static bool TryCreate(Compilation compilation, [NotNullWhen(returnValue: true)] out WellKnownTypes? wellKnownTypes)
+    {
+        wellKnownTypes = default;
+
+        const string RequestDelegate = "Microsoft.AspNetCore.Http.RequestDelegate";
+        if (compilation.GetTypeByMetadataName(RequestDelegate) is not { } requestDelegate)
+        {
+            return false;
+        }
+
+        const string TaskOfT = "System.Threading.Tasks.Task`1";
+        if (compilation.GetTypeByMetadataName(TaskOfT) is not { } taskOfT)
+        {
+            return false;
+        }
+
+        wellKnownTypes = new()
+        {
+            RequestDelegate = requestDelegate,
+            TaskOfT = taskOfT
+        };
+
+        return true;
+    }
+
+    public INamedTypeSymbol RequestDelegate { get; private init; }
+    public INamedTypeSymbol TaskOfT { get; private init; }
+}