Change IllegalArgumentException to ArgumentError.

lib/compiler/implementation/lib/interceptors.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.
 
 #library('dart:_interceptors');
 
 #import('coreimpl.dart');
 #import('js_helper.dart');
 
 add$1(var receiver, var value) {
   if (isJsArray(receiver)) {
     checkGrowable(receiver, 'add');
     JS('Object', r'#.push(#)', receiver, value);
     return;
   }
   return UNINTERCEPTED(receiver.add(value));
 }
 
 removeAt$1(var receiver, var index) {
   if (isJsArray(receiver)) {
-    if (index is !int) throw new IllegalArgumentException(index);
+    if (index is !int) throw new ArgumentError(index);
     if (index < 0 || index >= receiver.length) {
       throw new IndexOutOfRangeException(index);
     }
     checkGrowable(receiver, 'removeAt');
     return JS("Object", r'#.splice(#, 1)[0]', receiver, index);
   }
   return UNINTERCEPTED(receiver.removeAt(index));
 }
 
 removeLast(var receiver) {
@@ skipping 17 matching lines @@
   if (receiver is String || isJsArray(receiver)) {
     return JS('num', r'#.length', receiver);
   } else {
     return UNINTERCEPTED(receiver.length);
   }
 }
 
 set$length(receiver, newLength) {
   if (isJsArray(receiver)) {
     checkNull(newLength); // TODO(ahe): This is not specified but co19 tests it.
-    if (newLength is !int) throw new IllegalArgumentException(newLength);
+    if (newLength is !int) throw new ArgumentError(newLength);
     if (newLength < 0) throw new IndexOutOfRangeException(newLength);
     checkGrowable(receiver, 'set length');
     JS('void', r'#.length = #', receiver, newLength);
   } else {
     UNINTERCEPTED(receiver.length = newLength);
   }
   return newLength;
 }
 
 toString(var value) {
@@ skipping 16 matching lines @@
 
 iterator(receiver) {
   if (isJsArray(receiver)) {
     return new ListIterator(receiver);
   }
   return UNINTERCEPTED(receiver.iterator());
 }
 
 charCodeAt(var receiver, int index) {
   if (receiver is String) {
-    if (index is !num) throw new IllegalArgumentException(index);
+    if (index is !num) throw new ArgumentError(index);
     if (index < 0) throw new IndexOutOfRangeException(index);
     if (index >= receiver.length) throw new IndexOutOfRangeException(index);
     return JS('int', r'#.charCodeAt(#)', receiver, index);
   } else {
     return UNINTERCEPTED(receiver.charCodeAt(index));
   }
 }
 
 isEmpty(receiver) {
   if (receiver is String || isJsArray(receiver)) {
@@ skipping 19 matching lines @@
       return 0;
     } else if (a.isNaN()) {
       if (b.isNaN()) {
         return 0;
       }
       return 1;
     } else {
       return -1;
     }
   } else if (a is String) {
-    if (b is !String) throw new IllegalArgumentException(b);
+    if (b is !String) throw new ArgumentError(b);
     return JS('bool', r'# == #', a, b) ? 0
       : JS('bool', r'# < #', a, b) ? -1 : 1;
   } else {
     return UNINTERCEPTED(a.compareTo(b));
   }
 }
 
 addAll(receiver, collection) {
   if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.addAll(collection));
 
@@ skipping 40 matching lines @@
   }
 }
 
 getRange(receiver, start, length) {
   if (!isJsArray(receiver)) {
     return UNINTERCEPTED(receiver.getRange(start, length));
   }
   if (0 === length) return [];
   checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
   checkNull(length); // TODO(ahe): This is not specified but co19 tests it.
-  if (start is !int) throw new IllegalArgumentException(start);
-  if (length is !int) throw new IllegalArgumentException(length);
-  if (length < 0) throw new IllegalArgumentException(length);
+  if (start is !int) throw new ArgumentError(start);
+  if (length is !int) throw new ArgumentError(length);
+  if (length < 0) throw new ArgumentError(length);
   if (start < 0) throw new IndexOutOfRangeException(start);
   var end = start + length;
   if (end > receiver.length) {
     throw new IndexOutOfRangeException(length);
   }
-  if (length < 0) throw new IllegalArgumentException(length);
+  if (length < 0) throw new ArgumentError(length);
   return JS('Object', r'#.slice(#, #)', receiver, start, end);
 }
 
 indexOf$1(receiver, element) {
   if (isJsArray(receiver)) {
     var length = JS('num', r'#.length', receiver);
     return Arrays.indexOf(receiver, element, 0, length);
   } else if (receiver is String) {
     checkNull(element);
-    if (element is !String) throw new IllegalArgumentException(element);
+    if (element is !String) throw new ArgumentError(element);
     return JS('int', r'#.indexOf(#)', receiver, element);
   }
   return UNINTERCEPTED(receiver.indexOf(element));
 }
 
 indexOf$2(receiver, element, start) {
   if (isJsArray(receiver)) {
-    if (start is !int) throw new IllegalArgumentException(start);
+    if (start is !int) throw new ArgumentError(start);
     var length = JS('num', r'#.length', receiver);
     return Arrays.indexOf(receiver, element, start, length);
   } else if (receiver is String) {
     checkNull(element);
-    if (start is !int) throw new IllegalArgumentException(start);
-    if (element is !String) throw new IllegalArgumentException(element);
+    if (start is !int) throw new ArgumentError(start);
+    if (element is !String) throw new ArgumentError(element);
     if (start < 0) return -1; // TODO(ahe): Is this correct?
     return JS('int', r'#.indexOf(#, #)', receiver, element, start);
   }
   return UNINTERCEPTED(receiver.indexOf(element, start));
 }
 
 insertRange$2(receiver, start, length) {
   if (isJsArray(receiver)) {
     return insertRange$3(receiver, start, length, null);
   }
@@ skipping 13 matching lines @@
   }
   return receiver[receiver.length - 1];
 }
 
 lastIndexOf$1(receiver, element) {
   if (isJsArray(receiver)) {
     var start = JS('num', r'#.length', receiver);
     return Arrays.lastIndexOf(receiver, element, start);
   } else if (receiver is String) {
     checkNull(element);
-    if (element is !String) throw new IllegalArgumentException(element);
+    if (element is !String) throw new ArgumentError(element);
     return JS('int', r'#.lastIndexOf(#)', receiver, element);
   }
   return UNINTERCEPTED(receiver.lastIndexOf(element));
 }
 
 lastIndexOf$2(receiver, element, start) {
   if (isJsArray(receiver)) {
     return Arrays.lastIndexOf(receiver, element, start);
   } else if (receiver is String) {
     checkNull(element);
-    if (element is !String) throw new IllegalArgumentException(element);
+    if (element is !String) throw new ArgumentError(element);
     if (start !== null) {
-      if (start is !num) throw new IllegalArgumentException(start);
+      if (start is !num) throw new ArgumentError(start);
       if (start < 0) return -1;
       if (start >= receiver.length) {
         if (element == "") return receiver.length;
         start = receiver.length - 1;
       }
     }
     return stringLastIndexOfUnchecked(receiver, element, start);
   }
   return UNINTERCEPTED(receiver.lastIndexOf(element, start));
 }
 
 removeRange(receiver, start, length) {
   if (!isJsArray(receiver)) {
     return UNINTERCEPTED(receiver.removeRange(start, length));
   }
   checkGrowable(receiver, 'removeRange');
   if (length == 0) {
     return;
   }
   checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
   checkNull(length); // TODO(ahe): This is not specified but co19 tests it.
-  if (start is !int) throw new IllegalArgumentException(start);
-  if (length is !int) throw new IllegalArgumentException(length);
-  if (length < 0) throw new IllegalArgumentException(length);
+  if (start is !int) throw new ArgumentError(start);
+  if (length is !int) throw new ArgumentError(length);
+  if (length < 0) throw new ArgumentError(length);
   var receiverLength = JS('num', r'#.length', receiver);
   if (start < 0 || start >= receiverLength) {
     throw new IndexOutOfRangeException(start);
   }
   if (start + length > receiverLength) {
     throw new IndexOutOfRangeException(start + length);
   }
   Arrays.copy(receiver,
               start + length,
               receiver,
@@ skipping 13 matching lines @@
   if (!isJsArray(receiver)) {
     return UNINTERCEPTED(receiver.setRange(start, length, from, startFrom));
   }
 
   checkMutable(receiver, 'indexed set');
   if (length === 0) return;
   checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
   checkNull(length); // TODO(ahe): This is not specified but co19 tests it.
   checkNull(from); // TODO(ahe): This is not specified but co19 tests it.
   checkNull(startFrom); // TODO(ahe): This is not specified but co19 tests it.
-  if (start is !int) throw new IllegalArgumentException(start);
-  if (length is !int) throw new IllegalArgumentException(length);
-  if (startFrom is !int) throw new IllegalArgumentException(startFrom);
-  if (length < 0) throw new IllegalArgumentException(length);
+  if (start is !int) throw new ArgumentError(start);
+  if (length is !int) throw new ArgumentError(length);
+  if (startFrom is !int) throw new ArgumentError(startFrom);
+  if (length < 0) throw new ArgumentError(length);
   if (start < 0) throw new IndexOutOfRangeException(start);
   if (start + length > receiver.length) {
     throw new IndexOutOfRangeException(start + length);
   }
 
   Arrays.copy(from, startFrom, receiver, start, length);
 }
 
 some(receiver, f) {
   if (!isJsArray(receiver)) {
@@ skipping 136 matching lines @@
                      receiver, fractionDigits);
   if (receiver == 0 && receiver.isNegative()) return "-$result";
   return result;
 }
 
 toRadixString(receiver, radix) {
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toRadixString(radix));
   }
   checkNum(radix);
-  if (radix < 2 || radix > 36) throw new IllegalArgumentException(radix);
+  if (radix < 2 || radix > 36) throw new ArgumentError(radix);
   return JS('String', r'#.toString(#)', receiver, radix);
 }
 
 allMatches(receiver, str) {
   if (receiver is !String) return UNINTERCEPTED(receiver.allMatches(str));
   checkString(str);
   return allMatchesInStringUnchecked(receiver, str);
 }
 
 concat(receiver, other) {
   if (receiver is !String) return UNINTERCEPTED(receiver.concat(other));
 
-  if (other is !String) throw new IllegalArgumentException(other);
+  if (other is !String) throw new ArgumentError(other);
   return JS('String', r'# + #', receiver, other);
 }
 
 contains$1(receiver, other) {
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.contains(other));
   }
   return contains$2(receiver, other, 0);
 }
 
@@ skipping 141 matching lines @@
   } else if (receiver is String) {
     return getOrCreateCachedRuntimeType('String');
   } else if (receiver is double) {
     return getOrCreateCachedRuntimeType('double');
   } else if (receiver is List) {
     return getOrCreateCachedRuntimeType('List');
   } else {
     return UNINTERCEPTED(receiver.runtimeType());
   }
 }