Mark all private functions in dart: libraries as invisible (*sniff*).

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 214 matching lines @@
 
   // Constructor for file.
   _File(this.path) {
     if (path is! String) {
       throw new ArgumentError('${Error.safeToString(path)} '
                               'is not a String');
     }
   }
 
   Future<bool> exists() {
-    return _IOService.dispatch(_FILE_EXISTS, [path]).then((response) {
+    return _IOService._dispatch(_FILE_EXISTS, [path]).then((response) {
       if (_isErrorResponse(response)) {
         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);
     return result;
   }
 
   File get absolute => new File(_absolutePath);
 
   Future<FileStat> stat() => FileStat.stat(path);
 
   FileStat statSync() => FileStat.statSync(path);
 
   Future<File> create({bool recursive: false}) {
     var result = recursive ? parent.create(recursive: true)
                            : new Future.value(null);
     return result
-      .then((_) => _IOService.dispatch(_FILE_CREATE, [path]))
+      .then((_) => _IOService._dispatch(_FILE_CREATE, [path]))
       .then((response) {
         if (_isErrorResponse(response)) {
           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({bool recursive: false}) {
     if (recursive) {
       parent.createSync(recursive: true);
     }
     var result = _create(path);
     throwIfError(result, "Cannot create file", path);
   }
 
   Future<File> _delete({bool recursive: false}) {
     if (recursive) {
       return new Directory(path).delete(recursive: true).then((_) => this);
     }
-    return _IOService.dispatch(_FILE_DELETE, [path]).then((response) {
+    return _IOService._dispatch(_FILE_DELETE, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot delete file", path);
       }
       return this;
     });
   }
 
   external static _deleteNative(String path);
 
   external static _deleteLinkNative(String path);
 
   void _deleteSync({bool recursive: false}) {
     if (recursive) {
       return new Directory(path).deleteSync(recursive: true);
     }
     var result = _deleteNative(path);
     throwIfError(result, "Cannot delete file", path);
   }
 
   Future<File> rename(String newPath) {
-    return _IOService.dispatch(_FILE_RENAME, [path, newPath]).then((response) {
+    return _IOService._dispatch(_FILE_RENAME, [path, newPath]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             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 to '$newPath'", path);
     return new File(newPath);
   }
 
   Future<File> copy(String newPath) {
-    return _IOService.dispatch(_FILE_COPY, [path, newPath]).then((response) {
+    return _IOService._dispatch(_FILE_COPY, [path, newPath]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot copy file to '$newPath'", path);
       }
       return new File(newPath);
     });
   }
 
   external static _copy(String oldPath, String newPath);
 
   File copySync(String newPath) {
     var result = _copy(path, newPath);
     throwIfError(result, "Cannot copy file to '$newPath'", path);
     return new File(newPath);
   }
 
   Future<RandomAccessFile> open({FileMode mode: FileMode.READ}) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       return new Future.error(new ArgumentError());
     }
-    return _IOService.dispatch(_FILE_OPEN, [path, mode._mode]).then((response) {
+    return _IOService._dispatch(_FILE_OPEN, [path, mode._mode]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot open file", path);
       }
       return new _RandomAccessFile(response, path);
     });
   }
 
   Future<int> length() {
-    return _IOService.dispatch(_FILE_LENGTH_FROM_PATH, [path]).then((response) {
+    return _IOService._dispatch(_FILE_LENGTH_FROM_PATH, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "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);
     return result;
   }
 
   Future<DateTime> lastModified() {
-    return _IOService.dispatch(_FILE_LAST_MODIFIED, [path]).then((response) {
+    return _IOService._dispatch(_FILE_LAST_MODIFIED, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve modification time",
                                      path);
       }
       return new DateTime.fromMillisecondsSinceEpoch(response);
     });
   }
 
   external static _lastModified(String path);
@@ skipping 636 matching lines @@
     if (_asyncDispatched) {
       var msg = "An async operation is currently pending";
       return new Future.error(new FileSystemException(msg, path));
     }
     if (markClosed) {
       // Set the id_ to 0 (NULL) to ensure the no more async requests
       // can be issued for this file.
       _id = 0;
     }
     _asyncDispatched = true;
-    return _IOService.dispatch(request, data)
+    return _IOService._dispatch(request, data)
         .whenComplete(() {
           _asyncDispatched = false;
         });
   }
 
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }