Tests for `void`.

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

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.parser.parser;
 
 import '../scanner.dart' show
     ErrorToken;
 
 import '../scanner/recover.dart' show
@@ skipping 82 matching lines @@
 /**
  * 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.
  *
  * Subclasses of the class [Listener] are used to listen to events.
  *
  * Most methods of this class belong in one of two major categories:
- * parse metods and peek methods. Parse methods all have the prefix
+ * parse methods and peek methods. Parse methods all have the prefix
  * parse, and peek methods all have the prefix peek.
  *
  * Parse methods generate events (by calling methods on [listener])
  * and return the next token to parse. Peek methods do not generate
  * events (except for errors) and may return null.
  *
  * Parse methods are generally named parseGrammarProductionSuffix. The
  * suffix can be one of "opt", or "star". "opt" means zero or one
  * matches, "star" means zero or more matches. For example,
  * [parseMetadataStar] corresponds to this grammar snippet: [:
@@ skipping 264 matching lines @@
       token = parseIdentifier(token.next);
     }
     token = parseArgumentsOpt(token);
     listener.endMetadata(atToken, period, token);
     return token;
   }
 
   Token parseTypedef(Token token) {
     Token typedefKeyword = token;
     listener.beginFunctionTypeAlias(token);
-    token = parseReturnTypeOpt(token.next);
-    token = parseIdentifier(token);
-    token = parseTypeVariablesOpt(token);
-    token = parseFormalParameters(token);
-    listener.endFunctionTypeAlias(typedefKeyword, token);
+    Token equals;
+    if (optional('=', peekAfterNominalType(token.next))) {
+      token = parseIdentifier(token.next);
+      token = parseTypeVariablesOpt(token);
+      equals = token;
+      token = expect('=', token);
+      token = parseType(token);
+    } else {
+      token = parseTypeOpt(token.next);
+      token = parseIdentifier(token);
+      token = parseTypeVariablesOpt(token);
+      token = parseFormalParameters(token);
+    }
+    listener.endFunctionTypeAlias(typedefKeyword, equals, token);
     return expect(';', token);
   }
 
   Token parseMixinApplication(Token token) {
     listener.beginMixinApplication(token);
     token = parseType(token);
     token = expect('with', token);
     token = parseTypeList(token);
     listener.endMixinApplication();
     return token;
   }
 
-  Token parseReturnTypeOpt(Token token) {
-    if (identical(token.stringValue, 'void')) {
-      listener.handleVoidKeyword(token);
-      return token.next;
-    } else {
-      return parseTypeOpt(token);
-    }
-  }
-
   Token parseFormalParametersOpt(Token token) {
     if (optional('(', token)) {
       return parseFormalParameters(token);
     } else {
       listener.handleNoFormalParameters(token);
       return token;
     }
   }
 
   Token skipFormalParameters(Token token) {
     // TODO(ahe): Shouldn't this be `beginFormalParameters`?
     listener.beginOptionalFormalParameters(token);
     if (!optional('(', token)) {
       if (optional(';', token)) {
         reportRecoverableError(token, ErrorKind.ExpectedOpenParens);
         return token;
       }
       return reportUnrecoverableError(
           token, ErrorKind.ExpectedButGot, {"expected": "("});
     }
     BeginGroupToken beginGroupToken = token;
     Token endToken = beginGroupToken.endGroup;
     listener.endFormalParameters(0, token, endToken);
     return endToken.next;
   }
 
-  Token parseFormalParameters(Token token) {
+  /// 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}) {
     Token begin = token;
     listener.beginFormalParameters(begin);
     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);
+        token = parseOptionalFormalParameters(
+            token, false, inFunctionType: inFunctionType);
         break;
       } else if (identical(value, '{')) {
-        token = parseOptionalFormalParameters(token, true);
+        token = parseOptionalFormalParameters(
+            token, true, inFunctionType: inFunctionType);
         break;
       }
-      token = parseFormalParameter(token, FormalParameterType.REQUIRED);
+      token = parseFormalParameter(token, FormalParameterType.REQUIRED,
+          inFunctionType: inFunctionType);
     } while (optional(',', token));
     listener.endFormalParameters(parameterCount, begin, token);
     return expect(')', token);
   }
 
-  Token parseFormalParameter(Token token, FormalParameterType type) {
+  Token parseFormalParameter(Token token, FormalParameterType type,
+      {bool inFunctionType}) {
     token = parseMetadataStar(token, forParameter: true);
     listener.beginFormalParameter(token);
 
     // 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);
     if (identical(token.stringValue, 'covariant') &&
         (token.next.isIdentifier() || isModifier(token.next))) {
       token = token.next;
     }
     token = parseModifiers(token);
-    // TODO(ahe): Validate that there are formal parameters if void.
-    token = parseReturnTypeOpt(token);
+    bool isNamedParameter = type == FormalParameterType.NAMED;
+
     Token thisKeyword = null;
-    if (optional('this', token)) {
-      thisKeyword = token;
-      // TODO(ahe): Validate field initializers are only used in
-      // constructors, and not for function-typed arguments.
-      token = expect('.', token.next);
+    if (inFunctionType && isNamedParameter) {
+      token = parseType(token);
+      token = parseIdentifier(token);
+    } else if (inFunctionType) {
+      token = parseType(token);
+      if (token.isIdentifier()) {
+        token = parseIdentifier(token);
+      } else {
+        listener.handleNoName(token);
+      }
+    } else {
+      token = parseTypeOpt(token);
+      if (optional('this', token)) {
+        thisKeyword = token;
+        token = expect('.', token.next);
+      }
+      token = parseIdentifier(token);
     }
-    token = parseIdentifier(token);
+
+    // Generalized function types don't allow inline function types.
+    // The following isn't allowed:
+    //    int Function(int bar(String x)).
     if (optional('(', token)) {
+      Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
+      if (inFunctionType) {
+        reportRecoverableError(
+            inlineFunctionTypeStart, ErrorKind.InvalidInlineFunctionType);
+      }
     } else if (optional('<', token)) {
+      Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
+      if (inFunctionType) {
+        reportRecoverableError(
+            inlineFunctionTypeStart, ErrorKind.InvalidInlineFunctionType);
+      }
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
         reportRecoverableError(
             equal, ErrorKind.RequiredParameterWithDefault);
       } else if (type.isPositional && identical(':', value)) {
         reportRecoverableError(
             equal, ErrorKind.PositionalParameterWithEquals);
       }
     }
     listener.endFormalParameter(thisKeyword);
     return token;
   }
 
-  Token parseOptionalFormalParameters(Token token, bool isNamed) {
+  Token parseOptionalFormalParameters(Token token, bool isNamed,
+      {bool inFunctionType}) {
     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);
+      token =
+          parseFormalParameter(token, type, inFunctionType: inFunctionType);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
       reportRecoverableError(
           token,
           isNamed
               ? ErrorKind.EmptyNamedParameterList
               : ErrorKind.EmptyOptionalParameterList);
     }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
+    if (isGeneralizedFunctionType(token)) {
+      // Function type without return type.
+      return parseType(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;
@@ skipping 146 matching lines @@
   }
 
   Token parseClassOrNamedMixinApplication(Token token) {
     Token begin = token;
     Token abstractKeyword;
     if (optional('abstract', token)) {
       abstractKeyword = token;
       token = token.next;
     }
     Token classKeyword = token;
-    var isMixinApplication = optional('=', peekAfterType(token.next));
+    var isMixinApplication = optional('=', peekAfterNominalType(token.next));
     if (isMixinApplication) {
       listener.beginNamedMixinApplication(begin);
     } else {
       listener.beginClassDeclaration(begin);
     }
 
     int modifierCount = 0;
     if (abstractKeyword != null) {
       parseModifier(abstractKeyword);
       modifierCount++;
@@ skipping 20 matching lines @@
     listener.endNamedMixinApplication(classKeyword, implementsKeyword, token);
     return expect(';', token);
   }
 
   Token parseClass(Token begin, Token classKeyword) {
     Token token = parseIdentifier(classKeyword.next);
     token = parseTypeVariablesOpt(token);
     Token extendsKeyword;
     if (optional('extends', token)) {
       extendsKeyword = token;
-      if (optional('with', peekAfterType(token.next))) {
+      if (optional('with', peekAfterNominalType(token.next))) {
         token = parseMixinApplication(token.next);
       } else {
         token = parseType(token.next);
       }
     } else {
       extendsKeyword = null;
       listener.handleNoType(token);
     }
     Token implementsKeyword;
     int interfacesCount = 0;
@@ skipping 70 matching lines @@
         value2 == stringValue ||
         value3 == stringValue ||
         value4 == stringValue;
   }
 
   bool notEofOrValue(String value, Token token) {
     return !identical(token.kind, EOF_TOKEN) &&
         !identical(value, token.stringValue);
   }
 
+  bool isGeneralizedFunctionType(Token token) {
+    return optional('Function', token) &&
+        (optional('<', token.next) || optional('(', token.next));
+  }
+
   Token parseType(Token token) {
     Token begin = token;
-    if (isValidTypeReference(token)) {
-      token = parseIdentifier(token);
-      token = parseQualifiedRestOpt(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 {
-      token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
-      listener.handleInvalidTypeReference(token);
+      if (isValidTypeReference(token)) {
+        token = parseIdentifier(token);
+        token = parseQualifiedRestOpt(token);
+      } else {
+        token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
+        listener.handleInvalidTypeReference(token);
+      }
+      token = parseTypeArgumentsOpt(token);
+      listener.handleType(begin, token);
     }
-    token = parseTypeArgumentsOpt(token);
-    listener.endType(begin, token);
+
+    // While we see a `Function(` treat the pushed type as return type.
+    // For example: `int Function() Function(int) Function(String x)`.
+    while (isGeneralizedFunctionType(token)) {
+      token = parseFunctionType(token);
+    }
     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);
+    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),
         (t) => listener.handleNoTypeArguments(t));
   }
 
   Token parseTypeVariablesOpt(Token token) {
@@ skipping 196 matching lines @@
 
     if (getOrSet != null) {
       var kind = (hasModifier || hasType)
           ? ErrorKind.ExtraneousModifier
           : ErrorKind.ExtraneousModifierReplace;
       reportRecoverableError(getOrSet, kind, {'modifier': getOrSet});
     }
 
     if (!hasType) {
       listener.handleNoType(name);
-    } else if (optional('void', type)) {
-      listener.handleNoType(name);
-      // TODO(ahe): This error is reported twice, second time is from
-      // [parseVariablesDeclarationMaybeSemicolon] via
-      // [PartialFieldListElement.parseNode].
-      reportRecoverableError(type, ErrorKind.InvalidVoid);
     } else {
       parseType(type);
       if (isVar) {
         reportRecoverableError(modifiers.head, ErrorKind.ExtraneousModifier,
             {'modifier': modifiers.head});
       }
     }
 
     Token token = parseIdentifier(name);
 
@@ skipping 30 matching lines @@
     if (externalModifier != null) {
       parseModifier(externalModifier);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
-      parseReturnTypeOpt(type);
+      parseTypeOpt(type);
     }
     Token token = parseIdentifier(name);
 
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
@@ skipping 58 matching lines @@
         return listener.handleMemberName(identifiers);
       } else if (optional("=", token) || optional(";", token) ||
                  optional(",", token)) {
         // A field or abstract getter.
         identifiers = identifiers.prepend(token);
         return listener.handleMemberName(identifiers);
       } else if (isGetter) {
         hasName = true;
       }
       identifiers = identifiers.prepend(token);
-      if (isValidTypeReference(token)) {
-        // type ...
-        if (optional('.', token.next)) {
-          // type '.' ...
-          if (token.next.next.isIdentifier()) {
-            // type '.' identifier
-            token = token.next.next;
+
+      if (!isGeneralizedFunctionType(token)) {
+        // Read a potential return type.
+        if (isValidTypeReference(token)) {
+          // type ...
+          if (optional('.', token.next)) {
+            // type '.' ...
+            if (token.next.next.isIdentifier()) {
+              // type '.' identifier
+              token = token.next.next;
+            }
+          }
+          if (optional('<', token.next)) {
+            if (token.next is BeginGroupToken) {
+              BeginGroupToken beginGroup = token.next;
+              if (beginGroup.endGroup == null) {
+                reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
+              } else {
+                token = beginGroup.endGroup;
+              }
+            }
           }
         }
-        if (optional('<', token.next)) {
-          if (token.next is BeginGroupToken) {
-            BeginGroupToken beginGroup = token.next;
+        token = token.next;
+      }
+      while (isGeneralizedFunctionType(token)) {
+        token = token.next;
+        if (optional('<', token)) {
+          if (token is BeginGroupToken) {
+            BeginGroupToken beginGroup = token;
             if (beginGroup.endGroup == null) {
               reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
             } else {
-              token = beginGroup.endGroup;
+              token = beginGroup.endGroup.next;
             }
           }
         }
+        if (!optional('(', token)) {
+          if (optional(';', token)) {
+            reportRecoverableError(token, ErrorKind.ExpectedOpenParens);
+          }
+          token = expect("(", token);
+        }
+        if (token is BeginGroupToken) {
+          BeginGroupToken beginGroup = token;
+          if (beginGroup.endGroup == null) {
+            reportUnrecoverableError(beginGroup, ErrorKind.UnmatchedToken);
+          } else {
+            token = beginGroup.endGroup.next;
+          }
+        }
       }
-      token = token.next;
     }
     return listener.handleMemberName(const Link<Token>());
   }
 
   Token parseFieldInitializerOpt(Token token) {
     if (optional('=', token)) {
       Token assignment = token;
       listener.beginFieldInitializer(token);
       token = parseExpression(token.next);
       listener.endFieldInitializer(assignment);
@@ skipping 92 matching lines @@
       if (!isModifier(token)) break;
       token = parseModifier(token);
       count++;
     }
     listener.handleModifiers(count);
     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;
+    if (!isGeneralizedFunctionType(token)) {
+      peek = peekAfterNominalType(token);
+    }
+
+    // We might have just skipped over the return value of the function type.
+    // Check again, if we are now at a function type position.
+    while (isGeneralizedFunctionType(peek)) {
+      peek = peekAfterFunctionType(peek.next);
+    }
+    return peek;
+  }
+
+  /**
+   * Returns the first token after the nominal type starting at [token].
+   *
+   * This method assumes that [token] is an identifier (or void).
+   */
+  Token peekAfterNominalType(Token token) {
     Token peek = token.next;
     if (identical(peek.kind, PERIOD_TOKEN)) {
       if (peek.next.isIdentifier()) {
         // Look past a library prefix.
         peek = peek.next.next;
       }
     }
     // We are looking at "qualified ...".
     if (identical(peek.kind, LT_TOKEN)) {
       // Possibly generic type.
       // We are looking at "qualified '<'".
       BeginGroupToken beginGroupToken = peek;
       Token gtToken = beginGroupToken.endGroup;
       if (gtToken != null) {
         // We are looking at "qualified '<' ... '>' ...".
-        return gtToken.next;
+        peek = gtToken.next;
       }
     }
     return peek;
   }
 
   /**
+   * Returns the first token after the function type starting at [token].
+   *
+   * The token must be at the token *after* the `Function` token position. That
+   * is, the return type and the `Function` token must have already been
+   * skipped.
+   *
+   * This function only skips over one function type syntax.
+   * If necessary, this function must be called multiple times.
+   *
+   * Example:
+   * ```
+   * int Function() Function<T>(int)
+   *             ^          ^
+   * A call to this function must be either at `(` or at `<`.
+   * If `token` pointed to the first `(`, then the returned
+   * token points to the second `Function` token.
+   */
+  Token peekAfterFunctionType(Token token) {
+    // Possible inputs are:
+    //    ( ... )
+    //    < ... >( ... )
+
+    Token peek = token;
+    // If there is a generic argument to the function, skip over that one first.
+    if (identical(peek.kind, LT_TOKEN)) {
+      BeginGroupToken beginGroupToken = peek;
+      Token closeToken = beginGroupToken.endGroup;
+      if (closeToken != null) {
+        peek = closeToken.next;
+      }
+    }
+
+    // Now we just need to skip over the formals.
+    expect('(', peek);
+
+    BeginGroupToken beginGroupToken = peek;
+    Token closeToken = beginGroupToken.endGroup;
+    if (closeToken != null) {
+      peek = closeToken.next;
+    }
+
+    return peek;
+  }
+
+  /**
    * If [token] is the start of a type, returns the token after that type.
    * If [token] is not the start of a type, null is returned.
    */
   Token peekAfterIfType(Token token) {
-    if (!optional('void', token) && !token.isIdentifier()) {
+    if (!token.isIdentifier()) {
       return null;
     }
     return peekAfterType(token);
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableError(token, ErrorKind.ExpectedClassBodyToSkip);
     }
     BeginGroupToken beginGroupToken = token;
@@ skipping 164 matching lines @@
     }
     if (getOrSet != null && constModifier != null) {
       reportRecoverableError(constModifier, ErrorKind.ExtraneousModifier,
           {'modifier': constModifier});
     }
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
-      parseReturnTypeOpt(type);
+      parseTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
         reportRecoverableError(staticModifier, ErrorKind.ExtraneousModifier,
             {'modifier': staticModifier});
       }
     } else {
       token = parseIdentifier(name);
@@ skipping 71 matching lines @@
       } else {
         token = parseIdentifier(token);
       }
     } else if (optional('operator', token)) {
       // operator <op> (...
       listener.handleNoType(token);
       listener.beginFunctionName(token);
       token = parseOperatorName(token);
     } else {
       // <type>? <get>? <name>
-      token = parseReturnTypeOpt(token);
+      token = parseTypeOpt(token);
       if (identical(getOrSet, token)) {
         token = token.next;
       }
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
         token = parseIdentifier(token);
       }
     }
@@ skipping 29 matching lines @@
   Token parseFunctionDeclaration(Token token) {
     listener.beginFunctionDeclaration(token);
     token = parseFunction(token, null);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     listener.beginFunction(token);
     listener.handleModifiers(0);
-    token = parseReturnTypeOpt(token);
+    token = parseTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token);
     listener.endFunctionName(token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
@@ skipping 180 matching lines @@
       } else {
         return parseExpressionStatement(token);
       }
     } 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')) {
-      return parseExpressionStatementOrDeclaration(token);
     } else if (identical(value, 'while')) {
       return parseWhileStatement(token);
     } else if (identical(value, 'do')) {
       return parseDoWhileStatement(token);
     } else if (identical(value, 'try')) {
       return parseTryStatement(token);
     } else if (identical(value, 'switch')) {
       return parseSwitchStatement(token);
     } else if (identical(value, 'break')) {
       return parseBreakStatement(token);
@@ skipping 60 matching lines @@
       return peek;
     } else if (token.isIdentifier()) {
       // We are looking at "identifier".
       return token;
     } else {
       return null;
     }
   }
 
   Token parseExpressionStatementOrDeclaration(Token token) {
-    assert(token.isIdentifier() || identical(token.stringValue, 'void'));
+    assert(token.isIdentifier());
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
       assert(identifier.isIdentifier());
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) ||
           identical(afterIdKind, SEMICOLON_TOKEN) ||
           identical(afterIdKind, COMMA_TOKEN)) {
         // We are looking at "type identifier" followed by '=', ';', ','.
         return parseVariablesDeclaration(token);
@@ skipping 391 matching lines @@
       } else if (value == 'null') {
         return parseLiteralNull(token);
       } else if (value == 'this') {
         return parseThisExpression(token);
       } else if (value == 'super') {
         return parseSuperExpression(token);
       } else if (value == 'new') {
         return parseNewExpression(token);
       } else if (value == 'const') {
         return parseConstExpression(token);
-      } else if (value == 'void') {
-        return parseFunctionExpression(token);
       } else if (asyncAwaitKeywordsEnabled &&
           (value == 'yield' || value == 'async')) {
         return expressionExpected(token);
       } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
         return expressionExpected(token);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
@@ skipping 901 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }