Merge pull request #2364 from bjornhellander/Issue2062_Sa1513NotFiredInsideLambda

Updated SA1513 to fire inside lambdas

Author: vweijsters

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

@@ -162,12 +162,6 @@ private static bool StartsWithDirectiveTrivia(SyntaxTriviaList triviaList)
                 return false;
             }
 
-            private static bool IsQueryClause(SyntaxToken token)
-            {
-                return (token.Parent is FromClauseSyntax) ||
-                       (token.Parent is GroupClauseSyntax);
-            }
-
             private static bool IsPartOf<T>(SyntaxToken token)
             {
                 var result = false;
@@ -241,12 +235,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 +248,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 +279,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.