Fix for issue #2062: Updated SA1513 to fire inside e.g. lambdas in an argument list. Previously, it could never fire inside an argument list, which does not make sense if the brace was inside e.g. a lambda expression. Also updated documentation to have a correct example for this rule.

Author: bjornhellander

StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1513UnitTests.cs

@@ -725,6 +725,61 @@ public void Example()
             await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
         }
 
+        // This is a regression test for #2062.
+        [Fact]
+        public async Task VerifyThatBlockStatementDirectlyFollowedByReturnInsideLambdaInsideArgumentListWillProduceDiagnosticAsync()
+        {
+            var testCode = @"
+using System;
+public class TestClass
+{
+    public void Func1(Action action)
+    {
+    }
+
+    public void Func2(bool flag)
+    {
+        Func1(() => 
+        {
+            if (flag)
+            {
+                return;
+            }
+            return;
+        });
+    }
+}
+";
+
+            var fixedCode = @"
+using System;
+public class TestClass
+{
+    public void Func1(Action action)
+    {
+    }
+
+    public void Func2(bool flag)
+    {
+        Func1(() => 
+        {
+            if (flag)
+            {
+                return;
+            }
+
+            return;
+        });
+    }
+}
+";
+
+            var expected = this.CSharpDiagnostic().WithLocation(16, 14);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Verifies the analyzer will properly handle an object initializer without assignment.
         /// This is a regression test for <see href="https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1301">DotNetAnalyzers/StyleCopAnalyzers#1301</see>.

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1513ClosingBraceMustBeFollowedByBlankLine.cs

@@ -241,12 +241,6 @@ private void AnalyzeCloseBrace(SyntaxToken token)
                         }
                     }
 
-                    if (IsPartOf<ArgumentListSyntax>(token))
-                    {
-                        // the close brace is part of an object initializer, anonymous function or lambda expression within an argument list.
-                        return;
-                    }
-
                     if (nextToken.IsKind(SyntaxKind.SemicolonToken) &&
                         (IsPartOf<VariableDeclaratorSyntax>(token) ||
                          IsPartOf<YieldStatementSyntax>(token) ||
@@ -260,10 +254,10 @@ private void AnalyzeCloseBrace(SyntaxToken token)
                         return;
                     }
 
-                    if ((nextToken.IsKind(SyntaxKind.CommaToken) || nextToken.IsKind(SyntaxKind.CloseParenToken)) &&
-                        (IsPartOf<InitializerExpressionSyntax>(token) || IsPartOf<AnonymousObjectCreationExpressionSyntax>(token)))
+                    if (nextToken.IsKind(SyntaxKind.CommaToken) || nextToken.IsKind(SyntaxKind.CloseParenToken))
                     {
-                        // the close brace is part of an initializer statement.
+                        // The close brace is the end of an object initializer, anonymous function, lambda expression, etc.
+                        // Comma and close parenthesis never requires a preceeding blank line.
                         return;
                     }
 
@@ -291,13 +285,6 @@ private void AnalyzeCloseBrace(SyntaxToken token)
                         return;
                     }
 
-                    var parenthesizedExpressionSyntax = nextToken.Parent as ParenthesizedExpressionSyntax;
-                    if (parenthesizedExpressionSyntax?.CloseParenToken == nextToken)
-                    {
-                        // the close brace is followed by the closing paren of a parenthesized expression.
-                        return;
-                    }
-
                     if (nextToken.IsKind(SyntaxKind.EndOfFileToken))
                     {
                         // this is the last close brace in the file

documentation/SA1513.md

@@ -30,16 +30,14 @@ would generate one instance of this violation, since there is one place where a
 line.
 
 ```csharp
-public bool Enabled
+if (condition)
 {
-    get
-    {
-        return this.enabled;
-    }}
+    DoSomething();
+}
+return value;
 ```
 
 
-
 ## How to fix violations
 
 To fix a violation of this rule, ensure a blank line follows closing braces.