Update SA1110 to also check the parameter list in primary constructors

#3784

Author: bjornhellander

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/ReadabilityRules/SA1110CSharp11UnitTests.cs

@@ -3,9 +3,20 @@
 
 namespace StyleCop.Analyzers.Test.CSharp11.ReadabilityRules
 {
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp10.ReadabilityRules;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1110OpeningParenthesisMustBeOnDeclarationLine,
+        StyleCop.Analyzers.SpacingRules.TokenSpacingCodeFixProvider>;
 
     public partial class SA1110CSharp11UnitTests : SA1110CSharp10UnitTests
     {
+        protected override DiagnosticResult[] GetExpectedResultTestPrimaryConstructor()
+        {
+            return new[]
+            {
+                Diagnostic().WithLocation(0),
+            };
+        }
     }
 }

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

@@ -3,9 +3,66 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.ReadabilityRules;
+    using StyleCop.Analyzers.Test.Helpers;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1110OpeningParenthesisMustBeOnDeclarationLine,
+        StyleCop.Analyzers.SpacingRules.TokenSpacingCodeFixProvider>;
 
     public partial class SA1110CSharp9UnitTests : SA1110CSharp8UnitTests
     {
+        [Theory]
+        [MemberData(nameof(CommonMemberData.TypeKeywordsWhichSupportPrimaryConstructors), MemberType = typeof(CommonMemberData))]
+        [WorkItem(3784, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3784")]
+        public async Task TestPrimaryConstructorWithoutParametersAsync(string typeKeyword)
+        {
+            var testCode = $@"
+{typeKeyword} Foo
+    {{|#0:(|}})
+{{
+}}";
+
+            var fixedCode = $@"
+{typeKeyword} Foo()
+{{
+}}";
+
+            var expected = this.GetExpectedResultTestPrimaryConstructor();
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonMemberData.TypeKeywordsWhichSupportPrimaryConstructors), MemberType = typeof(CommonMemberData))]
+        [WorkItem(3784, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3784")]
+        public async Task TestPrimaryConstructorWithParametersAsync(string typeKeyword)
+        {
+            var testCode = $@"
+{typeKeyword} Foo
+    {{|#0:(|}}int x)
+{{
+}}";
+
+            var fixedCode = $@"
+{typeKeyword} Foo(
+    int x)
+{{
+}}";
+
+            var expected = this.GetExpectedResultTestPrimaryConstructor();
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        protected virtual DiagnosticResult[] GetExpectedResultTestPrimaryConstructor()
+        {
+            return new[]
+            {
+                Diagnostic().WithLocation(0),
+                Diagnostic().WithLocation(0),
+            };
+        }
     }
 }

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

@@ -114,5 +114,28 @@ public static IEnumerable<object[]> GenericTypeDeclarationKeywords
                     .Concat(new[] { new[] { "delegate" } });
             }
         }
+
+        public static IEnumerable<object[]> TypeKeywordsWhichSupportPrimaryConstructors
+        {
+            get
+            {
+                if (LightupHelpers.SupportsCSharp9)
+                {
+                    yield return new[] { "record" };
+                }
+
+                if (LightupHelpers.SupportsCSharp10)
+                {
+                    yield return new[] { "record class" };
+                    yield return new[] { "record struct" };
+                }
+
+                if (LightupHelpers.SupportsCSharp12)
+                {
+                    yield return new[] { "class" };
+                    yield return new[] { "struct" };
+                }
+            }
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TypeDeclarationSyntaxExtensions.cs

@@ -19,6 +19,20 @@ static TypeDeclarationSyntaxExtensions()
 
     public static ParameterListSyntax? ParameterList(this TypeDeclarationSyntax syntax)
     {
+        if (!LightupHelpers.SupportsCSharp12)
+        {
+            // Prior to C# 12, the ParameterList property in RecordDeclarationSyntax did not override a base method.
+            switch (syntax.Kind())
+            {
+            case SyntaxKindEx.RecordDeclaration:
+            case SyntaxKindEx.RecordStructDeclaration:
+                return ((RecordDeclarationSyntaxWrapper)syntax).ParameterList;
+
+            default:
+                return null;
+            }
+        }
+
         return ParameterListAccessor(syntax);
     }
 

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

@@ -53,6 +53,7 @@ internal class SA1110OpeningParenthesisMustBeOnDeclarationLine : DiagnosticAnaly
         private static readonly DiagnosticDescriptor Descriptor =
             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> MethodDeclarationAction = HandleMethodDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> LocalFunctionStatementAction = HandleLocalFunctionStatement;
         private static readonly Action<SyntaxNodeAnalysisContext> ConstructorDeclarationAction = HandleConstructorDeclaration;
@@ -77,6 +78,7 @@ public override void Initialize(AnalysisContext context)
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
             context.EnableConcurrentExecution();
 
+            context.RegisterSyntaxNodeAction(TypeDeclarationAction, SyntaxKinds.TypeDeclaration);
             context.RegisterSyntaxNodeAction(MethodDeclarationAction, SyntaxKind.MethodDeclaration);
             context.RegisterSyntaxNodeAction(LocalFunctionStatementAction, SyntaxKindEx.LocalFunctionStatement);
             context.RegisterSyntaxNodeAction(ConstructorDeclarationAction, SyntaxKind.ConstructorDeclaration);
@@ -329,6 +331,20 @@ private static void HandleLocalFunctionStatement(SyntaxNodeAnalysisContext conte
             }
         }
 
+        private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
+        {
+            var typeDeclaration = (TypeDeclarationSyntax)context.Node;
+            var parameterList = typeDeclaration.ParameterList();
+
+            if (parameterList != null
+                && !parameterList.OpenParenToken.IsMissing
+                && !typeDeclaration.Identifier.IsMissing)
+            {
+                bool preserveLayout = parameterList.Parameters.Any();
+                CheckIfLocationOfPreviousTokenAndOpenTokenAreTheSame(context, parameterList.OpenParenToken, preserveLayout);
+            }
+        }
+
         private static void CheckIfLocationOfPreviousTokenAndOpenTokenAreTheSame(SyntaxNodeAnalysisContext context, SyntaxToken openToken, bool preserveLayout)
         {
             var previousToken = openToken.GetPreviousToken();