Correct incomplete record parsing (#51610)

Author: jcouv

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

@@ -2218,8 +2218,6 @@ private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind
                         token = this.AddError(token, ErrorCode.ERR_MemberNeedsType);
                         var voidType = _syntaxFactory.PredefinedType(token);
 
-                        var identifier = this.EatToken();
-
                         if (!IsScript)
                         {
                             if (tryParseLocalDeclarationStatementFromStartPoint<LocalFunctionStatementSyntax>(attributes, ref afterAttributesPoint, out result))
@@ -2229,6 +2227,7 @@ private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind
                         }
                         else
                         {
+                            var identifier = this.EatToken();
                             return this.ParseMethodDeclaration(attributes, modifiers, voidType, explicitInterfaceOpt: null, identifier: identifier, typeParameterList: null);
                         }
                     }

src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs

@@ -28371,5 +28371,27 @@ public static class IsExternalInit
 </member>
 ", constructor.GetDocumentationCommentXml());
         }
+
+        [Fact, WorkItem(51590, "https://github.com/dotnet/roslyn/issues/51590")]
+        public void SealedIncomplete()
+        {
+            var source = @"
+public sealed record(";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (2,21): error CS1001: Identifier expected
+                // public sealed record(
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(2, 21),
+                // (2,22): error CS1026: ) expected
+                // public sealed record(
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(2, 22),
+                // (2,22): error CS1514: { expected
+                // public sealed record(
+                Diagnostic(ErrorCode.ERR_LbraceExpected, "").WithLocation(2, 22),
+                // (2,22): error CS1513: } expected
+                // public sealed record(
+                Diagnostic(ErrorCode.ERR_RbraceExpected, "").WithLocation(2, 22)
+                );
+        }
     }
 }

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

@@ -3,10 +3,13 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Text;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
 using Xunit.Abstractions;
@@ -319,5 +322,42 @@ private void Done(bool dump)
                 _output.WriteLine("EOF();");
             }
         }
+
+        protected static void ParseIncompleteSyntax(string text)
+        {
+            var tokens = getLexedTokens(text);
+
+            var stringBuilder = new StringBuilder();
+            for (int skip = 0; skip < tokens.Length; skip++)
+            {
+                stringBuilder.Clear();
+
+                for (int i = 0; i < tokens.Length; i++)
+                {
+                    if (i == skip)
+                    {
+                        continue;
+                    }
+                    stringBuilder.Append(tokens[i].Text);
+                    stringBuilder.Append(' ');
+
+                    // Verify that we can parse and round-trip
+                    _ = SyntaxFactory.ParseSyntaxTree(stringBuilder.ToString(), TestOptions.RegularPreview);
+                }
+            }
+
+            static ImmutableArray<Syntax.InternalSyntax.SyntaxToken> getLexedTokens(string text)
+            {
+                var lexer = new Syntax.InternalSyntax.Lexer(Text.SourceText.From(text), CSharpParseOptions.Default);
+                var tokensBuilder = ArrayBuilder<Syntax.InternalSyntax.SyntaxToken>.GetInstance();
+
+                while (lexer.Lex(Syntax.InternalSyntax.LexerMode.Syntax) is var token && token.Kind != SyntaxKind.EndOfFileToken)
+                {
+                    tokensBuilder.Add(token);
+                }
+
+                return tokensBuilder.ToImmutableAndFree();
+            }
+        }
     }
 }

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

@@ -2608,5 +2608,11 @@ public void Base_05()
             }
             EOF();
         }
+
+        [Fact, WorkItem(51590, "https://github.com/dotnet/roslyn/issues/51590")]
+        public void ParseIncompleteRecordSyntax()
+        {
+            ParseIncompleteSyntax("public sealed record C() { }");
+        }
     }
 }