Allow inheritdoc for class constructors with base types

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

@@ -1,7 +1,7 @@
 // Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-#nullable disable
+#nullable enable
 
 namespace StyleCop.Analyzers.Test.DocumentationRules
 {
@@ -18,6 +18,40 @@ namespace StyleCop.Analyzers.Test.DocumentationRules
     /// </summary>
     public class SA1648UnitTests
     {
+        [Fact]
+        public async Task TestConstructorInheritsFromParentAsync()
+        {
+            var testCode = @"class Base
+{
+    /// <summary>Base constructor.</summary>
+    public Base() { }
+}
+
+class Test : Base
+{
+    /// <inheritdoc />
+    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]
         public async Task TestClassOverridesClassAsync()
         {

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

@@ -159,6 +159,56 @@ private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context)
                 }
             }
 
+            if (memberSyntax is ConstructorDeclarationSyntax constructorDeclarationSyntax)
+            {
+                ISymbol symbol = context.SemanticModel.GetDeclaredSymbol(constructorDeclarationSyntax, context.CancellationToken);
+
+                if (symbol is IMethodSymbol constructorMethodSymbol && constructorMethodSymbol.ContainingType is INamedTypeSymbol enclosingNamedTypeSymbol)
+                {
+                    INamedTypeSymbol baseType = enclosingNamedTypeSymbol.BaseType;
+
+                    if (baseType.SpecialType != SpecialType.System_Object)
+                    {
+                        bool foundMatchingConstructorsToInheritFrom = false;
+
+                        foreach (IMethodSymbol baseConstructorMethod in baseType.Constructors)
+                        {
+                            // 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++)
+                            {
+                                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;
+                        }
+                    }
+                }
+            }
+
             if (documentation.Content.GetFirstXmlElement(XmlCommentHelper.IncludeXmlTag) is XmlEmptyElementSyntax includeElement)
             {
                 if (declaredSymbol == null)