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 '../fasta_codes.dart'
     show
         FastaCode,
         FastaMessage,
@@ skipping 546 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 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) {
     if (optional('(', token)) {
       return parseFormalParameters(token);
     } else {
       listener.handleNoFormalParameters(token);
       return token;
     }
   }
 
   Token skipFormalParameters(Token token) {
@@ skipping 77 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);
         nameToken = token;
         token = parseIdentifier(token, IdentifierContext.fieldInitializer);
       } else {
         nameToken = token;
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       }
@@ skipping 334 matching lines @@
   Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier) {
       token =
           reportUnrecoverableErrorCodeWithToken(token, codeExpectedIdentifier)
               .next;
     } else if (token.isBuiltInIdentifier &&
         !context.isBuiltInIdentifierAllowed) {
       if (context.inDeclaration) {
         reportRecoverableErrorCodeWithToken(
             token, codeBuiltInIdentifierInDeclaration);
-      } else if (!optional("dynamic", token)) {
+      } else if (!optional("dynamic", token) && !optional("void", token)) {
         reportRecoverableErrorCodeWithToken(token, codeBuiltInIdentifierAsType);
       }
     } else if (!inPlainSync && token.isPseudo) {
       if (optional('await', token)) {
         reportRecoverableErrorCode(token, codeAwaitAsIdentifier);
       } else if (optional('yield', token)) {
         reportRecoverableErrorCode(token, codeYieldAsIdentifier);
       } else if (optional('async', token)) {
         reportRecoverableErrorCode(token, codeAsyncAsIdentifier);
       }
@@ skipping 56 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 =
             reportUnrecoverableErrorCodeWithToken(token, codeExpectedType).next;
         listener.handleInvalidTypeReference(token);
       }
@@ skipping 254 matching lines @@
     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);
       }
     }
 
     IdentifierContext context = isTopLevel
         ? IdentifierContext.topLevelVariableDeclaration
@@ skipping 33 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 346 matching lines @@
     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 reportUnrecoverableErrorCodeWithToken(
               token, codeExpectedClassBodyToSkip)
           .next;
@@ skipping 165 matching lines @@
     }
     if (getOrSet != null && constModifier != null) {
       reportRecoverableErrorCodeWithToken(
           constModifier, codeExtraneousModifier);
     }
     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) {
         reportRecoverableErrorCodeWithToken(
             staticModifier, codeExtraneousModifier);
       }
     } else {
       token = parseIdentifier(name, IdentifierContext.methodDeclaration);
@@ skipping 84 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 33 matching lines @@
     listener.beginFunctionDeclaration(token);
     token = parseFunction(token, null);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginFunction(token);
     listener.handleModifiers(0);
-    token = parseReturnTypeOpt(token);
+    token = parseTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token, IdentifierContext.functionExpressionName);
     listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
@@ skipping 195 matching lines @@
         reportRecoverableErrorCode(token, codeAwaitForNotAsync);
       }
       return parseForStatement(token, token.next);
     } else if (identical(value, 'for')) {
       return parseForStatement(null, token);
     } else if (identical(value, 'rethrow')) {
       return parseRethrowStatement(token);
     } else if (identical(value, 'throw') && optional(';', token.next)) {
       // TODO(kasperl): Stop dealing with throw here.
       return parseRethrowStatement(token);
-    } else if (identical(value, 'void')) {
-      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 78 matching lines @@
       return token;
     } else {
       return null;
     }
   }
 
   Token parseExpressionStatementOrDeclaration(Token token) {
     if (!inPlainSync && optional("await", token)) {
       return parseExpressionStatement(token);
     }
-    assert(token.isIdentifier || identical(token.stringValue, 'void'));
+    assert(token.isIdentifier);
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
       assert(identifier.isIdentifier);
 
       // If the identifier token has a type substitution comment /*=T*/,
       // then the set of tokens type tokens should be replaced with the
       // tokens parsed from the comment.
       token =
           listener.replaceTokenWithGenericCommentTypeAssign(token, identifier);
 
@@ skipping 409 matching lines @@
       } else if (identical(value, "null")) {
         return parseLiteralNull(token);
       } else if (identical(value, "this")) {
         return parseThisExpression(token, context);
       } else if (identical(value, "super")) {
         return parseSuperExpression(token, context);
       } else if (identical(value, "new")) {
         return parseNewExpression(token);
       } else if (identical(value, "const")) {
         return parseConstExpression(token);
-      } else if (identical(value, "void")) {
-        return parseFunctionExpression(token);
       } else if (!inPlainSync &&
           (identical(value, "yield") || identical(value, "async"))) {
         return expressionExpected(token);
       } else if (token.isIdentifier) {
         return parseSendOrFunctionLiteral(token, context);
       } else {
         return expressionExpected(token);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
@@ skipping 981 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);