Handling of wrong types of arguments in the File API.

runtime/bin/file_impl.dart

 // Copyright (c) 2011, 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 implements FileInputStream {
   _FileInputStream(File file) {
     _file = new File(file.name);
     _file.openSync();
   }
 
@@ skipping 124 matching lines @@
   }
 
   String _name;
 }
 
 
 class _OpenOperation extends _FileOperation {
   _OpenOperation(String this._name, bool this._writable);
 
   void execute(ReceivePort port) {
-    _replyPort.send(_File._open(_name, _writable), port.toSendPort());
+    _replyPort.send(_File._checkedOpen(_name, _writable), port.toSendPort());
   }
 
   String _name;
   bool _writable;
 }
 
 
 class _CloseOperation extends _FileOperation {
   _CloseOperation(int this._id);
 
@@ skipping 95 matching lines @@
   List _buffer;
   int _offset;
   int _bytes;
 }
 
 
 class _WriteStringOperation extends _FileOperation {
   _WriteStringOperation(int this._id, String this._string);
 
   void execute(ReceivePort port) {
-    _replyPort.send(_File._writeString(_id, _string), port.toSendPort());
+    _replyPort.send(_File._checkedWriteString(_id, _string), port.toSendPort());
   }
 
   bool isWrite() => true;
 
   int _id;
   String _string;
 }
 
 
 class _PositionOperation extends _FileOperation {
@@ skipping 26 matching lines @@
   }
 
   int _id;
 }
 
 
 class _FullPathOperation extends _FileOperation {
   _FullPathOperation(String this._name);
 
   void execute(ReceivePort port) {
-    _replyPort.send(_File._fullPath(_name), port.toSendPort());
+    _replyPort.send(_File._checkedFullPath(_name), port.toSendPort());
   }
 
   String _name;
 }
 
 
 class _CreateOperation extends _FileOperation {
   _CreateOperation(String this._name);
 
   void execute(ReceivePort port) {
-    _replyPort.send(_File._create(_name), port.toSendPort());
+    _replyPort.send(_File._checkedCreate(_name), port.toSendPort());
   }
 
   String _name;
 }
 
 
 class _ExitOperation extends _FileOperation {
   void execute(ReceivePort port) {
     port.close();
   }
@@ skipping 60 matching lines @@
   Queue<_FileOperation> _queue;
   _FileOperationIsolate _isolate;
 }
 
 
 // Class for encapsulating the native implementation of files.
 class _File implements File {
   // Constructor for file.
   _File(String this._name)
     : _scheduler = new _FileOperationScheduler(),
-      _asyncUsed = false;
+      _asyncUsed = false,
+      _id = 0;
 
   static bool _exists(String name) native "File_Exists";
   static int _open(String name, bool writable) native "File_Open";
   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)
       native "File_WriteList";
   static int _writeString(int id, String string) native "File_WriteString";
   static int _position(int id) native "File_Position";
   static int _length(int id) native "File_Length";
   static int _flush(int id) native "File_Flush";
   static bool _create(String name) native "File_Create";
   static String _fullPath(String name) native "File_FullPath";
 
   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 _checkedOpen(String name, bool writable) {
+    if (name is !String || writable is !bool) return 0;
+    return _open(name, writable);
+  }
+
+  static bool _checkedCreate(String name) {
+    if (name is !String) return false;
+    return _create(name);
+  }
+
+  static int _checkedWriteString(int id, String string) {
+    if (string is !String) return -1;
+    return _writeString(id, string);
+  }
+
+  static String _checkedFullPath(String name) {
+    if (name is !String) return null;
+    return _fullPath(name);
+  }
+
   void exists() {
     _asyncUsed = true;
+    if (_name is !String) {
+      if (_errorHandler != null) {
+        _errorHandler('File name is not a string: $_name');
+      }
+      return;
+    }
     var handler =
         (_existsHandler != null) ? _existsHandler : (result) => null;
     var operation = new _ExistsOperation(_name);
     _scheduler.enqueue(operation, (result, ignored) { _existsHandler(result); });
   }
 
   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 _exists(_name);
   }
 
   void create() {
     _asyncUsed = true;
     var handler = (_createHandler != null) ? _createHandler : () => null;
     var handleCreateResult = (created, ignored) {
       if (created) {
         handler();
       } else if (_errorHandler != null) {
         _errorHandler("Cannot create file: $_name");
       }
     };
     var operation = new _CreateOperation(_name);
     _scheduler.enqueue(operation, handleCreateResult);
   }
 
   void createSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    bool created = _create(_name);
+    bool created = _checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file: $_name");
     }
   }
 
   void open([bool writable = false]) {
     _asyncUsed = true;
     var handler = (_openHandler != null) ? _openHandler : () => null;
     var handleOpenResult = (result, ignored) {
       if (result != 0) {
         _id = result;
         handler();
       } else if (_errorHandler != null) {
         _errorHandler("Cannot open file: $_name");
       }
     };
     var operation = new _OpenOperation(_name, writable);
     _scheduler.enqueue(operation, handleOpenResult);
   }
 
   void openSync([bool writable = false]) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    _id = _open(_name, writable);
+    _id = _checkedOpen(_name, writable);
     if (_id == 0) {
       throw new FileIOException("Cannot open file: $_name");
     }
   }
 
   void close() {
     _asyncUsed = true;
     var handler = (_closeHandler != null) ? _closeHandler : () => null;
     var handleOpenResult = (result, ignored) {
       if (result != -1) {
         _id = result;
         handler();
       } else if (_errorHandler != null) {
-        _errorHandler("Cannot open file: $_name");
+        _errorHandler("Cannot close file: $_name");
       }
     };
     var operation = new _CloseOperation(_id);
     _scheduler.enqueue(operation, handleOpenResult);
   }
 
   void closeSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    _id = _close(_id);
-    if (_id == -1) {
+    var id = _close(_id);
+    if (id == -1) {
       throw new FileIOException("Cannot close file: $_name");
     }
+    _id = id;
   }
 
   void readByte() {
     _asyncUsed = true;
     var handler =
         (_readByteHandler != null) ? _readByteHandler : (byte) => null;
     var handleReadByteResult = (result, ignored) {
       if (result != -1) {
         handler(result);
       } else if (_errorHandler != null) {
@@ skipping 11 matching lines @@
     }
     int result = _readByte(_id);
     if (result == -1) {
       throw new FileIOException("readByte failed");
     }
     return result;
   }
 
   void readList(List<int> buffer, int offset, int bytes) {
     _asyncUsed = true;
+    if (buffer is !List || offset is !int || bytes is !int) {
+      if (_errorHandler != null) {
+        _errorHandler("Invalid arguments to readList");
+      }
+      return;
+    };
     var handler =
         (_readListHandler != null) ? _readListHandler : (result) => null;
     var handleReadListResult = (result, ignored) {
       if (result is _ReadListResult && result.read != -1) {
         var read = result.read;
         buffer.setRange(offset, read, result.buffer);
         handler(read);
         return;
       }
       if (_errorHandler != null) {
         _errorHandler(result is String ? result : "readList failed");
       }
     };
     var operation = new _ReadListOperation(_id, buffer.length, offset, bytes);
     _scheduler.enqueue(operation, handleReadListResult);
   }
 
   int readListSync(List<int> buffer, int offset, int bytes) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
+    if (buffer is !List || offset is !int || bytes is !int) {
+      throw new FileIOException("Invalid arguments to readList");
+    }
     if (bytes == 0) return 0;
     int index = _checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     int result = _readList(_id, buffer, offset, bytes);
     if (result == -1) {
       throw new FileIOException("readList failed");
     }
     return result;
   }
 
   void _checkPendingWrites() {
     if (_scheduler.noPendingWrite() && _noPendingWriteHandler != null) {
       _noPendingWriteHandler();
     }
   }
 
   void writeByte(int value) {
     _asyncUsed = true;
+    if (value is !int) {
+      if (_errorHandler != null) {
+        _errorHandler("Invalid argument to writeByte");
+      }
+      return;
+    }
     var handleReadByteResult = (result, ignored) {
       if (result == -1 &&_errorHandler != null) {
         _errorHandler("writeByte failed");
         return;
       }
       _checkPendingWrites();
     };
     var operation = new _WriteByteOperation(_id, value);
     _scheduler.enqueue(operation, handleReadByteResult);
   }
 
   int writeByteSync(int value) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
+    if (value is !int) {
+      throw new FileIOException("Invalid argument to writeByte");
+    }
     int result = _writeByte(_id, value);
     if (result == -1) {
       throw new FileIOException("writeByte failed");
     }
     return result;
   }
 
   void writeList(List<int> buffer, int offset, int bytes) {
     _asyncUsed = true;
+    if (buffer is !List || offset is !int || bytes is !int) {
+      if (_errorHandler != null) {
+        _errorHandler("Invalid arguments to writeList");
+      }
+      return;
+    }
     var handleWriteListResult = (result, ignored) {
       if (result is !String && result != -1) {
         if (result < bytes) {
           writeList(buffer, offset + result, bytes - result);
         } else {
           _checkPendingWrites();
         }
         return;
       }
       if (_errorHandler != null) {
         _errorHandler(result is String ? result : "writeList failed");
       }
     };
     var operation = new _WriteListOperation(_id, buffer, offset, bytes);
     _scheduler.enqueue(operation, handleWriteListResult);
   }
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
+    if (buffer is !List || offset is !int || bytes is !int) {
+      throw new FileIOException("Invalid arguments to writeList");
+    }
     if (bytes == 0) return 0;
     int index = _checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     int result = _writeList(_id, buffer, offset, bytes);
     if (result == -1) {
       throw new FileIOException("writeList failed");
     }
     return result;
@@ skipping 14 matching lines @@
     };
     var operation = new _WriteStringOperation(_id, string);
     _scheduler.enqueue(operation, handleWriteStringResult);
   }
 
   int writeStringSync(String string) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    int result = _writeString(_id, string);
+    int result = _checkedWriteString(_id, string);
     if (result == -1) {
-      throw new FileIOException("Error: writeString failed");
+      throw new FileIOException("writeString failed");
     }
     return result;
   }
 
   void position() {
     _asyncUsed = true;
     var handler = (_positionHandler != null) ? _positionHandler : (pos) => null;
     var handlePositionResult = (result, ignored) {
       if (result == -1 && _errorHandler != null) {
         _errorHandler("position failed");
@@ skipping 69 matching lines @@
   }
 
   void fullPath() {
     _asyncUsed = true;
     var handler = _fullPathHandler;
     if (handler == null) handler = (path) => null;
     var handleFullPathResult = (result, ignored) {
       if (result != null) {
         handler(result);
       } else if (_errorHandler != null) {
-        _errorHandler("canonicalPath failed");
+        _errorHandler("fullPath failed");
       }
     };
     var operation = new _FullPathOperation(_name);
     _scheduler.enqueue(operation, handleFullPathResult);
   }
 
   String fullPathSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
-    String result = _fullPath(_name);
+    String result = _checkedFullPath(_name);
     if (result == null) {
       throw new FileIOException("fullPath failed");
     }
     return result;
   }
 
   InputStream openInputStream() {
     return new _FileInputStream(this);
   }
 
@@ skipping 65 matching lines @@
   var _closeHandler;
   var _readByteHandler;
   var _readListHandler;
   var _noPendingWriteHandler;
   var _positionHandler;
   var _lengthHandler;
   var _flushHandler;
   var _fullPathHandler;
   var _errorHandler;
 }