AST changes necessary for generic method support

pkg/analyzer/lib/src/generated/testing/ast_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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.testing.ast_factory;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 94 matching lines @@
 
   static IndexExpression cascadedIndexExpression(Expression index) =>
       new IndexExpression.forCascade(
           TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD),
           TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET), index,
           TokenFactory.tokenFromType(TokenType.CLOSE_SQUARE_BRACKET));
 
   static MethodInvocation cascadedMethodInvocation(String methodName,
       [List<Expression> arguments]) => new MethodInvocation(null,
       TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD),
-      identifier3(methodName), argumentList(arguments));
+      identifier3(methodName), null, argumentList(arguments));
 
   static PropertyAccess cascadedPropertyAccess(String propertyName) =>
       new PropertyAccess(null,
           TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD),
           identifier3(propertyName));
 
   static CascadeExpression cascadeExpression(Expression target,
           [List<Expression> cascadeSections]) =>
       new CascadeExpression(target, cascadeSections);
 
@@ skipping 229 matching lines @@
   static FieldDeclaration fieldDeclaration2(bool isStatic, Keyword keyword,
           List<VariableDeclaration> variables) =>
       fieldDeclaration(isStatic, keyword, null, variables);
 
   static FieldFormalParameter fieldFormalParameter(
       Keyword keyword, TypeName type, String identifier,
       [FormalParameterList parameterList]) => new FieldFormalParameter(null,
       null, keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
       type, TokenFactory.tokenFromKeyword(Keyword.THIS),
       TokenFactory.tokenFromType(TokenType.PERIOD), identifier3(identifier),
-      parameterList);
+      null, parameterList);
 
   static FieldFormalParameter fieldFormalParameter2(String identifier) =>
       fieldFormalParameter(null, null, identifier);
 
   static ForEachStatement forEachStatement(DeclaredIdentifier loopVariable,
           Expression iterator, Statement body) =>
       new ForEachStatement.withDeclaration(null,
           TokenFactory.tokenFromKeyword(Keyword.FOR),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN), loopVariable,
           TokenFactory.tokenFromKeyword(Keyword.IN), iterator,
@@ skipping 34 matching lines @@
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           identifier3(name), functionExpression);
 
   static FunctionDeclarationStatement functionDeclarationStatement(
           TypeName type, Keyword keyword, String name,
           FunctionExpression functionExpression) =>
       new FunctionDeclarationStatement(
           functionDeclaration(type, keyword, name, functionExpression));
 
   static FunctionExpression functionExpression() =>
-      new FunctionExpression(formalParameterList(), blockFunctionBody2());
+      new FunctionExpression(null, formalParameterList(), blockFunctionBody2());
 
   static FunctionExpression functionExpression2(
           FormalParameterList parameters, FunctionBody body) =>
-      new FunctionExpression(parameters, body);
+      new FunctionExpression(null, parameters, body);
+
+  static FunctionExpression functionExpression3(
+          TypeParameterList typeParameters, FormalParameterList parameters,
+          FunctionBody body) =>
+      new FunctionExpression(typeParameters, parameters, body);
 
   static FunctionExpressionInvocation functionExpressionInvocation(
           Expression function, [List<Expression> arguments]) =>
-      new FunctionExpressionInvocation(function, argumentList(arguments));
+      functionExpressionInvocation2(function, null, arguments);
+
+  static FunctionExpressionInvocation functionExpressionInvocation2(
+          Expression function,
+          [TypeArgumentList typeArguments, List<Expression> arguments]) =>
+      new FunctionExpressionInvocation(
+          function, typeArguments, argumentList(arguments));
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
       TypeName returnType, String identifier,
       [List<FormalParameter> parameters]) => new FunctionTypedFormalParameter(
-      null, null, returnType, identifier3(identifier),
+      null, null, returnType, identifier3(identifier), null,
       formalParameterList(parameters));
 
   static HideCombinator hideCombinator(List<SimpleIdentifier> identifiers) =>
       new HideCombinator(TokenFactory.tokenFromString("hide"), identifiers);
 
   static HideCombinator hideCombinator2(List<String> identifiers) =>
       new HideCombinator(
           TokenFactory.tokenFromString("hide"), identifierList(identifiers));
 
   static PrefixedIdentifier identifier(
@@ skipping 159 matching lines @@
 
   static MethodDeclaration methodDeclaration(Keyword modifier,
       TypeName returnType, Keyword property, Keyword operator,
       SimpleIdentifier name,
       FormalParameterList parameters) => new 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,
-      parameters, emptyFunctionBody());
+      null, parameters, emptyFunctionBody());
 
   static MethodDeclaration methodDeclaration2(Keyword modifier,
       TypeName returnType, Keyword property, Keyword operator,
       SimpleIdentifier name, FormalParameterList parameters,
       FunctionBody body) => new MethodDeclaration(null, null, null,
       modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
       returnType,
       property == null ? null : TokenFactory.tokenFromKeyword(property),
       operator == null ? null : TokenFactory.tokenFromKeyword(operator), name,
-      parameters, body);
+      null, parameters, body);
+
+  static MethodDeclaration methodDeclaration3(Keyword modifier,
+      TypeName returnType, Keyword property, Keyword operator,
+      SimpleIdentifier name, TypeParameterList typeParameters,
+      FormalParameterList parameters,
+      FunctionBody body) => new 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 MethodInvocation methodInvocation(Expression target, String methodName,
       [List<Expression> arguments,
       TokenType operator = TokenType.PERIOD]) => new MethodInvocation(target,
       target == null ? null : TokenFactory.tokenFromType(operator),
-      identifier3(methodName), argumentList(arguments));
+      identifier3(methodName), null, argumentList(arguments));
 
   static MethodInvocation methodInvocation2(String methodName,
           [List<Expression> arguments]) =>
       methodInvocation(null, methodName, arguments);
 
+  static MethodInvocation methodInvocation3(
+      Expression target, String methodName, TypeArgumentList typeArguments,
+      [List<Expression> arguments,
+      TokenType operator = TokenType.PERIOD]) => new MethodInvocation(target,
+      target == null ? null : TokenFactory.tokenFromType(operator),
+      identifier3(methodName), typeArguments, argumentList(arguments));
+
   static NamedExpression namedExpression(Label label, Expression expression) =>
       new NamedExpression(label, expression);
 
   static NamedExpression namedExpression2(
           String label, Expression expression) =>
       namedExpression(label2(label), expression);
 
   static DefaultFormalParameter namedFormalParameter(
           NormalFormalParameter parameter, Expression expression) =>
       new DefaultFormalParameter(parameter, ParameterKind.NAMED,
@@ skipping 299 matching lines @@
       new YieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           TokenFactory.tokenFromType(TokenType.STAR), expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static YieldStatement yieldStatement(
       Expression expression) => new YieldStatement(
       TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"), null,
       expression, TokenFactory.tokenFromType(TokenType.SEMICOLON));
 }