Remove AsyncError with Expando.

tests/lib/async/future_test.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.
 
 library future_test;
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import 'dart:isolate';
 
@@ skipping 11 matching lines @@
 testOf() {
   compare(func) {
     // Compare the results of the following two futures.
     Future f1 = new Future.of(func);
     Future f2 = new Future.immediate(null).then((_) => func());
     f2.catchError((_){});  // I'll get the error later.
     f1.then((v1) { f2.then((v2) { Expect.equals(v1, v2); }); },
             onError: (e1) {
               f2.then((_) { Expect.fail("Expected error"); },
                       onError: (e2) {
-                         Expect.equals(e1.error, e2.error);
+                         Expect.equals(e1, e2);
                       });
             });
   }
   Future val = new Future.immediate(42);
   Future err1 = new Future.immediateError("Error")..catchError((_){});
-  Future err2 = new Future.immediateError(new AsyncError("AsyncError"))..catchError((_){});
+  try {
+    throw new List(0);
+  } catch (e, st) {
+    Future err2 = new Future.immediateError(e, st)..catchError((_){});
+  }
   compare(() => 42);
   compare(() => val);
   compare(() { throw "Flif"; });
-  compare(() { throw new AsyncError("AsyncFlif"); });
   compare(() => err1);
-  compare(() => err2);
 }
 
 testNeverComplete() {
   final completer = new Completer<int>();
   final future = completer.future;
   future.then((v) => Expect.fails("Value not expected"));
   future.catchError((e) => Expect.fails("Value not expected"));
 }
 
 testComplete() {
@@ skipping 65 matching lines @@
 // Tests for [catchError]
 
 testException() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   var port = new ReceivePort();
   future
       .then((v) { throw "Value not expected"; })
-      .catchError((e) {
-        Expect.equals(e.error, ex);
+      .catchError((error) {
+        Expect.equals(error, ex);
         port.close();
       }, test: (e) => e == ex);
   completer.completeError(ex);
 }
 
 testExceptionHandler() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   var ex2;
-  var done = future.catchError((e) { ex2 = e.error; });
+  var done = future.catchError((error) { ex2 = error; });
 
   Expect.isFalse(completer.isCompleted);
   completer.completeError(ex);
   Expect.isTrue(completer.isCompleted);
 
   var port = new ReceivePort();
   done.then((_) {
     Expect.equals(ex, ex2);
     port.close();
   });
@@ skipping 102 matching lines @@
   var completer = new Completer();
   bool gotError = false;
   var port = new ReceivePort();
   completer.future.asStream().listen(
       (data) {
         Expect.fail("Unexpected data");
       },
       onError: (error) {
         Expect.isFalse(gotError);
         gotError = true;
-        Expect.equals("error", error.error);
+        Expect.equals("error", error);
       },
       onDone: () {
         Expect.isTrue(gotError);
         port.close();
       });
   completer.completeError("error");
 }
 
 testFutureAsStreamWrapper() {
   var completer = new Completer();
@@ skipping 32 matching lines @@
 
 testFutureWhenCompleteError() {
   var port = new ReceivePort();
   int counter = 2;
   countDown() {
     if (--counter == 0) port.close();
   }
   var completer = new Completer();
   Future future = completer.future;
   Future later = future.whenComplete(countDown);
-  later.catchError((AsyncError e) {
-    Expect.equals("error", e.error);
+  later.catchError((error) {
+    Expect.equals("error", error);
     countDown();
   });
   completer.completeError("error");
 }
 
 testFutureWhenCompleteValueNewError() {
   var port = new ReceivePort();
   int counter = 2;
   countDown() {
     if (--counter == 0) port.close();
   }
   var completer = new Completer();
   Future future = completer.future;
   Future later = future.whenComplete(() {
     countDown();
     throw "new error";
   });
-  later.catchError((AsyncError e) {
-    Expect.equals("new error", e.error);
+  later.catchError((error) {
+    Expect.equals("new error", error);
     countDown();
   });
   completer.complete(42);
 }
 
 testFutureWhenCompleteErrorNewError() {
   var port = new ReceivePort();
   int counter = 2;
   countDown() {
     if (--counter == 0) port.close();
   }
   var completer = new Completer();
   Future future = completer.future;
   Future later = future.whenComplete(() {
     countDown();
     throw "new error";
   });
-  later.catchError((AsyncError e) {
-    Expect.equals("new error", e.error);
+  later.catchError((error) {
+    Expect.equals("new error", error);
     countDown();
   });
   completer.completeError("error");
 }
 
 testFutureWhenCompletePreValue() {
   var port = new ReceivePort();
   int counter = 2;
   countDown() {
     if (--counter == 0) port.close();
@@ skipping 46 matching lines @@
   completer.future.whenComplete(() {
     countDown(3);
     var completer2 = new Completer();
     new Timer(MS * 10, () {
       countDown(2);
       completer2.completeError("Fail");
     });
     return completer2.future;
   }).then((v) {
     Expect.fail("should fail async");
-  }, onError: (AsyncError e) {
-    Expect.equals("Fail", e.error);
+  }, onError: (error) {
+    Expect.equals("Fail", error);
     countDown(1);
   });
 
   completer.complete(42);
 }
 
 testFutureWhenErrorFutureValue() {
   var port = new ReceivePort();
   int counter = 3;
   countDown(int expect) {
     Expect.equals(expect, counter);
     if (--counter == 0) port.close();
   }
   var completer = new Completer();
   completer.future.whenComplete(() {
     countDown(3);
     var completer2 = new Completer();
     new Timer(MS * 10, () {
       countDown(2);
       completer2.complete(37);
     });
     return completer2.future;
   }).then((v) {
     Expect.fail("should fail async");
-  }, onError: (AsyncError e) {
-    Expect.equals("Error", e.error);
+  }, onError: (error) {
+    Expect.equals("Error", error);
     countDown(1);
   });
 
   completer.completeError("Error");
 }
 
 testFutureWhenErrorFutureError() {
   var port = new ReceivePort();
   int counter = 3;
   countDown(int expect) {
     Expect.equals(expect, counter);
     if (--counter == 0) port.close();
   }
   var completer = new Completer();
   completer.future.whenComplete(() {
     countDown(3);
     var completer2 = new Completer();
     new Timer(MS * 10, () {
       countDown(2);
       completer2.completeError("Fail");
     });
     return completer2.future;
   }).then((v) {
     Expect.fail("should fail async");
-  }, onError: (AsyncError e) {
-    Expect.equals("Fail", e.error);
+  }, onError: (error) {
+    Expect.equals("Fail", error);
     countDown(1);
   });
 
   completer.completeError("Error");
 }
 
 testFutureThenThrowsAsync() {
   final completer = new Completer<int>();
   final future = completer.future;
-  AsyncError error = new AsyncError(42, "st");
+  int error = 42;
 
   var port = new ReceivePort();
   future.then((v) {
     throw error;
-  }).catchError((AsyncError e) {
+  }).catchError((e) {
     Expect.identical(error, e);
     port.close();
   });
   completer.complete(0);
 }
 
 testFutureCatchThrowsAsync() {
   final completer = new Completer<int>();
   final future = completer.future;
-  AsyncError error = new AsyncError(42, "st");
+  int error = 42;
 
   var port = new ReceivePort();
-  future.catchError((AsyncError e) {
+  future.catchError((e) {
     throw error;
-  }).catchError((AsyncError e) {
+  }).catchError((e) {
     Expect.identical(error, e);
     port.close();
   });
   completer.completeError(0);
 }
 
 testFutureCatchRethrowsAsync() {
   final completer = new Completer<int>();
   final future = completer.future;
-  AsyncError error;
+  var error;
 
   var port = new ReceivePort();
-  future.catchError((AsyncError e) {
+  future.catchError((e) {
     error = e;
     throw e;
-  }).catchError((AsyncError e) {
+  }).catchError((e) {
     Expect.identical(error, e);
     port.close();
   });
   completer.completeError(0);
 }
 
 testFutureWhenThrowsAsync() {
   final completer = new Completer<int>();
   final future = completer.future;
-  AsyncError error = new AsyncError(42, "st");
+  var error = 42;
 
   var port = new ReceivePort();
   future.whenComplete(() {
     throw error;
-  }).catchError((AsyncError e) {
+  }).catchError((e) {
     Expect.identical(error, e);
     port.close();
   });
   completer.complete(0);
 }
 
-testCompleteWithAsyncError() {
+testCompleteWithError() {
   final completer = new Completer<int>();
   final future = completer.future;
-  AsyncError error = new AsyncError(42, "st");
+  var error = 42;
 
   var port = new ReceivePort();
-  future.catchError((AsyncError e) {
+  future.catchError((e) {
     Expect.identical(error, e);
     port.close();
   });
 
   completer.completeError(error);
 }
 
 testChainedFutureValue() {
   final completer = new Completer();
   final future = completer.future;
@@ skipping 29 matching lines @@
       Expect.isNull(v);
       port.close();
     });
 }
 testChainedFutureError() {
   final completer = new Completer();
   final future = completer.future;
   var port = new ReceivePort();
 
   future.then((v) => new Future.immediateError("Fehler"))
-        .then((v) { Expect.fail("unreachable!"); }, onError: (e) {
-          Expect.equals("Fehler", e.error);
+        .then((v) { Expect.fail("unreachable!"); }, onError: (error) {
+          Expect.equals("Fehler", error);
           port.close();
         });
   completer.complete(21);
 }
 
 main() {
   testImmediate();
   testOf();
   testNeverComplete();
 
   testComplete();
   testCompleteWithSuccessHandlerBeforeComplete();
   testCompleteWithSuccessHandlerAfterComplete();
   testCompleteManySuccessHandlers();
-  testCompleteWithAsyncError();
+  testCompleteWithError();
 
   testException();
   testExceptionHandler();
   testExceptionHandlerReturnsTrue();
   testExceptionHandlerReturnsTrue2();
   testExceptionHandlerReturnsFalse();
 
   testFutureAsStreamCompleteAfter();
   testFutureAsStreamCompleteBefore();
   testFutureAsStreamCompleteImmediate();
@@ skipping 14 matching lines @@
   testFutureCatchThrowsAsync();
   testFutureWhenThrowsAsync();
   testFutureCatchRethrowsAsync();
 
   testChainedFutureValue();
   testChainedFutureValueDelay();
   testChainedFutureError();
 }