Error reporting on File in dart:io

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 = (String s) {
+    _file.onError = (e) {
       if (_clientErrorHandler != null) {
         _clientErrorHandler();
       }
     };
     _file.open(FileMode.READ, (openedFile) {
       _readDataFromFile(openedFile);
     });
   }
 
   _FileInputStream.fromStdio(int fd) {
     assert(fd == 0);
     _file = _File._openStdioSync(fd);
     _data = [];
     _position = 0;
     _readDataFromFile(_file);
   }
 
   void _readDataFromFile(RandomAccessFile openedFile) {
-    openedFile.onError = (String s) {
+    openedFile.onError = (e) {
       if (_clientErrorHandler != null) {
         _clientErrorHandler();
       }
     };
     openedFile.length((length) {
       var contents = new ByteArray(length);
       if (length != 0) {
         openedFile.readList(contents, 0, length, (read) {
           if (read != length) {
             if (_clientErrorHandler != null) {
@@ skipping 177 matching lines @@
   static final kSetPositionRequest = 8;
   static final kTruncateRequest = 9;
   static final kLengthRequest = 10;
   static final kFlushRequest = 11;
   static final kReadByteRequest = 12;
   static final kWriteByteRequest = 13;
   static final kReadListRequest = 14;
   static final kWriteListRequest = 15;
   static final kWriteStringRequest = 16;
 
+  static final kSuccessResponse = 0;
+  static final kIllegalArgumentResponse = 1;
+  static final kOSErrorResponse = 2;
+
   static List ensureFastAndSerializableBuffer(
       List buffer, int offset, int bytes) {
     // When using the Dart C API to access raw data, using a ByteArray is
     // currently much faster. This function will make a copy of the
     // supplied List to a ByteArray if it isn't already.
     List outBuffer;
     int outOffset = offset;
     if (buffer is ByteArray || buffer is ObjectArray) {
       outBuffer = buffer;
     } else {
       outBuffer = new ByteArray(bytes);
       outOffset = 0;
       int j = offset;
       for (int i = 0; i < bytes; i++) {
         int value = buffer[j];
         if (value is! int) {
           throw new FileIOException(
               "List element is not an integer at index $j");
         }
         outBuffer[i] = value;
         j++;
       }
     }
     return [outBuffer, outOffset];
   }
 
-  static bool exists(String name) native "File_Exists";
-  static int open(String name, int mode) native "File_Open";
-  static bool create(String name) native "File_Create";
-  static bool delete(String name) native "File_Delete";
-  static String fullPath(String name) native "File_FullPath";
-  static String directory(String name) native "File_Directory";
+  static exists(String name) native "File_Exists";
+  static open(String name, int mode) native "File_Open";
+  static create(String name) native "File_Create";
+  static delete(String name) native "File_Delete";
+  static fullPath(String name) native "File_FullPath";
+  static directory(String name) native "File_Directory";
   static int close(int id) native "File_Close";
   static int readByte(int id) native "File_ReadByte";
   static int readList(int id, List<int> buffer, int offset, int bytes)
       native "File_ReadList";
   static int writeByte(int id, int value) native "File_WriteByte";
   static int writeList(int id, List<int> buffer, int offset, int bytes) {
     List result =
         _FileUtils.ensureFastAndSerializableBuffer(buffer, offset, bytes);
     List outBuffer = result[0];
     int outOffset = result[1];
     return writeListNative(id, outBuffer, outOffset, bytes);
   }
   static int writeListNative(int id, List<int> buffer, int offset, int bytes)
       native "File_WriteList";
   static int writeString(int id, String string) native "File_WriteString";
   static int position(int id) native "File_Position";
   static bool setPosition(int id, int position) native "File_SetPosition";
   static bool truncate(int id, int length) native "File_Truncate";
   static int length(int id) native "File_Length";
   static int 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);
+    }
+    return result;
+  }
+
   static int checkedOpen(String name, int mode) {
-    if (name is !String || mode is !int) return 0;
-    return open(name, 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", result);
+    }
+    return result;
   }
 
   static bool checkedCreate(String name) {
-    if (name is !String) return false;
-    return create(name);
+    if (name is !String) {
+      throw new IllegalArgumentException();
+    };
+    var result = create(name);
+    if (result is OSError) {
+      throw new FileIOException("Cannot create file", result);
+    }
+    return true;
   }
 
   static bool checkedDelete(String name) {
-    if (name is !String) return false;
-    return delete(name);
+    if (name is !String) {
+      throw new IllegalArgumentException();
+    };
+    var result = delete(name);
+    if (result is OSError) {
+      throw new FileIOException("Cannot delete file", result);
+    }
+    return true;
   }
 
   static String checkedFullPath(String name) {
-    if (name is !String) return null;
-    return fullPath(name);
+    if (name is !String) {
+      throw new IllegalArgumentException();
+    };
+    var result = fullPath(name);
+    if (result is OSError) {
+      throw new FileIOException("Cannot retrieve full path", 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);
+    }
+    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;
   }
 
   static int checkedWriteString(int id, String string) {
     if (string is !String) return -1;
     return writeString(id, string);
   }
+
 }
 
 
 // Class for encapsulating the native implementation of files.
 class _File implements File {
   // Constructor for file.
   _File(String this._name) : _asyncUsed = false;
 
   void exists(void callback(bool exists)) {
     _ensureFileService();
     _asyncUsed = true;
-    if (_name is !String) {
-      if (_onError != null) {
-        _onError('File name is not a string: $_name');
-      }
-      return;
-    }
     List request = new List(2);
     request[0] = _FileUtils.kExistsRequest;
     request[1] = _name;
-    _fileService.call(request).then((exists) {
-      callback(exists);
+    _fileService.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        _reportError(response, "Cannot open file");
+      } else {
+        callback(response);
+      }
     });
   }
 
   bool existsSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    if (_name is !String) {
-      throw new FileIOException('File name is not a string: $_name');
-    }
-    return _FileUtils.exists(_name);
+    return _FileUtils.checkedExists(_name);
   }
 
   void create(void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kCreateRequest;
     request[1] = _name;
-    _fileService.call(request).then((created) {
-      if (created) {
+    _fileService.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        _reportError(response, "Cannot create file");
+      } else {
         callback();
-      } else if (_onError != null) {
-        _onError("Cannot create file: $_name");
       }
     });
   }
 
   void createSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file: $_name");
     }
   }
 
   void delete(void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDeleteRequest;
     request[1] = _name;
-    _fileService.call(request).then((deleted) {
-      if (deleted) {
+    _fileService.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        _reportError(response, "Cannot delete file");
+      } else {
         callback();
-      } else if (_onError != null) {
-        _onError("Cannot delete file: $_name");
       }
     });
   }
 
   void deleteSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    bool deleted = _FileUtils.checkedDelete(_name);
-    if (!deleted) {
-      throw new FileIOException("Cannot delete file: $_name");
-    }
+    _FileUtils.checkedDelete(_name);
   }
 
   void directory(void callback(Directory dir)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDirectoryRequest;
     request[1] = _name;
-    _fileService.call(request).then((path) {
-      if (path != null) {
-        callback(new Directory(path));
-      } else if (_onError != null) {
-        _onError("Cannot get directory for: ${_name}");
+    _fileService.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        _reportError(response, "Cannot retrieve directory for file");
+      } else {
+        callback(new Directory(response));
       }
     });
   }
 
   Directory directorySync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    if (!existsSync()) {
-      throw new FileIOException("Cannot get directory for: $_name");
-    }
+    _FileUtils.checkedDirectory(_name);
     return new Directory(_FileUtils.directory(_name));
   }
 
   void open(FileMode mode, void callback(RandomAccessFile file)) {
     _ensureFileService();
     _asyncUsed = true;
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       if (_onError != null) {
-        _onError("Unknown file mode. Use FileMode.READ, FileMode.WRITE " +
-                 "or FileMode.APPEND.");
+        _onError(new IllegalArgumentException());
         return;
       }
     }
     List request = new List(3);
     request[0] = _FileUtils.kOpenRequest;
     request[1] = _name;
     request[2] = mode._mode;  // Direct int value for serialization.
-    _fileService.call(request).then((id) {
-      if (id != 0) {
-        callback(new _RandomAccessFile(id, _name));
-      } else if (_onError != null) {
-        _onError("Cannot open file: $_name");
+    _fileService.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        _reportError(response, "Cannot open file");
+      } else {
+        callback(new _RandomAccessFile(response, _name));
       }
     });
   }
 
   RandomAccessFile openSync([FileMode mode = FileMode.READ]) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     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 = _FileUtils.checkedOpen(_name, mode._mode);
-    if (id == 0) {
-      throw new FileIOException("Cannot open file: $_name");
-    }
+    assert(id != 0);
     return new _RandomAccessFile(id, _name);
   }
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _FileUtils.openStdio(fd);
     if (id == 0) {
       throw new FileIOException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
   void fullPath(void callback(String result)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFullPathRequest;
     request[1] = _name;
-    _fileService.call(request).then((result) {
-      if (result != null) {
-        callback(result);
-      } else if (_onError != null) {
-        _onError("fullPath failed");
+    _fileService.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        _reportError(response, "Cannot retrieve full path");
+      } else {
+        callback(response);
       }
     });
   }
 
   String fullPathSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    String result = _FileUtils.checkedFullPath(_name);
-    if (result == null) {
-      throw new FileIOException("fullPath failed");
-    }
-    return result;
+    return _FileUtils.checkedFullPath(_name);
   }
 
   InputStream openInputStream() {
     return new _FileInputStream(_name);
   }
 
   OutputStream openOutputStream([FileMode mode = FileMode.WRITE]) {
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     return new _FileOutputStream(_name, mode);
   }
 
   void readAsBytes(void callback(List<int> bytes)) {
     _asyncUsed = true;
     var chunks = new _BufferList();
     var stream = openInputStream();
     stream.onClosed = () {
       callback(chunks.readBytes(chunks.length));
     };
     stream.onData = () {
       var chunk = stream.read();
       chunks.add(chunk);
     };
     stream.onError = () {
       if (_onError != null) {
-        _onError("Failed to read file as bytes: $_name");
+        _onError("Failed to read file");
       }
     };
   }
 
   List<int> readAsBytesSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var opened = openSync();
     var length = opened.lengthSync();
     var result = new ByteArray(length);
     var read = opened.readListSync(result, 0, length);
     if (read != length) {
-      throw new FileIOException("Failed reading file as bytes: $_name");
+      throw new FileIOException("Failed to read file");
     }
     opened.closeSync();
     return result;
   }
 
   void readAsText(Encoding encoding, void callback(String text)) {
     _asyncUsed = true;
     var decoder = _StringDecoders.decoder(encoding);
     readAsBytes((bytes) {
       try {
@@ skipping 67 matching lines @@
   void set onError(void handler(String error)) {
     _onError = handler;
   }
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils.newServicePort();
     }
   }
 
+  bool _isErrorResponse(response) {
+    return response is List && response[0] != _FileUtils.kSuccessResponse;
+  }
+
+  bool _reportError(response, String message) {
+    assert(_isErrorResponse(response));
+    if (_onError != null) {
+      switch (response[0]) {
+        case _FileUtils.kIllegalArgumentResponse:
+          _onError(new IllegalArgumentException());
+          break;
+        case _FileUtils.kOSErrorResponse:
+          _onError(new FileIOException(message,
+                                       new OSError(response[2], response[1])));
+          break;
+        default:
+          _onError(new Exception("Unknown error"));
+      }
+    }
+  }
+
   String _name;
   bool _asyncUsed;
 
   SendPort _fileService;
 
   Function _onError;
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
@@ skipping 399 matching lines @@
   bool _asyncUsed;
   int _pendingWrites = 0;
 
   SendPort _fileService;
 
   Timer _noPendingWriteTimer;
 
   Function _onNoPendingWrites;
   Function _onError;
 }