Restructure parser error handling and recovery.

pkg/dart_parser/lib/src/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 dart_parser.parser;
 
 import 'package:dart_scanner/src/keyword.dart' show
     Keyword;
 
 import 'package:dart_scanner/src/precedence.dart' show
     ASSIGNMENT_PRECEDENCE,
     AS_INFO,
     CASCADE_PRECEDENCE,
+    EOF_INFO,
     EQUALITY_PRECEDENCE,
     GT_INFO,
     IS_INFO,
     MINUS_MINUS_INFO,
     OPEN_PAREN_INFO,
     OPEN_SQUARE_BRACKET_INFO,
     PERIOD_INFO,
     PLUS_PLUS_INFO,
     POSTFIX_PRECEDENCE,
     PrecedenceInfo,
     QUESTION_INFO,
     QUESTION_PERIOD_INFO,
     RELATIONAL_PRECEDENCE;
 
 import 'package:dart_scanner/src/token.dart' show
+    BadInputToken,
     BeginGroupToken,
     ErrorToken,
     KeywordToken,
     SymbolToken,
     Token,
+    UnmatchedToken,
+    UnterminatedToken,
     isUserDefinableOperator;
 
 import 'package:dart_scanner/src/token_constants.dart' show
     BAD_INPUT_TOKEN,
     COMMA_TOKEN,
     DOUBLE_TOKEN,
     EOF_TOKEN,
     EQ_TOKEN,
     FUNCTION_TOKEN,
     GT_TOKEN,
@@ skipping 369 matching lines @@
       listener.handleNoFormalParameters(token);
       return token;
     }
   }
 
   Token skipFormalParameters(Token token) {
     // TODO(ahe): Shouldn't this be `beginFormalParameters`?
     listener.beginOptionalFormalParameters(token);
     if (!optional('(', token)) {
       if (optional(';', token)) {
-        listener.reportError(token, ErrorKind.ExpectedOpenParens);
+        reportRecoverableError(token, ErrorKind.ExpectedOpenParens);
         return token;
       }
-      return listener.unexpected(token);
+      return reportUnrecoverableError(
+          token, ErrorKind.ExpectedButGot, {"expected": "("});
     }
     BeginGroupToken beginGroupToken = token;
     Token endToken = beginGroupToken.endGroup;
     listener.endFormalParameters(0, token, endToken);
     return endToken.next;
   }
 
   Token parseFormalParameters(Token token) {
     Token begin = token;
     listener.beginFormalParameters(begin);
@@ skipping 53 matching lines @@
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
-        listener.reportError(
+        reportRecoverableError(
             equal, ErrorKind.RequiredParameterWithDefault);
       } else if (type.isPositional && identical(':', value)) {
-        listener.reportError(
+        reportRecoverableError(
             equal, ErrorKind.PositionalParameterWithEquals);
       }
     }
     listener.endFormalParameter(thisKeyword);
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
       token = token.next;
       if (isNamed && optional('}', token)) {
         break;
       } else if (!isNamed && optional(']', token)) {
         break;
       }
       var type =
           isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
       token = parseFormalParameter(token, type);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
-      listener.reportError(
+      reportRecoverableError(
           token,
           isNamed
               ? ErrorKind.EmptyNamedParameterList
               : ErrorKind.EmptyOptionalParameterList);
     }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
@@ skipping 116 matching lines @@
   Token parseQualifiedRest(Token token) {
     assert(optional('.', token));
     Token period = token;
     token = parseIdentifier(token.next);
     listener.handleQualified(period);
     return token;
   }
 
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
-      return listener.expectedBlockToSkip(token);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedBlockToSkip);
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null) {
-      return listener.unmatched(beginGroupToken);
+      return reportUnrecoverableError(
+          beginGroupToken, ErrorKind.UnmatchedToken);
     } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return listener.unmatched(beginGroupToken);
+      return reportUnrecoverableError(
+          beginGroupToken, ErrorKind.UnmatchedToken);
     }
     return beginGroupToken.endGroup;
   }
 
   Token parseEnum(Token token) {
     listener.beginEnum(token);
     Token enumKeyword = token;
     token = parseIdentifier(token.next);
     token = expect('{', token);
     int count = 0;
@@ skipping 84 matching lines @@
     listener.endClassDeclaration(
         interfacesCount, begin, extendsKeyword, implementsKeyword, token);
     return token.next;
   }
 
   Token parseStringPart(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       listener.handleStringPart(token);
       return token.next;
     } else {
-      return listener.expected('string', token);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedString);
     }
   }
 
   Token parseIdentifier(Token token) {
     if (!token.isIdentifier()) {
-      token = listener.expectedIdentifier(token);
+      token = reportUnrecoverableError(token, ErrorKind.ExpectedIdentifier);
     }
     listener.handleIdentifier(token);
     return token.next;
   }
 
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
-      return listener.expected(string, token);
+      return reportUnrecoverableError(
+          token, ErrorKind.ExpectedButGot, {"expected": string});
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseIdentifier(token);
     Token extendsOrSuper = null;
     if (optional('extends', token) || optional('super', token)) {
       extendsOrSuper = token;
@@ skipping 33 matching lines @@
     return !identical(token.kind, EOF_TOKEN) &&
         !identical(value, token.stringValue);
   }
 
   Token parseType(Token token) {
     Token begin = token;
     if (isValidTypeReference(token)) {
       token = parseIdentifier(token);
       token = parseQualifiedRestOpt(token);
     } else {
-      token = listener.expectedType(token);
+      token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(begin, token);
     return token;
   }
 
   Token parseTypeArgumentsOpt(Token token) {
     return parseStuff(
         token,
         (t) => listener.beginTypeArguments(t),
@@ skipping 34 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 listener.expectedDeclaration(start);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return listener.expectedDeclaration(start);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
     }
     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 = listener.unexpected(token);
+        token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
         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 50 matching lines @@
       parseModifier(varFinalOrConst);
       modifierCount++;
       hasTypeOrModifier = true;
       modifierList.remove(varFinalOrConst);
     }
     listener.handleModifiers(modifierCount);
     var kind = hasTypeOrModifier
         ? ErrorKind.ExtraneousModifier
         : ErrorKind.ExtraneousModifierReplace;
     for (Token modifier in modifierList) {
-      listener.reportError(modifier, kind, {'modifier': modifier});
+      reportRecoverableError(modifier, kind, {'modifier': modifier});
     }
     return null;
   }
 
   /// Removes the optional `covariant` token from the modifiers, if there
   /// is no `static` in the list, and `covariant` is the first modifier.
   Link<Token> removeOptCovariantTokenIfNotStatic(Link<Token> modifiers) {
     if (modifiers.isEmpty ||
         !identical(modifiers.first.stringValue, 'covariant')) {
       return modifiers;
@@ skipping 20 matching lines @@
     bool hasModifier = false;
     if (varFinalOrConst != null) {
       hasModifier = true;
       isVar = optional('var', varFinalOrConst);
     }
 
     if (getOrSet != null) {
       var kind = (hasModifier || hasType)
           ? ErrorKind.ExtraneousModifier
           : ErrorKind.ExtraneousModifierReplace;
-      listener.reportError(getOrSet, kind, {'modifier': getOrSet});
+      reportRecoverableError(getOrSet, kind, {'modifier': getOrSet});
     }
 
     if (!hasType) {
       listener.handleNoType(name);
     } else if (optional('void', type)) {
       listener.handleNoType(name);
       // TODO(ahe): This error is reported twice, second time is from
       // [parseVariablesDeclarationMaybeSemicolon] via
       // [PartialFieldListElement.parseNode].
-      listener.reportError(type, ErrorKind.InvalidVoid);
+      reportRecoverableError(type, ErrorKind.InvalidVoid);
     } else {
       parseType(type);
       if (isVar) {
-        listener.reportError(modifiers.head, ErrorKind.ExtraneousModifier,
+        reportRecoverableError(modifiers.head, ErrorKind.ExtraneousModifier,
             {'modifier': modifiers.head});
       }
     }
 
     Token token = parseIdentifier(name);
 
     int fieldCount = 1;
     token = parseFieldInitializerOpt(token);
     while (optional(',', token)) {
       token = parseIdentifier(token.next);
@@ skipping 12 matching lines @@
 
   Token parseTopLevelMethod(Token start, Link<Token> modifiers, Token type,
       Token getOrSet, Token name) {
     Token externalModifier;
     // TODO(johnniwinther): Move error reporting to resolution to give more
     // specific error messages.
     for (Token modifier in modifiers) {
       if (externalModifier == null && optional('external', modifier)) {
         externalModifier = modifier;
       } else {
-        listener.reportError(
+        reportRecoverableError(
             modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
       }
     }
     if (externalModifier != null) {
       parseModifier(externalModifier);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
@@ skipping 10 matching lines @@
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
     Token endToken = token;
     token = token.next;
     if (token.kind == BAD_INPUT_TOKEN) {
-      token = listener.unexpected(token);
+      token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     }
     listener.endTopLevelMethod(start, getOrSet, endToken);
     return token;
   }
 
   /// Looks ahead to find the name of a member. Returns a link of the modifiers,
   /// set/get, (operator) name, and either the start of the method body or the
   /// end of the declaration.
   ///
   /// Examples:
@@ skipping 56 matching lines @@
           // type '.' ...
           if (token.next.next.isIdentifier()) {
             // type '.' identifier
             token = token.next.next;
           }
         }
         if (optional('<', token.next)) {
           if (token.next is BeginGroupToken) {
             BeginGroupToken beginGroup = token.next;
             if (beginGroup.endGroup == null) {
-              listener.unmatched(beginGroup);
+              reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
             }
             token = beginGroup.endGroup;
           }
         }
       }
       token = token.next;
     }
     return const Link<Token>();
   }
 
@@ skipping 42 matching lines @@
     } while (optional(',', token));
     mayParseFunctionExpressions = old;
     listener.endInitializers(count, begin, token);
     return token;
   }
 
   Token parseLiteralStringOrRecoverExpression(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       return parseLiteralString(token);
     } else {
-      listener.reportError(token, ErrorKind.ExpectedString);
+      reportRecoverableError(token, ErrorKind.ExpectedString);
       return parseExpression(token);
     }
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
   bool isModifier(Token token) {
     final String value = token.stringValue;
@@ skipping 11 matching lines @@
     return token.next;
   }
 
   void parseModifierList(Link<Token> tokens) {
     int count = 0;
     for (; !tokens.isEmpty; tokens = tokens.tail) {
       Token token = tokens.head;
       if (isModifier(token)) {
         parseModifier(token);
       } else {
-        listener.unexpected(token);
+        reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
         // Skip the remaining modifiers.
         break;
       }
       count++;
     }
     listener.handleModifiers(count);
   }
 
   Token parseModifiers(Token token) {
     int count = 0;
@@ skipping 40 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 listener.expectedClassBodyToSkip(token);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedClassBodyToSkip);
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null) {
-      return listener.unmatched(beginGroupToken);
+      return reportUnrecoverableError(
+          beginGroupToken, ErrorKind.UnmatchedToken);
     } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return listener.unmatched(beginGroupToken);
+      return reportUnrecoverableError(
+          beginGroupToken, ErrorKind.UnmatchedToken);
     }
     return endGroup;
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
-      token = listener.expectedClassBody(token);
+      token = reportUnrecoverableError(token, ErrorKind.ExpectedClassBody);
     }
     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 listener.expectedDeclaration(start);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return listener.expectedDeclaration(start);
+      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration);
     }
     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 = (!identical(getOrSet.stringValue, 'get'));
           // TODO(ahe): This feels like a hack.
         } else {
           isField = true;
         }
         break;
       } else if ((identical(value, '=')) || (identical(value, ','))) {
         isField = true;
         break;
       } else {
-        token = listener.unexpected(token);
+        token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
         if (identical(token.kind, EOF_TOKEN)) {
           // TODO(ahe): This is a hack, see parseTopLevelMember.
           listener.endFields(1, start, token);
           listener.endMember();
           return token;
         }
       }
     }
 
     var modifiers = identifiers.reverse();
@@ skipping 11 matching lines @@
     Token constModifier;
     int modifierCount = 0;
     int allowedModifierCount = 1;
     // TODO(johnniwinther): Move error reporting to resolution to give more
     // specific error messages.
     for (Token modifier in modifiers) {
       if (externalModifier == null && optional('external', modifier)) {
         modifierCount++;
         externalModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(modifier, ErrorKind.ExtraneousModifier,
+          reportRecoverableError(modifier, ErrorKind.ExtraneousModifier,
               {'modifier': modifier});
         }
         allowedModifierCount++;
       } else if (staticModifier == null && optional('static', modifier)) {
         modifierCount++;
         staticModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(modifier, ErrorKind.ExtraneousModifier,
+          reportRecoverableError(modifier, ErrorKind.ExtraneousModifier,
               {'modifier': modifier});
         }
       } else if (constModifier == null && optional('const', modifier)) {
         modifierCount++;
         constModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(modifier, ErrorKind.ExtraneousModifier,
+          reportRecoverableError(modifier, ErrorKind.ExtraneousModifier,
               {'modifier': modifier});
         }
       } else {
-        listener.reportError(
+        reportRecoverableError(
             modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
       }
     }
     if (getOrSet != null && constModifier != null) {
-      listener.reportError(constModifier, ErrorKind.ExtraneousModifier,
+      reportRecoverableError(constModifier, ErrorKind.ExtraneousModifier,
           {'modifier': constModifier});
     }
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
-        listener.reportError(staticModifier, ErrorKind.ExtraneousModifier,
+        reportRecoverableError(staticModifier, ErrorKind.ExtraneousModifier,
             {'modifier': staticModifier});
       }
     } else {
       token = parseIdentifier(name);
     }
 
     token = parseQualifiedRestOpt(token);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
@@ skipping 167 matching lines @@
     listener.endRedirectingFactoryBody(equals, semicolon);
     return token;
   }
 
   Token skipFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     assert(!isExpression);
     token = skipAsyncModifier(token);
     String value = token.stringValue;
     if (identical(value, ';')) {
       if (!allowAbstract) {
-        listener.reportError(token, ErrorKind.ExpectedBody);
+        reportRecoverableError(token, ErrorKind.ExpectedBody);
       }
       listener.handleNoFunctionBody(token);
     } else {
       if (identical(value, '=>')) {
         token = parseExpression(token.next);
         expectSemicolon(token);
       } else if (value == '=') {
         token = parseRedirectingFactoryBody(token);
         expectSemicolon(token);
       } else {
         token = skipBlock(token);
       }
       listener.handleFunctionBodySkipped(token);
     }
     return token;
   }
 
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (optional(';', token)) {
       if (!allowAbstract) {
-        listener.reportError(token, ErrorKind.ExpectedBody);
+        reportRecoverableError(token, ErrorKind.ExpectedBody);
       }
       listener.endFunctionBody(0, null, token);
       return token;
     } else if (optional('=>', token)) {
       Token begin = token;
       token = parseExpression(token.next);
       if (!isExpression) {
         expectSemicolon(token);
         listener.endReturnStatement(true, begin, token);
       } else {
         listener.endReturnStatement(true, begin, null);
       }
       return token;
     }
     Token begin = token;
     int statementCount = 0;
     if (!optional('{', token)) {
-      return listener.expectedFunctionBody(token);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedFunctionBody);
     }
 
     listener.beginFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endFunctionBody(statementCount, begin, token);
     expect('}', token);
@@ skipping 33 matching lines @@
         token = token.next;
       }
     } else if (optional('sync', token)) {
       async = token;
       token = token.next;
       if (optional('*', token)) {
         asyncAwaitKeywordsEnabled = true;
         star = token;
         token = token.next;
       } else {
-        listener.reportError(async, ErrorKind.InvalidSyncModifier);
+        reportRecoverableError(async, ErrorKind.InvalidSyncModifier);
       }
     }
     listener.handleAsyncModifier(async, star);
     return token;
   }
 
   Token parseStatement(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) {
-        listener.reportErrorToken(token);
+        reportErrorToken(token, false);
       }
       token = token.next;
     }
     return token;
   }
 
   Token parseExpression(Token token) {
     listener.beginExpression(token);
     return optional('throw', token)
         ? parseThrowExpression(token, true)
@@ skipping 49 matching lines @@
             token = parseUnaryExpression(token.next, allowCascades);
             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 = listener.unexpected(token);
+            token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
           }
         } 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);
       listener.handleBinaryExpression(cascadeOperator);
     } else {
-      return listener.unexpected(token);
+      return reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     }
     Token mark;
     do {
       mark = token;
       if (optional('.', token)) {
         Token period = token;
         token = parseSend(token.next);
         listener.handleBinaryExpression(period);
       }
       token = parseArgumentOrIndexStar(token);
     } while (!identical(mark, token));
 
     if (identical(token.info.precedence, ASSIGNMENT_PRECEDENCE)) {
       Token assignment = token;
       token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
     listener.endCascade();
     return token;
   }
 
   Token parseUnaryExpression(Token token, bool allowCascades) {
     String value = token.stringValue;
     // Prefix:
     if (asyncAwaitKeywordsEnabled && optional('await', token)) {
       return parseAwaitExpression(token, allowCascades);
     } else if (identical(value, '+')) {
       // Dart no longer allows prefix-plus.
-      listener.reportError(token, ErrorKind.UnsupportedPrefixPlus);
+      reportRecoverableError(token, ErrorKind.UnsupportedPrefixPlus);
       return parseUnaryExpression(token.next, allowCascades);
     } else if ((identical(value, '!')) ||
         (identical(value, '-')) ||
         (identical(value, '~'))) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
       token = parsePrecedenceExpression(
           token.next, POSTFIX_PRECEDENCE, allowCascades);
       listener.handleUnaryPrefixExpression(operator);
@@ skipping 55 matching lines @@
       } else if (value == 'super') {
         return parseSuperExpression(token);
       } else if (value == 'new') {
         return parseNewExpression(token);
       } else if (value == 'const') {
         return parseConstExpression(token);
       } else if (value == 'void') {
         return parseFunctionExpression(token);
       } else if (asyncAwaitKeywordsEnabled &&
           (value == 'yield' || value == 'async')) {
-        return listener.expectedExpression(token);
+        return reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
       } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
-        return listener.expectedExpression(token);
+        return reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
     } else if (kind == OPEN_SQUARE_BRACKET_TOKEN || token.stringValue == '[]') {
       listener.handleNoTypeArguments(token);
       return parseLiteralListSuffix(token, null);
     } else if (kind == OPEN_CURLY_BRACKET_TOKEN) {
       listener.handleNoTypeArguments(token);
       return parseLiteralMapSuffix(token, null);
     } else if (kind == LT_TOKEN) {
       return parseLiteralListOrMapOrFunction(token, null);
     } else {
-      return listener.expectedExpression(token);
+      return reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
     }
   }
 
   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 &&
         (identical(kind, FUNCTION_TOKEN) ||
@@ skipping 12 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.
     var begin = token;
     token = expect('(', token);
     // [begin] is now known to have type [BeginGroupToken].
     token = parseExpression(token);
     if (!identical(begin.endGroup, token)) {
-      listener.unexpected(token);
+      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
       token = begin.endGroup;
     }
     listener.handleParenthesizedExpression(begin);
     return expect(')', token);
   }
 
   Token parseThisExpression(Token token) {
     listener.handleThisExpression(token);
     token = token.next;
     if (optional('(', token)) {
@@ skipping 81 matching lines @@
       Token nextToken = beginGroup.endGroup.next;
       int kind = nextToken.kind;
       if (identical(kind, FUNCTION_TOKEN) ||
           identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
           (identical(kind, KEYWORD_TOKEN) &&
               (nextToken.value == 'async' || nextToken.value == 'sync'))) {
         return parseUnnamedFunction(token);
       }
       // Fall through.
     }
-    listener.unexpected(token);
+    reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     return null;
   }
 
   /// genericListLiteral | genericMapLiteral | genericFunctionLiteral.
   ///
   /// Where
   ///   genericListLiteral ::= typeArguments '[' (expressionList ','?)? ']'
   ///   genericMapLiteral ::=
   ///       typeArguments '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'
   ///   genericFunctionLiteral ::=
   ///       typeParameters formalParameterList functionBody
   /// Provide token for [constKeyword] if preceded by 'const', null if not.
   Token parseLiteralListOrMapOrFunction(Token token, Token constKeyword) {
     assert(optional('<', token));
     BeginGroupToken begin = token;
     if (constKeyword == null &&
         begin.endGroup != null &&
         identical(begin.endGroup.next.kind, OPEN_PAREN_TOKEN)) {
       token = parseTypeVariablesOpt(token);
       return parseLiteralFunctionSuffix(token);
     } else {
       token = parseTypeArgumentsOpt(token);
       if (optional('{', token)) {
         return parseLiteralMapSuffix(token, constKeyword);
       } else if ((optional('[', token)) || (optional('[]', token))) {
         return parseLiteralListSuffix(token, constKeyword);
       }
-      listener.unexpected(token);
+      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
       return null;
     }
   }
 
   Token parseMapLiteralEntry(Token token) {
     listener.beginLiteralMapEntry(token);
     // Assume the listener rejects non-string keys.
     token = parseExpression(token);
     Token colon = token;
     token = expect(':', token);
@@ skipping 34 matching lines @@
       }
     }
     return false;
   }
 
   Token parseRequiredArguments(Token token) {
     if (optional('(', token)) {
       token = parseArguments(token);
     } else {
       listener.handleNoArguments(token);
-      token = listener.unexpected(token);
+      token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     }
     return token;
   }
 
   Token parseNewExpression(Token token) {
     Token newKeyword = token;
     token = expect('new', token);
     token = parseConstructorReference(token);
     token = parseRequiredArguments(token);
     listener.handleNewExpression(newKeyword);
@@ skipping 177 matching lines @@
     if (optional('!', token.next)) {
       token = token.next;
       not = token;
     }
     token = parseType(token.next);
     listener.handleIsOperator(operator, not, token);
     String value = token.stringValue;
     if (identical(value, 'is') || identical(value, 'as')) {
       // The is- and as-operators cannot be chained, but they can take part of
       // expressions like: foo is Foo || foo is Bar.
-      listener.unexpected(token);
+      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     }
     return token;
   }
 
   Token parseAsOperatorRest(Token token) {
     assert(optional('as', token));
     Token operator = token;
     token = parseType(token.next);
     listener.handleAsOperator(operator, token);
     String value = token.stringValue;
     if (identical(value, 'is') || identical(value, 'as')) {
       // The is- and as-operators cannot be chained.
-      listener.unexpected(token);
+      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     }
     return token;
   }
 
   Token parseVariablesDeclaration(Token token) {
     return parseVariablesDeclarationMaybeSemicolon(token, true);
   }
 
   Token parseVariablesDeclarationNoSemicolon(Token token) {
     // Only called when parsing a for loop, so this is for parsing locals.
@@ skipping 52 matching lines @@
   Token parseForStatement(Token awaitToken, Token token) {
     Token forToken = token;
     listener.beginForStatement(forToken);
     token = expect('for', token);
     token = expect('(', token);
     token = parseVariablesDeclarationOrExpressionOpt(token);
     if (optional('in', token)) {
       return parseForInRest(awaitToken, forToken, token);
     } else {
       if (awaitToken != null) {
-        listener.reportError(awaitToken, ErrorKind.InvalidAwaitFor);
+        reportRecoverableError(awaitToken, ErrorKind.InvalidAwaitFor);
       }
       return parseForRest(forToken, token);
     }
   }
 
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
@@ skipping 231 matching lines @@
         }
         Token caseKeyword = token;
         token = parseExpression(token.next);
         Token colonToken = token;
         token = expect(':', token);
         listener.handleCaseMatch(caseKeyword, colonToken);
         expressionCount++;
         peek = peekPastLabels(token);
       } else {
         if (expressionCount == 0) {
-          listener.expected("case", token);
+          // TODO(ahe): This is probably easy to recover from.
+          reportUnrecoverableError(
+              token, ErrorKind.ExpectedButGot, {"expected": "case"});
         }
         break;
       }
     }
     listener.beginSwitchCase(labelCount, expressionCount, begin);
     // Finally zero or more statements.
     int statementCount = 0;
     while (!identical(token.kind, EOF_TOKEN)) {
       String value = peek.stringValue;
       if ((identical(value, 'case')) ||
@@ skipping 54 matching lines @@
       hasTarget = true;
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
+
+  /// 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);
+    }
+    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);
+    }
+  }
+
+  Token reportErrorToken(ErrorToken token, bool isRecoverable) {
+    ErrorKind kind;
+    Map arguments = const {};
+    if (token is BadInputToken) {
+      String hex = token.character.toRadixString(16);
+      if (hex.length < 4) {
+        String padding = "0000".substring(hex.length);
+        hex = "$padding$hex";
+      }
+      kind = ErrorKind.InvalidInputCharacter;
+      arguments = {'characterHex': hex};
+    } else if (token is UnterminatedToken) {
+      switch (token.start) {
+        case '1e':
+          kind = ErrorKind.MissingExponent;
+          break;
+        case '"':
+        case "'":
+        case '"""':
+        case "'''":
+        case 'r"':
+        case "r'":
+        case 'r"""':
+        case "r'''":
+          kind = ErrorKind.UnterminatedString;
+          arguments = {'quote': token.start};
+          break;
+        case '0x':
+          kind = ErrorKind.ExpectedHexDigit;
+          break;
+        case r'$':
+          kind = ErrorKind.MalformedStringLiteral;
+          break;
+        case '/*':
+          kind = ErrorKind.UnterminatedComment;
+          break;
+        default:
+          kind = ErrorKind.UnterminatedToken;
+          break;
+      }
+    } else if (token is UnmatchedToken) {
+      String begin = token.begin.value;
+      String end = closeBraceFor(begin);
+      kind = ErrorKind.UnmatchedToken;
+      arguments = {'begin': begin, 'end': end};
+    } else {
+      return listener.handleUnrecoverableError(
+          token, ErrorKind.Unspecified, {"text": token.assertionMessage});
+    }
+    if (isRecoverable) {
+      listener.handleRecoverableError(token, kind, arguments);
+      return null;
+    } else {
+      return listener.handleUnrecoverableError(token, kind, arguments);
+    }
+  }
 }
+
+String closeBraceFor(String openBrace) {
+  return const {
+    '(': ')',
+    '[': ']',
+    '{': '}',
+    '<': '>',
+    r'${': '}',
+  }[openBrace];
+}
+
+Token skipToEof(Token token) {
+  while (!identical(token.info, EOF_INFO)) {
+    token = token.next;
+  }
+  return token;
+}