Remove AsyncError with Expando.

sdk/lib/async/future.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;
 
 /**
  * A [Future] represents a delayed computation. It is used to obtain a not-yet
  * available value, or error, sometime in the future.  Receivers of a
  * [Future] can register callbacks that handle the value or error once it is
  * available. For example:
  *
  *     Future<int> future = getFuture();
  *     future.then((value) => handleValue(value))
  *           .catchError((error) => handleError(error));
  *
  * A [Future] can be completed in two ways: with a value ("the future succeeds")
  * or with an error ("the future fails"). Users can install callbacks for each
  * case. The result of registering a pair of callbacks is a new Future (the
  * "successor") which in turn is completed with the result of invoking the
  * corresponding callback. The successor is completed with an error if the
  * invoked callback throws. For example:
  *
  *     Future<int> successor = future.then((int value) {
  *         // Invoked when the future is completed with a value.
  *         return 42;  // The successor is completed with the value 42.
  *       },
- *       onError: (AsyncError e) {
+ *       onError: (e) {
  *         // Invoked when the future is completed with an error.
  *         if (canHandle(e)) {
  *           return 499;  // The successor is completed with the value 499.
  *         } else {
  *           throw e;  // The successor is completed with the error e.
  *         }
  *       });
  *
  * If a future does not have a successor but is completed with an error, it
  * forwards the error message to the global error-handler. This special casing
@@ skipping 56 matching lines @@
    * If calling [function] throws, the created [Future] will be completed
    * with an async error containing the thrown value and a captured
    * stacktrace.
    *
    * However, if the result of calling [function] is already an asynchronous
    * result, we treat it specially.
    *
    * If the returned value is itself a [Future], completion of
    * the created future will wait until the returned future completes,
    * and will then complete with the same result.
-   *
-   * If a thrown value is an [AsyncError], it is used directly as the result
-   * of the created future.
    */
   factory Future.of(function()) {
     try {
       var result = function();
       return new _FutureImpl<T>().._setOrChainValue(result);
     } catch (error, stackTrace) {
       return new _FutureImpl<T>.immediateError(error, stackTrace);
     }
   }
 
@@ skipping 82 matching lines @@
   /**
    * When this future completes with a value, then [onValue] is called with this
    * value. If [this] future is already completed then the invocation of
    * [onValue] is delayed until the next event-loop iteration.
    *
    * Returns a new [Future] `f` which is completed with the result of
    * invoking [onValue] (if [this] completes with a value) or [onError] (if
    * [this] completes with an error).
    *
    * If the invoked callback throws an exception, the returned future `f` is
-   * completed with the error. If the value thrown is an [AsyncError], it is
-   * used directly, as the error result. Otherwise it is wrapped in an
-   * [AsyncError] first.
+   * completed with the error.
    *
    * If the invoked callback returns a [Future] `f2` then `f` and `f2` are
    * chained. That is, `f` is completed with the completion value of `f2`.
    *
    * If [onError] is not given, it is equivalent to `(e) { throw e; }`. That
    * is, it forwards the error to `f`.
    *
    * In most cases, it is more readable to use [catchError] separately, possibly
    * with a `test` parameter, instead of handling both value and error in a
    * single [then] call.
    */
-  Future then(onValue(T value), { onError(AsyncError asyncError) });
+  Future then(onValue(T value), { onError(Object error) });
 
   /**
    * Handles errors emitted by this [Future].
    *
    * Returns a new [Future] `f`.
    *
    * When [this] completes with a value, the value is forwarded to `f`
    * unmodified. That is, `f` completes with the same value.
    *
    * When [this] completes with an error, [test] is called with the
    * error's value. If the invocation returns [true], [onError] is called with
-   * the error wrapped in an [AsyncError]. The result of [onError] is handled
-   * exactly the same as for [then]'s [onError].
+   * the error. The result of [onError] is handled exactly the same as for
+   * [then]'s [onError].
    *
    * If [test] returns false, the exception is not handled by [onError], but is
    * thrown unmodified, thus forwarding it to `f`.
    *
    * If [test] is omitted, it defaults to a function that always returns true.
    *
    * Example:
    *
    *     foo
    *       .catchError(..., test: (e) => e is ArgumentError)
    *       .catchError(..., test: (e) => e is NoSuchMethodError)
    *       .then((v) { ... });
    *
    * This method is equivalent to:
    *
-   *     Future catchError(onError(AsyncError asyncError),
-   *                       {bool test(Object error)}) {
+   *     Future catchError(onError(error),
+   *                       {bool test(error)}) {
    *       this.then((v) => v,  // Forward the value.
    *                 // But handle errors, if the [test] succeeds.
-   *                 onError: (AsyncError e) {
-   *                   if (test == null || test(e.error)) {
+   *                 onError: (e) {
+   *                   if (test == null || test(e)) {
    *                     return onError(e);
    *                   }
    *                   throw e;
    *                 });
    *     }
    *
    */
-  Future catchError(onError(AsyncError asyncError),
+  Future catchError(onError(Object error),
                     {bool test(Object error)});
 
   /**
    * Register a function to be called when this future completes.
    *
    * The [action] function is called when this future completes, whether it
    * does so with a value or with an error.
    *
    * This is the asynchronous equivalent of a "finally" block.
    *
@@ skipping 11 matching lines @@
    * ignored.
    *
    * This method is equivalent to:
    *
    *     Future<T> whenComplete(action()) {
    *       this.then((v) {
    *                   var f2 = action();
    *                   if (f2 is Future) return f2.then((_) => v);
    *                   return v
    *                 },
-   *                 onError: (AsyncError e) {
+   *                 onError: (e) {
    *                   var f2 = action();
    *                   if (f2 is Future) return f2.then((_) { throw e; });
    *                   throw e;
    *                 });
    *     }
    */
   Future<T> whenComplete(action());
 
   /**
    * Creates a [Stream] that sends [this]' completion value, data or error, to
@@ skipping 36 matching lines @@
    */
   void complete([T value]);
 
   /**
    * Complete [future] with an error.
    *
    * Completing a future with an error indicates that an exception was thrown
    * while trying to produce a value.
    *
    * The argument [exception] should not be `null`.
-   *
-   * If [exception] is an [AsyncError], it is used directly as the error
-   * message sent to the future's listeners, and [stackTrace] is ignored.
-   *
-   * Otherwise the [exception] and an optional [stackTrace] is combined into an
-   * [AsyncError] and sent to this future's listeners.
    */
   void completeError(Object exception, [Object stackTrace]);
 
   /**
    * Whether the future has been completed.
    */
   bool get isCompleted;
 }