Address review comments

Author: MartyIX

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

@@ -54,6 +54,30 @@ public Test(string s, int b)
             await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestConstructorInheritsImplicitlyFromSystemObjectAsync()
+        {
+            var testCode = @"class Test
+{
+    /// <inheritdoc />
+    public Test() { }
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestConstructorInheritsExplicitlyFromSystemObjectAsync()
+        {
+            var testCode = @"class Test : System.Object
+{
+    /// <inheritdoc />
+    public Test() { }
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestClassOverridesClassAsync()
         {
@@ -126,7 +150,6 @@ public async Task TestTypeWithEmptyBaseListAndCrefAttributeAsync(string declarat
         }
 
         [Theory]
-        [InlineData("Test() { }")]
         [InlineData("void Foo() { }")]
         [InlineData("string foo;")]
         [InlineData("string Foo { get; set; }")]

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

@@ -148,51 +148,24 @@ private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context)
 
             ISymbol declaredSymbol = context.SemanticModel.GetDeclaredSymbol(memberSyntax, context.CancellationToken);
 
-            if (memberSyntax is ConstructorDeclarationSyntax constructorDeclarationSyntax)
+            if (memberSyntax is ConstructorDeclarationSyntax constructorDeclarationSyntax && declaredSymbol is IMethodSymbol constructorMethodSymbol)
             {
-                if (declaredSymbol is IMethodSymbol constructorMethodSymbol && constructorMethodSymbol.ContainingType is INamedTypeSymbol enclosingNamedTypeSymbol)
+                if (constructorMethodSymbol.ContainingType is INamedTypeSymbol enclosingNamedTypeSymbol)
                 {
                     INamedTypeSymbol baseType = enclosingNamedTypeSymbol.BaseType;
 
-                    if (baseType.SpecialType != SpecialType.System_Object)
+                    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)
+                        // Exception: If the base type is System.Object, then we can use <inheritdoc/> if our constructor has zero parameters.
+                        if (constructorMethodSymbol.Parameters.Length == 0)
                         {
                             return;
                         }
                     }
+                    else if (HasMatchingSignature(baseType.Constructors, constructorMethodSymbol))
+                    {
+                        return;
+                    }
                 }
             }
 
@@ -253,6 +226,48 @@ private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context)
             }
         }
 
+        /// <summary>
+        /// Method compares a <paramref name="constructorMethodSymbol">constructor method</paramref> signature against its
+        /// <paramref name="baseConstructorSymbols">base type constructors</paramref> to find if there is a method signature match.
+        /// </summary>
+        /// <returns><see langword="true"/> if any base type constructor's signature matches the signature of <paramref name="constructorMethodSymbol"/>, <see langword="false"/> otherwise.</returns>
+        private static bool HasMatchingSignature(ImmutableArray<IMethodSymbol> baseConstructorSymbols, IMethodSymbol constructorMethodSymbol)
+        {
+            bool found = false;
+
+            foreach (IMethodSymbol baseConstructorMethod in baseConstructorSymbols)
+            {
+                // 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)
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            return found;
+        }
+
         private static bool HasXmlCrefAttribute(XmlNodeSyntax inheritDocElement)
         {
             XmlElementSyntax? xmlElementSyntax = inheritDocElement as XmlElementSyntax;