Add the name of the file to exceptions on failed file operations.

runtime/bin/file_impl.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.
 
 class _FileInputStream extends _BaseDataInputStream implements InputStream {
   _FileInputStream(String name) {
     _file = new File(name);
     _data = [];
     _position = 0;
     _file.onError = _reportError;
@@ skipping 260 matching lines @@
   static flush(int id) native "File_Flush";
   static int openStdio(int fd) native "File_OpenStdio";
   static SendPort newServicePort() native "File_NewServicePort";
 
   static bool checkedExists(String name) {
     if (name is !String) {
       throw new IllegalArgumentException();
     }
     var result = exists(name);
     if (result is OSError) {
-      throw new FileIOException("Cannot check existence of file", result);
+      throw new FileIOException("Cannot check existence of file '$name'",
+                                result);
     }
     return result;
   }
 
   static int checkedOpen(String name, int mode) {
     if (name is !String || mode is !int) {
       throw new IllegalArgumentException();
     };
     var result = open(name, mode);
     if (result is OSError) {
-      throw new FileIOException("Cannot open file $name", result);
+      throw new FileIOException("Cannot open file '$name'", result);
     }
     return result;
   }
 
   static bool checkedCreate(String name) {
     if (name is !String) {
       throw new IllegalArgumentException();
     };
     var result = create(name);
     if (result is OSError) {
-      throw new FileIOException("Cannot create file", result);
+      throw new FileIOException("Cannot create file '$name'", result);
     }
     return true;
   }
 
   static bool checkedDelete(String name) {
     if (name is !String) {
       throw new IllegalArgumentException();
     };
     var result = delete(name);
     if (result is OSError) {
-      throw new FileIOException("Cannot delete file", result);
+      throw new FileIOException("Cannot delete file '$name'", result);
     }
     return true;
   }
 
   static String checkedFullPath(String name) {
     if (name is !String) {
       throw new IllegalArgumentException();
     };
     var result = fullPath(name);
     if (result is OSError) {
-      throw new FileIOException("Cannot retrieve full path", result);
+      throw new FileIOException(
+          "Cannot retrieve full path for file '$name'", result);
     }
     return result;
   }
 
   static String checkedDirectory(String name) {
     if (name is !String) {
       throw new IllegalArgumentException();
     }
     var result = directory(name);
     if (result is OSError) {
-      throw new FileIOException("Cannot retrieve directory for file", result);
+      throw new FileIOException(
+          "Cannot retrieve directory for file '$name'", result);
     }
     return result;
   }
 
   static int checkedLengthFromName(String name) {
     if (name is !String) {
       throw new IllegalArgumentException();
     }
     var result = lengthFromName(name);
     if (result is OSError) {
-      throw new FileIOException("Cannot retrieve length of file", result);
+      throw new FileIOException(
+          "Cannot retrieve length of file '$name'", result);
     }
     return result;
   }
 
   static int checkReadWriteListArguments(int length, int offset, int bytes) {
     if (offset < 0) return offset;
     if (bytes < 0) return bytes;
     if ((offset + bytes) > length) return offset + bytes;
     return 0;
   }
@@ skipping 79 matching lines @@
         _handleErrorResponse(response, "Cannot create file");
       } else {
         callback();
       }
     });
   }
 
   void createSync() {
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
-      throw new FileIOException("Cannot create file: $_name");
+      throw new FileIOException("Cannot create file '$_name'");
     }
   }
 
   void delete(void callback()) {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kDeleteRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot delete file");
+        _handleErrorResponse(response, "Cannot delete file '$_name'");
       } else {
         callback();
       }
     });
   }
 
   void deleteSync() {
     _FileUtils.checkedDelete(_name);
   }
 
@@ skipping 37 matching lines @@
     });
   }
 
   void length(void callback(int length)) {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kLengthFromNameRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot retrieve length of file");
+        _handleErrorResponse(response,
+                             "Cannot retrieve length of file '$_name'");
       } else {
         callback(response);
       }
     });
   }
 
   int lengthSync() {
     var result = _FileUtils.checkedLengthFromName(_name);
     if (result is OSError) {
-      throw new FileIOException("Cannot retrieve length of file", result);
+      throw new FileIOException("Cannot retrieve length of file '$_name'",
+                                result);
     }
     return result;
   }
 
   RandomAccessFile openSync([FileMode mode = FileMode.READ]) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException("Unknown file mode. Use FileMode.READ, "
                                 "FileMode.WRITE or FileMode.APPEND.");
@@ skipping 138 matching lines @@
 
   SendPort _fileService;
 }
 
 
 class _RandomAccessFile extends _FileBase implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name);
 
   void close(void callback()) {
     if (_id == 0) {
-      _reportError(new FileIOException("Cannot close file: $_name"));
+      _reportError(new FileIOException("Cannot close file '$_name'"));
       return;
     }
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kCloseRequest;
     request[1] = _id;
     // Set the id_ to 0 (NULL) to ensure the no more async requests
     // can be issues for this file.
     _id = 0;
     _fileService.call(request).then((result) {
       if (result != -1) {
         _id = result;
         callback();
       } else {
-        _reportError(new FileIOException("Cannot close file: $_name"));
+        _reportError(new FileIOException("Cannot close file '$_name'"));
       }
     });
   }
 
   void closeSync() {
     var id = _FileUtils.close(_id);
     if (id == -1) {
-      throw new FileIOException("Cannot close file: $_name");
+      throw new FileIOException("Cannot close file '$_name'");
     }
     _id = id;
   }
 
   void readByte(void callback(int byte)) {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kReadByteRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "readByte failed");
+        _handleErrorResponse(response, "readByte failed for file '$_name'");
       } else {
         callback(response);
       }
     });
   }
 
   int readByteSync() {
     _checkNotClosed();
     var result = _FileUtils.readByte(_id);
     if (result is OSError) {
-      throw new FileIOException("readByte failed", result);
+      throw new FileIOException("readByte failed for file '$_name'", result);
     }
     return result;
   }
 
   void readList(List<int> buffer, int offset, int bytes,
                 void callback(int read)) {
     _ensureFileService();
     if (buffer is !List || offset is !int || bytes is !int) {
-      _reportError(new FileIOException("Invalid arguments to readList"));
+      _reportError(new FileIOException(
+          "Invalid arguments to readList for file '$_name'"));
       return;
     };
     List request = new List(3);
     request[0] = _FileUtils.kReadListRequest;
     request[1] = _id;
     request[2] = bytes;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "readList failed");
+        _handleErrorResponse(response, "readList failed for file '$_name'");
       } else {
         var read = response[1];
         var data = response[2];
         buffer.setRange(offset, read, data);
         callback(read);
       }
     });
   }
 
   int readListSync(List<int> buffer, int offset, int bytes) {
     _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
-      throw new FileIOException("Invalid arguments to readList");
+      throw new FileIOException(
+          "Invalid arguments to readList for file '$_name'");
     }
     if (bytes == 0) return 0;
     int index =
         _FileUtils.checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     var result = _FileUtils.readList(_id, buffer, offset, bytes);
     if (result is OSError) {
-      throw new FileIOException("readList failed", result);
+      throw new FileIOException("readList failed for file '$_name'",
+                                result);
     }
     return result;
   }
 
   void writeByte(int value) {
     _ensureFileService();
     if (value is !int) {
-      _reportError(new FileIOException("Invalid argument to writeByte"));
+      _reportError(new FileIOException(
+          "Invalid argument to writeByte for file '$_name'"));
       return;
     }
     List request = new List(3);
     request[0] = _FileUtils.kWriteByteRequest;
     request[1] = _id;
     request[2] = value;
     _writeEnqueued();
     _fileService.call(request).then((response) {
       _writeCompleted();
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "writeByte failed");
+        _handleErrorResponse(response, "writeByte failed for file '$_name'");
       }
     });
   }
 
   int writeByteSync(int value) {
     _checkNotClosed();
     if (value is !int) {
-      throw new FileIOException("Invalid argument to writeByte");
+      throw new FileIOException(
+          "Invalid argument to writeByte for file '$_name'");
     }
     var result = _FileUtils.writeByte(_id, value);
     if (result is OSError) {
-      throw new FileIOException("writeByte failed", result);
+      throw new FileIOException("writeByte failed for file '$_name'",
+                                result);
     }
     return result;
   }
 
   void writeList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
     if (buffer is !List || offset is !int || bytes is !int) {
-      _reportError(new FileIOException("Invalid arguments to writeList"));
+      _reportError(new FileIOException(
+          "Invalid arguments to writeList for file '$_name'"));
       return;
     }
 
     List result =
         _FileUtils.ensureFastAndSerializableBuffer(buffer, offset, bytes);
     List outBuffer = result[0];
     int outOffset = result[1];
 
     List request = new List(5);
     request[0] = _FileUtils.kWriteListRequest;
     request[1] = _id;
     request[2] = outBuffer;
     request[3] = outOffset;
     request[4] = bytes;
     _writeEnqueued();
     _fileService.call(request).then((response) {
       _writeCompleted();
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "writeList failed");
+        _handleErrorResponse(response, "writeList failed for file '$_name'");
       }
     });
   }
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
     _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
-      throw new FileIOException("Invalid arguments to writeList");
+      throw new FileIOException(
+          "Invalid arguments to writeList for file '$_name'");
     }
     if (bytes == 0) return 0;
     int index =
         _FileUtils.checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     var result = _FileUtils.writeList(_id, buffer, offset, bytes);
     if (result is OSError) {
-      throw new FileIOException("writeList failed", result);
+      throw new FileIOException("writeList failed for file '$_name'", result);
     }
     return result;
   }
 
   void writeString(String string, [Encoding encoding = Encoding.UTF_8]) {
     _ensureFileService();
     List request = new List(3);
     request[0] = _FileUtils.kWriteStringRequest;
     request[1] = _id;
     request[2] = string;
     _writeEnqueued();
     _fileService.call(request).then((response) {
       _writeCompleted();
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "writeString failed");
+        _handleErrorResponse(response, "writeString failed for file '$_name'");
       }
     });
   }
 
   int writeStringSync(String string, [Encoding encoding = Encoding.UTF_8]) {
     _checkNotClosed();
     var result = _FileUtils.checkedWriteString(_id, string);
     if (result is OSError) {
-      throw new FileIOException("writeString failed", result);
+      throw new FileIOException("writeString failed for file '$_name'", result);
     }
     return result;
   }
 
   void position(void callback(int position)) {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kPositionRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "position failed");
+        _handleErrorResponse(response, "position failed for file '$_name'");
       } else {
         callback(response);
       }
     });
   }
 
   int positionSync() {
     _checkNotClosed();
     var result = _FileUtils.position(_id);
     if (result is OSError) {
-      throw new FileIOException("position failed", result);
+      throw new FileIOException("position failed for file '$_name'", result);
     }
     return result;
   }
 
   void setPosition(int position, void callback()) {
     _ensureFileService();
     List request = new List(3);
     request[0] = _FileUtils.kSetPositionRequest;
     request[1] = _id;
     request[2] = position;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "setPosition failed");
+        _handleErrorResponse(response, "setPosition failed for file '$_name'");
       } else {
         callback();
       }
     });
   }
 
   void setPositionSync(int position) {
     _checkNotClosed();
     var result = _FileUtils.setPosition(_id, position);
     if (result is OSError) {
-      throw new FileIOException("setPosition failed", result);
+      throw new FileIOException("setPosition failed for file '$_name'", result);
     }
   }
 
   void truncate(int length, void callback()) {
     _ensureFileService();
     List request = new List(3);
     request[0] = _FileUtils.kTruncateRequest;
     request[1] = _id;
     request[2] = length;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "truncate failed");
+        _handleErrorResponse(response, "truncate failed for file '$_name'");
       } else {
         callback();
       }
     });
   }
 
   void truncateSync(int length) {
     _checkNotClosed();
     var result = _FileUtils.truncate(_id, length);
     if (result is OSError) {
-      throw new FileIOException("truncate failed", result);
+      throw new FileIOException("truncate failed for file '$_name'", result);
     }
   }
 
   void length(void callback(int length)) {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kLengthRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "length failed");
+        _handleErrorResponse(response, "length failed for file '$_name'");
       } else {
         callback(response);
       }
     });
   }
 
   int lengthSync() {
     _checkNotClosed();
     var result = _FileUtils.length(_id);
     if (result is OSError) {
-      throw new FileIOException("length failed", result);
+      throw new FileIOException("length failed for file '$_name'", result);
     }
     return result;
   }
 
   void flush(void callback()) {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FileUtils.kFlushRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "flush failed");
+        _handleErrorResponse(response, "flush failed for file '$_name'");
       } else {
         callback();
       }
     });
   }
 
   void flushSync() {
     _checkNotClosed();
     var result = _FileUtils.flush(_id);
     if (result is OSError) {
-      throw new FileIOException("flush failed", result);
+      throw new FileIOException("flush failed for file '$_name'", result);
     }
   }
 
   String get name() => _name;
 
   void set onNoPendingWrites(void handler()) {
     _onNoPendingWrites = handler;
     if (_pendingWrites == 0) {
       _noPendingWriteTimer = new Timer(0, (t) {
         if (_onNoPendingWrites != null) _onNoPendingWrites();
@@ skipping 17 matching lines @@
 
   void  _writeCompleted() {
     _pendingWrites--;
     if (_pendingWrites == 0 && _onNoPendingWrites != null) {
       _onNoPendingWrites();
     }
   }
 
   void _checkNotClosed() {
     if (_id == 0) {
-      throw new FileIOException("File closed");
+      throw new FileIOException("File closed '$_name'");
     }
   }
 
   String _name;
   int _id;
   int _pendingWrites = 0;
 
   SendPort _fileService;
 
   Timer _noPendingWriteTimer;
 
   Function _onNoPendingWrites;
 }