Remove AsyncError with Expando.

sdk/lib/isolate/isolate_stream.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.isolate;
 
 /**
  * The initial [IsolateStream] available by default for this isolate. This
  * [IsolateStream] is created automatically and it is commonly used to establish
  * the first communication between isolates (see [streamSpawnFunction] and
@@ skipping 59 matching lines @@
    */
   void close() {
     if (!_isClosed) {
       _isClosed = true;
       _port.close();
       _controller.close();
     }
   }
 
   StreamSubscription listen(void onData(event),
-                            { void onError(AsyncError error),
+                            { void onError(error),
                               void onDone(),
                               bool unsubscribeOnError}) {
       return _controller.stream.listen(onData,
                                        onError: onError,
                                        onDone: onDone,
                                        unsubscribeOnError: unsubscribeOnError);
   }
 }
 
 /**
@@ skipping 16 matching lines @@
    * any of these. List and maps are also allowed to be cyclic.
    *
    * In the special circumstances when two isolates share the same code and are
    * running in the same process (e.g. isolates created via [spawnFunction]), it
    * is also possible to send object instances (which would be copied in the
    * process). This is currently only supported by the dartvm.  For now, the
    * dart2js compiler only supports the restricted messages described above.
    */
   void add(dynamic message);
 
-  void addError(AsyncError errorEvent);
+  void addError(errorEvent);
 
   /** Closing multiple times is allowed. */
   void close();
 
   /**
    * Tests whether [other] is an [IsolateSink] feeding into the same
    * [IsolateStream] as this one.
    */
   bool operator==(var other);
 }
@@ skipping 13 matching lines @@
  * default stream.
  *
  * The optional [unhandledExceptionCallback] argument is invoked whenever an
  * exception inside the isolate is unhandled. It can be seen as a big
  * `try/catch` around everything that is executed inside the isolate. The
  * callback should return `true` when it was able to handled the exception.
  */
 external IsolateSink streamSpawnFunction(
     void topLevelFunction(),
     [bool unhandledExceptionCallback(IsolateUnhandledException e)]);