From ddb284800b20ef1665f03122b1766a69107e1b88 Mon Sep 17 00:00:00 2001
From: Bart Koelman <10324372+bkoelman@users.noreply.github.com>
Date: Sat, 20 Apr 2024 15:08:07 +0200
Subject: [PATCH] AV1551: Ignore CancellationToken parameter in ordering, which
 always comes last by convention (#158)

---
 .../OverloadShouldCallOtherOverloadSpecs.cs   | 81 +++++++++++++++++++
 ...OverloadShouldCallOtherOverloadAnalyzer.cs |  7 +-
 2 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Maintainability/OverloadShouldCallOtherOverloadSpecs.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Maintainability/OverloadShouldCallOtherOverloadSpecs.cs
index 1e6a4f7..7aa1165 100644
--- a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Maintainability/OverloadShouldCallOtherOverloadSpecs.cs
+++ b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Maintainability/OverloadShouldCallOtherOverloadSpecs.cs
@@ -837,6 +837,87 @@ protected virtual bool M(string value, int index, bool flag, params object[] arg
             "Parameter order in 'C.M(int, string, params object[])' does not match with the parameter order of the longest overload");
     }
 
+    [Fact]
+    internal async Task When_parameter_order_in_overloads_is_consistent_with_CancellationToken_it_must_be_skipped()
+    {
+        // Arrange
+        ParsedSourceCode source = new TypeSourceCodeBuilder()
+            .Using(typeof(CancellationToken).Namespace)
+            .InGlobalScope("""
+                public class C
+                {
+                    public bool M()
+                    {
+                        return M(CancellationToken.None);
+                    }
+                
+                    public bool M(CancellationToken cancellationToken)
+                    {
+                        return M(string.Empty, cancellationToken);
+                    }
+                
+                    public bool M(string value, CancellationToken cancellationToken)
+                    {
+                        return M(value, -1, cancellationToken);
+                    }
+                
+                    public bool M(string value, int index, CancellationToken cancellationToken)
+                    {
+                        return M(value, index, false, cancellationToken);
+                    }
+                
+                    protected virtual bool M(string value, int index, bool flag, CancellationToken cancellationToken)
+                    {
+                        throw new NotImplementedException();
+                    }
+                }
+                """)
+            .Build();
+
+        await VerifyGuidelineDiagnosticAsync(source);
+    }
+
+    [Fact]
+    internal async Task When_parameter_order_in_overloads_is_not_consistent_with_CancellationToken_it_must_be_reported()
+    {
+        // Arrange
+        ParsedSourceCode source = new TypeSourceCodeBuilder()
+            .Using(typeof(CancellationToken).Namespace)
+            .InGlobalScope("""
+                public class C
+                {
+                    public bool M()
+                    {
+                        return M(CancellationToken.None);
+                    }
+                
+                    public bool M(CancellationToken cancellationToken)
+                    {
+                        return M(string.Empty, cancellationToken);
+                    }
+                
+                    public bool M(string value, CancellationToken cancellationToken)
+                    {
+                        return M(-1, value, cancellationToken);
+                    }
+                
+                    public bool [|M|](int index, string value, CancellationToken cancellationToken)
+                    {
+                        return M(value, index, false, cancellationToken);
+                    }
+                
+                    protected virtual bool M(string value, int index, bool flag, CancellationToken cancellationToken)
+                    {
+                        throw new NotImplementedException();
+                    }
+                }
+                """)
+            .Build();
+
+        await VerifyGuidelineDiagnosticAsync(source,
+            "Parameter order in 'C.M(int, string, CancellationToken)' does not match with the parameter order of the longest overload");
+    }
+
     [Fact]
     internal async Task When_parameter_order_in_overloads_is_consistent_with_optional_parameters_it_must_be_skipped()
     {
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/OverloadShouldCallOtherOverloadAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/OverloadShouldCallOtherOverloadAnalyzer.cs
index 88d4f33..373b236 100644
--- a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/OverloadShouldCallOtherOverloadAnalyzer.cs
+++ b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/OverloadShouldCallOtherOverloadAnalyzer.cs
@@ -216,7 +216,12 @@ private static void CompareOrderOfParameters([NotNull] IMethodSymbol method, [No
 
     private static bool IsRegularParameter([NotNull] IParameterSymbol parameter)
     {
-        return parameter is { HasExplicitDefaultValue: false, IsParams: false };
+        return parameter is { HasExplicitDefaultValue: false, IsParams: false } && !IsCancellationToken(parameter.Type);
+    }
+
+    private static bool IsCancellationToken([NotNull] ITypeSymbol type)
+    {
+        return type.ToDisplayString() == "System.Threading.CancellationToken";
     }
 
     private static bool AreDefaultParametersDeclaredInSameOrder([NotNull] IMethodSymbol method,