Remove AsyncError with Expando.

tests/standalone/io/file_error_test.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.
 //
 // Dart test program for testing error handling in file I/O.
 
 import "package:expect/expect.dart";
 import "dart:io";
 import "dart:isolate";
 
@@ skipping 35 matching lines @@
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentFile");
 
   // Non-existing file should throw exception.
   Expect.throws(() => file.openSync(),
                 (e) => checkOpenNonExistentFileException(e));
 
   var openFuture = file.open(mode: FileMode.READ);
   openFuture.then((raf) => Expect.fail("Unreachable code"))
-            .catchError((e) {
-              checkOpenNonExistentFileException(e.error);
+            .catchError((error) {
+              checkOpenNonExistentFileException(error);
               p.toSendPort().send(null);
             });
 }
 
 
 void testDeleteNonExistent() {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentFile");
 
   // Non-existing file should throw exception.
   Expect.throws(() => file.deleteSync(),
                 (e) => checkDeleteNonExistentFileException(e));
 
   var delete = file.delete();
   delete.then((ignore) => Expect.fail("Unreachable code"))
-        .catchError((e) {
-          checkDeleteNonExistentFileException(e.error);
+        .catchError((error) {
+          checkDeleteNonExistentFileException(error);
           p.toSendPort().send(null);
         });
 }
 
 
 void testLengthNonExistent() {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentFile");
 
   // Non-existing file should throw exception.
   Expect.throws(() => file.lengthSync(),
                 (e) => checkLengthNonExistentFileException(e));
 
   var lenFuture = file.length();
   lenFuture.then((len) => Expect.fail("Unreachable code"))
-           .catchError((e) {
-             checkLengthNonExistentFileException(e.error);
+           .catchError((error) {
+             checkLengthNonExistentFileException(error);
              p.toSendPort().send(null);
            });
 }
 
 
 bool checkCreateInNonExistentDirectoryException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.osError != null);
   Expect.isTrue(e.toString().indexOf("Cannot create file") != -1);
   if (Platform.operatingSystem == "linux") {
@@ skipping 15 matching lines @@
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentDirectory/newFile");
 
   // Create in non-existent directory should throw exception.
   Expect.throws(() => file.createSync(),
                 (e) => checkCreateInNonExistentDirectoryException(e));
 
   var create = file.create();
   create.then((ignore) => Expect.fail("Unreachable code"))
-  .catchError((e) {
-    checkCreateInNonExistentDirectoryException(e.error);
+  .catchError((error) {
+    checkCreateInNonExistentDirectoryException(error);
     p.toSendPort().send(null);
   });
 }
 
 bool checkFullPathOnNonExistentDirectoryException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.osError != null);
   Expect.isTrue(e.toString().indexOf("Cannot retrieve full path") != -1);
   // File not not found has error code 2 on all supported platforms.
   Expect.equals(2, e.osError.errorCode);
 
   return true;
 }
 
 void testFullPathOnNonExistentDirectory() {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentDirectory");
 
   // Full path non-existent directory should throw exception.
   Expect.throws(() => file.fullPathSync(),
                 (e) => checkFullPathOnNonExistentDirectoryException(e));
 
   var fullPathFuture = file.fullPath();
   fullPathFuture.then((path) => Expect.fail("Unreachable code $path"))
-  .catchError((e) {
-    checkFullPathOnNonExistentDirectoryException(e.error);
+  .catchError((error) {
+    checkFullPathOnNonExistentDirectoryException(error);
     p.toSendPort().send(null);
   });
 }
 
 bool checkDirectoryInNonExistentDirectoryException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.osError != null);
   Expect.isTrue(
       e.toString().indexOf("Cannot retrieve directory for file") != -1);
   // File not not found has error code 2 on all supported platforms.
@@ skipping 10 matching lines @@
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentDirectory/newFile");
 
   // Create in non-existent directory should throw exception.
   Expect.throws(() => file.directorySync(),
                 (e) => checkDirectoryInNonExistentDirectoryException(e));
 
   var dirFuture = file.directory();
   dirFuture.then((directory) => Expect.fail("Unreachable code"))
-  .catchError((e) {
-    checkDirectoryInNonExistentDirectoryException(e.error);
+  .catchError((error) {
+    checkDirectoryInNonExistentDirectoryException(error);
     p.toSendPort().send(null);
   });
 }
 
 void testReadAsBytesNonExistent() {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentFile3");
 
   // Non-existing file should throw exception.
   Expect.throws(() => file.readAsBytesSync(),
                 (e) => checkOpenNonExistentFileException(e));
 
   var readAsBytesFuture = file.readAsBytes();
   readAsBytesFuture.then((data) => Expect.fail("Unreachable code"))
-  .catchError((e) {
-    checkOpenNonExistentFileException(e.error);
+  .catchError((error) {
+    checkOpenNonExistentFileException(error);
     p.toSendPort().send(null);
   });
 }
 
 void testReadAsTextNonExistent() {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentFile4");
 
   // Non-existing file should throw exception.
   Expect.throws(() => file.readAsStringSync(),
                 (e) => checkOpenNonExistentFileException(e));
 
   var readAsStringFuture = file.readAsString(encoding: Encoding.ASCII);
   readAsStringFuture.then((data) => Expect.fail("Unreachable code"))
-  .catchError((e) {
-    checkOpenNonExistentFileException(e.error);
+  .catchError((error) {
+    checkOpenNonExistentFileException(error);
     p.toSendPort().send(null);
   });
 }
 
 testReadAsLinesNonExistent() {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteSync(recursive: true);
   });
   var file = new File("${temp.path}/nonExistentFile5");
 
   // Non-existing file should throw exception.
   Expect.throws(() => file.readAsLinesSync(),
                 (e) => checkOpenNonExistentFileException(e));
 
   var readAsLinesFuture = file.readAsLines(encoding: Encoding.ASCII);
   readAsLinesFuture.then((data) => Expect.fail("Unreachable code"))
-  .catchError((e) {
-    checkOpenNonExistentFileException(e.error);
+  .catchError((error) {
+    checkOpenNonExistentFileException(error);
     p.toSendPort().send(null);
   });
 }
 
 bool checkWriteReadOnlyFileException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.osError != null);
   Expect.isTrue(e.osError.errorCode != OSError.noErrorCode);
   return true;
 }
@@ skipping 18 matching lines @@
 
 testWriteByteToReadOnlyFile() {
   createTestFile((file, port) {
     var openedFile = file.openSync(mode: FileMode.READ);
 
     // Writing to read only file should throw an exception.
     Expect.throws(() => openedFile.writeByteSync(0),
                   (e) => checkWriteReadOnlyFileException(e));
 
     var writeByteFuture = openedFile.writeByte(0);
-    writeByteFuture.catchError((e) {
-      checkWriteReadOnlyFileException(e.error);
+    writeByteFuture.catchError((error) {
+      checkWriteReadOnlyFileException(error);
       openedFile.close().then((ignore) => port.send(null));
     });
   });
 }
 
 testWriteFromToReadOnlyFile() {
   createTestFile((file, port) {
     var openedFile = file.openSync(mode: FileMode.READ);
 
     List data = [0, 1, 2, 3];
     // Writing to read only file should throw an exception.
     Expect.throws(() => openedFile.writeFromSync(data, 0, data.length),
                   (e) => checkWriteReadOnlyFileException(e));
 
     var writeFromFuture = openedFile.writeFrom(data, 0, data.length);
-    writeFromFuture.catchError((e) {
-      checkWriteReadOnlyFileException(e.error);
+    writeFromFuture.catchError((error) {
+      checkWriteReadOnlyFileException(error);
       openedFile.close().then((ignore) => port.send(null));
     });
   });
 }
 
 testTruncateReadOnlyFile() {
   createTestFile((file, port) {
     var openedFile = file.openSync(mode: FileMode.WRITE);
     openedFile.writeByteSync(0);
     openedFile.closeSync();
     openedFile = file.openSync(mode: FileMode.READ);
 
     // Truncating read only file should throw an exception.
     Expect.throws(() => openedFile.truncateSync(0),
                   (e) => checkWriteReadOnlyFileException(e));
 
     var truncateFuture = openedFile.truncate(0);
     truncateFuture.then((ignore) => Expect.fail("Unreachable code"))
-    .catchError((e) {
-      checkWriteReadOnlyFileException(e.error);
+    .catchError((error) {
+      checkWriteReadOnlyFileException(error);
       openedFile.close().then((ignore) => port.send(null));
     });
   });
 }
 
 bool checkFileClosedException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.toString().indexOf("File closed") != -1);
   Expect.isTrue(e.osError == null);
   return true;
@@ skipping 21 matching lines @@
                   (e) => checkFileClosedException(e));
     Expect.throws(() => openedFile.truncateSync(0),
                   (e) => checkFileClosedException(e));
     Expect.throws(() => openedFile.lengthSync(),
                   (e) => checkFileClosedException(e));
     Expect.throws(() => openedFile.flushSync(),
                   (e) => checkFileClosedException(e));
 
     var errorCount = 0;
 
-    _errorHandler(e) {
-      checkFileClosedException(e.error);
+    _errorHandler(error) {
+      checkFileClosedException(error);
       if (--errorCount == 0) {
         port.send(null);
       }
     }
 
     var readByteFuture = openedFile.readByte();
     readByteFuture.then((byte) => Expect.fail("Unreachable code"))
     .catchError(_errorHandler);
     errorCount++;
     var writeByteFuture = openedFile.writeByte(0);
@@ skipping 34 matching lines @@
     errorCount++;
 });
 }
 
 testRepeatedlyCloseFile() {
   createTestFile((file, port) {
     var openedFile = file.openSync();
     openedFile.close().then((ignore) {
       var closeFuture = openedFile.close();
       closeFuture.then((ignore) => null)
-      .catchError((e) {
-        Expect.isTrue(e.error is FileIOException);
+      .catchError((error) {
+        Expect.isTrue(error is FileIOException);
         port.send(null);
       });
     });
   });
 }
 
 testRepeatedlyCloseFileSync() {
   createTestFile((file, port) {
     var openedFile = file.openSync();
     openedFile.closeSync();
@@ skipping 36 matching lines @@
   testReadAsLinesNonExistent();
   testWriteByteToReadOnlyFile();
   testWriteFromToReadOnlyFile();
   testTruncateReadOnlyFile();
   testOperateOnClosedFile();
   testRepeatedlyCloseFile();
   testRepeatedlyCloseFileSync();
   testReadSyncBigInt();
   testReadSyncClosedFile();
 }