Merge pull request #702 from sharwell/fix-689

Fix SA1509 getting reported for consecutive blocks

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1509UnitTests.cs

@@ -637,6 +637,158 @@ void Bar()
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestBlockStatementsAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    void Bar()
+    {
+
+        {
+        }
+
+        {
+        }
+    }
+}";
+
+            var fixedCode = @"
+class Foo
+{
+    void Bar()
+    {
+        {
+        }
+
+        {
+        }
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(7, 9);
+            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 TestBlockStatementsWithBlockCommentAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    void Bar()
+    {
+        /* Comment */
+
+        {
+        }
+
+        {
+        }
+    }
+}";
+
+            var fixedCode = @"
+class Foo
+{
+    void Bar()
+    {
+        /* Comment */
+        {
+        }
+
+        {
+        }
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(8, 9);
+            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 TestBlockStatementsWithLineCommentAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    void Bar()
+    {
+        // Comment
+
+        {
+        }
+
+        {
+        }
+    }
+}";
+
+            var fixedCode = @"
+class Foo
+{
+    void Bar()
+    {
+        // Comment
+        {
+        }
+
+        {
+        }
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(8, 9);
+            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 TestBlockStatementsWithRegionAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    void Bar()
+    {
+        #region Region
+
+        {
+        }
+
+        {
+        }
+        #endregion
+    }
+}";
+
+            var fixedCode = @"
+class Foo
+{
+    void Bar()
+    {
+        #region Region
+        {
+        }
+
+        {
+        }
+        #endregion
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(8, 9);
+            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 TestComplex1Async()
         {

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1509OpeningBracesMustNotBePrecededByBlankLine.cs

@@ -8,6 +8,7 @@ namespace StyleCop.Analyzers.LayoutRules
     using System.Linq;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
 
@@ -74,19 +75,21 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)
         {
             var syntaxRoot = context.Tree.GetRoot(context.CancellationToken);
 
-            var openBraces = syntaxRoot.DescendantTokens()
-                .Where(t => t.IsKind(SyntaxKind.OpenBraceToken));
-
-            foreach (var openBrace in openBraces)
+            SyntaxToken previousToken = default(SyntaxToken);
+            foreach (var token in syntaxRoot.DescendantTokens())
             {
-                AnalyzeOpenBrace(context, openBrace);
+                if (token.IsKind(SyntaxKind.OpenBraceToken) && !previousToken.IsKind(SyntaxKind.CloseBraceToken))
+                {
+                    AnalyzeOpenBrace(context, token, previousToken);
+                }
+
+                previousToken = token;
             }
         }
 
-        private static void AnalyzeOpenBrace(SyntaxTreeAnalysisContext context, SyntaxToken openBrace)
+        private static void AnalyzeOpenBrace(SyntaxTreeAnalysisContext context, SyntaxToken openBrace, SyntaxToken previousToken)
         {
-            var prevToken = openBrace.GetPreviousToken();
-            var triviaList = TriviaHelper.MergeTriviaLists(prevToken.TrailingTrivia, openBrace.LeadingTrivia);
+            var triviaList = TriviaHelper.MergeTriviaLists(previousToken.TrailingTrivia, openBrace.LeadingTrivia);
 
             var done = false;
             var eolCount = 0;

documentation/SA1509.md

@@ -21,23 +21,43 @@ An opening brace within a C# element, statement, or expression is preceded by a
 
 ## Rule description
 
-To improve the readability of the code, StyleCop requires blank lines in certain situations, and prohibits blank lines in other situations. This results in a consistent visual pattern across the code, which can improve recognition and readability of unfamiliar code.
+To improve the readability of the code, StyleCop requires blank lines in certain situations, and prohibits blank lines
+in other situations. This results in a consistent visual pattern across the code, which can improve recognition and
+readability of unfamiliar code.
 
-A violation of this rule occurs when an opening brace is preceded by a blank line. For example:
+In general, a violation of this rule occurs when an opening brace is preceded by a blank line. For example, the
+following above would generate two instances of this violation, since there are two places where opening braces are
+preceded by blank lines.
 
 ```csharp
 public bool Enabled
 
 {
-    get 
+    get
 
-    { 
-        return this.enabled; 
+    {
+        return this.enabled;
     }
 }
 ```
 
-The code above would generate two instances of this violation, since there are two places where opening braces are preceded by blank lines.
+An exception to this rule occurs when the opening brace is preceded by a closing brace. When this occurs, a blank line
+will be required by [SA1513](SA1513.md). The following example shows correct use of blank lines:
+
+```csharp
+public bool Enabled
+{
+    get
+    {
+        {
+        }
+
+        {
+            return this.enabled;
+        }
+    }
+}
+```
 
 ## How to fix violations
 

documentation/SA1513.md

@@ -21,20 +21,24 @@ A closing brace within a C# element, statement, or expression is not followed by
 
 ## Rule description
 
-To improve the readability of the code, StyleCop requires blank lines in certain situations, and prohibits blank lines in other situations. This results in a consistent visual pattern across the code, which can improve recognition and readability of unfamiliar code.
+To improve the readability of the code, StyleCop requires blank lines in certain situations, and prohibits blank lines
+in other situations. This results in a consistent visual pattern across the code, which can improve recognition and
+readability of unfamiliar code.
 
-A violation of this rule occurs when a closing brace is not followed by a blank line. For example:
+A violation of this rule occurs when a closing brace is not followed by a blank line. For example, the following code
+would generate one instance of this violation, since there is one place where a closing brace is not followed by a blank
+line.
 
 ```csharp
 public bool Enabled
 {
-    get 
-    { 
-        return this.enabled; 
+    get
+    {
+        return this.enabled;
     }}
 ```
 
-The code above would generate one instance of this violation, since there is one place where a closing brace is not followed by a blank line.
+
 
 ## How to fix violations