More minor type improvements in dart:async.

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 FutureOr<T> _FutureOnValue<S, T>(S value);
 /** Test used by [Future.catchError] to handle skip some errors. */
-typedef bool _FutureErrorTest(var error);
+typedef bool _FutureErrorTest(Object error);
 /** Used by [WhenFuture]. */
-typedef _FutureAction();
+typedef dynamic _FutureAction();
 
 abstract class _Completer<T> implements Completer<T> {
   final _Future<T> future = new _Future<T>();
 
   void complete([FutureOr<T> value]);
 
   void completeError(Object error, [StackTrace stackTrace]) {
     error = _nonNullError(error);
     if (!future._mayComplete) throw new StateError("Future already completed");
     AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
@@ skipping 33 matching lines @@
   }
 }
 
 class _FutureListener<S, T> {
   static const int MASK_VALUE = 1;
   static const int MASK_ERROR = 2;
   static const int MASK_TEST_ERROR = 4;
   static const int MASK_WHENCOMPLETE = 8;
   static const int STATE_CHAIN = 0;
   static const int STATE_THEN = MASK_VALUE;
-  // TODO(johnmccutchan): Remove the hard coded value. See #26030.
-  static const int STATE_THEN_ONERROR = 3; // MASK_VALUE | MASK_ERROR.
+  static const int STATE_THEN_ONERROR = MASK_VALUE | MASK_ERROR;
   static const int STATE_CATCHERROR = MASK_ERROR;
-  // TODO(johnmccutchan): Remove the hard coded value. See #26030.
-  static const int STATE_CATCHERROR_TEST = 6; // MASK_ERROR | MASK_TEST_ERROR.
+  static const int STATE_CATCHERROR_TEST = MASK_ERROR | MASK_TEST_ERROR;
   static const int STATE_WHENCOMPLETE = MASK_WHENCOMPLETE;
   // Listeners on the same future are linked through this link.
   _FutureListener _nextListener = null;
   // The future to complete when this listener is activated.
   final _Future<T> result;
   // Which fields means what.
   final int state;
   // Used for then/whenDone callback and error test
   final Function callback;
   // Used for error callbacks.
@@ skipping 45 matching lines @@
     assert(handlesError);
     return _onError != null;
   }
 
   FutureOr<T> handleValue(S sourceResult) {
     return _zone.runUnary<FutureOr<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, Object>(_errorTest, asyncError.error);
   }
 
   FutureOr<T> handleError(AsyncError asyncError) {
     assert(handlesError && hasErrorCallback);
     if (errorCallback is ZoneBinaryCallback) {
       var typedErrorCallback = errorCallback as Object
           /*=ZoneBinaryCallback<FutureOr<T>, Object, StackTrace>*/;
       return _zone.runBinary(
           typedErrorCallback, asyncError.error, asyncError.stackTrace);
     } else {
-      return _zone.runUnary<FutureOr<T>, dynamic>(
+      return _zone.runUnary<FutureOr<T>, Object>(
           errorCallback, asyncError.error);
     }
   }
 
   dynamic handleWhenComplete() {
     assert(!handlesError);
     return _zone.run(_whenCompleteAction);
   }
 }
 
@@ skipping 68 matching lines @@
   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}) {
     Zone currentZone = Zone.current;
-    ZoneUnaryCallback registered;
     if (!identical(currentZone, _ROOT_ZONE)) {
       f = currentZone.registerUnaryCallback<FutureOr<E>, T>(f);
       if (onError != null) {
         onError = _registerErrorHandler<E>(onError, currentZone);
       }
     }
     return _thenNoZoneRegistration<E>(f, onError);
   }
 
   // This method is used by async/await.
-  Future<E> _thenNoZoneRegistration<E>(f(T value), Function onError) {
+  Future<E> _thenNoZoneRegistration<E>(
+      FutureOr<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>();
     if (!identical(result._zone, _ROOT_ZONE)) {
       onError = _registerErrorHandler<T>(onError, result._zone);
       if (test != null) test = result._zone.registerUnaryCallback(test);
     }
     _addListener(new _FutureListener<T, T>.catchError(result, onError, test));
     return result;
   }
 
-  Future<T> whenComplete(action()) {
+  Future<T> whenComplete(dynamic action()) {
     _Future<T> result = new _Future<T>();
     if (!identical(result._zone, _ROOT_ZONE)) {
       action = result._zone.registerCallback<dynamic>(action);
     }
     _addListener(new _FutureListener<T, T>.whenComplete(result, action));
     return result;
   }
 
   Stream<T> asStream() => new Stream<T>.fromFuture(this);
 
@@ skipping 171 matching lines @@
       _FutureListener listeners = target._removeListeners();
       target._cloneResult(source);
       _propagateToListeners(target, listeners);
     } else {
       _FutureListener listeners = target._resultOrListeners;
       target._setChained(source);
       source._prependListeners(listeners);
     }
   }
 
-  void _complete(value) {
+  void _complete(FutureOr<T> value) {
     assert(!_isComplete);
-    if (value is Future) {
-      if (value is _Future) {
+    if (value is Future<T>) {
+      if (value is _Future<T>) {
         _chainCoreFuture(value, this);
       } else {
         _chainForeignFuture(value, this);
       }
     } else {
       _FutureListener listeners = _removeListeners();
       _setValue(value as Object/*=T*/);
       _propagateToListeners(this, listeners);
     }
   }
 
   void _completeWithValue(T value) {
     assert(!_isComplete);
     assert(value is! Future);
 
     _FutureListener listeners = _removeListeners();
     _setValue(value);
     _propagateToListeners(this, listeners);
   }
 
-  void _completeError(error, [StackTrace stackTrace]) {
+  void _completeError(Object error, [StackTrace stackTrace]) {
     assert(!_isComplete);
 
     _FutureListener listeners = _removeListeners();
     _setError(error, stackTrace);
     _propagateToListeners(this, listeners);
   }
 
-  void _asyncComplete(value) {
+  void _asyncComplete(FutureOr<T> value) {
     assert(!_isComplete);
     // Two corner cases if the value is a future:
     //   1. the future is already completed and an error.
     //   2. the future is not yet completed but might become an error.
     // The first case means that we must not immediately complete the Future,
     // as our code would immediately start propagating the error without
     // giving the time to install error-handlers.
     // However the second case requires us to deal with the value immediately.
     // Otherwise the value could complete with an error and report an
     // unhandled error, even though we know we are already going to listen to
     // it.
 
-    if (value is Future) {
-      // Assign to typed variables so we get earlier checks in checked mode.
-      Future<T> typedFuture = value as Object/*=Future<T>*/;
-      if (typedFuture is _Future) {
-        _Future<T> coreFuture = typedFuture;
-        if (coreFuture._hasError) {
+    if (value is Future<T>) {
+      if (value is _Future<T>) {
+        if (value._hasError) {
           // Case 1 from above. Delay completion to enable the user to register
           // callbacks.
           _setPendingComplete();
           _zone.scheduleMicrotask(() {
-            _chainCoreFuture(coreFuture, this);
+            _chainCoreFuture(value, this);
           });
         } else {
-          _chainCoreFuture(coreFuture, this);
+          _chainCoreFuture(value, this);
         }
       } else {
         // Case 2 from above. Chain the future immediately.
         // Note that we are still completing asynchronously (through
         // _chainForeignFuture).
-        _chainForeignFuture(typedFuture, this);
+        _chainForeignFuture(value, this);
       }
       return;
     }
     T typedValue = value as Object/*=T*/;
 
     _setPendingComplete();
     _zone.scheduleMicrotask(() {
       _completeWithValue(typedValue);
     });
   }
@@ skipping 171 matching lines @@
         result._setValue(listenerValueOrError);
       } else {
         AsyncError asyncError = listenerValueOrError;
         result._setErrorObject(asyncError);
       }
       // Prepare for next round.
       source = result;
     }
   }
 
-  Future<T> timeout(Duration timeLimit, {onTimeout()}) {
+  Future<T> timeout(Duration timeLimit, {FutureOr<T> onTimeout()}) {
     if (_isComplete) return new _Future.immediate(this);
     _Future<T> result = new _Future<T>();
     Timer timer;
     if (onTimeout == null) {
       timer = new Timer(timeLimit, () {
         result._completeError(
             new TimeoutException("Future not completed", timeLimit));
       });
     } else {
       Zone zone = Zone.current;
@@ skipping 13 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }