Remove AsyncError with Expando.

sdk/lib/async/stream_pipe.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;
 
-/** Utility function to create an [AsyncError] if [error] isn't one already. */
-AsyncError _asyncError(Object error, Object stackTrace, [AsyncError cause]) {
-  if (error is AsyncError) return error;
-  if (cause == null) return new AsyncError(error, stackTrace);
-  return new AsyncError.withCause(error, stackTrace, cause);
+/**
+ * Utility function to attach a stack trace to an [error]  if it doesn't have
+ * one already.
+ */
+_asyncError(Object error, Object stackTrace) {
+  if (stackTrace == null) return error;
+  if (getAttachedStackTrace(error) != null) return error;
+  _attachStackTrace(error, stackTrace);
+  return error;
 }
 
 /** Runs user code and takes actions depending on success or failure. */
-_runUserCode(userCode(), onSuccess(value), onError(AsyncError error),
-             { AsyncError cause }) {
-  var result;
+_runUserCode(userCode(), onSuccess(value), onError(error)) {
   try {
-    result = userCode();
-  } on AsyncError catch (e) {
-    return onError(e);
+    onSuccess(userCode());
   } catch (e, s) {
-    if (cause == null) {
-      onError(new AsyncError(e, s));
-    } else {
-      onError(new AsyncError.withCause(e, s, cause));
-    }
-    // onError is allowed to return. Don't execute the onSuccess below.
-    return;
+    onError(_asyncError(e, s));
   }
-  onSuccess(result);
 }
 
 /** Helper function to make an onError argument to [_runUserCode]. */
 _cancelAndError(StreamSubscription subscription, _FutureImpl future) =>
-  (AsyncError error) {
+  (error) {
     subscription.cancel();
     future._setError(error);
   };
 
 
 /**
  * A [Stream] that forwards subscriptions to another stream.
  *
  * This stream implements [Stream], but forwards all subscriptions
  * to an underlying stream, and wraps the returned subscription to
  * modify the events on the way.
  *
  * This class is intended for internal use only.
  */
 abstract class _ForwardingStream<S, T> extends Stream<T> {
   final Stream<S> _source;
 
   _ForwardingStream(this._source);
 
   bool get isBroadcast => _source.isBroadcast;
 
   StreamSubscription<T> listen(void onData(T value),
-                              { void onError(AsyncError error),
+                              { void onError(error),
                                 void onDone(),
                                 bool cancelOnError }) {
     if (onData == null) onData = _nullDataHandler;
     if (onError == null) onError = _nullErrorHandler;
     if (onDone == null) onDone = _nullDoneHandler;
     cancelOnError = identical(true, cancelOnError);
     return _createSubscription(onData, onError, onDone, cancelOnError);
   }
 
   StreamSubscription<T> _createSubscription(void onData(T value),
-                                            void onError(AsyncError error),
+                                            void onError(error),
                                             void onDone(),
                                             bool cancelOnError) {
     return new _ForwardingStreamSubscription<S, T>(
         this, onData, onError, onDone, cancelOnError);
   }
 
   // Override the following methods in subclasses to change the behavior.
 
   void _handleData(S data, _EventOutputSink<T> sink) {
     var outputData = data;
     sink._sendData(outputData);
   }
 
-  void _handleError(AsyncError error, _EventOutputSink<T> sink) {
+  void _handleError(error, _EventOutputSink<T> sink) {
     sink._sendError(error);
   }
 
   void _handleDone(_EventOutputSink<T> sink) {
     sink._sendDone();
   }
 }
 
 /**
  * Common behavior of [StreamSubscription] classes.
@@ skipping 14 matching lines @@
     if (_onError == null) _onError = _nullErrorHandler;
     if (_onDone == null) _onDone = _nullDoneHandler;
   }
 
   // StreamSubscription interface.
   void onData(void handleData(T event)) {
     if (handleData == null) handleData = _nullDataHandler;
     _onData = handleData;
   }
 
-  void onError(void handleError(AsyncError error)) {
+  void onError(void handleError(error)) {
     if (handleError == null) handleError = _nullErrorHandler;
     _onError = handleError;
   }
 
   void onDone(void handleDone()) {
     if (handleDone == null) handleDone = _nullDoneHandler;
     _onDone = handleDone;
   }
 
   void pause([Future resumeSignal]);
 
   void resume();
 
   void cancel();
 
   Future asFuture([var futureValue]) {
     _FutureImpl<T> result = new _FutureImpl<T>();
 
     // Overwrite the onDone and onError handlers.
     onDone(() { result._setValue(futureValue); });
-    onError((AsyncError error) {
+    onError((error) {
       cancel();
       result._setError(error);
     });
 
     return result;
   }
 }
 
 
 /**
  * Abstract superclass for subscriptions that forward to other subscriptions.
  */
 class _ForwardingStreamSubscription<S, T>
     extends _BaseStreamSubscription<T> implements _EventOutputSink<T> {
   final _ForwardingStream<S, T> _stream;
   final bool _cancelOnError;
 
   StreamSubscription<S> _subscription;
 
   _ForwardingStreamSubscription(this._stream,
                                 void onData(T data),
-                                void onError(AsyncError error),
+                                void onError(error),
                                 void onDone(),
                                 this._cancelOnError)
       : super(onData, onError, onDone) {
     // Don't unsubscribe on incoming error, only if we send an error forwards.
     _subscription =
         _stream._source.listen(_handleData,
                                onError: _handleError,
                                onDone: _handleDone);
   }
 
@@ skipping 15 matching lines @@
       _subscription = null;
     }
   }
 
   // _EventOutputSink interface. Sends data to this subscription.
 
   void _sendData(T data) {
     _onData(data);
   }
 
-  void _sendError(AsyncError error) {
+  void _sendError(error) {
     _onError(error);
     if (_cancelOnError) {
       _subscription.cancel();
       _subscription = null;
     }
   }
 
   void _sendDone() {
     // If the transformation sends a done signal, we stop the subscription.
     if (_subscription != null) {
       _subscription.cancel();
       _subscription = null;
     }
     _onDone();
   }
 
   // Methods used as listener on source subscription.
 
   // TODO(ahe): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   void _handleData(/*S*/ data) {
     _stream._handleData(data, this);
   }
 
-  void _handleError(AsyncError error) {
+  void _handleError(error) {
     _stream._handleError(error, this);
   }
 
   void _handleDone() {
     // On a done-event, we have already been unsubscribed.
     _subscription = null;
     _stream._handleDone(this);
   }
 }
 
@@ skipping 63 matching lines @@
       }
     } catch (e, s) {
       // If either _expand or iterating the generated iterator throws,
       // we abort the iteration.
       sink._sendError(_asyncError(e, s));
     }
   }
 }
 
 
-typedef void _ErrorTransformation(AsyncError error);
+typedef void _ErrorTransformation(error);
 typedef bool _ErrorTest(error);
 
 /**
  * A stream pipe that converts or disposes error events
  * before passing them on.
  */
 class _HandleErrorStream<T> extends _ForwardingStream<T, T> {
   final _ErrorTransformation _transform;
   final _ErrorTest _test;
 
   _HandleErrorStream(Stream<T> source,
-                    void transform(AsyncError event),
+                    void transform(event),
                     bool test(error))
       : this._transform = transform, this._test = test, super(source);
 
-  void _handleError(AsyncError error, _EventOutputSink<T> sink) {
+  void _handleError(Object error, _EventOutputSink<T> sink) {
     bool matches = true;
     if (_test != null) {
       try {
-        matches = _test(error.error);
+        matches = _test(error);
       } catch (e, s) {
-        sink._sendError(_asyncError(e, s, error));
+        sink._sendError(_asyncError(e, s));
         return;
       }
     }
     if (matches) {
       try {
         _transform(error);
       } catch (e, s) {
-        sink._sendError(_asyncError(e, s, error));
+        sink._sendError(_asyncError(e, s));
         return;
       }
     } else {
       sink._sendError(error);
     }
   }
 }
 
 
 class _TakeStream<T> extends _ForwardingStream<T, T> {
@@ skipping 121 matching lines @@
         sink._sendData(inputEvent);
         _previous = inputEvent;
       }
     }
   }
 }
 
 // Stream transformations and event transformations.
 
 typedef void _TransformDataHandler<S, T>(S data, EventSink<T> sink);
-typedef void _TransformErrorHandler<T>(AsyncError data, EventSink<T> sink);
+typedef void _TransformErrorHandler<T>(data, EventSink<T> sink);
 typedef void _TransformDoneHandler<T>(EventSink<T> sink);
 
 /** Default data handler forwards all data. */
 void _defaultHandleData(var data, EventSink sink) {
   sink.add(data);
 }
 
 /** Default error handler forwards all errors. */
-void _defaultHandleError(AsyncError error, EventSink sink) {
+void _defaultHandleError(error, EventSink sink) {
   sink.addError(error);
 }
 
 /** Default done handler forwards done. */
 void _defaultHandleDone(EventSink sink) {
   sink.close();
 }
 
 
 /**
  * A [StreamTransformer] that modifies stream events.
  *
  * This class is used by [StreamTransformer]'s factory constructor.
  * It is actually an [StreamEventTransformer] where the functions used to
  * modify the events are passed as constructor arguments.
  *
  * If an argument is omitted, it acts as the default method from
  * [StreamEventTransformer].
  */
 class _StreamTransformerImpl<S, T> extends StreamEventTransformer<S, T> {
   // TODO(ahe): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   final Function /*_TransformDataHandler<S, T>*/ _handleData;
   final _TransformErrorHandler<T> _handleError;
   final _TransformDoneHandler<T> _handleDone;
 
   _StreamTransformerImpl(void handleData(S data, EventSink<T> sink),
-                         void handleError(AsyncError data, EventSink<T> sink),
+                         void handleError(data, EventSink<T> sink),
                          void handleDone(EventSink<T> sink))
       : this._handleData  = (handleData == null  ? _defaultHandleData
                                                  : handleData),
         this._handleError = (handleError == null ? _defaultHandleError
                                                  : handleError),
         this._handleDone  = (handleDone == null  ? _defaultHandleDone
                                                  : handleDone);
 
   void handleData(S data, EventSink<T> sink) {
     _handleData(data, sink);
   }
 
-  void handleError(AsyncError error, EventSink<T> sink) {
+  void handleError(error, EventSink<T> sink) {
     _handleError(error, sink);
   }
 
   void handleDone(EventSink<T> sink) {
     _handleDone(sink);
   }
 }