Merge pull request #4072 from sharwell/extended-property-patterns

Update for extended property patterns in C# 10

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/ReadabilityRules/SA1101CSharp10UnitTests.cs

@@ -31,5 +31,63 @@ public bool Method(Test arg)
 
             await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
+
+        [Fact]
+        [WorkItem(3984, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3984")]
+        public async Task TestExtendedPropertyPatternInSwitchAsync()
+        {
+            var testCode = @"public class Test
+{
+    public Test Child { get; init; }
+    public int Value { get; init; }
+
+    public int Evaluate(Test other)
+    {
+        return other switch
+        {
+            { Child.Value: > 0 } and not { Value: 0 } => 1,
+            { Child.Value: <= 0 } or ({ Value: 0 } and { Child.Value: 0 }) => 0,
+            _ => -1,
+        };
+    }
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3984, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3984")]
+        public async Task TestExtendedPropertyPatternWithInstanceMemberAccessAsync()
+        {
+            var testCode = @"public class Test
+{
+    private int value;
+
+    public Test Child { get; }
+    public int Value { get; }
+
+    public bool Evaluate(Test other)
+    {
+        return other is { Child.Value: > 0 } && {|#0:value|} > 0;
+    }
+}";
+
+            var fixedCode = @"public class Test
+{
+    private int value;
+
+    public Test Child { get; }
+    public int Value { get; }
+
+    public bool Evaluate(Test other)
+    {
+        return other is { Child.Value: > 0 } && this.value > 0;
+    }
+}";
+
+            var expected = Diagnostic().WithLocation(0);
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/SpacingRules/SA1024CSharp10UnitTests.cs

@@ -3,9 +3,59 @@
 
 namespace StyleCop.Analyzers.Test.CSharp10.SpacingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp9.SpacingRules;
+    using Xunit;
+    using static StyleCop.Analyzers.SpacingRules.SA1024ColonsMustBeSpacedCorrectly;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.SpacingRules.SA1024ColonsMustBeSpacedCorrectly,
+        StyleCop.Analyzers.SpacingRules.TokenSpacingCodeFixProvider>;
 
     public partial class SA1024CSharp10UnitTests : SA1024CSharp9UnitTests
     {
+        [Fact]
+        [WorkItem(3984, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3984")]
+        public async Task TestExtendedPropertyPatternSpacingAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    public bool Test(SomeType value) => value is { Nested.Value: 1, Other.Value {|#0::|} 2, Third.Value{|#1::|}3 };
+}
+
+public class SomeType
+{
+    public SomeType Nested { get; set; }
+    public SomeType Other { get; set; }
+    public SomeType Third { get; set; }
+    public SomeType Child { get; set; }
+    public int Value { get; set; }
+}";
+
+            var fixedCode = @"
+public class TestClass
+{
+    public bool Test(SomeType value) => value is { Nested.Value: 1, Other.Value: 2, Third.Value: 3 };
+}
+
+public class SomeType
+{
+    public SomeType Nested { get; set; }
+    public SomeType Other { get; set; }
+    public SomeType Third { get; set; }
+    public SomeType Child { get; set; }
+    public int Value { get; set; }
+}";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DescriptorNotPreceded).WithLocation(0),
+                Diagnostic(DescriptorFollowed).WithLocation(1),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxKindEx.cs

@@ -79,6 +79,7 @@ internal static class SyntaxKindEx
         public const SyntaxKind PrimaryConstructorBaseType = (SyntaxKind)9065;
         public const SyntaxKind FunctionPointerUnmanagedCallingConventionList = (SyntaxKind)9066;
         public const SyntaxKind RecordStructDeclaration = (SyntaxKind)9068;
+        public const SyntaxKind ExpressionColon = (SyntaxKind)9069;
         public const SyntaxKind CollectionExpression = (SyntaxKind)9076;
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1024ColonsMustBeSpacedCorrectly.cs

@@ -137,6 +137,7 @@ private static void HandleColonToken(SyntaxTreeAnalysisContext context, SyntaxTo
             case SyntaxKindEx.CasePatternSwitchLabel:
             // NameColon is not explicitly listed in the description of this warning, but the behavior is inferred
             case SyntaxKind.NameColon:
+            case SyntaxKindEx.ExpressionColon:
                 requireBefore = false;
                 break;
 

documentation/SA1024.md

@@ -51,6 +51,14 @@ A colon that appears as part of a string interpolation formatting component shou
 var s = $"{x:N}";
 ```
 
+When a colon appears within a property pattern, including nested members referenced through extended property pattern syntax, it is treated like a named element separator. The colon should not be preceded by whitespace, and it should normally be followed by a single space.
+
+```csharp
+if (item is { Outer.Inner: value })
+{
+}
+```
+
 Finally, when a colon is used within a conditional statement, it should always contain a single space on either side, unless the colon is the first or last character on the line. For example:
 
 ```csharp

documentation/SA1101.md

@@ -27,6 +27,14 @@ By default, StyleCop disallows the use of underscores or *m_* to mark local clas
 
 A final advantage of using the 'this.' prefix is that typing *this.* will cause Visual Studio to show the IntelliSense popup, making it quick and easy for the developer to choose the class member to call.
 
+When using property patterns, including the extended property pattern syntax introduced in C# 10, the rule does not require (or allow) `this.` to qualify the properties referenced by the pattern. These expressions refer to members of the value being matched rather than the containing type. For example, no SA1101 diagnostic is reported for the following:
+
+```csharp
+if (item is { Outer.Inner: value })
+{
+}
+```
+
 ## How to fix violations
 
 To fix a violation of this rule, insert the 'this.' prefix before the call to the class member.