Improve error recovery for => in constructor initializers (#80764)

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: CyrusNajmabadi <[email protected]>
Co-authored-by: Cyrus Najmabadi <[email protected]>

Author: Copilot

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

@@ -3362,6 +3362,8 @@ public static bool IsComplete(CSharpSyntaxNode node)
             return true;
         }
 
+#nullable enable
+
         private ConstructorDeclarationSyntax ParseConstructorDeclaration(
             SyntaxList<AttributeListSyntax> attributes, SyntaxListBuilder modifiers)
         {
@@ -3371,9 +3373,7 @@ private ConstructorDeclarationSyntax ParseConstructorDeclaration(
             try
             {
                 var paramList = this.ParseParenthesizedParameterList(forExtension: false);
-                var initializer = this.CurrentToken.Kind == SyntaxKind.ColonToken
-                    ? this.ParseConstructorInitializer()
-                    : null;
+                var initializer = this.TryParseConstructorInitializer();
 
                 this.ParseBlockAndExpressionBodiesWithSemicolon(out var body, out var expressionBody, out var semicolon);
 
@@ -3385,38 +3385,48 @@ private ConstructorDeclarationSyntax ParseConstructorDeclaration(
             }
         }
 
-        private ConstructorInitializerSyntax ParseConstructorInitializer()
+        private ConstructorInitializerSyntax? TryParseConstructorInitializer()
         {
-            var colon = this.EatToken(SyntaxKind.ColonToken);
+            var currentTokenKind = this.CurrentToken.Kind;
+            var shouldParse = currentTokenKind is SyntaxKind.ColonToken ||
+                (currentTokenKind is SyntaxKind.EqualsGreaterThanToken &&
+                 this.PeekToken(1).Kind is SyntaxKind.ThisKeyword or SyntaxKind.BaseKeyword &&
+                 this.PeekToken(2).Kind is SyntaxKind.OpenParenToken);
 
-            var reportError = true;
-            var kind = this.CurrentToken.Kind == SyntaxKind.BaseKeyword
-                ? SyntaxKind.BaseConstructorInitializer
-                : SyntaxKind.ThisConstructorInitializer;
+            if (!shouldParse)
+                return null;
 
-            SyntaxToken token;
-            if (this.CurrentToken.Kind is SyntaxKind.BaseKeyword or SyntaxKind.ThisKeyword)
-            {
-                token = this.EatToken();
-            }
-            else
-            {
-                token = this.EatToken(SyntaxKind.ThisKeyword, ErrorCode.ERR_ThisOrBaseExpected);
+            return ParseConstructorInitializer();
+        }
 
-                // No need to report further errors at this point:
-                reportError = false;
-            }
+        private ConstructorInitializerSyntax ParseConstructorInitializer()
+        {
+            // Normally called for `:` but also in some error recovery circumstances for `=>`. EatTokenAsKind handles
+            // both cases properly, producing the right errors we need in the latter case, and always consuming
+            // whichever token we're coming into this method on.
+            Debug.Assert(this.CurrentToken.Kind is SyntaxKind.ColonToken or SyntaxKind.EqualsGreaterThanToken);
+            var colon = this.EatTokenAsKind(SyntaxKind.ColonToken);
+
+            var token = this.CurrentToken.Kind is SyntaxKind.BaseKeyword or SyntaxKind.ThisKeyword
+                ? this.EatToken()
+                : this.EatToken(SyntaxKind.ThisKeyword, ErrorCode.ERR_ThisOrBaseExpected);
 
             var argumentList = this.CurrentToken.Kind == SyntaxKind.OpenParenToken
                 ? this.ParseParenthesizedArgumentList()
                 : _syntaxFactory.ArgumentList(
-                    this.EatToken(SyntaxKind.OpenParenToken, reportError),
+                    this.EatToken(SyntaxKind.OpenParenToken, reportError: !token.ContainsDiagnostics),
                     arguments: default,
-                    this.EatToken(SyntaxKind.CloseParenToken, reportError));
+                    this.EatToken(SyntaxKind.CloseParenToken, reportError: !token.ContainsDiagnostics));
 
-            return _syntaxFactory.ConstructorInitializer(kind, colon, token, argumentList);
+            return _syntaxFactory.ConstructorInitializer(
+                token.Kind == SyntaxKind.BaseKeyword
+                    ? SyntaxKind.BaseConstructorInitializer
+                    : SyntaxKind.ThisConstructorInitializer,
+                colon, token, argumentList);
         }
 
+#nullable disable
+
         private DestructorDeclarationSyntax ParseDestructorDeclaration(SyntaxList<AttributeListSyntax> attributes, SyntaxListBuilder modifiers)
         {
             Debug.Assert(this.CurrentToken.Kind == SyntaxKind.TildeToken);