Update SA1015 for nullable reference types

Author: sharwell

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

@@ -35,5 +35,61 @@ public struct Foo<T>
 
             await VerifyCSharpFixAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
+
+        /// <summary>
+        /// Verifies that nullable reference type annotations following closing generic brackets do not produce diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3006, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3006")]
+        public async Task TestNullableReferenceTypeAnnotationsAsync()
+        {
+            const string testCode = @"#nullable enable
+using System.Collections.Generic;
+
+public class TestClass
+{
+    private List<string?>? names;
+    private Dictionary<string, List<object?>?>? items;
+
+    public IReadOnlyList<List<string?>?>? Property { get; }
+
+    public void TestMethod()
+    {
+        List<(string? key, List<string?>? values)>? local = null;
+        List<string?>?[]? jagged = null;
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that nullable reference type constraints involving generic types are handled without diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3006, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3006")]
+        public async Task TestNullableReferenceTypeConstraintsAsync()
+        {
+            const string testCode = @"#nullable enable
+using System.Collections.Generic;
+
+public class ConstraintClass<T> where T : class
+{
+    public void TestMethod<TValue>(TValue? value)
+        where TValue : class, IEnumerable<T?>?
+    {
+        if (value is List<T?> items)
+        {
+            _ = items;
+        }
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

documentation/SA1015.md

@@ -24,14 +24,14 @@ A closing generic bracket within a C# element is not spaced correctly.
 A violation of this rule occurs when the spacing around a closing generic bracket is not correct.
 
 A closing generic bracket should never be preceded by whitespace, unless the bracket is the first character on the line.
-                    A closing generic bracket should be followed by an open parenthesis, a close 
-                    parenthesis, a closing generic bracket, a nullable symbol, an end of 
-                    line or a single whitespace (but not whitespace and an open parenthesis).
+A closing generic bracket should be followed by an open parenthesis, a close parenthesis, a closing generic bracket, a
+nullable symbol, an end of line or a single whitespace (but not whitespace and an open parenthesis). In nullable-aware
+contexts, nullable reference type annotations (for example `List<string?>?`) follow the same rules as nullable value
+types.
 
 ## How to fix violations
 
-To fix a violation of this rule, ensure the whitespace around the closing generic bracket 
-                    is correct.
+To fix a violation of this rule, ensure the whitespace around the closing generic bracket is correct.
 
 ## How to suppress violations