Function pointer calling convention IDE support

src/EditorFeatures/CSharpTest/Classification/TotalClassifierTests.cs

@@ -2189,5 +2189,36 @@ public async Task TestStringEscape(TestHost testHost)
                 Verbatim("\""),
                 Punctuation.Semicolon);
         }
+
+        [Theory]
+        [CombinatorialData]
+        [WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")]
+        public async Task FunctionPointerCallingConventions(TestHost testHost)
+        {
+            await TestAsync(@"
+public unsafe class C
+{
+    delegate* unmanaged[Stdcall]<void> f0;
+}
+",
+                testHost,
+                Keyword("public"),
+                Keyword("unsafe"),
+                Keyword("class"),
+                Class("C"),
+                Punctuation.OpenCurly,
+                Keyword("delegate"),
+                Operators.Asterisk,
+                Keyword("unmanaged"),
+                Punctuation.OpenBracket,
+                Class("Stdcall"),
+                Punctuation.CloseBracket,
+                Punctuation.OpenAngle,
+                Keyword("void"),
+                Punctuation.CloseAngle,
+                Field("f0"),
+                Punctuation.Semicolon,
+                Punctuation.CloseCurly);
+        }
     }
 }

src/EditorFeatures/Test2/GoToDefinition/CSharpGoToDefinitionTests.vb

@@ -3333,5 +3333,23 @@ $$
 
             Test(workspace, expectedResult:=False)
         End Sub
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.GoToDefinition)>
+        <WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")>
+        Public Sub FunctionPointerCallingConvention()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[St$$dcall]<void> f0;
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace)
+        End Sub
     End Class
 End Namespace

src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/CSharpSyntaxClassificationService.cs

@@ -37,7 +37,8 @@ public CSharpSyntaxClassificationService(HostLanguageServices languageServices)
                     new OperatorOverloadSyntaxClassifier(),
                     new SyntaxTokenClassifier(),
                     new UsingDirectiveSyntaxClassifier(),
-                    new DiscardSyntaxClassifier()
+                    new DiscardSyntaxClassifier(),
+                    new FunctionPointerCallingConventionClassifier(),
                 });
         }
 

src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/FunctionPointerCallingConventionClassifier.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Classification.Classifiers;
+using Microsoft.CodeAnalysis.CSharp.LanguageServices;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.CSharp.Classification
+{
+    internal class FunctionPointerCallingConventionClassifier : AbstractSyntaxClassifier
+    {
+        public override ImmutableArray<Type> SyntaxNodeTypes { get; } = ImmutableArray.Create(
+            typeof(FunctionPointerUnmanagedCallingConventionSyntax));
+
+        public override void AddClassifications(
+            SyntaxNode syntax,
+            SemanticModel semanticModel,
+            ClassificationOptions options,
+            ArrayBuilder<ClassifiedSpan> result,
+            CancellationToken cancellationToken)
+        {
+            var callingConventionSyntax = (FunctionPointerUnmanagedCallingConventionSyntax)syntax;
+            if (CSharpSyntaxFacts.Instance.IsSpecialUnmanagedCallingConvention(callingConventionSyntax))
+            {
+                result.Add(new ClassifiedSpan(callingConventionSyntax.Span, ClassificationTypeNames.ClassName));
+                return;
+            }
+
+            var type = semanticModel.Compilation.UnmanagedCallingConventionType(callingConventionSyntax.Name.ValueText);
+            if (type is not null)
+            {
+                result.Add(new ClassifiedSpan(callingConventionSyntax.Name.Span, ClassificationTypeNames.ClassName));
+            }
+        }
+    }
+}

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs

@@ -267,10 +267,27 @@ public ImmutableArray<ISymbol> GetBestOrAllSymbols(SemanticModel semanticModel,
             {
                 AssignmentExpressionSyntax _ when token.Kind() == SyntaxKind.EqualsToken => GetDeconstructionAssignmentMethods(semanticModel, node).As<ISymbol>(),
                 ForEachVariableStatementSyntax _ when token.Kind() == SyntaxKind.InKeyword => GetDeconstructionForEachMethods(semanticModel, node).As<ISymbol>(),
+                FunctionPointerUnmanagedCallingConventionSyntax callingConvention => GetCallingConventionSymbol(semanticModel, callingConvention),
                 _ => GetSymbolInfo(semanticModel, node, token, cancellationToken).GetBestOrAllSymbols(),
             };
         }
 
+        private static ImmutableArray<ISymbol> GetCallingConventionSymbol(SemanticModel model, FunctionPointerUnmanagedCallingConventionSyntax syntax)
+        {
+            if (CSharpSyntaxFacts.Instance.IsSpecialUnmanagedCallingConvention(syntax))
+            {
+                return ImmutableArray<ISymbol>.Empty;
+            }
+
+            var type = model.Compilation.UnmanagedCallingConventionType(syntax.Name.ValueText);
+            if (type is null)
+            {
+                return ImmutableArray<ISymbol>.Empty;
+            }
+
+            return ImmutableArray.Create<ISymbol>(type);
+        }
+
         private static SymbolInfo GetSymbolInfo(SemanticModel semanticModel, SyntaxNode node, SyntaxToken token, CancellationToken cancellationToken)
         {
             switch (node)

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs

@@ -1554,6 +1554,17 @@ public bool IsVerbatimInterpolatedStringExpression(SyntaxNode node)
             => node is InterpolatedStringExpressionSyntax interpolatedString &&
                 interpolatedString.StringStartToken.IsKind(SyntaxKind.InterpolatedVerbatimStringStartToken);
 
+        public bool IsSpecialUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax syntax)
+        {
+            if (syntax.Parent is not FunctionPointerUnmanagedCallingConventionListSyntax list)
+            {
+                return false;
+            }
+
+            return list.CallingConventions.Count == 1 &&
+                syntax.Name.ValueText is "Cdecl" or "Stdcall" or "Thiscall" or "Fastcall");
+        }
+
         #region IsXXX members
 
         public bool IsAnonymousFunctionExpression([NotNullWhen(true)] SyntaxNode? node)

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ICompilationExtensions.cs

@@ -211,5 +211,11 @@ public static ImmutableArray<IAssemblySymbol> GetReferencedAssemblySymbols(this
 
         public static INamedTypeSymbol? DisallowNullAttribute(this Compilation compilation)
             => compilation.GetTypeByMetadataName(typeof(DisallowNullAttribute).FullName!);
+
+        public static INamedTypeSymbol? UnmanagedCallingConventionType(this Compilation compilation, string callConv)
+        {
+            var corLibrary = compilation.GetSpecialType(SpecialType.System_Object).ContainingAssembly;
+            return corLibrary.GetTypeByMetadataName("System.Runtime.CompilerServices.CallConv" + callConv);
+        }
     }
 }