Update SA1003 for pattern matching

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/SpacingRules/SA1003CSharp8UnitTests.cs

@@ -105,6 +105,103 @@ public void TestMethod(int? x)
             await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        [WorkItem(3003, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3003")]
+        public async Task TestSwitchExpressionArrowsAsync()
+        {
+            var testCode = @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public string TestMethod(object value)
+        {
+            return value switch
+            {
+                0{|#0:=>|}""zero"",
+                { }{|#1:=>|}""object"",
+            };
+        }
+    }
+}
+";
+
+            var fixedCode = @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public string TestMethod(object value)
+        {
+            return value switch
+            {
+                0 => ""zero"",
+                { } => ""object"",
+            };
+        }
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DescriptorPrecededByWhitespace).WithLocation(0).WithArguments("=>"),
+                Diagnostic(DescriptorFollowedByWhitespace).WithLocation(0).WithArguments("=>"),
+                Diagnostic(DescriptorPrecededByWhitespace).WithLocation(1).WithArguments("=>"),
+                Diagnostic(DescriptorFollowedByWhitespace).WithLocation(1).WithArguments("=>"),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3003, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3003")]
+        public async Task TestSwitchExpressionArrowWithWrappedArmAsync()
+        {
+            var testCode = @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public string TestMethod(int[] values)
+        {
+            return values switch
+            {
+                { Length: 1 }{|#0:=>|}
+                    ""single"",
+                _ => ""other"",
+            };
+        }
+    }
+}
+";
+
+            var fixedCode = @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public string TestMethod(int[] values)
+        {
+            return values switch
+            {
+                { Length: 1 } =>
+                    ""single"",
+                _ => ""other"",
+            };
+        }
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DescriptorPrecededByWhitespace).WithLocation(0).WithArguments("=>"),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         [WorkItem(3822, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3822")]
         public async Task TestNullForgivingOperatorAsync()

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1003SymbolsMustBeSpacedCorrectly.cs

@@ -138,6 +138,7 @@ internal class SA1003SymbolsMustBeSpacedCorrectly : DiagnosticAnalyzer
         private static readonly Action<SyntaxNodeAnalysisContext> EqualsValueClauseAction = HandleEqualsValueClause;
         private static readonly Action<SyntaxNodeAnalysisContext> LambdaExpressionAction = HandleLambdaExpression;
         private static readonly Action<SyntaxNodeAnalysisContext> ArrowExpressionClauseAction = HandleArrowExpressionClause;
+        private static readonly Action<SyntaxNodeAnalysisContext> SwitchExpressionArmAction = HandleSwitchExpressionArm;
 
         /// <summary>
         /// Gets the descriptor for prefix unary expression that may not be followed by a comment.
@@ -214,6 +215,7 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(EqualsValueClauseAction, SyntaxKind.EqualsValueClause);
             context.RegisterSyntaxNodeAction(LambdaExpressionAction, SyntaxKinds.LambdaExpression);
             context.RegisterSyntaxNodeAction(ArrowExpressionClauseAction, SyntaxKind.ArrowExpressionClause);
+            context.RegisterSyntaxNodeAction(SwitchExpressionArmAction, SyntaxKindEx.SwitchExpressionArm);
         }
 
         private static void HandleConstructorDeclaration(SyntaxNodeAnalysisContext context)
@@ -381,6 +383,12 @@ private static void HandleArrowExpressionClause(SyntaxNodeAnalysisContext contex
             CheckToken(context, arrowExpressionClause.ArrowToken, true, true, true);
         }
 
+        private static void HandleSwitchExpressionArm(SyntaxNodeAnalysisContext context)
+        {
+            var switchExpressionArm = (SwitchExpressionArmSyntaxWrapper)context.Node;
+            CheckToken(context, switchExpressionArm.EqualsGreaterThanToken, true, true, true);
+        }
+
         private static void CheckToken(SyntaxNodeAnalysisContext context, SyntaxToken token, bool withLeadingWhitespace, bool allowAtEndOfLine, bool withTrailingWhitespace, string tokenText = null)
         {
             tokenText = tokenText ?? token.Text;

documentation/SA1003.md

@@ -31,6 +31,13 @@ lambda operators. For example:
 int x = 4 + y;
 ```
 
+Starting with C# 8.0, the lambda operator `=>` also appears in switch expression arms. The same spacing
+rules apply: each arrow should have a single space on both sides.
+
+```csharp
+var description = value switch { 0 => "zero", _ => "nonzero" };
+```
+
 In contrast, unary operators should be preceded by a single space, but should never be followed by any space. For example:
 
 ```csharp