Handle Future result from Future.sync computation

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 _FutureOnValue<T>(T value);
 typedef dynamic _FutureOnError(error);
 /** Test used by [Future.catchError] to handle skip some errors. */
@@ skipping 125 matching lines @@
   _FutureOnValue get _onValue => _isChained ? null : _onValueCallback;
   _FutureErrorTest get _errorTest => _isChained ? null : _errorTestCallback;
   _FutureOnError get _onError => _isChained ? null : _onErrorCallback;
   _FutureAction get _whenCompleteAction
       => _isChained ? null : _whenCompleteActionCallback;
 
   _Future()
       : _onValueCallback = null, _errorTestCallback = null,
         _onErrorCallback = null, _whenCompleteActionCallback = null;
 
-  _Future.immediate(T value)
+  /// Valid types for value: `T` or `Future<T>`.
+  _Future.immediate(value)
         : _onValueCallback = null, _errorTestCallback = null,
           _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncComplete(value);
   }
 
   _Future.immediateError(var error, [Object stackTrace])
       : _onValueCallback = null, _errorTestCallback = null,
         _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncCompleteError(error, stackTrace);
   }
@@ skipping 157 matching lines @@
     // 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.
+
+    // Assign to typed variables so we get earlier checks in checked mode.
+    if (value is Future) {
+      Future<T> typedFuture = value;
+    } else {
+      T typedValue = value;
+    }
+
     if (value is Future &&
         (value is! _Future || !(value as _Future)._isComplete)) {
       // Case 2 from above. We need to register.
       // Note that we are still completing asynchronously: either we register
       // through .then (in which case the completing is asynchronous), or we
       // have a _Future which isn't complete yet.
       _complete(value);
       return;
     }
 
@@ skipping 172 matching lines @@
         listener._setValue(listenerValueOrError);
       } else {
         listeners = listener._removeListeners();
         listener._setError(listenerValueOrError);
       }
       // Prepare for next round.
       source = listener;
     }
   }
 }