Update SA1000 for function pointers

Author: sharwell

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

@@ -1,10 +1,9 @@
 // Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-#nullable disable
-
 namespace StyleCop.Analyzers.Test.CSharp9.SpacingRules
 {
+    using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.SpacingRules;
@@ -16,6 +15,33 @@ namespace StyleCop.Analyzers.Test.CSharp9.SpacingRules
 
     public partial class SA1000CSharp9UnitTests : SA1000CSharp8UnitTests
     {
+        [Fact]
+        [WorkItem(3970, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3970")]
+        public async Task TestFunctionPointerKeywordSpacingAsync()
+        {
+            var testCode = @"public class TestClass
+{
+    private unsafe {|#0:delegate|} *<int, void> pointer1;
+    private unsafe delegate* {|#1:unmanaged|} [Cdecl]<int, void> pointer2;
+}
+";
+
+            var fixedCode = @"public class TestClass
+{
+    private unsafe delegate*<int, void> pointer1;
+    private unsafe delegate* unmanaged[Cdecl]<int, void> pointer2;
+}
+";
+
+            var expected = new[]
+            {
+                Diagnostic().WithArguments("delegate", " not").WithLocation(0),
+                Diagnostic().WithArguments("unmanaged", " not").WithLocation(1),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestTargetTypedNewAsync()
         {

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

@@ -71,6 +71,7 @@ internal static class SyntaxKindEx
         public const SyntaxKind FunctionPointerType = (SyntaxKind)9056;
         public const SyntaxKind FunctionPointerParameter = (SyntaxKind)9057;
         public const SyntaxKind FunctionPointerParameterList = (SyntaxKind)9058;
+        public const SyntaxKind FunctionPointerCallingConvention = (SyntaxKind)9059;
         public const SyntaxKind InitAccessorDeclaration = (SyntaxKind)9060;
         public const SyntaxKind WithExpression = (SyntaxKind)9061;
         public const SyntaxKind WithInitializerExpression = (SyntaxKind)9062;

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1000KeywordsMustBeSpacedCorrectly.cs

@@ -85,6 +85,15 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)
             {
                 switch (token.Kind())
                 {
+                case SyntaxKind.DelegateKeyword:
+                    if (token.Parent.IsKind(SyntaxKindEx.FunctionPointerType))
+                    {
+                        HandleDisallowedSpaceToken(ref context, token);
+                        break;
+                    }
+
+                    goto default;
+
                 case SyntaxKindEx.AndKeyword:
                 case SyntaxKind.AwaitKeyword:
                 case SyntaxKind.CaseKeyword:
@@ -167,6 +176,14 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)
                     HandleThrowKeywordToken(ref context, token);
                     break;
 
+                case SyntaxKindEx.UnmanagedKeyword:
+                    if (token.Parent.IsKind(SyntaxKindEx.FunctionPointerCallingConvention))
+                    {
+                        HandleDisallowedSpaceToken(ref context, token);
+                    }
+
+                    break;
+
                 default:
                     break;
                 }

documentation/SA1000.md

@@ -42,6 +42,10 @@ The `new` and `stackalloc` keywords should always be followed by a space, except
 The `throw` keyword should always be followed by a space, unless it is part of a re-throw statement, in which case there
 should be no space between the `throw` keyword and the semicolon.
 
+In C# 9 function pointer syntax, the `delegate` keyword must not be followed by a space before the `*`, and the
+`unmanaged` keyword must not be followed by a space before the optional calling convention list. For example,
+`delegate*<int, void>` and `delegate* unmanaged[Cdecl]<int, void>` show the expected spacing for this feature.
+
 ## How to fix violations
 
 To fix a violation of this rule, add or remove a space after the keyword, according to the description above.