Change IllegalArgumentException to ArgumentError.

lib/utf/utf_core.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.
 
 /**
  * Provide a list of Unicode codepoints for a given string.
  */
 List<int> stringToCodepoints(String str) {
   List<int> codepoints;
   // TODO _is16BitCodeUnit() is used to work around a bug with dart2js
@@ skipping 88 matching lines @@
     } else if (value > UNICODE_PLANE_ONE_MAX &&
         value <= UNICODE_VALID_RANGE_MAX) {
       int base = value - UNICODE_UTF16_OFFSET;
       codeUnitsBuffer[j++] = UNICODE_UTF16_SURROGATE_UNIT_0_BASE +
           ((base & UNICODE_UTF16_HI_MASK) >> 10);
       codeUnitsBuffer[j++] = UNICODE_UTF16_SURROGATE_UNIT_1_BASE +
           (base & UNICODE_UTF16_LO_MASK);
     } else if (replacementCodepoint != null) {
       codeUnitsBuffer[j++] = replacementCodepoint;
     } else {
-      throw new IllegalArgumentException("Invalid encoding");
+      throw new ArgumentError("Invalid encoding");
     }
   }
   return codeUnitsBuffer;
 }
 
 /**
  * Decodes the utf16 codeunits to codepoints.
  */
 List<int> _utf16CodeUnitsToCodepoints(
     List<int> utf16CodeUnits, [int offset = 0, int length,
@@ skipping 12 matching lines @@
   } else {
     List<int> codepointTrunc = new List<int>(i);
     codepointTrunc.setRange(0, i, codepoints);
     return codepointTrunc;
   }
 }
 
 /**
  * An Iterator<int> of codepoints built on an Iterator of UTF-16 code units.
  * The parameters can override the default Unicode replacement character. Set
- * the replacementCharacter to null to throw an IllegalArgumentException
+ * the replacementCharacter to null to throw an ArgumentError
  * rather than replace the bad value.
  */
 class Utf16CodeUnitDecoder implements Iterator<int> {
   final _ListRangeIterator utf16CodeUnitIterator;
   final int replacementCodepoint;
 
   Utf16CodeUnitDecoder(List<int> utf16CodeUnits, [int offset = 0, int length,
       int this.replacementCodepoint =
       UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
       utf16CodeUnitIterator = (new _ListRange(utf16CodeUnits, offset, length))
           .iterator();
 
   Utf16CodeUnitDecoder.fromListRangeIterator(
       _ListRangeIterator this.utf16CodeUnitIterator,
       int this.replacementCodepoint);
 
   Iterator<int> iterator() => this;
 
   bool hasNext() => utf16CodeUnitIterator.hasNext();
 
   int next() {
     int value = utf16CodeUnitIterator.next();
     if (value < 0) {
       if (replacementCodepoint != null) {
         return replacementCodepoint;
       } else {
-        throw new IllegalArgumentException(
+        throw new ArgumentError(
             "Invalid UTF16 at ${utf16CodeUnitIterator.position}");
       }
     } else if (value < UNICODE_UTF16_RESERVED_LO ||
         (value > UNICODE_UTF16_RESERVED_HI && value <= UNICODE_PLANE_ONE_MAX)) {
       // transfer directly
       return value;
     } else if (value < UNICODE_UTF16_SURROGATE_UNIT_1_BASE &&
         utf16CodeUnitIterator.hasNext()) {
       // merge surrogate pair
       int nextValue = utf16CodeUnitIterator.next();
       if (nextValue >= UNICODE_UTF16_SURROGATE_UNIT_1_BASE &&
           nextValue <= UNICODE_UTF16_RESERVED_HI) {
         value = (value - UNICODE_UTF16_SURROGATE_UNIT_0_BASE) << 10;
         value += UNICODE_UTF16_OFFSET +
             (nextValue - UNICODE_UTF16_SURROGATE_UNIT_1_BASE);
         return value;
       } else {
         if (nextValue >= UNICODE_UTF16_SURROGATE_UNIT_0_BASE &&
            nextValue < UNICODE_UTF16_SURROGATE_UNIT_1_BASE) {
           utf16CodeUnitIterator.backup();
         }
         if (replacementCodepoint != null) {
           return replacementCodepoint;
         } else {
-          throw new IllegalArgumentException(
+          throw new ArgumentError(
               "Invalid UTF16 at ${utf16CodeUnitIterator.position}");
         }
       }
     } else if (replacementCodepoint != null) {
       return replacementCodepoint;
     } else {
-      throw new IllegalArgumentException(
+      throw new ArgumentError(
           "Invalid UTF16 at ${utf16CodeUnitIterator.position}");
     }
   }
 }
 
 /**
  * _ListRange in an internal type used to create a lightweight Interable on a
  * range within a source list. DO NOT MODIFY the underlying list while
  * iterating over it. The results of doing so are undefined.
  */
@@ skipping 54 matching lines @@
     _offset -= by;
   }
 
   int get remaining => _end - _offset;
 
   void skip([int count = 1]) {
     _offset += count;
   }
 }