Analyzer to detect missing ASP.NET Core integration registration

docs/analyzer-rules/AZFW0014.md

@@ -0,0 +1,19 @@
+# AZFW0011: Missing Registration for ASP.NET Integration
+
+| | Value |
+|-|-|
+| **Rule ID** |AZFW00014|
+| **Category** |[Usage]|
+| **Severity** |Error|
+
+## Cause
+
+This rule is triggered when the ASP.NET function app is missing registration for the appropriate method.
+
+## Rule description
+
+The ASP.NET function app should have registration for `ConfigureFunctionsWebApplication` method. This rule will be violated when the app is missing this registration.
+
+## How to fix violations
+
+Add registration for `ConfigureFunctionsWebApplication` method in Function App. Refer to [public documentation](https://learn.microsoft.com/en-us/azure/azure-functions/dotnet-isolated-process-guide#aspnet-core-integration) for guidance on ASP.NET Core integration.

sdk/Sdk.Analyzers/DiagnosticDescriptors.cs

@@ -32,5 +32,8 @@ private static DiagnosticDescriptor Create(string id, string title,string messag
         public static DiagnosticDescriptor IterableBindingTypeExpectedForBlobContainer { get; }
             = Create(id: "AZFW0011", title: "Invalid binding type", messageFormat: "The binding type '{0}' must be iterable for container path.",
                 category: Constants.DiagnosticsCategories.Usage, severity: DiagnosticSeverity.Error);
+        public static DiagnosticDescriptor CorrectRegistrationExpectedInAspNetIntegration { get; }
+            = Create(id: "AZFW0014", title: "Missing expected registration in ASPNet Integration", messageFormat: "The registration for method '{0}' is expected for ASP.Net Integration.",
+                category: Constants.DiagnosticsCategories.Usage, severity: DiagnosticSeverity.Error);
     }
 }

sdk/Sdk.Analyzers/Extensions/MethodSymbolExtensions.cs

@@ -43,5 +43,23 @@ public static bool IsFunction(this IMethodSymbol symbol, SymbolAnalysisContext a
 
             return attributes.Any(a => attributeType.IsAssignableFrom(a.AttributeClass, true));
         }
+
+        /// <summary>
+        /// Checks if a method symbol is a Main method. This also checks for implicit main in top-level statements
+        /// </summary>
+        /// <param name="symbol">The method symbol to check.</param>
+        /// <returns>A boolean value indicating whether the method symbol is a Main method.</returns>
+        public static bool IsMainMethod(this IMethodSymbol symbol)
+        {
+            bool isMainMethod = symbol?.IsStatic == true && symbol.Name switch
+            {
+                "Main" => true,
+                "$Main" => true,
+                "<Main>$" => true,
+                _ => false
+            };
+
+            return isMainMethod;
+        }
     }
 }

sdk/Sdk.Analyzers/RegistrationExpectedInASPNetIntegration.cs

@@ -0,0 +1,48 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.Azure.Functions.Worker.Sdk.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class RegistrationExpectedInASPNetIntegration : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DiagnosticDescriptors.CorrectRegistrationExpectedInAspNetIntegration);
+
+        private const string ExpectedRegistrationMethod = "ConfigureFunctionsWebApplication";
+        private const string AspNetExtensionAssemblyName = "Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore";
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze);
+            context.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);
+        }
+
+        private static void AnalyzeMethod(SymbolAnalysisContext context)
+        {
+            var symbol = (IMethodSymbol)context.Symbol;
+
+            bool isAspNetAssembly = context.Compilation.ReferencedAssemblyNames.Any(assembly => assembly.Name.Equals(AspNetExtensionAssemblyName));
+
+            if (!isAspNetAssembly || !symbol.IsMainMethod())
+            {
+                return;
+            }
+
+            SyntaxReference syntaxReference = symbol.DeclaringSyntaxReferences.FirstOrDefault();
+            string code = syntaxReference.SyntaxTree.GetText().ToString();
+
+            if (!code.Contains(ExpectedRegistrationMethod))
+            {
+                var diagnostic = Diagnostic.Create(DiagnosticDescriptors.CorrectRegistrationExpectedInAspNetIntegration, symbol.Locations.First(), ExpectedRegistrationMethod);
+                context.ReportDiagnostic(diagnostic);
+            }
+        }
+    }
+}

test/Sdk.Analyzers.Tests/RegistrationExpectedInAspNetIntegrationTests.cs

@@ -0,0 +1,293 @@
+using Xunit;
+using AnalyzerTest = Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerTest<Microsoft.Azure.Functions.Worker.Sdk.Analyzers.RegistrationExpectedInASPNetIntegration, Microsoft.CodeAnalysis.Testing.Verifiers.XUnitVerifier>;
+using Verify = Microsoft.CodeAnalysis.CSharp.Testing.XUnit.AnalyzerVerifier<Microsoft.Azure.Functions.Worker.Sdk.Analyzers.RegistrationExpectedInASPNetIntegration>;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Testing;
+using System.Collections.Immutable;
+
+namespace Sdk.Analyzers.Tests
+{
+    public class RegistrationExpectedInAspNetIntegrationTests
+    {
+        private const string ExpectedRegistrationMethod = "ConfigureFunctionsWebApplication";
+
+        [Fact]
+        public async Task AspNetIntegration_MissingRegistration_Diagnostics_Expected()
+        {
+            string testCode = @"
+                namespace AspNetIntegration
+                {
+                    using System.Linq;
+                    using System.Threading.Tasks;
+                    using Microsoft.Azure.Functions.Worker;
+                    using Microsoft.Extensions.DependencyInjection;
+                    using Microsoft.Extensions.Hosting;
+                    using Microsoft.Extensions.Logging;
+
+                    class Program
+                    {
+                        static void Main(string[] args)
+                        {
+                            var host = new HostBuilder()
+                                .ConfigureFunctionsWorkerDefaults()
+                                .Build();
+
+                            host.Run();
+                        }
+                    }
+                }";
+
+            var test = new AnalyzerTest
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net60.WithPackages(ImmutableArray.Create(
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker", "1.19.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Sdk", "1.14.1"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs", "6.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore", "1.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Abstractions", "5.0.0"),
+                    new PackageIdentity("Microsoft.Extensions.Hosting.Abstractions", "6.0.0")
+                    )),
+
+                TestCode = testCode
+            };
+
+            test.ExpectedDiagnostics.Add(Verify.Diagnostic()
+                            .WithSeverity(Microsoft.CodeAnalysis.DiagnosticSeverity.Error)
+                            .WithSpan(13, 37, 13, 41)
+                            .WithArguments(ExpectedRegistrationMethod));
+
+            await test.RunAsync();
+        }
+
+
+        [Fact]
+        public async Task AspNetIntegrationWithTrigger_MissingRegistration_Diagnostics_Expected()
+        {
+            string testCode = @"
+                namespace AspNetIntegration
+                {
+                    using System.Linq;
+                    using System.Threading.Tasks;
+                    using Microsoft.Azure.Functions.Worker;
+                    using Microsoft.Extensions.DependencyInjection;
+                    using Microsoft.Extensions.Hosting;
+                    using Microsoft.Extensions.Logging;
+
+                    class Program
+                    {
+                        static void Main(string[] args)
+                        {
+                            var host = new HostBuilder()
+                                .ConfigureFunctionsWorkerDefaults()
+                                .Build();
+
+                            host.Run();
+                        }
+                    }
+                }
+
+                namespace AspNetIntegration
+                {
+                    using Microsoft.Azure.Functions.Worker;
+                    using Microsoft.Azure.Functions.Worker.Http;
+
+                    public class FunctionHttpTrigger
+                    {
+                        [Function(nameof(FunctionHttpTrigger))]
+                        public void Run([HttpTrigger(AuthorizationLevel.Anonymous, ""post"")] HttpRequestData req)
+                        {
+                        }
+                    }
+                }";
+
+            var test = new AnalyzerTest
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net60.WithPackages(ImmutableArray.Create(
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker", "1.19.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Sdk", "1.14.1"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs", "6.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore", "1.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Abstractions", "5.0.0"),
+                    new PackageIdentity("Microsoft.Extensions.Hosting.Abstractions", "6.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Http", "3.1.0")
+                    )),
+
+                TestCode = testCode
+            };
+
+            test.ExpectedDiagnostics.Add(Verify.Diagnostic()
+                            .WithSeverity(Microsoft.CodeAnalysis.DiagnosticSeverity.Error)
+                            .WithSpan(13, 37, 13, 41)
+                            .WithArguments(ExpectedRegistrationMethod));
+
+            await test.RunAsync();
+        }
+
+        [Fact]
+        public async Task NotAspNetIntegration_Diagnostics_NotExpected()
+        {
+            string testCode = @"
+                using System;
+                using Microsoft.Extensions.DependencyInjection;
+                using Microsoft.Extensions.Hosting;
+
+                namespace SampleApp
+                {
+                    public class Program
+                    {
+                        public static void Main()
+                        {
+                            var host = new HostBuilder()
+                                .ConfigureFunctionsWorkerDefaults()
+                                .Build();
+
+                            host.Run();
+                        }
+
+                        public static void Method1()
+                        {
+                        }
+
+                        private static void Method2()
+                        {
+                        }
+                    }
+                }";
+
+            var test = new AnalyzerTest
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50.WithPackages(ImmutableArray.Create(
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker", "1.18.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Sdk", "1.13.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs", "6.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Abstractions", "1.3.0"))),
+
+                TestCode = testCode
+            };
+
+            // test.ExpectedDiagnostics is an empty collection.
+
+            await test.RunAsync();
+        }
+
+        [Fact]
+        public async Task AspNetIntegration_WithRegistration_Diagnostics_NotExpected()
+        {
+            string testCode = @"
+                using System.Linq;
+                using System.Threading.Tasks;
+                using Microsoft.Azure.Functions.Worker;
+                using Microsoft.Extensions.DependencyInjection;
+                using Microsoft.Extensions.Hosting;
+                using Microsoft.Extensions.Logging;
+
+                namespace AspNetIntegration
+                {
+                    class Program
+                    {
+                        static void Main(string[] args)
+                        {
+
+                            //<docsnippet_aspnet_registration>
+                            var host = new HostBuilder()
+                                .ConfigureFunctionsWebApplication()
+                                .Build();
+
+                            host.Run();
+                            //</docsnippet_aspnet_registration>
+                        }
+
+                        public static void Method1()
+                        {
+                        }
+
+                        private static void Method2()
+                        {
+                        }
+                    }
+                }";
+
+            var test = new AnalyzerTest
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net60.WithPackages(ImmutableArray.Create(
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker", "1.19.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Sdk", "1.14.1"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs", "6.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore", "1.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Abstractions", "5.0.0"),
+                    new PackageIdentity("Microsoft.Extensions.Hosting.Abstractions", "6.0.0")
+                    )),
+
+                TestCode = testCode
+            };
+
+            // test.ExpectedDiagnostics is an empty collection.
+
+            await test.RunAsync();
+        }
+
+        [Fact]
+        public async Task AspNetIntegration_WithMiddleWare_WithRegistration_Diagnostics_NotExpected()
+        {
+            string testCode = @"
+                using System.Linq;
+                using System.Threading.Tasks;
+                using Microsoft.Azure.Functions.Worker;
+                using Microsoft.Extensions.DependencyInjection;
+                using Microsoft.Extensions.Hosting;
+                using Microsoft.Extensions.Logging;
+
+                namespace AspNetIntegration
+                {
+                    class Program
+                    {
+                        static void Main(string[] args)
+                        {
+                            #if ENABLE_MIDDLEWARE
+                                var host = new HostBuilder()
+                                    .ConfigureFunctionsWebApplication(builder =>
+                                    {
+                                        // can still register middleware and use this extension method the same way
+                                        // .ConfigureFunctionsWorkerDefaults() is used
+                                        builder.UseWhen<RoutingMiddleware>((context)=>
+                                        {
+                                            // We want to use this middleware only for http trigger invocations.
+                                            return context.FunctionDefinition.InputBindings.Values
+                                                            .First(a => a.Type.EndsWith(""Trigger"")).Type == ""httpTrigger"";
+                                        });
+                                    })
+                                    .Build();
+                                host.Run();
+                            #else
+                                //<docsnippet_aspnet_registration>
+                                var host = new HostBuilder()
+                                    .ConfigureFunctionsWebApplication()
+                                    .Build();
+
+                                host.Run();
+                                //</docsnippet_aspnet_registration>
+                            #endif
+                        }
+                    }
+                }";
+
+            var test = new AnalyzerTest
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net60.WithPackages(ImmutableArray.Create(
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker", "1.19.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Sdk", "1.14.1"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs", "6.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore", "1.0.0"),
+                    new PackageIdentity("Microsoft.Azure.Functions.Worker.Extensions.Abstractions", "5.0.0"),
+                    new PackageIdentity("Microsoft.Extensions.Hosting.Abstractions", "6.0.0")
+                    )),
+
+                TestCode = testCode
+            };
+
+            // test.ExpectedDiagnostics is an empty collection.
+
+            await test.RunAsync();
+        }
+    }
+}