Remove AsyncError with Expando.

tests/lib/async/stream_controller_async_test.dart

 // Copyright (c) 2011, 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.
 
 // Test the basic StreamController and StreamController.singleSubscription.
 library stream_controller_async_test;
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import 'dart:isolate';
@@ skipping 11 matching lines @@
     }));
     c.add(10);
     c.add(32);
     c.close();
   });
 
   test("StreamController.fold throws", () {
     StreamController c = new StreamController.broadcast();
     Stream stream = c.stream;
     stream.fold(0, (a,b) { throw "Fnyf!"; })
-     .catchError(expectAsync1((e) { Expect.equals("Fnyf!", e.error); }));
+     .catchError(expectAsync1((error) { Expect.equals("Fnyf!", error); }));
     c.add(42);
   });
 }
 
 testSingleController() {
   test("Single-subscription StreamController.fold", () {
     StreamController c = new StreamController();
     Stream stream = c.stream;
     stream.fold(0, (a,b) => a + b)
     .then(expectAsync1((int v) { Expect.equals(42, v); }));
     c.add(10);
     c.add(32);
     c.close();
   });
 
   test("Single-subscription StreamController.fold throws", () {
     StreamController c = new StreamController();
     Stream stream = c.stream;
     stream.fold(0, (a,b) { throw "Fnyf!"; })
-            .catchError(expectAsync1((e) { Expect.equals("Fnyf!", e.error); }));
+            .catchError(expectAsync1((e) { Expect.equals("Fnyf!", e); }));
     c.add(42);
   });
 
   test("Single-subscription StreamController subscription changes", () {
     StreamController c = new StreamController();
     EventSink sink = c.sink;
     Stream stream = c.stream;
     int counter = 0;
     var subscription;
     subscription = stream.listen((data) {
@@ skipping 107 matching lines @@
 
   test("singleWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.singleWhere((x) => (x % 9) == 0);
     f.then(expectAsync1((v) { Expect.equals(9, v); }));
     sentEvents.replay(c);
   });
 
   test("singleWhere 2", () {
     StreamController c = new StreamController();
-    Future f = c.stream.singleWhere((x) => (x % 3) == 0);  // Matches both 9 and 87..
-    f.catchError(expectAsync1((e) { Expect.isTrue(e.error is StateError); }));
+    Future f = c.stream.singleWhere((x) => (x % 3) == 0);  // Matches 9 and 87..
+    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
     sentEvents.replay(c);
   });
 
   test("first", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
     f.then(expectAsync1((v) { Expect.equals(7, v);}));
     sentEvents.replay(c);
   });
 
   test("first empty", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync1((e) { Expect.isTrue(e.error is StateError); }));
+    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
     Events emptyEvents = new Events()..close();
     emptyEvents.replay(c);
   });
 
   test("first error", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync1((e) { Expect.equals("error", e.error); }));
+    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
 
   test("first error 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync1((e) { Expect.equals("error", e.error); }));
+    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
 
   test("last", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
     f.then(expectAsync1((v) { Expect.equals(87, v);}));
     sentEvents.replay(c);
   });
 
   test("last empty", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync1((e) { Expect.isTrue(e.error is StateError); }));
+    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
     Events emptyEvents = new Events()..close();
     emptyEvents.replay(c);
   });
 
   test("last error", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync1((e) { Expect.equals("error", e.error); }));
+    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
 
   test("last error 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync1((e) { Expect.equals("error", e.error); }));
+    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
 
   test("elementAt", () {
     StreamController c = new StreamController();
     Future f = c.stream.elementAt(2);
     f.then(expectAsync1((v) { Expect.equals(13, v);}));
     sentEvents.replay(c);
   });
 
   test("elementAt 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.elementAt(20);
-    f.catchError(expectAsync1((e) { Expect.isTrue(e.error is StateError); }));
+    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
     sentEvents.replay(c);
   });
 }
 
 testPause() {
   test("pause event-unpause", () {
     StreamController c = new StreamController();
     Events actualEvents = new Events.capture(c.stream);
     Events expectedEvents = new Events();
     expectedEvents.add(42);
@@ skipping 94 matching lines @@
     completer.complete();
     Expect.listEquals(expectedEvents.events, actualEvents.events);
     expectedEvents..add(43)..add(44)..close();
     actualEvents.onDone(expectAsync0(() {
       Expect.listEquals(expectedEvents.events, actualEvents.events);
     }));
     actualEvents.resume();
   });
 }
 
+class TestError { const TestError(); }
+
 testRethrow() {
-  AsyncError error = new AsyncError("UNIQUE", "UNIQUE");
+  TestError error = const TestError();
+  
 
   testStream(name, streamValueTransform) {
     test("rethrow-$name-value", () {
       StreamController c = new StreamController();
       Stream s = streamValueTransform(c.stream, (v) { throw error; });
       s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync1(
-          (AsyncError e) { Expect.identical(error, e); }));
+          (e) { Expect.identical(error, e); }));
       c.add(null);
       c.close();
     });
   }
 
   testStreamError(name, streamErrorTransform) {
     test("rethrow-$name-error", () {
       StreamController c = new StreamController();
       Stream s = streamErrorTransform(c.stream, (e) { throw error; });
       s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync1(
-          (AsyncError e) { Expect.identical(error, e); }));
+          (e) { Expect.identical(error, e); }));
       c.addError(null);
       c.close();
     });
   }
 
   testFuture(name, streamValueTransform) {
     test("rethrow-$name-value", () {
       StreamController c = new StreamController();
       Future f = streamValueTransform(c.stream, (v) { throw error; });
       f.then((v) { Expect.fail("unreachable"); },
@@ skipping 17 matching lines @@
   testFuture("fold", (s, act) => s.fold(0, (a,b) => act(b)));
 }
 
 main() {
   testController();
   testSingleController();
   testExtraMethods();
   testPause();
   testRethrow();
 }