Add FileException.path and clean up file exceptions.

sdk/lib/io/file_impl.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.
 
 part of dart.io;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 235 matching lines @@
   // Constructor from Path for file.
   _File.fromPath(Path path) : this(path.toNativePath());
 
   Future<bool> exists() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _EXISTS_REQUEST;
     request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "Cannot check existence of file '$_path'");
+        throw _exceptionFromResponse(response, "Cannot check existence", _path);
       }
       return response;
     });
   }
 
   external static _exists(String path);
 
   bool existsSync() {
     var result = _exists(_path);
-    throwIfError(result, "Cannot check existence of file '$_path'");
+    throwIfError(result, "Cannot check existence of file", _path);
     return result;
   }
 
   Future<FileStat> stat() => FileStat.stat(path);
 
   FileStat statSync() => FileStat.statSync(path);
 
   Future<File> create() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _CREATE_REQUEST;
     request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot create file '$_path'");
+        throw _exceptionFromResponse(response, "Cannot create file", _path);
       }
       return this;
     });
   }
 
   external static _create(String path);
 
   external static _createLink(String path, String target);
 
   external static _linkTarget(String path);
 
   void createSync() {
     var result = _create(_path);
-    throwIfError(result, "Cannot create file '$_path'");
+    throwIfError(result, "Cannot create file", _path);
   }
 
   Future<File> delete() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _DELETE_REQUEST;
     request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot delete file '$_path'");
+        throw _exceptionFromResponse(response, "Cannot delete file", _path);
       }
       return this;
     });
   }
 
   external static _delete(String path);
 
   external static _deleteLink(String path);
 
   void deleteSync() {
     var result = _delete(_path);
-    throwIfError(result, "Cannot delete file '$_path'");
+    throwIfError(result, "Cannot delete file", _path);
   }
 
   Future<File> rename(String newPath) {
     _ensureFileService();
     List request = new List(3);
     request[0] = _RENAME_REQUEST;
     request[1] = _path;
     request[2] = newPath;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
-            response, "Cannot rename file '$_path' to '$newPath'");
+            response, "Cannot rename file to '$newPath'", _path);
       }
       return new File(newPath);
     });
   }
 
   external static _rename(String oldPath, String newPath);
 
   external static _renameLink(String oldPath, String newPath);
 
   File renameSync(String newPath) {
     var result = _rename(_path, newPath);
-    throwIfError(result, "Cannot rename file '$_path' to '$newPath'");
+    throwIfError(result, "Cannot rename file to '$newPath'", _path);
     return new File(newPath);
   }
 
   Directory get directory {
     Path path = new Path(_path).directoryPath;
     return new Directory.fromPath(path);
   }
 
   Future<RandomAccessFile> open({FileMode mode: FileMode.READ}) {
     _ensureFileService();
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       return new Future.error(new ArgumentError());
     }
     List request = new List(3);
     request[0] = _OPEN_REQUEST;
     request[1] = _path;
     request[2] = mode._mode;  // Direct int value for serialization.
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot open file '$_path'");
+        throw _exceptionFromResponse(response, "Cannot open file", _path);
       }
       return new _RandomAccessFile(response, _path);
     });
   }
 
   Future<int> length() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _LENGTH_FROM_PATH_REQUEST;
     request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "Cannot retrieve length of "
-                                     "file '$_path'");
+                                     "Cannot retrieve length of file",
+                                     _path);
       }
       return response;
     });
   }
 
 
   external static _lengthFromPath(String path);
 
   int lengthSync() {
     var result = _lengthFromPath(_path);
-    throwIfError(result, "Cannot retrieve length of file '$_path'");
+    throwIfError(result, "Cannot retrieve length of file", _path);
     return result;
   }
 
   Future<DateTime> lastModified() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _LAST_MODIFIED_REQUEST;
     request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "Cannot retrieve modification time "
-                                     "for file '$_path'");
+                                     "Cannot retrieve modification time",
+                                     _path);
       }
       return new DateTime.fromMillisecondsSinceEpoch(response);
     });
   }
 
   external static _lastModified(String path);
 
   DateTime lastModifiedSync() {
     var ms = _lastModified(path);
-    throwIfError(ms, "Cannot retrieve modification time for file '$_path'");
+    throwIfError(ms, "Cannot retrieve modification time", _path);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   }
 
   external static _open(String path, int mode);
 
   RandomAccessFile openSync({FileMode mode: FileMode.READ}) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileException("Unknown file mode. Use FileMode.READ, "
-                                "FileMode.WRITE or FileMode.APPEND.");
+                              "FileMode.WRITE or FileMode.APPEND.",
+                              _path);
     }
     var id = _open(_path, mode._mode);
-    throwIfError(id, "Cannot open file '$_path'");
+    throwIfError(id, "Cannot open file", _path);
     return new _RandomAccessFile(id, _path);
   }
 
   external static int _openStdio(int fd);
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _openStdio(fd);
     if (id == 0) {
       throw new FileException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
   Future<String> fullPath() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FULL_PATH_REQUEST;
     request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "Cannot retrieve full path"
-                                     " for '$_path'");
+                                     "Cannot retrieve full path",
+                                     _path);
       }
       return response;
     });
   }
 
   external static _fullPath(String path);
 
   String fullPathSync() {
     var result = _fullPath(_path);
-    throwIfError(result, "Cannot retrieve full path for file '$_path'");
+    throwIfError(result, "Cannot retrieve full path", _path);
     return result;
   }
 
   Stream<List<int>> openRead([int start, int end]) {
     return new _FileStream(_path, start, end);
   }
 
   IOSink openWrite({FileMode mode: FileMode.WRITE,
                     Encoding encoding: Encoding.UTF_8}) {
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
-      throw new FileException(
+      throw new ArgumentError(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     var consumer = new _FileStreamConsumer(this, mode);
     return new IOSink(consumer, encoding: encoding);
   }
 
   Future<List<int>> readAsBytes() {
     _ensureFileService();
     Completer<List<int>> completer = new Completer<List<int>>();
     var chunks = new _BufferList();
@@ skipping 94 matching lines @@
   String get path => _path;
 
   String toString() => "File: '$path'";
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils._newServicePort();
     }
   }
 
-  static throwIfError(Object result, String msg) {
+  static throwIfError(Object result, String msg, String path) {
     if (result is OSError) {
-      throw new FileException(msg, result);
+      throw new FileException(msg, path, result);
     }
   }
 
   final String _path;
 
   SendPort _fileService;
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._path);
 
   Future<RandomAccessFile> close() {
     if (closed) return _closedException();
     _ensureFileService();
     List request = new List(2);
     request[0] = _CLOSE_REQUEST;
     request[1] = _id;
     // Set the id_ to 0 (NULL) to ensure the no more async requests
     // can be issued for this file.
     _id = 0;
     return _fileService.call(request).then((result) {
       if (result != -1) {
         _id = result;
         return this;
       } else {
-        throw new FileException("Cannot close file '$_path'");
+        throw new FileException("Cannot close file", _path);
       }
     });
   }
 
   external static int _close(int id);
 
   void closeSync() {
     _checkNotClosed();
     var id = _close(_id);
     if (id == -1) {
-      throw new FileException("Cannot close file '$_path'");
+      throw new FileException("Cannot close file", _path);
     }
     _id = id;
   }
 
   Future<int> readByte() {
     _ensureFileService();
     if (closed) return _closedException();
     List request = new List(2);
     request[0] = _READ_BYTE_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "readByte failed for file '$_path'");
+        throw _exceptionFromResponse(response, "readByte failed", _path);
       }
       return response;
     });
   }
 
   external static _readByte(int id);
 
   int readByteSync() {
     _checkNotClosed();
     var result = _readByte(_id);
     if (result is OSError) {
-      throw new FileException("readByte failed for file '$_path'", result);
+      throw new FileException("readByte failed", _path, result);
     }
     return result;
   }
 
   Future<List<int>> read(int bytes) {
     _ensureFileService();
     if (bytes is !int) {
-      return new Future.error(new FileException(
-          "Invalid arguments to read for file '$_path'"));
+      throw new ArgumentError(bytes);
     }
     if (closed) return _closedException();
     List request = new List(3);
     request[0] = _READ_REQUEST;
     request[1] = _id;
     request[2] = bytes;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "read failed for file '$_path'");
+        throw _exceptionFromResponse(response, "read failed", _path);
       }
       return response[1];
     });
   }
 
   external static _read(int id, int bytes);
 
   List<int> readSync(int bytes) {
     _checkNotClosed();
     if (bytes is !int) {
-      throw new FileException(
-          "Invalid arguments to readSync for file '$_path'");
+      throw new ArgumentError(bytes);
     }
     var result = _read(_id, bytes);
     if (result is OSError) {
-      throw new FileException("readSync failed for file '$_path'",
-                                result);
+      throw new FileException("readSync failed",_path, result);
     }
     return result;
   }
 
   Future<int> readInto(List<int> buffer, [int start, int end]) {
     _ensureFileService();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
-      return new Future.error(new FileException(
-          "Invalid arguments to readInto for file '$_path'"));
-    };
+      throw new ArgumentError();
+    }
     if (closed) return _closedException();
     List request = new List(3);
     if (start == null) start = 0;
     if (end == null) end = buffer.length;
     request[0] = _READ_LIST_REQUEST;
     request[1] = _id;
     request[2] = end - start;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "readInto failed for file '$_path'");
+        throw _exceptionFromResponse(response, "readInto failed", _path);
       }
       var read = response[1];
       var data = response[2];
       buffer.setRange(start, start + read, data);
       return read;
     });
   }
 
   static void _checkReadWriteListArguments(int length, int start, int end) {
     if (start < 0) throw new RangeError.value(start);
     if (end < start) throw new RangeError.value(end);
     if (end > length) {
       throw new RangeError.value(end);
     }
   }
 
   external static _readInto(int id, List<int> buffer, int start, int end);
 
   int readIntoSync(List<int> buffer, [int start, int end]) {
     _checkNotClosed();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
-      throw new FileException(
-          "Invalid arguments to readInto for file '$_path'");
+      throw new ArgumentError();
     }
     if (start == null) start = 0;
     if (end == null) end = buffer.length;
     if (end == start) return 0;
     _checkReadWriteListArguments(buffer.length, start, end);
     var result = _readInto(_id, buffer, start, end);
     if (result is OSError) {
-      throw new FileException("readInto failed for file '$_path'",
-                                result);
+      throw new FileException("readInto failed", _path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     _ensureFileService();
     if (value is !int) {
-      return new Future.error(new FileException(
-          "Invalid argument to writeByte for file '$_path'"));
+      throw new ArgumentError(value);
     }
     if (closed) return _closedException();
     List request = new List(3);
     request[0] = _WRITE_BYTE_REQUEST;
     request[1] = _id;
     request[2] = value;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "writeByte failed for file '$_path'");
+        throw _exceptionFromResponse(response, "writeByte failed",_path);
       }
       return this;
     });
   }
 
   external static _writeByte(int id, int value);
 
   int writeByteSync(int value) {
     _checkNotClosed();
     if (value is !int) {
-      throw new FileException(
-          "Invalid argument to writeByte for file '$_path'");
+      throw new ArgumentError(value);
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
-      throw new FileException("writeByte failed for file '$_path'",
-                                result);
+      throw new FileException("writeByte failed", _path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeFrom(List<int> buffer, [int start, int end]) {
     _ensureFileService();
     if ((buffer is !List && buffer is !ByteData) ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
-      return new Future.error(new FileException(
-          "Invalid arguments to writeFrom for file '$_path'"));
+      throw new ArgumentError("Invalid arguments to writeFrom");
     }
 
     if (closed) return _closedException();
 
     _BufferAndStart result;
     try {
       result = _ensureFastAndSerializableData(buffer, start, end);
     } catch (e) {
       return new Future.error(e);
     }
 
     List request = new List(5);
     request[0] = _WRITE_LIST_REQUEST;
     request[1] = _id;
     request[2] = result.buffer;
     request[3] = result.start;
     request[4] = end - (start - result.start);
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "writeFrom failed for file '$_path'");
+        throw _exceptionFromResponse(response, "writeFrom failed", _path);
       }
       return this;
     });
   }
 
   external static _writeFrom(int id, List<int> buffer, int start, int end);
 
   void writeFromSync(List<int> buffer, [int start, int end]) {
     _checkNotClosed();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
-      throw new FileException(
-          "Invalid arguments to writeFrom for file '$_path'");
+      throw new ArgumentError("Invalid arguments to writeFromSync");
     }
     if (start == null) start = 0;
     if (end == null) end = buffer.length;
     if (end == start) return;
     _checkReadWriteListArguments(buffer.length, start, end);
     _BufferAndStart bufferAndStart =
         _ensureFastAndSerializableData(buffer, start, end);
     var result = _writeFrom(_id,
                             bufferAndStart.buffer,
                             bufferAndStart.start,
                             end - (start - bufferAndStart.start));
     if (result is OSError) {
-      throw new FileException("writeFrom failed for file '$_path'", result);
+      throw new FileException("writeFrom failed", _path, result);
     }
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        {Encoding encoding: Encoding.UTF_8}) {
     if (encoding is! Encoding) {
-      return new Future.error(new FileException(
-          "Invalid encoding in writeString: $encoding"));
+      throw new ArgumentError(encoding);
     }
     var data = _encodeString(string, encoding);
     return writeFrom(data, 0, data.length);
   }
 
   void writeStringSync(String string, {Encoding encoding: Encoding.UTF_8}) {
     if (encoding is! Encoding) {
-      throw new FileException(
-          "Invalid encoding in writeStringSync: $encoding");
+      throw new ArgumentError(encoding);
     }
     var data = _encodeString(string, encoding);
     writeFromSync(data, 0, data.length);
   }
 
   Future<int> position() {
     _ensureFileService();
     if (closed) return _closedException();
     List request = new List(2);
     request[0] = _POSITION_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "position failed for file '$_path'");
+        throw _exceptionFromResponse(response, "position failed", _path);
       }
       return response;
     });
   }
 
   external static _position(int id);
 
   int positionSync() {
     _checkNotClosed();
     var result = _position(_id);
     if (result is OSError) {
-      throw new FileException("position failed for file '$_path'", result);
+      throw new FileException("position failed", _path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
     _ensureFileService();
     if (closed) return _closedException();
     List request = new List(3);
     request[0] = _SET_POSITION_REQUEST;
     request[1] = _id;
     request[2] = position;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "setPosition failed for file '$_path'");
+        throw _exceptionFromResponse(response, "setPosition failed", _path);
       }
       return this;
     });
   }
 
   external static _setPosition(int id, int position);
 
   void setPositionSync(int position) {
     _checkNotClosed();
     var result = _setPosition(_id, position);
     if (result is OSError) {
-      throw new FileException("setPosition failed for file '$_path'", result);
+      throw new FileException("setPosition failed", _path, result);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
     _ensureFileService();
     if (closed) return _closedException();
     List request = new List(3);
     request[0] = _TRUNCATE_REQUEST;
     request[1] = _id;
     request[2] = length;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "truncate failed for file '$_path'");
+        throw _exceptionFromResponse(response, "truncate failed", _path);
       }
       return this;
     });
   }
 
   external static _truncate(int id, int length);
 
   void truncateSync(int length) {
     _checkNotClosed();
     var result = _truncate(_id, length);
     if (result is OSError) {
-      throw new FileException("truncate failed for file '$_path'", result);
+      throw new FileException("truncate failed", _path, result);
     }
   }
 
   Future<int> length() {
     _ensureFileService();
     if (closed) return _closedException();
     List request = new List(2);
     request[0] = _LENGTH_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "length failed for file '$_path'");
+        throw _exceptionFromResponse(response, "length failed", _path);
       }
       return response;
     });
   }
 
   external static _length(int id);
 
   int lengthSync() {
     _checkNotClosed();
     var result = _length(_id);
     if (result is OSError) {
-      throw new FileException("length failed for file '$_path'", result);
+      throw new FileException("length failed", _path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> flush() {
     _ensureFileService();
     if (closed) return _closedException();
     List request = new List(2);
     request[0] = _FLUSH_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "flush failed for file '$_path'");
+                                     "flush failed",
+                                     _path);
       }
       return this;
     });
   }
 
   external static _flush(int id);
 
   void flushSync() {
     _checkNotClosed();
     var result = _flush(_id);
     if (result is OSError) {
-      throw new FileException("flush failed for file '$_path'", result);
+      throw new FileException("flush failed", _path, result);
     }
   }
 
   String get path => _path;
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils._newServicePort();
     }
   }
 
   bool get closed => _id == 0;
 
   void _checkNotClosed() {
     if (closed) {
-      throw new FileException("File closed '$_path'");
+      throw new FileException("File closed", _path);
     }
   }
 
   Future _closedException() {
-    return new Future.error(new FileException("File closed '$_path'"));
+    return new Future.error(new FileException("File closed", _path));
   }
 
   final String _path;
   int _id;
 
   SendPort _fileService;
 }