Reapply "Add support for generic function type syntax, part 1"

pkg/analyzer/lib/src/dart/ast/ast.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.dart.ast.ast;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
@@ skipping 486 matching lines @@
    */
   Expression _expression;
 
   /**
    * The 'as' operator.
    */
   @override
   Token asOperator;
 
   /**
-   * The name of the type being cast to.
+   * The type being cast to.
    */
-  TypeName _type;
+  TypeAnnotation _type;
 
   /**
    * Initialize a newly created as expression.
    */
   AsExpressionImpl(
-      ExpressionImpl expression, this.asOperator, TypeNameImpl type) {
+      ExpressionImpl expression, this.asOperator, TypeAnnotationImpl type) {
     _expression = _becomeParentOf(expression);
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable<SyntacticEntity> get childEntities =>
       new ChildEntities()..add(_expression)..add(asOperator)..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
     _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 7;
 
   @override
-  TypeName get type => _type;
+  TypeAnnotation get type => _type;
 
   @override
-  void set type(TypeName name) {
-    _type = _becomeParentOf(name as AstNodeImpl);
+  void set type(TypeAnnotation type) {
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitAsExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
     _type?.accept(visitor);
@@ skipping 1011 matching lines @@
    * The token representing the 'on' keyword, or `null` if there is no 'on'
    * keyword.
    */
   @override
   Token onKeyword;
 
   /**
    * The type of exceptions caught by this catch clause, or `null` if this catch
    * clause catches every type of exception.
    */
-  TypeName _exceptionType;
+  TypeAnnotation _exceptionType;
 
   /**
    * The token representing the 'catch' keyword, or `null` if there is no
    * 'catch' keyword.
    */
   @override
   Token catchKeyword;
 
   /**
    * The left parenthesis, or `null` if there is no 'catch' keyword.
@@ skipping 32 matching lines @@
   Block _body;
 
   /**
    * Initialize a newly created catch clause. The [onKeyword] and
    * [exceptionType] can be `null` if the clause will catch all exceptions. The
    * [comma] and [stackTraceParameter] can be `null` if the stack trace
    * parameter is not defined.
    */
   CatchClauseImpl(
       this.onKeyword,
-      TypeNameImpl exceptionType,
+      TypeAnnotationImpl exceptionType,
       this.catchKeyword,
       this.leftParenthesis,
       SimpleIdentifierImpl exceptionParameter,
       this.comma,
       SimpleIdentifierImpl stackTraceParameter,
       this.rightParenthesis,
       BlockImpl body) {
     _exceptionType = _becomeParentOf(exceptionType);
     _exceptionParameter = _becomeParentOf(exceptionParameter);
     _stackTraceParameter = _becomeParentOf(stackTraceParameter);
@@ skipping 33 matching lines @@
 
   @override
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
   @override
   void set exceptionParameter(SimpleIdentifier parameter) {
     _exceptionParameter = _becomeParentOf(parameter as AstNodeImpl);
   }
 
   @override
-  TypeName get exceptionType => _exceptionType;
+  TypeAnnotation get exceptionType => _exceptionType;
 
   @override
-  void set exceptionType(TypeName exceptionType) {
+  void set exceptionType(TypeAnnotation exceptionType) {
     _exceptionType = _becomeParentOf(exceptionType as AstNodeImpl);
   }
 
   @override
   SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
 
   @override
   void set stackTraceParameter(SimpleIdentifier parameter) {
     _stackTraceParameter = _becomeParentOf(parameter as AstNodeImpl);
   }
@@ skipping 1588 matching lines @@
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   @override
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter
    * does not have a declared type.
    */
-  TypeName _type;
+  TypeAnnotation _type;
 
   /**
    * The name of the variable being declared.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [keyword] can be `null` if a type name is
    * given. The [type] must be `null` if the keyword is 'var'.
    */
   DeclaredIdentifierImpl(CommentImpl comment, List<Annotation> metadata,
-      this.keyword, TypeNameImpl type, SimpleIdentifierImpl identifier)
+      this.keyword, TypeAnnotationImpl type, SimpleIdentifierImpl identifier)
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Iterable<SyntacticEntity> get childEntities =>
       super._childEntities..add(keyword)..add(_type)..add(_identifier);
 
   @override
@@ skipping 25 matching lines @@
     _identifier = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
-  TypeName get type => _type;
+  TypeAnnotation get type => _type;
 
   @override
-  void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName as AstNodeImpl);
+  void set type(TypeAnnotation type) {
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitDeclaredIdentifier(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _type?.accept(visitor);
@@ skipping 1029 matching lines @@
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   @override
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter
    * does not have a declared type.
    */
-  TypeName _type;
+  TypeAnnotation _type;
 
   /**
    * The token representing the 'this' keyword.
    */
   @override
   Token thisKeyword;
 
   /**
    * The token representing the period.
    */
@@ skipping 18 matching lines @@
    * corresponding attribute. The [keyword] can be `null` if there is a type.
    * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
    * [parameters] can be `null` if this is not a function-typed field formal
    * parameter.
    */
   FieldFormalParameterImpl(
       CommentImpl comment,
       List<Annotation> metadata,
       this.keyword,
-      TypeNameImpl type,
+      TypeAnnotationImpl type,
       this.thisKeyword,
       this.period,
       SimpleIdentifierImpl identifier,
       TypeParameterListImpl typeParameters,
       FormalParameterListImpl parameters)
       : super(comment, metadata, identifier) {
     _type = _becomeParentOf(type);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
@@ skipping 33 matching lines @@
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
     _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
-  TypeName get type => _type;
+  TypeAnnotation get type => _type;
 
   @override
-  void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName as AstNodeImpl);
+  void set type(TypeAnnotation type) {
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
     _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
@@ skipping 558 matching lines @@
   /**
    * The token representing the 'external' keyword, or `null` if this is not an
    * external function.
    */
   @override
   Token externalKeyword;
 
   /**
    * The return type of the function, or `null` if no return type was declared.
    */
-  TypeName _returnType;
+  TypeAnnotation _returnType;
 
   /**
    * The token representing the 'get' or 'set' keyword, or `null` if this is a
    * function declaration rather than a property declaration.
    */
   @override
   Token propertyKeyword;
 
   /**
    * The function expression being wrapped.
    */
   FunctionExpression _functionExpression;
 
   /**
    * Initialize a newly created function declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the
    * function is not an external function. The [returnType] can be `null` if no
    * return type was specified. The [propertyKeyword] can be `null` if the
    * function is neither a getter or a setter.
    */
   FunctionDeclarationImpl(
       CommentImpl comment,
       List<Annotation> metadata,
       this.externalKeyword,
-      TypeNameImpl returnType,
+      TypeAnnotationImpl returnType,
       this.propertyKeyword,
       SimpleIdentifierImpl name,
       FunctionExpressionImpl functionExpression)
       : super(comment, metadata, name) {
     _returnType = _becomeParentOf(returnType);
     _functionExpression = _becomeParentOf(functionExpression);
   }
 
   @override
   Iterable<SyntacticEntity> get childEntities => super._childEntities
@@ skipping 31 matching lines @@
     _functionExpression = _becomeParentOf(functionExpression as AstNodeImpl);
   }
 
   @override
   bool get isGetter => propertyKeyword?.keyword == Keyword.GET;
 
   @override
   bool get isSetter => propertyKeyword?.keyword == Keyword.SET;
 
   @override
-  TypeName get returnType => _returnType;
+  TypeAnnotation get returnType => _returnType;
 
   @override
-  void set returnType(TypeName returnType) {
-    _returnType = _becomeParentOf(returnType as AstNodeImpl);
+  void set returnType(TypeAnnotation type) {
+    _returnType = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
     _name?.accept(visitor);
     _functionExpression?.accept(visitor);
   }
 }
 
 /**
  * A [FunctionDeclaration] used as a statement.
  */
 class FunctionDeclarationStatementImpl extends StatementImpl
     implements FunctionDeclarationStatement {
   /**
    * The function declaration being wrapped.
    */
   FunctionDeclaration _functionDeclaration;
 
   /**
    * Initialize a newly created function declaration statement.
    */
-  FunctionDeclarationStatementImpl(FunctionDeclaration functionDeclaration) {
-    _functionDeclaration = _becomeParentOf(functionDeclaration as AstNodeImpl);
+  FunctionDeclarationStatementImpl(
+      FunctionDeclarationImpl functionDeclaration) {
+    _functionDeclaration = _becomeParentOf(functionDeclaration);
   }
 
   @override
   Token get beginToken => _functionDeclaration.beginToken;
 
   @override
   Iterable<SyntacticEntity> get childEntities =>
       new ChildEntities()..add(_functionDeclaration);
 
   @override
@@ skipping 217 matching lines @@
  *        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  *
  *    functionPrefix ::=
  *        [TypeName]? [SimpleIdentifier]
  */
 class FunctionTypeAliasImpl extends TypeAliasImpl implements FunctionTypeAlias {
   /**
    * The name of the return type of the function type being defined, or `null`
    * if no return type was given.
    */
-  TypeName _returnType;
+  TypeAnnotation _returnType;
 
   /**
    * The type parameters for the function type, or `null` if the function type
    * does not have any type parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The parameters associated with the function type.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created function type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified. The [typeParameters] can be `null` if the function has no
    * type parameters.
    */
   FunctionTypeAliasImpl(
       CommentImpl comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeNameImpl returnType,
+      TypeAnnotationImpl returnType,
       SimpleIdentifierImpl name,
       TypeParameterListImpl typeParameters,
       FormalParameterListImpl parameters,
       Token semicolon)
       : super(comment, metadata, keyword, name, semicolon) {
     _returnType = _becomeParentOf(returnType);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
@@ skipping 12 matching lines @@
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
     _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
-  TypeName get returnType => _returnType;
+  TypeAnnotation get returnType => _returnType;
 
   @override
-  void set returnType(TypeName typeName) {
-    _returnType = _becomeParentOf(typeName as AstNodeImpl);
+  void set returnType(TypeAnnotation type) {
+    _returnType = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
     _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
@@ skipping 16 matching lines @@
  *
  *    functionSignature ::=
  *        [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  */
 class FunctionTypedFormalParameterImpl extends NormalFormalParameterImpl
     implements FunctionTypedFormalParameter {
   /**
    * The return type of the function, or `null` if the function does not have a
    * return type.
    */
-  TypeName _returnType;
+  TypeAnnotation _returnType;
 
   /**
    * The type parameters associated with the function, or `null` if the function
    * is not a generic function.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The parameters of the function-typed parameter.
    */
   FormalParameterList _parameters;
 
   @override
   Token question;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
   FunctionTypedFormalParameterImpl(
       CommentImpl comment,
       List<Annotation> metadata,
-      TypeNameImpl returnType,
+      TypeAnnotationImpl returnType,
       SimpleIdentifierImpl identifier,
       TypeParameterListImpl typeParameters,
       FormalParameterListImpl parameters,
       this.question)
       : super(comment, metadata, identifier) {
     _returnType = _becomeParentOf(returnType);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
@@ skipping 20 matching lines @@
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
     _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
-  TypeName get returnType => _returnType;
+  TypeAnnotation get returnType => _returnType;
 
   @override
-  void set returnType(TypeName type) {
+  void set returnType(TypeAnnotation type) {
     _returnType = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
     _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionTypedFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
     identifier?.accept(visitor);
     _typeParameters?.accept(visitor);
     _parameters?.accept(visitor);
   }
 }
 
 /**
+ * An anonymous function type.
+ *
+ *    functionType ::=
+ *        [TypeAnnotation]? 'Function' [TypeParameterList]? [FormalParameterList]
+ *
+ * where the FormalParameterList is being used to represent the following
+ * grammar, despite the fact that FormalParameterList can represent a much
+ * larger grammar than the one below. This is done in order to simplify the
+ * implementation.
+ *
+ *    parameterTypeList ::=
+ *        () |
+ *        ( normalParameterTypes ,? ) |
+ *        ( normalParameterTypes , optionalParameterTypes ) |
+ *        ( optionalParameterTypes )
+ *    namedParameterTypes ::=
+ *        { namedParameterType (, namedParameterType)* ,? }
+ *    namedParameterType ::=
+ *        [TypeAnnotation]? [SimpleIdentifier]
+ *    normalParameterTypes ::=
+ *        normalParameterType (, normalParameterType)*
+ *    normalParameterType ::=
+ *        [TypeAnnotation] [SimpleIdentifier]?
+ *    optionalParameterTypes ::=
+ *        optionalPositionalParameterTypes | namedParameterTypes
+ *    optionalPositionalParameterTypes ::=
+ *        [ normalParameterTypes ,? ]
+ */
+class GenericFunctionTypeImpl extends TypeAnnotationImpl
+    implements GenericFunctionType {
+  /**
+   * The name of the return type of the function type being defined, or
+   * `null` if no return type was given.
+   */
+  TypeAnnotation _returnType;
+
+  @override
+  Token functionKeyword;
+
+  /**
+   * The type parameters for the function type, or `null` if the function type
+   * does not have any type parameters.
+   */
+  TypeParameterList _typeParameters;
+
+  /**
+   * The parameters associated with the function type.
+   */
+  FormalParameterList _parameters;
+
+  /**
+   * Initialize a newly created generic function type.
+   */
+  GenericFunctionTypeImpl(
+      TypeAnnotationImpl returnType,
+      this.functionKeyword,
+      TypeParameterListImpl typeParameters,
+      FormalParameterListImpl parameters) {
+    _returnType = _becomeParentOf(returnType);
+    _typeParameters = _becomeParentOf(typeParameters);
+    _parameters = _becomeParentOf(parameters);
+  }
+
+  @override
+  Token get beginToken =>
+      _returnType == null ? functionKeyword : _returnType.beginToken;
+
+  @override
+  Iterable<SyntacticEntity> get childEntities => new ChildEntities()
+    ..add(_returnType)
+    ..add(functionKeyword)
+    ..add(_typeParameters)
+    ..add(_parameters);
+
+  @override
+  Token get endToken => _parameters.endToken;
+
+  @override
+  FormalParameterList get parameters => _parameters;
+
+  @override
+  void set parameters(FormalParameterList parameters) {
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
+  }
+
+  @override
+  TypeAnnotation get returnType => _returnType;
+
+  @override
+  void set returnType(TypeAnnotation type) {
+    _returnType = _becomeParentOf(type as AstNodeImpl);
+  }
+
+  @override
+  DartType get type => null;
+
+  /**
+   * Return the type parameters for the function type, or `null` if the function
+   * type does not have any type parameters.
+   */
+  TypeParameterList get typeParameters => _typeParameters;
+
+  /**
+   * Set the type parameters for the function type to the given list of
+   * [typeParameters].
+   */
+  void set typeParameters(TypeParameterList typeParameters) {
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
+  }
+
+  // TODO: implement type
+  @override
+  dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) {
+    return visitor.visitGenericFunctionType(this);
+  }
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    _returnType?.accept(visitor);
+    _typeParameters?.accept(visitor);
+    _parameters?.accept(visitor);
+  }
+}
+
+/**
+ * A generic type alias.
+ *
+ *    functionTypeAlias ::=
+ *        metadata 'typedef' [SimpleIdentifier] [TypeParameterList]? = [FunctionType] ';'
+ */
+class GenericTypeAliasImpl extends TypeAliasImpl implements GenericTypeAlias {
+  /**
+   * The type parameters for the function type, or `null` if the function
+   * type does not have any type parameters.
+   */
+  TypeParameterList _typeParameters;
+
+  @override
+  Token equals;
+
+  /**
+   * The type of function being defined by the alias.
+   */
+  GenericFunctionType _functionType;
+
+  /**
+   * Returns a newly created generic type alias. Either or both of the
+   * [comment] and [metadata] can be `null` if the variable list does not have
+   * the corresponding attribute. The [typeParameters] can be `null` if there
+   * are no type parameters.
+   */
+  GenericTypeAliasImpl(
+      Comment comment,
+      List<Annotation> metadata,
+      Token typedefToken,
+      SimpleIdentifier name,
+      TypeParameterListImpl typeParameters,
+      this.equals,
+      GenericFunctionTypeImpl functionType,
+      Token semicolon)
+      : super(comment, metadata, typedefToken, name, semicolon) {
+    _typeParameters = _becomeParentOf(typeParameters);
+    _functionType = _becomeParentOf(functionType);
+  }
+
+  @override
+  Iterable<SyntacticEntity> get childEntities => new ChildEntities()
+    ..addAll(metadata)
+    ..add(typedefKeyword)
+    ..add(name)
+    ..add(_typeParameters)
+    ..add(equals)
+    ..add(_functionType);
+  @override
+  Element get element => null;
+
+  @override
+  GenericFunctionType get functionType => _functionType;
+
+  @override
+  void set functionType(GenericFunctionType functionType) {
+    _functionType = _becomeParentOf(functionType as AstNodeImpl);
+  }
+
+  @override
+  TypeParameterList get typeParameters => _typeParameters;
+
+  @override
+  void set typeParameters(TypeParameterList typeParameters) {
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
+  }
+
+  @override
+  dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) {
+    return visitor.visitGenericTypeAlias(this);
+  }
+
+  // TODO: implement element
+  @override
+  void visitChildren(AstVisitor visitor) {
+    super.visitChildren(visitor);
+    name?.accept(visitor);
+    _typeParameters?.accept(visitor);
+    _functionType?.accept(visitor);
+  }
+}
+
+/**
  * A combinator that restricts the names being imported to those that are not in
  * a given list.
  *
  *    hideCombinator ::=
  *        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  */
 class HideCombinatorImpl extends CombinatorImpl implements HideCombinator {
   /**
    * The list of names from the library that are hidden by this combinator.
    */
@@ skipping 879 matching lines @@
 
   /**
    * The not operator, or `null` if the sense of the test is not negated.
    */
   @override
   Token notOperator;
 
   /**
    * The name of the type being tested for.
    */
-  TypeName _type;
+  TypeAnnotation _type;
 
   /**
    * Initialize a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
   IsExpressionImpl(ExpressionImpl expression, this.isOperator, this.notOperator,
-      TypeNameImpl type) {
+      TypeAnnotationImpl type) {
     _expression = _becomeParentOf(expression);
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable<SyntacticEntity> get childEntities => new ChildEntities()
     ..add(_expression)
     ..add(isOperator)
     ..add(notOperator)
     ..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
     _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 7;
 
   @override
-  TypeName get type => _type;
+  TypeAnnotation get type => _type;
 
   @override
-  void set type(TypeName name) {
-    _type = _becomeParentOf(name as AstNodeImpl);
+  void set type(TypeAnnotation type) {
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitIsExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
     _type?.accept(visitor);
@@ skipping 535 matching lines @@
   /**
    * The token representing the 'abstract' or 'static' keyword, or `null` if
    * neither modifier was specified.
    */
   @override
   Token modifierKeyword;
 
   /**
    * The return type of the method, or `null` if no return type was declared.
    */
-  TypeName _returnType;
+  TypeAnnotation _returnType;
 
   /**
    * The token representing the 'get' or 'set' keyword, or `null` if this is a
    * method declaration rather than a property declaration.
    */
   @override
   Token propertyKeyword;
 
   /**
    * The token representing the 'operator' keyword, or `null` if this method
@@ skipping 33 matching lines @@
    * type was specified. The [propertyKeyword] can be `null` if the method is
    * neither a getter or a setter. The [operatorKeyword] can be `null` if the
    * method does not implement an operator. The [parameters] must be `null` if
    * this method declares a getter.
    */
   MethodDeclarationImpl(
       CommentImpl comment,
       List<Annotation> metadata,
       this.externalKeyword,
       this.modifierKeyword,
-      TypeNameImpl returnType,
+      TypeAnnotationImpl returnType,
       this.propertyKeyword,
       this.operatorKeyword,
       SimpleIdentifierImpl name,
       TypeParameterListImpl typeParameters,
       FormalParameterListImpl parameters,
       FunctionBodyImpl body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
@@ skipping 78 matching lines @@
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
     _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
-  TypeName get returnType => _returnType;
+  TypeAnnotation get returnType => _returnType;
 
   @override
-  void set returnType(TypeName typeName) {
-    _returnType = _becomeParentOf(typeName as AstNodeImpl);
+  void set returnType(TypeAnnotation type) {
+    _returnType = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
     _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
@@ skipping 1689 matching lines @@
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter
    * does not have a declared type.
    */
-  TypeName _type;
+  TypeAnnotation _type;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
   SimpleFormalParameterImpl(CommentImpl comment, List<Annotation> metadata,
-      this.keyword, TypeNameImpl type, SimpleIdentifierImpl identifier)
+      this.keyword, TypeAnnotationImpl type, SimpleIdentifierImpl identifier)
       : super(comment, metadata, identifier) {
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken {
     NodeList<Annotation> metadata = this.metadata;
     if (!metadata.isEmpty) {
       return metadata.beginToken;
     } else if (keyword != null) {
@@ skipping 11 matching lines @@
   @override
   Token get endToken => identifier.endToken;
 
   @override
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
-  TypeName get type => _type;
+  TypeAnnotation get type => _type;
 
   @override
-  void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName as AstNodeImpl);
+  void set type(TypeAnnotation type) {
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitSimpleFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _type?.accept(visitor);
@@ skipping 1242 matching lines @@
       : super(comment, metadata, name);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => typedefKeyword;
 }
 
 /**
+ * A type annotation.
+ *
+ *    type ::=
+ *        [NamedType]
+ *      | [GenericFunctionType]
+ */
+abstract class TypeAnnotationImpl extends AstNodeImpl
+    implements TypeAnnotation {}
+
+/**
  * A list of type arguments.
  *
  *    typeArguments ::=
  *        '<' typeName (',' typeName)* '>'
  */
 class TypeArgumentListImpl extends AstNodeImpl implements TypeArgumentList {
   /**
    * The left bracket.
    */
   Token leftBracket;
 
   /**
    * The type arguments associated with the type.
    */
-  NodeList<TypeName> _arguments;
+  NodeList<TypeAnnotation> _arguments;
 
   /**
    * The right bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created list of type arguments.
    */
   TypeArgumentListImpl(
-      this.leftBracket, List<TypeName> arguments, this.rightBracket) {
-    _arguments = new NodeListImpl<TypeName>(this, arguments);
+      this.leftBracket, List<TypeAnnotation> arguments, this.rightBracket) {
+    _arguments = new NodeListImpl<TypeAnnotation>(this, arguments);
   }
 
   @override
-  NodeList<TypeName> get arguments => _arguments;
+  NodeList<TypeAnnotation> get arguments => _arguments;
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   // TODO(paulberry): Add commas.
   Iterable<SyntacticEntity> get childEntities => new ChildEntities()
     ..add(leftBracket)
     ..addAll(_arguments)
     ..add(rightBracket);
@@ skipping 56 matching lines @@
     _typeArguments?.accept(visitor);
   }
 }
 
 /**
  * The name of a type, which can optionally include type arguments.
  *
  *    typeName ::=
  *        [Identifier] typeArguments?
  */
-class TypeNameImpl extends AstNodeImpl implements TypeName {
+class TypeNameImpl extends TypeAnnotationImpl implements TypeName {
   /**
    * The name of the type.
    */
   Identifier _name;
 
   /**
    * The type arguments associated with the type, or `null` if there are no type
    * arguments.
    */
   TypeArgumentList _typeArguments;
@@ skipping 85 matching lines @@
   /**
    * The token representing the 'extends' keyword, or `null` if there is no
    * explicit upper bound.
    */
   Token extendsKeyword;
 
   /**
    * The name of the upper bound for legal arguments, or `null` if there is no
    * explicit upper bound.
    */
-  TypeName _bound;
+  TypeAnnotation _bound;
 
   /**
    * Initialize a newly created type parameter. Either or both of the [comment]
    * and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [extendsKeyword] and [bound] can be `null` if
    * the parameter does not have an upper bound.
    */
   TypeParameterImpl(CommentImpl comment, List<Annotation> metadata,
-      SimpleIdentifierImpl name, this.extendsKeyword, TypeNameImpl bound)
+      SimpleIdentifierImpl name, this.extendsKeyword, TypeAnnotationImpl bound)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
     _bound = _becomeParentOf(bound);
   }
 
   @override
-  TypeName get bound => _bound;
+  TypeAnnotation get bound => _bound;
 
   @override
-  void set bound(TypeName typeName) {
-    _bound = _becomeParentOf(typeName as AstNodeImpl);
+  void set bound(TypeAnnotation type) {
+    _bound = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   Iterable<SyntacticEntity> get childEntities =>
       super._childEntities..add(_name)..add(extendsKeyword)..add(_bound);
 
   @override
   TypeParameterElement get element =>
       _name?.staticElement as TypeParameterElement;
 
@@ skipping 337 matching lines @@
     implements VariableDeclarationList {
   /**
    * The token representing the 'final', 'const' or 'var' keyword, or `null` if
    * no keyword was included.
    */
   Token keyword;
 
   /**
    * The type of the variables being declared, or `null` if no type was provided.
    */
-  TypeName _type;
+  TypeAnnotation _type;
 
   /**
    * A list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> _variables;
 
   /**
    * Initialize a newly created variable declaration list. Either or both of the
    * [comment] and [metadata] can be `null` if the variable list does not have
    * the corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
-  VariableDeclarationListImpl(CommentImpl comment, List<Annotation> metadata,
-      this.keyword, TypeNameImpl type, List<VariableDeclaration> variables)
+  VariableDeclarationListImpl(
+      CommentImpl comment,
+      List<Annotation> metadata,
+      this.keyword,
+      TypeAnnotationImpl type,
+      List<VariableDeclaration> variables)
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
     _variables = new NodeListImpl<VariableDeclaration>(this, variables);
   }
 
   @override
   // TODO(paulberry): include commas.
   Iterable<SyntacticEntity> get childEntities => super._childEntities
     ..add(keyword)
     ..add(_type)
@@ skipping 12 matching lines @@
     return _variables.beginToken;
   }
 
   @override
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
-  TypeName get type => _type;
+  TypeAnnotation get type => _type;
 
   @override
-  void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName as AstNodeImpl);
+  void set type(TypeAnnotation type) {
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   NodeList<VariableDeclaration> get variables => _variables;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitVariableDeclarationList(this);
 
   @override
@@ skipping 259 matching lines @@
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
 }