Use FastaMessage instead of String. Part 1.

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;
+import '../fasta_codes.dart' show Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
 import '../scanner.dart' show ErrorToken, Token;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
 import '../../scanner/token.dart'
     show
         ASSIGNMENT_PRECEDENCE,
@@ skipping 253 matching lines @@
 ///
 /// Both dart2js and the Dart VM have used the `native` keyword to mark methods
 /// that couldn't be implemented in the Dart language and needed to be
 /// implemented in JavaScript or C++, respectively. An example of the syntax
 /// extension used by the Dart VM is:
 ///
 ///     nativeFunction() native "NativeFunction";
 ///
 /// When attempting to parse this function, the parser eventually calls
 /// [parseFunctionBody]. This method will report an unrecoverable error to the
-/// listener with the code [fasta.codeExpectedFunctionBody]. The listener can
+/// listener with the code [fasta.messageExpectedFunctionBody]. The listener can
 /// then look at the error code and the token and use the methods in
 /// [dart_vm_native.dart](dart_vm_native.dart) to parse the native syntax.
 ///
 /// #### Implementation of Diet Parsing
 ///
 /// We call it _diet_ _parsing_ when the parser skips parts of a file. Both
 /// dart2js and the Dart VM have been relying on this from early on as it allows
 /// them to more quickly compile small programs that use small parts of big
 /// libraries. It's also become an integrated part of how Fasta builds up
 /// outlines before starting to parse method bodies.
@@ skipping 314 matching lines @@
 
   /// Parse `'@' qualified (‘.’ identifier)? (arguments)?`
   Token parseMetadata(Token token) {
     listener.beginMetadata(token);
     Token atToken = token;
     assert(optional('@', token));
     token = parseIdentifier(token.next, IdentifierContext.metadataReference);
     token =
         parseQualifiedRestOpt(token, IdentifierContext.metadataContinuation);
     if (optional("<", token)) {
-      reportRecoverableErrorCode(token, fasta.codeMetadataTypeArguments);
+      reportRecoverableError(token, fasta.messageMetadataTypeArguments);
     }
     token = parseTypeArgumentsOpt(token);
     Token period = null;
     if (optional('.', token)) {
       period = token;
       token = parseIdentifier(
           token.next, IdentifierContext.metadataContinuationAfterTypeArguments);
     }
     token = parseArgumentsOpt(token);
     listener.endMetadata(atToken, period, token);
@@ skipping 44 matching lines @@
       listener.handleNoFormalParameters(token, kind);
       return token;
     }
   }
 
   Token skipFormalParameters(Token token, MemberKind kind) {
     // TODO(ahe): Shouldn't this be `beginFormalParameters`?
     listener.beginOptionalFormalParameters(token);
     if (!optional('(', token)) {
       if (optional(';', token)) {
-        reportRecoverableErrorCode(token, fasta.codeExpectedOpenParens);
+        reportRecoverableError(token, fasta.messageExpectedOpenParens);
         return token;
       }
-      return reportUnrecoverableErrorCodeWithString(
-              token, fasta.codeExpectedButGot, "(")
+      return reportUnrecoverableError(
+              token, fasta.templateExpectedButGot.withArguments("("))
           .next;
     }
     BeginToken beginGroupToken = token;
     Token endToken = beginGroupToken.endGroup;
     listener.endFormalParameters(0, token, endToken, kind);
     return endToken.next;
   }
 
   /// Parses the formal parameter list of a function.
   ///
@@ skipping 12 matching lines @@
       ++parameterCount;
       String value = token.stringValue;
       if (identical(value, '[')) {
         token = parseOptionalFormalParameters(token, false, kind);
         break;
       } else if (identical(value, '{')) {
         token = parseOptionalFormalParameters(token, true, kind);
         break;
       } else if (identical(value, '[]')) {
         --parameterCount;
-        reportRecoverableErrorCode(token, fasta.codeEmptyOptionalParameterList);
+        reportRecoverableError(token, fasta.messageEmptyOptionalParameterList);
         token = token.next;
         break;
       }
       token = parseFormalParameter(token, FormalParameterType.REQUIRED, kind);
     } while (optional(',', token));
     listener.endFormalParameters(parameterCount, begin, token, kind);
     return expect(')', token);
   }
 
   Token parseFormalParameter(
@@ skipping 16 matching lines @@
         break;
       } else if (!isNamed && optional(']', token)) {
         break;
       }
       var type =
           isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
       token = parseFormalParameter(token, type, kind);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
-      reportRecoverableErrorCode(
+      reportRecoverableError(
           token,
           isNamed
-              ? fasta.codeEmptyNamedParameterList
-              : fasta.codeEmptyOptionalParameterList);
+              ? fasta.messageEmptyNamedParameterList
+              : fasta.messageEmptyOptionalParameterList);
     }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
     }
   }
 
   bool isValidTypeReference(Token token) {
@@ skipping 108 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 reportUnrecoverableErrorCode(token, fasta.codeExpectedBlockToSkip)
+      return reportUnrecoverableError(token, fasta.messageExpectedBlockToSkip)
           .next;
     }
     BeginToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
       return reportUnmatchedToken(beginGroupToken).next;
     }
     return beginGroupToken.endGroup;
   }
 
@@ skipping 83 matching lines @@
     }
     token = parseClassBody(token);
     listener.endClassDeclaration(interfacesCount, begin, classKeyword,
         extendsKeyword, implementsKeyword, token);
     return token.next;
   }
 
   Token parseStringPart(Token token) {
     if (token.kind != STRING_TOKEN) {
       token =
-          reportUnrecoverableErrorCodeWithToken(token, fasta.codeExpectedString)
+          reportUnrecoverableErrorWithToken(token, fasta.templateExpectedString)
               .next;
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
   Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier) {
       if (optional("void", token)) {
-        reportRecoverableErrorCode(token, fasta.codeInvalidVoid);
+        reportRecoverableError(token, fasta.messageInvalidVoid);
       } else {
-        token = reportUnrecoverableErrorCodeWithToken(
-                token, fasta.codeExpectedIdentifier)
+        token = reportUnrecoverableErrorWithToken(
+                token, fasta.templateExpectedIdentifier)
             .next;
       }
     } else if (token.type.isBuiltIn && !context.isBuiltInIdentifierAllowed) {
       if (context.inDeclaration) {
-        reportRecoverableErrorCodeWithToken(
-            token, fasta.codeBuiltInIdentifierInDeclaration);
+        reportRecoverableErrorWithToken(
+            token, fasta.templateBuiltInIdentifierInDeclaration);
       } else if (!optional("dynamic", token)) {
-        reportRecoverableErrorCodeWithToken(
-            token, fasta.codeBuiltInIdentifierAsType);
+        reportRecoverableErrorWithToken(
+            token, fasta.templateBuiltInIdentifierAsType);
       }
     } else if (!inPlainSync && token.type.isPseudo) {
       if (optional('await', token)) {
-        reportRecoverableErrorCode(token, fasta.codeAwaitAsIdentifier);
+        reportRecoverableError(token, fasta.messageAwaitAsIdentifier);
       } else if (optional('yield', token)) {
-        reportRecoverableErrorCode(token, fasta.codeYieldAsIdentifier);
+        reportRecoverableError(token, fasta.messageYieldAsIdentifier);
       } else if (optional('async', token)) {
-        reportRecoverableErrorCode(token, fasta.codeAsyncAsIdentifier);
+        reportRecoverableError(token, fasta.messageAsyncAsIdentifier);
       }
     }
     listener.handleIdentifier(token, context);
     return token.next;
   }
 
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
-      return reportUnrecoverableErrorCodeWithString(
-              token, fasta.codeExpectedButGot, string)
+      return reportUnrecoverableError(
+              token, fasta.templateExpectedButGot.withArguments(string))
           .next;
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseMetadataStar(token);
     token = parseIdentifier(token, IdentifierContext.typeVariableDeclaration);
     Token extendsOrSuper = null;
@@ skipping 198 matching lines @@
         if (optional("<", token)) {
           // Skip type parameters, they were parsed above.
           token = getClose(token).next;
         }
         token =
             parseFormalParameters(token, MemberKind.GeneralizedFunctionType);
         listener.endFunctionType(functionToken, token);
       }
 
       if (hasVar) {
-        reportRecoverableErrorCode(begin, fasta.codeTypeAfterVar);
+        reportRecoverableError(begin, fasta.messageTypeAfterVar);
       }
 
       return token;
     }
 
     /// Returns true if [kind] is '=', ';', or ',', that is, if [kind] could be
     /// the end of a variable declaration.
     bool looksLikeVariableDeclarationEnd(int kind) {
       return EQ_TOKEN == kind || SEMICOLON_TOKEN == kind || COMMA_TOKEN == kind;
     }
@@ skipping 191 matching lines @@
           nameToken = token;
           nameContext = IdentifierContext.fieldInitializer;
           token = token.next;
         } else if (!nameToken.isIdentifier) {
           untyped = true;
           nameToken = begin;
           token = nameToken.next;
         }
         if (isNamedParameter && nameToken.lexeme.startsWith("_")) {
           // TODO(ahe): Move this to after commiting the type.
-          reportRecoverableErrorCode(
-              nameToken, fasta.codePrivateNamedParameter);
+          reportRecoverableError(nameToken, fasta.messagePrivateNamedParameter);
         }
 
         token = listener.injectGenericCommentTypeList(token);
 
         Token inlineFunctionTypeStart;
         if (optional("<", token)) {
           Token closer = getClose(token);
           if (closer != null) {
             if (optional("(", closer.next)) {
               inlineFunctionTypeStart = token;
@@ skipping 20 matching lines @@
             listener.handleNoType(begin);
           }
           token =
               parseFormalParameters(token, MemberKind.FunctionTypedParameter);
           listener.endFunctionTypedFormalParameter();
 
           // Generalized function types don't allow inline function types.
           // The following isn't allowed:
           //    int Function(int bar(String x)).
           if (memberKind == MemberKind.GeneralizedFunctionType) {
-            reportRecoverableErrorCode(
-                inlineFunctionTypeStart, fasta.codeInvalidInlineFunctionType);
+            reportRecoverableError(inlineFunctionTypeStart,
+                fasta.messageInvalidInlineFunctionType);
           }
         } else if (untyped) {
           listener.handleNoType(begin);
         } else {
           Token saved = token;
           commitType();
           token = saved;
         }
 
         if (nameContext != null) {
           parseIdentifier(nameToken, nameContext);
         } else {
           listener.handleNoName(nameToken);
         }
 
         String value = token.stringValue;
         if ((identical('=', value)) || (identical(':', value))) {
           Token equal = token;
           token = parseExpression(token.next);
           listener.handleValuedFormalParameter(equal, token);
           if (parameterKind.isRequired) {
-            reportRecoverableErrorCode(
-                equal, fasta.codeRequiredParameterWithDefault);
+            reportRecoverableError(
+                equal, fasta.messageRequiredParameterWithDefault);
           } else if (parameterKind.isPositional && identical(':', value)) {
-            reportRecoverableErrorCode(
-                equal, fasta.codePositionalParameterWithEquals);
+            reportRecoverableError(
+                equal, fasta.messagePositionalParameterWithEquals);
           } else if (inFunctionType ||
               memberKind == MemberKind.FunctionTypeAlias ||
               memberKind == MemberKind.FunctionTypedParameter) {
-            reportRecoverableErrorCode(
-                equal.next, fasta.codeFunctionTypeDefaultValue);
+            reportRecoverableError(
+                equal.next, fasta.messageFunctionTypeDefaultValue);
           }
         } else {
           listener.handleFormalParameterWithoutValue(token);
         }
         listener.endFormalParameter(
             thisKeyword, nameToken, parameterKind, memberKind);
 
         return token;
     }
 
@@ skipping 42 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 reportUnrecoverableErrorCodeWithToken(
-              start, fasta.codeExpectedDeclaration)
+      return reportUnrecoverableErrorWithToken(
+              start, fasta.templateExpectedDeclaration)
           .next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return reportUnrecoverableErrorCodeWithToken(
-              start, fasta.codeExpectedDeclaration)
+      return reportUnrecoverableErrorWithToken(
+              start, fasta.templateExpectedDeclaration)
           .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 51 matching lines @@
           optional("const", modifier)) {
         varFinalOrConst = modifier;
         break;
       }
     }
     Token token = parseModifiers(start,
         isTopLevel ? MemberKind.TopLevelField : MemberKind.NonStaticField,
         isVarAllowed: true);
 
     if (token != name) {
-      reportRecoverableErrorCodeWithToken(token, fasta.codeExtraneousModifier);
+      reportRecoverableErrorWithToken(token, fasta.templateExtraneousModifier);
       token = name;
     }
 
     IdentifierContext context = isTopLevel
         ? IdentifierContext.topLevelVariableDeclaration
         : IdentifierContext.fieldDeclaration;
     token = parseIdentifier(token, context);
 
     int fieldCount = 1;
     token = parseFieldInitializerOpt(token, name, varFinalOrConst, isTopLevel);
@@ skipping 17 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 {
-        reportRecoverableErrorCodeWithToken(
-            modifier, fasta.codeExtraneousModifier);
+        reportRecoverableErrorWithToken(
+            modifier, fasta.templateExtraneousModifier);
       }
     }
     if (externalModifier != null) {
       parseModifier(externalModifier);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
     if (type == null) {
@@ skipping 10 matching lines @@
     } else {
       isGetter = optional("get", getOrSet);
       listener.handleNoTypeVariables(token);
     }
     checkFormals(isGetter, name, token);
     token = parseFormalParametersOpt(token, MemberKind.TopLevelMethod);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
-      reportRecoverableErrorCode(asyncToken, fasta.codeSetterNotSync);
+      reportRecoverableError(asyncToken, fasta.messageSetterNotSync);
     }
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncState = savedAsyncModifier;
     Token endToken = token;
     token = token.next;
     listener.endTopLevelMethod(start, getOrSet, endToken);
     return token;
   }
 
   void checkFormals(bool isGetter, Token name, Token token) {
     if (optional("(", token)) {
       if (isGetter) {
-        reportRecoverableErrorCode(token, fasta.codeGetterWithFormals);
+        reportRecoverableError(token, fasta.messageGetterWithFormals);
       }
     } else if (!isGetter) {
-      reportRecoverableErrorCodeWithToken(name, fasta.codeNoFormals);
+      reportRecoverableErrorWithToken(name, fasta.templateNoFormals);
     }
   }
 
   /// 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:
   ///
   ///     int get foo;
@@ skipping 104 matching lines @@
             BeginToken beginGroup = token;
             if (beginGroup.endGroup == null) {
               token = reportUnmatchedToken(beginGroup).next;
             } else {
               token = beginGroup.endGroup.next;
             }
           }
         }
         if (!optional('(', token)) {
           if (optional(';', token)) {
-            reportRecoverableErrorCode(token, fasta.codeExpectedOpenParens);
+            reportRecoverableError(token, fasta.messageExpectedOpenParens);
           }
           token = expect("(", token);
         }
         if (token is BeginToken) {
           BeginToken beginGroup = token;
           if (beginGroup.endGroup == null) {
             token = reportUnmatchedToken(beginGroup).next;
           } else {
             token = beginGroup.endGroup.next;
           }
         }
       }
     }
     return listener.handleMemberName(const Link<Token>());
   }
 
   Token parseFieldInitializerOpt(
       Token token, Token name, Token varFinalOrConst, bool isTopLevel) {
     if (optional('=', token)) {
       Token assignment = token;
       listener.beginFieldInitializer(token);
       token = parseExpression(token.next);
       listener.endFieldInitializer(assignment, token);
     } else {
       if (varFinalOrConst != null) {
         if (optional("const", varFinalOrConst)) {
-          reportRecoverableErrorCode(
-              name, fasta.codeConstFieldWithoutInitializer);
+          reportRecoverableError(
+              name, fasta.messageConstFieldWithoutInitializer);
         } else if (isTopLevel && optional("final", varFinalOrConst)) {
-          reportRecoverableErrorCode(
-              name, fasta.codeFinalFieldWithoutInitializer);
+          reportRecoverableError(
+              name, fasta.messageFinalFieldWithoutInitializer);
         }
       }
       listener.handleNoFieldInitializer(token);
     }
     return token;
   }
 
   Token parseVariableInitializerOpt(Token token) {
     if (optional('=', token)) {
       Token assignment = token;
@@ skipping 38 matching lines @@
     } else {
       token = parseExpression(token);
     }
     listener.endInitializer(token);
     return token;
   }
 
   Token parseLiteralStringOrRecoverExpression(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       return parseLiteralString(token);
+    } else if (token is ErrorToken) {
+      return reportErrorToken(token, false);
     } else {
-      reportRecoverableErrorCodeWithToken(token, fasta.codeExpectedString);
+      reportRecoverableErrorWithToken(token, fasta.templateExpectedString);
       return parseRecoverExpression(
-          token, fasta.codeExpectedString.format(uri, token.charOffset, token));
+          token, fasta.templateExpectedString.withArguments(token));
     }
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
   bool isModifier(Token token) => modifierOrder(token) < 127;
 
   /// Provides a partial order on modifiers.
@@ skipping 53 matching lines @@
           break;
         }
       }
       int order = modifierOrder(token);
       if (order < 3) {
         // `abstract` isn't parsed with this method.
         if (order > currentOrder) {
           currentOrder = order;
           if (optional("var", token)) {
             if (!isVarAllowed && parameterKind == null) {
-              reportRecoverableErrorCodeWithToken(
-                  token, fasta.codeExtraneousModifier);
+              reportRecoverableErrorWithToken(
+                  token, fasta.templateExtraneousModifier);
             }
             switch (typeContinuation ?? TypeContinuation.Required) {
               case TypeContinuation.NormalFormalParameter:
                 typeContinuation =
                     TypeContinuation.NormalFormalParameterAfterVar;
                 break;
 
               case TypeContinuation.OptionalPositionalFormalParameter:
                 typeContinuation =
                     TypeContinuation.OptionalPositionalFormalParameterAfterVar;
                 break;
 
               case TypeContinuation.NamedFormalParameter:
                 typeContinuation =
                     TypeContinuation.NamedFormalParameterAfterVar;
                 break;
 
               default:
                 typeContinuation = TypeContinuation.OptionalAfterVar;
                 break;
             }
           } else if (optional("final", token)) {
             if (!isVarAllowed && parameterKind == null) {
-              reportRecoverableErrorCodeWithToken(
-                  token, fasta.codeExtraneousModifier);
+              reportRecoverableErrorWithToken(
+                  token, fasta.templateExtraneousModifier);
             }
             typeContinuation ??= TypeContinuation.Optional;
           } else if (optional("const", token)) {
             if (!isVarAllowed) {
-              reportRecoverableErrorCodeWithToken(
-                  token, fasta.codeExtraneousModifier);
+              reportRecoverableErrorWithToken(
+                  token, fasta.templateExtraneousModifier);
             }
             typeContinuation ??= TypeContinuation.Optional;
           } else if (optional("static", token)) {
             if (parameterKind != null) {
-              reportRecoverableErrorCodeWithToken(
-                  token, fasta.codeExtraneousModifier);
+              reportRecoverableErrorWithToken(
+                  token, fasta.templateExtraneousModifier);
             } else if (memberKind == MemberKind.NonStaticMethod) {
               memberKind = MemberKind.StaticMethod;
             } else if (memberKind == MemberKind.NonStaticField) {
               memberKind = MemberKind.StaticField;
             } else {
-              reportRecoverableErrorCodeWithToken(
-                  token, fasta.codeExtraneousModifier);
+              reportRecoverableErrorWithToken(
+                  token, fasta.templateExtraneousModifier);
               token = token.next;
               continue;
             }
           } else if (optional("covariant", token)) {
             switch (memberKind) {
               case MemberKind.StaticField:
               case MemberKind.StaticMethod:
               case MemberKind.TopLevelField:
               case MemberKind.TopLevelMethod:
-                reportRecoverableErrorCodeWithToken(
-                    token, fasta.codeExtraneousModifier);
+                reportRecoverableErrorWithToken(
+                    token, fasta.templateExtraneousModifier);
                 token = token.next;
                 continue;
 
               default:
                 break;
             }
           } else if (optional("external", token)) {
             switch (memberKind) {
               case MemberKind.Factory:
               case MemberKind.NonStaticMethod:
               case MemberKind.StaticMethod:
               case MemberKind.TopLevelMethod:
                 break;
 
               default:
-                reportRecoverableErrorCodeWithToken(
-                    token, fasta.codeExtraneousModifier);
+                reportRecoverableErrorWithToken(
+                    token, fasta.templateExtraneousModifier);
                 token = token.next;
                 continue;
             }
           }
           token = parseModifier(token);
           count++;
         } else {
-          reportRecoverableErrorCodeWithToken(
-              token, fasta.codeExtraneousModifier);
+          reportRecoverableErrorWithToken(
+              token, fasta.templateExtraneousModifier);
           token = token.next;
         }
       } else {
         break;
       }
     }
     listener.handleModifiers(count);
 
     typeContinuation ??=
         (isVarAllowed || memberKind == MemberKind.GeneralizedFunctionType)
             ? TypeContinuation.Required
             : TypeContinuation.Optional;
 
     token = parseType(token, typeContinuation, null, memberKind);
     return token;
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
-      return reportUnrecoverableErrorCodeWithToken(
-              token, fasta.codeExpectedClassBodyToSkip)
+      return reportUnrecoverableErrorWithToken(
+              token, fasta.templateExpectedClassBodyToSkip)
           .next;
     }
     BeginToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     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 = reportUnrecoverableErrorCodeWithToken(
-              token, fasta.codeExpectedClassBody)
+      token = reportUnrecoverableErrorWithToken(
+              token, fasta.templateExpectedClassBody)
           .next;
     }
     token = token.next;
     int count = 0;
     while (notEofOrValue('}', token)) {
       token = parseMember(token);
       ++count;
     }
     expect('}', token);
     listener.endClassBody(count, begin, token);
@@ skipping 17 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 reportUnrecoverableErrorCodeWithToken(
-              start, fasta.codeExpectedDeclaration)
+      return reportUnrecoverableErrorWithToken(
+              start, fasta.templateExpectedDeclaration)
           .next;
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
     if (identifiers.isEmpty) {
-      return reportUnrecoverableErrorCodeWithToken(
-              start, fasta.codeExpectedDeclaration)
+      return reportUnrecoverableErrorWithToken(
+              start, fasta.templateExpectedDeclaration)
           .next;
     }
     Token name = identifiers.head;
     identifiers = identifiers.tail;
     if (!identifiers.isEmpty) {
       if (optional('operator', identifiers.head)) {
         name = identifiers.head;
         identifiers = identifiers.tail;
       }
     }
@@ skipping 63 matching lines @@
 
     Token externalModifier;
     Token staticModifier;
     // TODO(ahe): Consider using [parseModifiers] instead.
     void parseModifierList(Link<Token> tokens) {
       int count = 0;
       int currentOrder = -1;
       for (; !tokens.isEmpty; tokens = tokens.tail) {
         Token token = tokens.head;
         if (optional("abstract", token)) {
-          reportRecoverableErrorCodeWithToken(
-              token, fasta.codeExtraneousModifier);
+          reportRecoverableErrorWithToken(
+              token, fasta.templateExtraneousModifier);
           continue;
         }
         int order = modifierOrder(token);
         if (order < 127) {
           if (order > currentOrder) {
             currentOrder = order;
             if (optional("var", token)) {
-              reportRecoverableErrorCodeWithToken(
-                  token, fasta.codeExtraneousModifier);
+              reportRecoverableErrorWithToken(
+                  token, fasta.templateExtraneousModifier);
             } else if (optional("const", token)) {
               if (getOrSet != null) {
-                reportRecoverableErrorCodeWithToken(
-                    token, fasta.codeExtraneousModifier);
+                reportRecoverableErrorWithToken(
+                    token, fasta.templateExtraneousModifier);
                 continue;
               }
             } else if (optional("external", token)) {
               externalModifier = token;
             } else if (optional("static", token)) {
               staticModifier = token;
             } else if (optional("covariant", token)) {
               if (staticModifier != null ||
                   getOrSet == null ||
                   optional("get", getOrSet)) {
-                reportRecoverableErrorCodeWithToken(
-                    token, fasta.codeExtraneousModifier);
+                reportRecoverableErrorWithToken(
+                    token, fasta.templateExtraneousModifier);
                 continue;
               }
             }
           } else {
-            reportRecoverableErrorCodeWithToken(
-                token, fasta.codeExtraneousModifier);
+            reportRecoverableErrorWithToken(
+                token, fasta.templateExtraneousModifier);
             continue;
           }
         } else {
           reportUnexpectedToken(token);
           break; // Skip the remaining modifiers.
         }
         parseModifier(token);
         count++;
       }
       listener.handleModifiers(count);
     }
 
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseType(type, TypeContinuation.Optional);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
-        reportRecoverableErrorCodeWithToken(
-            staticModifier, fasta.codeExtraneousModifier);
+        reportRecoverableErrorWithToken(
+            staticModifier, fasta.templateExtraneousModifier);
       }
     } else {
       token = parseIdentifier(name, IdentifierContext.methodDeclaration);
     }
 
     token = parseQualifiedRestOpt(
         token, IdentifierContext.methodDeclarationContinuation);
     bool isGetter = false;
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       isGetter = optional("get", getOrSet);
       listener.handleNoTypeVariables(token);
     }
     checkFormals(isGetter, name, token);
     token = parseFormalParametersOpt(
         token,
         staticModifier != null
             ? MemberKind.StaticMethod
             : MemberKind.NonStaticMethod);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
-      reportRecoverableErrorCode(asyncToken, fasta.codeSetterNotSync);
+      reportRecoverableError(asyncToken, fasta.messageSetterNotSync);
     }
     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, MemberKind.Factory);
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (!inPlainSync) {
-      reportRecoverableErrorCode(asyncToken, fasta.codeFactoryNotSync);
+      reportRecoverableError(asyncToken, fasta.messageFactoryNotSync);
     }
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false, isExternal);
     }
     listener.endFactoryMethod(start, factoryKeyword, token);
     return token.next;
   }
 
@@ skipping 99 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) {
-        reportRecoverableErrorCode(token, fasta.codeExpectedBody);
+        reportRecoverableError(token, fasta.messageExpectedBody);
       }
       listener.handleNoFunctionBody(token);
     } else {
       if (identical(value, '=>')) {
         token = parseExpression(token.next);
         expectSemicolon(token);
         listener.handleFunctionBodySkipped(token, true);
       } else if (identical(value, '=')) {
-        reportRecoverableErrorCode(token, fasta.codeExpectedBody);
+        reportRecoverableError(token, fasta.messageExpectedBody);
         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) {
-        reportRecoverableErrorCode(token, fasta.codeExpectedBody);
+        reportRecoverableError(token, fasta.messageExpectedBody);
       }
       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.
-      reportRecoverableErrorCode(token, fasta.codeExpectedBody);
+      reportRecoverableError(token, fasta.messageExpectedBody);
       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 = reportUnrecoverableErrorCodeWithToken(
-              token, fasta.codeExpectedFunctionBody)
+      token = reportUnrecoverableErrorWithToken(
+              token, fasta.templateExpectedFunctionBody)
           .next;
       listener.handleInvalidFunctionBody(token);
       return token;
     }
 
     listener.beginBlockFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
@@ skipping 38 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 {
-        reportRecoverableErrorCode(async, fasta.codeInvalidSyncModifier);
+        reportRecoverableError(async, fasta.messageInvalidSyncModifier);
       }
     }
     listener.handleAsyncModifier(async, star);
     if (inGenerator && optional('=>', token)) {
-      reportRecoverableErrorCode(token, fasta.codeGeneratorReturnsValue);
+      reportRecoverableError(token, fasta.messageGeneratorReturnsValue);
     } else if (!inPlainSync && optional(';', token)) {
-      reportRecoverableErrorCode(token, fasta.codeAbstractNotSync);
+      reportRecoverableError(token, fasta.messageAbstractNotSync);
     }
     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 reportUnrecoverableErrorCode(token, fasta.codeStackOverflow).next;
+      return reportUnrecoverableError(token, fasta.messageStackOverflow).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) {
-        reportRecoverableErrorCode(token, fasta.codeAwaitForNotAsync);
+        reportRecoverableError(token, fasta.messageAwaitForNotAsync);
       }
       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:
-          reportRecoverableErrorCode(token, fasta.codeYieldNotGenerator);
+          reportRecoverableError(token, fasta.messageYieldNotGenerator);
           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 if (identical(value, '@')) {
       return parseVariablesDeclaration(token);
     } else {
@@ skipping 19 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) {
-        reportRecoverableErrorCode(begin.next, fasta.codeGeneratorReturnsValue);
+        reportRecoverableError(begin.next, fasta.messageGeneratorReturnsValue);
       }
       listener.endReturnStatement(true, begin, token);
     }
     return expectSemicolon(token);
   }
 
   Token parseExpressionStatementOrDeclaration(Token token) {
     return parseType(token, TypeContinuation.ExpressionStatementOrDeclaration);
   }
 
@@ skipping 92 matching lines @@
         BeginToken begin = token;
         token = (begin.endGroup != null) ? begin.endGroup : token;
       } else if (token is ErrorToken) {
         reportErrorToken(token, false).next;
       }
       token = token.next;
     }
     return token;
   }
 
-  Token parseRecoverExpression(Token token, FastaMessage message) =>
-      parseExpression(token);
+  Token parseRecoverExpression(Token token, Message message) {
+    return 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 reportUnrecoverableErrorCode(token, fasta.codeStackOverflow).next;
+      return reportUnrecoverableError(token, fasta.messageStackOverflow).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 120 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.
-      reportRecoverableErrorCode(token, fasta.codeUnsupportedPrefixPlus);
+      reportRecoverableError(token, fasta.messageUnsupportedPrefixPlus);
       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 82 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 = reportUnrecoverableErrorCodeWithToken(
-            token, fasta.codeExpectedExpression)
+    token = reportUnrecoverableErrorWithToken(
+            token, fasta.templateExpectedExpression)
         .next;
     listener.handleInvalidExpression(token);
     return token;
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginToken beginGroup = token;
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
@@ skipping 44 matching lines @@
   Token parseSuperExpression(Token token, IdentifierContext context) {
     Token beginToken = token;
     listener.handleSuperExpression(token, context);
     token = token.next;
     if (optional('(', token)) {
       // Super constructor.
       listener.handleNoTypeArguments(token);
       token = parseArguments(token);
       listener.endSend(beginToken, token);
     } else if (optional("?.", token)) {
-      reportRecoverableErrorCode(token, fasta.codeSuperNullAware);
+      reportRecoverableError(token, fasta.messageSuperNullAware);
     }
     return token;
   }
 
   /// '[' (expressionList ','?)? ']'.
   ///
   /// Provide [constKeyword] if preceded by 'const', null if not.
   /// This is a suffix parser because it is assumed that type arguments have
   /// been parsed, or `listener.handleNoTypeArguments(..)` has been executed.
   Token parseLiteralListSuffix(Token token, Token constKeyword) {
@@ skipping 455 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) {
-        reportRecoverableErrorCode(awaitToken, fasta.codeInvalidAwaitFor);
+        reportRecoverableError(awaitToken, fasta.messageInvalidAwaitFor);
       }
       return parseForRest(forKeyword, leftParenthesis, token);
     }
   }
 
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
@@ skipping 85 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) {
-      reportRecoverableErrorCode(awaitToken, fasta.codeAwaitNotAsync);
+      reportRecoverableError(awaitToken, fasta.messageAwaitNotAsync);
     }
     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 38 matching lines @@
       if (identical(value, 'catch')) {
         catchKeyword = token;
         Token openParens = catchKeyword.next;
         Token exceptionName = openParens.next;
         Token commaOrCloseParens = exceptionName.next;
         Token traceName = commaOrCloseParens.next;
         Token closeParens = traceName.next;
         if (!optional("(", openParens)) {
           // Handled below by parseFormalParameters.
         } else if (!exceptionName.isIdentifier) {
-          reportRecoverableErrorCode(exceptionName, fasta.codeCatchSyntax);
+          reportRecoverableError(exceptionName, fasta.messageCatchSyntax);
         } else if (optional(")", commaOrCloseParens)) {
           // OK: `catch (identifier)`.
         } else if (!optional(",", commaOrCloseParens)) {
-          reportRecoverableErrorCode(exceptionName, fasta.codeCatchSyntax);
+          reportRecoverableError(exceptionName, fasta.messageCatchSyntax);
         } else if (!traceName.isIdentifier) {
-          reportRecoverableErrorCode(exceptionName, fasta.codeCatchSyntax);
+          reportRecoverableError(exceptionName, fasta.messageCatchSyntax);
         } else if (!optional(")", closeParens)) {
-          reportRecoverableErrorCode(exceptionName, fasta.codeCatchSyntax);
+          reportRecoverableError(exceptionName, fasta.messageCatchSyntax);
         }
         token = parseFormalParameters(token.next, MemberKind.Catch);
       }
       listener.endCatchClause(token);
       token = parseBlock(token);
       ++catchCount;
       listener.handleCatchBlock(onKeyword, catchKeyword);
       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) {
-        reportRecoverableErrorCode(tryKeyword, fasta.codeOnlyTry);
+        reportRecoverableError(tryKeyword, fasta.messageOnlyTry);
       }
     }
     listener.endTryStatement(catchCount, tryKeyword, finallyKeyword);
     return token;
   }
 
   Token parseSwitchStatement(Token token) {
     assert(optional('switch', token));
     Token switchKeyword = token;
     listener.beginSwitchStatement(switchKeyword);
@@ skipping 60 matching lines @@
         token = parseExpression(token.next);
         listener.endCaseExpression(token);
         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.
-          reportUnrecoverableErrorCodeWithString(
-              token, fasta.codeExpectedButGot, "case");
+          reportUnrecoverableError(
+              token, fasta.templateExpectedButGot.withArguments("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 39 matching lines @@
       commaToken = token;
       token = token.next;
       token = parseExpression(token);
     }
     if (optional(',', token)) {
       Token firstExtra = token.next;
       while (optional(',', token)) {
         token = token.next;
         Token begin = token;
         token = parseExpression(token);
-        listener.handleExtraneousExpression(begin,
-            fasta.codeAssertExtraneousArgument.format(uri, token.charOffset));
+        listener.handleExtraneousExpression(
+            begin, fasta.messageAssertExtraneousArgument);
       }
-      reportRecoverableErrorCode(
-          firstExtra, fasta.codeAssertExtraneousArgument);
+      reportRecoverableError(firstExtra, fasta.messageAssertExtraneousArgument);
     }
     Token rightParenthesis = token;
     token = expect(')', token);
     mayParseFunctionExpressions = old;
     listener.endAssert(assertKeyword, kind, leftParenthesis, commaToken,
         rightParenthesis, token);
     if (kind == Assert.Expression) {
-      reportRecoverableErrorCode(assertKeyword, fasta.codeAssertAsExpression);
+      reportRecoverableError(assertKeyword, fasta.messageAssertAsExpression);
     }
     return token;
   }
 
   Token parseAssertStatement(Token token) {
     token = parseAssert(token, Assert.Statement);
     return expectSemicolon(token);
   }
 
   Token parseContinueStatement(Token token) {
     assert(optional('continue', token));
     Token continueKeyword = token;
     token = token.next;
     bool hasTarget = false;
     if (token.isIdentifier) {
       token = parseIdentifier(token, IdentifierContext.labelReference);
       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, FastaMessage format()) {
+  Token reportUnrecoverableError(Token token, Message message) {
     Token next;
     if (token is ErrorToken) {
       next = reportErrorToken(token, false);
     } else {
-      next = listener.handleUnrecoverableError(token, format());
+      next = listener.handleUnrecoverableError(token, message);
     }
     return next ?? skipToEof(token);
   }
 
-  void reportRecoverableError(Token token, FastaMessage format()) {
+  void reportRecoverableError(Token token, Message message) {
     if (token is ErrorToken) {
       reportErrorToken(token, true);
     } else {
-      listener.handleRecoverableError(token, format());
+      listener.handleRecoverableError(token, message);
+    }
+  }
+
+  Token reportUnrecoverableErrorWithToken(
+      Token token, Template<_MessageWithArgument<Token>> template) {
+    Token next;
+    if (token is ErrorToken) {
+      next = reportErrorToken(token, false);
+    } else {
+      next = listener.handleUnrecoverableError(
+          token, template.withArguments(token));
+    }
+    return next ?? skipToEof(token);
+  }
+
+  void reportRecoverableErrorWithToken(
+      Token token, Template<_MessageWithArgument<Token>> template) {
+    if (token is ErrorToken) {
+      reportErrorToken(token, true);
+    } else {
+      listener.handleRecoverableError(token, template.withArguments(token));
     }
   }
 
   Token reportErrorToken(ErrorToken token, bool isRecoverable) {
-    FastaCode code = token.errorCode;
-    FastaMessage message;
+    Code code = token.errorCode;
+    Message message;
     if (code == fasta.codeAsciiControlCharacter) {
-      message = fasta.codeAsciiControlCharacter
-          .format(uri, token.charOffset, token.character);
+      message =
+          fasta.templateAsciiControlCharacter.withArguments(token.character);
     } else if (code == fasta.codeNonAsciiWhitespace) {
-      message = fasta.codeNonAsciiWhitespace
-          .format(uri, token.charOffset, token.character);
+      message = fasta.templateNonAsciiWhitespace.withArguments(token.character);
     } else if (code == fasta.codeEncoding) {
-      message = fasta.codeEncoding.format(uri, token.charOffset);
+      message = fasta.messageEncoding;
     } else if (code == fasta.codeNonAsciiIdentifier) {
-      message = fasta.codeNonAsciiIdentifier.format(uri, token.charOffset,
+      message = fasta.templateNonAsciiIdentifier.withArguments(
           new String.fromCharCodes([token.character]), token.character);
     } else if (code == fasta.codeUnterminatedString) {
-      message = fasta.codeUnterminatedString
-          .format(uri, token.charOffset, token.start);
+      message = fasta.templateUnterminatedString.withArguments(token.start);
     } else if (code == fasta.codeUnmatchedToken) {
       Token begin = token.begin;
-      message = fasta.codeUnmatchedToken
-          .format(uri, token.charOffset, closeBraceFor(begin.lexeme), begin);
+      message = fasta.templateUnmatchedToken
+          .withArguments(closeBraceFor(begin.lexeme), begin);
     } else if (code == fasta.codeUnspecified) {
-      message = fasta.codeUnspecified
-          .format(uri, token.charOffset, token.assertionMessage);
+      message = fasta.templateUnspecified.withArguments(token.assertionMessage);
     } else {
-      message = code.format(uri, token.charOffset);
+      message = code as Message;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, message);
       return null;
     } else {
       Token next = listener.handleUnrecoverableError(token, message);
       return next ?? skipToEof(token);
     }
   }
 
   Token reportUnmatchedToken(BeginToken token) {
     return reportUnrecoverableError(
         token,
-        () => fasta.codeUnmatchedToken
-            .format(uri, token.charOffset, closeBraceFor(token.lexeme), token));
+        fasta.templateUnmatchedToken
+            .withArguments(closeBraceFor(token.lexeme), token));
   }
 
   Token reportUnexpectedToken(Token token) {
-    return reportUnrecoverableError(token,
-        () => fasta.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));
+    return reportUnrecoverableErrorWithToken(
+        token, fasta.templateUnexpectedToken);
   }
 }
 
-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);
+// TODO(ahe): Remove when analyzer supports generalized function syntax.
+typedef _MessageWithArgument<T> = Message Function(T);