Change IllegalArgumentException to ArgumentError.

lib/compiler/implementation/lib/js_helper.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:_js_helper');
 
 #import('coreimpl.dart');
 
 #source('constant_map.dart');
 #source('native_helper.dart');
@@ skipping 79 matching lines @@
       return;
     }
   }
   indexSet$slow(a, index, value);
 }
 
 /**
  * Returns true if both arguments are numbers.
  *
  * If only the first argument is a number, an
- * [IllegalArgumentException] with the other argument is thrown.
+ * [ArgumentError] with the other argument is thrown.
  */
 bool checkNumbers(var a, var b) {
   if (a is num) {
     if (b is num) {
       return true;
     } else {
       checkNull(b);
-      throw new IllegalArgumentException(b);
+      throw new ArgumentError(b);
     }
   }
   return false;
 }
 
 bool isJsArray(var value) {
   return value !== null && JS('bool', r'#.constructor === Array', value);
 }
 
 add$slow(var a, var b) {
@@ skipping 98 matching lines @@
 le$slow(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('bool', r'# <= #', a, b);
   }
   return UNINTERCEPTED(a <= b);
 }
 
 shl(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
-    if (JS('num', '#', b) < 0) throw new IllegalArgumentException(b);
+    if (JS('num', '#', b) < 0) throw new ArgumentError(b);
     // JavaScript only looks at the last 5 bits of the shift-amount. Shifting
     // by 33 is hence equivalent to a shift by 1.
     if (JS('bool', r'# > 31', b)) return 0;
     return JS('num', r'(# << #) >>> 0', a, b);
   }
   return UNINTERCEPTED(a << b);
 }
 
 shr(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
-    if (JS('num', '#', b) < 0) throw new IllegalArgumentException(b);
+    if (JS('num', '#', b) < 0) throw new ArgumentError(b);
     if (JS('num', '#', a) > 0) {
       // JavaScript only looks at the last 5 bits of the shift-amount. In JS
       // shifting by 33 is hence equivalent to a shift by 1. Shortcut the
       // computation when that happens.
       if (JS('bool', r'# > 31', b)) return 0;
       // Given that 'a' is positive we must not use '>>'. Otherwise a number
       // that has the 31st bit set would be treated as negative and shift in
       // ones.
       return JS('num', r'# >>> #', a, b);
     }
@@ skipping 38 matching lines @@
 }
 
 neg(var a) {
   if (JS('bool', r'typeof # === "number"', a)) return JS('num', r'-#', a);
   return UNINTERCEPTED(-a);
 }
 
 index$slow(var a, var index) {
   if (a is String || isJsArray(a)) {
     if (index is !int) {
-      if (index is !num) throw new IllegalArgumentException(index);
-      if (index.truncate() !== index) throw new IllegalArgumentException(index);
+      if (index is !num) throw new ArgumentError(index);
+      if (index.truncate() !== index) throw new ArgumentError(index);
     }
     if (index < 0 || index >= a.length) {
       throw new IndexOutOfRangeException(index);
     }
     return JS('Object', r'#[#]', a, index);
   }
   return UNINTERCEPTED(a[index]);
 }
 
 void indexSet$slow(var a, var index, var value) {
   if (isJsArray(a)) {
     if (index is !int) {
-      throw new IllegalArgumentException(index);
+      throw new ArgumentError(index);
     }
     if (index < 0 || index >= a.length) {
       throw new IndexOutOfRangeException(index);
     }
     checkMutable(a, 'indexed set');
     JS('Object', r'#[#] = #', a, index, value);
     return;
   }
   UNINTERCEPTED(a[index] = value);
 }
 
 checkMutable(list, reason) {
   if (JS('bool', r'!!(#.immutable$list)', list)) {
     throw new UnsupportedOperationException(reason);
   }
 }
 
 checkGrowable(list, reason) {
   if (JS('bool', r'!!(#.fixed$length)', list)) {
     throw new UnsupportedOperationException(reason);
   }
 }
 
 String S(value) {
   var res = value.toString();
-  if (res is !String) throw new IllegalArgumentException(value);
+  if (res is !String) throw new ArgumentError(value);
   return res;
 }
 
 class ListIterator<T> implements Iterator<T> {
   int i;
   List<T> list;
   ListIterator(List<T> this.list) : i = 0;
   bool hasNext() => i < JS('int', r'#.length', list);
   T next() {
     if (!hasNext()) throw new NoMoreElementsException();
@@ skipping 96 matching lines @@
   }
 
   static String objectToString(Object object) {
     String name = objectTypeName(object);
     return "Instance of '$name'";
   }
 
   static List newList(length) {
     if (length === null) return JS('Object', r'new Array()');
     if ((length is !int) || (length < 0)) {
-      throw new IllegalArgumentException(length);
+      throw new ArgumentError(length);
     }
     var result = JS('Object', r'new Array(#)', length);
     JS('void', r'#.fixed$length = #', result, true);
     return result;
   }
 
   static num dateNow() => JS('num', r'Date.now()');
 
   static String stringFromCharCodes(charCodes) {
     for (var i in charCodes) {
-      if (i is !int) throw new IllegalArgumentException(i);
+      if (i is !int) throw new ArgumentError(i);
     }
     return JS('String', r'String.fromCharCode.apply(#, #)', null, charCodes);
   }
 
   static String getTimeZoneName(receiver) {
     // When calling toString on a Date it will emit the timezone in parenthesis.
     // Example: "Wed May 16 2012 21:13:00 GMT+0200 (CEST)".
     // We extract this name using a regexp.
     var d = lazyAsJsDate(receiver);
     return JS('String', r'/\((.*)\)/.exec(#.toString())[1]', d);
@@ skipping 20 matching lines @@
     if (isUtc) {
       value = JS('num', r'Date.UTC(#, #, #, #, #, #, #)',
                  years, jsMonth, day, hours, minutes, seconds, milliseconds);
     } else {
       value = JS('num', r'new Date(#, #, #, #, #, #, #).valueOf()',
                  years, jsMonth, day, hours, minutes, seconds, milliseconds);
     }
     if (value.isNaN() ||
         value < -MAX_MILLISECONDS_SINCE_EPOCH ||
         value > MAX_MILLISECONDS_SINCE_EPOCH) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     if (years <= 0 || years < 100) return patchUpY2K(value, years, isUtc);
     return value;
   }
 
   static patchUpY2K(value, years, isUtc) {
     var date = JS('Object', r'new Date(#)', value);
     if (isUtc) {
       JS('num', r'#.setUTCFullYear(#)', date, years);
     } else {
@@ skipping 56 matching lines @@
   static getWeekday(receiver) {
     int weekday = (receiver.isUtc)
       ? JS('int', r'#.getUTCDay()', lazyAsJsDate(receiver))
       : JS('int', r'#.getDay()', lazyAsJsDate(receiver));
     // Adjust by one because JS weeks start on Sunday.
     return (weekday + 6) % 7 + 1;
   }
 
   static valueFromDateString(str) {
     checkNull(str);
-    if (str is !String) throw new IllegalArgumentException(str);
+    if (str is !String) throw new ArgumentError(str);
     var value = JS('num', r'Date.parse(#)', str);
-    if (value.isNaN()) throw new IllegalArgumentException(str);
+    if (value.isNaN()) throw new ArgumentError(str);
     return value;
   }
 
   static getProperty(object, key) {
     checkNull(object);
     if (object is bool || object is num || object is String) {
-      throw new IllegalArgumentException(object);
+      throw new ArgumentError(object);
     }
     return JS('var', '#[#]', object, key);
   }
 
   static void setProperty(object, key, value) {
     checkNull(object);
     if (object is bool || object is num || object is String) {
-      throw new IllegalArgumentException(object);
+      throw new ArgumentError(object);
     }
     JS('void', '#[#] = #', object, key, value);
   }
 }
 
 /**
  * Called by generated code to throw an illegal-argument exception,
  * for example, if a non-integer index is given to an optimized
  * indexed access.
  */
 iae(argument) {
-  throw new IllegalArgumentException(argument);
+  throw new ArgumentError(argument);
 }
 
 /**
  * Called by generated code to throw an index-out-of-range exception,
  * for example, if a bounds check fails in an optimized indexed
  * access.
  */
 ioore(index) {
   throw new IndexOutOfRangeException(index);
 }
 
 listInsertRange(receiver, start, length, initialValue) {
   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 (length is !int) throw new IllegalArgumentException(length);
-  if (length < 0) throw new IllegalArgumentException(length);
-  if (start is !int) throw new IllegalArgumentException(start);
+  if (length is !int) throw new ArgumentError(length);
+  if (length < 0) throw new ArgumentError(length);
+  if (start is !int) throw new ArgumentError(start);
 
   var receiverLength = JS('num', r'#.length', receiver);
   if (start < 0 || start > receiverLength) {
     throw new IndexOutOfRangeException(start);
   }
   receiver.length = receiverLength + length;
   Arrays.copy(receiver,
               start,
               receiver,
               start + length,
@@ skipping 11 matching lines @@
 
 
 checkNull(object) {
   if (object === null) throw new NullPointerException();
   return object;
 }
 
 checkNum(value) {
   if (value is !num) {
     checkNull(value);
-    throw new IllegalArgumentException(value);
+    throw new ArgumentError(value);
   }
   return value;
 }
 
 checkInt(value) {
   if (value is !int) {
     checkNull(value);
-    throw new IllegalArgumentException(value);
+    throw new ArgumentError(value);
   }
   return value;
 }
 
 checkBool(value) {
   if (value is !bool) {
     checkNull(value);
-    throw new IllegalArgumentException(value);
+    throw new ArgumentError(value);
   }
   return value;
 }
 
 checkString(value) {
   if (value is !String) {
     checkNull(value);
-    throw new IllegalArgumentException(value);
+    throw new ArgumentError(value);
   }
   return value;
 }
 
 substringUnchecked(receiver, startIndex, endIndex)
   => JS('String', r'#.substring(#, #)', receiver, startIndex, endIndex);
 
 class MathNatives {
   static int parseInt(str) {
     checkString(str);
@@ skipping 172 matching lines @@
   }
 
   if (JS('bool', r'# instanceof RangeError', ex)) {
     if (message is String && message.contains('call stack')) {
       return new StackOverflowException();
     }
 
     // In general, a RangeError is thrown when trying to pass a number
     // as an argument to a function that does not allow a range that
     // includes that number.
-    return new IllegalArgumentException();
+    return new ArgumentError();
   }
 
   // Check for the Firefox specific stack overflow signal.
   if (JS('bool',
          r"typeof InternalError == 'function' && # instanceof InternalError",
          ex)) {
     if (message is String && message == 'too much recursion') {
       return new StackOverflowException();
     }
   }
@@ skipping 460 matching lines @@
     JS('void', r'#.runtimeTypeCache[#] = #', JS_CURRENT_ISOLATE(), key,
        runtimeType);
   }
   return runtimeType;
 }
 
 String getRuntimeTypeString(var object) {
   var typeInfo = JS('Object', r'#.builtin$typeInfo', object);
   return JS('String', r'#.runtimeType', typeInfo);
 }