Remove AsyncError with Expando.

utils/pub/error_group.dart

 // Copyright (c) 2013, 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.
 
 library error_group;
 
 import 'dart:async';
 
 import 'utils.dart';
 
@@ skipping 85 matching lines @@
     _streams.add(wrapped);
     return wrapped;
   }
 
   /// Sends [error] to all members of [this]. Like errors that come from
   /// members, this will only be passed to the top-level error handler if no
   /// members have listeners.
   ///
   /// If all members of [this] have already completed successfully or with an
   /// error, it's a [StateError] to try to signal an error.
-  void signalError(AsyncError error) {
+  void signalError(var error) {
     if (_isDone) {
       throw new StateError("Can't signal errors on a complete ErrorGroup.");
     }
 
     _signalError(error);
   }
 
   /// Signal an error internally. This is just like [signalError], but instead
   /// of throwing an error if [this] is complete, it just does nothing.
-  void _signalError(AsyncError error) {
+  void _signalError(var error) {
     if (_isDone) return;
 
     var caught = false;
     for (var future in _futures) {
       if (future._isDone || future._hasListeners) caught = true;
       future._signalError(error);
     }
 
     for (var stream in _streams) {
       if (stream._isDone || stream._hasListeners) caught = true;
@@ skipping 47 matching lines @@
       if (!_isDone) _completer.complete(value);
       _isDone = true;
       _group._signalFutureComplete(this);
     }).catchError((error) => _group._signalError(error));
 
     // Make sure _completer.future doesn't automatically send errors to the
     // top-level.
     _completer.future.catchError((_) {});
   }
 
-  Future then(onValue(value), {onError(AsyncError asyncError)}) {
+  Future then(onValue(value), {onError(error)}) {
     _hasListeners = true;
     return _completer.future.then(onValue, onError: onError);
   }
 
-  Future catchError(onError(AsyncError asyncError), {bool test(Object error)}) {
+  Future catchError(onError(error), {bool test(Object error)}) {
     _hasListeners = true;
     return _completer.future.catchError(onError, test: test);
   }
 
   Future whenComplete(void action()) {
     _hasListeners = true;
     return _completer.future.whenComplete(action);
   }
 
   Stream asStream() {
     _hasListeners = true;
     return _completer.future.asStream();
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
-  void _signalError(AsyncError error) {
-    if (!_isDone) _completer.completeError(error.error, error.stackTrace);
+  void _signalError(var error) {
+    if (!_isDone) _completer.completeError(error);
     _isDone = true;
   }
 }
 
 // TODO(nweiz): currently streams never top-level unhandled errors (issue 7843).
 // When this is fixed, this class will need to prevent such errors from being
 // top-leveled.
 /// A [Stream] wrapper that keeps track of whether it's been completed and
 /// whether it has any listeners. It also notifies its parent [ErrorGroup] when
 /// it completes successfully or receives an error.
@@ skipping 25 matching lines @@
     }, onError: (e) {
       _group._signalError(e);
     }, onDone: () {
       _isDone = true;
       _group._signalStreamComplete(this);
       _controller.close();
     });
   }
 
   StreamSubscription listen(void onData(value),
-      {void onError(AsyncError error), void onDone(),
+      {void onError(var error), void onDone(),
        bool cancelOnError}) {
     return _controller.stream.listen(onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: true);
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
-  void _signalError(AsyncError e) {
+  void _signalError(var e) {
     if (_isDone) return;
     _subscription.cancel();
     // Call these asynchronously to work around issue 7913.
     new Future.immediate(null).then((_) {
-      _controller.addError(e.error, e.stackTrace);
+      _controller.addError(e);
       _controller.close();
     });
   }
 }