Add support for generic function type syntax, part 1

pkg/analyzer/lib/dart/ast/ast_factory.dart

 // Copyright (c) 2016, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:front_end/src/scanner/token.dart';
 
 /**
  * A collection of factory methods which may be used to create concrete
@@ skipping 21 matching lines @@
    * Returns a newly created list of arguments. The list of [arguments] can
    * be `null` if there are no arguments.
    */
   ArgumentList argumentList(Token leftParenthesis, List<Expression> arguments,
       Token rightParenthesis);
 
   /**
    * Returns a newly created as expression.
    */
   AsExpression asExpression(
-      Expression expression, Token asOperator, TypeName type);
+      Expression expression, Token asOperator, TypeAnnotation type);
 
   /**
    * Returns a newly created assert initializer. The [comma] and [message]
    * can be `null` if there is no message.
    */
   AssertInitializer assertInitializer(
       Token assertKeyword,
       Token leftParenthesis,
       Expression condition,
       Token comma,
@@ skipping 68 matching lines @@
       Expression target, List<Expression> cascadeSections);
 
   /**
    * Returns 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.
    */
   CatchClause catchClause(
       Token onKeyword,
-      TypeName exceptionType,
+      TypeAnnotation exceptionType,
       Token catchKeyword,
       Token leftParenthesis,
       SimpleIdentifier exceptionParameter,
       Token comma,
       SimpleIdentifier stackTraceParameter,
       Token rightParenthesis,
       Block body);
 
   /**
    * Returns a newly created class declaration. Either or both of the
@@ skipping 141 matching lines @@
   /**
    * Returns 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'.
    */
   DeclaredIdentifier declaredIdentifier(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeName type,
+      TypeAnnotation type,
       SimpleIdentifier identifier);
 
   /**
    * Returns a newly created default formal parameter. The [separator] and
    * [defaultValue] can be `null` if there is no default value.
    */
   DefaultFormalParameter defaultFormalParameter(NormalFormalParameter parameter,
       ParameterKind kind, Token separator, Expression defaultValue);
 
   /**
@@ skipping 112 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.
    */
   FieldFormalParameter fieldFormalParameter(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeName type,
+      TypeAnnotation type,
       Token thisKeyword,
       Token period,
       SimpleIdentifier identifier,
       TypeParameterList typeParameters,
       FormalParameterList parameters);
 
   /**
    * Returns a newly created for-each statement whose loop control variable
    * is declared internally (in the for-loop part). The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
@@ skipping 58 matching lines @@
    * [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.
    */
   FunctionDeclaration functionDeclaration(
       Comment comment,
       List<Annotation> metadata,
       Token externalKeyword,
-      TypeName returnType,
+      TypeAnnotation returnType,
       Token propertyKeyword,
       SimpleIdentifier name,
       FunctionExpression functionExpression);
 
   /**
    * Returns a newly created function declaration statement.
    */
   FunctionDeclarationStatement functionDeclarationStatement(
       FunctionDeclaration functionDeclaration);
 
@@ skipping 13 matching lines @@
    * Returns 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.
    */
   FunctionTypeAlias functionTypeAlias(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeName returnType,
+      TypeAnnotation returnType,
       SimpleIdentifier name,
       TypeParameterList typeParameters,
       FormalParameterList parameters,
       Token semicolon);
 
   /**
    * Returns 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.
    */
   FunctionTypedFormalParameter functionTypedFormalParameter(
       Comment comment,
       List<Annotation> metadata,
-      TypeName returnType,
+      TypeAnnotation returnType,
       SimpleIdentifier identifier,
       TypeParameterList typeParameters,
       FormalParameterList parameters,
       {Token question: null});
 
   /**
    * Returns a newly created import show combinator.
    */
   HideCombinator hideCombinator(
       Token keyword, List<SimpleIdentifier> hiddenNames);
@@ skipping 70 matching lines @@
    * Returns a newly created string of characters that are part of a string
    * interpolation.
    */
   InterpolationString interpolationString(Token contents, String value);
 
   /**
    * Returns a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
   IsExpression isExpression(Expression expression, Token isOperator,
-      Token notOperator, TypeName type);
+      Token notOperator, TypeAnnotation type);
 
   /**
    * Returns a newly created label.
    */
   Label label(SimpleIdentifier label, Token colon);
 
   /**
    * Returns a newly created labeled statement.
    */
   LabeledStatement labeledStatement(List<Label> labels, Statement statement);
@@ skipping 43 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.
    */
   MethodDeclaration methodDeclaration(
       Comment comment,
       List<Annotation> metadata,
       Token externalKeyword,
       Token modifierKeyword,
-      TypeName returnType,
+      TypeAnnotation returnType,
       Token propertyKeyword,
       Token operatorKeyword,
       SimpleIdentifier name,
       TypeParameterList typeParameters,
       FormalParameterList parameters,
       FunctionBody body);
 
   /**
    * Returns a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.
@@ skipping 122 matching lines @@
   /**
    * Returns 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'.
    */
   SimpleFormalParameter simpleFormalParameter(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeName type,
+      TypeAnnotation type,
       SimpleIdentifier identifier);
 
   /**
    * Returns a newly created identifier.
    */
   SimpleIdentifier simpleIdentifier(Token token, {bool isDeclaration: false});
 
   /**
    * Returns a newly created simple string literal.
    */
@@ skipping 78 matching lines @@
    * `null` if there are no catch clauses. The [finallyKeyword] and
    * [finallyBlock] can be `null` if there is no finally clause.
    */
   TryStatement tryStatement(Token tryKeyword, Block body,
       List<CatchClause> catchClauses, Token finallyKeyword, Block finallyBlock);
 
   /**
    * Returns a newly created list of type arguments.
    */
   TypeArgumentList typeArgumentList(
-      Token leftBracket, List<TypeName> arguments, Token rightBracket);
+      Token leftBracket, List<TypeAnnotation> arguments, Token rightBracket);
 
   /**
    * Returns a newly created type name. The [typeArguments] can be `null` if
    * there are no type arguments.
    */
   TypeName typeName(Identifier name, TypeArgumentList typeArguments,
       {Token question: null});
 
   /**
    * Returns 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.
    */
   TypeParameter typeParameter(Comment comment, List<Annotation> metadata,
-      SimpleIdentifier name, Token extendsKeyword, TypeName bound);
+      SimpleIdentifier name, Token extendsKeyword, TypeAnnotation bound);
 
   /**
    * Returns a newly created list of type parameters.
    */
   TypeParameterList typeParameterList(Token leftBracket,
       List<TypeParameter> typeParameters, Token rightBracket);
 
   /**
    * Returns a newly created variable declaration. The [equals] and
    * [initializer] can be `null` if there is no initializer.
    */
   VariableDeclaration variableDeclaration(
       SimpleIdentifier name, Token equals, Expression initializer);
 
   /**
    * Returns 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'.
    */
   VariableDeclarationList variableDeclarationList(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeName type,
+      TypeAnnotation type,
       List<VariableDeclaration> variables);
 
   /**
+   * 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.
+   */
+  GenericTypeAlias genericTypeAlias(Comment comment, List<Annotation> metadata, Token typedefKeyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, GenericFunctionType functionType, Token semicolon);
+
+  /**
+   * Initialize a newly created generic function type.
+   */
+  GenericFunctionType genericFunctionType(TypeAnnotation returnType, Token functionKeyword, TypeParameterList typeParameters, FormalParameterList _parameters);
+
+  /**
    * Returns a newly created variable declaration statement.
    */
   VariableDeclarationStatement variableDeclarationStatement(
       VariableDeclarationList variableList, Token semicolon);
 
   /**
    * Returns a newly created while statement.
    */
   WhileStatement whileStatement(Token whileKeyword, Token leftParenthesis,
       Expression condition, Token rightParenthesis, Statement body);
 
   /**
    * Returns a newly created with clause.
    */
   WithClause withClause(Token withKeyword, List<TypeName> mixinTypes);
 
   /**
    * Returns a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
   YieldStatement yieldStatement(
       Token yieldKeyword, Token star, Expression expression, Token semicolon);
 }