Add support for generic function type syntax, part 1

pkg/analyzer/lib/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.
 
 /**
  * Defines the AST model. The AST (Abstract Syntax Tree) model describes the
  * syntactic (as opposed to semantic) structure of Dart code. The semantic
  * structure of the code is modeled by the
  * [element model](../element/element.dart).
  *
@@ skipping 236 matching lines @@
   /**
    * Set the right parenthesis to the given [token].
    */
   void set rightParenthesis(Token token);
 }
 
 /**
  * An as expression.
  *
  *    asExpression ::=
- *        [Expression] 'as' [TypeName]
+ *        [Expression] 'as' [TypeAnnotation]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AsExpression extends Expression {
   /**
    * Return the 'as' operator.
    */
   Token get asOperator;
 
   /**
    * Set the 'as' operator to the given [token].
    */
   void set asOperator(Token token);
 
   /**
    * Return the expression used to compute the value being cast.
    */
   Expression get expression;
 
   /**
    * Set the expression used to compute the value being cast to the given
    * [expression].
    */
   void set expression(Expression expression);
 
   /**
-   * Return the name of the type being cast to.
+   * Return the type being cast to.
    */
-  TypeName get type;
+  TypeAnnotation get type;
 
   /**
-   * Set the name of the type being cast to to the given [name].
+   * Set the type being cast to to the given [type].
    */
-  void set type(TypeName name);
+  void set type(TypeAnnotation type);
 }
 
 /**
  * An assert in the initializer list of a constructor.
  *
  *    assertInitializer ::=
  *        'assert' '(' [Expression] (',' [Expression])? ')'
  *
  * Clients may not extend, implement or mix-in this class.
  */
@@ skipping 350 matching lines @@
   R visitFunctionDeclarationStatement(FunctionDeclarationStatement node);
 
   R visitFunctionExpression(FunctionExpression node);
 
   R visitFunctionExpressionInvocation(FunctionExpressionInvocation node);
 
   R visitFunctionTypeAlias(FunctionTypeAlias functionTypeAlias);
 
   R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node);
 
+  R visitGenericFunctionType(GenericFunctionType node);
+
+  R visitGenericTypeAlias(GenericTypeAlias node);
+
   R visitHideCombinator(HideCombinator node);
 
   R visitIfStatement(IfStatement node);
 
   R visitImplementsClause(ImplementsClause node);
 
   R visitImportDirective(ImportDirective node);
 
   R visitIndexExpression(IndexExpression node);
 
@@ skipping 418 matching lines @@
   /**
    * Set the parameter whose value will be the exception that was thrown to the
    * given [parameter].
    */
   void set exceptionParameter(SimpleIdentifier parameter);
 
   /**
    * Return the type of exceptions caught by this catch clause, or `null` if
    * this catch clause catches every type of exception.
    */
-  TypeName get exceptionType;
+  TypeAnnotation get exceptionType;
 
   /**
    * Set the type of exceptions caught by this catch clause to the given
    * [exceptionType].
    */
-  void set exceptionType(TypeName exceptionType);
+  void set exceptionType(TypeAnnotation exceptionType);
 
   /**
    * Return the left parenthesis, or `null` if there is no 'catch' keyword.
    */
   Token get leftParenthesis;
 
   /**
    * Set the left parenthesis to the given [token].
    */
   void set leftParenthesis(Token token);
@@ skipping 1063 matching lines @@
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to
    * the given [token].
    */
   void set keyword(Token token);
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the
    * parameter does not have a declared type.
    */
-  TypeName get type;
+  TypeAnnotation get type;
 
   /**
-   * Set the name of the declared type of the parameter to the given [typeName].
+   * Set the declared type of the parameter to the given [type].
    */
-  void set type(TypeName typeName);
+  void set type(TypeAnnotation type);
 }
 
 /**
  * A formal parameter with a default value. There are two kinds of parameters
  * that are both represented by this class: named formal parameters and
  * positional formal parameters.
  *
  *    defaultFormalParameter ::=
  *        [NormalFormalParameter] ('=' [Expression])?
  *
@@ skipping 576 matching lines @@
   /**
    * Set the token representing the 'static' keyword to the given [token].
    */
   void set staticKeyword(Token token);
 }
 
 /**
  * A field formal parameter.
  *
  *    fieldFormalParameter ::=
- *        ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])?
+ *        ('final' [TypeAnnotation] | 'const' [TypeAnnotation] | 'var' | [TypeAnnotation])?
  *        'this' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FieldFormalParameter extends NormalFormalParameter {
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword,
    * or `null` if no keyword was used.
    */
   Token get keyword;
@@ skipping 30 matching lines @@
    * Return the token representing the 'this' keyword.
    */
   Token get thisKeyword;
 
   /**
    * Set the token representing the 'this' keyword to the given [token].
    */
   void set thisKeyword(Token token);
 
   /**
-   * Return the name of the declared type of the parameter, or `null` if the
-   * parameter does not have a declared type. Note that if this is a
-   * function-typed field formal parameter this is the return type of the
-   * function.
+   * Return the declared type of the parameter, or `null` if the parameter does
+   * not have a declared type. Note that if this is a function-typed field
+   * formal parameter this is the return type of the function.
    */
-  TypeName get type;
+  TypeAnnotation get type;
 
   /**
-   * Set the name of the declared type of the parameter to the given [typeName].
+   * Set the declared type of the parameter to the given [type].
    */
-  void set type(TypeName typeName);
+  void set type(TypeAnnotation type);
 
   /**
    * Return the type parameters associated with this method, or `null` if this
    * method is not a generic method.
    */
   TypeParameterList get typeParameters;
 
   /**
    * Set the type parameters associated with this method to the given
    * [typeParameters].
@@ skipping 477 matching lines @@
 
   /**
    * Set the token representing the 'get' or 'set' keyword to the given [token].
    */
   void set propertyKeyword(Token token);
 
   /**
    * Return the return type of the function, or `null` if no return type was
    * declared.
    */
-  TypeName get returnType;
+  TypeAnnotation get returnType;
 
   /**
-   * Set the return type of the function to the given [returnType].
+   * Set the return type of the function to the given [type].
    */
-  void set returnType(TypeName returnType);
+  void set returnType(TypeAnnotation type);
 }
 
 /**
  * A [FunctionDeclaration] used as a statement.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionDeclarationStatement extends Statement {
   /**
    * Return the function declaration being wrapped.
@@ skipping 132 matching lines @@
   void set typeArguments(TypeArgumentList typeArguments);
 }
 
 /**
  * A function type alias.
  *
  *    functionTypeAlias ::=
  *        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  *
  *    functionPrefix ::=
- *        [TypeName]? [SimpleIdentifier]
+ *        [TypeAnnotation]? [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionTypeAlias extends TypeAlias {
   /**
    * Return the parameters associated with the function type.
    */
   FormalParameterList get parameters;
 
   /**
    * Set the parameters associated with the function type to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters);
 
   /**
-   * Return the name of the return type of the function type being defined, or
-   * `null` if no return type was given.
+   * Return the return type of the function type being defined, or `null` if no
+   * return type was given.
    */
-  TypeName get returnType;
+  TypeAnnotation get returnType;
 
   /**
-   * Set the name of the return type of the function type being defined to the
-   * given [typeName].
+   * Set the return type of the function type being defined to the given [type].
    */
-  void set returnType(TypeName typeName);
+  void set returnType(TypeAnnotation type);
 
   /**
    * Return the type parameters for the function type, or `null` if the function
    * type does not have any type parameters.
    */
   TypeParameterList get typeParameters;
 
   /**
    * Set the type parameters for the function type to the given list of
    * [typeParameters].
    */
   void set typeParameters(TypeParameterList typeParameters);
 }
 
 /**
  * A function-typed formal parameter.
  *
  *    functionSignature ::=
- *        [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
+ *        [TypeAnnotation]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionTypedFormalParameter extends NormalFormalParameter {
   /**
    * Return the parameters of the function-typed parameter.
    */
   FormalParameterList get parameters;
 
   /**
@@ skipping 11 matching lines @@
   /**
    * Return the question mark marking this as a nullable type to the given
    * [question].
    */
   void set question(Token question);
 
   /**
    * Return the return type of the function, or `null` if the function does not
    * have a return type.
    */
-  TypeName get returnType;
+  TypeAnnotation get returnType;
 
   /**
    * Set the return type of the function to the given [type].
    */
-  void set returnType(TypeName type);
+  void set returnType(TypeAnnotation type);
 
   /**
    * Return the type parameters associated with this function, or `null` if
    * this function is not a generic function.
    */
   TypeParameterList get typeParameters;
 
   /**
    * Set the type parameters associated with this method to the given
    * [typeParameters].
    */
   void set typeParameters(TypeParameterList typeParameters);
 }
 
 /**
+ * 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 ,? ]
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+abstract class GenericFunctionType extends TypeAnnotation {
+  /**
+   * Return the keyword 'Function'.
+   */
+  Token get functionKeyword;
+
+  /**
+   * Set the keyword 'Function' to the given [token].
+   */
+  void set functionKeyword(Token token);
+
+  /**
+   * Return the parameters associated with the function type.
+   */
+  FormalParameterList get parameters;
+
+  /**
+   * Set the parameters associated with the function type to the given list of
+   * [parameters].
+   */
+  void set parameters(FormalParameterList parameters);
+
+  /**
+   * Return the return type of the function type being defined, or `null` if
+   * no return type was given.
+   */
+  TypeAnnotation get returnType;
+
+  /**
+   * Set the return type of the function type being defined to the given[type].
+   */
+  void set returnType(TypeAnnotation type);
+
+  /**
+   * Return the type parameters for the function type, or `null` if the function
+   * type does not have any type parameters.
+   */
+  TypeParameterList get typeParameters;
+
+  /**
+   * Set the type parameters for the function type to the given list of
+   * [typeParameters].
+   */
+  void set typeParameters(TypeParameterList typeParameters);
+}
+
+/**
+ * A generic type alias.
+ *
+ *    functionTypeAlias ::=
+ *        metadata 'typedef' [SimpleIdentifier] [TypeParameterList]? = [FunctionType] ';'
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+abstract class GenericTypeAlias extends TypeAlias {
+  /**
+     * Return the equal sign separating the name being defined from the function
+     * type.
+     */
+  Token get equals;
+
+  /**
+     * Set the equal sign separating the name being defined from the function type
+     * to the given [token].
+     */
+  void set equals(Token token);
+
+  /**
+     * Return the type of function being defined by the alias.
+     */
+  GenericFunctionType get functionType;
+
+  /**
+     * Set the type of function being defined by the alias to the given
+     * [functionType].
+     */
+  void set functionType(GenericFunctionType functionType);
+
+  /**
+     * Return the type parameters for the function type, or `null` if the function
+     * type does not have any type parameters.
+     */
+  TypeParameterList get typeParameters;
+
+  /**
+     * Set the type parameters for the function type to the given list of
+     * [typeParameters].
+     */
+  void set typeParameters(TypeParameterList typeParameters);
+}
+
+/**
  * A combinator that restricts the names being imported to those that are not in
  * a given list.
  *
  *    hideCombinator ::=
  *        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class HideCombinator extends Combinator {
   /**
@@ skipping 679 matching lines @@
    * Return the type arguments to be applied to the method being invoked, or
    * `null` if no type arguments were provided.
    */
   TypeArgumentList get typeArguments;
 }
 
 /**
  * An is expression.
  *
  *    isExpression ::=
- *        [Expression] 'is' '!'? [TypeName]
+ *        [Expression] 'is' '!'? [TypeAnnotation]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IsExpression extends Expression {
   /**
    * Return the expression used to compute the value whose type is being tested.
    */
   Expression get expression;
 
   /**
@@ skipping 16 matching lines @@
    * Return the not operator, or `null` if the sense of the test is not negated.
    */
   Token get notOperator;
 
   /**
    * Set the not operator to the given [token].
    */
   void set notOperator(Token token);
 
   /**
-   * Return the name of the type being tested for.
+   * Return the type being tested for.
    */
-  TypeName get type;
+  TypeAnnotation get type;
 
   /**
-   * Set the name of the type being tested for to the given [name].
+   * Set the type being tested for to the given [type].
    */
-  void set type(TypeName name);
+  void set type(TypeAnnotation type);
 }
 
 /**
  * A label on either a [LabeledStatement] or a [NamedExpression].
  *
  *    label ::=
  *        [SimpleIdentifier] ':'
  *
  * Clients may not extend, implement or mix-in this class.
  */
@@ skipping 98 matching lines @@
   /**
    * Return the components of the identifier.
    */
   NodeList<SimpleIdentifier> get components;
 }
 
 /**
  * A list literal.
  *
  *    listLiteral ::=
- *        'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
+ *        'const'? ('<' [TypeAnnotation] '>')? '[' ([Expression] ','?)? ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ListLiteral extends TypedLiteral {
   /**
    * Return the expressions used to compute the elements of the list.
    */
   NodeList<Expression> get elements;
 
   /**
@@ skipping 30 matching lines @@
  *      | [StringLiteral]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Literal extends Expression {}
 
 /**
  * A literal map.
  *
  *    mapLiteral ::=
- *        'const'? ('<' [TypeName] (',' [TypeName])* '>')?
+ *        'const'? ('<' [TypeAnnotation] (',' [TypeAnnotation])* '>')?
  *        '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapLiteral extends TypedLiteral {
   /**
    * Return the entries in the map.
    */
   NodeList<MapLiteralEntry> get entries;
 
@@ skipping 181 matching lines @@
 
   /**
    * Set the token representing the 'get' or 'set' keyword to the given [token].
    */
   void set propertyKeyword(Token token);
 
   /**
    * Return the return type of the method, or `null` if no return type was
    * declared.
    */
-  TypeName get returnType;
+  TypeAnnotation get returnType;
 
   /**
-   * Set the return type of the method to the given [typeName].
+   * Set the return type of the method to the given [type].
    */
-  void set returnType(TypeName typeName);
+  void set returnType(TypeAnnotation type);
 
   /**
    * Return the type parameters associated with this method, or `null` if this
    * method is not a generic method.
    */
   TypeParameterList get typeParameters;
 
   /**
    * Set the type parameters associated with this method to the given
    * [typeParameters].
@@ skipping 891 matching lines @@
    * Return the list of names from the library that are made visible by this
    * combinator.
    */
   NodeList<SimpleIdentifier> get shownNames;
 }
 
 /**
  * A simple formal parameter.
  *
  *    simpleFormalParameter ::=
- *        ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
+ *        ('final' [TypeAnnotation] | 'var' | [TypeAnnotation])? [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleFormalParameter extends NormalFormalParameter {
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword,
    * or `null` if no keyword was used.
    */
   Token get keyword;
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to
    * the given [token].
    */
   void set keyword(Token token);
 
   /**
-   * Return the name of the declared type of the parameter, or `null` if the
-   * parameter does not have a declared type.
+   * Return the declared type of the parameter, or `null` if the parameter does
+   * not have a declared type.
    */
-  TypeName get type;
+  TypeAnnotation get type;
 
   /**
-   * Set the name of the declared type of the parameter to the given [typeName].
+   * Set the declared type of the parameter to the given [type].
    */
-  void set type(TypeName typeName);
+  void set type(TypeAnnotation type);
 }
 
 /**
  * A simple identifier.
  *
  *    simpleIdentifier ::=
  *        initialCharacter internalCharacter*
  *
  *    initialCharacter ::= '_' | '$' | letter
  *
@@ skipping 646 matching lines @@
    */
   Token get typedefKeyword;
 
   /**
    * Set the token representing the 'typedef' keyword to the given [token].
    */
   void set typedefKeyword(Token token);
 }
 
 /**
+ * A type annotation.
+ *
+ *    type ::=
+ *        [NamedType]
+ *      | [GenericFunctionType]
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+abstract class TypeAnnotation extends AstNode {
+  /**
+   * Return the type being named, or `null` if the AST structure has not been
+   * resolved.
+   */
+  DartType get type;
+}
+
+/**
  * A list of type arguments.
  *
  *    typeArguments ::=
  *        '<' typeName (',' typeName)* '>'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeArgumentList extends AstNode {
   /**
    * Return the type arguments associated with the type.
    */
-  NodeList<TypeName> get arguments;
+  NodeList<TypeAnnotation> get arguments;
 
   /**
    * Return the left bracket.
    */
   Token get leftBracket;
 
   /**
    * Set the left bracket to the given [token].
    */
   void set leftBracket(Token token);
@@ skipping 44 matching lines @@
 }
 
 /**
  * The name of a type, which can optionally include type arguments.
  *
  *    typeName ::=
  *        [Identifier] typeArguments?
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class TypeName extends AstNode {
+abstract class TypeName extends TypeAnnotation {
   /**
    * Return `true` if this type is a deferred type.
    *
    * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
    * </i>p.T</i> where <i>p</i> is a deferred prefix.
    */
   bool get isDeferred;
 
   /**
    * Return the name of the type.
@@ skipping 11 matching lines @@
    */
   Token get question;
 
   /**
    * Return the question mark marking this as a nullable type to the given
    * [question].
    */
   void set question(Token question);
 
   /**
-   * Return the type being named, or `null` if the AST structure has not been
-   * resolved.
-   */
-  DartType get type;
-
-  /**
    * Set the type being named to the given [type].
    */
   void set type(DartType type);
 
   /**
    * Return the type arguments associated with the type, or `null` if there are
    * no type arguments.
    */
   TypeArgumentList get typeArguments;
 
   /**
    * Set the type arguments associated with the type to the given
    * [typeArguments].
    */
   void set typeArguments(TypeArgumentList typeArguments);
 }
 
 /**
  * A type parameter.
  *
  *    typeParameter ::=
- *        [SimpleIdentifier] ('extends' [TypeName])?
+ *        [SimpleIdentifier] ('extends' [TypeAnnotation])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeParameter extends Declaration {
   /**
-   * Return the name of the upper bound for legal arguments, or `null` if there
-   * is no explicit upper bound.
+   * Return the upper bound for legal arguments, or `null` if there is no
+   * explicit upper bound.
    */
-  TypeName get bound;
+  TypeAnnotation get bound;
 
   /**
-   * Set the name of the upper bound for legal arguments to the given
-   * [typeName].
+   * Set the upper bound for legal arguments to the given [type].
    */
-  void set bound(TypeName typeName);
+  void set bound(TypeAnnotation type);
 
   /**
    * Return the token representing the 'extends' keyword, or `null` if there is
    * no explicit upper bound.
    */
   Token get extendsKeyword;
 
   /**
    * Set the token representing the 'extends' keyword to the given [token].
    */
@@ skipping 162 matching lines @@
   void set name(SimpleIdentifier identifier);
 }
 
 /**
  * The declaration of one or more variables of the same type.
  *
  *    variableDeclarationList ::=
  *        finalConstVarOrType [VariableDeclaration] (',' [VariableDeclaration])*
  *
  *    finalConstVarOrType ::=
- *      | 'final' [TypeName]?
- *      | 'const' [TypeName]?
+ *      | 'final' [TypeAnnotation]?
+ *      | 'const' [TypeAnnotation]?
  *      | 'var'
- *      | [TypeName]
+ *      | [TypeAnnotation]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclarationList extends AnnotatedNode {
   /**
    * Return `true` if the variables in this list were declared with the 'const'
    * modifier.
    */
   bool get isConst;
 
@@ skipping 14 matching lines @@
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the
    * given [token].
    */
   void set keyword(Token token);
 
   /**
    * Return the type of the variables being declared, or `null` if no type was
    * provided.
    */
-  TypeName get type;
+  TypeAnnotation get type;
 
   /**
-   * Set the type of the variables being declared to the given [typeName].
+   * Set the type of the variables being declared to the given [type].
    */
-  void set type(TypeName typeName);
+  void set type(TypeAnnotation type);
 
   /**
    * Return a list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> get variables;
 }
 
 /**
  * A list of variables that are being declared in a context where a statement is
  * required.
@@ skipping 154 matching lines @@
   /**
    * Return the 'yield' keyword.
    */
   Token get yieldKeyword;
 
   /**
    * Return the 'yield' keyword to the given [token].
    */
   void set yieldKeyword(Token token);
 }