Fix S4144 FP: when type constraints are used

analyzers/src/SonarAnalyzer.CSharp/Rules/MethodsShouldNotHaveIdenticalImplementations.cs

@@ -40,10 +40,11 @@ protected override IEnumerable<IMethodDeclaration> GetMethodDeclarations(SyntaxN
             ? ((CompilationUnitSyntax)node).GetMethodDeclarations()
             : ((TypeDeclarationSyntax)node).GetMethodDeclarations();
 
-        protected override bool AreDuplicates(IMethodDeclaration firstMethod, IMethodDeclaration secondMethod) =>
+        protected override bool AreDuplicates(SemanticModel model, IMethodDeclaration firstMethod, IMethodDeclaration secondMethod) =>
             firstMethod is { Body: { Statements: { Count: > 1 } } }
             && firstMethod.Identifier.ValueText != secondMethod.Identifier.ValueText
-            && HaveSameParameters<ParameterSyntax>(firstMethod.ParameterList.Parameters, secondMethod.ParameterList.Parameters)
+            && HaveSameParameters(firstMethod.ParameterList?.Parameters, secondMethod.ParameterList?.Parameters)
+            && HaveSameTypeParameters(model, firstMethod.TypeParameterList?.Parameters, secondMethod.TypeParameterList?.Parameters)
             && firstMethod.Body.IsEquivalentTo(secondMethod.Body, false);
 
         protected override SyntaxToken GetMethodIdentifier(IMethodDeclaration method) =>

analyzers/src/SonarAnalyzer.Common/Rules/MethodsShouldNotHaveIdenticalImplementationsBase.cs

@@ -18,58 +18,95 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-namespace SonarAnalyzer.Rules
+namespace SonarAnalyzer.Rules;
+
+public abstract class MethodsShouldNotHaveIdenticalImplementationsBase<TSyntaxKind, TMethodDeclarationSyntax> : SonarDiagnosticAnalyzer<TSyntaxKind>
+    where TSyntaxKind : struct
 {
-    public abstract class MethodsShouldNotHaveIdenticalImplementationsBase<TSyntaxKind, TMethodDeclarationSyntax> : SonarDiagnosticAnalyzer<TSyntaxKind>
-        where TSyntaxKind : struct
-    {
-        private const string DiagnosticId = "S4144";
+    private const string DiagnosticId = "S4144";
 
-        protected abstract TSyntaxKind[] SyntaxKinds { get; }
+    protected abstract TSyntaxKind[] SyntaxKinds { get; }
 
-        protected abstract IEnumerable<TMethodDeclarationSyntax> GetMethodDeclarations(SyntaxNode node);
-        protected abstract SyntaxToken GetMethodIdentifier(TMethodDeclarationSyntax method);
-        protected abstract bool AreDuplicates(TMethodDeclarationSyntax firstMethod, TMethodDeclarationSyntax secondMethod);
+    protected abstract IEnumerable<TMethodDeclarationSyntax> GetMethodDeclarations(SyntaxNode node);
+    protected abstract SyntaxToken GetMethodIdentifier(TMethodDeclarationSyntax method);
+    protected abstract bool AreDuplicates(SemanticModel model, TMethodDeclarationSyntax firstMethod, TMethodDeclarationSyntax secondMethod);
 
-        protected override string MessageFormat => "Update this method so that its implementation is not identical to '{0}'.";
+    protected override string MessageFormat => "Update this method so that its implementation is not identical to '{0}'.";
 
-        protected MethodsShouldNotHaveIdenticalImplementationsBase() : base(DiagnosticId) { }
+    protected MethodsShouldNotHaveIdenticalImplementationsBase() : base(DiagnosticId) { }
 
-        protected override void Initialize(SonarAnalysisContext context) =>
-            context.RegisterNodeAction(Language.GeneratedCodeRecognizer,
-                c =>
+    protected override void Initialize(SonarAnalysisContext context) =>
+        context.RegisterNodeAction(Language.GeneratedCodeRecognizer,
+            c =>
+            {
+                if (IsExcludedFromBeingExamined(c))
                 {
-                    if (IsExcludedFromBeingExamined(c))
-                    {
-                        return;
-                    }
+                    return;
+                }
 
-                    var methodsToHandle = new LinkedList<TMethodDeclarationSyntax>(GetMethodDeclarations(c.Node));
+                var methodsToHandle = new LinkedList<TMethodDeclarationSyntax>(GetMethodDeclarations(c.Node));
 
-                    while (methodsToHandle.Any())
+                while (methodsToHandle.Any())
+                {
+                    var method = methodsToHandle.First.Value;
+                    methodsToHandle.RemoveFirst();
+                    var duplicates = methodsToHandle.Where(x => AreDuplicates(c.SemanticModel, method, x)).ToList();
+
+                    foreach (var duplicate in duplicates)
                     {
-                        var method = methodsToHandle.First.Value;
-                        methodsToHandle.RemoveFirst();
-                        var duplicates = methodsToHandle.Where(x => AreDuplicates(method, x)).ToList();
-
-                        foreach (var duplicate in duplicates)
-                        {
-                            methodsToHandle.Remove(duplicate);
-                            c.ReportIssue(SupportedDiagnostics[0], GetMethodIdentifier(duplicate), [GetMethodIdentifier(method).ToSecondaryLocation()], GetMethodIdentifier(method).ValueText);
-                        }
+                        methodsToHandle.Remove(duplicate);
+                        c.ReportIssue(SupportedDiagnostics[0], GetMethodIdentifier(duplicate), [GetMethodIdentifier(method).ToSecondaryLocation()], GetMethodIdentifier(method).ValueText);
                     }
-                },
-                SyntaxKinds);
-
-        protected virtual bool IsExcludedFromBeingExamined(SonarSyntaxNodeReportingContext context) =>
-            context.ContainingSymbol.Kind != SymbolKind.NamedType;
-
-        protected static bool HaveSameParameters<TSyntax>(SeparatedSyntaxList<TSyntax>? leftParameters, SeparatedSyntaxList<TSyntax>? rightParameters)
-            where TSyntax : SyntaxNode =>
-            (leftParameters == null && rightParameters == null)
-            || (leftParameters != null
-                && rightParameters != null
-                && leftParameters.Value.Count == rightParameters.Value.Count
-                && leftParameters.Value.Select((left, index) => left.IsEquivalentTo(rightParameters.Value[index])).All(x => x));
+                }
+            },
+            SyntaxKinds);
+
+    protected virtual bool IsExcludedFromBeingExamined(SonarSyntaxNodeReportingContext context) =>
+        context.ContainingSymbol.Kind != SymbolKind.NamedType;
+
+    protected static bool HaveSameParameters<TSyntax>(SeparatedSyntaxList<TSyntax>? leftParameters, SeparatedSyntaxList<TSyntax>? rightParameters)
+        where TSyntax : SyntaxNode =>
+        (leftParameters is null && rightParameters is null) // In VB.Net the parameter list can be omitted
+        || (leftParameters?.Count == rightParameters?.Count && HaveSameParameterLists(leftParameters.Value, rightParameters.Value));
+
+    protected static bool HaveSameTypeParameters<TSyntax>(SemanticModel model, SeparatedSyntaxList<TSyntax>? firstTypeParameterList, SeparatedSyntaxList<TSyntax>? secondTypeParameterList)
+        where TSyntax : SyntaxNode
+    {
+        var firstSymbols = firstTypeParameterList?.Select(x => model.GetDeclaredSymbol(x)).OfType<ITypeParameterSymbol>() ?? [];
+        var secondSymbols = secondTypeParameterList?.Select(x => model.GetDeclaredSymbol(x)).OfType<ITypeParameterSymbol>().ToArray() ?? [];
+        return firstSymbols.All(x => Array.Exists(secondSymbols, secondSymbol => TypesAreSame(x, secondSymbol)));
     }
+
+    private static bool HaveSameParameterLists<TSyntax>(SeparatedSyntaxList<TSyntax> leftParameters,
+                                                        SeparatedSyntaxList<TSyntax> rightParameters) where TSyntax : SyntaxNode =>
+        leftParameters.Equals(rightParameters, (left, right) => left.IsEquivalentTo(right)); // Perf: Syntactic equivalence for all parameters
+
+    private static bool TypesAreSame(ITypeSymbol leftParameterType, ITypeSymbol rightParameterType) =>
+        leftParameterType.Equals(rightParameterType) // M1(int x) <-> M2(int x)
+        || TypesAreSameTypeParameters(leftParameterType, rightParameterType) // M1<T>(T x) where T: class <-> M2<T>(T x) where T: class
+                                                                             // T of M1 is a different symbol than T of M2, but if they have the same constraints, they can be interchanged
+        || TypesAreSameGenericType(leftParameterType, rightParameterType); // M1<T>(IEnumerable<T> x) where T: class <-> M2<T>(IEnumerable<T> x) where T: class
+
+    private static bool TypesAreSameGenericType(ITypeSymbol leftParameterType, ITypeSymbol rightParameterType) =>
+        leftParameterType is INamedTypeSymbol { IsGenericType: true } namedTypeLeft
+        && rightParameterType is INamedTypeSymbol { IsGenericType: true } namedTypeRight
+        && namedTypeLeft.TypeArguments.Length == namedTypeRight.TypeArguments.Length
+        && namedTypeLeft.TypeArguments.Equals(namedTypeRight.TypeArguments, (x, y) =>
+            x is ITypeParameterSymbol a
+                ? y is ITypeParameterSymbol b && a.Name == b.Name
+                : TypesAreSame(x, y));
+
+    private static bool TypesAreSameTypeParameters(ITypeSymbol leftParameterType, ITypeSymbol rightParameterType) =>
+        leftParameterType.Equals(rightParameterType) || TypeParametersHaveSameNameAndConstraints(leftParameterType, rightParameterType);
+
+    private static bool TypeParametersHaveSameNameAndConstraints(ITypeSymbol leftParameterType, ITypeSymbol rightParameterType) =>
+        leftParameterType is ITypeParameterSymbol left
+        && rightParameterType is ITypeParameterSymbol right
+        && left.Name == right.Name
+        && left.HasConstructorConstraint == right.HasConstructorConstraint
+        && left.HasReferenceTypeConstraint == right.HasReferenceTypeConstraint
+        && left.HasValueTypeConstraint == right.HasValueTypeConstraint
+        && left.HasUnmanagedTypeConstraint() == right.HasUnmanagedTypeConstraint()
+        && left.ConstraintTypes.Length == right.ConstraintTypes.Length
+        && left.ConstraintTypes.All(x => right.ConstraintTypes.Any(y => TypesAreSame(x, y)));
 }

analyzers/src/SonarAnalyzer.VisualBasic/Rules/MethodsShouldNotHaveIdenticalImplementations.cs

@@ -30,10 +30,11 @@ public sealed class MethodsShouldNotHaveIdenticalImplementations : MethodsShould
         protected override IEnumerable<MethodBlockSyntax> GetMethodDeclarations(SyntaxNode node) =>
             ((TypeBlockSyntax)node).Members.OfType<MethodBlockSyntax>();
 
-        protected override bool AreDuplicates(MethodBlockSyntax firstMethod, MethodBlockSyntax secondMethod) =>
+        protected override bool AreDuplicates(SemanticModel model, MethodBlockSyntax firstMethod, MethodBlockSyntax secondMethod) =>
             firstMethod.Statements.Count > 1
             && firstMethod.GetIdentifierText() != secondMethod.GetIdentifierText()
             && HaveSameParameters(firstMethod.GetParameters(), secondMethod.GetParameters())
+            && HaveSameTypeParameters(model, firstMethod.SubOrFunctionStatement?.TypeParameterList?.Parameters, secondMethod.SubOrFunctionStatement?.TypeParameterList?.Parameters)
             && VisualBasicEquivalenceChecker.AreEquivalent(firstMethod.Statements, secondMethod.Statements);
 
         protected override SyntaxToken GetMethodIdentifier(MethodBlockSyntax method) =>

analyzers/tests/SonarAnalyzer.Test/Rules/AspNet/UseAspNetModelBindingTest.cs

@@ -135,8 +135,7 @@ static void StaticLocalFunction(HttpRequest request)
             }
             """").Verify();
 
-    [TestMethod]
-    [CombinatorialData]
+    [CombinatorialDataTestMethod]
     public void UseAspNetModelBinding_CompliantAccess(
         [DataValues(
             "_ = {0}.Keys",
@@ -293,8 +292,7 @@ public void HandleRequest(HttpRequest request)
             }            
             """").VerifyNoIssues();
 
-    [TestMethod]
-    [CombinatorialData]
+    [CombinatorialDataTestMethod]
     public void UseAspNetModelBinding_InheritanceAccess(
         [DataValues(
             ": Controller",