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

pkg/analyzer/test/generated/utilities_test.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.test.generated.utilities_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 1613 matching lines @@
   Identifier get(Annotation node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_annotation_3
     implements NodeReplacerTest_Getter<Annotation, SimpleIdentifier> {
   @override
   SimpleIdentifier get(Annotation node) => node.constructorName;
 }
 
 class Getter_NodeReplacerTest_test_asExpression
-    implements NodeReplacerTest_Getter<AsExpression, TypeName> {
+    implements NodeReplacerTest_Getter<AsExpression, TypeAnnotation> {
   @override
-  TypeName get(AsExpression node) => node.type;
+  TypeAnnotation get(AsExpression node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_asExpression_2
     implements NodeReplacerTest_Getter<AsExpression, Expression> {
   @override
   Expression get(AsExpression node) => node.expression;
 }
 
 class Getter_NodeReplacerTest_test_assertStatement
     implements NodeReplacerTest_Getter<AssertStatement, Expression> {
@@ skipping 61 matching lines @@
   SimpleIdentifier get(CatchClause node) => node.stackTraceParameter;
 }
 
 class Getter_NodeReplacerTest_test_catchClause_2
     implements NodeReplacerTest_Getter<CatchClause, SimpleIdentifier> {
   @override
   SimpleIdentifier get(CatchClause node) => node.exceptionParameter;
 }
 
 class Getter_NodeReplacerTest_test_catchClause_3
-    implements NodeReplacerTest_Getter<CatchClause, TypeName> {
+    implements NodeReplacerTest_Getter<CatchClause, TypeAnnotation> {
   @override
-  TypeName get(CatchClause node) => node.exceptionType;
+  TypeAnnotation get(CatchClause node) => node.exceptionType;
 }
 
 class Getter_NodeReplacerTest_test_classDeclaration
     implements NodeReplacerTest_Getter<ClassDeclaration, ImplementsClause> {
   @override
   ImplementsClause get(ClassDeclaration node) => node.implementsClause;
 }
 
 class Getter_NodeReplacerTest_test_classDeclaration_2
     implements NodeReplacerTest_Getter<ClassDeclaration, WithClause> {
@@ skipping 145 matching lines @@
   SimpleIdentifier get(ConstructorName node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_continueStatement
     implements NodeReplacerTest_Getter<ContinueStatement, SimpleIdentifier> {
   @override
   SimpleIdentifier get(ContinueStatement node) => node.label;
 }
 
 class Getter_NodeReplacerTest_test_declaredIdentifier
-    implements NodeReplacerTest_Getter<DeclaredIdentifier, TypeName> {
+    implements NodeReplacerTest_Getter<DeclaredIdentifier, TypeAnnotation> {
   @override
-  TypeName get(DeclaredIdentifier node) => node.type;
+  TypeAnnotation get(DeclaredIdentifier node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_declaredIdentifier_2
     implements NodeReplacerTest_Getter<DeclaredIdentifier, SimpleIdentifier> {
   @override
   SimpleIdentifier get(DeclaredIdentifier node) => node.identifier;
 }
 
 class Getter_NodeReplacerTest_test_defaultFormalParameter
     implements
@@ skipping 59 matching lines @@
 }
 
 class Getter_NodeReplacerTest_test_fieldFormalParameter
     implements
         NodeReplacerTest_Getter<FieldFormalParameter, FormalParameterList> {
   @override
   FormalParameterList get(FieldFormalParameter node) => node.parameters;
 }
 
 class Getter_NodeReplacerTest_test_fieldFormalParameter_2
-    implements NodeReplacerTest_Getter<FieldFormalParameter, TypeName> {
+    implements NodeReplacerTest_Getter<FieldFormalParameter, TypeAnnotation> {
   @override
-  TypeName get(FieldFormalParameter node) => node.type;
+  TypeAnnotation get(FieldFormalParameter node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier
     implements NodeReplacerTest_Getter<ForEachStatement, Statement> {
   @override
   Statement get(ForEachStatement node) => node.body;
 }
 
 class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2
     implements NodeReplacerTest_Getter<ForEachStatement, SimpleIdentifier> {
@@ skipping 55 matching lines @@
   VariableDeclarationList get(ForStatement node) => node.variables;
 }
 
 class Getter_NodeReplacerTest_test_forStatement_withVariables_3
     implements NodeReplacerTest_Getter<ForStatement, Expression> {
   @override
   Expression get(ForStatement node) => node.condition;
 }
 
 class Getter_NodeReplacerTest_test_functionDeclaration
-    implements NodeReplacerTest_Getter<FunctionDeclaration, TypeName> {
+    implements NodeReplacerTest_Getter<FunctionDeclaration, TypeAnnotation> {
   @override
-  TypeName get(FunctionDeclaration node) => node.returnType;
+  TypeAnnotation get(FunctionDeclaration node) => node.returnType;
 }
 
 class Getter_NodeReplacerTest_test_functionDeclaration_2
     implements
         NodeReplacerTest_Getter<FunctionDeclaration, FunctionExpression> {
   @override
   FunctionExpression get(FunctionDeclaration node) => node.functionExpression;
 }
 
 class Getter_NodeReplacerTest_test_functionDeclaration_3
@@ skipping 44 matching lines @@
   TypeParameterList get(FunctionTypeAlias node) => node.typeParameters;
 }
 
 class Getter_NodeReplacerTest_test_functionTypeAlias_2
     implements NodeReplacerTest_Getter<FunctionTypeAlias, FormalParameterList> {
   @override
   FormalParameterList get(FunctionTypeAlias node) => node.parameters;
 }
 
 class Getter_NodeReplacerTest_test_functionTypeAlias_3
-    implements NodeReplacerTest_Getter<FunctionTypeAlias, TypeName> {
+    implements NodeReplacerTest_Getter<FunctionTypeAlias, TypeAnnotation> {
   @override
-  TypeName get(FunctionTypeAlias node) => node.returnType;
+  TypeAnnotation get(FunctionTypeAlias node) => node.returnType;
 }
 
 class Getter_NodeReplacerTest_test_functionTypeAlias_4
     implements NodeReplacerTest_Getter<FunctionTypeAlias, SimpleIdentifier> {
   @override
   SimpleIdentifier get(FunctionTypeAlias node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_functionTypedFormalParameter
-    implements NodeReplacerTest_Getter<FunctionTypedFormalParameter, TypeName> {
+    implements
+        NodeReplacerTest_Getter<FunctionTypedFormalParameter, TypeAnnotation> {
   @override
-  TypeName get(FunctionTypedFormalParameter node) => node.returnType;
+  TypeAnnotation get(FunctionTypedFormalParameter node) => node.returnType;
 }
 
 class Getter_NodeReplacerTest_test_functionTypedFormalParameter_2
     implements
         NodeReplacerTest_Getter<FunctionTypedFormalParameter,
             FormalParameterList> {
   @override
   FormalParameterList get(FunctionTypedFormalParameter node) => node.parameters;
 }
 
@@ skipping 53 matching lines @@
   Expression get(InterpolationExpression node) => node.expression;
 }
 
 class Getter_NodeReplacerTest_test_isExpression
     implements NodeReplacerTest_Getter<IsExpression, Expression> {
   @override
   Expression get(IsExpression node) => node.expression;
 }
 
 class Getter_NodeReplacerTest_test_isExpression_2
-    implements NodeReplacerTest_Getter<IsExpression, TypeName> {
+    implements NodeReplacerTest_Getter<IsExpression, TypeAnnotation> {
   @override
-  TypeName get(IsExpression node) => node.type;
+  TypeAnnotation get(IsExpression node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_label
     implements NodeReplacerTest_Getter<Label, SimpleIdentifier> {
   @override
   SimpleIdentifier get(Label node) => node.label;
 }
 
 class Getter_NodeReplacerTest_test_labeledStatement
     implements NodeReplacerTest_Getter<LabeledStatement, Statement> {
@@ skipping 13 matching lines @@
   Expression get(MapLiteralEntry node) => node.value;
 }
 
 class Getter_NodeReplacerTest_test_mapLiteralEntry_2
     implements NodeReplacerTest_Getter<MapLiteralEntry, Expression> {
   @override
   Expression get(MapLiteralEntry node) => node.key;
 }
 
 class Getter_NodeReplacerTest_test_methodDeclaration
-    implements NodeReplacerTest_Getter<MethodDeclaration, TypeName> {
+    implements NodeReplacerTest_Getter<MethodDeclaration, TypeAnnotation> {
   @override
-  TypeName get(MethodDeclaration node) => node.returnType;
+  TypeAnnotation get(MethodDeclaration node) => node.returnType;
 }
 
 class Getter_NodeReplacerTest_test_methodDeclaration_2
     implements NodeReplacerTest_Getter<MethodDeclaration, FunctionBody> {
   @override
   FunctionBody get(MethodDeclaration node) => node.body;
 }
 
 class Getter_NodeReplacerTest_test_methodDeclaration_3
     implements NodeReplacerTest_Getter<MethodDeclaration, SimpleIdentifier> {
@@ skipping 114 matching lines @@
   ArgumentList get(RedirectingConstructorInvocation node) => node.argumentList;
 }
 
 class Getter_NodeReplacerTest_test_returnStatement
     implements NodeReplacerTest_Getter<ReturnStatement, Expression> {
   @override
   Expression get(ReturnStatement node) => node.expression;
 }
 
 class Getter_NodeReplacerTest_test_simpleFormalParameter
-    implements NodeReplacerTest_Getter<SimpleFormalParameter, TypeName> {
+    implements NodeReplacerTest_Getter<SimpleFormalParameter, TypeAnnotation> {
   @override
-  TypeName get(SimpleFormalParameter node) => node.type;
+  TypeAnnotation get(SimpleFormalParameter node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_superConstructorInvocation
     implements
         NodeReplacerTest_Getter<SuperConstructorInvocation, SimpleIdentifier> {
   @override
   SimpleIdentifier get(SuperConstructorInvocation node) => node.constructorName;
 }
 
 class Getter_NodeReplacerTest_test_superConstructorInvocation_2
@@ skipping 48 matching lines @@
   TypeArgumentList get(TypeName node) => node.typeArguments;
 }
 
 class Getter_NodeReplacerTest_test_typeName_2
     implements NodeReplacerTest_Getter<TypeName, Identifier> {
   @override
   Identifier get(TypeName node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_typeParameter
-    implements NodeReplacerTest_Getter<TypeParameter, TypeName> {
+    implements NodeReplacerTest_Getter<TypeParameter, TypeAnnotation> {
   @override
-  TypeName get(TypeParameter node) => node.bound;
+  TypeAnnotation get(TypeParameter node) => node.bound;
 }
 
 class Getter_NodeReplacerTest_test_typeParameter_2
     implements NodeReplacerTest_Getter<TypeParameter, SimpleIdentifier> {
   @override
   SimpleIdentifier get(TypeParameter node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_variableDeclaration
     implements NodeReplacerTest_Getter<VariableDeclaration, SimpleIdentifier> {
   @override
   SimpleIdentifier get(VariableDeclaration node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_variableDeclaration_2
     implements NodeReplacerTest_Getter<VariableDeclaration, Expression> {
   @override
   Expression get(VariableDeclaration node) => node.initializer;
 }
 
 class Getter_NodeReplacerTest_test_variableDeclarationList
-    implements NodeReplacerTest_Getter<VariableDeclarationList, TypeName> {
+    implements
+        NodeReplacerTest_Getter<VariableDeclarationList, TypeAnnotation> {
   @override
-  TypeName get(VariableDeclarationList node) => node.type;
+  TypeAnnotation get(VariableDeclarationList node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_variableDeclarationStatement
     implements
         NodeReplacerTest_Getter<VariableDeclarationStatement,
             VariableDeclarationList> {
   @override
   VariableDeclarationList get(VariableDeclarationStatement node) =>
       node.variables;
 }
@@ skipping 275 matching lines @@
 
 class ListGetter_NodeReplacerTest_test_tryStatement
     extends NodeReplacerTest_ListGetter<TryStatement, CatchClause> {
   ListGetter_NodeReplacerTest_test_tryStatement(int arg0) : super(arg0);
 
   @override
   NodeList<CatchClause> getList(TryStatement node) => node.catchClauses;
 }
 
 class ListGetter_NodeReplacerTest_test_typeArgumentList
-    extends NodeReplacerTest_ListGetter<TypeArgumentList, TypeName> {
+    extends NodeReplacerTest_ListGetter<TypeArgumentList, TypeAnnotation> {
   ListGetter_NodeReplacerTest_test_typeArgumentList(int arg0) : super(arg0);
 
   @override
-  NodeList<TypeName> getList(TypeArgumentList node) => node.arguments;
+  NodeList<TypeAnnotation> getList(TypeArgumentList node) => node.arguments;
 }
 
 class ListGetter_NodeReplacerTest_test_typeParameterList
     extends NodeReplacerTest_ListGetter<TypeParameterList, TypeParameter> {
   ListGetter_NodeReplacerTest_test_typeParameterList(int arg0) : super(arg0);
 
   @override
   NodeList<TypeParameter> getList(TypeParameterList node) =>
       node.typeParameters;
 }
@@ skipping 1605 matching lines @@
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }
 
 class _ExceptionThrowingVisitor extends SimpleAstVisitor {
   visitNullLiteral(NullLiteral node) {
     throw new ArgumentError('');
   }
 }