Basic handling of function pointer types in the IDE

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -108,6 +108,8 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeA
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string text, int offset, bool consumeFullText) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> TResult
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
@@ -122,6 +124,7 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAn
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string text, int offset = 0, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> void

src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs

@@ -1693,9 +1693,19 @@ public static NameSyntax ParseName(string text, int offset = 0, bool consumeFull
         /// <summary>
         /// Parse a TypeNameSyntax node using the grammar rule for type names.
         /// </summary>
-        public static TypeSyntax ParseTypeName(string text, int offset = 0, bool consumeFullText = true)
+        // Backcompat overload, do not remove
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static TypeSyntax ParseTypeName(string text, int offset, bool consumeFullText)
         {
-            using (var lexer = MakeLexer(text, offset))
+            return ParseTypeName(text, offset, options: null, consumeFullText);
+        }
+
+        /// <summary>
+        /// Parse a TypeNameSyntax node using the grammar rule for type names.
+        /// </summary>
+        public static TypeSyntax ParseTypeName(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
+        {
+            using (var lexer = MakeLexer(text, offset, (CSharpParseOptions?)options))
             using (var parser = MakeParser(lexer))
             {
                 var node = parser.ParseTypeName();

src/Compilers/VisualBasic/Portable/PublicAPI.Unshipped.txt

@@ -1 +1,3 @@
-
+Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.ParseTypeName(text As String, offset As Integer = 0, options As Microsoft.CodeAnalysis.ParseOptions = Nothing, consumeFullText As Boolean = True) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TypeSyntax
+Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.ParseTypeName(text As String, offset As Integer, consumeFullText As Boolean) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TypeSyntax
+*REMOVED*Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.ParseTypeName(text As String, offset As Integer = 0, consumeFullText As Boolean = True) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TypeSyntax

src/Compilers/VisualBasic/Portable/Syntax/SyntaxNodeFactories.vb

@@ -15,6 +15,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.SyntaxFacts
 Imports InternalSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax
 Imports Microsoft.CodeAnalysis.Syntax
 Imports System.Collections.Immutable
+Imports System.ComponentModel
 
 Namespace Microsoft.CodeAnalysis.VisualBasic
 
@@ -191,14 +192,25 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' </summary>
         ''' <param name="text">The input string</param>
         ''' <param name="offset">The starting offset in the string</param>
-        Public Shared Function ParseTypeName(text As String, Optional offset As Integer = 0, Optional consumeFullText As Boolean = True) As TypeSyntax
-            Using p = New InternalSyntax.Parser(MakeSourceText(text, offset), VisualBasicParseOptions.Default)
+        Public Shared Function ParseTypeName(text As String, Optional offset As Integer = 0, Optional options As ParseOptions = Nothing, Optional consumeFullText As Boolean = True) As TypeSyntax
+            Using p = New InternalSyntax.Parser(MakeSourceText(text, offset), If(DirectCast(options, VisualBasicParseOptions), VisualBasicParseOptions.Default))
                 p.GetNextToken()
                 Dim node = p.ParseGeneralType()
                 Return DirectCast(If(consumeFullText, p.ConsumeUnexpectedTokens(node), node).CreateRed(Nothing, 0), TypeSyntax)
             End Using
         End Function
 
+        '' Backcompat overload, do not touch
+        ''' <summary>
+        ''' Parse a type name.
+        ''' </summary>
+        ''' <param name="text">The input string</param>
+        ''' <param name="offset">The starting offset in the string</param>
+        <EditorBrowsable(EditorBrowsableState.Never)>
+        Public Shared Function ParseTypeName(text As String, offset As Integer, consumeFullText As Boolean) As TypeSyntax
+            Return ParseTypeName(text, offset, options:=Nothing, consumeFullText)
+        End Function
+
         ''' <summary>
         ''' Parse an expression.
         ''' </summary>

src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs

@@ -35,6 +35,7 @@ public override bool CheckOpeningPoint(IBraceCompletionSession session, Cancella
             // type argument or parameter list
             if (!token.CheckParent<TypeParameterListSyntax>(n => n.LessThanToken == token) &&
                 !token.CheckParent<TypeArgumentListSyntax>(n => n.LessThanToken == token) &&
+                !token.CheckParent<FunctionPointerTypeSyntax>(n => n.LessThanToken == token) &&
                 !PossibleTypeArgument(snapshot, token, cancellationToken))
             {
                 return false;

src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs

@@ -11109,17 +11109,17 @@ public async Task ExtractMethodInInterface()
             var code = @"
 interface Program
 {
-    void Foo();
+    void Goo();
 
     void Test()
     {
-        [|Foo();|]
+        [|Goo();|]
     }
 }";
             var expected = @"
 interface Program
 {
-    void Foo();
+    void Goo();
 
     void Test()
     {
@@ -11128,7 +11128,7 @@ void Test()
 
     void NewMethod()
     {
-        Foo();
+        Goo();
     }
 }";
             await TestExtractMethodAsync(code, expected);
@@ -11139,18 +11139,18 @@ void NewMethod()
         public async Task ExtractMethodInExpressionBodiedConstructors()
         {
             var code = @"
-class Foo
+class Goo
 {
     private readonly string _bar;
 
-    private Foo(string bar) => _bar = [|bar|];
+    private Goo(string bar) => _bar = [|bar|];
 }";
             var expected = @"
-class Foo
+class Goo
 {
     private readonly string _bar;
 
-    private Foo(string bar) => _bar = GetBar(bar);
+    private Goo(string bar) => _bar = GetBar(bar);
 
     private static string GetBar(string bar)
     {
@@ -11165,18 +11165,18 @@ private static string GetBar(string bar)
         public async Task ExtractMethodInExpressionBodiedFinalizers()
         {
             var code = @"
-class Foo
+class Goo
 {
     bool finalized;
 
-    ~Foo() => finalized = [|true|];
+    ~Goo() => finalized = [|true|];
 }";
             var expected = @"
-class Foo
+class Goo
 {
     bool finalized;
 
-    ~Foo() => finalized = NewMethod();
+    ~Goo() => finalized = NewMethod();
 
     private static bool NewMethod()
     {
@@ -11185,5 +11185,65 @@ private static bool NewMethod()
 }";
             await TestExtractMethodAsync(code, expected);
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
+        public async Task ExtractMethodInvolvingFunctionPointer()
+        {
+            var code = @"
+class C
+{
+    void M(delegate*<delegate*<ref string, ref readonly int>> ptr1)
+    {
+        string s = null;
+        _ = [|ptr1()|](ref s);
+    }
+}";
+
+            var expected = @"
+class C
+{
+    void M(delegate*<delegate*<ref string, ref readonly int>> ptr1)
+    {
+        string s = null;
+        _ = NewMethod(ptr1)(ref s);
+    }
+
+    private static delegate*<ref string, ref readonly int> NewMethod(delegate*<delegate*<ref string, ref readonly int>> ptr1)
+    {
+        return ptr1();
+    }
+}";
+
+            await TestExtractMethodAsync(code, expected);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
+        public async Task ExtractMethodInvolvingFunctionPointerWithTypeParameter()
+        {
+            var code = @"
+class C
+{
+    void M<T1, T2>(delegate*<T1, T2> ptr1)
+    {
+        _ = [|ptr1|]();
+    }
+}";
+
+            var expected = @"
+class C
+{
+    void M<T1, T2>(delegate*<T1, T2> ptr1)
+    {
+        _ = GetPtr1(ptr1)();
+    }
+
+    private static delegate*<T1, T2> GetPtr1<T1, T2>(delegate*<T1, T2> ptr1)
+    {
+        return ptr1;
+    }
+}";
+
+            await TestExtractMethodAsync(code, expected);
+        }
     }
 }

src/EditorFeatures/CSharpTest2/Recommendations/BoolKeywordRecommenderTests.cs

@@ -716,5 +716,41 @@ void Method()
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerType()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<$$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterComma()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<int, $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterModifier()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<ref $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterDelegateAsterisk()
+        {
+            await VerifyAbsenceAsync(@"
+class C
+{
+    delegate*$$");
+        }
     }
 }

src/EditorFeatures/CSharpTest2/Recommendations/ByteKeywordRecommenderTests.cs

@@ -716,6 +716,42 @@ void Method()
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerType()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<$$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterComma()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<int, $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterModifier()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<ref $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterDelegateAsterisk()
+        {
+            await VerifyAbsenceAsync(@"
+class C
+{
+    delegate*$$");
+        }
     }
 }
 

src/EditorFeatures/CSharpTest2/Recommendations/CharKeywordRecommenderTests.cs

@@ -767,5 +767,41 @@ void Method()
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerType()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<$$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterComma()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<int, $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterModifier()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<ref $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterDelegateAsterisk()
+        {
+            await VerifyAbsenceAsync(@"
+class C
+{
+    delegate*$$");
+        }
     }
 }

src/EditorFeatures/CSharpTest2/Recommendations/DecimalKeywordRecommenderTests.cs

@@ -732,5 +732,41 @@ void Method()
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerType()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<$$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterComma()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<int, $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInFunctionPointerTypeAfterModifier()
+        {
+            await VerifyKeywordAsync(@"
+class C
+{
+    delegate*<ref $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestNotAfterDelegateAsterisk()
+        {
+            await VerifyAbsenceAsync(@"
+class C
+{
+    delegate*$$");
+        }
     }
 }