tweak FunctionTypeImpl to support generic methods

pkg/analyzer/test/generated/element_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 engine.element_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisOptionsImpl;
@@ skipping 1871 matching lines @@
         ElementFactory.functionTypeAliasElement('f');
     FunctionTypeAliasElementImpl g =
         ElementFactory.functionTypeAliasElement('g');
     f.typeParameters = [ElementFactory.typeParameterElement('T')];
     f.returnType = g.type;
     FunctionTypeImpl paramType = f.type.returnType;
     expect(paramType.prunedTypedefs, hasLength(1));
     expect(paramType.prunedTypedefs[0], same(f));
   }
 
-  void test_setTypeArguments() {
+  void test_withTypeArguments() {
     ClassElementImpl enclosingClass = ElementFactory.classElement2("C", ["E"]);
     MethodElementImpl methodElement =
         new MethodElementImpl.forNode(AstFactory.identifier3("m"));
     enclosingClass.methods = <MethodElement>[methodElement];
     FunctionTypeImpl type = new FunctionTypeImpl(methodElement);
     DartType expectedType = enclosingClass.typeParameters[0].type;
-    type.typeArguments = <DartType>[expectedType];
     List<DartType> arguments = type.typeArguments;
     expect(arguments, hasLength(1));
     expect(arguments[0], expectedType);
   }
 
   void test_substitute2_equal() {
     ClassElementImpl definingClass = ElementFactory.classElement2("C", ["E"]);
     TypeParameterType parameterType = definingClass.typeParameters[0].type;
     MethodElementImpl functionElement =
         new MethodElementImpl.forNode(AstFactory.identifier3("m"));
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("a", parameterType),
       ElementFactory.positionalParameter2("b", parameterType),
       ElementFactory.namedParameter2(namedParameterName, parameterType)
     ];
     functionElement.returnType = parameterType;
     definingClass.methods = <MethodElement>[functionElement];
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
-    functionType.typeArguments = <DartType>[parameterType];
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl(
         new ClassElementImpl.forNode(AstFactory.identifier3("D")));
     FunctionType result = functionType.substitute2(
         <DartType>[argumentType], <DartType>[parameterType]);
     expect(result.returnType, argumentType);
     List<DartType> normalParameters = result.normalParameterTypes;
     expect(normalParameters, hasLength(1));
     expect(normalParameters[0], argumentType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
     expect(optionalParameters, hasLength(1));
@@ skipping 489 matching lines @@
     expect(typeA.getGetter(getterName), same(getterG));
   }
 
   void test_getGetter_parameterized() {
     //
     // class A<E> { E get g {} }
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     DartType typeE = classA.type.typeArguments[0];
     String getterName = "g";
-    PropertyAccessorElement getterG =
+    PropertyAccessorElementImpl getterG =
         ElementFactory.getterElement(getterName, false, typeE);
     classA.accessors = <PropertyAccessorElement>[getterG];
-    (getterG.type as FunctionTypeImpl).typeArguments =
-        classA.type.typeArguments;
+    getterG.type = new FunctionTypeImpl(getterG);
     //
     // A<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I").type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl(classA);
     typeAI.typeArguments = <DartType>[typeI];
     PropertyAccessorElement getter = typeAI.getGetter(getterName);
     expect(getter, isNotNull);
     FunctionType getterType = getter.type;
     expect(getterType.returnType, same(typeI));
@@ skipping 302 matching lines @@
   void test_getMethod_parameterized() {
     //
     // class A<E> { E m(E p) {} }
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     DartType typeE = classA.type.typeArguments[0];
     String methodName = "m";
     MethodElementImpl methodM =
         ElementFactory.methodElement(methodName, typeE, [typeE]);
     classA.methods = <MethodElement>[methodM];
-    (methodM.type as FunctionTypeImpl).typeArguments =
-        classA.type.typeArguments;
+    methodM.type = new FunctionTypeImpl(methodM);
     //
     // A<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I").type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl(classA);
     typeAI.typeArguments = <DartType>[typeI];
     MethodElement method = typeAI.getMethod(methodName);
     expect(method, isNotNull);
     FunctionType methodType = method.type;
     expect(methodType.returnType, same(typeI));
@@ skipping 83 matching lines @@
     expect(typeA.getSetter(setterName), same(setterS));
   }
 
   void test_getSetter_parameterized() {
     //
     // class A<E> { set s(E p) {} }
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     DartType typeE = classA.type.typeArguments[0];
     String setterName = "s";
-    PropertyAccessorElement setterS =
+    PropertyAccessorElementImpl setterS =
         ElementFactory.setterElement(setterName, false, typeE);
     classA.accessors = <PropertyAccessorElement>[setterS];
-    (setterS.type as FunctionTypeImpl).typeArguments =
-        classA.type.typeArguments;
+    setterS.type = new FunctionTypeImpl(setterS);
     //
     // A<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I").type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl(classA);
     typeAI.typeArguments = <DartType>[typeI];
     PropertyAccessorElement setter = typeAI.getSetter(setterName);
     expect(setter, isNotNull);
     FunctionType setterType = setter.type;
     List<DartType> parameterTypes = setterType.normalParameterTypes;
@@ skipping 640 matching lines @@
     //
     // class A<E> { E m(E p) {} }
     // class B<F> extends A<F> {}
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     DartType typeE = classA.type.typeArguments[0];
     String methodName = "m";
     MethodElementImpl methodM =
         ElementFactory.methodElement(methodName, typeE, [typeE]);
     classA.methods = <MethodElement>[methodM];
-    (methodM.type as FunctionTypeImpl).typeArguments =
-        classA.type.typeArguments;
+    methodM.type = new FunctionTypeImpl(methodM);
     ClassElementImpl classB = ElementFactory.classElement2("B", ["F"]);
     InterfaceType typeB = classB.type;
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl(classA);
     typeAF.typeArguments = <DartType>[typeB.typeArguments[0]];
     classB.supertype = typeAF;
     LibraryElementImpl library =
         ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library.definingCompilationUnit;
     (unit as CompilationUnitElementImpl).types = <ClassElement>[classA];
     //
@@ skipping 738 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }