generic method type parameter inference

pkg/analyzer/test/src/task/strong/strong_test_helper.dart

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this file needs to be refactored, it's a port from
 // package:dev_compiler's tests
 library test.src.task.strong.strong_test_helper;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
@@ skipping 352 matching lines @@
 
   bool get isInSystemLibrary => true;
 
   Source resolveRelative(Uri relativeUri) =>
       throw new UnsupportedError('not expecting relative urls in dart: mocks');
 
   Uri resolveRelativeUri(Uri relativeUri) =>
       throw new UnsupportedError('not expecting relative urls in dart: mocks');
 }
 
+// TODO(jmesserly): can we reuse the same mock SDK as Analyzer tests?

[Brian Wilkerson, 2015/11/19 00:10:17]

I certainly hope so! We control both.

 /// Sample mock SDK sources.
 final Map<String, String> mockSdkSources = {
   // The list of types below is derived from:
   //   * types we use via our smoke queries, including HtmlElement and
   //     types from `_typeHandlers` (deserialize.dart)
   //   * types that are used internally by the resolver (see
   //   _initializeFrom in resolver.dart).
   'dart:core': '''
         library dart.core;
 
@@ skipping 29 matching lines @@
           final String expires;
           const Deprecated(this.expires);
         }
         const Object deprecated = const Deprecated("next release");
         class _Override { const _Override(); }
         const Object override = const _Override();
         class _Proxy { const _Proxy(); }
         const Object proxy = const _Proxy();
 
         class Iterable<E> {
-          fold(initialValue, combine(previousValue, E element)) {}
-          Iterable map(f(E element)) {}
+          Iterable/*<R>*/ map/*<R>*/(/*=R*/ f(E e));
+
+          /*=R*/ fold/*<R>*/(/*=R*/ initialValue,
+              /*=R*/ combine(/*=R*/ previousValue, E element));
         }
         class List<E> implements Iterable<E> {
           List([int length]);
           List.filled(int length, E fill);
         }
         class Map<K, V> {
           Iterable<K> get keys {}
         }
         ''',
   'dart:async': '''
         class Future<T> {
           Future(computation()) {}
           Future.value(T t) {}
-          Future then(onValue(T value)) {}
-          static Future<List> wait(Iterable<Future> futures) {}
+          static Future<List/*<T>*/> wait/*<T>*/(
+              Iterable<Future/*<T>*/> futures) => null;
+          Future/*<R>*/ then/*<R>*/(/*=R*/ onValue(T value)) => null;
         }
         class Stream<T> {}
   ''',
   'dart:html': '''
         library dart.html;
         class HtmlElement {}
         ''',
   'dart:math': '''
         library dart.math;
         class Random {
           bool nextBool() {}
         }
-        num min(num x, num y) {}
-        num max(num x, num y) {}
+        num/*=T*/ min/*<T extends num>*/(num/*=T*/ a, num/*=T*/ b) => null;
+        num/*=T*/ max/*<T extends num>*/(num/*=T*/ a, num/*=T*/ b) => null;
         ''',
 };
 
 /// Returns all libraries transitively imported or exported from [start].
 List<LibraryElement> reachableLibraries(LibraryElement start) {
   var results = <LibraryElement>[];
   var seen = new Set();
   void find(LibraryElement lib) {
     if (seen.contains(lib)) return;
     seen.add(lib);
@@ skipping 28 matching lines @@
   if (levelName == 'warning') return _MAGENTA_COLOR;
   if (levelName == 'info') return _CYAN_COLOR;
   return null;
 }
 
 const String _RED_COLOR = '\u001b[31m';
 const String _MAGENTA_COLOR = '\u001b[35m';
 const String _CYAN_COLOR = '\u001b[36m';
 const String GREEN_COLOR = '\u001b[32m';
 const String NO_COLOR = '\u001b[0m';