Support `void` as generic argument.

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 closeBraceFor, skipToEof;
 
@@ skipping 383 matching lines @@
     Token typedefKeyword = token;
     listener.beginFunctionTypeAlias(token);
     Token equals;
     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 = parseTypeOpt(token.next);
       token = parseIdentifier(token, IdentifierContext.typedefDeclaration);
       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')) {
-      if (isGeneralizedFunctionType(token.next)) {
-        return parseType(token);
-      } else {
-        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) {
@@ skipping 70 matching lines @@
           parseIdentifier(token, IdentifierContext.formalParameterDeclaration);
     } else if (inFunctionType) {
       token = parseType(token);
       if (token.isIdentifier()) {
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       } else {
         listener.handleNoName(token);
       }
     } else {
-      token = parseReturnTypeOpt(token);
+      token = parseTypeOpt(token);
       if (optional('this', token)) {
         thisKeyword = token;
         token = expect('.', token.next);
         token = parseIdentifier(token, IdentifierContext.fieldInitializer);
       } else {
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       }
     }
 
@@ skipping 394 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') &&
-        isGeneralizedFunctionType(token.next)) {
-      listener.handleVoidKeyword(token);
-      token = token.next;
     } else {
       if (isValidTypeReference(token)) {
         token = parseIdentifier(token, IdentifierContext.typeReference);
         token = parseQualifiedRestOpt(
             token, IdentifierContext.typeReferenceContinuation);
       } else {
         token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
         listener.handleInvalidTypeReference(token);
       }
       token = parseTypeArgumentsOpt(token);
@@ skipping 237 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) &&
-        !isGeneralizedFunctionType(type.next)) {
-      listener.handleNoType(name);
-      // TODO(ahe): This error is reported twice, second time is from
-      // [parseVariablesDeclarationMaybeSemicolon] via
-      // [PartialFieldListElement.parseNode].
-      reportRecoverableError(type, ErrorKind.InvalidVoid);
     } else {
       parseType(type);
       if (isVar) {
         reportRecoverableError(modifiers.head, ErrorKind.ExtraneousModifier,
             {'modifier': modifiers.head});
       }
     }
 
     IdentifierContext context = isTopLevel
         ? IdentifierContext.topLevelVariableDeclaration
@@ skipping 34 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, IdentifierContext.topLevelFunctionDeclaration);
 
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
@@ skipping 323 matching lines @@
     }
 
     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 165 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, IdentifierContext.methodDeclaration);
@@ skipping 75 matching lines @@
         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);
+      token = parseTypeOpt(token);
       if (identical(getOrSet, token)) {
         token = token.next;
       }
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
         token =
             parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
       }
@@ skipping 31 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, IdentifierContext.functionExpressionName);
     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 185 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 393 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 905 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }