Fix S4144 FP: when type constraints are used

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

@@ -40,10 +40,10 @@ 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<ParameterSyntax>(model, firstMethod.ParameterList.Parameters, secondMethod.ParameterList.Parameters)
             && firstMethod.Body.IsEquivalentTo(secondMethod.Body, false);
 
         protected override SyntaxToken GetMethodIdentifier(IMethodDeclaration method) =>

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

@@ -29,7 +29,7 @@ public abstract class MethodsShouldNotHaveIdenticalImplementationsBase<TSyntaxKi
 
         protected abstract IEnumerable<TMethodDeclarationSyntax> GetMethodDeclarations(SyntaxNode node);
         protected abstract SyntaxToken GetMethodIdentifier(TMethodDeclarationSyntax method);
-        protected abstract bool AreDuplicates(TMethodDeclarationSyntax firstMethod, TMethodDeclarationSyntax secondMethod);
+        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}'.";
 
@@ -50,7 +50,7 @@ protected override void Initialize(SonarAnalysisContext context) =>
                     {
                         var method = methodsToHandle.First.Value;
                         methodsToHandle.RemoveFirst();
-                        var duplicates = methodsToHandle.Where(x => AreDuplicates(method, x)).ToList();
+                        var duplicates = methodsToHandle.Where(x => AreDuplicates(c.SemanticModel, method, x)).ToList();
 
                         foreach (var duplicate in duplicates)
                         {
@@ -64,12 +64,23 @@ protected override void Initialize(SonarAnalysisContext context) =>
         protected virtual bool IsExcludedFromBeingExamined(SonarSyntaxNodeReportingContext context) =>
             context.ContainingSymbol.Kind != SymbolKind.NamedType;
 
-        protected static bool HaveSameParameters<TSyntax>(SeparatedSyntaxList<TSyntax>? leftParameters, SeparatedSyntaxList<TSyntax>? rightParameters)
+        protected static bool HaveSameParameters<TSyntax>(SemanticModel model, 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));
+            (leftParameters is null && rightParameters is null) // VB.Net
+            || (leftParameters is { Count: { } leftCount } leftParams
+                && rightParameters is { Count: { } rightCount } rightParams
+                && leftCount == rightCount
+                && (leftCount == 0 || HaveSameParameterLists(model, leftParams, rightParams)));
+
+        private static bool HaveSameParameterLists<TSyntax>(SemanticModel model,
+                                                            SeparatedSyntaxList<TSyntax> leftParameters,
+                                                            SeparatedSyntaxList<TSyntax> rightParameters) where TSyntax : SyntaxNode =>
+            leftParameters.Zip(rightParameters, (left, right) => left.IsEquivalentTo(right)).All(x => x)                    // Perf: Syntactic equivalence for all parameters first
+            && leftParameters.Zip(rightParameters, (left, right) => HaveSameParameterType(model, left, right)).All(x => x); // Also make sure the parameter types are same
+
+        private static bool HaveSameParameterType(SemanticModel model, SyntaxNode left, SyntaxNode right) =>
+            model.GetDeclaredSymbol(left) is IParameterSymbol { Type: { } leftParameterType }
+            && model.GetDeclaredSymbol(right) is IParameterSymbol { Type: { } rightParameterType }
+            && leftParameterType.Equals(rightParameterType);
     }
 }

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

@@ -30,10 +30,10 @@ 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())
+            && HaveSameParameters(model, firstMethod.GetParameters(), secondMethod.GetParameters())
             && VisualBasicEquivalenceChecker.AreEquivalent(firstMethod.Statements, secondMethod.Statements);
 
         protected override SyntaxToken GetMethodIdentifier(MethodBlockSyntax method) =>

analyzers/tests/SonarAnalyzer.Test/TestCases/MethodsShouldNotHaveIdenticalImplementations.CSharp9.cs

@@ -95,13 +95,13 @@ public static class TypeConstraints
 
     public static int Use<T>(T? value) where T : class => 2;
 
-    public static void First<T>(T? value) where T : struct // Secondary
+    public static void First<T>(T? value) where T : struct
     {
         var x = Use(value);
         Console.WriteLine(x);
     }
 
-    public static void Second<T>(T? value) where T : class  // Noncompliant - FP, method looks the same but different overloads are called due to the type constraints used. See: https://github.com/SonarSource/sonar-dotnet/issues/7068
+    public static void Second<T>(T? value) where T : class  // Compliant, method looks the same but different overloads are called due to the type constraints used. See: https://github.com/SonarSource/sonar-dotnet/issues/7068
     {
         var x = Use(value);
         Console.WriteLine(x);