Improve implementation

Author: MartyIX

StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1648UnitTests.cs

@@ -23,6 +23,7 @@ public async Task TestConstructorInheritsFromParentAsync()
         {
             var testCode = @"class Base
 {
+    /// <summary>Base constructor.</summary>
     public Base() { }
 }
 
@@ -33,6 +34,22 @@ public Test() { }
 }";
 
             await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+
+            testCode = @"class Base
+{
+    /// <summary>Base constructor.</summary>
+    public Base(string s, int a) { }
+}
+
+class Test : Base
+{
+    /// <inheritdoc />
+    public Test(string s, int b)
+        : base(s, b) { }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
         [Fact]

StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1648InheritDocMustBeUsedWithInheritingClass.cs

@@ -161,7 +161,6 @@ private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context)
 
             if (memberSyntax is ConstructorDeclarationSyntax constructorDeclarationSyntax)
             {
-                // ConstructorInitializerSyntax initializer = constructorDeclarationSyntax.Initializer;
                 ISymbol symbol = context.SemanticModel.GetDeclaredSymbol(constructorDeclarationSyntax, context.CancellationToken);
 
                 if (symbol is IMethodSymbol constructorMethodSymbol && constructorMethodSymbol.ContainingType is INamedTypeSymbol enclosingNamedTypeSymbol)
@@ -170,14 +169,41 @@ private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context)
 
                     if (baseType.SpecialType != SpecialType.System_Object)
                     {
+                        bool foundMatchingConstructorsToInheritFrom = false;
+
                         foreach (IMethodSymbol baseConstructorMethod in baseType.Constructors)
                         {
-                            // TODO: SymbolEqualityComparer?
-                            if (constructorMethodSymbol.Parameters.SequenceEqual(baseConstructorMethod.Parameters))
+                            // Constructors must have the same number of parameters.
+                            if (constructorMethodSymbol.Parameters.Count() != baseConstructorMethod.Parameters.Count())
+                            {
+                                continue;
+                            }
+
+                            // Our constructor and the base constructor must have the same signature. But variable names can be different.
+                            bool success = true;
+
+                            for (int i = 0; i < constructorMethodSymbol.Parameters.Length; i++)
                             {
-                                // Matching constructor was found.
-                                return;
+                                IParameterSymbol constructorParameter = constructorMethodSymbol.Parameters[i];
+                                IParameterSymbol baseParameter = baseConstructorMethod.Parameters[i];
+
+                                if (!constructorParameter.Type.Equals(baseParameter.Type))
+                                {
+                                    success = false;
+                                    break;
+                                }
                             }
+
+                            if (success)
+                            {
+                                foundMatchingConstructorsToInheritFrom = true;
+                                break;
+                            }
+                        }
+
+                        if (foundMatchingConstructorsToInheritFrom)
+                        {
+                            return;
                         }
                     }
                 }