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

pkg/analyzer/lib/src/generated/testing/ast_test_factory.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.testing.ast_test_factory;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 27 matching lines @@
           constructorName == null
               ? null
               : TokenFactory.tokenFromType(TokenType.PERIOD),
           constructorName,
           arguments);
 
   static ArgumentList argumentList([List<Expression> arguments]) =>
       astFactory.argumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           arguments, TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
 
-  static AsExpression asExpression(Expression expression, TypeName type) =>
+  static AsExpression asExpression(
+          Expression expression, TypeAnnotation type) =>
       astFactory.asExpression(
           expression, TokenFactory.tokenFromKeyword(Keyword.AS), type);
 
   static AssertStatement assertStatement(Expression condition,
           [Expression message]) =>
       astFactory.assertStatement(
           TokenFactory.tokenFromKeyword(Keyword.ASSERT),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           condition,
           message == null ? null : TokenFactory.tokenFromType(TokenType.COMMA),
@@ skipping 92 matching lines @@
 
   static CatchClause catchClause(String exceptionParameter,
           [List<Statement> statements]) =>
       catchClause5(null, exceptionParameter, null, statements);
 
   static CatchClause catchClause2(
           String exceptionParameter, String stackTraceParameter,
           [List<Statement> statements]) =>
       catchClause5(null, exceptionParameter, stackTraceParameter, statements);
 
-  static CatchClause catchClause3(TypeName exceptionType,
+  static CatchClause catchClause3(TypeAnnotation exceptionType,
           [List<Statement> statements]) =>
       catchClause5(exceptionType, null, null, statements);
 
   static CatchClause catchClause4(
-          TypeName exceptionType, String exceptionParameter,
+          TypeAnnotation exceptionType, String exceptionParameter,
           [List<Statement> statements]) =>
       catchClause5(exceptionType, exceptionParameter, null, statements);
 
-  static CatchClause catchClause5(TypeName exceptionType,
+  static CatchClause catchClause5(TypeAnnotation exceptionType,
           String exceptionParameter, String stackTraceParameter,
           [List<Statement> statements]) =>
       astFactory.catchClause(
           exceptionType == null
               ? null
               : TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "on"),
           exceptionType,
           exceptionParameter == null
               ? null
               : TokenFactory.tokenFromKeyword(Keyword.CATCH),
@@ skipping 179 matching lines @@
       astFactory.continueStatement(
           TokenFactory.tokenFromKeyword(Keyword.CONTINUE),
           label == null ? null : identifier3(label),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static DeclaredIdentifier declaredIdentifier(
           Keyword keyword, String identifier) =>
       declaredIdentifier2(keyword, null, identifier);
 
   static DeclaredIdentifier declaredIdentifier2(
-          Keyword keyword, TypeName type, String identifier) =>
+          Keyword keyword, TypeAnnotation type, String identifier) =>
       astFactory.declaredIdentifier(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           identifier3(identifier));
 
   static DeclaredIdentifier declaredIdentifier3(String identifier) =>
       declaredIdentifier2(Keyword.VAR, null, identifier);
 
   static DeclaredIdentifier declaredIdentifier4(
-          TypeName type, String identifier) =>
+          TypeAnnotation type, String identifier) =>
       declaredIdentifier2(null, type, identifier);
 
   static Comment documentationComment(
       List<Token> tokens, List<CommentReference> references) {
     return astFactory.documentationComment(tokens, references);
   }
 
   static DoStatement doStatement(Statement body, Expression condition) =>
       astFactory.doStatement(
           TokenFactory.tokenFromKeyword(Keyword.DO),
@@ skipping 59 matching lines @@
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ExpressionStatement expressionStatement(Expression expression) =>
       astFactory.expressionStatement(
           expression, TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ExtendsClause extendsClause(TypeName type) => astFactory.extendsClause(
       TokenFactory.tokenFromKeyword(Keyword.EXTENDS), type);
 
   static FieldDeclaration fieldDeclaration(bool isStatic, Keyword keyword,
-          TypeName type, List<VariableDeclaration> variables) =>
+          TypeAnnotation type, List<VariableDeclaration> variables) =>
       astFactory.fieldDeclaration(
           null,
           null,
           isStatic ? TokenFactory.tokenFromKeyword(Keyword.STATIC) : null,
           variableDeclarationList(keyword, type, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static FieldDeclaration fieldDeclaration2(bool isStatic, Keyword keyword,
           List<VariableDeclaration> variables) =>
       fieldDeclaration(isStatic, keyword, null, variables);
 
   static FieldFormalParameter fieldFormalParameter(
-          Keyword keyword, TypeName type, String identifier,
+          Keyword keyword, TypeAnnotation type, String identifier,
           [FormalParameterList parameterList]) =>
       astFactory.fieldFormalParameter(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           TokenFactory.tokenFromKeyword(Keyword.THIS),
           TokenFactory.tokenFromType(TokenType.PERIOD),
           identifier3(identifier),
           null,
@@ skipping 56 matching lines @@
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           variableList,
           null,
           TokenFactory.tokenFromType(TokenType.SEMICOLON),
           condition,
           TokenFactory.tokenFromType(TokenType.SEMICOLON),
           updaters,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           body);
 
-  static FunctionDeclaration functionDeclaration(TypeName type, Keyword keyword,
-          String name, FunctionExpression functionExpression) =>
+  static FunctionDeclaration functionDeclaration(
+          TypeAnnotation type,
+          Keyword keyword,
+          String name,
+          FunctionExpression functionExpression) =>
       astFactory.functionDeclaration(
           null,
           null,
           null,
           type,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           identifier3(name),
           functionExpression);
 
   static FunctionDeclarationStatement functionDeclarationStatement(
-          TypeName type,
+          TypeAnnotation type,
           Keyword keyword,
           String name,
           FunctionExpression functionExpression) =>
       astFactory.functionDeclarationStatement(
           functionDeclaration(type, keyword, name, functionExpression));
 
   static FunctionExpression functionExpression() => astFactory
       .functionExpression(null, formalParameterList(), blockFunctionBody2());
 
   static FunctionExpression functionExpression2(
@@ skipping 12 matching lines @@
       functionExpressionInvocation2(function, null, arguments);
 
   static FunctionExpressionInvocation functionExpressionInvocation2(
           Expression function,
           [TypeArgumentList typeArguments,
           List<Expression> arguments]) =>
       astFactory.functionExpressionInvocation(
           function, typeArguments, argumentList(arguments));
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
-          TypeName returnType, String identifier,
+          TypeAnnotation returnType, String identifier,
           [List<FormalParameter> parameters]) =>
       astFactory.functionTypedFormalParameter(null, null, returnType,
           identifier3(identifier), null, formalParameterList(parameters));
 
   static HideCombinator hideCombinator(List<SimpleIdentifier> identifiers) =>
       astFactory.hideCombinator(
           TokenFactory.tokenFromString("hide"), identifiers);
 
   static HideCombinator hideCombinator2(List<String> identifiers) =>
       astFactory.hideCombinator(
@@ skipping 122 matching lines @@
           TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_IDENTIFIER),
           identifier3(identifier),
           null);
 
   static InterpolationString interpolationString(
           String contents, String value) =>
       astFactory.interpolationString(
           TokenFactory.tokenFromString(contents), value);
 
   static IsExpression isExpression(
-          Expression expression, bool negated, TypeName type) =>
+          Expression expression, bool negated, TypeAnnotation type) =>
       astFactory.isExpression(
           expression,
           TokenFactory.tokenFromKeyword(Keyword.IS),
           negated ? TokenFactory.tokenFromType(TokenType.BANG) : null,
           type);
 
   static Label label(SimpleIdentifier label) =>
       astFactory.label(label, TokenFactory.tokenFromType(TokenType.COLON));
 
   static Label label2(String label) => AstTestFactory.label(identifier3(label));
@@ skipping 55 matching lines @@
   static MapLiteralEntry mapLiteralEntry(String key, Expression value) =>
       astFactory.mapLiteralEntry(
           string2(key), TokenFactory.tokenFromType(TokenType.COLON), value);
 
   static MapLiteralEntry mapLiteralEntry2(Expression key, Expression value) =>
       astFactory.mapLiteralEntry(
           key, TokenFactory.tokenFromType(TokenType.COLON), value);
 
   static MethodDeclaration methodDeclaration(
           Keyword modifier,
-          TypeName returnType,
+          TypeAnnotation returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           FormalParameterList parameters) =>
       astFactory.methodDeclaration(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.EXTERNAL),
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           null,
           parameters,
           emptyFunctionBody());
 
   static MethodDeclaration methodDeclaration2(
           Keyword modifier,
-          TypeName returnType,
+          TypeAnnotation returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           FormalParameterList parameters,
           FunctionBody body) =>
       astFactory.methodDeclaration(
           null,
           null,
           null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           null,
           parameters,
           body);
 
   static MethodDeclaration methodDeclaration3(
           Keyword modifier,
-          TypeName returnType,
+          TypeAnnotation returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           TypeParameterList typeParameters,
           FormalParameterList parameters,
           FunctionBody body) =>
       astFactory.methodDeclaration(
           null,
           null,
           null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           typeParameters,
           parameters,
           body);
 
   static MethodDeclaration methodDeclaration4(
           {bool external: false,
           Keyword modifier,
-          TypeName returnType,
+          TypeAnnotation returnType,
           Keyword property,
           bool operator: false,
           String name,
           FormalParameterList parameters,
           FunctionBody body}) =>
       astFactory.methodDeclaration(
           null,
           null,
           external ? TokenFactory.tokenFromKeyword(Keyword.EXTERNAL) : null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
@@ skipping 153 matching lines @@
 
   static ShowCombinator showCombinator2(List<String> identifiers) =>
       astFactory.showCombinator(
           TokenFactory.tokenFromString("show"), identifierList(identifiers));
 
   static SimpleFormalParameter simpleFormalParameter(
           Keyword keyword, String parameterName) =>
       simpleFormalParameter2(keyword, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter2(
-          Keyword keyword, TypeName type, String parameterName) =>
+          Keyword keyword, TypeAnnotation type, String parameterName) =>
       astFactory.simpleFormalParameter(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           identifier3(parameterName));
 
   static SimpleFormalParameter simpleFormalParameter3(String parameterName) =>
       simpleFormalParameter2(null, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter4(
-          TypeName type, String parameterName) =>
+          TypeAnnotation type, String parameterName) =>
       simpleFormalParameter2(null, type, parameterName);
 
   static StringInterpolation string([List<InterpolationElement> elements]) =>
       astFactory.stringInterpolation(elements);
 
   static SimpleStringLiteral string2(String content) => astFactory
       .simpleStringLiteral(TokenFactory.tokenFromString("'$content'"), content);
 
   static SuperConstructorInvocation superConstructorInvocation(
           [List<Expression> arguments]) =>
@@ skipping 69 matching lines @@
       astFactory.thisExpression(TokenFactory.tokenFromKeyword(Keyword.THIS));
 
   static ThrowExpression throwExpression() => throwExpression2(null);
 
   static ThrowExpression throwExpression2(Expression expression) =>
       astFactory.throwExpression(
           TokenFactory.tokenFromKeyword(Keyword.THROW), expression);
 
   static TopLevelVariableDeclaration topLevelVariableDeclaration(
           Keyword keyword,
-          TypeName type,
+          TypeAnnotation type,
           List<VariableDeclaration> variables) =>
       astFactory.topLevelVariableDeclaration(
           null,
           null,
           variableDeclarationList(keyword, type, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static TopLevelVariableDeclaration topLevelVariableDeclaration2(
           Keyword keyword, List<VariableDeclaration> variables) =>
       astFactory.topLevelVariableDeclaration(
@@ skipping 13 matching lines @@
           Block body, List<CatchClause> catchClauses, Block finallyClause) =>
       astFactory.tryStatement(
           TokenFactory.tokenFromKeyword(Keyword.TRY),
           body,
           catchClauses,
           finallyClause == null
               ? null
               : TokenFactory.tokenFromKeyword(Keyword.FINALLY),
           finallyClause);
 
-  static FunctionTypeAlias typeAlias(TypeName returnType, String name,
+  static FunctionTypeAlias typeAlias(TypeAnnotation returnType, String name,
           TypeParameterList typeParameters, FormalParameterList parameters) =>
       astFactory.functionTypeAlias(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.TYPEDEF),
           returnType,
           identifier3(name),
           typeParameters,
           parameters,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
-  static TypeArgumentList typeArgumentList(List<TypeName> typeNames) {
-    if (typeNames == null || typeNames.length == 0) {
+  static TypeArgumentList typeArgumentList(List<TypeAnnotation> types) {
+    if (types == null || types.length == 0) {
       return null;
     }
     return astFactory.typeArgumentList(TokenFactory.tokenFromType(TokenType.LT),
-        typeNames, TokenFactory.tokenFromType(TokenType.GT));
+        types, TokenFactory.tokenFromType(TokenType.GT));
   }
 
   /**
    * Create a type name whose name has been resolved to the given [element] and
    * whose type has been resolved to the type of the given element.
    *
    * <b>Note:</b> This method does not correctly handle class elements that have
    * type parameters.
    */
-  static TypeName typeName(ClassElement element, [List<TypeName> arguments]) {
+  static TypeName typeName(ClassElement element,
+      [List<TypeAnnotation> arguments]) {
     SimpleIdentifier name = identifier3(element.name);
     name.staticElement = element;
     TypeName typeName = typeName3(name, arguments);
     typeName.type = element.type;
     return typeName;
   }
 
-  static TypeName typeName3(Identifier name, [List<TypeName> arguments]) =>
+  static TypeName typeName3(Identifier name,
+          [List<TypeAnnotation> arguments]) =>
       astFactory.typeName(name, typeArgumentList(arguments));
 
-  static TypeName typeName4(String name, [List<TypeName> arguments]) =>
+  static TypeName typeName4(String name, [List<TypeAnnotation> arguments]) =>
       astFactory.typeName(identifier3(name), typeArgumentList(arguments));
 
   static TypeParameter typeParameter(String name) =>
       astFactory.typeParameter(null, null, identifier3(name), null, null);
 
-  static TypeParameter typeParameter2(String name, TypeName bound) =>
+  static TypeParameter typeParameter2(String name, TypeAnnotation bound) =>
       astFactory.typeParameter(null, null, identifier3(name),
           TokenFactory.tokenFromKeyword(Keyword.EXTENDS), bound);
 
   static TypeParameterList typeParameterList([List<String> typeNames]) {
     List<TypeParameter> typeParameters = null;
     if (typeNames != null && !typeNames.isEmpty) {
       typeParameters = new List<TypeParameter>();
       for (String typeName in typeNames) {
         typeParameters.add(typeParameter(typeName));
       }
     }
     return astFactory.typeParameterList(
         TokenFactory.tokenFromType(TokenType.LT),
         typeParameters,
         TokenFactory.tokenFromType(TokenType.GT));
   }
 
   static VariableDeclaration variableDeclaration(String name) =>
       astFactory.variableDeclaration(identifier3(name), null, null);
 
   static VariableDeclaration variableDeclaration2(
           String name, Expression initializer) =>
       astFactory.variableDeclaration(identifier3(name),
           TokenFactory.tokenFromType(TokenType.EQ), initializer);
 
   static VariableDeclarationList variableDeclarationList(Keyword keyword,
-          TypeName type, List<VariableDeclaration> variables) =>
+          TypeAnnotation type, List<VariableDeclaration> variables) =>
       astFactory.variableDeclarationList(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           variables);
 
   static VariableDeclarationList variableDeclarationList2(
           Keyword keyword, List<VariableDeclaration> variables) =>
       variableDeclarationList(keyword, null, variables);
 
   static VariableDeclarationStatement variableDeclarationStatement(
           Keyword keyword,
-          TypeName type,
+          TypeAnnotation type,
           List<VariableDeclaration> variables) =>
       astFactory.variableDeclarationStatement(
           variableDeclarationList(keyword, type, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static VariableDeclarationStatement variableDeclarationStatement2(
           Keyword keyword, List<VariableDeclaration> variables) =>
       variableDeclarationStatement(keyword, null, variables);
 
   static WhileStatement whileStatement(Expression condition, Statement body) =>
@@ skipping 14 matching lines @@
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static YieldStatement yieldStatement(Expression expression) =>
       astFactory.yieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           null,
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 }