fixes #27586, prefer context type in generic inference

pkg/dev_compiler/tool/input_sdk/lib/async/future_impl.dart

 // Copyright (c) 2012, 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.
 
 part of dart.async;
 
 /** The onValue and onError handlers return either a value or a future */
 typedef dynamic/*T|Future<T>*/ _FutureOnValue<S, T>(S value);
 /** Test used by [Future.catchError] to handle skip some errors. */
 typedef bool _FutureErrorTest(var error);
@@ skipping 110 matching lines @@
 
   /// Whether this listener has an error callback.
   ///
   /// This function must only be called if the listener [handlesError].
   bool get hasErrorCallback {
     assert(handlesError);
     return _onError != null;
   }
 
   dynamic/*T|Future<T>*/ handleValue(S sourceResult) {
-    return _zone.runUnary<dynamic/*T|Future<T>*/, S>(
+    return _zone.runUnary/*<dynamic/*T|Future<T>*/, S>*/(
         _onValue, sourceResult);
   }
 
   bool matchesErrorTest(AsyncError asyncError) {
     if (!hasErrorTest) return true;
     _FutureErrorTest test = _errorTest;
-    return _zone.runUnary<bool, dynamic>(_errorTest, asyncError.error);
+    return _zone.runUnary/*<bool, dynamic>*/(_errorTest, asyncError.error);
   }
 
   dynamic/*T|Future<T>*/ handleError(AsyncError asyncError) {
     assert(handlesError && hasErrorCallback);
     if (errorCallback is ZoneBinaryCallback) {
       var typedErrorCallback = errorCallback as Object
           /*=ZoneBinaryCallback<Object/*T|Future<T>*/, Object, StackTrace>*/;
       return _zone.runBinary(typedErrorCallback,
           asyncError.error,
           asyncError.stackTrace);
     } else {
-      return _zone.runUnary<dynamic/*T|Future<T>*/, dynamic>(
+      return _zone.runUnary/*<dynamic/*T|Future<T>*/, dynamic>*/(
           errorCallback, asyncError.error);
     }
   }
 
   dynamic handleWhenComplete() {
     assert(!handlesError);
     return _zone.run(_whenCompleteAction);
   }
 }
 
@@ skipping 62 matching lines @@
   bool get _isChained         => _state == _CHAINED;
   bool get _isComplete        => _state >= _VALUE;
   bool get _hasError          => _state == _ERROR;
 
   void _setChained(_Future source) {
     assert(_mayAddListener);
     _state = _CHAINED;
     _resultOrListeners = source;
   }
 
-  Future<E> then<E>(
-      FutureOr<E> f(T value), { Function onError }) {
+  Future/*<E>*/ then/*<E>*/(
+      /*=dynamic/*E|Future<E>*/*/ f(T value), { Function onError }) {
     Zone currentZone = Zone.current;
     ZoneUnaryCallback registered;
     if (!identical(currentZone, _ROOT_ZONE)) {
-      f = currentZone.registerUnaryCallback<FutureOr<E>, T>(f);
+      f = currentZone.registerUnaryCallback/*<dynamic, T>*/(f);
       if (onError != null) {
-        onError = _registerErrorHandler<T>(onError, currentZone);
+        onError = _registerErrorHandler/*<T>*/(onError, currentZone);
       }
     }
-    return _thenNoZoneRegistration<E>(f, onError);
+    return _thenNoZoneRegistration/*<E>*/(f, onError);
   }
 
   // This method is used by async/await.
-  Future<E> _thenNoZoneRegistration<E>(f(T value), Function onError) {
-    _Future<E> result = new _Future<E>();
-    _addListener(new _FutureListener<T, E>.then(result, f, onError));
+  Future/*<E>*/ _thenNoZoneRegistration/*<E>*/(f(T value), Function onError) {
+    _Future/*<E>*/ result = new _Future/*<E>*/();
+    _addListener(new _FutureListener/*<T, E>*/.then(result, f, onError));
     return result;
   }
 
-  Future<T> catchError(Function onError, { bool test(error) }) {
-    _Future<T> result = new _Future<T>();
+  Future/*<T>*/ catchError(Function onError, { bool test(error) }) {
+    _Future/*<T>*/ result = new _Future/*<T>*/();
     if (!identical(result._zone, _ROOT_ZONE)) {
-      onError = _registerErrorHandler<T>(onError, result._zone);
+      onError = _registerErrorHandler/*<T>*/(onError, result._zone);
       if (test != null) test = result._zone.registerUnaryCallback(test);
     }
-    _addListener(new _FutureListener<T, T>.catchError(
+    _addListener(new _FutureListener/*<T, T>*/.catchError(
         result, onError, test));
     return result;
   }
 
   Future<T> whenComplete(action()) {
     _Future<T> result = new _Future<T>();
     if (!identical(result._zone, _ROOT_ZONE)) {
-      action = result._zone.registerCallback<dynamic>(action);
+      action = result._zone.registerCallback/*<dynamic>*/(action);
     }
-    _addListener(new _FutureListener<T, T>.whenComplete(result, action));
+    _addListener(new _FutureListener/*<T, T>*/.whenComplete(result, action));
     return result;
   }
 
   Stream<T> asStream() => new Stream<T>.fromFuture(this);
 
   void _setPendingComplete() {
     assert(_mayComplete);
     _state = _PENDING_COMPLETE;
   }
 
-  void _clearPendingComplete() {
-    assert(_isPendingComplete);
-    _state = _INCOMPLETE;
-  }
-
   AsyncError get _error {
     assert(_hasError);
     return _resultOrListeners;
   }
 
   _Future get _chainSource {
     assert(_isChained);
     return _resultOrListeners;
   }
 
@@ skipping 108 matching lines @@
   // in that case.
   static void _chainForeignFuture(Future source, _Future target) {
     assert(!target._isComplete);
     assert(source is! _Future);
 
     // Mark the target as chained (and as such half-completed).
     target._setPendingComplete();
     try {
       source.then((value) {
           assert(target._isPendingComplete);
-          // The "value" may be another future if the foreign future
-          // implementation is mis-behaving,
-          // so use _complete instead of _completeWithValue.
-          target._clearPendingComplete();  // Clear this first, it's set again.
-          target._complete(value);
+          target._completeWithValue(value);
         },
         // TODO(floitsch): eventually we would like to make this non-optional
         // and dependent on the listeners of the target future. If none of
         // the target future's listeners want to have the stack trace we don't
         // need a trace.
         onError: (error, [stackTrace]) {
           assert(target._isPendingComplete);
           target._completeError(error, stackTrace);
         });
     } catch (e, s) {
@@ skipping 224 matching lines @@
           } catch (e, s) {
             if (identical(source._error.error, e)) {
               listenerValueOrError = source._error;
             } else {
               listenerValueOrError = new AsyncError(e, s);
             }
             listenerHasError = true;
           }
         }
 
-
+ 
         if (listener.handlesComplete) {
           handleWhenCompleteCallback();
         } else if (!hasError) {
           if (listener.handlesValue) {
             handleValueCallback();
           }
         } else {
           if (listener.handlesError) {
             handleError();
           }
         }
-
+        
         // If we changed zone, oldZone will not be null.
         if (oldZone != null) Zone._leave(oldZone);
 
         // If the listener's value is a future we need to chain it. Note that
         // this can only happen if there is a callback.
         if (listenerValueOrError is Future) {
           Future chainSource = listenerValueOrError;
           // Shortcut if the chain-source is already completed. Just continue
           // the loop.
           _Future result = listener.result;
@@ skipping 52 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }