Merge pull request #3252 from NextTurn/sa1023

Fix SA1023 for C# 9 function pointer parameters

Author: sharwell

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

@@ -3,9 +3,86 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.SpacingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.SpacingRules;
+    using StyleCop.Analyzers.Test.Verifiers;
+    using Xunit;
+    using static StyleCop.Analyzers.SpacingRules.SA1023DereferenceAndAccessOfSymbolsMustBeSpacedCorrectly;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.SpacingRules.SA1023DereferenceAndAccessOfSymbolsMustBeSpacedCorrectly,
+        StyleCop.Analyzers.SpacingRules.TokenSpacingCodeFixProvider>;
 
     public class SA1023CSharp9UnitTests : SA1023CSharp8UnitTests
     {
+        [Fact]
+        public async Task TestFunctionPointerParameterInvalidSpacingAsync()
+        {
+            var testCode = @"public class TestClass
+{
+    unsafe delegate*<int {|#0:*|}> FuncPtr1;
+    unsafe delegate*<int{|#1:*|} > FuncPtr2;
+}
+";
+
+            var fixedCode = @"public class TestClass
+{
+    unsafe delegate*<int*> FuncPtr1;
+    unsafe delegate*<int*> FuncPtr2;
+}
+";
+
+            var expected = new[]
+            {
+                Diagnostic(DescriptorNotPreceded).WithLocation(0),
+                Diagnostic(DescriptorNotFollowed).WithLocation(1),
+            };
+
+            await VerifyCSharpFixAsync(LanguageVersion.CSharp9, testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestFunctionPointerTypeInvalidSpacingAsync()
+        {
+            var testCode = @"public class TestClass
+{
+    unsafe delegate {|#0:*|}<int*> FuncPtr1;
+    unsafe delegate{|#1:*|} <int*> FuncPtr2;
+    unsafe delegate {|#2:*|} managed<int*> FuncPtr3;
+    unsafe delegate{|#3:*|}managed<int*> FuncPtr4;
+    unsafe delegate {|#4:*|} unmanaged<int*> FuncPtr5;
+    unsafe delegate{|#5:*|}unmanaged<int*> FuncPtr6;
+}
+";
+
+            var fixedCode = @"public class TestClass
+{
+    unsafe delegate*<int*> FuncPtr1;
+    unsafe delegate*<int*> FuncPtr2;
+    unsafe delegate* managed<int*> FuncPtr3;
+    unsafe delegate* managed<int*> FuncPtr4;
+    unsafe delegate* unmanaged<int*> FuncPtr5;
+    unsafe delegate* unmanaged<int*> FuncPtr6;
+}
+";
+
+            await new CSharpTest(LanguageVersion.CSharp9)
+            {
+                ReferenceAssemblies = GenericAnalyzerTest.ReferenceAssembliesNet50,
+                TestCode = testCode,
+                FixedCode = fixedCode,
+                ExpectedDiagnostics =
+                {
+                    Diagnostic(DescriptorNotPreceded).WithLocation(0),
+                    Diagnostic(DescriptorNotFollowed).WithLocation(1),
+                    Diagnostic(DescriptorNotPreceded).WithLocation(2),
+                    Diagnostic(DescriptorFollowed).WithLocation(3),
+                    Diagnostic(DescriptorNotPreceded).WithLocation(4),
+                    Diagnostic(DescriptorFollowed).WithLocation(5),
+                },
+            }.RunAsync().ConfigureAwait(false);
+        }
     }
 }

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

@@ -9,6 +9,8 @@ internal static class SyntaxKindEx
     {
         public const SyntaxKind DotDotToken = (SyntaxKind)8222;
         public const SyntaxKind QuestionQuestionEqualsToken = (SyntaxKind)8284;
+        public const SyntaxKind ManagedKeyword = (SyntaxKind)8445;
+        public const SyntaxKind UnmanagedKeyword = (SyntaxKind)8446;
         public const SyntaxKind NullableKeyword = (SyntaxKind)8486;
         public const SyntaxKind EnableKeyword = (SyntaxKind)8487;
         public const SyntaxKind WarningsKeyword = (SyntaxKind)8488;
@@ -49,6 +51,8 @@ internal static class SyntaxKindEx
         public const SyntaxKind ImplicitStackAllocArrayCreationExpression = (SyntaxKind)9053;
         public const SyntaxKind SuppressNullableWarningExpression = (SyntaxKind)9054;
         public const SyntaxKind NullableDirectiveTrivia = (SyntaxKind)9055;
+        public const SyntaxKind FunctionPointerType = (SyntaxKind)9056;
+        public const SyntaxKind FunctionPointerParameter = (SyntaxKind)9057;
         public const SyntaxKind WithInitializerExpression = (SyntaxKind)9062;
         public const SyntaxKind RecordDeclaration = (SyntaxKind)9063;
         public const SyntaxKind FunctionPointerUnmanagedCallingConventionList = (SyntaxKind)9066;

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1023DereferenceAndAccessOfSymbolsMustBeSpacedCorrectly.cs

@@ -9,6 +9,7 @@ namespace StyleCop.Analyzers.SpacingRules
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// A dereference symbol or an access-of symbol within a C# element is not spaced correctly.
@@ -112,11 +113,37 @@ private static void HandleAsteriskToken(SyntaxTreeAnalysisContext context, Synta
             bool allowTrailingSpace;
             switch (token.Parent.Kind())
             {
+            case SyntaxKindEx.FunctionPointerType:
+                allowAtLineStart = true;
+                allowAtLineEnd = true;
+                allowPrecedingSpace = false;
+                var nextToken = token.GetNextToken();
+                switch (nextToken.Kind())
+                {
+                case SyntaxKindEx.ManagedKeyword:
+                case SyntaxKindEx.UnmanagedKeyword:
+                    allowTrailingSpace = true;
+                    break;
+
+                default:
+                    allowTrailingSpace = false;
+                    break;
+                }
+
+                break;
+
+            case SyntaxKind.PointerType when token.Parent.Parent.IsKind(SyntaxKindEx.FunctionPointerParameter):
+                allowAtLineStart = true;
+                allowAtLineEnd = true;
+                allowPrecedingSpace = false;
+                allowTrailingSpace = false;
+                break;
+
             case SyntaxKind.PointerType:
                 allowAtLineStart = false;
                 allowAtLineEnd = true;
                 allowPrecedingSpace = false;
-                var nextToken = token.GetNextToken();
+                nextToken = token.GetNextToken();
                 switch (nextToken.Kind())
                 {
                 case SyntaxKind.OpenBracketToken: