Added contructor initializer support to SA1113

Author: vweijsters

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1113UnitTests.cs

@@ -1128,11 +1128,102 @@ public void TestMethod2()
             await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that a base constructor call with the comma on the wrong line is handled properly.
+        /// This is a regression test for #1654.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyBaseConstructorCallAsync()
+        {
+            var testCode = @"
+abstract class BaseClass
+{
+    protected BaseClass(int x, int y) { }
+}
+
+class ClassName : BaseClass
+{
+    protected ClassName(int x, int y)
+        : base(
+            x
+            , y)
+    {
+    }
+}
+";
+            var fixedCode = @"
+abstract class BaseClass
+{
+    protected BaseClass(int x, int y) { }
+}
+
+class ClassName : BaseClass
+{
+    protected ClassName(int x, int y)
+        : base(
+            x,
+            y)
+    {
+    }
+}
+";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(12, 13);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that a this constructor call with the comma on the wrong line is handled properly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyThisConstructorCallAsync()
+        {
+            var testCode = @"
+class ClassName
+{
+    private ClassName(int x, int y) { }
+
+    protected ClassName(int x, int y, int z)
+        : this(
+            x
+            , y)
+    {
+    }
+}
+";
+            var fixedCode = @"
+class ClassName
+{
+    private ClassName(int x, int y) { }
+
+    protected ClassName(int x, int y, int z)
+        : this(
+            x,
+            y)
+    {
+    }
+}
+";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(9, 13);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc/>
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1113CommaMustBeOnSameLineAsPreviousParameter();
         }
 
+        /// <inheritdoc/>
         protected override CodeFixProvider GetCSharpCodeFixProvider()
         {
             return new TokenSpacingCodeFixProvider();

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1113CommaMustBeOnSameLineAsPreviousParameter.cs

@@ -50,6 +50,9 @@ internal class SA1113CommaMustBeOnSameLineAsPreviousParameter : DiagnosticAnalyz
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> ConstructorInitializerKinds =
+            ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
         private static readonly Action<SyntaxNodeAnalysisContext> MethodDeclarationAction = HandleMethodDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> ConstructorDeclarationAction = HandleConstructorDeclaration;
@@ -64,6 +67,7 @@ internal class SA1113CommaMustBeOnSameLineAsPreviousParameter : DiagnosticAnalyz
         private static readonly Action<SyntaxNodeAnalysisContext> AttributeListAction = HandleAttributeList;
         private static readonly Action<SyntaxNodeAnalysisContext> OperatorDeclarationAction = HandleOperatorDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> ArrayCreationExpressionAction = HandleArrayCreationExpression;
+        private static readonly Action<SyntaxNodeAnalysisContext> ConstructorInitializerExpressionAction = HandleConstructorInitializerExpression;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -90,6 +94,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(AttributeListAction, SyntaxKind.AttributeList);
             context.RegisterSyntaxNodeActionHonorExclusions(OperatorDeclarationAction, SyntaxKind.OperatorDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(ArrayCreationExpressionAction, SyntaxKind.ArrayCreationExpression);
+            context.RegisterSyntaxNodeActionHonorExclusions(ConstructorInitializerExpressionAction, ConstructorInitializerKinds);
         }
 
         private static void HandleArrayCreationExpression(SyntaxNodeAnalysisContext context)
@@ -205,6 +210,12 @@ private static void HandleMethodDeclaration(SyntaxNodeAnalysisContext context)
             HandleBaseParameterListSyntax(context, methodDeclaration.ParameterList);
         }
 
+        private static void HandleConstructorInitializerExpression(SyntaxNodeAnalysisContext context)
+        {
+            var constructorInitializer = (ConstructorInitializerSyntax)context.Node;
+            HandleBaseArgumentListSyntax(context, constructorInitializer.ArgumentList);
+        }
+
         private static void HandleBaseArgumentListSyntax(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentList)
         {
             if (argumentList != null && !argumentList.IsMissing)