Add tests for base type declarations and fix bugs

* Ignore leading attribute lists when analyzing other element kinds

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1137UnitTests.cs

@@ -17,6 +17,90 @@ namespace StyleCop.Analyzers.Test.ReadabilityRules
     /// </summary>
     public class SA1137UnitTests : CodeFixVerifier
     {
+        [Theory]
+        [InlineData("class")]
+        [InlineData("struct")]
+        [InlineData("interface")]
+        [InlineData("enum")]
+        public async Task TestBaseTypeDeclarationAsync(string baseTypeKind)
+        {
+            // Need to test attribute lists here
+            string testCode = $@"
+using System;
+
+namespace Namespace0
+{{
+    [My] [My] {baseTypeKind} TypeName {{ }}
+}}
+
+namespace Namespace1
+{{
+    [My]
+  [My] {baseTypeKind} TypeName {{ }}
+}}
+
+namespace Namespace2
+{{
+  [My]
+    [My]
+  {baseTypeKind} TypeName {{ }}
+}}
+
+namespace Namespace3
+{{
+    [My]
+    [My]
+  {baseTypeKind} TypeName {{ }}
+}}
+
+[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
+class MyAttribute : Attribute {{ }}
+";
+            string fixedCode = $@"
+using System;
+
+namespace Namespace0
+{{
+    [My] [My] {baseTypeKind} TypeName {{ }}
+}}
+
+namespace Namespace1
+{{
+    [My]
+    [My] {baseTypeKind} TypeName {{ }}
+}}
+
+namespace Namespace2
+{{
+  [My]
+  [My]
+  {baseTypeKind} TypeName {{ }}
+}}
+
+namespace Namespace3
+{{
+  [My]
+  [My]
+  {baseTypeKind} TypeName {{ }}
+}}
+
+[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
+class MyAttribute : Attribute {{ }}
+";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(12, 1),
+                this.CSharpDiagnostic().WithLocation(18, 1),
+                this.CSharpDiagnostic().WithLocation(24, 1),
+                this.CSharpDiagnostic().WithLocation(25, 1),
+            };
+
+            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);
+        }
+
         [Fact]
         public async Task TestBlockAsync()
         {

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

@@ -349,7 +349,7 @@ private static void CheckElements<T>(SyntaxNodeAnalysisContext context, Immutabl
             elements = elements.RemoveAll(
                 element =>
                 {
-                    SyntaxToken firstToken = element.GetFirstToken();
+                    SyntaxToken firstToken = GetFirstTokenForAnalysis(element);
                     return firstToken.IsMissingOrDefault() || !firstToken.IsFirstInLine();
                 });
 
@@ -362,7 +362,8 @@ private static void CheckElements<T>(SyntaxNodeAnalysisContext context, Immutabl
             string expectedIndentation = null;
             foreach (T element in elements)
             {
-                SyntaxTrivia indentationTrivia = element.GetFirstToken().LeadingTrivia.LastOrDefault();
+                SyntaxToken firstToken = GetFirstTokenForAnalysis(element);
+                SyntaxTrivia indentationTrivia = firstToken.LeadingTrivia.LastOrDefault();
                 string indentation = indentationTrivia.IsKind(SyntaxKind.WhitespaceTrivia) ? indentationTrivia.ToString() : string.Empty;
 
                 if (first)
@@ -381,7 +382,7 @@ private static void CheckElements<T>(SyntaxNodeAnalysisContext context, Immutabl
                 Location location;
                 if (indentation.Length == 0)
                 {
-                    location = element.GetFirstToken().GetLocation();
+                    location = firstToken.GetLocation();
                 }
                 else
                 {
@@ -392,5 +393,21 @@ private static void CheckElements<T>(SyntaxNodeAnalysisContext context, Immutabl
                 context.ReportDiagnostic(Diagnostic.Create(Descriptor, location, properties));
             }
         }
+
+        private static SyntaxToken GetFirstTokenForAnalysis(SyntaxNode node)
+        {
+            SyntaxToken firstToken = node.GetFirstToken();
+            if (!node.IsKind(SyntaxKind.AttributeList))
+            {
+                while (firstToken.IsKind(SyntaxKind.OpenBracketToken)
+                    && firstToken.Parent.IsKind(SyntaxKind.AttributeList))
+                {
+                    // Skip over the attribute list since it's not the focus of this check
+                    firstToken = firstToken.Parent.GetLastToken().GetNextToken();
+                }
+            }
+
+            return firstToken;
+        }
     }
 }