Use message.yaml in parser.

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 '../fasta_codes.dart'
+    show
+        FastaCode,
+        FastaMessage,
+        codeAbstractNotSync,
+        codeAsciiControlCharacter,
+        codeAsyncAsIdentifier,
+        codeAwaitAsIdentifier,
+        codeAwaitForNotAsync,
+        codeAwaitNotAsync,
+        codeBuiltInIdentifierAsType,
+        codeBuiltInIdentifierInDeclaration,
+        codeEmptyNamedParameterList,
+        codeEmptyOptionalParameterList,
+        codeEncoding,
+        codeExpectedBlockToSkip,
+        codeExpectedBody,
+        codeExpectedButGot,
+        codeExpectedClassBody,
+        codeExpectedClassBodyToSkip,
+        codeExpectedDeclaration,
+        codeExpectedExpression,
+        codeExpectedFunctionBody,
+        codeExpectedIdentifier,
+        codeExpectedOpenParens,
+        codeExpectedString,
+        codeExpectedType,
+        codeExtraneousModifier,
+        codeExtraneousModifierReplace,
+        codeFactoryNotSync,
+        codeGeneratorReturnsValue,
+        codeInvalidAwaitFor,
+        codeInvalidInlineFunctionType,
+        codeInvalidSyncModifier,
+        codeInvalidVoid,
+        codeNonAsciiIdentifier,
+        codeNonAsciiWhitespace,
+        codeOnlyTry,
+        codePositionalParameterWithEquals,
+        codeRequiredParameterWithDefault,
+        codeSetterNotSync,
+        codeStackOverflow,
+        codeUnexpectedToken,
+        codeUnmatchedToken,
+        codeUnspecified,
+        codeUnsupportedPrefixPlus,
+        codeUnterminatedString,
+        codeYieldAsIdentifier,
+        codeYieldNotGenerator;
+
 import '../scanner.dart' show ErrorToken;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
 import '../scanner/keyword.dart' show Keyword;
 
 import '../scanner/precedence.dart'
     show
         ASSIGNMENT_PRECEDENCE,
         AS_INFO,
@@ skipping 46 matching lines @@
         STRING_TOKEN;
 
 import '../scanner/characters.dart' show $CLOSE_CURLY_BRACKET;
 
 import '../util/link.dart' show Link;
 
 import 'async_modifier.dart' show AsyncModifier;
 
 import 'listener.dart' show Listener;
 
-import 'error_kind.dart' show ErrorKind;
-
 import 'identifier_context.dart' show IdentifierContext;
 
 /// Returns true if [token] is the symbol or keyword [value].
 bool optional(String value, Token token) {
   return identical(value, token.stringValue);
 }
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
@@ skipping 40 matching lines @@
 /// As a consequence of this, one should not use `==` to compare strings in the
 /// parser. One should favor the methods [optional] and [expected] to recognize
 /// keywords or identifiers. In some cases, it's possible to compare a token's
 /// `stringValue` using [identical], but normally [optional] will suffice.
 ///
 /// Historically, we over-used identical, and when identical is used on other
 /// objects than strings, it can often be replaced by `==`.
 class Parser {
   final Listener listener;
 
+  Uri get uri => listener.uri;
+
   bool mayParseFunctionExpressions = true;
 
   /// Represents parser state: what asynchronous syntax is allowed in the
   /// function being currently parsed. In rare situations, this can be set by
   /// external clients, for example, to parse an expression outside a function.
   AsyncModifier asyncState = AsyncModifier.Sync;
 
   Parser(this.listener);
 
   bool get inGenerator {
@@ skipping 335 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)) {
-        reportRecoverableError(token, ErrorKind.ExpectedOpenParens);
+        reportRecoverableErrorCode(token, codeExpectedOpenParens);
         return token;
       }
-      return reportUnrecoverableError(
-          token, ErrorKind.ExpectedButGot, {"expected": "("})?.next;
+      return reportUnrecoverableErrorCodeWithString(
+              token, codeExpectedButGot, "(")
+          .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 13 matching lines @@
       if (identical(value, '[')) {
         token = parseOptionalFormalParameters(token, false,
             inFunctionType: inFunctionType);
         break;
       } else if (identical(value, '{')) {
         token = parseOptionalFormalParameters(token, true,
             inFunctionType: inFunctionType);
         break;
       } else if (identical(value, '[]')) {
         --parameterCount;
-        reportRecoverableError(token, ErrorKind.EmptyOptionalParameterList);
+        reportRecoverableErrorCode(token, codeEmptyOptionalParameterList);
         token = token.next;
         break;
       }
       token = parseFormalParameter(token, FormalParameterType.REQUIRED,
           inFunctionType: inFunctionType);
     } while (optional(',', token));
     listener.endFormalParameters(parameterCount, begin, token);
     return expect(')', token);
   }
 
@@ skipping 47 matching lines @@
       Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(
           covariantKeyword, thisKeyword, kind);
       // Generalized function types don't allow inline function types.
       // The following isn't allowed:
       //    int Function(int bar(String x)).
       if (inFunctionType) {
-        reportRecoverableError(
-            inlineFunctionTypeStart, ErrorKind.InvalidInlineFunctionType);
+        reportRecoverableErrorCode(
+            inlineFunctionTypeStart, codeInvalidInlineFunctionType);
       }
     } else if (optional('<', token)) {
       Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(
           covariantKeyword, thisKeyword, kind);
       // Generalized function types don't allow inline function types.
       // The following isn't allowed:
       //    int Function(int bar(String x)).
       if (inFunctionType) {
-        reportRecoverableError(
-            inlineFunctionTypeStart, ErrorKind.InvalidInlineFunctionType);
+        reportRecoverableErrorCode(
+            inlineFunctionTypeStart, codeInvalidInlineFunctionType);
       }
     }
     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 (kind.isRequired) {
-        reportRecoverableError(equal, ErrorKind.RequiredParameterWithDefault);
+        reportRecoverableErrorCode(equal, codeRequiredParameterWithDefault);
       } else if (kind.isPositional && identical(':', value)) {
-        reportRecoverableError(equal, ErrorKind.PositionalParameterWithEquals);
+        reportRecoverableErrorCode(equal, codePositionalParameterWithEquals);
       }
     } else {
       listener.handleFormalParameterWithoutValue(token);
     }
     listener.endFormalParameter(covariantKeyword, thisKeyword, nameToken, kind);
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed,
       {bool inFunctionType: false}) {
     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, inFunctionType: inFunctionType);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
-      reportRecoverableError(
+      reportRecoverableErrorCode(
           token,
           isNamed
-              ? ErrorKind.EmptyNamedParameterList
-              : ErrorKind.EmptyOptionalParameterList);
+              ? codeEmptyNamedParameterList
+              : codeEmptyOptionalParameterList);
     }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
@@ skipping 118 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)
-          ?.next;
+      return reportUnrecoverableErrorCode(token, codeExpectedBlockToSkip).next;
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
-    if (endGroup == null) {
-      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
-          ?.next;
-    } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
-          ?.next;
+    if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
+      return reportUnmatchedToken(beginGroupToken).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)?.next;
+      token =
+          reportUnrecoverableErrorCodeWithToken(token, codeExpectedString).next;
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
   Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier()) {
       token =
-          reportUnrecoverableError(token, ErrorKind.ExpectedIdentifier)?.next;
+          reportUnrecoverableErrorCodeWithToken(token, codeExpectedIdentifier)
+              .next;
     } else if (token.isBuiltInIdentifier &&
         !context.isBuiltInIdentifierAllowed) {
       if (context.inDeclaration) {
-        reportRecoverableError(token, ErrorKind.BuiltInIdentifierInDeclaration);
+        reportRecoverableErrorCodeWithToken(
+            token, codeBuiltInIdentifierInDeclaration);
       } else if (!optional("dynamic", token)) {
-        reportRecoverableError(token, ErrorKind.BuiltInIdentifierAsType);
+        reportRecoverableErrorCodeWithToken(token, codeBuiltInIdentifierAsType);
       }
     } else if (!inPlainSync && token.isPseudo) {
       if (optional('await', token)) {
-        reportRecoverableError(token, ErrorKind.AwaitAsIdentifier);
+        reportRecoverableErrorCode(token, codeAwaitAsIdentifier);
       } else if (optional('yield', token)) {
-        reportRecoverableError(token, ErrorKind.YieldAsIdentifier);
+        reportRecoverableErrorCode(token, codeYieldAsIdentifier);
       } else if (optional('async', token)) {
-        reportRecoverableError(token, ErrorKind.AsyncAsIdentifier);
+        reportRecoverableErrorCode(token, codeAsyncAsIdentifier);
       }
     }
     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})?.next;
+      return reportUnrecoverableErrorCodeWithString(
+              token, codeExpectedButGot, string)
+          .next;
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseMetadataStar(token);
     token = parseIdentifier(token, IdentifierContext.typeVariableDeclaration);
     Token extendsOrSuper = null;
     if (optional('extends', token) || optional('super', token)) {
@@ skipping 46 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)?.next;
+        token =
+            reportUnrecoverableErrorCodeWithToken(token, codeExpectedType).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)
-          ?.next;
+      return reportUnrecoverableErrorCodeWithToken(
+              start, codeExpectedDeclaration)
+          .next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration)
-          ?.next;
+      return reportUnrecoverableErrorCodeWithToken(
+              start, codeExpectedDeclaration)
+          .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)?.next;
+        token = reportUnexpectedToken(token).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 46 matching lines @@
       }
     }
     bool hasTypeOrModifier = hasType;
     if (varFinalOrConst != null) {
       parseModifier(varFinalOrConst);
       modifierCount++;
       hasTypeOrModifier = true;
       modifierList.remove(varFinalOrConst);
     }
     listener.handleModifiers(modifierCount);
-    var kind = hasTypeOrModifier
-        ? ErrorKind.ExtraneousModifier
-        : ErrorKind.ExtraneousModifierReplace;
     for (Token modifier in modifierList) {
-      reportRecoverableError(modifier, kind, {'modifier': modifier});
+      reportRecoverableErrorCodeWithToken(
+          modifier,
+          hasTypeOrModifier
+              ? codeExtraneousModifier
+              : codeExtraneousModifierReplace);
     }
     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 24 matching lines @@
     Token varFinalOrConst =
         expectVarFinalOrConst(modifiers, hasType, !isTopLevel);
     bool isVar = false;
     bool hasModifier = false;
     if (varFinalOrConst != null) {
       hasModifier = true;
       isVar = optional('var', varFinalOrConst);
     }
 
     if (getOrSet != null) {
-      var kind = (hasModifier || hasType)
-          ? ErrorKind.ExtraneousModifier
-          : ErrorKind.ExtraneousModifierReplace;
-      reportRecoverableError(getOrSet, kind, {'modifier': getOrSet});
+      reportRecoverableErrorCodeWithToken(
+          getOrSet,
+          hasModifier || hasType
+              ? codeExtraneousModifier
+              : codeExtraneousModifierReplace);
     }
 
     if (!hasType) {
       listener.handleNoType(name);
     } else if (optional('void', type) &&
         !isGeneralizedFunctionType(type.next)) {
       listener.handleNoType(name);
       // TODO(ahe): This error is reported twice, second time is from
       // [parseVariablesDeclarationMaybeSemicolon] via
       // [PartialFieldListElement.parseNode].
-      reportRecoverableError(type, ErrorKind.InvalidVoid);
+      reportRecoverableErrorCode(type, codeInvalidVoid);
     } else {
       parseType(type);
       if (isVar) {
-        reportRecoverableError(modifiers.head, ErrorKind.ExtraneousModifier,
-            {'modifier': modifiers.head});
+        reportRecoverableErrorCodeWithToken(
+            modifiers.head, codeExtraneousModifier);
       }
     }
 
     IdentifierContext context = isTopLevel
         ? IdentifierContext.topLevelVariableDeclaration
         : IdentifierContext.fieldDeclaration;
     Token token = parseIdentifier(name, context);
 
     int fieldCount = 1;
     token = parseFieldInitializerOpt(token);
@@ skipping 15 matching lines @@
   Token parseTopLevelMethod(Token start, Link<Token> modifiers, Token type,
       Token getOrSet, Token name) {
     listener.beginTopLevelMethod(start, 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 {
-        reportRecoverableError(
-            modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
+        reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
       }
     }
     if (externalModifier != null) {
       parseModifier(externalModifier);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token =
         parseIdentifier(name, IdentifierContext.topLevelFunctionDeclaration);
 
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
-      reportRecoverableError(asyncToken, ErrorKind.SetterNotSync);
+      reportRecoverableErrorCode(asyncToken, codeSetterNotSync);
     }
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncState = savedAsyncModifier;
     Token endToken = token;
     token = token.next;
     listener.endTopLevelMethod(start, getOrSet, endToken);
     return token;
   }
 
   /// Looks ahead to find the name of a member. Returns a link of the modifiers,
@@ skipping 73 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) {
-                reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
+                token = reportUnmatchedToken(beginGroup).next;
               } else {
                 token = beginGroup.endGroup;
               }
             }
           }
         }
         token = token.next;
       }
       while (isGeneralizedFunctionType(token)) {
         token = token.next;
         if (optional('<', token)) {
           if (token is BeginGroupToken) {
             BeginGroupToken beginGroup = token;
             if (beginGroup.endGroup == null) {
-              reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
+              token = reportUnmatchedToken(beginGroup).next;
             } else {
               token = beginGroup.endGroup.next;
             }
           }
         }
         if (!optional('(', token)) {
           if (optional(';', token)) {
-            reportRecoverableError(token, ErrorKind.ExpectedOpenParens);
+            reportRecoverableErrorCode(token, codeExpectedOpenParens);
           }
           token = expect("(", token);
         }
         if (token is BeginGroupToken) {
           BeginGroupToken beginGroup = token;
           if (beginGroup.endGroup == null) {
-            reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
+            token = reportUnmatchedToken(beginGroup).next;
           } else {
             token = beginGroup.endGroup.next;
           }
         }
       }
     }
     return listener.handleMemberName(const Link<Token>());
   }
 
   Token parseFieldInitializerOpt(Token token) {
@@ skipping 45 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 {
-      reportRecoverableError(token, ErrorKind.ExpectedString);
+      reportRecoverableErrorCodeWithToken(token, codeExpectedString);
       return parseRecoverExpression(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 {
-        reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+        reportUnexpectedToken(token);
         // Skip the remaining modifiers.
         break;
       }
       count++;
     }
     listener.handleModifiers(count);
   }
 
   Token parseModifiers(Token token) {
     // TODO(ahe): The calling convention of this method probably needs to
     // change. For example, this is parsed as a local variable declaration:
     // `abstract foo;`. Ideally, this example should be handled as a local
     // variable having the type `abstract` (which should be reported as
-    // `ErrorKind.BuiltInIdentifierAsType` by [parseIdentifier]).
+    // `codeBuiltInIdentifierAsType` by [parseIdentifier]).
     int count = 0;
     while (identical(token.kind, KEYWORD_TOKEN)) {
       if (!isModifier(token)) break;
       token = parseModifier(token);
       count++;
     }
     listener.handleModifiers(count);
     return token;
   }
 
@@ skipping 89 matching lines @@
   /// If [token] is not the start of a type, null is returned.
   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)
-          ?.next;
+      return reportUnrecoverableErrorCodeWithToken(
+              token, codeExpectedClassBodyToSkip)
+          .next;
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
-    if (endGroup == null) {
-      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
-          ?.next;
-    } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return reportUnrecoverableError(beginGroupToken, ErrorKind.UnmatchedToken)
-          ?.next;
+    if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
+      return reportUnmatchedToken(beginGroupToken).next;
     }
     return endGroup;
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
       token =
-          reportUnrecoverableError(token, ErrorKind.ExpectedClassBody)?.next;
+          reportUnrecoverableErrorCodeWithToken(token, codeExpectedClassBody)
+              .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)
-          ?.next;
+      return reportUnrecoverableErrorCodeWithToken(
+              start, codeExpectedDeclaration)
+          .next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return reportUnrecoverableError(start, ErrorKind.ExpectedDeclaration)
-          ?.next;
+      return reportUnrecoverableErrorCodeWithToken(
+              start, codeExpectedDeclaration)
+          .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)?.next;
+        token = reportUnexpectedToken(token).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 12 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) {
-          reportRecoverableError(
-              modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
+          reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
         }
         allowedModifierCount++;
       } else if (staticModifier == null && optional('static', modifier)) {
         modifierCount++;
         staticModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          reportRecoverableError(
-              modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
+          reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
         }
       } else if (constModifier == null && optional('const', modifier)) {
         modifierCount++;
         constModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          reportRecoverableError(
-              modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
+          reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
         }
       } else {
-        reportRecoverableError(
-            modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
+        reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
       }
     }
     if (getOrSet != null && constModifier != null) {
-      reportRecoverableError(constModifier, ErrorKind.ExtraneousModifier,
-          {'modifier': constModifier});
+      reportRecoverableErrorCodeWithToken(
+          constModifier, codeExtraneousModifier);
     }
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
-        reportRecoverableError(staticModifier, ErrorKind.ExtraneousModifier,
-            {'modifier': staticModifier});
+        reportRecoverableErrorCodeWithToken(
+            staticModifier, codeExtraneousModifier);
       }
     } else {
       token = parseIdentifier(name, IdentifierContext.methodDeclaration);
     }
 
     token = parseQualifiedRestOpt(
         token, IdentifierContext.methodDeclarationContinuation);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
-      reportRecoverableError(asyncToken, ErrorKind.SetterNotSync);
+      reportRecoverableErrorCode(asyncToken, codeSetterNotSync);
     }
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(
           token, false, staticModifier == null || externalModifier != null);
     }
     asyncState = savedAsyncModifier;
     listener.endMethod(getOrSet, start, token);
     return token.next;
@@ skipping 13 matching lines @@
     }
     listener.handleModifiers(modifierCount);
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = expect('factory', token);
     token = parseConstructorReference(token);
     token = parseFormalParameters(token);
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (!inPlainSync) {
-      reportRecoverableError(asyncToken, ErrorKind.FactoryNotSync);
+      reportRecoverableErrorCode(asyncToken, codeFactoryNotSync);
     }
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false, isExternal);
     }
     listener.endFactoryMethod(start, factoryKeyword, token);
     return token.next;
   }
 
@@ skipping 131 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) {
-        reportRecoverableError(token, ErrorKind.ExpectedBody);
+        reportRecoverableErrorCode(token, codeExpectedBody);
       }
       listener.handleNoFunctionBody(token);
     } else {
       if (identical(value, '=>')) {
         token = parseExpression(token.next);
         expectSemicolon(token);
         listener.handleFunctionBodySkipped(token, true);
       } else if (identical(value, '=')) {
-        reportRecoverableError(token, ErrorKind.ExpectedBody);
+        reportRecoverableErrorCode(token, codeExpectedBody);
         token = parseExpression(token.next);
         expectSemicolon(token);
         listener.handleFunctionBodySkipped(token, true);
       } else {
         token = skipBlock(token);
         listener.handleFunctionBodySkipped(token, false);
       }
     }
     return token;
   }
 
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (optional(';', token)) {
       if (!allowAbstract) {
-        reportRecoverableError(token, ErrorKind.ExpectedBody);
+        reportRecoverableErrorCode(token, codeExpectedBody);
       }
       listener.handleEmptyFunctionBody(token);
       return token;
     } else if (optional('=>', token)) {
       Token begin = token;
       token = parseExpression(token.next);
       if (!isExpression) {
         expectSemicolon(token);
         listener.handleExpressionFunctionBody(begin, token);
       } else {
         listener.handleExpressionFunctionBody(begin, null);
       }
       return token;
     } else if (optional('=', token)) {
       Token begin = token;
       // Recover from a bad factory method.
-      reportRecoverableError(token, ErrorKind.ExpectedBody);
+      reportRecoverableErrorCode(token, codeExpectedBody);
       token = parseExpression(token.next);
       if (!isExpression) {
         expectSemicolon(token);
         listener.handleExpressionFunctionBody(begin, token);
       } else {
         listener.handleExpressionFunctionBody(begin, null);
       }
       return token;
     }
     Token begin = token;
     int statementCount = 0;
     if (!optional('{', token)) {
       token =
-          reportUnrecoverableError(token, ErrorKind.ExpectedFunctionBody)?.next;
+          reportUnrecoverableErrorCodeWithToken(token, codeExpectedFunctionBody)
+              .next;
       listener.handleInvalidFunctionBody(token);
       return token;
     }
 
     listener.beginBlockFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
@@ skipping 37 matching lines @@
         asyncState = AsyncModifier.Async;
       }
     } else if (optional('sync', token)) {
       async = token;
       token = token.next;
       if (optional('*', token)) {
         asyncState = AsyncModifier.SyncStar;
         star = token;
         token = token.next;
       } else {
-        reportRecoverableError(async, ErrorKind.InvalidSyncModifier);
+        reportRecoverableErrorCode(async, codeInvalidSyncModifier);
       }
     }
     listener.handleAsyncModifier(async, star);
     if (inGenerator && optional('=>', token)) {
-      reportRecoverableError(token, ErrorKind.GeneratorReturnsValue);
+      reportRecoverableErrorCode(token, codeGeneratorReturnsValue);
     } else if (!inPlainSync && optional(';', token)) {
-      reportRecoverableError(token, ErrorKind.AbstractNotSync);
+      reportRecoverableErrorCode(token, codeAbstractNotSync);
     }
     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)?.next;
+      return reportUnrecoverableErrorCode(token, codeStackOverflow).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);
     } else if (identical(value, '{')) {
       return parseBlock(token);
     } else if (identical(value, 'return')) {
       return parseReturnStatement(token);
     } else if (identical(value, 'var') || identical(value, 'final')) {
       return parseVariablesDeclaration(token);
     } else if (identical(value, 'if')) {
       return parseIfStatement(token);
     } else if (identical(value, 'await') && optional('for', token.next)) {
       if (!inAsync) {
-        reportRecoverableError(token, ErrorKind.AwaitForNotAsync);
+        reportRecoverableErrorCode(token, codeAwaitForNotAsync);
       }
       return parseForStatement(token, token.next);
     } else if (identical(value, 'for')) {
       return parseForStatement(null, token);
     } else if (identical(value, 'rethrow')) {
       return parseRethrowStatement(token);
     } else if (identical(value, 'throw') && optional(';', token.next)) {
       // TODO(kasperl): Stop dealing with throw here.
       return parseRethrowStatement(token);
     } else if (identical(value, 'void')) {
@@ skipping 17 matching lines @@
     } else if (identical(value, 'yield')) {
       switch (asyncState) {
         case AsyncModifier.Sync:
           return parseExpressionStatementOrDeclaration(token);
 
         case AsyncModifier.SyncStar:
         case AsyncModifier.AsyncStar:
           return parseYieldStatement(token);
 
         case AsyncModifier.Async:
-          reportRecoverableError(token, ErrorKind.YieldNotGenerator);
+          reportRecoverableErrorCode(token, codeYieldNotGenerator);
           return parseYieldStatement(token);
       }
       throw "Internal error: Unknown asyncState: '$asyncState'.";
     } else if (identical(value, 'const')) {
       return parseExpressionStatementOrConstDeclaration(token);
     } else if (token.isIdentifier()) {
       return parseExpressionStatementOrDeclaration(token);
     } else {
       return parseExpressionStatement(token);
     }
@@ skipping 17 matching lines @@
   Token parseReturnStatement(Token token) {
     Token begin = token;
     listener.beginReturnStatement(begin);
     assert(identical('return', token.stringValue));
     token = token.next;
     if (optional(';', token)) {
       listener.endReturnStatement(false, begin, token);
     } else {
       token = parseExpression(token);
       if (inGenerator) {
-        reportRecoverableError(begin.next, ErrorKind.GeneratorReturnsValue);
+        reportRecoverableErrorCode(begin.next, codeGeneratorReturnsValue);
       }
       listener.endReturnStatement(true, begin, token);
     }
     return expectSemicolon(token);
   }
 
   Token peekIdentifierAfterType(Token token) {
     Token peek = peekAfterType(token);
     if (peek != null && peek.isIdentifier()) {
       // We are looking at "type identifier".
@@ skipping 204 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)?.next;
+        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)?.next;
+      return reportUnrecoverableErrorCode(token, codeStackOverflow).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 47 matching lines @@
                 token.next, IdentifierContext.expressionContinuation);
             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)
-                ?.next;
+            token = reportUnexpectedToken(token).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)?.next;
+      return reportUnexpectedToken(token).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 12 matching lines @@
     String value = token.stringValue;
     // Prefix:
     if (optional('await', token)) {
       if (inPlainSync) {
         return parsePrimary(token, IdentifierContext.expression);
       } else {
         return parseAwaitExpression(token, allowCascades);
       }
     } else if (identical(value, '+')) {
       // Dart no longer allows prefix-plus.
-      reportRecoverableError(token, ErrorKind.UnsupportedPrefixPlus);
+      reportRecoverableErrorCode(token, codeUnsupportedPrefixPlus);
       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 79 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)?.next;
+    token = reportUnrecoverableErrorCodeWithToken(token, codeExpectedExpression)
+        .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 14 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)?.next;
+      reportUnexpectedToken(token).next;
       token = begin.endGroup;
     }
     listener.handleParenthesizedExpression(begin);
     return expect(')', token);
   }
 
   Token parseThisExpression(Token token, IdentifierContext context) {
     Token beginToken = token;
     listener.handleThisExpression(token, context);
     token = token.next;
@@ skipping 83 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) &&
               (optional('async', nextToken) || optional('sync', nextToken)))) {
         return parseUnnamedFunction(token);
       }
       // Fall through.
     }
-    reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
-    return null;
+    return reportUnexpectedToken(token).next;
   }
 
   /// 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);
       }
-      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
-      return null;
+      return reportUnexpectedToken(token).next;
     }
   }
 
   Token parseMapLiteralEntry(Token token) {
     listener.beginLiteralMapEntry(token);
     // Assume the listener rejects non-string keys.
     token = parseExpression(token);
     Token colon = token;
     token = expect(':', token);
     token = parseExpression(token);
@@ skipping 35 matching lines @@
       }
     }
     return false;
   }
 
   Token parseRequiredArguments(Token token) {
     if (optional('(', token)) {
       token = parseArguments(token);
     } else {
       listener.handleNoArguments(token);
-      token = reportUnrecoverableError(token, ErrorKind.UnexpectedToken)?.next;
+      token = reportUnexpectedToken(token).next;
     }
     return token;
   }
 
   Token parseNewExpression(Token token) {
     Token newKeyword = token;
     token = expect('new', token);
     listener.beginNewExpression(newKeyword);
     token = parseConstructorReference(token);
     token = parseRequiredArguments(token);
@@ skipping 184 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.
-      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+      reportUnexpectedToken(token);
     }
     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.
-      reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
+      reportUnexpectedToken(token);
     }
     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 54 matching lines @@
     Token forKeyword = token;
     listener.beginForStatement(forKeyword);
     token = expect('for', token);
     Token leftParenthesis = token;
     token = expect('(', token);
     token = parseVariablesDeclarationOrExpressionOpt(token);
     if (optional('in', token)) {
       return parseForInRest(awaitToken, forKeyword, leftParenthesis, token);
     } else {
       if (awaitToken != null) {
-        reportRecoverableError(awaitToken, ErrorKind.InvalidAwaitFor);
+        reportRecoverableErrorCode(awaitToken, codeInvalidAwaitFor);
       }
       return parseForRest(forKeyword, leftParenthesis, token);
     }
   }
 
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
@@ skipping 92 matching lines @@
     }
     listener.endBlock(statementCount, begin, token);
     return expect('}', token);
   }
 
   Token parseAwaitExpression(Token token, bool allowCascades) {
     Token awaitToken = token;
     listener.beginAwaitExpression(awaitToken);
     token = expect('await', token);
     if (!inAsync) {
-      reportRecoverableError(awaitToken, ErrorKind.AwaitNotAsync);
+      reportRecoverableErrorCode(awaitToken, codeAwaitNotAsync);
     }
     token = parsePrecedenceExpression(token, POSTFIX_PRECEDENCE, allowCascades);
     listener.endAwaitExpression(awaitToken, token);
     return token;
   }
 
   Token parseThrowExpression(Token token, bool allowCascades) {
     Token throwToken = token;
     listener.beginThrowExpression(throwToken);
     token = expect('throw', token);
@@ skipping 47 matching lines @@
       value = token.stringValue; // while condition
     }
 
     Token finallyKeyword = null;
     if (optional('finally', token)) {
       finallyKeyword = token;
       token = parseBlock(token.next);
       listener.handleFinallyBlock(finallyKeyword);
     } else {
       if (catchCount == 0) {
-        reportRecoverableError(tryKeyword, ErrorKind.OnlyTry);
+        reportRecoverableErrorCode(tryKeyword, codeOnlyTry);
       }
     }
     listener.endTryStatement(catchCount, tryKeyword, finallyKeyword);
     return token;
   }
 
   Token parseSwitchStatement(Token token) {
     assert(optional('switch', token));
     Token switchKeyword = token;
     listener.beginSwitchStatement(switchKeyword);
@@ skipping 58 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) {
           // TODO(ahe): This is probably easy to recover from.
-          reportUnrecoverableError(
-              token, ErrorKind.ExpectedButGot, {"expected": "case"});
+          reportUnrecoverableErrorCodeWithString(
+              token, codeExpectedButGot, "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 60 matching lines @@
     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 reportUnrecoverableError(Token token, FastaMessage format()) {
     Token next;
     if (token is ErrorToken) {
       next = reportErrorToken(token, false);
     } else {
-      arguments ??= {};
-      arguments.putIfAbsent("actual", () => token.lexeme);
-      next = listener.handleUnrecoverableError(token, kind, arguments);
+      next = listener.handleUnrecoverableError(token, format());
     }
     return next ?? skipToEof(token);
   }
 
-  void reportRecoverableError(Token token, ErrorKind kind, [Map arguments]) {
+  void reportRecoverableError(Token token, FastaMessage format()) {
     if (token is ErrorToken) {
       reportErrorToken(token, true);
     } else {
-      arguments ??= {};
-      listener.handleRecoverableError(token, kind, arguments);
+      listener.handleRecoverableError(token, format());
     }
   }
 
   Token reportErrorToken(ErrorToken token, bool isRecoverable) {
-    ErrorKind kind = token.errorCode;
-    Map arguments = const {};
-    switch (kind) {
-      case ErrorKind.AsciiControlCharacter:
-      case ErrorKind.NonAsciiIdentifier:
-      case ErrorKind.NonAsciiWhitespace:
-      case ErrorKind.Encoding:
-        String hex = token.character.toRadixString(16);
-        if (hex.length < 4) {
-          String padding = "0000".substring(hex.length);
-          hex = "$padding$hex";
-        }
-        arguments = {'characterHex': hex};
-        break;
-
-      case ErrorKind.UnterminatedString:
-        arguments = {'quote': token.start};
-        break;
-
-      case ErrorKind.UnmatchedToken:
-        String begin = token.begin.lexeme;
-        String end = closeBraceFor(begin);
-        arguments = {'begin': begin, 'end': end};
-        break;
-
-      case ErrorKind.Unspecified:
-        arguments = {"text": token.assertionMessage};
-        break;
-
-      default:
-        break;
+    FastaCode code = token.errorCode;
+    FastaMessage message;
+    if (code == codeAsciiControlCharacter) {
+      message = codeAsciiControlCharacter.format(
+          uri, token.charOffset, token.character);
+    } else if (code == codeNonAsciiWhitespace) {
+      message =
+          codeNonAsciiWhitespace.format(uri, token.charOffset, token.character);
+    } else if (code == codeEncoding) {
+      message = codeEncoding.format(uri, token.charOffset);
+    } else if (code == codeNonAsciiIdentifier) {
+      message = codeNonAsciiIdentifier.format(uri, token.charOffset,
+          new String.fromCharCodes([token.character]), token.character);
+    } else if (code == codeUnterminatedString) {
+      message =
+          codeUnterminatedString.format(uri, token.charOffset, token.start);
+    } else if (code == codeUnmatchedToken) {
+      Token begin = token.begin;
+      message = codeUnmatchedToken.format(
+          uri, token.charOffset, closeBraceFor(begin.lexeme), begin);
+    } else if (code == codeUnspecified) {
+      message =
+          codeUnspecified.format(uri, token.charOffset, token.assertionMessage);
+    } else {
+      message = code.format(uri, token.charOffset);
     }
     if (isRecoverable) {
-      listener.handleRecoverableError(token, kind, arguments);
+      listener.handleRecoverableError(token, message);
       return null;
     } else {
-      return listener.handleUnrecoverableError(token, kind, arguments);
+      Token next = listener.handleUnrecoverableError(token, message);
+      return next ?? skipToEof(token);
     }
   }
+
+  Token reportUnmatchedToken(BeginGroupToken token) {
+    return reportUnrecoverableError(
+        token,
+        () => codeUnmatchedToken.format(
+            uri, token.charOffset, closeBraceFor(token.lexeme), token));
+  }
+
+  Token reportUnexpectedToken(Token token) {
+    return reportUnrecoverableError(
+        token, () => codeUnexpectedToken.format(uri, token.charOffset, token));
+  }
+
+  void reportRecoverableErrorCode(Token token, FastaCode<NoArgument> code) {
+    reportRecoverableError(token, () => code.format(uri, token.charOffset));
+  }
+
+  Token reportUnrecoverableErrorCode(Token token, FastaCode<NoArgument> code) {
+    return reportUnrecoverableError(
+        token, () => code.format(uri, token.charOffset));
+  }
+
+  void reportRecoverableErrorCodeWithToken(
+      Token token, FastaCode<TokenArgument> code) {
+    reportRecoverableError(
+        token, () => code.format(uri, token.charOffset, token));
+  }
+
+  Token reportUnrecoverableErrorCodeWithToken(
+      Token token, FastaCode<TokenArgument> code) {
+    return reportUnrecoverableError(
+        token, () => code.format(uri, token.charOffset, token));
+  }
+
+  Token reportUnrecoverableErrorCodeWithString(
+      Token token, FastaCode<StringArgument> code, String string) {
+    return reportUnrecoverableError(
+        token, () => code.format(uri, token.charOffset, string));
+  }
 }
+
+typedef FastaMessage NoArgument(Uri uri, int charOffset);
+
+typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
+
+typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);