Revert "Add support for generic function type syntax, part 1" (TBR)

pkg/analyzer/lib/src/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/dart/ast/ast_factory.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:front_end/src/scanner/token.dart';
 
@@ skipping 11 matching lines @@
           SimpleIdentifier constructorName, ArgumentList arguments) =>
       new AnnotationImpl(atSign, name, period, constructorName, arguments);
 
   @override
   ArgumentList argumentList(Token leftParenthesis, List<Expression> arguments,
           Token rightParenthesis) =>
       new ArgumentListImpl(leftParenthesis, arguments, rightParenthesis);
 
   @override
   AsExpression asExpression(
-          Expression expression, Token asOperator, TypeAnnotation type) =>
+          Expression expression, Token asOperator, TypeName type) =>
       new AsExpressionImpl(expression, asOperator, type);
 
   @override
   AssertInitializer assertInitializer(
           Token assertKeyword,
           Token leftParenthesis,
           Expression condition,
           Token comma,
           Expression message,
           Token rightParenthesis) =>
@@ skipping 48 matching lines @@
       new BreakStatementImpl(breakKeyword, label, semicolon);
 
   @override
   CascadeExpression cascadeExpression(
           Expression target, List<Expression> cascadeSections) =>
       new CascadeExpressionImpl(target, cascadeSections);
 
   @override
   CatchClause catchClause(
           Token onKeyword,
-          TypeAnnotation exceptionType,
+          TypeName exceptionType,
           Token catchKeyword,
           Token leftParenthesis,
           SimpleIdentifier exceptionParameter,
           Token comma,
           SimpleIdentifier stackTraceParameter,
           Token rightParenthesis,
           Block body) =>
       new CatchClauseImpl(
           onKeyword,
           exceptionType,
@@ skipping 143 matching lines @@
   @override
   ContinueStatement continueStatement(
           Token continueKeyword, SimpleIdentifier label, Token semicolon) =>
       new ContinueStatementImpl(continueKeyword, label, semicolon);
 
   @override
   DeclaredIdentifier declaredIdentifier(
           Comment comment,
           List<Annotation> metadata,
           Token keyword,
-          TypeAnnotation type,
+          TypeName type,
           SimpleIdentifier identifier) =>
       new DeclaredIdentifierImpl(comment, metadata, keyword, type, identifier);
 
   @override
   DefaultFormalParameter defaultFormalParameter(NormalFormalParameter parameter,
           ParameterKind kind, Token separator, Expression defaultValue) =>
       new DefaultFormalParameterImpl(parameter, kind, separator, defaultValue);
 
   @override
   Comment documentationComment(List<Token> tokens,
@@ skipping 84 matching lines @@
           VariableDeclarationList fieldList,
           Token semicolon) =>
       new FieldDeclarationImpl(
           comment, metadata, staticKeyword, fieldList, semicolon);
 
   @override
   FieldFormalParameter fieldFormalParameter(
           Comment comment,
           List<Annotation> metadata,
           Token keyword,
-          TypeAnnotation type,
+          TypeName type,
           Token thisKeyword,
           Token period,
           SimpleIdentifier identifier,
           TypeParameterList typeParameters,
           FormalParameterList parameters) =>
       new FieldFormalParameterImpl(comment, metadata, keyword, type,
           thisKeyword, period, identifier, typeParameters, parameters);
 
   @override
   ForEachStatement forEachStatementWithDeclaration(
@@ skipping 67 matching lines @@
           rightSeparator,
           updaters,
           rightParenthesis,
           body);
 
   @override
   FunctionDeclaration functionDeclaration(
           Comment comment,
           List<Annotation> metadata,
           Token externalKeyword,
-          TypeAnnotation returnType,
+          TypeName returnType,
           Token propertyKeyword,
           SimpleIdentifier name,
           FunctionExpression functionExpression) =>
       new FunctionDeclarationImpl(comment, metadata, externalKeyword,
           returnType, propertyKeyword, name, functionExpression);
 
   @override
   FunctionDeclarationStatement functionDeclarationStatement(
           FunctionDeclaration functionDeclaration) =>
       new FunctionDeclarationStatementImpl(functionDeclaration);
 
   @override
   FunctionExpression functionExpression(TypeParameterList typeParameters,
           FormalParameterList parameters, FunctionBody body) =>
       new FunctionExpressionImpl(typeParameters, parameters, body);
 
   @override
   FunctionExpressionInvocation functionExpressionInvocation(Expression function,
           TypeArgumentList typeArguments, ArgumentList argumentList) =>
       new FunctionExpressionInvocationImpl(
           function, typeArguments, argumentList);
 
   @override
   FunctionTypeAlias functionTypeAlias(
           Comment comment,
           List<Annotation> metadata,
           Token keyword,
-          TypeAnnotation returnType,
+          TypeName returnType,
           SimpleIdentifier name,
           TypeParameterList typeParameters,
           FormalParameterList parameters,
           Token semicolon) =>
       new FunctionTypeAliasImpl(comment, metadata, keyword, returnType, name,
           typeParameters, parameters, semicolon);
 
   @override
   FunctionTypedFormalParameter functionTypedFormalParameter(
           Comment comment,
           List<Annotation> metadata,
-          TypeAnnotation returnType,
+          TypeName returnType,
           SimpleIdentifier identifier,
           TypeParameterList typeParameters,
           FormalParameterList parameters,
           {Token question: null}) =>
       new FunctionTypedFormalParameterImpl(comment, metadata, returnType,
           identifier, typeParameters, parameters, question);
 
   @override
-  GenericFunctionType genericFunctionType(
-          TypeAnnotation returnType,
-          Token functionKeyword,
-          TypeParameterList typeParameters,
-          FormalParameterList _parameters) =>
-      new GenericFunctionTypeImpl(
-          returnType, functionKeyword, typeParameters, _parameters);
-
-  @override
-  GenericTypeAlias genericTypeAlias(
-          Comment comment,
-          List<Annotation> metadata,
-          Token typedefKeyword,
-          SimpleIdentifier name,
-          TypeParameterList typeParameters,
-          Token equals,
-          GenericFunctionType functionType,
-          Token semicolon) =>
-      new GenericTypeAliasImpl(comment, metadata, typedefKeyword, name,
-          typeParameters, equals, functionType, semicolon);
-
-  @override
   HideCombinator hideCombinator(
           Token keyword, List<SimpleIdentifier> hiddenNames) =>
       new HideCombinatorImpl(keyword, hiddenNames);
 
   @override
   IfStatement ifStatement(
           Token ifKeyword,
           Token leftParenthesis,
           Expression condition,
           Token rightParenthesis,
@@ skipping 58 matching lines @@
   InterpolationExpression interpolationExpression(
           Token leftBracket, Expression expression, Token rightBracket) =>
       new InterpolationExpressionImpl(leftBracket, expression, rightBracket);
 
   @override
   InterpolationString interpolationString(Token contents, String value) =>
       new InterpolationStringImpl(contents, value);
 
   @override
   IsExpression isExpression(Expression expression, Token isOperator,
-          Token notOperator, TypeAnnotation type) =>
+          Token notOperator, TypeName type) =>
       new IsExpressionImpl(expression, isOperator, notOperator, type);
 
   @override
   Label label(SimpleIdentifier label, Token colon) =>
       new LabelImpl(label, colon);
 
   @override
   LabeledStatement labeledStatement(List<Label> labels, Statement statement) =>
       new LabeledStatementImpl(labels, statement);
 
@@ skipping 27 matching lines @@
   MapLiteralEntry mapLiteralEntry(
           Expression key, Token separator, Expression value) =>
       new MapLiteralEntryImpl(key, separator, value);
 
   @override
   MethodDeclaration methodDeclaration(
           Comment comment,
           List<Annotation> metadata,
           Token externalKeyword,
           Token modifierKeyword,
-          TypeAnnotation returnType,
+          TypeName returnType,
           Token propertyKeyword,
           Token operatorKeyword,
           SimpleIdentifier name,
           TypeParameterList typeParameters,
           FormalParameterList parameters,
           FunctionBody body) =>
       new MethodDeclarationImpl(
           comment,
           metadata,
           externalKeyword,
@@ skipping 102 matching lines @@
   @override
   ShowCombinator showCombinator(
           Token keyword, List<SimpleIdentifier> shownNames) =>
       new ShowCombinatorImpl(keyword, shownNames);
 
   @override
   SimpleFormalParameter simpleFormalParameter(
           Comment comment,
           List<Annotation> metadata,
           Token keyword,
-          TypeAnnotation type,
+          TypeName type,
           SimpleIdentifier identifier) =>
       new SimpleFormalParameterImpl(
           comment, metadata, keyword, type, identifier);
 
   @override
   SimpleIdentifier simpleIdentifier(Token token, {bool isDeclaration: false}) {
     if (isDeclaration) {
       return new DeclaredSimpleIdentifier(token);
     }
     return new SimpleIdentifierImpl(token);
@@ skipping 13 matching lines @@
           Token superKeyword,
           Token period,
           SimpleIdentifier constructorName,
           ArgumentList argumentList) =>
       new SuperConstructorInvocationImpl(
           superKeyword, period, constructorName, argumentList);
 
   @override
   SuperExpression superExpression(Token superKeyword) =>
       new SuperExpressionImpl(superKeyword);
+
   @override
   SwitchCase switchCase(List<Label> labels, Token keyword,
           Expression expression, Token colon, List<Statement> statements) =>
       new SwitchCaseImpl(labels, keyword, expression, colon, statements);
 
   @override
   SwitchDefault switchDefault(List<Label> labels, Token keyword, Token colon,
           List<Statement> statements) =>
       new SwitchDefaultImpl(labels, keyword, colon, statements);
-
   @override
   SwitchStatement switchStatement(
           Token switchKeyword,
           Token leftParenthesis,
           Expression expression,
           Token rightParenthesis,
           Token leftBracket,
           List<SwitchMember> members,
           Token rightBracket) =>
       new SwitchStatementImpl(switchKeyword, leftParenthesis, expression,
@@ skipping 24 matching lines @@
   TryStatement tryStatement(
           Token tryKeyword,
           Block body,
           List<CatchClause> catchClauses,
           Token finallyKeyword,
           Block finallyBlock) =>
       new TryStatementImpl(
           tryKeyword, body, catchClauses, finallyKeyword, finallyBlock);
 
   @override
-  TypeArgumentList typeArgumentList(Token leftBracket,
-          List<TypeAnnotation> arguments, Token rightBracket) =>
+  TypeArgumentList typeArgumentList(
+          Token leftBracket, List<TypeName> arguments, Token rightBracket) =>
       new TypeArgumentListImpl(leftBracket, arguments, rightBracket);
 
   @override
   TypeName typeName(Identifier name, TypeArgumentList typeArguments,
           {Token question: null}) =>
       new TypeNameImpl(name, typeArguments, question);
 
   @override
   TypeParameter typeParameter(Comment comment, List<Annotation> metadata,
-          SimpleIdentifier name, Token extendsKeyword, TypeAnnotation bound) =>
+          SimpleIdentifier name, Token extendsKeyword, TypeName bound) =>
       new TypeParameterImpl(comment, metadata, name, extendsKeyword, bound);
 
   @override
   TypeParameterList typeParameterList(Token leftBracket,
           List<TypeParameter> typeParameters, Token rightBracket) =>
       new TypeParameterListImpl(leftBracket, typeParameters, rightBracket);
 
   @override
   VariableDeclaration variableDeclaration(
           SimpleIdentifier name, Token equals, Expression initializer) =>
       new VariableDeclarationImpl(name, equals, initializer);
 
   @override
   VariableDeclarationList variableDeclarationList(
           Comment comment,
           List<Annotation> metadata,
           Token keyword,
-          TypeAnnotation type,
+          TypeName type,
           List<VariableDeclaration> variables) =>
       new VariableDeclarationListImpl(
           comment, metadata, keyword, type, variables);
 
   @override
   VariableDeclarationStatement variableDeclarationStatement(
           VariableDeclarationList variableList, Token semicolon) =>
       new VariableDeclarationStatementImpl(variableList, semicolon);
 
   @override
   WhileStatement whileStatement(Token whileKeyword, Token leftParenthesis,
           Expression condition, Token rightParenthesis, Statement body) =>
       new WhileStatementImpl(
           whileKeyword, leftParenthesis, condition, rightParenthesis, body);
 
   @override
   WithClause withClause(Token withKeyword, List<TypeName> mixinTypes) =>
       new WithClauseImpl(withKeyword, mixinTypes);
 
   @override
   YieldStatement yieldStatement(Token yieldKeyword, Token star,
           Expression expression, Token semicolon) =>
       new YieldStatementImpl(yieldKeyword, star, expression, semicolon);
 }