Update SA1110 to also check the primary constructor argument list in a base list

#3784

Author: bjornhellander

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/ReadabilityRules/SA1110CSharp9UnitTests.cs

@@ -56,10 +56,95 @@ public async Task TestPrimaryConstructorWithParametersAsync(string typeKeyword)
             await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Theory]
+        [MemberData(nameof(CommonMemberData.ReferenceTypeKeywordsWhichSupportPrimaryConstructors), MemberType = typeof(CommonMemberData))]
+        [WorkItem(3784, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3784")]
+        public async Task TestPrimaryConstructorBaseListWithParametersOnSameLineAsync(string typeKeyword)
+        {
+            var testCode = $@"
+{typeKeyword} Foo(int x)
+{{
+}}
+
+{typeKeyword} Bar(int x) : Foo(x)
+{{
+}}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonMemberData.ReferenceTypeKeywordsWhichSupportPrimaryConstructors), MemberType = typeof(CommonMemberData))]
+        [WorkItem(3784, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3784")]
+        public async Task TestPrimaryConstructorBaseListWithParametersAsync(string typeKeyword)
+        {
+            var testCode = $@"
+{typeKeyword} Foo(int x)
+{{
+}}
+
+{typeKeyword} Bar(int x) : Foo
+    {{|#0:(|}}x)
+{{
+}}";
+
+            var fixedCode = $@"
+{typeKeyword} Foo(int x)
+{{
+}}
+
+{typeKeyword} Bar(int x) : Foo(
+    x)
+{{
+}}";
+
+            var expected = this.GetExpectedResultTestPrimaryConstructorBaseList();
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonMemberData.ReferenceTypeKeywordsWhichSupportPrimaryConstructors), MemberType = typeof(CommonMemberData))]
+        [WorkItem(3784, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3784")]
+        public async Task TestPrimaryConstructorBaseListWithoutParametersAsync(string typeKeyword)
+        {
+            var testCode = $@"
+{typeKeyword} Foo()
+{{
+}}
+
+{typeKeyword} Bar(int x) : Foo
+    {{|#0:(|}})
+{{
+}}";
+
+            var fixedCode = $@"
+{typeKeyword} Foo()
+{{
+}}
+
+{typeKeyword} Bar(int x) : Foo()
+{{
+}}";
+
+            var expected = this.GetExpectedResultTestPrimaryConstructorBaseList();
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
         protected virtual DiagnosticResult[] GetExpectedResultTestPrimaryConstructor()
         {
             return new[]
             {
+                // Diagnostic issued twice because of https://github.com/dotnet/roslyn/issues/53136
+                Diagnostic().WithLocation(0),
+                Diagnostic().WithLocation(0),
+            };
+        }
+
+        protected virtual DiagnosticResult[] GetExpectedResultTestPrimaryConstructorBaseList()
+        {
+            return new[]
+            {
+                // Diagnostic issued twice because of https://github.com/dotnet/roslyn/issues/70488
                 Diagnostic().WithLocation(0),
                 Diagnostic().WithLocation(0),
             };

StyleCop.Analyzers/StyleCop.Analyzers.Test/Helpers/CommonMemberData.cs

@@ -137,5 +137,13 @@ public static IEnumerable<object[]> TypeKeywordsWhichSupportPrimaryConstructors
                 }
             }
         }
+
+        public static IEnumerable<object[]> ReferenceTypeKeywordsWhichSupportPrimaryConstructors
+        {
+            get
+            {
+                return TypeKeywordsWhichSupportPrimaryConstructors.Where(x => !((string)x[0]).Contains("struct"));
+            }
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxKindEx.cs

@@ -67,6 +67,7 @@ internal static class SyntaxKindEx
         public const SyntaxKind WithExpression = (SyntaxKind)9061;
         public const SyntaxKind WithInitializerExpression = (SyntaxKind)9062;
         public const SyntaxKind RecordDeclaration = (SyntaxKind)9063;
+        public const SyntaxKind PrimaryConstructorBaseType = (SyntaxKind)9065;
         public const SyntaxKind FunctionPointerUnmanagedCallingConventionList = (SyntaxKind)9066;
         public const SyntaxKind RecordStructDeclaration = (SyntaxKind)9068;
         public const SyntaxKind CollectionExpression = (SyntaxKind)9076;

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1110OpeningParenthesisMustBeOnDeclarationLine.cs

@@ -54,6 +54,7 @@ internal class SA1110OpeningParenthesisMustBeOnDeclarationLine : DiagnosticAnaly
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
         private static readonly Action<SyntaxNodeAnalysisContext> TypeDeclarationAction = HandleTypeDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext> PrimaryConstructorBaseTypeAction = HandlePrimaryConstructorBaseType;
         private static readonly Action<SyntaxNodeAnalysisContext> MethodDeclarationAction = HandleMethodDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> LocalFunctionStatementAction = HandleLocalFunctionStatement;
         private static readonly Action<SyntaxNodeAnalysisContext> ConstructorDeclarationAction = HandleConstructorDeclaration;
@@ -79,6 +80,7 @@ public override void Initialize(AnalysisContext context)
             context.EnableConcurrentExecution();
 
             context.RegisterSyntaxNodeAction(TypeDeclarationAction, SyntaxKinds.TypeDeclaration);
+            context.RegisterSyntaxNodeAction(PrimaryConstructorBaseTypeAction, SyntaxKindEx.PrimaryConstructorBaseType);
             context.RegisterSyntaxNodeAction(MethodDeclarationAction, SyntaxKind.MethodDeclaration);
             context.RegisterSyntaxNodeAction(LocalFunctionStatementAction, SyntaxKindEx.LocalFunctionStatement);
             context.RegisterSyntaxNodeAction(ConstructorDeclarationAction, SyntaxKind.ConstructorDeclaration);
@@ -345,6 +347,27 @@ private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
             }
         }
 
+        private static void HandlePrimaryConstructorBaseType(SyntaxNodeAnalysisContext context)
+        {
+            var primaryConstructorBaseType = (PrimaryConstructorBaseTypeSyntaxWrapper)context.Node;
+
+            var identifierName = ((BaseTypeSyntax)primaryConstructorBaseType).ChildNodes()
+                .OfType<IdentifierNameSyntax>()
+                .FirstOrDefault();
+            if (identifierName == null || identifierName.Identifier.IsMissing)
+            {
+                return;
+            }
+
+            var argumentListSyntax = primaryConstructorBaseType.ArgumentList;
+
+            if (argumentListSyntax != null && !argumentListSyntax.OpenParenToken.IsMissing)
+            {
+                bool preserveLayout = argumentListSyntax.Arguments.Any();
+                CheckIfLocationOfPreviousTokenAndOpenTokenAreTheSame(context, argumentListSyntax.OpenParenToken, preserveLayout);
+            }
+        }
+
         private static void CheckIfLocationOfPreviousTokenAndOpenTokenAreTheSame(SyntaxNodeAnalysisContext context, SyntaxToken openToken, bool preserveLayout)
         {
             var previousToken = openToken.GetPreviousToken();