Revert "Implemented support for generalized void in analyzer."

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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 analyzer.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 333 matching lines @@
 
   /**
    * Return `true` if the current token is the first token of a return type that
    * is followed by an identifier, possibly followed by a list of type
    * parameters, followed by a left-parenthesis. This is used by
    * [parseTypeAlias] to determine whether or not to parse a return type.
    */
   bool get hasReturnTypeInTypeAlias {
     // TODO(brianwilkerson) This is too expensive as implemented and needs to be
     // re-implemented or removed.
-    Token next = skipTypeAnnotation(_currentToken);
+    Token next = skipReturnType(_currentToken);
     if (next == null) {
       return false;
     }
     return _tokenMatchesIdentifier(next);
   }
 
   /**
    * Set whether the parser is to parse the async support.
    *
    * Support for removing the 'async' library has been removed.
@@ skipping 77 matching lines @@
     _currentToken = _currentToken.next;
     return token;
   }
 
   /**
    * Return `true` if the current token appears to be the beginning of a
    * function declaration.
    */
   bool isFunctionDeclaration() {
     Keyword keyword = _currentToken.keyword;
-    Token afterReturnType = skipTypeWithoutFunction(_currentToken);
+    if (keyword == Keyword.VOID) {
+      return true;
+    }
+    Token afterReturnType = skipTypeName(_currentToken);
     if (afterReturnType != null &&
         _tokenMatchesKeyword(afterReturnType, Keyword.FUNCTION)) {
       afterReturnType = skipGenericFunctionTypeAfterReturnType(afterReturnType);
     }
     if (afterReturnType == null) {
       // There was no return type, but it is optional, so go back to where we
       // started.
       afterReturnType = _currentToken;
     }
     Token afterIdentifier = skipSimpleIdentifier(afterReturnType);
@@ skipping 855 matching lines @@
           ])) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
             modifiers.externalKeyword, modifiers.staticKeyword, returnType);
       } else if (_matchesIdentifier() &&
           _peek().matchesAny(const <TokenType>[
             TokenType.EQ,
             TokenType.COMMA,
             TokenType.SEMICOLON
           ])) {
+        if (returnType is! GenericFunctionType) {
+          _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+        }
         return parseInitializedIdentifierList(
             commentAndMetadata,
             modifiers.staticKeyword,
             modifiers.covariantKeyword,
             _validateModifiersForField(modifiers),
             returnType);
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
@@ skipping 786 matching lines @@
           ])) {
         _validateModifiersForTopLevelFunction(modifiers);
         return parseFunctionDeclaration(
             commentAndMetadata, modifiers.externalKeyword, returnType);
       } else if (_matchesIdentifier() &&
           next.matchesAny(const <TokenType>[
             TokenType.EQ,
             TokenType.COMMA,
             TokenType.SEMICOLON
           ])) {
+        if (returnType is! GenericFunctionType) {
+          _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+        }
         return astFactory.topLevelVariableDeclaration(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             parseVariableDeclarationListAfterType(null,
                 _validateModifiersForTopLevelVariable(modifiers), returnType),
             _expect(TokenType.SEMICOLON));
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
@@ skipping 57 matching lines @@
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
       return astFactory.topLevelVariableDeclaration(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           parseVariableDeclarationListAfterType(
               null, _validateModifiersForTopLevelVariable(modifiers), null),
           _expect(TokenType.SEMICOLON));
     }
-    TypeAnnotation returnType = parseTypeAnnotation(false);
+    TypeAnnotation returnType = parseReturnType(false);
     keyword = _currentToken.keyword;
     next = _peek();
     if ((keyword == Keyword.GET || keyword == Keyword.SET) &&
         _tokenMatchesIdentifier(next)) {
       _validateModifiersForTopLevelFunction(modifiers);
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, returnType);
     } else if (keyword == Keyword.OPERATOR && _isOperator(next)) {
       _reportErrorForToken(ParserErrorCode.TOP_LEVEL_OPERATOR, _currentToken);
       return _convertToFunctionDeclaration(_parseOperatorAfterKeyword(
@@ skipping 654 matching lines @@
       }
     } else if (keyword == Keyword.VAR) {
       keywordToken = getAndAdvance();
       // Support `var/*=T*/ x;`
       type = _parseOptionalTypeNameComment();
       if (type != null) {
         // Clear the keyword to prevent an error.
         keywordToken = null;
       }
     } else if (_isTypedIdentifier(_currentToken)) {
-      type = parseTypeAnnotation(false);
+      type = parseReturnType(false);
     } else if (inFunctionType && _matchesIdentifier()) {
       type = parseTypeAnnotation(false);
     } else if (!optional) {
       // If there is a valid type immediately following an unexpected token,
       // then report and skip the unexpected token.
       Token next = _peek();
       Keyword nextKeyword = next.keyword;
       if (nextKeyword == Keyword.FINAL ||
           nextKeyword == Keyword.CONST ||
           nextKeyword == Keyword.VAR ||
@@ skipping 501 matching lines @@
    * Parse the portion of a generic function type following the [returnType].
    *
    *     functionType ::=
    *         returnType? 'Function' typeParameters? parameterTypeList
    *     parameterTypeList ::=
    *         '(' ')' |
    *       | '(' normalParameterTypes ','? ')' |
    *       | '(' normalParameterTypes ',' optionalParameterTypes ')' |
    *       | '(' optionalParameterTypes ')'
    *     normalParameterTypes ::=
-   *         normalParameterType (',' normalParameterType)*
+   *     normalParameterType (',' normalParameterType)*
    *     normalParameterType ::=
    *         type | typedIdentifier
    *     optionalParameterTypes ::=
    *         optionalPositionalParameterTypes | namedParameterTypes
    *     optionalPositionalParameterTypes ::=
    *         '[' normalParameterTypes ','? ']'
    *     namedParameterTypes ::=
    *         '{' typedIdentifier (',' typedIdentifier)* ','? '}'
    *     typedIdentifier ::=
    *         type identifier
@@ skipping 702 matching lines @@
               TokenType.LT
             ])) {
           return _parseFunctionDeclarationStatementAfterReturnType(
               commentAndMetadata, returnType);
         } else if (_matchesIdentifier() &&
             next.matchesAny(const <TokenType>[
               TokenType.EQ,
               TokenType.COMMA,
               TokenType.SEMICOLON
             ])) {
+          if (returnType is! GenericFunctionType) {
+            _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+          }
           return _parseVariableDeclarationStatementAfterType(
               commentAndMetadata, null, returnType);
         } else {
           //
           // We have found an error of some kind. Try to recover.
           //
           if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
             //
             // We appear to have found an incomplete statement at the end of a
             // block. Parse it as a variable declaration.
@@ skipping 57 matching lines @@
             TokenType.LT
           ])) {
         return _parseFunctionDeclarationStatementAfterReturnType(
             commentAndMetadata, returnType);
       } else if (_matchesIdentifier() &&
           next.matchesAny(const <TokenType>[
             TokenType.EQ,
             TokenType.COMMA,
             TokenType.SEMICOLON
           ])) {
+        if (returnType is! GenericFunctionType) {
+          _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+        }
         return _parseVariableDeclarationStatementAfterType(
             commentAndMetadata, null, returnType);
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
         if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
           //
           // We appear to have found an incomplete statement at the end of a
           // block. Parse it as a variable declaration.
@@ skipping 125 matching lines @@
             identifier: identifier,
             typeParameters: typeParameters,
             parameters: parameters);
       }
     } else if (typeParameters != null) {
       // TODO(brianwilkerson) Report an error. It looks like a function-typed
       // parameter with no parameter list.
       //_reportErrorForToken(ParserErrorCode.MISSING_PARAMETERS, typeParameters.endToken);
     }
     TypeAnnotation type = holder.type;
-    if (type != null &&
-        holder.keyword != null &&
-        _tokenMatchesKeyword(holder.keyword, Keyword.VAR)) {
-      _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, holder.keyword);
+    if (type != null) {
+      if (type is TypeName &&
+          _tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
+        _reportErrorForToken(
+            ParserErrorCode.VOID_PARAMETER, type.name.beginToken);
+      } else if (holder.keyword != null &&
+          _tokenMatchesKeyword(holder.keyword, Keyword.VAR)) {
+        _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, holder.keyword);
+      }
     }
     if (thisKeyword != null) {
       // TODO(brianwilkerson) If there are type parameters but no parameters,
       // should we create a synthetic empty parameter list here so we can
       // capture the type parameters?
       return astFactory.fieldFormalParameter2(
           comment: commentAndMetadata.comment,
           metadata: commentAndMetadata.metadata,
           covariantKeyword: covariantKeyword,
           keyword: holder.keyword,
@@ skipping 307 matching lines @@
       Expression expression = astFactory.superExpression(getAndAdvance());
       Token operator = getAndAdvance();
       return astFactory.binaryExpression(
           expression, operator, parseBitwiseOrExpression());
     }
     Expression expression = parseBitwiseOrExpression();
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.AS) {
       Token asOperator = getAndAdvance();
       return astFactory.asExpression(
-          expression, asOperator, parseTypeNotVoid(true));
+          expression, asOperator, parseTypeAnnotation(true));
     } else if (keyword == Keyword.IS) {
       Token isOperator = getAndAdvance();
       Token notOperator = null;
       if (_matches(TokenType.BANG)) {
         notOperator = getAndAdvance();
       }
-      TypeAnnotation type = parseTypeNotVoid(true);
+      TypeAnnotation type = parseTypeAnnotation(true);
       return astFactory.isExpression(expression, isOperator, notOperator, type);
     } else if (_currentToken.type.isRelationalOperator) {
       Token operator = getAndAdvance();
       return astFactory.binaryExpression(
           expression, operator, parseBitwiseOrExpression());
     }
     return expression;
   }
 
   /**
@@ skipping 19 matching lines @@
     Token returnKeyword = getAndAdvance();
     if (_matches(TokenType.SEMICOLON)) {
       return astFactory.returnStatement(returnKeyword, null, getAndAdvance());
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
     return astFactory.returnStatement(returnKeyword, expression, semicolon);
   }
 
   /**
+   * Parse a return type. Return the return type that was parsed.
+   *
+   *     returnType ::=
+   *         'void'
+   *       | type
+   */
+  TypeAnnotation parseReturnType(bool inExpression) {
+    if (_currentToken.keyword == Keyword.VOID) {
+      if (_atGenericFunctionTypeAfterReturnType(_peek())) {
+        return parseTypeAnnotation(false);
+      } else {
+        return astFactory.typeName(
+            astFactory.simpleIdentifier(getAndAdvance()), null);
+      }
+    } else {
+      return parseTypeAnnotation(inExpression);
+    }
+  }
+
+  /**
    * Parse a setter. The [commentAndMetadata] is the documentation comment and
    * metadata to be associated with the declaration. The [externalKeyword] is
    * the 'external' token. The [staticKeyword] is the static keyword, or `null`
    * if the setter is not static. The [returnType] is the return type that has
    * already been parsed, or `null` if there was no return type. Return the
    * setter that was parsed.
    *
    * This method assumes that the current token matches `Keyword.SET`.
    *
    *     setter ::=
@@ skipping 342 matching lines @@
   Statement parseTryStatement() {
     Token tryKeyword = getAndAdvance();
     Block body = _parseBlockChecked();
     List<CatchClause> catchClauses = <CatchClause>[];
     Block finallyClause = null;
     while (_matchesKeyword(Keyword.ON) || _matchesKeyword(Keyword.CATCH)) {
       Token onKeyword = null;
       TypeName exceptionType = null;
       if (_matchesKeyword(Keyword.ON)) {
         onKeyword = getAndAdvance();
-        exceptionType = parseTypeNotVoid(false);
+        exceptionType = parseTypeAnnotation(false);
       }
       Token catchKeyword = null;
       Token leftParenthesis = null;
       SimpleIdentifier exceptionParameter = null;
       Token comma = null;
       SimpleIdentifier stackTraceParameter = null;
       Token rightParenthesis = null;
       if (_matchesKeyword(Keyword.CATCH)) {
         catchKeyword = getAndAdvance();
         leftParenthesis = _expect(TokenType.OPEN_PAREN);
@@ skipping 70 matching lines @@
    * Parse a type.
    *
    *     type ::=
    *         typeWithoutFunction
    *       | functionType
    */
   TypeAnnotation parseTypeAnnotation(bool inExpression) {
     TypeAnnotation type = null;
     if (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
       // Generic function type with no return type.
-      type = parseGenericFunctionTypeAfterReturnType(null);
-    } else {
-      type = parseTypeWithoutFunction(inExpression);
-    }
-    while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
-      type = parseGenericFunctionTypeAfterReturnType(type);
-    }
-    return type;
-  }
-
-  /**
-   * Parse a type which is not `void`.
-   *
-   *     typeNotVoid ::=
-   *         functionType
-   *       | typeNotVoidWithoutFunction
-   */
-  TypeAnnotation parseTypeNotVoid(bool inExpression) {
-    TypeAnnotation type = null;
-    if (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
-      // Generic function type with no return type.
       type = parseGenericFunctionTypeAfterReturnType(null);
     } else if (_currentToken.keyword == Keyword.VOID &&
         _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
       type = astFactory.typeName(
           astFactory.simpleIdentifier(getAndAdvance()), null);
     } else {
       type = parseTypeName(inExpression);
     }
     while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
       type = parseGenericFunctionTypeAfterReturnType(type);
     }
     return type;
   }
 
   /**
-   * Parse a type which is not a function type.
-   *
-   *     typeWithoutFunction ::=
-   *         `void`
-   *       | typeNotVoidWithoutFunction
-   */
-  TypeAnnotation parseTypeWithoutFunction(bool inExpression) {
-    if (_currentToken.keyword == Keyword.VOID) {
-      return astFactory.typeName(
-          astFactory.simpleIdentifier(getAndAdvance()), null);
-    } else {
-      return parseTypeName(inExpression);
-    }
-  }
-
-  /**
    * Parse a list of type arguments. Return the type argument list that was
    * parsed.
    *
    * This method assumes that the current token matches `TokenType.LT`.
    *
    *     typeArguments ::=
    *         '<' typeList '>'
    *
    *     typeList ::=
    *         type (',' type)*
    */
   TypeArgumentList parseTypeArgumentList() {
     Token leftBracket = getAndAdvance();
     List<TypeAnnotation> arguments = <TypeAnnotation>[
       parseTypeAnnotation(false)
     ];
     while (_optional(TokenType.COMMA)) {
       arguments.add(parseTypeAnnotation(false));
     }
     Token rightBracket = _expectGt();
     return astFactory.typeArgumentList(leftBracket, arguments, rightBracket);
   }
 
   /**
-   * Parse a type which is not void and is not a function type. Return the type
-   * that was parsed.
+   * Parse a type name. Return the type name that was parsed.
    *
-   *     typeNotVoidWithoutFunction ::=
+   *     type ::=
    *         qualified typeArguments?
    */
-  // TODO(eernst): Rename this to `parseTypeNotVoidWithoutFunction`?
-  // Apparently,  it was named `parseTypeName` before type arguments existed.
   TypeName parseTypeName(bool inExpression) {
     TypeName realType = _parseTypeName(inExpression);
     // If this is followed by a generic method type comment, allow the comment
     // type to replace the real type name.
     // TODO(jmesserly): this feels like a big hammer. Can we restrict it to
     // only work inside generic methods?
     TypeName typeFromComment = _parseOptionalTypeNameComment();
     return typeFromComment ?? realType;
   }
 
   /**
    * Parse a type parameter. Return the type parameter that was parsed.
    *
    *     typeParameter ::=
    *         metadata name ('extends' bound)?
    */
   TypeParameter parseTypeParameter() {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     if (_matches(TokenType.QUESTION)) {
       _reportErrorForCurrentToken(ParserErrorCode.NULLABLE_TYPE_PARAMETER);
       _advance();
     }
     if (_matchesKeyword(Keyword.EXTENDS)) {
       Token keyword = getAndAdvance();
-      TypeAnnotation bound = parseTypeNotVoid(false);
+      TypeAnnotation bound = parseTypeAnnotation(false);
       return astFactory.typeParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, name, keyword, bound);
     }
     return astFactory.typeParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, name, null, null);
   }
 
   /**
    * Parse a list of type parameters. Return the list of type parameters that
    * were parsed.
@@ skipping 310 matching lines @@
         _tokenMatches(token, TokenType.COMMA)) {
       // If the `id.` is followed by something that cannot produce a valid
       // structure then assume this is a prefixed identifier but missing the
       // trailing identifier
       return token;
     }
     return null;
   }
 
   /**
+   * Parse a return type, starting at the [startToken], without actually
+   * creating a return type or changing the current token. Return the token
+   * following the return type that was parsed, or `null` if the given token is
+   * not the first token in a valid return type.
+   *
+   * This method must be kept in sync with [parseReturnType].
+   *
+   *     returnType ::=
+   *         'void'
+   *       | type
+   */
+  Token skipReturnType(Token startToken) {
+    if (_tokenMatchesKeyword(startToken, Keyword.VOID)) {
+      if (_atGenericFunctionTypeAfterReturnType(_peek())) {
+        return skipTypeAnnotation(startToken);
+      }
+      return startToken.next;
+    } else {
+      return skipTypeAnnotation(startToken);
+    }
+  }
+
+  /**
    * Parse a simple identifier, starting at the [startToken], without actually
    * creating a simple identifier or changing the current token. Return the
    * token following the simple identifier that was parsed, or `null` if the
    * given token is not the first token in a valid simple identifier.
    *
    * This method must be kept in sync with [parseSimpleIdentifier].
    *
    *     identifier ::=
    *         IDENTIFIER
    */
@@ skipping 37 matching lines @@
    * Parse a type annotation, starting at the [startToken], without actually
    * creating a type annotation or changing the current token. Return the token
    * following the type annotation that was parsed, or `null` if the given token
    * is not the first token in a valid type annotation.
    *
    * This method must be kept in sync with [parseTypeAnnotation].
    */
   Token skipTypeAnnotation(Token startToken) {
     Token next = null;
     if (_atGenericFunctionTypeAfterReturnType(startToken)) {
-      // Generic function type with no return type.
       next = skipGenericFunctionTypeAfterReturnType(startToken);
+    } else if (startToken.keyword == Keyword.VOID &&
+        _atGenericFunctionTypeAfterReturnType(startToken.next)) {
+      next = startToken.next;
     } else {
-      next = skipTypeWithoutFunction(startToken);
+      next = skipTypeName(startToken);
     }
     while (next != null && _atGenericFunctionTypeAfterReturnType(next)) {
       next = skipGenericFunctionTypeAfterReturnType(next);
     }
     return next;
   }
 
   /**
-   * Parse a typeWithoutFunction, starting at the [startToken], without actually
-   * creating a TypeAnnotation or changing the current token. Return the token
-   * following the typeWithoutFunction that was parsed, or `null` if the given
-   * token is not the first token in a valid typeWithoutFunction.
-   *
-   * This method must be kept in sync with [parseTypeWithoutFunction].
-   */
-  Token skipTypeWithoutFunction(Token startToken) {
-    if (startToken.keyword == Keyword.VOID) {
-      return startToken.next;
-    } else {
-      return skipTypeName(startToken);
-    }
-  }
-
-  /**
    * Parse a list of type arguments, starting at the [startToken], without
    * actually creating a type argument list or changing the current token.
    * Return the token following the type argument list that was parsed, or
    * `null` if the given token is not the first token in a valid type argument
    * list.
    *
    * This method must be kept in sync with [parseTypeArgumentList].
    *
    *     typeArguments ::=
    *         '<' typeList '>'
    *
    *     typeList ::=
    *         type (',' type)*
    */
   Token skipTypeArgumentList(Token startToken) {
     Token token = startToken;
     if (!_tokenMatches(token, TokenType.LT) &&
         !_injectGenericCommentTypeList()) {
       return null;
     }
-    token = skipTypeAnnotation(token.next);
+    token = skipTypeName(token.next);
     if (token == null) {
       // If the start token '<' is followed by '>'
       // then assume this should be type argument list but is missing a type
       token = startToken.next;
       if (_tokenMatches(token, TokenType.GT)) {
         return token.next;
       }
       return null;
     }
     while (_tokenMatches(token, TokenType.COMMA)) {
-      token = skipTypeAnnotation(token.next);
+      token = skipTypeName(token.next);
       if (token == null) {
         return null;
       }
     }
     if (token.type == TokenType.GT) {
       return token.next;
     } else if (token.type == TokenType.GT_GT) {
       Token second = new Token(TokenType.GT, token.offset + 1);
       second.setNextWithoutSettingPrevious(token.next);
       return second;
@@ skipping 166 matching lines @@
         ((keyword == Keyword.GET || keyword == Keyword.SET) &&
             _tokenMatchesIdentifier(next)) ||
         (keyword == Keyword.OPERATOR && _isOperator(next))) {
       // This looks like the start of a function
       return true;
     } else if (_matchesIdentifier()) {
       if (nextType == TokenType.OPEN_PAREN) {
         // This looks like the start of a function
         return true;
       }
-      Token token = skipTypeAnnotation(_currentToken);
+      Token token = skipReturnType(_currentToken);
       if (token == null) {
         return false;
       }
       // TODO(brianwilkerson) This looks wrong; should we be checking 'token'?
       if (keyword == Keyword.GET ||
           keyword == Keyword.SET ||
           (keyword == Keyword.OPERATOR && _isOperator(next)) ||
           _matchesIdentifier()) {
         return true;
       }
@@ skipping 367 matching lines @@
   bool _isPeekGenericTypeParametersAndOpenParen() {
     Token token = _skipTypeParameterList(_peek());
     return token != null && _tokenMatches(token, TokenType.OPEN_PAREN);
   }
 
   /**
    * Return `true` if the [startToken] appears to be the first token of a type
    * name that is followed by a variable or field formal parameter.
    */
   bool _isTypedIdentifier(Token startToken) {
-    Token token = skipTypeAnnotation(startToken);
+    Token token = skipReturnType(startToken);
     if (token == null) {
       return false;
     } else if (_tokenMatchesIdentifier(token)) {
       return true;
     } else if (_tokenMatchesKeyword(token, Keyword.THIS) &&
         _tokenMatches(token.next, TokenType.PERIOD) &&
         _tokenMatchesIdentifier(token.next.next)) {
       return true;
+    } else if (_tokenMatchesKeyword(startToken, Keyword.VOID)) {
+      // The keyword 'void' isn't a valid identifier, so it should be assumed to
+      // be a type name.
+      return true;
     } else if (startToken.next != token &&
         !_tokenMatches(token, TokenType.OPEN_PAREN)) {
       // The type is more than a simple identifier, so it should be assumed to
       // be a type name.
       return true;
     }
     return false;
   }
 
   /**
@@ skipping 669 matching lines @@
    *     functionTypeAlias ::=
    *         functionPrefix typeParameterList? formalParameterList ';'
    *
    *     functionPrefix ::=
    *         returnType? name
    */
   FunctionTypeAlias _parseFunctionTypeAlias(
       CommentAndMetadata commentAndMetadata, Token keyword) {
     TypeAnnotation returnType = null;
     if (hasReturnTypeInTypeAlias) {
-      returnType = parseTypeAnnotation(false);
+      returnType = parseReturnType(false);
     }
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     TokenType type = _currentToken.type;
     if (type == TokenType.SEMICOLON || type == TokenType.EOF) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
       FormalParameterList parameters = astFactory.formalParameterList(
@@ skipping 294 matching lines @@
           (_tokenMatchesIdentifier(next) ||
               _tokenMatches(next, TokenType.LT))) {
         Token afterTypeParameters = _skipTypeParameterList(next);
         if (afterTypeParameters != null &&
             _tokenMatches(afterTypeParameters, TokenType.OPEN_PAREN)) {
           // If the identifier is followed by type parameters and a parenthesis,
           // then the identifier is the name of a generic method, not a return
           // type.
           return null;
         }
-        return parseTypeAnnotation(false);
+        return parseReturnType(false);
       }
       Token next2 = next.next;
       Token next3 = next2.next;
       if (_tokenMatches(next, TokenType.PERIOD) &&
           _tokenMatchesIdentifier(next2) &&
           (_tokenMatchesIdentifier(next3) ||
               _tokenMatches(next3, TokenType.LT))) {
-        return parseTypeAnnotation(false);
+        return parseReturnType(false);
       }
     }
     return null;
   }
 
   /**
    * Parse a [TypeArgumentList] if present, otherwise return null.
    * This also supports the comment form, if enabled: `/*<T>*/`
    */
   TypeArgumentList _parseOptionalTypeArguments() {
@@ skipping 524 matching lines @@
     } else if (_tokenMatchesIdentifier(startToken)) {
       Token next = startToken.next;
       if (_tokenMatchesIdentifier(next) ||
           _tokenMatches(next, TokenType.LT) ||
           _tokenMatchesKeyword(next, Keyword.THIS) ||
           (_tokenMatches(next, TokenType.PERIOD) &&
               _tokenMatchesIdentifier(next.next) &&
               (_tokenMatchesIdentifier(next.next.next) ||
                   _tokenMatches(next.next.next, TokenType.LT) ||
                   _tokenMatchesKeyword(next.next.next, Keyword.THIS)))) {
-        return skipTypeAnnotation(startToken);
+        return skipReturnType(startToken);
       }
     }
     return null;
   }
 
   /**
    * Parse a list of formal parameters, starting at the [startToken], without
    * actually creating a formal parameter list or changing the current token.
    * Return the token following the formal parameter list that was parsed, or
    * `null` if the given token is not the first token in a valid list of formal
@@ skipping 756 matching lines @@
     }
   }
 }
 
 /**
  * Instances of this class are thrown when the parser detects that AST has
  * too many nested expressions to be parsed safely and avoid possibility of
  * [StackOverflowError] in the parser or during later analysis.
  */
 class _TooDeepTreeError {}