Change IllegalArgumentException to ArgumentError.

runtime/bin/directory_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 _Directory implements Directory {
   static const CREATE_REQUEST = 0;
   static const DELETE_REQUEST = 1;
   static const EXISTS_REQUEST = 2;
   static const CREATE_TEMP_REQUEST = 3;
@@ skipping 24 matching lines @@
     return _directoryService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Exists failed");
       }
       return response == 1;
     });
   }
 
   bool existsSync() {
     if (_path is !String) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     var result = _exists(_path);
     if (result is OSError) {
       throw new DirectoryIOException("Exists failed", _path, result);
     }
     return (result == 1);
   }
 
   Future<Directory> create() {
     _ensureDirectoryService();
     List request = new List(2);
     request[0] = CREATE_REQUEST;
     request[1] = _path;
     return _directoryService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Creation failed");
       }
       return this;
     });
   }
 
   void createSync() {
     if (_path is !String) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     var result = _create(_path);
     if (result is OSError) {
       throw new DirectoryIOException("Creation failed", _path, result);
     }
   }
 
   Future<Directory> createTemp() {
     _ensureDirectoryService();
     List request = new List(2);
     request[0] = CREATE_TEMP_REQUEST;
     request[1] = _path;
     return _directoryService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Creation of temporary directory failed");
       }
       return new Directory(response);
     });
   }
 
   Directory createTempSync() {
     if (_path is !String) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     var result = _createTemp(path);
     if (result is OSError) {
       throw new DirectoryIOException("Creation of temporary directory failed",
                                      _path,
                                      result);
     }
     return new Directory(result);
   }
 
@@ skipping 11 matching lines @@
     });
     return completer.future;
   }
 
   Future<Directory> delete() {
     return _deleteHelper(false, "Deletion failed");
   }
 
   void deleteSync() {
     if (_path is !String) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     var result = _delete(_path, false);
     if (result is OSError) {
       throw new DirectoryIOException("Deletion failed", _path, result);
     }
   }
 
   Future<Directory> deleteRecursively() {
     return _deleteHelper(true, "Deletion failed");
   }
 
   void deleteRecursivelySync() {
     if (_path is !String) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     var result = _delete(_path, true);
     if (result is OSError) {
       throw new DirectoryIOException("Deletion failed", _path, result);
     }
   }
 
   Future<Directory> rename(String newPath) {
     _ensureDirectoryService();
     List request = new List(3);
     request[0] = RENAME_REQUEST;
     request[1] = _path;
     request[2] = newPath;
     return _directoryService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Rename failed");
       }
       return new Directory(newPath);
     });
   }
 
   Directory renameSync(String newPath) {
     if (_path is !String || newPath is !String) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     var result = _rename(_path, newPath);
     if (result is OSError) {
       throw new DirectoryIOException("Rename failed", _path, result);
     }
     return new Directory(newPath);
   }
 
   DirectoryLister list([bool recursive = false]) {
     return new _DirectoryLister(_path, recursive);
   }
 
   String get path { return _path; }
 
   bool _isErrorResponse(response) {
     return response is List && response[0] != _FileUtils.SUCCESS_RESPONSE;
   }
 
   Exception _exceptionFromResponse(response, String message) {
     assert(_isErrorResponse(response));
     switch (response[_FileUtils.ERROR_RESPONSE_ERROR_TYPE]) {
       case _FileUtils.ILLEGAL_ARGUMENT_RESPONSE:
-        return new IllegalArgumentException();
+        return new ArgumentError();
       case _FileUtils.OSERROR_RESPONSE:
         var err = new OSError(response[_FileUtils.OSERROR_RESPONSE_MESSAGE],
                               response[_FileUtils.OSERROR_RESPONSE_ERROR_CODE]);
         return new DirectoryIOException(message, _path, err);
       default:
         return new Exception("Unknown error");
     }
   }
 
   void _ensureDirectoryService() {
@@ skipping 36 matching lines @@
         case LIST_DIRECTORY:
           if (_onDir != null) _onDir(message[RESPONSE_PATH]);
           break;
         case LIST_FILE:
           if (_onFile != null) _onFile(message[RESPONSE_PATH]);
           break;
         case LIST_ERROR:
           var errorType =
               message[RESPONSE_ERROR][_FileUtils.ERROR_RESPONSE_ERROR_TYPE];
           if (errorType == _FileUtils.ILLEGAL_ARGUMENT_RESPONSE) {
-            _reportError(new IllegalArgumentException());
+            _reportError(new ArgumentError());
           } else if (errorType == _FileUtils.OSERROR_RESPONSE) {
             var responseError = message[RESPONSE_ERROR];
             var err = new OSError(
                 responseError[_FileUtils.OSERROR_RESPONSE_MESSAGE],
                 responseError[_FileUtils.OSERROR_RESPONSE_ERROR_CODE]);
             var errorPath = message[RESPONSE_PATH];
             if (errorPath == null) errorPath = path;
             _reportError(new DirectoryIOException("Directory listing failed",
                                                   errorPath,
                                                   err));
@@ skipping 31 matching lines @@
     } else {
       throw e;
     }
   }
 
   Function _onDir;
   Function _onFile;
   Function _onDone;
   Function _onError;
 }