Update SA1003 for relational and logical patterns

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/SpacingRules/SA1003CSharp9UnitTests.cs

@@ -3,9 +3,62 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.SpacingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.SpacingRules;
+    using Xunit;
+    using static StyleCop.Analyzers.SpacingRules.SA1003SymbolsMustBeSpacedCorrectly;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.SpacingRules.SA1003SymbolsMustBeSpacedCorrectly,
+        StyleCop.Analyzers.SpacingRules.SA1003CodeFixProvider>;
 
     public partial class SA1003CSharp9UnitTests : SA1003CSharp8UnitTests
     {
+        [Fact]
+        [WorkItem(3968, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3968")]
+        public async Task TestRelationalPatternsAreValidatedAsync()
+        {
+            const string testCode = @"
+class C
+{
+    void M(int value)
+    {
+        _ = value is {|#0:>|}5;
+        _ = value is{|#1:<|} 5;
+        _ = value is ( < 5); // Validated by SA1008
+        _ = value is (< 5);
+        _ = value is {|#2:<=|}5;
+        _ = value is {|#3:>=|}5;
+        _ = value is {|#4:>|}
+            5;
+    }
+}";
+
+            const string fixedCode = @"
+class C
+{
+    void M(int value)
+    {
+        _ = value is > 5;
+        _ = value is < 5;
+        _ = value is ( < 5); // Validated by SA1008
+        _ = value is (< 5);
+        _ = value is <= 5;
+        _ = value is >= 5;
+        _ = value is > 5;
+    }
+}";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DescriptorFollowedByWhitespace).WithLocation(0).WithArguments(">"),
+                Diagnostic(DescriptorPrecededByWhitespace).WithLocation(1).WithArguments("<"),
+                Diagnostic(DescriptorFollowedByWhitespace).WithLocation(2).WithArguments("<="),
+                Diagnostic(DescriptorFollowedByWhitespace).WithLocation(3).WithArguments(">="),
+                Diagnostic(DescriptorNotAtEndOfLine).WithLocation(4).WithArguments(">"),
+            };
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

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

@@ -140,6 +140,7 @@ internal class SA1003SymbolsMustBeSpacedCorrectly : DiagnosticAnalyzer
         private static readonly Action<SyntaxNodeAnalysisContext> LambdaExpressionAction = HandleLambdaExpression;
         private static readonly Action<SyntaxNodeAnalysisContext> ArrowExpressionClauseAction = HandleArrowExpressionClause;
         private static readonly Action<SyntaxNodeAnalysisContext> RangeExpressionAction = HandleRangeExpression;
+        private static readonly Action<SyntaxNodeAnalysisContext> RelationalPatternAction = HandleRelationalPattern;
         private static readonly Action<SyntaxNodeAnalysisContext> SwitchExpressionArmAction = HandleSwitchExpressionArm;
 
         /// <summary>
@@ -218,6 +219,7 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(LambdaExpressionAction, SyntaxKinds.LambdaExpression);
             context.RegisterSyntaxNodeAction(ArrowExpressionClauseAction, SyntaxKind.ArrowExpressionClause);
             context.RegisterSyntaxNodeAction(RangeExpressionAction, SyntaxKindEx.RangeExpression);
+            context.RegisterSyntaxNodeAction(RelationalPatternAction, SyntaxKindEx.RelationalPattern);
             context.RegisterSyntaxNodeAction(SwitchExpressionArmAction, SyntaxKindEx.SwitchExpressionArm);
         }
 
@@ -256,11 +258,6 @@ private static void HandleBinaryExpression(SyntaxNodeAnalysisContext context)
 
         private static void HandleRangeExpression(SyntaxNodeAnalysisContext context)
         {
-            if (!RangeExpressionSyntaxWrapper.IsInstance(context.Node))
-            {
-                return;
-            }
-
             var rangeExpression = (RangeExpressionSyntaxWrapper)context.Node;
             var hasLeftOperand = rangeExpression.LeftOperand != null;
             var hasRightOperand = rangeExpression.RightOperand != null;
@@ -346,6 +343,22 @@ private static void HandlePrefixUnaryExpression(SyntaxNodeAnalysisContext contex
             }
         }
 
+        private static void HandleRelationalPattern(SyntaxNodeAnalysisContext context)
+        {
+            var relationalPattern = (RelationalPatternSyntaxWrapper)context.Node;
+            var operatorToken = relationalPattern.OperatorToken;
+            var precedingToken = operatorToken.GetPreviousToken();
+
+            if (precedingToken.IsKind(SyntaxKind.OpenParenToken))
+            {
+                // Spacing next to the opening parenthesis is handled by SA1008; only enforce trailing whitespace here.
+                CheckTokenTrailingWhitespace(context, operatorToken, allowAtEndOfLine: false, withTrailingWhitespace: true);
+                return;
+            }
+
+            CheckToken(context, operatorToken, withLeadingWhitespace: true, allowAtEndOfLine: false, withTrailingWhitespace: true);
+        }
+
         private static void HandlePostfixUnaryExpression(SyntaxNodeAnalysisContext context)
         {
             var unaryExpression = (PostfixUnaryExpressionSyntax)context.Node;

documentation/SA1003.md

@@ -38,6 +38,11 @@ rules apply: each arrow should have a single space on both sides.
 var description = value switch { 0 => "zero", _ => "nonzero" };
 ```
 
+Relational operators inside pattern matching expressions follow the same rules when they appear after keywords such as
+`is`. For example, in a relational pattern the `>` in `value is > 5` must be surrounded by spaces: `value is > 5`. When
+a relational pattern is wrapped in parentheses, it should still avoid spaces immediately after `(` or before `)`,
+consistent with the parenthesis rules described in SA1008.
+
 In contrast, unary operators should be preceded by a single space, but should never be followed by any space. For example:
 
 ```csharp