Remaining parser changes for generic function types

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.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 44 matching lines @@
 /**
  * A simple data-holder for a method that needs to return multiple values.
  */
 class FinalConstVarOrType {
   /**
    * The 'final', 'const' or 'var' keyword, or `null` if none was given.
    */
   final Token keyword;
 
   /**
-   * The type, of `null` if no type was specified.
+   * The type, or `null` if no type was specified.
    */
-  final TypeName type;
+  final TypeAnnotation type;
 
   /**
    * Initialize a newly created holder with the given [keyword] and [type].
    */
   FinalConstVarOrType(this.keyword, this.type);
 }
 
 /**
  * A simple data-holder for a method that needs to return multiple values.
  */
@@ skipping 1350 matching lines @@
       // function type alias that was parsed.
       _parseFunctionTypeAlias(commentAndMetadata, getAndAdvance());
       return null;
     } else {
       Token token = _skipTypeParameterList(_peek());
       if (token != null && _tokenMatches(token, TokenType.OPEN_PAREN)) {
         return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
             modifiers.externalKeyword, modifiers.staticKeyword, null);
       }
     }
-    TypeName type = _parseTypeNameAfterIdentifier();
+    TypeAnnotation type = _parseTypeAnnotationAfterIdentifier();
     keyword = _currentToken.keyword;
     next = _peek();
     isFollowedByIdentifier = _tokenMatchesIdentifier(next);
     if (keyword == Keyword.GET && isFollowedByIdentifier) {
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       return parseGetter(commentAndMetadata, modifiers.externalKeyword,
           modifiers.staticKeyword, type);
     } else if (keyword == Keyword.SET && isFollowedByIdentifier) {
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       return parseSetter(commentAndMetadata, modifiers.externalKeyword,
@@ skipping 653 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));
     }
-    TypeName returnType = parseReturnType();
+    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 627 matching lines @@
    *
    *     finalConstVarOrType ::=
    *         'final' type?
    *       | 'const' type?
    *       | 'var'
    *       | type
    */
   FinalConstVarOrType parseFinalConstVarOrType(bool optional,
       {bool inFunctionType: false}) {
     Token keywordToken = null;
-    TypeName type = null;
+    TypeAnnotation type = null;
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.FINAL || keyword == Keyword.CONST) {
       keywordToken = getAndAdvance();
       if (_isTypedIdentifier(_currentToken)) {
-        type = parseTypeName(false);
+        type = parseTypeAnnotation(false);
       } else {
         // Support `final/*=T*/ x;`
         type = _parseOptionalTypeNameComment();
       }
     } 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 = parseReturnType();
+      type = parseReturnType(false);
     } else if (inFunctionType && _matchesIdentifier()) {
-      type = parseTypeAnnotation();
+      type = parseTypeAnnotation(false);
     } else if (!optional) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
     } else {
       // Support parameters such as `(/*=K*/ key, /*=V*/ value)`
       // This is not supported if the type is required.
       type = _parseOptionalTypeNameComment();
     }
     return new FinalConstVarOrType(keywordToken, type);
   }
@@ skipping 168 matching lines @@
               _reportErrorForCurrentToken(
                   ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH,
                   [variables.length.toString()]);
             }
             VariableDeclaration variable = variables[0];
             if (variable.initializer != null) {
               _reportErrorForCurrentToken(
                   ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH);
             }
             Token keyword = variableList.keyword;
-            TypeName type = variableList.type;
+            TypeAnnotation type = variableList.type;
             if (keyword != null || type != null) {
               loopVariable = astFactory.declaredIdentifier(
                   commentAndMetadata.comment,
                   commentAndMetadata.metadata,
                   keyword,
                   type,
                   astFactory.simpleIdentifier(variable.name.token,
                       isDeclaration: true));
             } else {
               if (commentAndMetadata.hasMetadata) {
@@ skipping 191 matching lines @@
    * being parsed as a statement. Return the function declaration that was
    * parsed.
    *
    *     functionDeclaration ::=
    *         functionSignature functionBody
    *       | returnType? getOrSet identifier formalParameterList functionBody
    */
   FunctionDeclaration parseFunctionDeclaration(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
-      TypeName returnType) {
+      TypeAnnotation returnType) {
     Token keywordToken = null;
     bool isGetter = false;
     Keyword keyword = _currentToken.keyword;
     SimpleIdentifier name = null;
     if (keyword == Keyword.GET) {
       keywordToken = getAndAdvance();
       isGetter = true;
     } else if (keyword == Keyword.SET) {
       keywordToken = getAndAdvance();
     }
@@ skipping 128 matching lines @@
    *         'typedef' identifier typeParameterList? '=' functionType ';'
    */
   GenericTypeAlias parseGenericTypeAlias(
       CommentAndMetadata commentAndMetadata, Token keyword) {
     Identifier name = _parseSimpleIdentifierUnchecked(isDeclaration: true);
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     Token equals = _expect(TokenType.EQ);
-    TypeAnnotation functionType = parseTypeAnnotation();
+    TypeAnnotation functionType = parseTypeAnnotation(false);
     Token semicolon = _expect(TokenType.SEMICOLON);
     if (functionType is! GenericFunctionType) {
       // TODO(brianwilkerson) Generate an error and recover (better than this).
       return astFactory.genericTypeAlias(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           keyword,
           name,
           typeParameters,
           equals,
@@ skipping 21 matching lines @@
    *
    * This method assumes that the current token matches `Keyword.GET`.
    *
    *     getter ::=
    *         getterSignature functionBody?
    *
    *     getterSignature ::=
    *         'external'? 'static'? returnType? 'get' identifier
    */
   MethodDeclaration parseGetter(CommentAndMetadata commentAndMetadata,
-      Token externalKeyword, Token staticKeyword, TypeName returnType) {
+      Token externalKeyword, Token staticKeyword, TypeAnnotation returnType) {
     Token propertyKeyword = getAndAdvance();
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     if (_matches(TokenType.OPEN_PAREN) &&
         _tokenMatches(_peek(), TokenType.CLOSE_PAREN)) {
       _reportErrorForCurrentToken(ParserErrorCode.GETTER_WITH_PARAMETERS);
       _advance();
       _advance();
     }
     FunctionBody body = parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
@@ skipping 163 matching lines @@
    *     initializedIdentifierList ::=
    *         initializedIdentifier (',' initializedIdentifier)*
    *
    *     initializedIdentifier ::=
    *         identifier ('=' expression)?
    */
   FieldDeclaration parseInitializedIdentifierList(
       CommentAndMetadata commentAndMetadata,
       Token staticKeyword,
       Token keyword,
-      TypeName type) {
+      TypeAnnotation type) {
     VariableDeclarationList fieldList =
         parseVariableDeclarationListAfterType(null, keyword, type);
     return astFactory.fieldDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         staticKeyword,
         fieldList,
         _expect(TokenType.SEMICOLON));
   }
 
@@ skipping 580 matching lines @@
             period,
             identifier,
             typeParameters,
             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);
     }
-    TypeName type = holder.type;
+    TypeAnnotation type = holder.type;
     if (type != null) {
-      if (_tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
+      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.fieldFormalParameter(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           holder.keyword,
-          holder.type,
+          type,
           thisKeyword,
           period,
           identifier,
           null,
           null);
     }
     return astFactory.simpleFormalParameter(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         holder.keyword,
-        holder.type,
+        type,
         astFactory.simpleIdentifier(identifier.token, isDeclaration: true));
   }
 
   /**
    * Parse an operator declaration. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [externalKeyword] is the 'external' token. The [returnType] is the
    * return type that has already been parsed, or `null` if there was no return
    * type. Return the operator declaration that was parsed.
    *
@@ skipping 285 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, parseTypeName(true));
+          expression, asOperator, parseTypeAnnotation(true));
     } else if (keyword == Keyword.IS) {
       Token isOperator = getAndAdvance();
       Token notOperator = null;
       if (_matches(TokenType.BANG)) {
         notOperator = getAndAdvance();
       }
-      return astFactory.isExpression(
-          expression, isOperator, notOperator, parseTypeName(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;
   }
 
   /**
    * Parse a rethrow expression. Return the rethrow expression that was parsed.
@@ skipping 24 matching lines @@
     return astFactory.returnStatement(returnKeyword, expression, semicolon);
   }
 
   /**
    * Parse a return type. Return the return type that was parsed.
    *
    *     returnType ::=
    *         'void'
    *       | type
    */
-  TypeName parseReturnType() {
+  TypeAnnotation parseReturnType(bool inExpression) {
     if (_currentToken.keyword == Keyword.VOID) {
       return astFactory.typeName(
           astFactory.simpleIdentifier(getAndAdvance()), null);
     } else {
-      return parseTypeName(false);
+      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 ::=
    *         setterSignature functionBody?
    *
    *     setterSignature ::=
    *         'external'? 'static'? returnType? 'set' identifier formalParameterList
    */
   MethodDeclaration parseSetter(CommentAndMetadata commentAndMetadata,
-      Token externalKeyword, Token staticKeyword, TypeName returnType) {
+      Token externalKeyword, Token staticKeyword, TypeAnnotation returnType) {
     Token propertyKeyword = getAndAdvance();
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body = parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_SETTER_WITHOUT_BODY,
         false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_SETTER_WITH_BODY);
@@ skipping 314 matching lines @@
   Statement parseTryStatement() {
     Token tryKeyword = getAndAdvance();
     Block body = _parseBlockChecked();
     List<CatchClause> catchClauses = <CatchClause>[];
     Block finallyClause = null;
     while (_matchesString(_ON) || _matchesKeyword(Keyword.CATCH)) {
       Token onKeyword = null;
       TypeName exceptionType = null;
       if (_matchesString(_ON)) {
         onKeyword = getAndAdvance();
-        exceptionType = parseTypeName(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 66 matching lines @@
     return _parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
   /**
    * Parse a type.
    *
    *     type ::=
    *         typeWithoutFunction
    *       | functionType
    */
-  TypeAnnotation parseTypeAnnotation() {
-    if (_matchesString('Function')) {
+  TypeAnnotation parseTypeAnnotation(bool inExpression) {
+    TypeAnnotation type = null;
+    if (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
       // Generic function type with no return type.
-      return parseGenericFunctionTypeAfterReturnType(null);
+      type = parseGenericFunctionTypeAfterReturnType(null);
+    } else if (_currentToken.keyword == Keyword.VOID &&
+        _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
+      type = astFactory.typeName(
+          astFactory.simpleIdentifier(getAndAdvance()), null);
+    } else {
+      type = parseTypeName(inExpression);
     }
-    TypeAnnotation type = parseReturnType();
-    while (_matchesString('Function')) {
+    while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
       type = parseGenericFunctionTypeAfterReturnType(type);
     }
     return type;
   }
 
   /**
    * 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<TypeName> arguments = <TypeName>[parseTypeName(false)];
+    List<TypeAnnotation> arguments = <TypeAnnotation>[
+      parseTypeAnnotation(false)
+    ];
     while (_optional(TokenType.COMMA)) {
-      arguments.add(parseTypeName(false));
+      arguments.add(parseTypeAnnotation(false));
     }
     Token rightBracket = _expectGt();
     return astFactory.typeArgumentList(leftBracket, arguments, rightBracket);
   }
 
   /**
    * Parse a type name. Return the type name that was parsed.
    *
    *     type ::=
    *         qualified typeArguments?
@@ skipping 16 matching lines @@
    */
   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();
-      TypeName bound = parseTypeName(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 137 matching lines @@
    * to be associated with the variable declaration list, or `null` if there is
    * no attempt at parsing the comment and metadata. The [keyword] is the token
    * representing the 'final', 'const' or 'var' keyword, or `null` if there is
    * no keyword. The [type] is the type of the variables in the list. Return the
    * variable declaration list that was parsed.
    *
    *     variableDeclarationList ::=
    *         finalConstVarOrType variableDeclaration (',' variableDeclaration)*
    */
   VariableDeclarationList parseVariableDeclarationListAfterType(
-      CommentAndMetadata commentAndMetadata, Token keyword, TypeName type) {
+      CommentAndMetadata commentAndMetadata,
+      Token keyword,
+      TypeAnnotation type) {
     if (type != null &&
         keyword != null &&
         _tokenMatchesKeyword(keyword, Keyword.VAR)) {
       _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, keyword);
     }
     List<VariableDeclaration> variables = <VariableDeclaration>[
       parseVariableDeclaration()
     ];
     while (_optional(TokenType.COMMA)) {
       variables.add(parseVariableDeclaration());
@@ skipping 82 matching lines @@
     Token star = null;
     if (_matches(TokenType.STAR)) {
       star = getAndAdvance();
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
     return astFactory.yieldStatement(yieldToken, star, expression, semicolon);
   }
 
   /**
+   * Parse a formal parameter list, starting at the [startToken], without
+   * actually creating a formal parameter list or changing the current token.
+   * Return the token following the parameter list that was parsed, or `null`
+   * if the given token is not the first token in a valid parameter list.
+   *
+   * This method must be kept in sync with [parseFormalParameterList].
+   */
+  Token skipFormalParameterList(Token startToken) {
+    if (!_tokenMatches(startToken, TokenType.OPEN_PAREN)) {
+      return null;
+    }
+    return (startToken as BeginToken).endToken;
+  }
+
+  /**
+   * Parse the portion of a generic function type after the return type,
+   * starting at the [startToken], without actually creating a generic function
+   * type or changing the current token. Return the token following the generic
+   * function type that was parsed, or `null` if the given token is not the
+   * first token in a valid generic function type.
+   *
+   * This method must be kept in sync with
+   * [parseGenericFunctionTypeAfterReturnType].
+   */
+  Token skipGenericFunctionTypeAfterReturnType(Token startToken) {
+    Token next = startToken.next; // Skip 'Function'
+    if (_tokenMatches(next, TokenType.LT)) {
+      next = skipTypeParameterList(next);
+    }
+    return skipFormalParameterList(next);
+  }
+
+  /**
    * Parse a prefixed identifier, starting at the [startToken], without actually
    * creating a prefixed identifier or changing the current token. Return the
    * token following the prefixed identifier that was parsed, or `null` if the
    * given token is not the first token in a valid prefixed identifier.
    *
    * This method must be kept in sync with [parsePrefixedIdentifier].
    *
    *     prefixedIdentifier ::=
    *         identifier ('.' identifier)?
    */
@@ skipping 27 matching lines @@
    * This method must be kept in sync with [parseReturnType].
    *
    *     returnType ::=
    *         'void'
    *       | type
    */
   Token skipReturnType(Token startToken) {
     if (_tokenMatchesKeyword(startToken, Keyword.VOID)) {
       return startToken.next;
     } else {
-      return skipTypeName(startToken);
+      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].
@@ skipping 31 matching lines @@
         token = _skipStringInterpolation(token);
       }
     }
     if (identical(token, startToken)) {
       return null;
     }
     return token;
   }
 
   /**
+   * 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)) {
+      next = skipGenericFunctionTypeAfterReturnType(startToken);
+    } else if (_currentToken.keyword == Keyword.VOID &&
+        _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
+      next = next.next;
+    } else {
+      next = skipTypeName(startToken);
+    }
+    while (next != null && _tokenMatchesString(next, 'Function')) {
+      next = skipGenericFunctionTypeAfterReturnType(next);
+    }
+    return next;
+  }
+
+  /**
    * 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 '>'
@@ skipping 49 matching lines @@
     if (token == null) {
       return null;
     }
     if (_tokenMatches(token, TokenType.LT)) {
       token = skipTypeArgumentList(token);
     }
     return token;
   }
 
   /**
+   * Parse a type parameter list, starting at the [startToken], without actually
+   * creating a type parameter list or changing the current token. Return the
+   * token following the type parameter list that was parsed, or `null` if the
+   * given token is not the first token in a valid type parameter list.
+   *
+   * This method must be kept in sync with [parseTypeParameterList].
+   */
+  Token skipTypeParameterList(Token startToken) {
+    if (!_tokenMatches(startToken, TokenType.LT)) {
+      return null;
+    }
+    int depth = 1;
+    Token previous = startToken;
+    Token next = startToken.next;
+    while (next != previous) {
+      if (_tokenMatches(startToken, TokenType.LT)) {
+        depth++;
+      } else if (_tokenMatches(next, TokenType.GT)) {
+        depth--;
+        if (depth == 0) {
+          return next;
+        }
+      }
+      previous = next;
+      next = next.next;
+    }
+    return null;
+  }
+
+  /**
    * Advance to the next token in the token stream.
    */
   void _advance() {
     _currentToken = _currentToken.next;
   }
 
   /**
    * Append the character equivalent of the given [codePoint] to the given
    * [builder]. Use the [startIndex] and [endIndex] to report an error, and
    * don't append anything to the builder, if the code point is invalid. The
    * [escapeSequence] is the escape sequence that was parsed to produce the
    * code point (used for error reporting).
    */
   void _appendCodePoint(StringBuffer buffer, String source, int codePoint,
       int startIndex, int endIndex) {
     if (codePoint < 0 || codePoint > Character.MAX_CODE_POINT) {
       String escapeSequence = source.substring(startIndex, endIndex + 1);
       _reportErrorForCurrentToken(
           ParserErrorCode.INVALID_CODE_POINT, [escapeSequence]);
       return;
     }
     if (codePoint < Character.MAX_VALUE) {
       buffer.writeCharCode(codePoint);
     } else {
       buffer.write(Character.toChars(codePoint));
     }
   }
 
   /**
+   * Return `true` if we are positioned at the keyword 'Function' in a generic
+   * function type alias.
+   */
+  bool _atGenericFunctionTypeAfterReturnType(Token startToken) {
+    if (_tokenMatchesString(startToken, 'Function')) {
+      Token next = startToken.next;
+      if (next != null &&
+          (_tokenMatches(next, TokenType.OPEN_PAREN) ||
+              _tokenMatches(next, TokenType.LT))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
    * Clone all token starting from the given [token] up to the end of the token
    * stream, and return the first token in the new token stream.
    */
   Token _cloneTokens(Token token) {
     if (token == null) {
       return null;
     }
     token = token is CommentToken ? token.parent : token;
     Token head = new Token(TokenType.EOF, -1);
     head.setNext(head);
@@ skipping 1115 matching lines @@
   /**
    * Parse a function declaration statement. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [returnType] is the return type, or `null` if there is no return type.
    * Return the function declaration statement that was parsed.
    *
    *     functionDeclarationStatement ::=
    *         functionSignature functionBody
    */
   Statement _parseFunctionDeclarationStatementAfterReturnType(
-      CommentAndMetadata commentAndMetadata, TypeName returnType) {
+      CommentAndMetadata commentAndMetadata, TypeAnnotation returnType) {
     FunctionDeclaration declaration =
         parseFunctionDeclaration(commentAndMetadata, null, returnType);
     Token propertyKeyword = declaration.propertyKeyword;
     if (propertyKeyword != null) {
       if (propertyKeyword.keyword == Keyword.GET) {
         _reportErrorForToken(
             ParserErrorCode.GETTER_IN_FUNCTION, propertyKeyword);
       } else {
         _reportErrorForToken(
             ParserErrorCode.SETTER_IN_FUNCTION, propertyKeyword);
       }
     }
     return astFactory.functionDeclarationStatement(declaration);
   }
 
   /**
    * Parse a function type alias. The [commentAndMetadata] is the metadata to be
    * associated with the member. The [keyword] is the token representing the
    * 'typedef' keyword. Return the function type alias that was parsed.
    *
    *     functionTypeAlias ::=
    *         functionPrefix typeParameterList? formalParameterList ';'
    *
    *     functionPrefix ::=
    *         returnType? name
    */
   FunctionTypeAlias _parseFunctionTypeAlias(
       CommentAndMetadata commentAndMetadata, Token keyword) {
-    TypeName returnType = null;
+    TypeAnnotation returnType = null;
     if (hasReturnTypeInTypeAlias) {
-      returnType = parseReturnType();
+      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 112 matching lines @@
    * that was parsed.
    *
    *     functionDeclaration ::=
    *         ('external' 'static'?)? functionSignature functionBody
    *       | 'external'? functionSignature ';'
    */
   MethodDeclaration _parseMethodDeclarationAfterParameters(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
       Token staticKeyword,
-      TypeName returnType,
+      TypeAnnotation returnType,
       SimpleIdentifier name,
       TypeParameterList typeParameters,
       FormalParameterList parameters) {
     FunctionBody body = parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.MISSING_FUNCTION_BODY,
         false);
     if (externalKeyword != null) {
       if (body is! EmptyFunctionBody) {
         _reportErrorForNode(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, body);
@@ skipping 26 matching lines @@
    * parsed.
    *
    *     functionDeclaration ::=
    *         'external'? 'static'? functionSignature functionBody
    *       | 'external'? functionSignature ';'
    */
   MethodDeclaration _parseMethodDeclarationAfterReturnType(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
       Token staticKeyword,
-      TypeName returnType) {
+      TypeAnnotation returnType) {
     SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters;
     TokenType type = _currentToken.type;
     // TODO(brianwilkerson) Figure out why we care what the current token is if
     // it isn't a paren.
     if (type != TokenType.OPEN_PAREN &&
         (type == TokenType.OPEN_CURLY_BRACKET || type == TokenType.FUNCTION)) {
       _reportErrorForToken(
           ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous);
@@ skipping 41 matching lines @@
    *
    *     operatorDeclaration ::=
    *         operatorSignature (';' | functionBody)
    *
    *     operatorSignature ::=
    *         'external'? returnType? 'operator' operator formalParameterList
    */
   MethodDeclaration _parseOperatorAfterKeyword(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
-      TypeName returnType,
+      TypeAnnotation returnType,
       Token operatorKeyword) {
     if (!_currentToken.isUserDefinableOperator) {
       _reportErrorForCurrentToken(
           ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]);
     }
     SimpleIdentifier name =
         astFactory.simpleIdentifier(getAndAdvance(), isDeclaration: true);
     if (_matches(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((_tokenMatches(previous, TokenType.EQ_EQ) ||
@@ skipping 22 matching lines @@
         name,
         null,
         parameters,
         body);
   }
 
   /**
    * Parse a return type if one is given, otherwise return `null` without
    * advancing. Return the return type that was parsed.
    */
-  TypeName _parseOptionalReturnType() {
+  TypeAnnotation _parseOptionalReturnType() {
     TypeName typeComment = _parseOptionalTypeNameComment();
     if (typeComment != null) {
       return typeComment;
     }
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.VOID) {
       return astFactory.typeName(
           astFactory.simpleIdentifier(getAndAdvance()), null);
     } else if (_matchesIdentifier()) {
       Token next = _peek();
       if (keyword != Keyword.GET &&
           keyword != Keyword.SET &&
           keyword != Keyword.OPERATOR &&
           (_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 parseReturnType();
+        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 parseReturnType();
+        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 216 matching lines @@
       } else {
         strings.add(astFactory.simpleStringLiteral(
             string, computeStringValue(string.lexeme, true, true)));
       }
     } while (_matches(TokenType.STRING));
     return strings.length == 1
         ? strings[0]
         : astFactory.adjacentStrings(strings);
   }
 
+  /**
+   * Parse a type annotation, possibly superseded by a type name in a comment.
+   * Return the type name that was parsed.
+   *
+   * This method assumes that the current token is an identifier.
+   *
+   *     type ::=
+   *         qualified typeArguments?
+   */
+  TypeAnnotation _parseTypeAnnotationAfterIdentifier() {
+    TypeAnnotation type = parseTypeAnnotation(false);
+    // If this is followed by a generic method type comment, allow the comment
+    // type to replace the real type name.
+    TypeName typeFromComment = _parseOptionalTypeNameComment();
+    return typeFromComment ?? type;
+  }
+
   TypeName _parseTypeName(bool inExpression) {
     Identifier typeName;
     if (_matchesIdentifier()) {
       typeName = _parsePrefixedIdentifierUnchecked();
     } else if (_matchesKeyword(Keyword.VAR)) {
       _reportErrorForCurrentToken(ParserErrorCode.VAR_AS_TYPE_NAME);
       typeName = astFactory.simpleIdentifier(getAndAdvance());
     } else {
       typeName = createSyntheticIdentifier();
       _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TYPE_NAME);
     }
     TypeArgumentList typeArguments = _parseOptionalTypeArguments();
     Token question = null;
     if (enableNnbd && _matches(TokenType.QUESTION)) {
       if (!inExpression || !_isConditionalOperator()) {
         question = getAndAdvance();
       }
     }
     return astFactory.typeName(typeName, typeArguments, question: question);
   }
 
   /**
-   * Parse a type name. Return the type name that was parsed.
-   *
-   * This method assumes that the current token is an identifier.
-   *
-   *     type ::=
-   *         qualified typeArguments?
-   */
-  TypeName _parseTypeNameAfterIdentifier() {
-    Identifier typeName = _parsePrefixedIdentifierUnchecked();
-    TypeArgumentList typeArguments = _parseOptionalTypeArguments();
-    // 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 ?? astFactory.typeName(typeName, typeArguments);
-  }
-
-  /**
    * Parse a string literal representing a URI. Return the string literal that
    * was parsed.
    */
   StringLiteral _parseUri() {
     // TODO(brianwilkerson) Should this function also return true for valid
     // top-level keywords?
     bool isKeywordAfterUri(Token token) =>
         token.lexeme == Keyword.AS.syntax ||
         token.lexeme == _HIDE ||
         token.lexeme == _SHOW;
@@ skipping 1006 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }