Update SA1508/SA1509 for pattern matching

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/LayoutRules/SA1508CSharp8UnitTests.cs

@@ -3,9 +3,105 @@
 
 namespace StyleCop.Analyzers.Test.CSharp8.LayoutRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
     using StyleCop.Analyzers.Test.CSharp7.LayoutRules;
+    using Xunit;
+
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.LayoutRules.SA1508ClosingBracesMustNotBePrecededByBlankLine,
+        StyleCop.Analyzers.LayoutRules.SA1508CodeFixProvider>;
 
     public partial class SA1508CSharp8UnitTests : SA1508CSharp7UnitTests
     {
+        [Fact]
+        [WorkItem(3003, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3003")]
+        public async Task TestSwitchExpressionClosingBracePrecededByBlankLineAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    public int Test(Wrapper value)
+    {
+        return value switch
+        {
+            { X: 1 } => 1,
+            _ => 0,
+
+        {|#0:}|};
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+            var fixedCode = @"
+public class TestClass
+{
+    public int Test(Wrapper value)
+    {
+        return value switch
+        {
+            { X: 1 } => 1,
+            _ => 0,
+        };
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+
+            var expected = Diagnostic().WithLocation(0);
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3003, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3003")]
+        public async Task TestPropertyPatternClosingBracePrecededByBlankLineAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    public bool Test(Wrapper value)
+    {
+        return value is Wrapper
+        {
+            X: 1,
+
+        {|#0:}|};
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+            var fixedCode = @"
+public class TestClass
+{
+    public bool Test(Wrapper value)
+    {
+        return value is Wrapper
+        {
+            X: 1,
+        };
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+
+            var expected = Diagnostic().WithLocation(0);
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/LayoutRules/SA1509CSharp8UnitTests.cs

@@ -3,9 +3,106 @@
 
 namespace StyleCop.Analyzers.Test.CSharp8.LayoutRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp7.LayoutRules;
+    using Xunit;
+
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.LayoutRules.SA1509OpeningBracesMustNotBePrecededByBlankLine,
+        StyleCop.Analyzers.LayoutRules.SA1509CodeFixProvider>;
 
     public partial class SA1509CSharp8UnitTests : SA1509CSharp7UnitTests
     {
+        [Fact]
+        [WorkItem(3003, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3003")]
+        public async Task TestSwitchExpressionOpeningBracePrecededByBlankLineAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    public int Test(Wrapper value)
+    {
+        return value switch
+
+        {|#0:{|}
+            { X: 1 } => 1,
+            _ => 0,
+        };
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+            var fixedCode = @"
+public class TestClass
+{
+    public int Test(Wrapper value)
+    {
+        return value switch
+        {
+            { X: 1 } => 1,
+            _ => 0,
+        };
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+
+            var expected = Diagnostic().WithLocation(0);
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3003, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3003")]
+        public async Task TestPropertyPatternOpeningBracePrecededByBlankLineAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    public bool Test(Wrapper value)
+    {
+        return value is Wrapper
+
+        {|#0:{|}
+            X: 1,
+        };
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+            var fixedCode = @"
+public class TestClass
+{
+    public bool Test(Wrapper value)
+    {
+        return value is Wrapper
+        {
+            X: 1,
+        };
+    }
+}
+
+public class Wrapper
+{
+    public int X { get; set; }
+}
+";
+
+            var expected = Diagnostic().WithLocation(0);
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1508ClosingBracesMustNotBePrecededByBlankLine.cs

@@ -12,6 +12,7 @@ namespace StyleCop.Analyzers.LayoutRules
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// A closing brace within a C# element, statement, or expression is preceded by a blank line.
@@ -61,6 +62,8 @@ internal class SA1508ClosingBracesMustNotBePrecededByBlankLine : DiagnosticAnaly
         private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> BaseTypeDeclarationAction = HandleBaseTypeDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> AccessorListAction = HandleAccessorList;
+        private static readonly Action<SyntaxNodeAnalysisContext> SwitchExpressionAction = HandleSwitchExpression;
+        private static readonly Action<SyntaxNodeAnalysisContext> PropertyPatternClauseAction = HandlePropertyPatternClause;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -79,6 +82,8 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
             context.RegisterSyntaxNodeAction(BaseTypeDeclarationAction, SyntaxKinds.BaseTypeDeclaration);
             context.RegisterSyntaxNodeAction(AccessorListAction, SyntaxKind.AccessorList);
+            context.RegisterSyntaxNodeAction(SwitchExpressionAction, SyntaxKindEx.SwitchExpression);
+            context.RegisterSyntaxNodeAction(PropertyPatternClauseAction, SyntaxKindEx.PropertyPatternClause);
         }
 
         private static void HandleBlock(SyntaxNodeAnalysisContext context)
@@ -123,6 +128,18 @@ private static void HandleAccessorList(SyntaxNodeAnalysisContext context)
             AnalyzeCloseBrace(context, accessorList.CloseBraceToken);
         }
 
+        private static void HandleSwitchExpression(SyntaxNodeAnalysisContext context)
+        {
+            var switchExpression = (SwitchExpressionSyntaxWrapper)context.Node;
+            AnalyzeCloseBrace(context, switchExpression.CloseBraceToken);
+        }
+
+        private static void HandlePropertyPatternClause(SyntaxNodeAnalysisContext context)
+        {
+            var propertyPatternClause = (PropertyPatternClauseSyntaxWrapper)context.Node;
+            AnalyzeCloseBrace(context, propertyPatternClause.CloseBraceToken);
+        }
+
         private static void AnalyzeCloseBrace(SyntaxNodeAnalysisContext context, SyntaxToken closeBraceToken)
         {
             if (closeBraceToken.IsKind(SyntaxKind.None))

documentation/SA1508.md

@@ -39,6 +39,10 @@ public bool Enabled
 
 The code above would generate two instances of this violation, since there are two places where closing braces are preceded by blank lines.
 
+Starting with C# 8.0, this rule also applies to closing braces in switch expressions and property patterns. If the brace
+belongs to a multi-line switch expression arm list or a multi-line property pattern, it still must not be preceded by a
+blank line.
+
 ## How to fix violations
 
 To fix a violation of this rule, remove the blank line preceding the closing brace.

documentation/SA1509.md

@@ -59,6 +59,9 @@ public bool Enabled
 }
 ```
 
+This rule also applies to opening braces introduced by C# 8.0 switch expressions and property patterns. Even in these
+constructs, a blank line may not appear immediately before the opening brace.
+
 ## How to fix violations
 
 To fix a violation of this rule, remove the blank line preceding the opening brace.