Moved back to comparing Text, added a test to demonstrate behavior.

Author: 333fred

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -6471,7 +6471,7 @@ private bool IsPossibleCallingConvention(SyntaxToken asteriskToken)
             // we'd have an error anyway, and it's more likely the user intended for it to be a
             // function pointer convention than not.
             // PROTOTYPE(func-ptr): refactor this out into a helper method to share with binding
-            switch (CurrentToken.ValueText)
+            switch (CurrentToken.Text)
             {
                 case "cdecl":
                 case "managed":

src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs

@@ -809,6 +809,47 @@ public void Unterminated_10()
             EOF();
         }
 
+        [Fact]
+        public void Unterminated_11()
+        {
+            UsingStatement("delegate* @cdecl>", options: TestOptions.RegularPreview,
+                // (1,11): error CS1003: Syntax error, '<' expected
+                // delegate* @cdecl>
+                Diagnostic(ErrorCode.ERR_SyntaxError, "@cdecl").WithArguments("<", "").WithLocation(1, 11),
+                // (1,17): error CS1003: Syntax error, ',' expected
+                // delegate* @cdecl>
+                Diagnostic(ErrorCode.ERR_SyntaxError, ">").WithArguments(",", ">").WithLocation(1, 17),
+                // (1,18): error CS1002: ; expected
+                // delegate* @cdecl>
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 18));
+            N(SyntaxKind.LocalDeclarationStatement);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.FunctionPointerType);
+                    {
+                        N(SyntaxKind.DelegateKeyword);
+                        N(SyntaxKind.AsteriskToken);
+                        M(SyntaxKind.LessThanToken);
+                        M(SyntaxKind.ModifiedType);
+                        {
+                            M(SyntaxKind.IdentifierName);
+                            {
+                                M(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                        M(SyntaxKind.GreaterThanToken);
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "@cdecl");
+                    }
+                }
+                M(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
         [Fact]
         public void NoParamOrReturnTypes()
         {