Merge pull request #2 from PandaTechAM/development

bug fixes

Author: HaikAsatryan

src/Analyzers/Analyzers.csproj

@@ -18,7 +18,7 @@
         <PackageId>Pandatech.Analyzers</PackageId>
         <PackageIcon>pandatech.png</PackageIcon>
         <PackageReadmeFile>Readme.md</PackageReadmeFile>
-        <Version>1.1.0</Version>
+        <Version>1.2.0</Version>
         <Authors>Pandatech</Authors>
         <Description>Pandatech Roslyn analyzers enforcing company coding rules.</Description>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/Analyzers/Async/AsyncMethodConventionsAnalyzer.cs

@@ -224,11 +224,23 @@ private static CtInfo GetCancellationTokenInfo(IMethodSymbol method)
       }
 
       var isNamedCt = string.Equals(ctParam.Name, "ct", StringComparison.Ordinal);
-      var isLast = ctParam.Ordinal == parameters.Length - 1;
+
+      // "Last" means: last non-params parameter (params must stay physically last)
+      var lastNonParamsIndex = -1;
+      for (var i = 0; i < parameters.Length; i++)
+      {
+         if (!parameters[i].IsParams)
+         {
+            lastNonParamsIndex = i;
+         }
+      }
+
+      var isLast = ctParam.Ordinal == lastNonParamsIndex;
 
       return new CtInfo(true, isNamedCt, isLast, ctParam.Name);
    }
 
+
    private readonly struct CtInfo(bool hasCt, bool isNamedCt, bool isLast, string name)
    {
       public bool HasCt { get; } = hasCt;

src/Analyzers/Async/AsyncMethodConventionsCodeFixProvider.cs

@@ -418,17 +418,40 @@ private static async Task<Document> AddCancellationTokenAsync(Document document,
          newRoot = newRoot.AddUsings(usingDirective);
       }
 
+      var parameters = methodDecl.ParameterList.Parameters;
+
       var ctType = SyntaxFactory.IdentifierName("CancellationToken");
       var ctParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier("ct"))
-                                 .WithType(ctType);
+                                 .WithType(ctType)
+                                 .WithDefault(
+                                    SyntaxFactory.EqualsValueClause(
+                                       SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)));
+
+      // Insert CT before any params parameter; otherwise at the end.
+      var insertIndex = parameters.Count;
+      for (var i = 0; i < parameters.Count; i++)
+      {
+         if (!parameters[i]
+              .Modifiers
+              .Any(SyntaxKind.ParamsKeyword))
+         {
+            continue;
+         }
+
+         insertIndex = i;
+         break;
+      }
 
-      var newParamList = methodDecl.ParameterList.AddParameters(ctParam);
-      var newMethod = methodDecl.WithParameterList(newParamList);
+      var newParameters = parameters.Insert(insertIndex, ctParam);
+
+      var newMethod = methodDecl.WithParameterList(
+         methodDecl.ParameterList.WithParameters(newParameters));
 
       newRoot = newRoot.ReplaceNode(methodDecl, newMethod);
       return document.WithSyntaxRoot(newRoot);
    }
 
+
    private static bool HasSystemThreadingUsing(CompilationUnitSyntax root)
    {
       foreach (var u in root.Usings)
@@ -468,14 +491,61 @@ private static async Task<Document> MoveCancellationTokenToLastAsync(Document do
          break;
       }
 
-      if (ctIndex < 0 || ctIndex == parameters.Count - 1)
+      if (ctIndex < 0)
+      {
+         return document;
+      }
+
+      // Find params parameter (if any)
+      var paramsIndex = -1;
+      for (var i = 0; i < parameters.Count; i++)
+      {
+         if (!parameters[i]
+              .Modifiers
+              .Any(SyntaxKind.ParamsKeyword))
+         {
+            continue;
+         }
+
+         paramsIndex = i;
+         break;
+      }
+
+      // Already in the correct spot?
+      var alreadyCorrect =
+         (paramsIndex < 0 && ctIndex == parameters.Count - 1) ||
+         (paramsIndex >= 0 && ctIndex == paramsIndex - 1);
+
+      if (alreadyCorrect)
       {
          return document;
       }
 
       var ctSyntax = parameters[ctIndex];
-      var newParameters = parameters.RemoveAt(ctIndex)
-                                    .Add(ctSyntax);
+      var withoutCt = parameters.RemoveAt(ctIndex);
+
+      // Recompute params index after removal
+      var newParamsIndex = -1;
+      for (var i = 0; i < withoutCt.Count; i++)
+      {
+         if (!withoutCt[i]
+              .Modifiers
+              .Any(SyntaxKind.ParamsKeyword))
+         {
+            continue;
+         }
+
+         newParamsIndex = i;
+         break;
+      }
+
+      // Insert CT just before params
+      var newParameters =
+         newParamsIndex >= 0
+            ? withoutCt.Insert(newParamsIndex, ctSyntax)
+            :
+            // No params -> CT becomes last
+            withoutCt.Add(ctSyntax);
 
       var newMethod = methodDecl.WithParameterList(
          methodDecl.ParameterList.WithParameters(newParameters));
@@ -491,6 +561,7 @@ private static async Task<Document> MoveCancellationTokenToLastAsync(Document do
       return document.WithSyntaxRoot(newRoot);
    }
 
+
    // ----------------------------------------------------------------------
    // Syntax-level helpers – lambdas / anonymous functions
    // ----------------------------------------------------------------------
@@ -659,20 +730,34 @@ private static async Task<Solution> AddCancellationTokenForInterfaceAndImplement
                   }
                }
 
-               // Build parameter differently for interface vs implementation
-               var ctParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier("ct"))
-                                          .WithType(ctType);
+               var parameters = original.ParameterList.Parameters;
 
-               if (original.Parent is InterfaceDeclarationSyntax)
+               // Always: CancellationToken ct = default
+               var ctParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier("ct"))
+                                          .WithType(ctType)
+                                          .WithDefault(
+                                             SyntaxFactory.EqualsValueClause(
+                                                SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)));
+
+               // Insert CT before any params parameter; otherwise at the end.
+               var insertIndex = parameters.Count;
+               for (var i = 0; i < parameters.Count; i++)
                {
-                  // interface: CancellationToken ct = default
-                  ctParam = ctParam.WithDefault(
-                     SyntaxFactory.EqualsValueClause(
-                        SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)));
+                  if (!parameters[i]
+                       .Modifiers
+                       .Any(SyntaxKind.ParamsKeyword))
+                  {
+                     continue;
+                  }
+
+                  insertIndex = i;
+                  break;
                }
 
-               var newParamList = original.ParameterList.AddParameters(ctParam);
-               return original.WithParameterList(newParamList);
+               var newParameters = parameters.Insert(insertIndex, ctParam);
+
+               return original.WithParameterList(
+                  original.ParameterList.WithParameters(newParameters));
             });
 
          solution = solution.WithDocumentSyntaxRoot(docId, updatedRoot);
@@ -705,21 +790,9 @@ private static async Task<Solution> MoveCancellationTokenToLastForInterfaceAndIm
       }
 
       var methodsByDocument = new Dictionary<DocumentId, ImmutableArray<MethodDeclarationSyntax>.Builder>();
-      var ctIndexBySyntax = new Dictionary<MethodDeclarationSyntax, int>();
 
       foreach (var method in allMethods)
       {
-         var ctParam = method.Parameters.FirstOrDefault(p => IsCancellationToken(p.Type));
-         if (ctParam is null)
-         {
-            continue;
-         }
-
-         if (ctParam.Ordinal == method.Parameters.Length - 1)
-         {
-            continue;
-         }
-
          foreach (var syntaxRef in method.DeclaringSyntaxReferences)
          {
             var syntax = await syntaxRef.GetSyntaxAsync(cancellationToken)
@@ -744,7 +817,6 @@ private static async Task<Solution> MoveCancellationTokenToLastForInterfaceAndIm
             }
 
             list.Add(methodDecl);
-            ctIndexBySyntax[methodDecl] = ctParam.Ordinal;
          }
       }
 
@@ -770,20 +842,69 @@ private static async Task<Solution> MoveCancellationTokenToLastForInterfaceAndIm
             methodDecls,
             (original, _) =>
             {
-               if (!ctIndexBySyntax.TryGetValue(original, out var ctIndex))
+               var parameters = original.ParameterList.Parameters;
+
+               // Find CT parameter syntax
+               var ctIndex = -1;
+               for (var i = 0; i < parameters.Count; i++)
+               {
+                  var p = parameters[i];
+                  if (p.Type is IdentifierNameSyntax id &&
+                      string.Equals(id.Identifier.Text, "CancellationToken", StringComparison.Ordinal))
+                  {
+                     ctIndex = i;
+                     break;
+                  }
+               }
+
+               if (ctIndex < 0)
                {
                   return original;
                }
 
-               var parameters = original.ParameterList.Parameters;
-               if (ctIndex < 0 || ctIndex >= parameters.Count || ctIndex == parameters.Count - 1)
+               // Find params parameter
+               var paramsIndex = -1;
+               for (var i = 0; i < parameters.Count; i++)
+               {
+                  if (parameters[i]
+                      .Modifiers
+                      .Any(SyntaxKind.ParamsKeyword))
+                  {
+                     paramsIndex = i;
+                     break;
+                  }
+               }
+
+               var alreadyCorrect =
+                  (paramsIndex < 0 && ctIndex == parameters.Count - 1) ||
+                  (paramsIndex >= 0 && ctIndex == paramsIndex - 1);
+
+               if (alreadyCorrect)
                {
                   return original;
                }
 
                var ctSyntax = parameters[ctIndex];
-               var newParameters = parameters.RemoveAt(ctIndex)
-                                             .Add(ctSyntax);
+               var withoutCt = parameters.RemoveAt(ctIndex);
+
+               // Recompute params index after removal
+               var newParamsIndex = -1;
+               for (var i = 0; i < withoutCt.Count; i++)
+               {
+                  if (!withoutCt[i]
+                       .Modifiers
+                       .Any(SyntaxKind.ParamsKeyword))
+                  {
+                     continue;
+                  }
+
+                  newParamsIndex = i;
+                  break;
+               }
+
+               var newParameters = newParamsIndex >= 0
+                  ? withoutCt.Insert(newParamsIndex, ctSyntax)
+                  : withoutCt.Add(ctSyntax);
 
                return original.WithParameterList(
                   original.ParameterList.WithParameters(newParameters));

test/Analyzers.Sample/Async/Examples1.cs

@@ -18,6 +18,8 @@ public interface IOrderService
 
    // ❌ PT0002 (CT is not last, name is wrong)
    Task<Order> GetOrderByCodeAsync(CancellationToken token, string code);
+   Task<Order> GetSomethingAsync(params string[] args);
+   Task<Order> GetMeAsync(int id = 5, params object[] args);
 }
 
 public sealed class OrderService : IOrderService
@@ -38,6 +40,16 @@ public Task<Order> GetOrderByCodeAsync(CancellationToken token, string code)
       return Task.FromResult(new Order(42));
       // PT0002
    }
+
+   public Task<Order> GetSomethingAsync(params string[] args)
+   {
+      throw new System.NotImplementedException();
+   }
+
+   public Task<Order> GetMeAsync(int id = 5, params object[] args)
+   {
+      throw new System.NotImplementedException();
+   }
 }
 
 // Simulated controller-style class.