tweak FunctionTypeImpl to support generic methods

pkg/analyzer/test/generated/resolver_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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 183 matching lines @@
     // Future
     ClassElementImpl futureElement =
         ElementFactory.classElement2("Future", ["T"]);
     //   factory Future.value([value])
     ConstructorElementImpl futureConstructor =
         ElementFactory.constructorElement2(futureElement, "value");
     futureConstructor.parameters = <ParameterElement>[
       ElementFactory.positionalParameter2("value", provider.dynamicType)
     ];
     futureConstructor.factory = true;
-    (futureConstructor.type as FunctionTypeImpl).typeArguments =
-        futureElement.type.typeArguments;
     futureElement.constructors = <ConstructorElement>[futureConstructor];
     //   Future then(onValue(T value), { Function onError });
     List<ParameterElement> parameters = <ParameterElement>[
       ElementFactory.requiredParameter2(
           "value", futureElement.typeParameters[0].type)
     ];
     FunctionTypeAliasElementImpl aliasElement =
         new FunctionTypeAliasElementImpl.forNode(null);
     aliasElement.synthetic = true;
     aliasElement.parameters = parameters;
     aliasElement.returnType = provider.dynamicType;
     aliasElement.enclosingElement = asyncUnit;
+    aliasElement.shareTypeParameters(futureElement.typeParameters);
     FunctionTypeImpl aliasType = new FunctionTypeImpl.forTypedef(aliasElement);
-    aliasElement.shareTypeParameters(futureElement.typeParameters);
-    aliasType.typeArguments = futureElement.type.typeArguments;
+    aliasElement.type = aliasType;
     DartType futureDynamicType =
         futureElement.type.substitute4([provider.dynamicType]);
     MethodElement thenMethod = ElementFactory.methodElementWithParameters(
-        "then", futureElement.type.typeArguments, futureDynamicType, [
+        futureElement, "then", futureDynamicType, [
       ElementFactory.requiredParameter2("onValue", aliasType),
       ElementFactory.namedParameter2("onError", provider.functionType)
     ]);
     futureElement.methods = <MethodElement>[thenMethod];
     // Completer
     ClassElementImpl completerElement =
         ElementFactory.classElement2("Completer", ["T"]);
     ConstructorElementImpl completerConstructor =
         ElementFactory.constructorElement2(completerElement, null);
-    (completerConstructor.type as FunctionTypeImpl).typeArguments =
-        completerElement.type.typeArguments;
     completerElement.constructors = <ConstructorElement>[completerConstructor];
     // StreamSubscription
     ClassElementImpl streamSubscriptionElement =
         ElementFactory.classElement2("StreamSubscription", ["T"]);
     // Stream
     ClassElementImpl streamElement =
         ElementFactory.classElement2("Stream", ["T"]);
     streamElement.constructors = <ConstructorElement>[
       ElementFactory.constructorElement2(streamElement, null)
     ];
     DartType returnType = streamSubscriptionElement.type
         .substitute4(streamElement.type.typeArguments);
     List<DartType> parameterTypes = <DartType>[
       ElementFactory
           .functionElement3('onData', VoidTypeImpl.instance.element,
               <TypeDefiningElement>[streamElement.typeParameters[0]], null)
           .type,
     ];
     // TODO(brianwilkerson) This is missing the optional parameters.
     MethodElementImpl listenMethod =
         ElementFactory.methodElement('listen', returnType, parameterTypes);
-    (listenMethod.type as FunctionTypeImpl).typeArguments =
-        streamElement.type.typeArguments;
-    (parameterTypes[0] as FunctionTypeImpl).typeArguments =
-        streamElement.type.typeArguments;
-    (parameterTypes[0].element as FunctionElementImpl).enclosingElement =
-        listenMethod;
     streamElement.methods = <MethodElement>[listenMethod];
+    listenMethod.type = new FunctionTypeImpl(listenMethod);
+
+    FunctionElementImpl listenParamFunction = parameterTypes[0].element;
+    listenParamFunction.enclosingElement = listenMethod;
+    listenParamFunction.type = new FunctionTypeImpl(listenParamFunction);
+    ParameterElementImpl listenParam = listenMethod.parameters[0];
+    listenParam.type = listenParamFunction.type;
 
     asyncUnit.types = <ClassElement>[
       completerElement,
       futureElement,
       streamElement
     ];
     LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "async"]));
     asyncLibrary.definingCompilationUnit = asyncUnit;
     //
@@ skipping 11894 matching lines @@
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
     expect(declaration.initializer.staticType.name, 'String');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
+  void test_genericFunction() {
+    // TODO(jmesserly): we're missing a case in the parser for the return type,
+    // so "dynamic" must be used to workaround this.
+    _resolveTestUnit(r'''
+dynamic/*=T*/ f/*<T>*/(/*=T*/ x) => null;
+''');
+    SimpleIdentifier f = _findIdentifier('f');
+    FunctionElementImpl e = f.staticElement;
+    expect(e.typeParameters.toString(), '[T]');
+    expect(e.type.typeParameters.toString(), '[T]');
+    expect(e.type.typeParameters[0].type, e.type.typeArguments[0]);
+    expect(e.type.toString(), '(T) → T');
+
+    // Substitute for T
+    DartType t = e.typeParameters[0].type;
+    FunctionType ft = e.type.substitute2([typeProvider.stringType], [t]);
+    expect(ft.toString(), '(String) → String');
+  }
+
+  void test_genericMethod() {
+    _resolveTestUnit(r'''
+class C<E> {
+  List/*<T>*/ f/*<T>*/(E e) => null;
+}
+main() {
+  C<String> cOfString;
+}
+''');
+    SimpleIdentifier f = _findIdentifier('f');
+    MethodElementImpl e = f.staticElement;
+    expect(e.typeParameters.toString(), '[T]');
+    expect(e.type.typeParameters.toString(), '[T, E]');
+    expect(e.type.typeArguments.toString(), '[T, E]');
+    expect(e.type.toString(), '(E) → List<T>');
+
+    SimpleIdentifier c = _findIdentifier('cOfString');
+    FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
+    expect(ft.toString(), '(String) → List<T>');
+    DartType t = e.typeParameters[0].type;
+    ft = ft.substitute2([typeProvider.intType], [t]);
+    expect(ft.toString(), '(String) → List<int>');
+  }
+
   void test_pseudoGeneric_max_doubleDouble() {
     String code = r'''
 import 'dart:math';
 main() {
   var foo = max(1.0, 2.0);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
@@ skipping 2935 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }