Index: pkg/dev_compiler/tool/input_sdk/lib/async/future.dart |
diff --git a/pkg/dev_compiler/tool/input_sdk/lib/async/future.dart b/pkg/dev_compiler/tool/input_sdk/lib/async/future.dart |
index 49b2460524c27e21f121043531bb7e773e399dfd..815f526558764d8b6ab574cdbb53bf525388fac8 100644 |
--- a/pkg/dev_compiler/tool/input_sdk/lib/async/future.dart |
+++ b/pkg/dev_compiler/tool/input_sdk/lib/async/future.dart |
@@ -4,46 +4,6 @@ |
part of dart.async; |
-/// A type representing values that are either `Future<T>` or `T`. |
-/// |
-/// This class declaration is a public stand-in for an internal |
-/// future-or-value generic type. References to this class are resolved to the |
-/// internal type. |
-/// |
-/// It is a compile-time error for any class to extend, mix in or implement |
-/// `FutureOr`. |
-/// |
-/// Note: the `FutureOr<T>` type is interpreted as `dynamic` in non strong-mode. |
-/// |
-/// # Examples |
-/// ``` dart |
-/// // The `Future<T>.then` function takes a callback [f] that returns either |
-/// // an `S` or a `Future<S>`. |
-/// Future<S> then<S>(FutureOr<S> f(T x), ...); |
-/// |
-/// // `Completer<T>.complete` takes either a `T` or `Future<T>`. |
-/// void complete(FutureOr<T> value); |
-/// ``` |
-/// |
-/// # Advanced |
-/// The `FutureOr<int>` type is actually the "type union" of the types `int` and |
-/// `Future<int>`. This type union is defined in such a way that |
-/// `FutureOr<Object>` is both a super- and sub-type of `Object` (sub-type |
-/// because `Object` is one of the types of the union, super-type because |
-/// `Object` is a super-type of both of the types of the union). Together it |
-/// means that `FutureOr<Object>` is equivalent to `Object`. |
-/// |
-/// As a corollary, `FutureOr<Object>` is equivalent to |
-/// `FutureOr<FutureOr<Object>>`, `FutureOr<Future<Object>> is equivalent to |
-/// `Future<Object>`. |
-abstract class FutureOr<T> { |
- // Private constructor, so that it is not subclassable, mixable, or |
- // instantiable. |
- FutureOr._() { |
- throw new UnsupportedError("FutureOr can't be instantiated"); |
- } |
-} |
- |
/** |
* An object representing a delayed computation. |
* |
@@ -265,7 +225,7 @@ abstract class Future<T> { |
_Future<T> result = new _Future<T>(); |
new Timer(duration, () { |
try { |
- result._complete(computation?.call()); |
+ result._complete(computation == null ? null : computation()); |
} catch (e, s) { |
_completeWithErrorCallback(result, e, s); |
} |
@@ -294,11 +254,11 @@ abstract class Future<T> { |
* The call to `cleanUp` should not throw. If it does, the error will be an |
* uncaught asynchronous error. |
*/ |
- static Future<List<T>> wait<T>(Iterable<Future<T>> futures, |
+ static Future<List/*<T>*/> wait/*<T>*/(Iterable<Future/*<T>*/> futures, |
{bool eagerError: false, |
- void cleanUp(T successValue)}) { |
- final _Future<List<T>> result = new _Future<List<T>>(); |
- List<T> values; // Collects the values. Set to null on error. |
+ void cleanUp(/*=T*/ successValue)}) { |
+ final _Future<List/*<T>*/> result = new _Future<List/*<T>*/>(); |
+ List/*<T>*/ values; // Collects the values. Set to null on error. |
int remaining = 0; // How many futures are we waiting for. |
var error; // The first error from a future. |
StackTrace stackTrace; // The stackTrace that came with the error. |
@@ -327,56 +287,32 @@ abstract class Future<T> { |
} |
} |
- try { |
- // As each future completes, put its value into the corresponding |
- // position in the list of values. |
- for (Future future in futures) { |
- int pos = remaining; |
- future.then((T value) { |
- remaining--; |
- if (values != null) { |
- values[pos] = value; |
- if (remaining == 0) { |
- result._completeWithValue(values); |
- } |
- } else { |
- if (cleanUp != null && value != null) { |
- // Ensure errors from cleanUp are uncaught. |
- new Future.sync(() { cleanUp(value); }); |
- } |
- if (remaining == 0 && !eagerError) { |
- result._completeError(error, stackTrace); |
- } |
+ // As each future completes, put its value into the corresponding |
+ // position in the list of values. |
+ for (Future future in futures) { |
+ int pos = remaining++; |
+ future.then((Object/*=T*/ value) { |
+ remaining--; |
+ if (values != null) { |
+ values[pos] = value; |
+ if (remaining == 0) { |
+ result._completeWithValue(values); |
} |
- }, onError: handleError); |
- // Increment the 'remaining' after the call to 'then'. |
- // If that call throws, we don't expect any future callback from |
- // the future, and we also don't increment remaining. |
- remaining++; |
- } |
- if (remaining == 0) { |
- return new Future.value(const []); |
- } |
- values = new List<T>(remaining); |
- } catch (e, st) { |
- // The error must have been thrown while iterating over the futures |
- // list, or while installing a callback handler on the future. |
- if (remaining == 0 || eagerError) { |
- // Throw a new Future.error. |
- // Don't just call `result._completeError` since that would propagate |
- // the error too eagerly, not giving the callers time to install |
- // error handlers. |
- // Also, don't use `_asyncCompleteError` since that one doesn't give |
- // zones the chance to intercept the error. |
- return new Future.error(e, st); |
- } else { |
- // Don't allocate a list for values, thus indicating that there was an |
- // error. |
- // Set error to the caught exception. |
- error = e; |
- stackTrace = st; |
- } |
+ } else { |
+ if (cleanUp != null && value != null) { |
+ // Ensure errors from cleanUp are uncaught. |
+ new Future.sync(() { cleanUp(value); }); |
+ } |
+ if (remaining == 0 && !eagerError) { |
+ result._completeError(error, stackTrace); |
+ } |
+ } |
+ }, onError: handleError); |
+ } |
+ if (remaining == 0) { |
+ return new Future.value(const []); |
} |
+ values = new List/*<T>*/(remaining); |
return result; |
} |
@@ -390,9 +326,9 @@ abstract class Future<T> { |
* If [futures] is empty, or if none of its futures complete, |
* the returned future never completes. |
*/ |
- static Future<T> any<T>(Iterable<Future<T>> futures) { |
- var completer = new Completer<T>.sync(); |
- var onValue = (T value) { |
+ static Future/*<T>*/ any/*<T>*/(Iterable<Future/*<T>*/> futures) { |
+ var completer = new Completer/*<T>*/.sync(); |
+ var onValue = (/*=T*/ value) { |
if (!completer.isCompleted) completer.complete(value); |
}; |
var onError = (error, stack) { |
@@ -427,19 +363,18 @@ abstract class Future<T> { |
} |
/** |
- * Performs an async operation repeatedly until it returns `false`. |
- * |
- * The function [f] is called repeatedly while it returns either the [bool] |
- * value `true` or a [Future] which completes with the value `true`. |
+ * Perform an async operation repeatedly until it returns `false`. |
* |
- * If a call to [f] returns `false` or a [Future] that completes to `false`, |
- * iteration ends and the future returned by [doWhile] is completed. |
+ * Runs [f] repeatedly, starting the next iteration only when the [Future] |
+ * returned by [f] completes to `true`. Returns a [Future] that completes once |
+ * [f] returns `false`. |
* |
- * If a future returned by [f] completes with an error, iteration ends and |
- * the future returned by [doWhile] completes with the same error. |
+ * The return values of all [Future]s are discarded. Any errors will cause the |
+ * iteration to stop and will be piped through the returned [Future]. |
* |
- * The [f] function must return either a `bool` value or a [Future] completing |
- * with a `bool` value. |
+ * The function [f] may return either a [bool] or a [Future] that completes to |
+ * a [bool]. If it returns a non-[Future], iteration continues immediately. |
+ * Otherwise it waits for the returned [Future] to complete. |
*/ |
static Future doWhile(f()) { |
_Future doneSignal = new _Future(); |
@@ -497,7 +432,7 @@ abstract class Future<T> { |
* with a `test` parameter, instead of handling both value and error in a |
* single [then] call. |
*/ |
- Future<S> then<S>(FutureOr<S> onValue(T value), { Function onError }); |
+ Future/*<S>*/ then/*<S>*/(onValue(T value), { Function onError }); |
/** |
* Handles errors emitted by this [Future]. |
@@ -560,7 +495,7 @@ abstract class Future<T> { |
// `isCheck` we should also expect functions that take a specific argument. |
// Note: making `catchError` return a `Future<T>` in non-strong mode could be |
// a breaking change. |
- Future<T> catchError(Function onError, |
+ Future/*<T>*/ catchError(Function onError, |
{bool test(Object error)}); |
/** |