Function pointer calling convention IDE support

src/EditorFeatures/CSharpTest/Classification/SyntacticClassifierTests.cs

@@ -5564,9 +5564,9 @@ await TestAsync(code,
                 Operators.Asterisk,
                 Keyword("unmanaged"),
                 Punctuation.OpenBracket,
-                Identifier("Stdcall"),
+                Class("Stdcall"),
                 Punctuation.Comma,
-                Identifier("SuppressGCTransition"),
+                Class("SuppressGCTransition"),
                 Punctuation.CloseBracket,
                 Punctuation.OpenAngle,
                 Keyword("int"),

src/EditorFeatures/CSharpTest/Classification/TotalClassifierTests.cs

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

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/FunctionPointerUnmanagedCallingConventionCompletionProviderTests.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Completion.Providers;

src/EditorFeatures/Test2/GoToDefinition/CSharpGoToDefinitionTests.vb

@@ -3333,5 +3333,120 @@ $$
 
             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_Single_SpecialConv()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferencesNet6="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[St$$dcall]<void> f0;
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace)
+        End Sub
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.GoToDefinition)>
+        <WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")>
+        Public Sub FunctionPointerCallingConvention_Single_NonSpecialConv()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferencesNet6="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[M$$emberFunction]<void> f0;
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace)
+        End Sub
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.GoToDefinition)>
+        <WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")>
+        Public Sub FunctionPointerCallingConvention_Multiple_SpecialConv()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferencesNet6="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[St$$dcall, MemberFunction]<void> f0;
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace)
+        End Sub
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.GoToDefinition)>
+        <WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")>
+        Public Sub FunctionPointerCallingConvention_Multiple_NonSpecialConv()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferencesNet6="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[Stdcall, M$$emberFunction]<void> f0;
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace)
+        End Sub
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.GoToDefinition)>
+        <WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")>
+        Public Sub FunctionPointerCallingConvention_Multiple_AllAreSpecialConv()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferencesNet6="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[St$$dcall, Fastcall]<void> f0;
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace)
+        End Sub
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.GoToDefinition)>
+        <WorkItem(59052, "https://github.com/dotnet/roslyn/issues/59052")>
+        Public Sub FunctionPointerCallingConvention_NotFromCorLib()
+            Dim workspace =
+<Workspace>
+    <Project Language="C#" CommonReferencesNet45="true">
+        <Document><![CDATA[
+public unsafe class C
+{
+    delegate* unmanaged[Stdcall, M$$emberFunction]<void> f0;
+}
+
+namespace System.Runtime.CompilerServices
+{
+    public class CallConvMemberFunction 
+    {
+    }
+}
+        ]]></Document>
+    </Project>
+</Workspace>
+
+            Test(workspace, expectedResult:=False)
+        End Sub
     End Class
 End Namespace

src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_Create.cs

@@ -50,6 +50,7 @@ public partial class TestWorkspace
         private const string CommonReferencesNet45AttributeName = "CommonReferencesNet45";
         private const string CommonReferencesPortableAttributeName = "CommonReferencesPortable";
         private const string CommonReferencesNetCoreAppName = "CommonReferencesNetCoreApp";
+        private const string CommonReferencesNet6Name = "CommonReferencesNet6";
         private const string CommonReferencesNetStandard20Name = "CommonReferencesNetStandard20";
         private const string ReferencesOnDiskAttributeName = "ReferencesOnDisk";
         private const string FilePathAttributeName = "FilePath";

src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs

@@ -1078,6 +1078,14 @@ private static IList<MetadataReference> CreateCommonReferences(TestWorkspace wor
                 references = TargetFrameworkUtil.NetStandard20References.ToList();
             }
 
+            var net6 = element.Attribute(CommonReferencesNet6Name);
+            if (net6 != null &&
+                ((bool?)net6).HasValue &&
+                ((bool?)net6).Value)
+            {
+                references = TargetFrameworkUtil.GetReferences(TargetFramework.Net60).ToList();
+            }
+
             return references;
         }
 

src/Workspaces/CSharp/Portable/Classification/ClassificationHelpers.cs

@@ -289,6 +289,10 @@ private static bool IsVerbatimStringToken(SyntaxToken token)
             {
                 return ClassificationTypeNames.LabelName;
             }
+            else if (token.Parent.IsKind(SyntaxKind.FunctionPointerUnmanagedCallingConvention))
+            {
+                return ClassificationTypeNames.ClassName;
+            }
             else
             {
                 return ClassificationTypeNames.Identifier;

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

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

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

@@ -267,10 +267,22 @@ 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)
+        {
+            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/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);
+        }
     }
 }