Merge pull request #3 from PandaTechAM/development

lambda

Author: HaikAsatryan

src/Analyzers/Analyzers.csproj

@@ -18,13 +18,13 @@
         <PackageId>Pandatech.Analyzers</PackageId>
         <PackageIcon>pandatech.png</PackageIcon>
         <PackageReadmeFile>Readme.md</PackageReadmeFile>
-        <Version>1.2.0</Version>
+        <Version>1.4.0</Version>
         <Authors>Pandatech</Authors>
         <Description>Pandatech Roslyn analyzers enforcing company coding rules.</Description>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageTags>Pandatech, analyzers, roslyn, async, cancellation, coding-rules</PackageTags>
         <RepositoryUrl>https://github.com/PandaTechAM/be-lib-analyzers</RepositoryUrl>
-        <PackageReleaseNotes>Bug fix on external interfaces</PackageReleaseNotes>
+        <PackageReleaseNotes>Bug fix on lambdas</PackageReleaseNotes>
 
 
     </PropertyGroup>

src/Analyzers/Async/AsyncMethodConventionsAnalyzer.cs

@@ -61,6 +61,8 @@ public override void Initialize(AnalysisContext context)
 
       context.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);
       context.RegisterOperationAction(AnalyzeAnonymousFunction, OperationKind.AnonymousFunction);
+
+      context.RegisterOperationAction(AnalyzeMinimalApiInvocation, OperationKind.Invocation);
    }
 
    private static void AnalyzeMethod(SymbolAnalysisContext context)
@@ -117,6 +119,7 @@ private static void AnalyzeAnonymousFunction(OperationAnalysisContext context)
       var anon = (IAnonymousFunctionOperation)context.Operation;
       var symbol = anon.Symbol;
 
+      // Only Task / ValueTask
       if (symbol.ReturnType is not INamedTypeSymbol returnType)
       {
          return;
@@ -127,15 +130,43 @@ private static void AnalyzeAnonymousFunction(OperationAnalysisContext context)
          return;
       }
 
+      // For lambdas/anonymous functions we do NOT enforce "must have CT" (PT0002),
+      // because the delegate signature is usually dictated by an external API
+      // (Hangfire, ASP.NET, minimal APIs binder, etc.).
+      // We only normalize name and position if a CT parameter already exists.
+      var ctInfo = GetCancellationTokenInfo(symbol);
+      if (!ctInfo.HasCt)
+      {
+         return;
+      }
+
       const string displayName = "anonymous function";
+      var location = anon.Syntax.GetLocation();
 
-      AnalyzeAsyncMember(
-         symbol,
-         anon.Syntax.GetLocation(),
-         displayName,
-         context.ReportDiagnostic);
+      // PT0003: name must be ct
+      if (!ctInfo.IsNamedCt)
+      {
+         context.ReportDiagnostic(
+            Diagnostic.Create(
+               CancellationTokenNameRule,
+               location,
+               displayName,
+               ctInfo.Name));
+      }
+
+      // PT0004: CT must be last non-params parameter
+      if (!ctInfo.IsLast)
+      {
+         context.ReportDiagnostic(
+            Diagnostic.Create(
+               CancellationTokenPositionRule,
+               location,
+               displayName,
+               ctInfo.Name));
+      }
    }
 
+
    private static void AnalyzeAsyncMember(IMethodSymbol method,
       Location location,
       string displayName,
@@ -240,6 +271,129 @@ private static CtInfo GetCancellationTokenInfo(IMethodSymbol method)
       return new CtInfo(true, isNamedCt, isLast, ctParam.Name);
    }
 
+   private static void AnalyzeMinimalApiInvocation(OperationAnalysisContext context)
+   {
+      var invocation = (IInvocationOperation)context.Operation;
+      var target = invocation.TargetMethod;
+
+      // 1. Is this one of the Minimal API Map* extension methods?
+      if (!IsMinimalApiMapMethod(target))
+      {
+         return;
+      }
+
+      // 2. Find the handler lambda inside the arguments.
+      //    We do NOT rely on arg.Parameter.Type (which is often System.Delegate).
+      IAnonymousFunctionOperation? handlerAnon = null;
+
+      foreach (var arg in invocation.Arguments)
+      {
+         handlerAnon = ExtractAnonymousFunction(arg.Value);
+         if (handlerAnon is not null)
+         {
+            break;
+         }
+      }
+
+      if (handlerAnon is null)
+      {
+         // Handler is a method group or something non-lambda; skip.
+         return;
+      }
+
+      var handlerSymbol = handlerAnon.Symbol;
+
+      // Must be Task/ValueTask-based handler.
+      if (handlerSymbol.ReturnType is not INamedTypeSymbol returnType ||
+          !IsTaskLike(returnType))
+      {
+         return;
+      }
+
+      // 3. Enforce: minimal API handler must have a CancellationToken parameter.
+      var ctInfo = GetCancellationTokenInfo(handlerSymbol);
+      if (ctInfo.HasCt)
+      {
+         // If CT already exists, PT0003/PT0004 are handled by AnalyzeAnonymousFunction.
+         return;
+      }
+
+      const string displayName = "anonymous function";
+
+      context.ReportDiagnostic(
+         Diagnostic.Create(
+            CancellationTokenMissingRule,
+            handlerAnon.Syntax.GetLocation(),
+            displayName));
+   }
+
+
+   private static bool IsMinimalApiMapMethod(IMethodSymbol method)
+   {
+      if (!method.IsExtensionMethod)
+      {
+         return false;
+      }
+
+      // EndpointRouteBuilderExtensions.MapGet / MapPost / MapPut / MapDelete / MapMethods / ...
+      var containingType = method.ContainingType;
+      if (containingType is null)
+      {
+         return false;
+      }
+
+      if (!string.Equals(containingType.Name, "EndpointRouteBuilderExtensions", StringComparison.Ordinal))
+      {
+         return false;
+      }
+
+      var ns = containingType.ContainingNamespace.ToDisplayString();
+      if (!ns.StartsWith("Microsoft.AspNetCore.Builder", StringComparison.Ordinal))
+      {
+         return false;
+      }
+
+      // Limit to the typical Map* names
+      return method.Name is
+         "MapGet" or
+         "MapPost" or
+         "MapPut" or
+         "MapDelete" or
+         "MapPatch" or
+         "MapHead" or
+         "MapOptions" or
+         "MapTrace" or
+         "MapMethods";
+   }
+   
+
+   private static IAnonymousFunctionOperation? ExtractAnonymousFunction(IOperation value)
+   {
+      while (true)
+      {
+         switch (value)
+         {
+            case IAnonymousFunctionOperation anon:
+               return anon;
+
+            case IDelegateCreationOperation
+            {
+               Target: IAnonymousFunctionOperation anon
+            }:
+               return anon;
+
+            case IConversionOperation
+            {
+               Operand: var operand
+            }:
+               value = operand;
+               continue;
+
+            default:
+               return null;
+         }
+      }
+   }
 
    private readonly struct CtInfo(bool hasCt, bool isNamedCt, bool isLast, string name)
    {

test/Analyzers.Tests/AsyncMethodConventionsAnalyzerTests.cs

@@ -170,7 +170,7 @@ public class Service
    }
 
    [Fact]
-   public async Task Anonymous_lambda_missing_ct_reports_PT0002()
+   public async Task Anonymous_lambda_without_ct_is_ignored_when_delegate_has_no_ct()
    {
       const string code = """
                           using System;
@@ -180,14 +180,89 @@ public class Service
                           {
                               public void Register()
                               {
-                                  Func<Task> handler = {|PT0002:async () =>
+                                  Func<Task> handler = async () =>
                                   {
                                       await Task.Delay(10);
-                                  }|};
+                                  };
                               }
                           }
                           """;
 
       await VerifyCS.VerifyAnalyzerAsync(code);
    }
+
+
+   [Fact]
+   public async Task Hangfire_expression_lambda_is_ignored()
+   {
+      const string code = """
+                          using System;
+                          using System.Threading;
+                          using System.Threading.Tasks;
+
+                          public interface IUserManagementIntegrationService
+                          {
+                              Task UpdateAuthenticationHistoryMissingLocationsAsync(CancellationToken ct);
+                          }
+
+                          public static class Jobs
+                          {
+                              public static void Register()
+                              {
+                                  RecurringJob.AddOrUpdate<IUserManagementIntegrationService>(
+                                      "Update Authentication History Missing Locations",
+                                      service => service.UpdateAuthenticationHistoryMissingLocationsAsync(CancellationToken.None),
+                                      "0 * * * *",
+                                      TimeZoneInfo.Utc);
+                              }
+                          }
+
+                          public static class RecurringJob
+                          {
+                              public static void AddOrUpdate<T>(string id, System.Linq.Expressions.Expression<Func<T, Task>> method, string cron, TimeZoneInfo tz) { }
+                          }
+                          """;
+
+      await VerifyCS.VerifyAnalyzerAsync(code);
+   }
+
+   [Fact]
+   public async Task RequestDelegate_lambda_is_ignored()
+   {
+      const string code = """
+                          using System.Threading.Tasks;
+
+                          public static class Extensions
+                          {
+                              public static void Configure(IEndpointConventionBuilder builder)
+                              {
+                                  builder.Add(endpointBuilder =>
+                                  {
+                                      var original = endpointBuilder.RequestDelegate;
+                                      endpointBuilder.RequestDelegate = async context =>
+                                      {
+                                          await original!(context);
+                                      };
+                                  });
+                              }
+                          }
+
+                          public interface IEndpointConventionBuilder
+                          {
+                              void Add(System.Action<EndpointBuilder> convention);
+                          }
+
+                          public class EndpointBuilder
+                          {
+                              public RequestDelegate? RequestDelegate { get; set; }
+                          }
+
+                          // Fake ASP.NET-like types just for the test
+                          public class HttpContext { }
+
+                          public delegate Task RequestDelegate(HttpContext context);
+                          """;
+
+      await VerifyCS.VerifyAnalyzerAsync(code);
+   }
 }