Change IllegalArgumentException to ArgumentError.

lib/utf/utf8.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.
 
 const int _UTF8_ONE_BYTE_MAX = 0x7f;
 const int _UTF8_TWO_BYTE_MAX = 0x7ff;
 const int _UTF8_THREE_BYTE_MAX = 0xffff;
 
 const int _UTF8_LO_SIX_BIT_MASK = 0x3f;
 
 const int _UTF8_FIRST_BYTE_OF_TWO_BASE = 0xc0;
 const int _UTF8_FIRST_BYTE_OF_THREE_BASE = 0xe0;
 const int _UTF8_FIRST_BYTE_OF_FOUR_BASE = 0xf0;
 const int _UTF8_FIRST_BYTE_OF_FIVE_BASE = 0xf8;
 const int _UTF8_FIRST_BYTE_OF_SIX_BASE = 0xfc;
 
 const int _UTF8_FIRST_BYTE_OF_TWO_MASK = 0x1f;
 const int _UTF8_FIRST_BYTE_OF_THREE_MASK = 0xf;
 const int _UTF8_FIRST_BYTE_OF_FOUR_MASK = 0x7;
 
 const int _UTF8_FIRST_BYTE_BOUND_EXCL = 0xfe;
 const int _UTF8_SUBSEQUENT_BYTE_BASE = 0x80;
 
 /**
  * Decodes the UTF-8 bytes as an iterable. Thus, the consumer can only convert
  * as much of the input as needed. Set the replacementCharacter to null to
- * throw an IllegalArgumentException rather than replace the bad value.
+ * throw an ArgumentError rather than replace the bad value.
  */
 IterableUtf8Decoder decodeUtf8AsIterable(List<int> bytes, [int offset = 0,
     int length,
     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
   return new IterableUtf8Decoder(bytes, offset, length, replacementCodepoint);
 }
 
 /**
  * Produce a String from a List of UTF-8 encoded bytes. The parameters
  * can set an offset into a list of bytes (as int), limit the length of the
  * values to be decoded, and override the default Unicode replacement character.
- * Set the replacementCharacter to null to throw an IllegalArgumentException
+ * Set the replacementCharacter to null to throw an ArgumentError
  * rather than replace the bad value.
  */
 String decodeUtf8(List<int> bytes, [int offset = 0, int length,
     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
   return codepointsToString(
       (new Utf8Decoder(bytes, offset, length, replacementCodepoint))
       .decodeRest());
 }
 
 /**
@@ skipping 89 matching lines @@
 
   Utf8Decoder iterator() => new Utf8Decoder(bytes, offset, length,
           replacementCodepoint);
 }
 
 /**
  * Provides an iterator of Unicode codepoints from UTF-8 encoded bytes. The
  * parameters can set an offset into a list of bytes (as int), limit the length
  * of the values to be decoded, and override the default Unicode replacement
  * character. Set the replacementCharacter to null to throw an
- * IllegalArgumentException rather than replace the bad value. The return value
+ * ArgumentError rather than replace the bad value. The return value
  * from this method can be used as an Iterable (e.g. in a for-loop).
  */
 class Utf8Decoder implements Iterator<int> {
   final _ListRangeIterator utf8EncodedBytesIterator;
   final int replacementCodepoint;
 
   Utf8Decoder(List<int> utf8EncodedBytes, [int offset = 0, int length,
       int this.replacementCodepoint =
       UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
       utf8EncodedBytesIterator = (new _ListRange(utf8EncodedBytes, offset,
@@ skipping 26 matching lines @@
   bool hasNext() => utf8EncodedBytesIterator.hasNext();
 
   int next() {
     int value = utf8EncodedBytesIterator.next();
     int additionalBytes = 0;
 
     if (value < 0) {
       if (replacementCodepoint != null) {
         return replacementCodepoint;
       } else {
-        throw new IllegalArgumentException(
+        throw new ArgumentError(
             "Invalid UTF8 at ${utf8EncodedBytesIterator.position}");
       }
     } else if (value <= _UTF8_ONE_BYTE_MAX) {
       return value;
     } else if (value < _UTF8_FIRST_BYTE_OF_TWO_BASE) {
       if (replacementCodepoint != null) {
         return replacementCodepoint;
       } else {
-        throw new IllegalArgumentException(
+        throw new ArgumentError(
             "Invalid UTF8 at ${utf8EncodedBytesIterator.position}");
       }
     } else if (value < _UTF8_FIRST_BYTE_OF_THREE_BASE) {
       value -= _UTF8_FIRST_BYTE_OF_TWO_BASE;
       additionalBytes = 1;
     } else if (value < _UTF8_FIRST_BYTE_OF_FOUR_BASE) {
       value -= _UTF8_FIRST_BYTE_OF_THREE_BASE;
       additionalBytes = 2;
     } else if (value < _UTF8_FIRST_BYTE_OF_FIVE_BASE) {
       value -= _UTF8_FIRST_BYTE_OF_FOUR_BASE;
       additionalBytes = 3;
     } else if (value < _UTF8_FIRST_BYTE_OF_SIX_BASE) {
       value -= _UTF8_FIRST_BYTE_OF_FIVE_BASE;
       additionalBytes = 4;
     } else if (value < _UTF8_FIRST_BYTE_BOUND_EXCL) {
       value -= _UTF8_FIRST_BYTE_OF_SIX_BASE;
       additionalBytes = 5;
     } else if (replacementCodepoint != null) {
       return replacementCodepoint;
     } else {
-      throw new IllegalArgumentException(
+      throw new ArgumentError(
           "Invalid UTF8 at ${utf8EncodedBytesIterator.position}");
     }
     int j = 0;
     while (j < additionalBytes && utf8EncodedBytesIterator.hasNext()) {
       int nextValue = utf8EncodedBytesIterator.next();
       if (nextValue > _UTF8_ONE_BYTE_MAX &&
           nextValue < _UTF8_FIRST_BYTE_OF_TWO_BASE) {
         value = ((value << 6) | (nextValue & _UTF8_LO_SIX_BIT_MASK));
       } else {
         // if sequence-starting code unit, reposition cursor to start here
@@ skipping 10 matching lines @@
     bool nonOverlong =
         (additionalBytes == 1 && value > _UTF8_ONE_BYTE_MAX) ||
         (additionalBytes == 2 && value > _UTF8_TWO_BYTE_MAX) ||
         (additionalBytes == 3 && value > _UTF8_THREE_BYTE_MAX);
     bool inRange = value <= UNICODE_VALID_RANGE_MAX;
     if (validSequence && nonOverlong && inRange) {
       return value;
     } else if (replacementCodepoint != null) {
       return replacementCodepoint;
     } else {
-      throw new IllegalArgumentException(
+      throw new ArgumentError(
           "Invalid UTF8 at ${utf8EncodedBytesIterator.position - j}");
     }
   }
 }