AST changes necessary for generic method support

pkg/analyzer/test/generated/ast_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.
 
 // 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.ast_test;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 2114 matching lines @@
         .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertSource("@deprecated var a;", declaration);
   }
 
   void test_visitFieldFormalParameter_functionTyped() {
     _assertSource("A this.a(b)", AstFactory.fieldFormalParameter(null,
         AstFactory.typeName4("A"), "a", AstFactory
             .formalParameterList([AstFactory.simpleFormalParameter3("b")])));
   }
 
+  void test_visitFieldFormalParameter_functionTyped_typeParameters() {
+    _assertSource("A this.a<E, F>(b)", new FieldFormalParameter(null, null,
+        null, AstFactory.typeName4('A'),
+        TokenFactory.tokenFromKeyword(Keyword.THIS),
+        TokenFactory.tokenFromType(TokenType.PERIOD),
+        AstFactory.identifier3('a'), AstFactory.typeParameterList(['E', 'F']),
+        AstFactory
+            .formalParameterList([AstFactory.simpleFormalParameter3("b")])));
+  }
+
   void test_visitFieldFormalParameter_keyword() {
     _assertSource(
         "var this.a", AstFactory.fieldFormalParameter(Keyword.VAR, null, "a"));
   }
 
   void test_visitFieldFormalParameter_keywordAndType() {
     _assertSource("final A this.a", AstFactory.fieldFormalParameter(
         Keyword.FINAL, AstFactory.typeName4("A"), "a"));
   }
 
@@ skipping 254 matching lines @@
   void test_visitFunctionDeclaration_normal() {
     _assertSource("f() {}", AstFactory.functionDeclaration(
         null, null, "f", AstFactory.functionExpression()));
   }
 
   void test_visitFunctionDeclaration_setter() {
     _assertSource("set f() {}", AstFactory.functionDeclaration(
         null, Keyword.SET, "f", AstFactory.functionExpression()));
   }
 
+  void test_visitFunctionDeclaration_typeParameters() {
+    _assertSource("f<E>() {}", AstFactory.functionDeclaration(null, null, "f",
+        AstFactory.functionExpression3(AstFactory.typeParameterList(['E']),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2())));
+  }
+
   void test_visitFunctionDeclaration_withMetadata() {
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null, null, "f", AstFactory.functionExpression());
     declaration.metadata
         .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertSource("@deprecated f() {}", declaration);
   }
 
   void test_visitFunctionDeclarationStatement() {
     _assertSource("f() {}", AstFactory.functionDeclarationStatement(
         null, null, "f", AstFactory.functionExpression()));
   }
 
   void test_visitFunctionExpression() {
     _assertSource("() {}", AstFactory.functionExpression());
   }
 
-  void test_visitFunctionExpressionInvocation() {
+  void test_visitFunctionExpression_typeParameters() {
+    _assertSource("<E>() {}", AstFactory.functionExpression3(
+        AstFactory.typeParameterList(['E']), AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2()));
+  }
+
+  void test_visitFunctionExpressionInvocation_minimal() {
     _assertSource("f()",
         AstFactory.functionExpressionInvocation(AstFactory.identifier3("f")));
   }
 
+  void test_visitFunctionExpressionInvocation_typeArguments() {
+    _assertSource("f<A>()", AstFactory.functionExpressionInvocation2(
+        AstFactory.identifier3("f"),
+        AstFactory.typeArgumentList([AstFactory.typeName4('A')])));
+  }
+
   void test_visitFunctionTypeAlias_generic() {
     _assertSource("typedef A F<B>();", AstFactory.typeAlias(
         AstFactory.typeName4("A"), "F", AstFactory.typeParameterList(["B"]),
         AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_nonGeneric() {
     _assertSource("typedef A F();", AstFactory.typeAlias(
         AstFactory.typeName4("A"), "F", null,
         AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_withMetadata() {
     FunctionTypeAlias declaration = AstFactory.typeAlias(
         AstFactory.typeName4("A"), "F", null, AstFactory.formalParameterList());
     declaration.metadata
         .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertSource("@deprecated typedef A F();", declaration);
   }
 
   void test_visitFunctionTypedFormalParameter_noType() {
     _assertSource("f()", AstFactory.functionTypedFormalParameter(null, "f"));
   }
 
   void test_visitFunctionTypedFormalParameter_type() {
     _assertSource("T f()", AstFactory.functionTypedFormalParameter(
         AstFactory.typeName4("T"), "f"));
   }
 
+  void test_visitFunctionTypedFormalParameter_typeParameters() {
+    _assertSource("T f<E>()", new FunctionTypedFormalParameter(null, null,
+        AstFactory.typeName4("T"), AstFactory.identifier3('f'),
+        AstFactory.typeParameterList(['E']),
+        AstFactory.formalParameterList([])));
+  }
+
   void test_visitIfStatement_withElse() {
     _assertSource("if (c) {} else {}", AstFactory.ifStatement2(
         AstFactory.identifier3("c"), AstFactory.block(), AstFactory.block()));
   }
 
   void test_visitIfStatement_withoutElse() {
     _assertSource("if (c) {}", AstFactory.ifStatement(
         AstFactory.identifier3("c"), AstFactory.block()));
   }
 
@@ skipping 281 matching lines @@
         AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_static_returnType() {
     _assertSource("static T m() {}", AstFactory.methodDeclaration2(
         Keyword.STATIC, AstFactory.typeName4("T"), null, null,
         AstFactory.identifier3("m"), AstFactory.formalParameterList(),
         AstFactory.blockFunctionBody2()));
   }
 
+  void test_visitMethodDeclaration_typeParameters() {
+    _assertSource("m<E>() {}", AstFactory.methodDeclaration3(null, null, null,
+        null, AstFactory.identifier3("m"), AstFactory.typeParameterList(['E']),
+        AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+  }
+
   void test_visitMethodDeclaration_withMetadata() {
     MethodDeclaration declaration = AstFactory.methodDeclaration2(null, null,
         null, null, AstFactory.identifier3("m"),
         AstFactory.formalParameterList(), AstFactory.blockFunctionBody2());
     declaration.metadata
         .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertSource("@deprecated m() {}", declaration);
   }
 
   void test_visitMethodInvocation_conditional() {
     _assertSource("t?.m()", AstFactory.methodInvocation(
         AstFactory.identifier3("t"), "m", null, TokenType.QUESTION_PERIOD));
   }
 
   void test_visitMethodInvocation_noTarget() {
     _assertSource("m()", AstFactory.methodInvocation2("m"));
   }
 
   void test_visitMethodInvocation_target() {
     _assertSource(
         "t.m()", AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
   }
 
+  void test_visitMethodInvocation_typeArguments() {
+    _assertSource("m<A>()", AstFactory.methodInvocation3(
+        null, "m", AstFactory.typeArgumentList([AstFactory.typeName4('A')])));
+  }
+
   void test_visitNamedExpression() {
     _assertSource(
         "a: b", AstFactory.namedExpression2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitNamedFormalParameter() {
     _assertSource("var a : 0", AstFactory.namedFormalParameter(
         AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
         AstFactory.integer(0)));
   }
@@ skipping 443 matching lines @@
   static const List<WrapperKind> values = const [
     PREFIXED_LEFT,
     PREFIXED_RIGHT,
     PROPERTY_LEFT,
     PROPERTY_RIGHT,
     NONE
   ];
 
   const WrapperKind(String name, int ordinal) : super(name, ordinal);
 }