Change IllegalArgumentException to ArgumentError.

pkg/args/lib/args.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.
 
 /**
  * This library lets you define parsers for parsing raw command-line arguments
  * into a set of options and values using [GNU][] and [POSIX][] style options.
  *
  * ## Defining options ##
  *
@@ skipping 202 matching lines @@
 
   /** Index of the current argument being parsed in [_args]. */
   int _current;
 
   /** Creates a new ArgParser. */
   ArgParser()
     : _options = <String, _Option>{},
       _optionNames = <String>[];
 
   /**
-   * Defines a flag. Throws an [IllegalArgumentException] if:
+   * Defines a flag. Throws an [ArgumentError] if:
    *
    * * There is already an option named [name].
    * * There is already an option using abbreviation [abbr].
    */
   void addFlag(String name, [String abbr, String help, bool defaultsTo = false,
       bool negatable = true, void callback(bool value)]) {
     _addOption(name, abbr, help, null, null, defaultsTo, callback,
         isFlag: true, negatable: negatable);
   }
 
   /**
-   * Defines a value-taking option. Throws an [IllegalArgumentException] if:
+   * Defines a value-taking option. Throws an [ArgumentError] if:
    *
    * * There is already an option with name [name].
    * * There is already an option using abbreviation [abbr].
    */
   void addOption(String name, [String abbr, String help, List<String> allowed,
       Map<String, String> allowedHelp, String defaultsTo,
       void callback(value), bool allowMultiple = false]) {
     _addOption(name, abbr, help, allowed, allowedHelp, defaultsTo,
         callback, isFlag: false, allowMultiple: allowMultiple);
   }
 
   void _addOption(String name, String abbr, String help, List<String> allowed,
       Map<String, String> allowedHelp, defaultsTo,
       void callback(value), [bool isFlag, bool negatable = false,
       bool allowMultiple = false]) {
     // Make sure the name isn't in use.
     if (_options.containsKey(name)) {
-      throw new IllegalArgumentException('Duplicate option "$name".');
+      throw new ArgumentError('Duplicate option "$name".');
     }
 
     // Make sure the abbreviation isn't too long or in use.
     if (abbr != null) {
       if (abbr.length > 1) {
-        throw new IllegalArgumentException(
+        throw new ArgumentError(
             'Abbreviation "$abbr" is longer than one character.');
       }
 
       var existing = _findByAbbr(abbr);
       if (existing != null) {
-        throw new IllegalArgumentException(
+        throw new ArgumentError(
             'Abbreviation "$abbr" is already used by "${existing.name}".');
       }
     }
 
     _options[name] = new _Option(name, abbr, help, allowed, allowedHelp,
         defaultsTo, callback, isFlag: isFlag, negatable: negatable,
         allowMultiple: allowMultiple);
     _optionNames.add(name);
   }
 
@@ skipping 221 matching lines @@
 
     return null;
   }
 
   /**
    * Get the default value for an option. Useful after parsing to test
    * if the user specified something other than the default.
    */
   getDefault(String option) {
     if (!_options.containsKey(option)) {
-      throw new IllegalArgumentException('No option named $option');
+      throw new ArgumentError('No option named $option');
     }
     return _options[option].defaultValue;
   }
 }
 
 /**
  * The results of parsing a series of command line arguments using
  * [ArgParser.parse()]. Includes the parsed options and any remaining unparsed
  * command line arguments.
  */
 class ArgResults {
   final Map _options;
 
   /**
    * The remaining command-line arguments that were not parsed as options or
    * flags. If `--` was used to separate the options from the remaining
    * arguments, it will not be included in this list.
    */
   final List<String> rest;
 
   /** Creates a new [ArgResults]. */
   ArgResults(this._options, this.rest);
 
   /** Gets the parsed command-line option named [name]. */
   operator [](String name) {
     if (!_options.containsKey(name)) {
-      throw new IllegalArgumentException(
+      throw new ArgumentError(
           'Could not find an option named "$name".');
     }
 
     return _options[name];
   }
 
   /** Get the names of the options as a [Collection]. */
   Collection<String> get options => _options.getKeys();
 }
 
@@ skipping 226 matching lines @@
       allowedBuffer.add(allowed);
       if (allowed == option.defaultValue) {
         allowedBuffer.add(' (default)');
       }
       first = false;
     }
     allowedBuffer.add(']');
     return allowedBuffer.toString();
   }
 }