Change IllegalArgumentException to ArgumentError.

runtime/bin/process_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.
 
 _exit(int status) native "Exit";
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
 class _Process extends NativeFieldWrapperClass1 implements Process {
   static Future<ProcessResult> run(String path,
                                    List<String> arguments,
                                    [ProcessOptions options]) {
     return new _NonInteractiveProcess._start(path, arguments, options)._result;
   }
 
   _Process.start(String path,
                  List<String> arguments,
                  ProcessOptions options) {
     if (path is !String) {
-      throw new IllegalArgumentException("Path is not a String: $path");
+      throw new ArgumentError("Path is not a String: $path");
     }
     _path = path;
 
     if (arguments is !List) {
-      throw new IllegalArgumentException("Arguments is not a List: $arguments");
+      throw new ArgumentError("Arguments is not a List: $arguments");
     }
     int len = arguments.length;
     _arguments = new ObjectArray<String>(len);
     for (int i = 0; i < len; i++) {
       var arg = arguments[i];
       if (arg is !String) {
-        throw new IllegalArgumentException("Non-string argument: $arg");
+        throw new ArgumentError("Non-string argument: $arg");
       }
       _arguments[i] = arguments[i];
       if (Platform.operatingSystem == 'windows') {
         _arguments[i] = _windowsArgumentEscape(_arguments[i]);
       }
     }
 
     if (options !== null && options.workingDirectory !== null) {
       _workingDirectory = options.workingDirectory;
       if (_workingDirectory is !String) {
-        throw new IllegalArgumentException(
+        throw new ArgumentError(
             "WorkingDirectory is not a String: $_workingDirectory");
       }
     }
 
     if (options !== null && options.environment !== null) {
       var env = options.environment;
       if (env is !Map) {
-        throw new IllegalArgumentException("Environment is not a map: $env");
+        throw new ArgumentError("Environment is not a map: $env");
       }
       _environment = [];
       env.forEach((key, value) {
         if (key is !String || value is !String) {
-          throw new IllegalArgumentException(
+          throw new ArgumentError(
               "Environment key or value is not a string: ($key, $value)");
         }
         _environment.add('$key=$value');
       });
     }
 
     _in = new _Socket._internalReadOnly();  // stdout coming from process.
     _out = new _Socket._internalWriteOnly();  // stdin going to process.
     _err = new _Socket._internalReadOnly();  // stderr coming from process.
     _exitHandler = new _Socket._internalReadOnly();
@@ skipping 146 matching lines @@
 
   OutputStream get stdin {
     if (_closed) {
       throw new ProcessException("Process closed");
     }
     return _out.outputStream;
   }
 
   void kill([ProcessSignal signal = ProcessSignal.SIGTERM]) {
     if (signal is! ProcessSignal) {
-      throw new IllegalArgumentException(
+      throw new ArgumentError(
           "Argument 'signal' must be a ProcessSignal");
     }
     if (!_started) {
       var e = new ProcessException("Cannot kill process that is not started");
       _reportError(e);
       return;
     }
     if (_ended) {
       return;
     }
@@ skipping 70 matching lines @@
                                 List<String> arguments,
                                 ProcessOptions options) {
     _completer = new Completer<ProcessResult>();
     // Extract output encoding options and verify arguments.
     var stdoutEncoding = Encoding.UTF_8;
     var stderrEncoding = Encoding.UTF_8;
     if (options !== null) {
       if (options.stdoutEncoding !== null) {
         stdoutEncoding = options.stdoutEncoding;
         if (stdoutEncoding is !Encoding) {
-          throw new IllegalArgumentException(
+          throw new ArgumentError(
               'stdoutEncoding option is not an encoding: $stdoutEncoding');
         }
       }
       if (options.stderrEncoding !== null) {
         stderrEncoding = options.stderrEncoding;
         if (stderrEncoding is !Encoding) {
-          throw new IllegalArgumentException(
+          throw new ArgumentError(
               'stderrEncoding option is not an encoding: $stderrEncoding');
         }
       }
     }
 
     // Start the underlying process.
     _process = new _Process.start(path, arguments, options);
 
     // Make sure stdin is closed.
     _process.onStart = _process.stdin.close;
@@ skipping 54 matching lines @@
 
 class _ProcessResult implements ProcessResult {
   const _ProcessResult(int this.exitCode,
                        String this.stdout,
                        String this.stderr);
 
   final int exitCode;
   final String stdout;
   final String stderr;
 }