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

sdk/lib/async/stream_controller.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;
 
 // -------------------------------------------------------------------
 // Default implementation of a stream with a controller for adding
 // events to the stream.
 // -------------------------------------------------------------------
@@ skipping 67 matching lines @@
   bool get hasSubscribers => _stream._hasSubscribers;
 
   /**
    * Send or queue a data event.
    */
   void add(T value) => _stream._add(value);
 
   /**
    * Send or enqueue an error event.
    *
+   * If the [error] is an [AsyncError], it is used directly as the
+   * error object reported to listeners, and the [stackTrace] is ignored.

[floitsch, 2013/01/10 16:38:10]

I would mention the special case after the normal case.
Maybe:

If the [exception] is not an [AsyncError], combines the [exception] and the
optional [stackTrace] into an [AsyncError] and sends the result to [this]
stream's listeners.

If the [exception] is already an [AsyncError], then the [stackTrace] is ignored
and the [exception] is sent directly to the listeners.

[Lasse Reichstein Nielsen, 2013/01/11 07:02:05]

Done.

+   *
+   * Otherwise the [exception] and an optional [stackTrace] is combined and sent
+   * this stream's listeners.
+   *
    * If a subscription has requested to be unsubscribed on errors,
    * it will be unsubscribed after receiving this event.
    */
-  void signalError(AsyncError error) { _stream._signalError(error); }
+  void signalError(Object error, [Object stackTrace]) {
+    AsyncError asyncError;
+    if (error is AsyncError) {
+      asyncError = error;
+    } else {
+      asyncError = new AsyncError(error, stackTrace);
+    }
+    _stream._signalError(asyncError);
+  }
 
   /**
    * Send or enqueue a "done" message.
    *
    * The "done" message should be sent at most once by a stream, and it
    * should be the last message sent.
    */
   void close() { _stream._close(); }
 
   /**
@@ skipping 45 matching lines @@
   _SingleControllerStream(this._subscriptionHandler, this._pauseHandler);
 
   void _onSubscriptionStateChange() {
     _subscriptionHandler();
   }
 
   void _onPauseStateChange() {
     _pauseHandler();
   }
 }