Use FutureOr more and make Future.sync return the resulting Future directly.

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(Object error);
@@ skipping 189 matching lines @@
    * The future is another future that his future is chained to. This future
    * is waiting for the other future to complete, and when it does, this future
    * will complete with the same result.
    * All listeners are forwarded to the other future.
    */
   var _resultOrListeners;
 
   // This constructor is used by async/await.
   _Future();
 
-  /// Valid types for value: `T` or `Future<T>`.
-  _Future.immediate(value) {
-    _asyncComplete(value);
+  _Future.immediate(FutureOr<T> result) {
+    _asyncComplete(result);
   }
 
   _Future.immediateError(var error, [StackTrace stackTrace]) {
     _asyncCompleteError(error, stackTrace);
   }
 
+  /** Creates a future that is already completed with the value. */
+  _Future.value(T value) {
+    _setValue(value);
+  }
+
   bool get _mayComplete => _state == _INCOMPLETE;
   bool get _isPendingComplete => _state == _PENDING_COMPLETE;
   bool get _mayAddListener => _state <= _PENDING_COMPLETE;
   bool get _isChained => _state == _CHAINED;
   bool get _isComplete => _state >= _VALUE;
   bool get _hasError => _state == _ERROR;
 
   void _setChained(_Future source) {
     assert(_mayAddListener);
     _state = _CHAINED;
@@ skipping 260 matching lines @@
     //   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<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(value, this);
-          });
-        } else {
-          _chainCoreFuture(value, this);
-        }
-      } else {
-        // Case 2 from above. Chain the future immediately.
-        // Note that we are still completing asynchronously (through
-        // _chainForeignFuture).
-        _chainForeignFuture(value, this);
-      }
+      _chainFuture(value);
       return;
     }
     T typedValue = value as Object/*=T*/;
 
     _setPendingComplete();
     _zone.scheduleMicrotask(() {
       _completeWithValue(typedValue);
     });
   }
 
+  void _chainFuture(Future<T> value) {
+    if (value is _Future<T>) {
+      if (value._hasError) {
+        // Delay completion to allow the user to register callbacks.
+        _setPendingComplete();
+        _zone.scheduleMicrotask(() {
+          _chainCoreFuture(value, this);
+        });
+      } else {
+        _chainCoreFuture(value, this);
+      }
+      return;
+    }
+    // Just listen on the foreign future. This guarantees an async delay.
+    _chainForeignFuture(value, this);
+  }
+
   void _asyncCompleteError(error, StackTrace stackTrace) {
     assert(!_isComplete);
 
     _setPendingComplete();
     _zone.scheduleMicrotask(() {
       _completeError(error, stackTrace);
     });
   }
 
   /**
@@ skipping 194 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }