Interceptor maintenance:

dart/frog/leg/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('js_helper');
 
 #import('coreimpl.dart');
 
 #source('constant_map.dart');
 #source('date_helper.dart');
@@ skipping 28 matching lines @@
   if (checkNumbers(a, b)) {
     return JS('num', @'# + #', a, b);
   } else if (a is String) {
     b = b.toString();
     if (b is String) {
       return JS('String', @'# + #', a, b);
     }
     checkNull(b);
     throw new IllegalArgumentException(b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a + b);
 }
 
 div(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('num', @'# / #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a / b);
 }
 
 mul(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('num', @'# * #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a * b);
 }
 
 sub(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('num', @'# - #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a - b);
 }
 
 mod(var a, var b) {
   if (checkNumbers(a, b)) {
     // Euclidean Modulo.
     int result = JS('num', @'# % #', a, b);
     if (result == 0) return 0;  // Make sure we don't return -0.0.
     if (result > 0) return result;
     if (b < 0) {
       return result - b;
     } else {
       return result + b;
     }
   }
-  checkNull(a);
   return UNINTERCEPTED(a % b);
 }
 
 tdiv(var a, var b) {
   if (checkNumbers(a, b)) {
     return (a / b).truncate();
   }
-  checkNull(a);
   return UNINTERCEPTED(a ~/ b);
 }
 
 eq(var a, var b) {
   if (JS('bool', @'typeof # === "object"', a)) {
     if (JS_HAS_EQUALS(a)) {
       return UNINTERCEPTED(a == b) === true;
     } else {
       return JS('bool', @'# === #', a, b);
     }
@@ skipping 15 matching lines @@
     }
   } else {
     return JS('bool', @'typeof # === "undefined"', a);
   }
 }
 
 gt(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('bool', @'# > #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a > b);
 }
 
 ge(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('bool', @'# >= #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a >= b);
 }
 
 lt(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('bool', @'# < #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a < b);
 }
 
 le(var a, var b) {
   if (checkNumbers(a, b)) {
     return JS('bool', @'# <= #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a <= b);
 }
 
 shl(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
     if (b < 0) throw new IllegalArgumentException(b);
     return JS('num', @'# << #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a << b);
 }
 
 shr(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
     if (b < 0) throw new IllegalArgumentException(b);
     return JS('num', @'# >> #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a >> b);
 }
 
 and(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
     return JS('num', @'# & #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a & b);
 }
 
 or(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
     return JS('num', @'# | #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a | b);
 }
 
 xor(var a, var b) {
   // TODO(floitsch): inputs must be integers.
   if (checkNumbers(a, b)) {
     return JS('num', @'# ^ #', a, b);
   }
-  checkNull(a);
   return UNINTERCEPTED(a ^ b);
 }
 
 not(var a) {
   if (JS('bool', @'typeof # === "number"', a)) return JS('num', @'~#', a);
-  checkNull(a);
   return UNINTERCEPTED(~a);
 }
 
 neg(var a) {
   if (JS('bool', @'typeof # === "number"', a)) return JS('num', @'-#', a);
-  checkNull(a);
   return UNINTERCEPTED(-a);
 }
 
 index(var a, var index) {
-  checkNull(a);
   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 < 0 || index >= a.length) {
       throw new IndexOutOfRangeException(index);
     }
     return JS('Object', @'#[#]', a, index);
   }
-  checkNull(a);
   return UNINTERCEPTED(a[index]);
 }
 
 void indexSet(var a, var index, var value) {
-  checkNull(a);
   if (isJsArray(a)) {
     if (!(index is int)) {
       throw new IllegalArgumentException(index);
     }
     if (index < 0 || index >= a.length) {
       throw new IndexOutOfRangeException(index);
     }
     checkMutable(a, 'indexed set');
     JS('Object', @'#[#] = #', a, index, value);
     return;
   }
-  checkNull(a);
   UNINTERCEPTED(a[index] = value);
 }
 
 checkMutable(list, reason) {
   if (JS('bool', @'!!(#.immutable$list)', list)) {
     throw new UnsupportedOperationException(reason);
   }
 }
 
 builtin$add$1(var receiver, var value) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     checkGrowable(receiver, 'add');
     JS('Object', @'#.push(#)', receiver, value);
     return;
   }
   return UNINTERCEPTED(receiver.add(value));
 }
 
 builtin$removeLast$0(var receiver) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     checkGrowable(receiver, 'removeLast');
     if (receiver.length === 0) throw new IndexOutOfRangeException(-1);
     return JS('Object', @'#.pop()', receiver);
   }
   return UNINTERCEPTED(receiver.removeLast());
 }
 
 builtin$filter$1(var receiver, var predicate) {
-  checkNull(receiver);
-  if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.filter(predicate));
-
-  return Collections.filter(receiver, [], predicate);
+  if (!isJsArray(receiver)) {
+    return UNINTERCEPTED(receiver.filter(predicate));
+  } else {
+    return Collections.filter(receiver, [], predicate);
+  }
 }
 
 
 builtin$get$length(var receiver) {
-  checkNull(receiver);
   if (receiver is String || isJsArray(receiver)) {
     return JS('num', @'#.length', receiver);
+  } else {
+    return UNINTERCEPTED(receiver.length);
   }
-  return UNINTERCEPTED(receiver.length);
 }
 
 builtin$set$length(receiver, newLength) {
-  checkNull(receiver);
   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 < 0) throw new IndexOutOfRangeException(newLength);
     checkGrowable(receiver, 'set length');
     JS('void', @'#.length = #', receiver, newLength);
   } else {
     UNINTERCEPTED(receiver.length = newLength);
   }
   return newLength;
@@ skipping 18 matching lines @@
   }
   if (value === null) return 'null';
   if (JS('bool', @'typeof # == "function"', value)) {
     return 'Closure';
   }
   return JS('string', @'String(#)', value);
 }
 
 
 builtin$iterator$0(receiver) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     return new ListIterator(receiver);
   }
   return UNINTERCEPTED(receiver.iterator());
 }
 
 class ListIterator<T> implements Iterator<T> {
   int i;
   List<T> list;
   ListIterator(List<T> this.list) : i = 0;
   bool hasNext() => i < JS('int', @'#.length', list);
   T next() {
     if (!hasNext()) throw new NoMoreElementsException();
     var value = JS('Object', @'#[#]', list, i);
     i += 1;
     return value;
   }
 }
 
 builtin$charCodeAt$1(var receiver, int index) {
-  checkNull(receiver);
   if (receiver is String) {
     if (index is !num) throw new IllegalArgumentException(index);
     if (index < 0) throw new IndexOutOfRangeException(index);
     if (index >= receiver.length) throw new IndexOutOfRangeException(index);
     return JS('int', @'#.charCodeAt(#)', receiver, index);
   } else {
     return UNINTERCEPTED(receiver.charCodeAt(index));
   }
 }
 
 builtin$isEmpty$0(receiver) {
-  checkNull(receiver);
   if (receiver is String || isJsArray(receiver)) {
     return JS('bool', @'#.length === 0', receiver);
   }
   return UNINTERCEPTED(receiver.isEmpty());
 }
 
 class Primitives {
   static void printString(String string) {
     var hasConsole = JS('bool', @'typeof console == "object"');
     if (hasConsole) {
@@ skipping 138 matching lines @@
   static valueFromDateString(str) {
     checkNull(str);
     if (str is !String) throw new IllegalArgumentException(str);
     var value = JS('num', @'Date.parse(#)', str);
     if (value.isNaN()) throw new IllegalArgumentException(str);
     return value;
   }
 }
 
 builtin$compareTo$1(a, b) {
-  checkNull(a);
   if (checkNumbers(a, b)) {
     if (a < b) {
       return -1;
     } else if (a > b) {
       return 1;
     } else if (a == b) {
       if (a == 0) {
         bool aIsNegative = a.isNegative();
         bool bIsNegative = b.isNegative();
         if (aIsNegative == bIsNegative) return 0;
@@ skipping 30 matching lines @@
 /**
  * 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);
 }
 
 builtin$addAll$1(receiver, collection) {
-  checkNull(receiver);
   if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.addAll(collection));
 
   // TODO(ahe): Use for-in when it is implemented correctly.
   var iterator = collection.iterator();
   while (iterator.hasNext()) {
     receiver.add(iterator.next());
   }
 }
 
 builtin$addLast$1(receiver, value) {
-  checkNull(receiver);
   if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.addLast(value));
 
   checkGrowable(receiver, 'addLast');
   JS('Object', @'#.push(#)', receiver, value);
 }
 
 builtin$clear$0(receiver) {
-  checkNull(receiver);
   if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.clear());
   receiver.length = 0;
 }
 
 builtin$forEach$1(receiver, f) {
-  checkNull(receiver);
-  if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.forEach(f));
+  if (!isJsArray(receiver)) {
+    return UNINTERCEPTED(receiver.forEach(f));
+  } else {
+    return Collections.forEach(receiver, f);
+  }
+}
 
-
-  var length = JS('num', @'#.length', receiver);
-  if (length > 0 && f === null) throw new ObjectNotClosureException(); // Sigh.
-  for (var i = 0; i < length; i++) {
-    f(JS('Object', @'#[#]', receiver, i));
+builtin$map$1(receiver, f) {
+  if (!isJsArray(receiver)) {
+    return UNINTERCEPTED(receiver.map(f));
+  } else {
+    return Collections.map(receiver, [], f);
   }
 }
 
 builtin$getRange$2(receiver, start, length) {
-  checkNull(receiver);
   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 (start < 0) throw new IndexOutOfRangeException(start);
   if (length < 0) throw new IllegalArgumentException(length);
   var end = start + length;
   if (end > receiver.length) {
     throw new IndexOutOfRangeException(length);
   }
   if (length < 0) throw new IllegalArgumentException(length);
   return JS('Object', @'#.slice(#, #)', receiver, start, end);
 }
 
 builtin$indexOf$1(receiver, element) {
-  checkNull(receiver);
   if (isJsArray(receiver) || receiver is String) {
     return builtin$indexOf$2(receiver, element, 0);
   }
   return UNINTERCEPTED(receiver.indexOf(element));
 }
 
 builtin$indexOf$2(receiver, element, start) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     if (start is !int) throw new IllegalArgumentException(start);
     var length = JS('num', @'#.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 < 0) return -1; // TODO(ahe): Is this correct?
     return JS('int', @'#.indexOf(#, #)', receiver, element, start);
   }
   return UNINTERCEPTED(receiver.indexOf(element, start));
 }
 
 builtin$insertRange$2(receiver, start, length) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     return builtin$insertRange$3(receiver, start, length, null);
   }
   return UNINTERCEPTED(receiver.insertRange(start, length));
 }
 
 builtin$insertRange$3(receiver, start, length, initialValue) {
-  checkNull(receiver);
   if (!isJsArray(receiver)) {
     return UNINTERCEPTED(receiver.insertRange(start, length, initialValue));
   }
   return listInsertRange(receiver, start, length, initialValue);
 }
 
 listInsertRange(receiver, start, length, initialValue) {
   if (length === 0) {
     return;
   }
@@ skipping 15 matching lines @@
               receiverLength - start);
   if (initialValue !== null) {
     for (int i = start; i < start + length; i++) {
       receiver[i] = initialValue;
     }
   }
   receiver.length = receiverLength + length;
 }
 
 builtin$last$0(receiver) {
-  checkNull(receiver);
   if (!isJsArray(receiver)) {
     return UNINTERCEPTED(receiver.last());
   }
   return receiver[receiver.length - 1];
 }
 
 builtin$lastIndexOf$1(receiver, element) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     var start = JS('num', @'#.length', receiver);
     return Arrays.lastIndexOf(receiver, element, start);
   } else if (receiver is String) {
     checkNull(element);
     if (element is !String) throw new IllegalArgumentException(element);
     return JS('int', @'#.lastIndexOf(#)', receiver, element);
   }
   return UNINTERCEPTED(receiver.lastIndexOf(element));
 }
 
 builtin$lastIndexOf$2(receiver, element, start) {
-  checkNull(receiver);
   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 (start !== null) {
       if (start is !num) throw new IllegalArgumentException(start);
       if (start < 0) return -1;
       if (start >= receiver.length) start = receiver.length - 1;
     }
     return stringLastIndexOfUnchecked(receiver, element, start);
   }
   return UNINTERCEPTED(receiver.lastIndexOf(element, start));
 }
 
 stringLastIndexOfUnchecked(receiver, element, start)
   => JS('int', @'#.lastIndexOf(#, #)', receiver, element, start);
 
 builtin$removeRange$2(receiver, start, length) {
-  checkNull(receiver);
   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);
   var receiverLength = JS('num', @'#.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,
               start,
               receiverLength - length - start);
   receiver.length = receiverLength - length;
 }
 
 builtin$setRange$3(receiver, start, length, from) {
-  checkNull(receiver);
   if (isJsArray(receiver)) {
     return builtin$setRange$4(receiver, start, length, from, 0);
   }
   return UNINTERCEPTED(receiver.setRange(start, length, from));
 }
 
 builtin$setRange$4(receiver, start, length, from, startFrom) {
-  checkNull(receiver);
   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 < 0) throw new IndexOutOfRangeException(start);
   if (start + length > receiver.length) {
     throw new IndexOutOfRangeException(start + length);
   }
 
   Arrays.copy(from, startFrom, receiver, start, length);
 }
 
 builtin$some$1(receiver, f) {
-  checkNull(receiver);
-  if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.some(f));
-
-  return Collections.some(receiver, f);
+  if (!isJsArray(receiver)) {
+    return UNINTERCEPTED(receiver.some(f));
+  } else {
+    return Collections.some(receiver, f);
+  }
 }
 
 builtin$every$1(receiver, f) {
-  if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.every(f));
-
-  return Collections.every(receiver, f);
+  if (!isJsArray(receiver)) {
+    return UNINTERCEPTED(receiver.every(f));
+  } else {
+    return Collections.every(receiver, f);
+  }
 }
 
 builtin$sort$1(receiver, compare) {
-  checkNull(receiver);
   if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.sort(compare));
 
   DualPivotQuicksort.sort(receiver, compare);
 }
 
 checkNull(object) {
   if (object === null) throw new NullPointerException();
   return object;
 }
 
 checkNum(value) {
-  checkNull(value);
-  if (value is !num) throw new IllegalArgumentException(value);
+  if (value is !num) {
+    checkNull(value);
+    throw new IllegalArgumentException(value);
+  }
   return value;
 }
 
 checkInt(value) {
-  checkNull(value);
-  if (value is !int) throw new IllegalArgumentException(value);
+  if (value is !int) {
+    checkNull(value);
+    throw new IllegalArgumentException(value);
+  }
   return value;
 }
 
 checkBool(value) {
-  checkNull(value);
-  if (value is !bool) throw new IllegalArgumentException(value);
+  if (value is !bool) {
+    checkNull(value);
+    throw new IllegalArgumentException(value);
+  }
   return value;
 }
 
 checkString(value) {
-  checkNull(value);
-  if (value is !String) throw new IllegalArgumentException(value);
+  if (value is !String) {
+    checkNull(value);
+    throw new IllegalArgumentException(value);
+  }
   return value;
 }
 
 builtin$isNegative$0(receiver) {
-  checkNull(receiver);
   if (receiver is num) {
     return (receiver === 0) ? (1 / receiver) < 0 : receiver < 0;
   } else {
     return UNINTERCEPTED(receiver.isNegative());
   }
 }
 
 builtin$isNaN$0(receiver) {
-  checkNull(receiver);
   if (receiver is num) {
     return JS('bool', @'isNaN(#)', receiver);
   } else {
     return UNINTERCEPTED(receiver.isNegative());
   }
 }
 
 builtin$remainder$1(a, b) {
-  checkNull(a);
   if (checkNumbers(a, b)) {
     return JS('num', @'# % #', a, b);
   } else {
     return UNINTERCEPTED(a.remainder(b));
   }
 }
 
 builtin$abs$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.abs());
 
   return JS('num', @'Math.abs(#)', receiver);
 }
 
 builtin$toInt$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.toInt());
 
   if (receiver.isNaN()) throw new BadNumberFormatException('NaN');
 
   if (receiver.isInfinite()) throw new BadNumberFormatException('Infinity');
 
   var truncated = receiver.truncate();
   return JS('bool', @'# == -0.0', truncated) ? 0 : truncated;
 }
 
 builtin$ceil$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.ceil());
 
   return JS('num', @'Math.ceil(#)', receiver);
 }
 
 builtin$floor$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.floor());
 
   return JS('num', @'Math.floor(#)', receiver);
 }
 
 builtin$isInfinite$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.isInfinite());
 
   return JS('bool', @'# == Infinity', receiver)
     || JS('bool', @'# == -Infinity', receiver);
 }
 
 builtin$negate$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.negate());
 
   return JS('num', @'-#', receiver);
 }
 
 builtin$round$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.round());
 
   if (JS('bool', @'# < 0', receiver)) {
     return JS('num', @'-Math.round(-#)', receiver);
   } else {
     return JS('num', @'Math.round(#)', receiver);
   }
 }
 
 builtin$toDouble$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.toDouble());
 
   // TODO(ahe): Just return receiver?
   return JS('double', @'# + 0', receiver);
 }
 
 builtin$truncate$0(receiver) {
-  checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.truncate());
 
   return receiver < 0 ? receiver.ceil() : receiver.floor();
 }
 
 builtin$toStringAsFixed$1(receiver, fractionDigits) {
-  checkNull(receiver);
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsFixed(fractionDigits));
   }
   checkNum(fractionDigits);
 
   String result = JS('String', @'#.toFixed(#)', receiver, fractionDigits);
   if (receiver == 0 && receiver.isNegative()) return "-$result";
   return result;
 }
 
 builtin$toStringAsExponential$1(receiver, fractionDigits) {
-  checkNull(receiver);
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsExponential(fractionDigits));
   }
   if (fractionDigits !== null) checkNum(fractionDigits);
 
   String result = JS('String', @'#.toExponential(#)',
                      receiver, fractionDigits);
   if (receiver == 0 && receiver.isNegative()) return "-$result";
   return result;
 }
 
 builtin$toStringAsPrecision$1(receiver, fractionDigits) {
-  checkNull(receiver);
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsPrecision(fractionDigits));
   }
   checkNum(fractionDigits);
 
   String result = JS('String', @'#.toPrecision(#)',
                      receiver, fractionDigits);
   if (receiver == 0 && receiver.isNegative()) return "-$result";
   return result;
 }
 
 builtin$toRadixString$1(receiver, radix) {
-  checkNull(receiver);
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toRadixString(radix));
   }
   checkNum(radix);
 
   return JS('String', @'#.toString(#)', receiver, radix);
 }
 
 builtin$allMatches$1(receiver, str) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.allMatches(str));
   checkString(str);
   return allMatchesInStringUnchecked(receiver, str);
 }
 
 builtin$concat$1(receiver, other) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.concat(other));
 
   if (other is !String) throw new IllegalArgumentException(other);
   return JS('String', @'#.concat(#)', receiver, other);
 }
 
 builtin$contains$1(receiver, other) {
   if (receiver is !String) {
-    checkNull(receiver);
     return UNINTERCEPTED(receiver.contains(other));
   }
   return builtin$contains$2(receiver, other, 0);
 }
 
 builtin$contains$2(receiver, other, startIndex) {
-  checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.contains(other, startIndex));
   }
   checkNull(other);
   return stringContainsUnchecked(receiver, other, startIndex);
 }
 
 builtin$endsWith$1(receiver, other) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.endsWith(other));
 
-  checkNull(other);
-  if (other is !String) throw new IllegalArgumentException(other);
-
+  checkString(other);
   int receiverLength = receiver.length;
   int otherLength = other.length;
   if (otherLength > receiverLength) return false;
   return other == receiver.substring(receiverLength - otherLength);
 }
 
 builtin$replaceAll$2(receiver, from, to) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.replaceAll(from, to));
 
-  checkNull(from);
   checkString(to);
   return stringReplaceAllUnchecked(receiver, from, to);
 }
 
 builtin$replaceFirst$2(receiver, from, to) {
-  checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.replaceFirst(from, to));
   }
-  checkNull(from);
   checkString(to);
   return stringReplaceFirstUnchecked(receiver, from, to);
 }
 
 builtin$split$1(receiver, pattern) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.split(pattern));
   checkNull(pattern);
   return stringSplitUnchecked(receiver, pattern);
 }
 
 builtin$splitChars$0(receiver) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.splitChars());
 
   return JS('List', @'#.split("")', receiver);
 }
 
 builtin$startsWith$1(receiver, other) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.startsWith(other));
-  checkNull(other);
-  if (other is !String) throw new IllegalArgumentException(other);
+  checkString(other);
 
   int length = other.length;
   if (length > receiver.length) return false;
   return JS('bool', @'# == #', other,
             JS('String', @'#.substring(0, #)', receiver, length));
 }
 
 builtin$substring$1(receiver, startIndex) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.substring(startIndex));
 
   return builtin$substring$2(receiver, startIndex, null);
 }
 
 builtin$substring$2(receiver, startIndex, endIndex) {
-  checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.substring(startIndex, endIndex));
   }
   checkNum(startIndex);
   var length = receiver.length;
   if (endIndex === null) endIndex = length;
   checkNum(endIndex);
   if (startIndex < 0 ) throw new IndexOutOfRangeException(startIndex);
   if (startIndex > endIndex) throw new IndexOutOfRangeException(startIndex);
   if (endIndex > length) throw new IndexOutOfRangeException(endIndex);
   return substringUnchecked(receiver, startIndex, endIndex);
 }
 
 substringUnchecked(receiver, startIndex, endIndex)
   => JS('String', @'#.substring(#, #)', receiver, startIndex, endIndex);
 
 
 builtin$toLowerCase$0(receiver) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.toLowerCase());
 
   return JS('String', @'#.toLowerCase()', receiver);
 }
 
 builtin$toUpperCase$0(receiver) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.toUpperCase());
 
   return JS('String', @'#.toUpperCase()', receiver);
 }
 
 builtin$trim$0(receiver) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.trim());
 
   return JS('String', @'#.trim()', receiver);
 }
 
 class MathNatives {
   static int parseInt(str) {
-    checkNull(str);
-    if (str is !String) throw new IllegalArgumentException(str);
+    checkString(str);
     if (!JS('bool',
             @'/^\s*[+-]?(?:0[xX][abcdefABCDEF0-9]+|\d+)\s*$/.test(#)',
             str)) {
       throw new BadNumberFormatException(str);
     }
     var trimmed = str.trim();
     var base = 10;;
     if ((trimmed.length > 2 && (trimmed[1] == 'x' || trimmed[1] == 'X')) ||
         (trimmed.length > 3 && (trimmed[2] == 'x' || trimmed[2] == 'X'))) {
       base = 16;
     }
     var ret = JS('num', @'parseInt(#, #)', trimmed, base);
     if (ret.isNaN()) throw new BadNumberFormatException(str);
     return ret;
   }
 
   static double parseDouble(String str) {
-    checkNull(str);
-    if (str is !String) throw new IllegalArgumentException();
+    checkString(str);
     var ret = JS('num', @'parseFloat(#)', str);
     if (ret == 0 && (str.startsWith("0x") || str.startsWith("0X"))) {
       // TODO(ahe): This is unspecified, but tested by co19.
       ret = JS('num', @'parseInt(#)', str);
     }
     if (ret.isNaN() && str != 'NaN' && str != '-NaN') {
       throw new BadNumberFormatException(str);
     }
     return ret;
   }
@@ skipping 77 matching lines @@
 
 /**
  * This method is installed as JavaScript toString method on exception
  * objects in [captureStackTrace]. So JavaScript 'this' binds to an
  * instance of JavaScript Error to which we have added a property
  * 'dartException' which holds a Dart object.
  */
 toStringWrapper() => JS('Object', @'this.dartException').toString();
 
 builtin$charCodes$0(receiver) {
-  checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.charCodes());
   int len = receiver.length;
   List<int> result = new List<int>(len);
   for (int i = 0; i < len; i++) {
     result[i] = receiver.charCodeAt(i);
   }
   return result;
 }
 
 makeLiteralListConst(list) {
@@ skipping 122 matching lines @@
 
 jsPropertyAccess(var jsObject, String property) {
   return JS('var', @'#[#]', jsObject, property);
 }
 
 /**
  * Called at the end of unaborted switch cases to get the singleton
  * FallThroughError exception that will be thrown.
  */
 getFallThroughError() => const FallThroughError();
+
+builtin$isEven$0(receiver) {
+  if (receiver is !int) return UNINTERCEPTED(receiver.isEven());
+  return (receiver & 1) === 0;
+}
+
+builtin$isOdd$0(receiver) {
+  if (receiver is !int) return UNINTERCEPTED(receiver.isOdd());
+  return (receiver & 1) === 1;
+}