Merge pull request #2865 from sharwell/tuple-tests

Update SA1137 to handle tuple types and expressions

Author: vweijsters

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/ReadabilityRules/SA1137CSharp7UnitTests.cs

@@ -3,9 +3,101 @@
 
 namespace StyleCop.Analyzers.Test.CSharp7.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.ReadabilityRules;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1137ElementsShouldHaveTheSameIndentation,
+        StyleCop.Analyzers.ReadabilityRules.IndentationCodeFixProvider>;
 
     public class SA1137CSharp7UnitTests : SA1137UnitTests
     {
+        [Fact]
+        public async Task TestTupleTypeAsync()
+        {
+            string testCode = @"
+class Container
+{
+    (
+        int x,
+      int y,
+int z) NonZeroAlignment;
+
+    (
+int x,
+      int y,
+        int z) ZeroAlignment;
+}
+";
+            string fixedCode = @"
+class Container
+{
+    (
+        int x,
+        int y,
+        int z) NonZeroAlignment;
+
+    (
+int x,
+int y,
+int z) ZeroAlignment;
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic().WithLocation(6, 1),
+                Diagnostic().WithLocation(7, 1),
+                Diagnostic().WithLocation(11, 1),
+                Diagnostic().WithLocation(12, 1),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestTupleExpressionAsync()
+        {
+            string testCode = @"
+class Container
+{
+    (int x, int y, int z) NonZeroAlignment = (
+        0,
+      0,
+0);
+
+    (int x, int y, int z) ZeroAlignment = (
+0,
+      0,
+        0);
+}
+";
+            string fixedCode = @"
+class Container
+{
+    (int x, int y, int z) NonZeroAlignment = (
+        0,
+        0,
+        0);
+
+    (int x, int y, int z) ZeroAlignment = (
+0,
+0,
+0);
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic().WithLocation(6, 1),
+                Diagnostic().WithLocation(7, 1),
+                Diagnostic().WithLocation(11, 1),
+                Diagnostic().WithLocation(12, 1),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1137ElementsShouldHaveTheSameIndentation.cs

@@ -4,13 +4,15 @@
 namespace StyleCop.Analyzers.ReadabilityRules
 {
     using System;
+    using System.Collections.Generic;
     using System.Collections.Immutable;
     using System.Linq;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal class SA1137ElementsShouldHaveTheSameIndentation : DiagnosticAnalyzer
@@ -45,6 +47,8 @@ internal class SA1137ElementsShouldHaveTheSameIndentation : DiagnosticAnalyzer
         private static readonly Action<SyntaxNodeAnalysisContext> SwitchStatementAction = HandleSwitchStatement;
         private static readonly Action<SyntaxNodeAnalysisContext> InitializerExpressionAction = HandleInitializerExpression;
         private static readonly Action<SyntaxNodeAnalysisContext> AnonymousObjectCreationExpressionAction = HandleAnonymousObjectCreationExpression;
+        private static readonly Action<SyntaxNodeAnalysisContext> TupleTypeAction = HandleTupleType;
+        private static readonly Action<SyntaxNodeAnalysisContext> TupleExpressionAction = HandleTupleExpression;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -72,6 +76,8 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(SwitchStatementAction, SyntaxKind.SwitchStatement);
             context.RegisterSyntaxNodeAction(InitializerExpressionAction, SyntaxKinds.InitializerExpression);
             context.RegisterSyntaxNodeAction(AnonymousObjectCreationExpressionAction, SyntaxKind.AnonymousObjectCreationExpression);
+            context.RegisterSyntaxNodeAction(TupleTypeAction, SyntaxKindEx.TupleType);
+            context.RegisterSyntaxNodeAction(TupleExpressionAction, SyntaxKindEx.TupleExpression);
         }
 
         private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
@@ -262,6 +268,20 @@ private static void HandleAnonymousObjectCreationExpression(SyntaxNodeAnalysisCo
             CheckElements(context, anonymousObjectCreationExpression.Initializers);
         }
 
+        private static void HandleTupleType(SyntaxNodeAnalysisContext context)
+        {
+            var tupleType = (TupleTypeSyntaxWrapper)context.Node;
+
+            CheckElements(context, tupleType.Elements);
+        }
+
+        private static void HandleTupleExpression(SyntaxNodeAnalysisContext context)
+        {
+            var tupleExpression = (TupleExpressionSyntaxWrapper)context.Node;
+
+            CheckElements(context, tupleExpression.Arguments);
+        }
+
         private static void AddMembersAndAttributes<T>(ImmutableList<SyntaxNode>.Builder elements, SeparatedSyntaxList<T> members)
             where T : SyntaxNode
         {
@@ -355,6 +375,16 @@ private static void CheckElements<T>(SyntaxNodeAnalysisContext context, Separate
             CheckElements(context, elements.ToImmutableList());
         }
 
+        private static void CheckElements<T>(SyntaxNodeAnalysisContext context, SeparatedSyntaxListWrapper<T> elements)
+        {
+            if (elements.Count < 2)
+            {
+                return;
+            }
+
+            CheckElements(context, ((IEnumerable<SyntaxNode>)elements.UnderlyingList).ToImmutableList());
+        }
+
         // BlockSyntax is analyzed separately because it needs to check both braces.
         private static void CheckBlocks(SyntaxNodeAnalysisContext context, ImmutableList<BlockSyntax> elements)
         {