Add generic annotations to more SDK APIs.

sdk/lib/async/future_impl.dart

Index: sdk/lib/async/future_impl.dart
diff --git a/sdk/lib/async/future_impl.dart b/sdk/lib/async/future_impl.dart
index 8ca10c99c7f55bfedec0ddb23f6445eb4afd45e6..2da3f6e0cb5bb75f97ba6cd1bad705d1831ab028 100644
--- a/sdk/lib/async/future_impl.dart
+++ b/sdk/lib/async/future_impl.dart
@@ -191,7 +191,7 @@ class _Future<T> implements Future<T> {
     _resultOrListeners = source;
   }
 
-  Future then(f(T value), { Function onError }) {
+  Future/*<S>*/ then/*<S>*/(/*=S*/ f(T value), { Function onError }) {

[floitsch, 2016/03/18 14:46:02]

That's not correct.
f is allowed to return S or a Future<S>

[Leaf, 2016/03/18 16:20:30]

You can instantiate S with Future<S> when f returns Future, and then Future
flattening does the right thing on the return type.  It's a total hack, but
without union or intersection types and/or intrinsic support for the future
operations its the best we can do right now.   We could type f as returning
dynamic, but then inference won't be able to use the return type of the passed
closure to figure out the instantiation.

[floitsch, 2016/03/18 16:39:05]

I don't think I agree with that type-information. It just leads to troubles in
the next '.then' call.
In other words, what should X be in the following expression?

f.then<X>(new Future.value(499)).then((int x) => x);

[Leaf, 2016/03/18 17:04:43]

Assuming that you mean to pass a closure to the first .then:

  f.then<Future<int>>((_) => new Future.value(499)).then<int>((int x) => x);

The first .then returns Future<Future<int>> == Future<int>, and so the second
.then expects a closure taking an int and returning an int.

Does that make sense, or am I missing the gist of your example?

     Zone currentZone = Zone.current;
     if (!identical(currentZone, _ROOT_ZONE)) {
       f = currentZone.registerUnaryCallback(f);