Implement generalized function types.

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,
@@ skipping 12 matching lines @@
         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,
+        codeTypeAfterVar,
+        codeTypeRequired,
         codeUnexpectedToken,
         codeUnmatchedToken,
         codeUnspecified,
         codeUnsupportedPrefixPlus,
         codeUnterminatedString,
         codeYieldAsIdentifier,
         codeYieldNotGenerator;
 
 import '../scanner.dart' show ErrorToken, Token;
 
@@ skipping 54 matching lines @@
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
   bool get isPositional => this == POSITIONAL;
   bool get isNamed => this == NAMED;
   static final REQUIRED = const FormalParameterType('required');
   static final POSITIONAL = const FormalParameterType('positional');
   static final NAMED = const FormalParameterType('named');
 }
 
+enum MemberKind {
+  /// A catch block, not a real member.
+  Catch,
+
+  /// A factory
+  Factory,
+
+  /// Old-style typedef.
+  FunctionTypeAlias,
+
+  /// Old-style function-typed parameter, not a real member.
+  FunctionTypedParameter,
+
+  /// A generalized function type, not a real member.
+  GeneralizedFunctionType,
+
+  /// A local function.
+  Local,
+
+  /// A non-static method in a class (including constructors).
+  NonStaticMethod,
+
+  /// A static method in a class.
+  StaticMethod,
+
+  /// A top-level method.
+  TopLevelMethod,
+
+  /// An instance field in a class.
+  NonStaticField,
+
+  /// A static field in a class.
+  StaticField,
+
+  /// A top-level field.
+  TopLevelField,
+}
+
 /// An event generating parser of Dart programs. This parser expects all tokens
 /// in a linked list (aka a token stream).
 ///
 /// The class [Scanner] is used to generate a token stream. See the file
 /// [scanner.dart](../scanner.dart).
 ///
 /// Subclasses of the class [Listener] are used to listen to events.
 ///
 /// Most methods of this class belong in one of three major categories: parse
 /// methods, peek methods, and skip methods. Parse methods all have the prefix
@@ skipping 157 matching lines @@
     if (identical(token.type, TokenType.SCRIPT_TAG)) {
       return parseScript(token);
     }
     token = parseMetadataStar(token);
     final String value = token.stringValue;
     if ((identical(value, 'abstract') && optional('class', token.next)) ||
         identical(value, 'class')) {
       return parseClassOrNamedMixinApplication(token);
     } else if (identical(value, 'enum')) {
       return parseEnum(token);
-    } else if (identical(value, 'typedef')) {
+    } else if (identical(value, 'typedef') &&
+        (token.next.isIdentifier || optional("void", token.next))) {
       return parseTypedef(token);
     } else if (identical(value, 'library')) {
       return parseLibraryName(token);
     } else if (identical(value, 'import')) {
       return parseImport(token);
     } else if (identical(value, 'export')) {
       return parseExport(token);
     } else if (identical(value, 'part')) {
       return parsePartOrPartOf(token);
     } else {
@@ skipping 243 matching lines @@
     if (optional('=', peekAfterNominalType(token.next))) {
       token = parseIdentifier(token.next, IdentifierContext.typedefDeclaration);
       token = parseTypeVariablesOpt(token);
       equals = token;
       token = expect('=', token);
       token = parseType(token);
     } else {
       token = parseReturnTypeOpt(token.next);
       token = parseIdentifier(token, IdentifierContext.typedefDeclaration);
       token = parseTypeVariablesOpt(token);
-      token = parseFormalParameters(token);
+      token = parseFormalParameters(token, MemberKind.FunctionTypeAlias);
     }
     listener.endFunctionTypeAlias(typedefKeyword, equals, token);
     return expect(';', token);
   }
 
   Token parseMixinApplication(Token token) {
     listener.beginMixinApplication(token);
     token = parseType(token);
     Token withKeyword = token;
     token = expect('with', token);
     token = parseTypeList(token);
     listener.endMixinApplication(withKeyword);
     return token;
   }
 
   Token parseReturnTypeOpt(Token token) {
     if (identical(token.stringValue, 'void')) {
       if (isGeneralizedFunctionType(token.next)) {
         return parseType(token);
       } else {
         listener.handleVoidKeyword(token);
         return token.next;
       }
     } else {
       return parseTypeOpt(token);
     }
   }
 
-  Token parseFormalParametersOpt(Token token) {
+  Token parseFormalParametersOpt(Token token, MemberKind kind) {
     if (optional('(', token)) {
-      return parseFormalParameters(token);
+      return parseFormalParameters(token, kind);
     } else {
-      listener.handleNoFormalParameters(token);
+      listener.handleNoFormalParameters(token, kind);
       return token;
     }
   }
 
-  Token skipFormalParameters(Token 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, codeExpectedOpenParens);
         return token;
       }
       return reportUnrecoverableErrorCodeWithString(
               token, codeExpectedButGot, "(")
           .next;
     }
     BeginGroupToken beginGroupToken = token;
     Token endToken = beginGroupToken.endGroup;
-    listener.endFormalParameters(0, token, endToken);
+    listener.endFormalParameters(0, token, endToken, kind);
     return endToken.next;
   }
 
   /// Parses the formal parameter list of a function.
   ///
-  /// If [inFunctionType] is true, then the names may be omitted (except for
-  /// named arguments). If it is false, then the types may be omitted.
-  Token parseFormalParameters(Token token, {bool inFunctionType: false}) {
+  /// If `kind == MemberKind.GeneralizedFunctionType`, then names may be
+  /// omitted (except for named arguments). Otherwise, types may be omitted.
+  Token parseFormalParameters(Token token, MemberKind kind) {
     Token begin = token;
-    listener.beginFormalParameters(begin);
+    listener.beginFormalParameters(begin, kind);
     expect('(', token);
     int parameterCount = 0;
     do {
       token = token.next;
       if (optional(')', token)) {
         break;
       }
       ++parameterCount;
       String value = token.stringValue;
       if (identical(value, '[')) {
-        token = parseOptionalFormalParameters(token, false,
-            inFunctionType: inFunctionType);
+        token = parseOptionalFormalParameters(token, false, kind);
         break;
       } else if (identical(value, '{')) {
-        token = parseOptionalFormalParameters(token, true,
-            inFunctionType: inFunctionType);
+        token = parseOptionalFormalParameters(token, true, kind);
         break;
       } else if (identical(value, '[]')) {
         --parameterCount;
         reportRecoverableErrorCode(token, codeEmptyOptionalParameterList);
         token = token.next;
         break;
       }
-      token = parseFormalParameter(token, FormalParameterType.REQUIRED,
-          inFunctionType: inFunctionType);
+      token = parseFormalParameter(token, FormalParameterType.REQUIRED, kind);
     } while (optional(',', token));
-    listener.endFormalParameters(parameterCount, begin, token);
+    listener.endFormalParameters(parameterCount, begin, token, kind);
     return expect(')', token);
   }
 
-  Token parseFormalParameter(Token token, FormalParameterType kind,
-      {bool inFunctionType: false}) {
+  Token parseFormalParameter(
+      Token token, FormalParameterType parameterKind, MemberKind memberKind) {
     token = parseMetadataStar(token, forParameter: true);
-    listener.beginFormalParameter(token);
+    listener.beginFormalParameter(token, memberKind);
 
-    // Skip over `covariant` token, if the next token is an identifier or
-    // modifier.
-    // This enables the case where `covariant` is the name of the parameter:
-    //    void foo(covariant);
-    Token covariantKeyword;
-    if (identical(token.stringValue, 'covariant') &&
-        (token.next.isIdentifier || isModifier(token.next))) {
-      covariantKeyword = token;
-      token = token.next;
-    }
-    token = parseModifiers(token);
-    bool isNamedParameter = kind == FormalParameterType.NAMED;
+    bool inFunctionType = memberKind == MemberKind.GeneralizedFunctionType;
+    token = parseModifiers(token, memberKind, parameterKind: parameterKind);
+    bool isNamedParameter = parameterKind == FormalParameterType.NAMED;
 
     Token thisKeyword = null;
     Token nameToken;
-    if (inFunctionType && isNamedParameter) {
-      token = parseType(token);
-      token =
-          parseIdentifier(token, IdentifierContext.formalParameterDeclaration);
-    } else if (inFunctionType) {
-      token = parseType(token);
-      if (token.isIdentifier) {
+    if (inFunctionType) {
+      if (isNamedParameter || token.isIdentifier) {
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       } else {
         listener.handleNoName(token);
       }
     } else {
-      token = parseReturnTypeOpt(token);
       if (optional('this', token)) {
         thisKeyword = token;
         token = expect('.', token.next);
         nameToken = token;
         token = parseIdentifier(token, IdentifierContext.fieldInitializer);
       } else {
         nameToken = token;
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       }
     }
 
     token = listener.injectGenericCommentTypeList(token);
     if (optional('(', token)) {
       Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
-      token = parseFormalParameters(token);
-      listener.endFunctionTypedFormalParameter(
-          covariantKeyword, thisKeyword, kind);
+      token = parseFormalParameters(token, MemberKind.FunctionTypedParameter);
+      listener.endFunctionTypedFormalParameter(thisKeyword, parameterKind);
       // Generalized function types don't allow inline function types.
       // The following isn't allowed:
       //    int Function(int bar(String x)).
-      if (inFunctionType) {
+      if (memberKind == MemberKind.GeneralizedFunctionType) {
         reportRecoverableErrorCode(
             inlineFunctionTypeStart, codeInvalidInlineFunctionType);
       }
     } else if (optional('<', token)) {
       Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
-      token = parseFormalParameters(token);
-      listener.endFunctionTypedFormalParameter(
-          covariantKeyword, thisKeyword, kind);
+      token = parseFormalParameters(token, MemberKind.FunctionTypedParameter);
+      listener.endFunctionTypedFormalParameter(thisKeyword, parameterKind);
       // Generalized function types don't allow inline function types.
       // The following isn't allowed:
       //    int Function(int bar(String x)).
-      if (inFunctionType) {
+      if (memberKind == MemberKind.GeneralizedFunctionType) {
         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) {
+      if (parameterKind.isRequired) {
         reportRecoverableErrorCode(equal, codeRequiredParameterWithDefault);
-      } else if (kind.isPositional && identical(':', value)) {
+      } else if (parameterKind.isPositional && identical(':', value)) {
         reportRecoverableErrorCode(equal, codePositionalParameterWithEquals);
       }
     } else {
       listener.handleFormalParameterWithoutValue(token);
     }
-    listener.endFormalParameter(covariantKeyword, thisKeyword, nameToken, kind);
+    listener.endFormalParameter(
+        thisKeyword, nameToken, parameterKind, memberKind);
     return token;
   }
 
-  Token parseOptionalFormalParameters(Token token, bool isNamed,
-      {bool inFunctionType: false}) {
+  Token parseOptionalFormalParameters(
+      Token token, bool isNamed, MemberKind kind) {
     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);
+      token = parseFormalParameter(token, type, kind);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
       reportRecoverableErrorCode(
           token,
           isNamed
               ? codeEmptyNamedParameterList
               : codeEmptyOptionalParameterList);
     }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
@@ skipping 12 matching lines @@
     token = listener.injectGenericCommentTypeAssign(token);
     Token peek = peekAfterIfType(token);
     if (peek != null && (peek.isIdentifier || optional('this', peek))) {
       return parseType(token);
     }
     listener.handleNoType(token);
     return token;
   }
 
   bool isValidTypeReference(Token token) {
-    final kind = token.kind;
-    if (identical(kind, IDENTIFIER_TOKEN)) return true;
-    if (identical(kind, KEYWORD_TOKEN)) {
+    int kind = token.kind;
+    if (IDENTIFIER_TOKEN == kind) return true;
+    if (KEYWORD_TOKEN == kind) {
       String value = token.type.lexeme;
       return token.type.isPseudo ||
           (identical(value, 'dynamic')) ||
           (identical(value, 'void'));
     }
     return false;
   }
 
   /// Returns true if [token] matches '<' type (',' type)* '>' '(', and
   /// otherwise returns false. The final '(' is not part of the grammar
@@ skipping 214 matching lines @@
     if (token.kind != STRING_TOKEN) {
       token =
           reportUnrecoverableErrorCodeWithToken(token, codeExpectedString).next;
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
   Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier) {
-      token =
-          reportUnrecoverableErrorCodeWithToken(token, codeExpectedIdentifier)
-              .next;
+      if (optional("void", token)) {
+        reportRecoverableErrorCode(token, codeInvalidVoid);
+      } else {
+        token =
+            reportUnrecoverableErrorCodeWithToken(token, codeExpectedIdentifier)
+                .next;
+      }
     } else if (token.type.isBuiltIn && !context.isBuiltInIdentifierAllowed) {
       if (context.inDeclaration) {
         reportRecoverableErrorCodeWithToken(
             token, codeBuiltInIdentifierInDeclaration);
       } else if (!optional("dynamic", token)) {
         reportRecoverableErrorCodeWithToken(token, codeBuiltInIdentifierAsType);
       }
     } else if (!inPlainSync && token.type.isPseudo) {
       if (optional('await', token)) {
         reportRecoverableErrorCode(token, codeAwaitAsIdentifier);
@@ skipping 61 matching lines @@
         (optional('<', token.next) || optional('(', token.next));
   }
 
   Token parseType(Token token) {
     Token begin = token;
     if (isGeneralizedFunctionType(token)) {
       // A function type without return type.
       // Push the non-existing return type first. The loop below will
       // generate the full type.
       listener.handleNoType(token);
-    } else if (identical(token.stringValue, 'void') &&
+    } else if (optional("void", token) &&
         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 =
-            reportUnrecoverableErrorCodeWithToken(token, codeExpectedType).next;
-        listener.handleInvalidTypeReference(token);
+      IdentifierContext context = IdentifierContext.typeReference;
+      if (token.isIdentifier && optional(".", token.next)) {
+        context = IdentifierContext.prefixedTypeReference;
       }
+      token = parseIdentifier(token, context);
+      token = parseQualifiedRestOpt(
+          token, IdentifierContext.typeReferenceContinuation);
       token = parseTypeArgumentsOpt(token);
       listener.handleType(begin, token);
     }
 
     {
       Token newBegin =
           listener.replaceTokenWithGenericCommentTypeAssign(begin, token);
       if (!identical(newBegin, begin)) {
         listener.discardTypeReplacedWithCommentTypeAssign();
         return parseType(newBegin);
       }
     }
 
     // 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);
     }
     return token;
   }
 
   /// Parses a generalized function type.
   ///
   /// The return type must already be pushed.
   Token parseFunctionType(Token token) {
     assert(optional('Function', token));
     Token functionToken = token;
     token = token.next;
     token = parseTypeVariablesOpt(token);
-    token = parseFormalParameters(token, inFunctionType: true);
+    token = parseFormalParameters(token, MemberKind.GeneralizedFunctionType);
     listener.handleFunctionType(functionToken, token);
     return token;
   }
 
   Token parseTypeArgumentsOpt(Token token) {
     return parseStuff(
         token,
         (t) => listener.beginTypeArguments(t),
         (t) => parseType(t),
         (c, bt, et) => listener.endTypeArguments(c, bt, et),
@@ skipping 98 matching lines @@
         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) {
-    String value = token.stringValue;
-    return identical('var', value) ||
-        identical('final', value) ||
-        identical('const', value);
-  }
-
-  Token expectVarFinalOrConst(
-      Link<Token> modifiers, bool hasType, bool allowStatic) {
-    int modifierCount = 0;
-    Token staticModifier;
-    if (allowStatic &&
-        !modifiers.isEmpty &&
-        optional('static', modifiers.head)) {
-      staticModifier = modifiers.head;
-      modifierCount++;
-      parseModifier(staticModifier);
-      modifiers = modifiers.tail;
-    }
-    if (modifiers.isEmpty) {
-      listener.handleModifiers(modifierCount);
-      return null;
-    }
-    if (modifiers.tail.isEmpty) {
-      Token modifier = modifiers.head;
-      if (isVarFinalOrConst(modifier)) {
-        modifierCount++;
-        parseModifier(modifier);
-        listener.handleModifiers(modifierCount);
-        // TODO(ahe): The caller checks for "var Type name", perhaps we should
-        // check here instead.
-        return modifier;
-      }
-    }
-
-    // Slow case to report errors.
-    List<Token> modifierList = modifiers.toList();
-    Token varFinalOrConst =
-        modifierList.firstWhere(isVarFinalOrConst, orElse: () => null);
-    if (allowStatic && staticModifier == null) {
-      staticModifier = modifierList.firstWhere(
-          (modifier) => optional('static', modifier),
-          orElse: () => null);
-      if (staticModifier != null) {
-        modifierCount++;
-        parseModifier(staticModifier);
-        modifierList.remove(staticModifier);
-      }
-    }
-    bool hasTypeOrModifier = hasType;
-    if (varFinalOrConst != null) {
-      parseModifier(varFinalOrConst);
-      modifierCount++;
-      hasTypeOrModifier = true;
-      modifierList.remove(varFinalOrConst);
-    }
-    listener.handleModifiers(modifierCount);
-    for (Token modifier in modifierList) {
-      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;
-    }
-    for (Token modifier in modifiers.tail) {
-      if (identical(modifier.stringValue, 'static')) {
-        return modifiers;
-      }
-    }
-    return modifiers.tail;
-  }
-
   Token parseFields(Token start, Link<Token> modifiers, Token type,
       Token getOrSet, Token name, bool isTopLevel) {
-    bool hasType = type != null;
+    Token token = parseModifiers(start,
+        isTopLevel ? MemberKind.TopLevelField : MemberKind.NonStaticField,
+        isVariable: true);
 
-    Token covariantKeyword;
-    if (getOrSet == null && !isTopLevel) {
-      // TODO(ahe): replace the method removeOptCovariantTokenIfNotStatic with
-      // a better mechanism.
-      Link<Token> newModifiers = removeOptCovariantTokenIfNotStatic(modifiers);
-      if (!identical(newModifiers, modifiers)) {
-        covariantKeyword = modifiers.first;
-        modifiers = newModifiers;
-      }
-    }
-
-    Token varFinalOrConst =
-        expectVarFinalOrConst(modifiers, hasType, !isTopLevel);
-    bool isVar = false;
-    bool hasModifier = false;
-    if (varFinalOrConst != null) {
-      hasModifier = true;
-      isVar = optional('var', varFinalOrConst);
-    }
-
-    if (getOrSet != null) {
-      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].
-      reportRecoverableErrorCode(type, codeInvalidVoid);
-    } else {
-      parseType(type);
-      if (isVar) {
-        reportRecoverableErrorCodeWithToken(
-            modifiers.head, codeExtraneousModifier);
-      }
+    if (token != name) {
+      reportRecoverableErrorCodeWithToken(token, codeExtraneousModifier);
+      token = name;
     }
 
     IdentifierContext context = isTopLevel
         ? IdentifierContext.topLevelVariableDeclaration
         : IdentifierContext.fieldDeclaration;
-    Token token = parseIdentifier(name, context);
+    token = parseIdentifier(token, context);
 
     int fieldCount = 1;
     token = parseFieldInitializerOpt(token);
     while (optional(',', token)) {
       token = parseIdentifier(token.next, context);
       token = parseFieldInitializerOpt(token);
       ++fieldCount;
     }
     Token semicolon = token;
     token = expectSemicolon(token);
     if (isTopLevel) {
       listener.endTopLevelFields(fieldCount, start, semicolon);
     } else {
-      listener.endFields(fieldCount, covariantKeyword, start, semicolon);
+      listener.endFields(fieldCount, start, semicolon);
     }
     return token;
   }
 
   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.
@@ skipping 17 matching lines @@
       parseReturnTypeOpt(type);
     }
     Token token =
         parseIdentifier(name, IdentifierContext.topLevelFunctionDeclaration);
 
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
-    token = parseFormalParametersOpt(token);
+    token = parseFormalParametersOpt(token, MemberKind.TopLevelMethod);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
       reportRecoverableErrorCode(asyncToken, codeSetterNotSync);
     }
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncState = savedAsyncModifier;
     Token endToken = token;
     token = token.next;
@@ skipping 197 matching lines @@
     } else {
       reportRecoverableErrorCodeWithToken(token, codeExpectedString);
       return parseRecoverExpression(token);
     }
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
-  bool isModifier(Token token) {
+  bool isModifier(Token token) => modifierOrder(token) < 127;
+
+  /// Provides a partial order on modifiers.
+  ///
+  /// The order is based on the order modifiers must appear in according to the
+  /// grammar. For example, `external` must come before `static`.
+  ///
+  /// In addition, if two modifiers have the same order, they can't both be
+  /// used together, for example, `final` and `var` can't be used together.
+  ///
+  /// If [token] isn't a modifier, 127 is returned.
+  int modifierOrder(Token token) {
     final String value = token.stringValue;
-    return (identical('final', value)) ||
-        (identical('var', value)) ||
-        (identical('const', value)) ||
-        (identical('abstract', value)) ||
-        (identical('static', value)) ||
-        (identical('external', value));
+    if (identical('external', value)) return 0;
+    if (identical('static', value) || identical('covariant', value)) {
+      return 1;
+    }
+    if (identical('final', value) ||
+        identical('var', value) ||
+        identical('const', value)) {
+      return 2;
+    }
+    if (identical('abstract', value)) return 3;
+    return 127;
   }
 
   Token parseModifier(Token token) {
     assert(isModifier(token));
     listener.handleModifier(token);
     return token.next;
   }
 
-  void parseModifierList(Link<Token> tokens) {
+  /// This method is used in most locations where modifiers can occur. However,
+  /// it isn't used when parsing a class or when parsing the modifiers of a
+  /// member function (non-local), but is used when parsing their formal
+  /// parameters.
+  ///
+  /// When parsing the formal parameters of any function, [parameterKind] is
+  /// non-null.
+  Token parseModifiers(Token token, MemberKind memberKind,
+      {FormalParameterType parameterKind, bool isVariable: false}) {
+    bool returnTypeAllowed =
+        !isVariable && memberKind != MemberKind.GeneralizedFunctionType;
+    bool typeRequired =
+        isVariable || memberKind == MemberKind.GeneralizedFunctionType;
     int count = 0;
-    for (; !tokens.isEmpty; tokens = tokens.tail) {
-      Token token = tokens.head;
-      if (isModifier(token)) {
-        parseModifier(token);
-      } else {
-        reportUnexpectedToken(token);
-        // Skip the remaining modifiers.
+
+    int currentOrder = -1;
+    bool hasVar = false;
+    while (token.kind == KEYWORD_TOKEN) {
+      if (token.type.isPseudo) {
+        // A pseudo keyword is never a modifier.
         break;
       }
-      count++;
+      if (token.type.isBuiltIn) {
+        // A built-in identifier can only be a modifier as long as it is
+        // followed by another modifier or an identifier. Otherwise, it is the
+        // identifier.
+        if (token.next.kind != KEYWORD_TOKEN && !token.next.isIdentifier) {
+          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 (!isVariable && parameterKind == null) {
+              reportRecoverableErrorCodeWithToken(
+                  token, codeExtraneousModifier);
+            }
+            hasVar = true;
+            typeRequired = false;
+          } else if (optional("final", token)) {
+            if (!isVariable && parameterKind == null) {
+              reportRecoverableErrorCodeWithToken(
+                  token, codeExtraneousModifier);
+            }
+            typeRequired = false;
+          } else if (optional("const", token)) {
+            if (!isVariable) {
+              reportRecoverableErrorCodeWithToken(
+                  token, codeExtraneousModifier);
+            }
+            typeRequired = false;
+          } else if (optional("static", token)) {
+            if (memberKind == MemberKind.NonStaticMethod) {
+              memberKind = MemberKind.StaticMethod;
+            } else if (memberKind == MemberKind.NonStaticField) {
+              memberKind = MemberKind.StaticField;
+            } else {
+              reportRecoverableErrorCodeWithToken(
+                  token, codeExtraneousModifier);
+              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, codeExtraneousModifier);
+                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, codeExtraneousModifier);
+                token = token.next;
+                continue;
+            }
+          }
+          token = parseModifier(token);
+          count++;
+        } else {
+          reportRecoverableErrorCodeWithToken(token, codeExtraneousModifier);
+          token = token.next;
+        }
+      } else {
+        break;
+      }
     }
     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
-    // `codeBuiltInIdentifierAsType` by [parseIdentifier]).
-    int count = 0;
-    while (identical(token.kind, KEYWORD_TOKEN)) {
-      if (!isModifier(token)) break;
-      token = parseModifier(token);
-      count++;
+    Token beforeType = token;
+    if (returnTypeAllowed) {
+      token = parseReturnTypeOpt(token);
+    } else {
+      token = typeRequired ? parseType(token) : parseTypeOpt(token);
     }
-    listener.handleModifiers(count);
+    if (typeRequired && beforeType == token) {
+      reportRecoverableErrorCode(token, codeTypeRequired);
+    }
+    if (hasVar && beforeType != token) {
+      reportRecoverableErrorCode(beforeType, codeTypeAfterVar);
+    }
     return token;
   }
 
   /// Returns the first token after the type starting at [token].
   ///
   /// This method assumes that [token] is an identifier (or void).  Use
   /// [peekAfterIfType] if [token] isn't known to be an identifier.
   Token peekAfterType(Token token) {
     // We are looking at "identifier ...".
     Token peek = token;
@@ skipping 202 matching lines @@
           isField = true;
         }
         break;
       } else if ((identical(value, '=')) || (identical(value, ','))) {
         isField = true;
         break;
       } else {
         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.endFields(1, start, token);
           listener.endMember();
           return token;
         }
       }
     }
 
     var modifiers = identifiers.reverse();
     token = isField
         ? parseFields(start, modifiers, type, getOrSet, name, false)
         : parseMethod(start, modifiers, type, getOrSet, name);
     listener.endMember();
     return token;
   }
 
   Token parseMethod(Token start, Link<Token> modifiers, Token type,
       Token getOrSet, Token name) {
     listener.beginMethod(start, name);
+
     Token externalModifier;
     Token staticModifier;
-    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) {
-          reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
+    // 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, codeExtraneousModifier);
+          continue;
         }
-        allowedModifierCount++;
-      } else if (staticModifier == null && optional('static', modifier)) {
-        modifierCount++;
-        staticModifier = modifier;
-        if (modifierCount != allowedModifierCount) {
-          reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
+        int order = modifierOrder(token);
+        if (order < 127) {
+          if (order > currentOrder) {
+            currentOrder = order;
+            if (optional("var", token)) {
+              reportRecoverableErrorCodeWithToken(
+                  token, codeExtraneousModifier);
+            } else if (optional("const", token)) {
+              if (getOrSet != null) {
+                reportRecoverableErrorCodeWithToken(
+                    token, codeExtraneousModifier);
+                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, codeExtraneousModifier);
+                continue;
+              }
+            }
+          } else {
+            reportRecoverableErrorCodeWithToken(token, codeExtraneousModifier);
+            continue;
+          }
+        } else {
+          reportUnexpectedToken(token);
+          break; // Skip the remaining modifiers.
         }
-      } else if (constModifier == null && optional('const', modifier)) {
-        modifierCount++;
-        constModifier = modifier;
-        if (modifierCount != allowedModifierCount) {
-          reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
-        }
-      } else {
-        reportRecoverableErrorCodeWithToken(modifier, codeExtraneousModifier);
+        parseModifier(token);
+        count++;
       }
+      listener.handleModifiers(count);
     }
-    if (getOrSet != null && constModifier != null) {
-      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) {
         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 = 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, codeSetterNotSync);
     }
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
@@ skipping 15 matching lines @@
         isExternal = true;
       }
       token = parseModifier(token);
       modifierCount++;
     }
     listener.handleModifiers(modifierCount);
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = expect('factory', token);
     token = parseConstructorReference(token);
-    token = parseFormalParameters(token);
+    token = parseFormalParameters(token, MemberKind.Factory);
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (!inPlainSync) {
       reportRecoverableErrorCode(asyncToken, codeFactoryNotSync);
     }
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false, isExternal);
     }
     listener.endFactoryMethod(start, factoryKeyword, token);
     return token.next;
   }
 
   Token parseOperatorName(Token token) {
     assert(optional('operator', token));
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
       listener.handleOperatorName(operator, token);
       return token.next;
     } else {
       return parseIdentifier(token, IdentifierContext.operatorName);
     }
   }
 
-  Token parseFunction(Token token, Token getOrSet) {
+  Token parseFunction(Token token) {
     Token beginToken = token;
     listener.beginFunction(token);
-    token = parseModifiers(token);
-    if (identical(getOrSet, token)) {
-      // get <name>  => ...
-      token = token.next;
-      listener.handleNoType(token);
-      listener.beginFunctionName(token);
-      if (optional('operator', token)) {
-        token = parseOperatorName(token);
-      } else {
-        token =
-            parseIdentifier(token, IdentifierContext.localAccessorDeclaration);
-      }
-    } else if (optional('operator', token)) {
-      // operator <op> (...
-      listener.handleNoType(token);
-      listener.beginFunctionName(token);
-      token = parseOperatorName(token);
-    } else {
-      // <type>? <get>? <name>
-      token = parseReturnTypeOpt(token);
-      if (identical(getOrSet, token)) {
-        token = token.next;
-      }
-      listener.beginFunctionName(token);
-      if (optional('operator', token)) {
-        token = parseOperatorName(token);
-      } else {
-        token =
-            parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
-      }
-    }
+    token = parseModifiers(token, MemberKind.Local);
+    listener.beginFunctionName(token);
+    token = parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
     token = parseQualifiedRestOpt(
         token, IdentifierContext.localFunctionDeclarationContinuation);
     listener.endFunctionName(beginToken, token);
-    if (getOrSet == null) {
-      token = parseTypeVariablesOpt(token);
-    } else {
-      listener.handleNoTypeVariables(token);
-    }
-    token = parseFormalParametersOpt(token);
+    token = parseTypeVariablesOpt(token);
+    token = parseFormalParametersOpt(token, MemberKind.Local);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, true);
     asyncState = savedAsyncModifier;
-    listener.endFunction(getOrSet, token);
+    listener.endFunction(null, token);
     return token.next;
   }
 
   Token parseUnnamedFunction(Token token) {
     Token beginToken = token;
     listener.beginUnnamedFunction(token);
-    token = parseFormalParameters(token);
+    token = parseFormalParameters(token, MemberKind.Local);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncState = savedAsyncModifier;
     listener.endUnnamedFunction(beginToken, token);
     return isBlock ? token.next : token;
   }
 
   Token parseFunctionDeclaration(Token token) {
     listener.beginFunctionDeclaration(token);
-    token = parseFunction(token, null);
+    token = parseFunction(token);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginFunction(token);
     listener.handleModifiers(0);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token, IdentifierContext.functionExpressionName);
     listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
-    token = parseFormalParameters(token);
+    token = parseFormalParameters(token, MemberKind.Local);
     listener.handleNoInitializers();
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncState = savedAsyncModifier;
     listener.endFunction(null, token);
     return isBlock ? token.next : token;
   }
 
@@ skipping 1219 matching lines @@
     return parseVariablesDeclarationMaybeSemicolon(token, false);
   }
 
   Token parseVariablesDeclarationMaybeSemicolon(
       Token token, bool endWithSemicolon) {
     int count = 1;
     token = parseMetadataStar(token);
 
     // If the next token has a type substitution comment /*=T*/, then
     // the current 'var' token should be repealed and replaced.
-    if (identical('var', token.stringValue)) {
+    if (optional('var', token)) {
       token =
           listener.replaceTokenWithGenericCommentTypeAssign(token, token.next);
     }
 
-    token = parseModifiers(token);
-    token = parseTypeOpt(token);
+    token = parseModifiers(token, MemberKind.Local, isVariable: true);
     listener.beginVariablesDeclaration(token);
     token = parseOptionallyInitializedIdentifier(token);
     while (optional(',', token)) {
       token = parseOptionallyInitializedIdentifier(token.next);
       ++count;
     }
     if (endWithSemicolon) {
       Token semicolon = token;
       token = expectSemicolon(semicolon);
       listener.endVariablesDeclaration(count, semicolon);
@@ skipping 201 matching lines @@
       if (identical(value, 'on')) {
         // on qualified catchPart?
         onKeyword = token;
         token = parseType(token.next);
         value = token.stringValue;
       }
       Token catchKeyword = null;
       if (identical(value, 'catch')) {
         catchKeyword = token;
         // TODO(ahe): Validate the "parameters".
-        token = parseFormalParameters(token.next);
+        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)) {
@@ skipping 255 matching lines @@
     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);