Analyzer to detect missing ASP.NET Core integration registration

DotNetWorker.sln

@@ -136,6 +136,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DependentAssemblyWithFuncti
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Worker.Extensions.Http.AspNetCore.Tests", "test\extensions\Worker.Extensions.Http.AspNetCore.Tests\Worker.Extensions.Http.AspNetCore.Tests.csproj", "{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Worker.Extensions.Http.AspNetCore.Analyzers", "extensions\Worker.Extensions.Http.AspNetCore.Analyzers\Worker.Extensions.Http.AspNetCore.Analyzers.csproj", "{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -334,6 +336,10 @@ Global
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -397,6 +403,7 @@ Global
 		{D2F67410-9933-42E8-B04A-E17634D83A30} = {9D6603BD-7EA2-4D11-A69C-0D9E01317FD6}
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753} = {B5821230-6E0A-4535-88A9-ED31B6F07596}
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4} = {AA4D318D-101B-49E7-A4EC-B34165AEDB33}
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B} = {A7B4FF1E-3DF7-4F28-9333-D0961CDDF702}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {497D2ED4-A13E-4BCA-8D29-F30CA7D0EA4A}

docs/analyzer-rules/AZFW0014.md

@@ -0,0 +1,25 @@
+# AZFW0011: Missing Registration for ASP.NET Core Integration
+
+| | Value |
+|-|-|
+| **Rule ID** |AZFW00014|
+| **Category** |[Usage]|
+| **Severity** |Error|
+
+## Cause
+
+This rule is triggered when worker using the ASP.NET Core Integration uses `ConfigureFunctionsWorkerDefaults()`.
+
+## Rule description
+
+When using the ASP.NET Core Integration, the worker must configure the worker using the `ConfigureFunctionsWebApplication()` method. This rule will be violated when the worker uses  `ConfigureFunctionsWorkerDefaults()`.
+
+
+## How to fix violations
+
+Replace usage of `ConfigureFunctionsWorkerDefaults` with  `ConfigureFunctionsWebApplication` method in the 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.
+
+
+## When to suppress
+
+It is okay to suppress this if `ConfigureFunctionsWebApplication` is called indirectly through a different API.

extensions/Worker.Extensions.Http.AspNetCore.Analyzers/DiagnosticDescriptors.cs

@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore
+{
+    internal class DiagnosticDescriptors
+    {
+        public const string Usage = "Usage";
+
+        private static DiagnosticDescriptor Create(string id, string title, string messageFormat, string category, DiagnosticSeverity severity)
+        {
+            var helpLink = $"https://aka.ms/azfw-rules?ruleid={id}";
+            return new DiagnosticDescriptor(id, title, messageFormat, category, severity, isEnabledByDefault: true, helpLinkUri: helpLink);
+        }
+
+        public static DiagnosticDescriptor CorrectRegistrationExpectedInAspNetIntegration { get; }
+            = Create(id: "AZFW0014", title: "Missing expected registration of ASP.NET Core Integration services", messageFormat: "The registration for method '{0}' is expected for ASP.NET Core Integration.",
+                category: Usage, severity: DiagnosticSeverity.Error);
+    }
+}

extensions/Worker.Extensions.Http.AspNetCore.Analyzers/RegistrationExpectedInASPNetIntegration.cs

@@ -0,0 +1,95 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore
+{
+    /// <summary>
+    /// Analyzer to verify whether expected registration is present for ASP.NET Core Integration.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class RegistrationExpectedInASPNetIntegration : DiagnosticAnalyzer
+    {
+        /// Diagnostics supported by the analyzer
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DiagnosticDescriptors.CorrectRegistrationExpectedInAspNetIntegration);
+
+        private const string ExpectedRegistrationMethod = "ConfigureFunctionsWebApplication";
+        private const string IncorrectRegistrationMethod = "ConfigureFunctionsWorkerDefaults";
+
+        /// Initialization method
+        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;
+
+            if (!IsMainMethod(symbol))
+            {
+                return;
+            }
+
+            var syntaxReference = symbol.DeclaringSyntaxReferences.FirstOrDefault();
+            var root = syntaxReference?.SyntaxTree.GetRoot();
+            var methodCallExpressions = root?.DescendantNodes().OfType<InvocationExpressionSyntax>();
+
+            var expectedMethodInvocationPresent = methodCallExpressions?.Any(invocation => (invocation.Expression as MemberAccessExpressionSyntax)?.Name.Identifier.ValueText == ExpectedRegistrationMethod);
+
+            var incorrectMethodCallExpressions = methodCallExpressions?.Where(invocation => (invocation.Expression as MemberAccessExpressionSyntax)?.Name.Identifier.ValueText == IncorrectRegistrationMethod);
+            var incorrectMethodInvocationPresent = incorrectMethodCallExpressions?.Any();
+
+            if (!(bool)incorrectMethodInvocationPresent)
+            {
+                return;
+            }
+
+            //Finding exact location of method call
+            Location location = GetSymbolLocation(root, incorrectMethodCallExpressions);
+
+            if (!(bool)expectedMethodInvocationPresent)
+            {
+                var diagnostic = Diagnostic.Create(DiagnosticDescriptors.CorrectRegistrationExpectedInAspNetIntegration, location, ExpectedRegistrationMethod);
+                context.ReportDiagnostic(diagnostic);
+            }
+        }
+
+        // Checks if a method symbol is a Main method. This also checks for implicit main in top-level statements
+        private static bool IsMainMethod(IMethodSymbol symbol)
+        {
+            return symbol?.IsStatic == true && symbol.Name switch
+            {
+                "Main" => true,
+                "$Main" => true,
+                "<Main>$" => true,
+                _ => false
+            };
+        }
+
+        private static Location GetSymbolLocation(SyntaxNode root, IEnumerable<InvocationExpressionSyntax> methodCallExpressions)
+        {
+            Location location = Location.None;
+
+            if (methodCallExpressions != null)
+            {
+                var lineSpan = methodCallExpressions.FirstOrDefault().GetLocation().SourceSpan;
+                var node = root.DescendantNodes(lineSpan)
+                            .First(n => lineSpan.Contains(n.FullSpan)).DescendantNodes()
+                            .OfType<IdentifierNameSyntax>().FirstOrDefault(c => c.Identifier.Text == IncorrectRegistrationMethod);
+
+                location = node.GetLocation();
+            }
+
+            return location;
+        }
+    }
+}

extensions/Worker.Extensions.Http.AspNetCore.Analyzers/Worker.Extensions.Http.AspNetCore.Analyzers.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <VersionPrefix>1.0.0</VersionPrefix>
+        <OutputType>Library</OutputType>
+        <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
+        <IncludeBuildOutput>false</IncludeBuildOutput>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <PackageId>Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore.Analyzers</PackageId>
+        <Description>This package provides development time code analysis for ASP.NET Core extensions for .NET isolated functions.</Description>
+        <AssemblyName>Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore.Analyzers</AssemblyName>
+        <RootNamespace>Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore.Analyzers</RootNamespace>
+        <Nullable>disable</Nullable>
+        <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage);_AddAnalyzersToOutput</TargetsForTfmSpecificContentInPackage>
+    </PropertyGroup>
+
+    <Import Project="..\..\build\Common.props" />
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.11.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="1.1.1" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="1.1.1" />
+    </ItemGroup>
+
+    <Target Name="_AddAnalyzersToOutput">
+        <ItemGroup>
+            <TfmSpecificPackageFile Include="$(OutputPath)\Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore.Analyzers.dll" PackagePath="analyzers/dotnet/cs" />
+        </ItemGroup>
+    </Target>
+</Project>

extensions/Worker.Extensions.Http.AspNetCore/release_notes.md

@@ -7,3 +7,7 @@
 ### Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore <version>
 
 - New overload added to `ConfigureFunctionsWebApplication` to take a `HostBuilderContext` (#1925). Thank you @vmcbaptista
+
+### Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore.Analyzers
+
+- Analyzer to detect missing ASP.NET Core Integration registration (#1917)

extensions/Worker.Extensions.Http.AspNetCore/src/Worker.Extensions.Http.AspNetCore.csproj

@@ -18,6 +18,7 @@
     <ProjectReference Include="..\..\..\src\DotNetWorker\DotNetWorker.csproj" />
     <ProjectReference Include="..\..\Worker.Extensions.Abstractions\src\Worker.Extensions.Abstractions.csproj" />
     <ProjectReference Include="..\..\Worker.Extensions.Http\src\Worker.Extensions.Http.csproj" />
+    <ProjectReference Include="..\..\Worker.Extensions.Http.AspNetCore.Analyzers\Worker.Extensions.Http.AspNetCore.Analyzers.csproj" />
   </ItemGroup>
 
 </Project>