Consider a thrown AsyncError from a future/stream handler a rethrow.

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;
 
 deprecatedFutureValue(_FutureImpl future) =>
   future._isComplete ? future._resultOrListeners : null;
 
 
 class _CompleterImpl<T> implements Completer<T> {
   final Future<T> future;
   bool _isComplete = false;
 
   _CompleterImpl() : future = new _FutureImpl<T>();
 
   void complete([T value]) {
     if (_isComplete) throw new StateError("Future already completed");
     _isComplete = true;
     _FutureImpl future = this.future;
     future._setValue(value);
   }
 
   void completeError(Object error, [Object stackTrace = null]) {
     if (_isComplete) throw new StateError("Future already completed");
     _isComplete = true;
+    AsyncError asyncError;
+    if (error is AsyncError) {
+      asyncError = error;
+    } else {
+      asyncError = new AsyncError(error, stackTrace);
+    }
+    // Never complete an error in the same cycle. Otherwise users might
+    // not have a chance to register their error-handlers.
     new Timer(0, (_) {
-      // Never complete an error in the same cycle. Otherwise users might
-      // not have a chance to register their error-handlers.
       _FutureImpl future = this.future;
-      future._setError(new AsyncError(error, stackTrace));
+      future._setError(asyncError);
     });
   }
 }
 
 /**
  * A listener on a future.
  *
  * When the future completes, the [_sendValue] or [_sendError] method
  * is invoked with the result.
  *
@@ skipping 44 matching lines @@
   var _resultOrListeners;
 
   _FutureImpl();
 
   _FutureImpl.immediate(T value) {
     _state = _VALUE;
     _resultOrListeners = value;
   }
 
   _FutureImpl.immediateError(var error, [Object stackTrace]) {
-    new Timer(0, (_) { _setError(new AsyncError(error, stackTrace)); });
+    AsyncError asyncError;
+    if (error is AsyncError) {
+      asyncError = error;
+    } else {
+      asyncError = new AsyncError(error, stackTrace);
+    }
+    new Timer(0, (_) { _setError(asyncError); });
   }
 
   factory _FutureImpl.wait(Iterable<Future> futures) {
     // TODO(ajohnsen): can we do better wrt the generic type T?
     if (futures.isEmpty) {
       return new Future<List>.immediate(const []);
     }
 
     Completer completer = new Completer<List>();
     int remaining = futures.length;
@@ skipping 222 matching lines @@
   // checked mode.
   final /* _FutureOnValue<S> */ _onValue;
 
   _ThenFuture(this._onValue);
 
   _sendValue(S value) {
     assert(_onValue != null);
     var result;
     try {
       result = _onValue(value);
+    } on AsyncError catch (e) {
+      _setError(e);
+      return;
     } catch (e, s) {
       _setError(new AsyncError(e, s));
       return;
     }
     _setOrChainValue(result);
   }
 
   void _sendError(AsyncError error) {
     _setError(error);
   }
@@ skipping 24 matching lines @@
       }
       if (!matchesTest) {
         _setError(error);
         return;
       }
     }
     // Act on the error, and use the result as this future's result.
     var result;
     try {
       result = _onError(error);
+    } on AsyncError catch (e) {
+      _setError(e);
+      return;
     } catch (e, s) {
       _setError(new AsyncError.withCause(e, s, error));
       return;
     }
     _setOrChainValue(result);
   }
 }
 
 /** Future returned by [Future.then] with an [:onError:] parameter. */
 class _SubscribeFuture<S, T> extends _ThenFuture<S, T> {
   final _FutureOnError _onError;
 
   _SubscribeFuture(onValue(S value), this._onError) : super(onValue);
 
   // The _sendValue method is inherited from ThenFuture.
 
   void _sendError(AsyncError error) {
     assert(_onError != null);
     var result;
     try {
       result = _onError(error);
+    } on AsyncError catch (e) {
+      _setError(e);
+      return;
     } catch (e, s) {
       _setError(new AsyncError.withCause(e, s, error));
       return;
     }
     _setOrChainValue(result);
   }
 }
 
 /** Future returned by [Future.whenComplete]. */
 class _WhenFuture<T> extends _TransformFuture<T, T> {
   final _FutureAction _action;
 
   _WhenFuture(this._action);
 
   void _sendValue(T value) {
     try {
       var result = _action();
       if (result is Future) {
         Future resultFuture = result;
         resultFuture.then((_) {
           _setValue(value);
         }, onError: _setError);
         return;
       }
+    } on AsyncError catch (e) {
+      _setError(e);
+      return;
     } catch (e, s) {
       _setError(new AsyncError(e, s));
       return;
     }
 
     _setValue(value);
   }
 
   void _sendError(AsyncError error) {
     try {
       var result = _action();
       if (result is Future) {
         Future resultFuture = result;
         // TODO(lrn): Find a way to combine [error] into [e].
         resultFuture.then((_) {
           _setError(error);
         }, onError: _setError);
         return;
       }
+    } on AsyncError catch (e) {
+      _setError(e);
+      return;
     } catch (e, s) {
       error = new AsyncError.withCause(e, s, error);
     }
     _setError(error);
   }
 }
 
 /**
  * Thin wrapper around a [Future].
  *
@@ skipping 13 matching lines @@
   Future catchError(function(AsyncError error), {bool test(var error)}) {
     return _future.catchError(function, test: test);
   }
 
   Future<T> whenComplete(action()) {
     return _future.whenComplete(action);
   }
 
   Stream<T> asStream() => new Stream.fromFuture(_future);
 }