Change the calling conventions for Parser.reportUnrecoverableError.

pkg/front_end/lib/src/fasta/parser/parser.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.parser.parser;
 
 import '../scanner.dart' show ErrorToken;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
@@ skipping 442 matching lines @@
 
   Token skipFormalParameters(Token token) {
     // TODO(ahe): Shouldn't this be `beginFormalParameters`?
     listener.beginOptionalFormalParameters(token);
     if (!optional('(', token)) {
       if (optional(';', token)) {
         reportRecoverableError(token, ErrorKind.ExpectedOpenParens);
         return token;
       }
       return reportUnrecoverableError(
-          token, ErrorKind.ExpectedButGot, {"expected": "("});
+          token, ErrorKind.ExpectedButGot, {"expected": "("})?.next;
     }
     BeginGroupToken beginGroupToken = token;
     Token endToken = beginGroupToken.endGroup;
     listener.endFormalParameters(0, token, endToken);
     return endToken.next;
   }
 
   /// Parses the formal parameter list of a function.
   ///
   /// If [inFunctionType] is true, then the names may be omitted (except for
@@ skipping 271 matching lines @@
   Token parseQualifiedRest(Token token, IdentifierContext context) {
     assert(optional('.', token));
     Token period = token;
     token = parseIdentifier(token.next, context);
     listener.handleQualified(period);
     return token;
   }
 
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
-      return reportUnrecoverableError(token, ErrorKind.ExpectedBlockToSkip);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedBlockToSkip)
+          ?.next;
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null) {
-      return reportUnrecoverableError(
-          beginGroupToken, ErrorKind.UnmatchedToken);
+      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
+          ?.next;
     } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return reportUnrecoverableError(
-          beginGroupToken, ErrorKind.UnmatchedToken);
+      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
+          ?.next;
     }
     return beginGroupToken.endGroup;
   }
 
   Token parseEnum(Token token) {
     listener.beginEnum(token);
     Token enumKeyword = token;
     token = parseIdentifier(token.next, IdentifierContext.enumDeclaration);
     token = expect('{', token);
     int count = 0;
@@ skipping 88 matching lines @@
       } while (optional(',', token));
     }
     token = parseClassBody(token);
     listener.endClassDeclaration(interfacesCount, begin, classKeyword,
         extendsKeyword, implementsKeyword, token);
     return token.next;
   }
 
   Token parseStringPart(Token token) {
     if (token.kind != STRING_TOKEN) {
-      token = reportUnrecoverableError(token, ErrorKind.ExpectedString);
+      token = reportUnrecoverableError(token, ErrorKind.ExpectedString)?.next;
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
   Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier()) {
-      token = reportUnrecoverableError(token, ErrorKind.ExpectedIdentifier);
+      token =
+          reportUnrecoverableError(token, ErrorKind.ExpectedIdentifier)?.next;
     }
     listener.handleIdentifier(token, context);
     return token.next;
   }
 
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
       return reportUnrecoverableError(
-          token, ErrorKind.ExpectedButGot, {"expected": string});
+          token, ErrorKind.ExpectedButGot, {"expected": string})?.next;
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseIdentifier(token, IdentifierContext.typeVariableDeclaration);
     Token extendsOrSuper = null;
     if (optional('extends', token) || optional('super', token)) {
       extendsOrSuper = token;
@@ skipping 49 matching lines @@
     } else if (identical(token.stringValue, 'void') &&
         isGeneralizedFunctionType(token.next)) {
       listener.handleVoidKeyword(token);
       token = token.next;
     } else {
       if (isValidTypeReference(token)) {
         token = parseIdentifier(token, IdentifierContext.typeReference);
         token = parseQualifiedRestOpt(
             token, IdentifierContext.typeReferenceContinuation);
       } else {
-        token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
+        token = reportUnrecoverableError(token, ErrorKind.ExpectedType)?.next;
         listener.handleInvalidTypeReference(token);
       }
       token = parseTypeArgumentsOpt(token);
       listener.handleType(begin, token);
     }
 
     // While we see a `Function(` treat the pushed type as return type.
     // For example: `int Function() Function(int) Function(String x)`.
     while (isGeneralizedFunctionType(token)) {
       token = parseFunctionType(token);
@@ skipping 55 matching lines @@
     handleNoStuff(token);
     return token;
   }
 
   Token parseTopLevelMember(Token token) {
     Token start = token;
     listener.beginTopLevelMember(token);
 
     Link<Token> identifiers = findMemberName(token);
     if (identifiers.isEmpty) {
-      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration)
+          ?.next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration)
+          ?.next;
     }
     Token name = identifiers.head;
     identifiers = identifiers.tail;
     Token getOrSet;
     if (!identifiers.isEmpty) {
       String value = identifiers.head.stringValue;
       if ((identical(value, 'get')) || (identical(value, 'set'))) {
         getOrSet = identifiers.head;
         identifiers = identifiers.tail;
       }
@@ skipping 24 matching lines @@
         if (getOrSet != null) {
           // If we found a "get" keyword, this must be an abstract
           // getter.
           isField = (!identical(getOrSet.stringValue, 'get'));
           // TODO(ahe): This feels like a hack.
         } else {
           isField = true;
         }
         break;
       } else {
-        token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+        token =
+            reportUnrecoverableError(token, ErrorKind.UnexpectedToken)?.next;
         if (identical(token.kind, EOF_TOKEN)) return token;
       }
     }
     var modifiers = identifiers.reverse();
     return isField
         ? parseFields(start, modifiers, type, getOrSet, name, true)
         : parseTopLevelMethod(start, modifiers, type, getOrSet, name);
   }
 
   bool isVarFinalOrConst(Token token) {
@@ skipping 516 matching lines @@
    */
   Token peekAfterIfType(Token token) {
     if (!optional('void', token) && !token.isIdentifier()) {
       return null;
     }
     return peekAfterType(token);
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
-      return reportUnrecoverableError(token, ErrorKind.ExpectedClassBodyToSkip);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedClassBodyToSkip)
+          ?.next;
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null) {
-      return reportUnrecoverableError(
-          beginGroupToken, ErrorKind.UnmatchedToken);
+      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
+          ?.next;
     } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return reportUnrecoverableError(
-          beginGroupToken, ErrorKind.UnmatchedToken);
+      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
+          ?.next;
     }
     return endGroup;
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
-      token = reportUnrecoverableError(token, ErrorKind.ExpectedClassBody);
+      token =
+          reportUnrecoverableError(token, ErrorKind.ExpectedClassBody)?.next;
     }
     token = token.next;
     int count = 0;
     while (notEofOrValue('}', token)) {
       token = parseMember(token);
       ++count;
     }
     expect('}', token);
     listener.endClassBody(count, begin, token);
     return token;
@@ skipping 16 matching lines @@
     listener.beginMember(token);
     if (isFactoryDeclaration(token)) {
       token = parseFactoryMethod(token);
       listener.endMember();
       assert(token != null);
       return token;
     }
 
     Link<Token> identifiers = findMemberName(token);
     if (identifiers.isEmpty) {
-      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration)
+          ?.next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration)
+          ?.next;
     }
     Token name = identifiers.head;
     identifiers = identifiers.tail;
     if (!identifiers.isEmpty) {
       if (optional('operator', identifiers.head)) {
         name = identifiers.head;
         identifiers = identifiers.tail;
       }
     }
     Token getOrSet;
@@ skipping 31 matching lines @@
           isField = !optional("get", getOrSet);
           // TODO(ahe): This feels like a hack.
         } else {
           isField = true;
         }
         break;
       } else if ((identical(value, '=')) || (identical(value, ','))) {
         isField = true;
         break;
       } else {
-        token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+        token =
+            reportUnrecoverableError(token, ErrorKind.UnexpectedToken)?.next;
         if (identical(token.kind, EOF_TOKEN)) {
           // TODO(ahe): This is a hack, see parseTopLevelMember.
           listener.endFields(1, null, start, token);
           listener.endMember();
           return token;
         }
       }
     }
 
     var modifiers = identifiers.reverse();
@@ skipping 297 matching lines @@
         expectSemicolon(token);
         listener.endExpressionFunctionBody(begin, token);
       } else {
         listener.endExpressionFunctionBody(begin, null);
       }
       return token;
     }
     Token begin = token;
     int statementCount = 0;
     if (!optional('{', token)) {
-      token = reportUnrecoverableError(token, ErrorKind.ExpectedFunctionBody);
+      token =
+          reportUnrecoverableError(token, ErrorKind.ExpectedFunctionBody)?.next;
       listener.handleInvalidFunctionBody(token);
       return token;
     }
 
     listener.beginFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
@@ skipping 48 matching lines @@
     listener.handleAsyncModifier(async, star);
     return token;
   }
 
   int statementDepth = 0;
   Token parseStatement(Token token) {
     if (statementDepth++ > 500) {
       // This happens for degenerate programs, for example, a lot of nested
       // if-statements. The language test deep_nesting2_negative_test, for
       // example, provokes this.
-      return reportUnrecoverableError(token, ErrorKind.StackOverflow);
+      return reportUnrecoverableError(token, ErrorKind.StackOverflow)?.next;
     }
     Token result = parseStatementX(token);
     statementDepth--;
     return result;
   }
 
   Token parseStatementX(Token token) {
     final value = token.stringValue;
     if (identical(token.kind, IDENTIFIER_TOKEN)) {
       return parseExpressionStatementOrDeclaration(token);
@@ skipping 284 matching lines @@
           continue;
         }
       }
       if (!mayParseFunctionExpressions && identical(value, '{')) {
         break;
       }
       if (token is BeginGroupToken) {
         BeginGroupToken begin = token;
         token = (begin.endGroup != null) ? begin.endGroup : token;
       } else if (token is ErrorToken) {
-        reportErrorToken(token, false);
+        reportErrorToken(token, false)?.next;
       }
       token = token.next;
     }
     return token;
   }
 
   Token parseRecoverExpression(Token token) => parseExpression(token);
 
   int expressionDepth = 0;
   Token parseExpression(Token token) {
     if (expressionDepth++ > 500) {
       // This happens in degenerate programs, for example, with a lot of nested
       // list literals. This is provoked by, for examaple, the language test
       // deep_nesting1_negative_test.
-      return reportUnrecoverableError(token, ErrorKind.StackOverflow);
+      return reportUnrecoverableError(token, ErrorKind.StackOverflow)?.next;
     }
     listener.beginExpression(token);
     Token result = optional('throw', token)
         ? parseThrowExpression(token, true)
         : parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, true);
     expressionDepth--;
     return result;
   }
 
   Token parseExpressionWithoutCascade(Token token) {
@@ skipping 46 matching lines @@
             token = parsePrimary(token.next);
             listener.handleBinaryExpression(operator);
           } else if ((identical(info, OPEN_PAREN_INFO)) ||
               (identical(info, OPEN_SQUARE_BRACKET_INFO))) {
             token = parseArgumentOrIndexStar(token);
           } else if ((identical(info, PLUS_PLUS_INFO)) ||
               (identical(info, MINUS_MINUS_INFO))) {
             listener.handleUnaryPostfixAssignmentExpression(token);
             token = token.next;
           } else {
-            token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+            token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken)
+                ?.next;
           }
         } else if (identical(info, IS_INFO)) {
           token = parseIsOperatorRest(token);
         } else if (identical(info, AS_INFO)) {
           token = parseAsOperatorRest(token);
         } else if (identical(info, QUESTION_INFO)) {
           token = parseConditionalExpressionRest(token);
         } else {
           // Left associative, so we recurse at the next higher
           // precedence level.
@@ skipping 19 matching lines @@
     listener.beginCascade(token);
     assert(optional('..', token));
     Token cascadeOperator = token;
     token = token.next;
     if (optional('[', token)) {
       token = parseArgumentOrIndexStar(token);
     } else if (token.isIdentifier()) {
       token = parseSend(token, IdentifierContext.expressionContinuation);
       listener.handleBinaryExpression(cascadeOperator);
     } else {
-      return reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+      return reportUnrecoverableError(token, ErrorKind.UnexpectedToken)?.next;
     }
     Token mark;
     do {
       mark = token;
       if (optional('.', token)) {
         Token period = token;
         token = parseSend(token.next, IdentifierContext.expressionContinuation);
         listener.handleBinaryExpression(period);
       }
       token = parseArgumentOrIndexStar(token);
@@ skipping 107 matching lines @@
       listener.handleNoTypeArguments(token);
       return parseLiteralMapSuffix(token, null);
     } else if (kind == LT_TOKEN) {
       return parseLiteralListOrMapOrFunction(token, null);
     } else {
       return expressionExpected(token);
     }
   }
 
   Token expressionExpected(Token token) {
-    token = reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
+    token = reportUnrecoverableError(token, ErrorKind.ExpectedExpression)?.next;
     listener.handleInvalidExpression(token);
     return token;
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
     // TODO(eernst): Check for NPE as described in issue 26252.
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
@@ skipping 13 matching lines @@
   }
 
   Token parseParenthesizedExpression(Token token) {
     // We expect [begin] to be of type [BeginGroupToken], but we don't know for
     // sure until after calling expect.
     dynamic begin = token;
     token = expect('(', token);
     // [begin] is now known to have type [BeginGroupToken].
     token = parseExpression(token);
     if (!identical(begin.endGroup, token)) {
-      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+      reportUnrecoverableError(token, ErrorKind.UnexpectedToken)?.next;
       token = begin.endGroup;
     }
     listener.handleParenthesizedExpression(begin);
     return expect(')', token);
   }
 
   Token parseThisExpression(Token token) {
     Token beginToken = token;
     listener.handleThisExpression(token);
     token = token.next;
@@ skipping 168 matching lines @@
       }
     }
     return false;
   }
 
   Token parseRequiredArguments(Token token) {
     if (optional('(', token)) {
       token = parseArguments(token);
     } else {
       listener.handleNoArguments(token);
-      token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+      token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken)?.next;
     }
     return token;
   }
 
   Token parseNewExpression(Token token) {
     Token newKeyword = token;
     token = expect('new', token);
     token = parseConstructorReference(token);
     token = parseRequiredArguments(token);
     listener.handleNewExpression(newKeyword);
@@ skipping 610 matching lines @@
 
   /// Don't call this method. Should only be used as a last resort when there
   /// is no feasible way to recover from a parser error.
   Token reportUnrecoverableError(Token token, ErrorKind kind, [Map arguments]) {
     Token next;
     if (token is ErrorToken) {
       next = reportErrorToken(token, false);
     } else {
       arguments ??= {};
       arguments.putIfAbsent("actual", () => token.value);
-      next = listener.handleUnrecoverableError(token, kind, arguments)?.next;
+      next = listener.handleUnrecoverableError(token, kind, arguments);
     }
     return next ?? skipToEof(token);
   }
 
   void reportRecoverableError(Token token, ErrorKind kind, [Map arguments]) {
     if (token is ErrorToken) {
       reportErrorToken(token, true);
     } else {
       arguments ??= {};
       listener.handleRecoverableError(token, kind, arguments);
@@ skipping 30 matching lines @@
         arguments = {"text": token.assertionMessage};
         break;
 
       default:
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
-      return listener.handleUnrecoverableError(token, kind, arguments)?.next;
+      return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }