generic method type parameter inference

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 185 matching lines @@
         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;
     futureElement.constructors = <ConstructorElement>[futureConstructor];
     //   Future then(onValue(T value), { Function onError });
-    List<ParameterElement> parameters = <ParameterElement>[
-      ElementFactory.requiredParameter2(
-          "value", futureElement.typeParameters[0].type)
-    ];
-    FunctionElementImpl onValueFunction = new FunctionElementImpl.forNode(null);
-    onValueFunction.synthetic = true;
-    onValueFunction.parameters = parameters;
-    onValueFunction.returnType = provider.dynamicType;
-    onValueFunction.enclosingElement = futureElement;
-    onValueFunction.type = new FunctionTypeImpl(onValueFunction);
-    DartType futureDynamicType =
-        futureElement.type.substitute4([provider.dynamicType]);
-    MethodElement thenMethod = ElementFactory.methodElementWithParameters(
-        futureElement, "then", futureDynamicType, [
-      ElementFactory.requiredParameter2("onValue", onValueFunction.type),
+    TypeDefiningElement futureThenR = DynamicElementImpl.instance;
+    if (context.analysisOptions.strongMode) {
+      futureThenR = ElementFactory.typeParameterWithType('R');
+    }
+    FunctionElementImpl thenOnValue = ElementFactory.functionElement3(
+        'onValue', futureThenR, [futureElement.typeParameters[0]], null);
+
+    DartType futureRType = futureElement.type.substitute4([futureThenR.type]);
+    MethodElementImpl thenMethod = ElementFactory.methodElementWithParameters(
+        futureElement, "then", futureRType, [
+      ElementFactory.requiredParameter2("onValue", thenOnValue.type),
       ElementFactory.namedParameter2("onError", provider.functionType)
     ]);
+    if (!futureThenR.type.isDynamic) {
+      thenMethod.typeParameters = [futureThenR];
+    }
+    thenOnValue.enclosingElement = thenMethod;
+    thenOnValue.type = new FunctionTypeImpl(thenOnValue);
+    (thenMethod.parameters[0] as ParameterElementImpl).type = thenOnValue.type;
+    thenMethod.type = new FunctionTypeImpl(thenMethod);
+
     futureElement.methods = <MethodElement>[thenMethod];
     // Completer
     ClassElementImpl completerElement =
         ElementFactory.classElement2("Completer", ["T"]);
     ConstructorElementImpl completerConstructor =
         ElementFactory.constructorElement2(completerElement, null);
     completerElement.constructors = <ConstructorElement>[completerConstructor];
     // StreamSubscription
     ClassElementImpl streamSubscriptionElement =
         ElementFactory.classElement2("StreamSubscription", ["T"]);
@@ skipping 100 matching lines @@
     Source mathSource = sourceFactory.forUri(_DART_MATH);
     coreContext.setContents(mathSource, "");
     mathUnit.librarySource = mathUnit.source = mathSource;
     FunctionElement cosElement = ElementFactory.functionElement3(
         "cos",
         provider.doubleType.element,
         <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     TopLevelVariableElement ln10Element = ElementFactory
         .topLevelVariableElement3("LN10", true, false, provider.doubleType);
-    FunctionElement maxElement = ElementFactory.functionElement3(
-        "max",
-        provider.numType.element,
-        <ClassElement>[provider.numType.element, provider.numType.element],
-        ClassElement.EMPTY_LIST);
+    TypeParameterElement maxT =
+        ElementFactory.typeParameterWithType('T', provider.numType);
+    FunctionElementImpl maxElement = ElementFactory.functionElement3(
+        "max", maxT, [maxT, maxT], ClassElement.EMPTY_LIST);
+    maxElement.typeParameters = [maxT];
+    maxElement.type = new FunctionTypeImpl(maxElement);
     TopLevelVariableElement piElement = ElementFactory.topLevelVariableElement3(
         "PI", true, false, provider.doubleType);
     ClassElementImpl randomElement = ElementFactory.classElement2("Random");
     randomElement.abstract = true;
     ConstructorElementImpl randomConstructor =
         ElementFactory.constructorElement2(randomElement, null);
     randomConstructor.factory = true;
     ParameterElementImpl seedParam = new ParameterElementImpl("seed", 0);
     seedParam.parameterKind = ParameterKind.POSITIONAL;
     seedParam.type = provider.intType;
@@ skipping 14835 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }