dart:io | Rename File.name to File.path.

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;
 
 
 class _FileStream extends Stream<List<int>> {
   // Stream controller.
   StreamController<List<int>> _controller;
 
   // Read the file in blocks of size 64k.
   final int _blockSize = 64 * 1024;
 
   // Information about the underlying file.
-  String _name;
+  String _path;
   RandomAccessFile _openedFile;
   int _position;
 
   // Has the stream been paused or unsubscribed?
   bool _paused = false;
   bool _unsubscribed = false;
 
   // Is there a read currently in progress?
   bool _readInProgress = false;
 
   // Block read but not yet send because stream is paused.
   List<int> _currentBlock;
 
-  _FileStream(String this._name) : _position = 0 {
+  _FileStream(String this._path) : _position = 0 {
     _setupController();
   }
 
   _FileStream.forStdin() : _position = 0 {
     _setupController();
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(AsyncError error),
                                         void onDone(),
@@ skipping 55 matching lines @@
         if (!_unsubscribed) {
           _controller.signalError(e);
           _closeFile().then((_) { _controller.close(); });
           _unsubscribed = true;
         }
       });
   }
 
   void _start() {
     Future<RandomAccessFile> openFuture;
-    if (_name != null) {
-      openFuture = new File(_name).open(FileMode.READ);
+    if (_path != null) {
+      openFuture = new File(_path).open(FileMode.READ);
     } else {
       openFuture = new Future.immediate(_File._openStdioSync(0));
     }
     openFuture
       .then((RandomAccessFile opened) {
         _openedFile = opened;
         _readBlock();
       })
       .catchError((e) {
         _controller.signalError(e);
@@ skipping 86 matching lines @@
 const int _CREATE_REQUEST = 1;
 const int _DELETE_REQUEST = 2;
 const int _OPEN_REQUEST = 3;
 const int _FULL_PATH_REQUEST = 4;
 const int _DIRECTORY_REQUEST = 5;
 const int _CLOSE_REQUEST = 6;
 const int _POSITION_REQUEST = 7;
 const int _SET_POSITION_REQUEST = 8;
 const int _TRUNCATE_REQUEST = 9;
 const int _LENGTH_REQUEST = 10;
-const int _LENGTH_FROM_NAME_REQUEST = 11;
+const int _LENGTH_FROM_PATH_REQUEST = 11;
 const int _LAST_MODIFIED_REQUEST = 12;
 const int _FLUSH_REQUEST = 13;
 const int _READ_BYTE_REQUEST = 14;
 const int _WRITE_BYTE_REQUEST = 15;
 const int _READ_REQUEST = 16;
 const int _READ_LIST_REQUEST = 17;
 const int _WRITE_LIST_REQUEST = 18;
 
 // Base class for _File and _RandomAccessFile with shared functions.
 class _FileBase {
@@ skipping 21 matching lines @@
 // TODO(ager): The only reason for this class is that the patching
 // mechanism doesn't seem to like patching a private top level
 // function.
 class _FileUtils {
   external static SendPort _newServicePort();
 }
 
 // Class for encapsulating the native implementation of files.
 class _File extends _FileBase implements File {
   // Constructor for file.
-  _File(String this._name) {
-    if (_name is! String) {
-      throw new ArgumentError('${Error.safeToString(_name)} '
+  _File(String this._path) {
+    if (_path is! String) {
+      throw new ArgumentError('${Error.safeToString(_path)} '
                               'is not a String');
     }
   }
 
   // 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] = _name;
+    request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot open file '$_name'");
+        throw _exceptionFromResponse(response, "Cannot open file '$_path'");
       }
       return response;
     });
   }
 
-  external static _exists(String name);
+  external static _exists(String path);
 
   bool existsSync() {
-    var result = _exists(_name);
-    throwIfError(result, "Cannot check existence of file '$_name'");
+    var result = _exists(_path);
+    throwIfError(result, "Cannot check existence of file '$_path'");
     return result;
   }
 
   Future<File> create() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _CREATE_REQUEST;
-    request[1] = _name;
+    request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot create file '$_name'");
+        throw _exceptionFromResponse(response, "Cannot create file '$_path'");
       }
       return this;
     });
   }
 
-  external static _create(String name);
+  external static _create(String path);
 
   void createSync() {
-    var result = _create(_name);
-    throwIfError(result, "Cannot create file '$_name'");
+    var result = _create(_path);
+    throwIfError(result, "Cannot create file '$_path'");
   }
 
   Future<File> delete() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _DELETE_REQUEST;
-    request[1] = _name;
+    request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot delete file '$_name'");
+        throw _exceptionFromResponse(response, "Cannot delete file '$_path'");
       }
       return this;
     });
   }
 
-  external static _delete(String name);
+  external static _delete(String path);
 
   void deleteSync() {
-    var result = _delete(_name);
-    throwIfError(result, "Cannot delete file '$_name'");
+    var result = _delete(_path);
+    throwIfError(result, "Cannot delete file '$_path'");
   }
 
   Future<Directory> directory() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _DIRECTORY_REQUEST;
-    request[1] = _name;
+    request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve directory for "
-                                     "file '$_name'");
+                                     "file '$_path'");
       }
       return new Directory(response);
     });
   }
 
-  external static _directory(String name);
+  external static _directory(String path);
 
   Directory directorySync() {
-    var result = _directory(name);
-    throwIfError(result, "Cannot retrieve directory for file '$_name'");
+    var result = _directory(path);
+    throwIfError(result, "Cannot retrieve directory for file '$_path'");
     return new Directory(result);
   }
 
   Future<RandomAccessFile> open([FileMode mode = FileMode.READ]) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       Timer.run(() {
         completer.completeError(new ArgumentError());
       });
       return completer.future;
     }
     List request = new List(3);
     request[0] = _OPEN_REQUEST;
-    request[1] = _name;
+    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 '$_name'");
+        throw _exceptionFromResponse(response, "Cannot open file '$_path'");
       }
-      return new _RandomAccessFile(response, _name);
+      return new _RandomAccessFile(response, _path);
     });
   }
 
   Future<int> length() {
     _ensureFileService();
     List request = new List(2);
-    request[0] = _LENGTH_FROM_NAME_REQUEST;
-    request[1] = _name;
+    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 '$_name'");
+                                     "file '$_path'");
       }
       return response;
     });
   }
 
 
-  external static _lengthFromName(String name);
+  external static _lengthFromPath(String path);
 
   int lengthSync() {
-    var result = _lengthFromName(_name);
-    throwIfError(result, "Cannot retrieve length of file '$_name'");
+    var result = _lengthFromPath(_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] = _name;
+    request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve modification time "
-                                     "for file '$_name'");
+                                     "for file '$_path'");
       }
       return new DateTime.fromMillisecondsSinceEpoch(response);
     });
   }
 
-  external static _lastModified(String name);
+  external static _lastModified(String path);
 
   DateTime lastModifiedSync() {
-    var ms = _lastModified(name);
-    throwIfError(ms, "Cannot retrieve modification time for file '$_name'");
+    var ms = _lastModified(path);
+    throwIfError(ms, "Cannot retrieve modification time for file '$_path'");
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   }
 
-  external static _open(String name, int mode);
+  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 FileIOException("Unknown file mode. Use FileMode.READ, "
                                 "FileMode.WRITE or FileMode.APPEND.");
     }
-    var id = _open(_name, mode._mode);
-    throwIfError(id, "Cannot open file '$_name'");
-    return new _RandomAccessFile(id, _name);
+    var id = _open(_path, mode._mode);
+    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 FileIOException("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] = _name;
+    request[1] = _path;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve full path"
-                                     " for '$_name'");
+                                     " for '$_path'");
       }
       return response;
     });
   }
 
-  external static _fullPath(String name);
+  external static _fullPath(String path);
 
   String fullPathSync() {
-    var result = _fullPath(_name);
-    throwIfError(result, "Cannot retrieve full path for file '$_name'");
+    var result = _fullPath(_path);
+    throwIfError(result, "Cannot retrieve full path for file '$_path'");
     return result;
   }
 
   Stream<List<int>> openRead() {
-    return new _FileStream(_name);
+    return new _FileStream(_path);
   }
 
   IOSink<File> openWrite([FileMode mode = FileMode.WRITE]) {
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     var consumer = new _FileStreamConsumer(this, mode);
     return new IOSink<File>(consumer);
@@ skipping 104 matching lines @@
       return completer.future;
     }
   }
 
   void writeAsStringSync(String contents,
                          {FileMode mode: FileMode.WRITE,
                           Encoding encoding: Encoding.UTF_8}) {
     writeAsBytesSync(_encodeString(contents, encoding), mode);
   }
 
-  String get name => _name;
+  String get path => _path;
 
-  String toString() => "File: '$name'";
+  String toString() => "File: '$path'";
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils._newServicePort();
     }
   }
 
   static throwIfError(Object result, String msg) {
     if (result is OSError) {
       throw new FileIOException(msg, result);
     }
   }
 
-  final String _name;
+  final String _path;
 
   SendPort _fileService;
 }
 
 
 class _RandomAccessFile extends _FileBase implements RandomAccessFile {
-  _RandomAccessFile(int this._id, String this._name);
+  _RandomAccessFile(int this._id, String this._path);
 
   Future<RandomAccessFile> close() {
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     _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 FileIOException("Cannot close file '$_name'");
+        throw new FileIOException("Cannot close file '$_path'");
       }
     });
   }
 
   external static int _close(int id);
 
   void closeSync() {
     _checkNotClosed();
     var id = _close(_id);
     if (id == -1) {
-      throw new FileIOException("Cannot close file '$_name'");
+      throw new FileIOException("Cannot close file '$_path'");
     }
     _id = id;
   }
 
   Future<int> readByte() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "readByte failed for file '$_path'");
       }
       return response;
     });
   }
 
   external static _readByte(int id);
 
   int readByteSync() {
     _checkNotClosed();
     var result = _readByte(_id);
     if (result is OSError) {
-      throw new FileIOException("readByte failed for file '$_name'", result);
+      throw new FileIOException("readByte failed for file '$_path'", result);
     }
     return result;
   }
 
   Future<List<int>> read(int bytes) {
     _ensureFileService();
     Completer<List<int>> completer = new Completer<List<int>>();
     if (bytes is !int) {
       // Complete asynchronously so the user has a chance to setup
       // handlers without getting exceptions when registering the
       // then handler.
       Timer.run(() {
         completer.completeError(new FileIOException(
-            "Invalid arguments to read for file '$_name'"));
+            "Invalid arguments to read for file '$_path'"));
       });
       return completer.future;
     };
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "read failed for file '$_path'");
       }
       return response[1];
     });
   }
 
   external static _read(int id, int bytes);
 
   List<int> readSync(int bytes) {
     if (bytes is !int) {
       throw new FileIOException(
-          "Invalid arguments to readSync for file '$_name'");
+          "Invalid arguments to readSync for file '$_path'");
     }
     return _read(_id, bytes);
   }
 
   Future<int> readList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (buffer is !List || offset is !int || bytes is !int) {
       // Complete asynchronously so the user has a chance to setup
       // handlers without getting exceptions when registering the
       // then handler.
       Timer.run(() {
         completer.completeError(new FileIOException(
-            "Invalid arguments to readList for file '$_name'"));
+            "Invalid arguments to readList for file '$_path'"));
       });
       return completer.future;
     };
     if (closed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _READ_LIST_REQUEST;
     request[1] = _id;
     request[2] = bytes;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "readList failed for file '$_name'");
+                                     "readList failed for file '$_path'");
       }
       var read = response[1];
       var data = response[2];
       buffer.setRange(offset, read, data);
       return read;
     });
   }
 
   static void _checkReadWriteListArguments(int length, int offset, int bytes) {
     if (offset < 0) throw new RangeError.value(offset);
     if (bytes < 0) throw new RangeError.value(bytes);
     if ((offset + bytes) > length) {
       throw new RangeError.value(offset + bytes);
     }
   }
 
   external static _readList(int id, List<int> buffer, int offset, int bytes);
 
   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 for file '$_name'");
+          "Invalid arguments to readList for file '$_path'");
     }
     if (bytes == 0) return 0;
     _checkReadWriteListArguments(buffer.length, offset, bytes);
     var result = _readList(_id, buffer, offset, bytes);
     if (result is OSError) {
-      throw new FileIOException("readList failed for file '$_name'",
+      throw new FileIOException("readList failed for file '$_path'",
                                 result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (value is !int) {
       // Complete asynchronously so the user has a chance to setup
       // handlers without getting exceptions when registering the
       // then handler.
       Timer.run(() {
           completer.completeError(new FileIOException(
-              "Invalid argument to writeByte for file '$_name'"));
+              "Invalid argument to writeByte for file '$_path'"));
       });
       return completer.future;
     }
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "writeByte failed for file '$_path'");
       }
       return this;
     });
   }
 
   external static _writeByte(int id, int value);
 
   int writeByteSync(int value) {
     _checkNotClosed();
     if (value is !int) {
       throw new FileIOException(
-          "Invalid argument to writeByte for file '$_name'");
+          "Invalid argument to writeByte for file '$_path'");
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
-      throw new FileIOException("writeByte failed for file '$_name'",
+      throw new FileIOException("writeByte failed for file '$_path'",
                                 result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (buffer is !List || offset is !int || bytes is !int) {
       // Complete asynchronously so the user has a chance to setup
       // handlers without getting exceptions when registering the
       // then handler.
       Timer.run(() {
           completer.completeError(new FileIOException(
-          "Invalid arguments to writeList for file '$_name'"));
+          "Invalid arguments to writeList for file '$_path'"));
       });
       return completer.future;
     }
     if (closed) return _completeWithClosedException(completer);
 
     _BufferAndOffset result;
     try {
       result = _ensureFastAndSerializableBuffer(buffer, offset, bytes);
     } catch (e) {
       // Complete asynchronously so the user has a chance to setup
       // handlers without getting exceptions when registering the
       // then handler.
       Timer.run(() => completer.completeError(e));
       return completer.future;
     }
 
     List request = new List(5);
     request[0] = _WRITE_LIST_REQUEST;
     request[1] = _id;
     request[2] = result.buffer;
     request[3] = result.offset;
     request[4] = bytes;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "writeList failed for file '$_name'");
+                                     "writeList failed for file '$_path'");
       }
       return this;
     });
   }
 
   external static _writeList(int id, List<int> buffer, int offset, int bytes);
 
   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 for file '$_name'");
+          "Invalid arguments to writeList for file '$_path'");
     }
     if (bytes == 0) return 0;
     _checkReadWriteListArguments(buffer.length, offset, bytes);
     _BufferAndOffset bufferAndOffset =
         _ensureFastAndSerializableBuffer(buffer, offset, bytes);
     var result =
       _writeList(_id, bufferAndOffset.buffer, bufferAndOffset.offset, bytes);
     if (result is OSError) {
-      throw new FileIOException("writeList failed for file '$_name'", result);
+      throw new FileIOException("writeList failed for file '$_path'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        [Encoding encoding = Encoding.UTF_8]) {
     if (encoding is! Encoding) {
       var completer = new Completer();
       Timer.run(() {
         completer.completeError(new FileIOException(
@@ skipping 17 matching lines @@
   Future<int> position() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "position failed for file '$_path'");
       }
       return response;
     });
   }
 
   external static _position(int id);
 
   int positionSync() {
     _checkNotClosed();
     var result = _position(_id);
     if (result is OSError) {
-      throw new FileIOException("position failed for file '$_name'", result);
+      throw new FileIOException("position failed for file '$_path'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "setPosition failed for file '$_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 FileIOException("setPosition failed for file '$_name'", result);
+      throw new FileIOException("setPosition failed for file '$_path'", result);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "truncate failed for file '$_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 FileIOException("truncate failed for file '$_name'", result);
+      throw new FileIOException("truncate failed for file '$_path'", result);
     }
   }
 
   Future<int> length() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "length failed for file '$_path'");
       }
       return response;
     });
   }
 
   external static _length(int id);
 
   int lengthSync() {
     _checkNotClosed();
     var result = _length(_id);
     if (result is OSError) {
-      throw new FileIOException("length failed for file '$_name'", result);
+      throw new FileIOException("length failed for file '$_path'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> flush() {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     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 '$_name'");
+                                     "flush failed for file '$_path'");
       }
       return this;
     });
   }
 
   external static _flush(int id);
 
   void flushSync() {
     _checkNotClosed();
     var result = _flush(_id);
     if (result is OSError) {
-      throw new FileIOException("flush failed for file '$_name'", result);
+      throw new FileIOException("flush failed for file '$_path'", result);
     }
   }
 
-  String get name => _name;
+  String get path => _path;
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils._newServicePort();
     }
   }
 
   bool get closed => _id == 0;
 
   void _checkNotClosed() {
     if (closed) {
-      throw new FileIOException("File closed '$_name'");
+      throw new FileIOException("File closed '$_path'");
     }
   }
 
   Future _completeWithClosedException(Completer completer) {
     Timer.run(() {
       completer.completeError(
-          new FileIOException("File closed '$_name'"));
+          new FileIOException("File closed '$_path'"));
     });
     return completer.future;
   }
 
-  final String _name;
+  final String _path;
   int _id;
 
   SendPort _fileService;
 }