isEven, isOdd, isNegative, isMaxValue, isMinValue, isInfinite, isPositive, isSingleValue.

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('dart:coreimpl');
 
 add$1(var receiver, var value) {
   if (isJsArray(receiver)) {
@@ skipping 98 matching lines @@
 }
 
 compareTo(a, b) {
   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();
+        bool aIsNegative = a.isNegative;
+        bool bIsNegative = b.isNegative;
         if (aIsNegative == bIsNegative) return 0;
         if (aIsNegative) return -1;
         return 1;
       }
       return 0;
-    } else if (a.isNaN()) {
-      if (b.isNaN()) {
+    } 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 ArgumentError(b);
     return JS('bool', r'# == #', a, b) ? 0
       : JS('bool', r'# < #', a, b) ? -1 : 1;
@@ skipping 228 matching lines @@
   checkMutable(receiver, 'sort');
   DualPivotQuicksort.sort(receiver, Comparable.compare);
 }
 
 sort$1(receiver, compare) {
   if (!isJsArray(receiver)) return UNINTERCEPTED(receiver.sort(compare));
   checkMutable(receiver, 'sort');
   DualPivotQuicksort.sort(receiver, compare);
 }
 
-isNegative(receiver) {
+get$isNegative(receiver) {
   if (receiver is num) {
     return (receiver == 0) ? (1 / receiver) < 0 : receiver < 0;
   } else {
-    return UNINTERCEPTED(receiver.isNegative());
+    return UNINTERCEPTED(receiver.isNegative);
   }
 }
 
-isNaN(receiver) {
+get$isNaN(receiver) {
   if (receiver is num) {
     return JS('bool', r'isNaN(#)', receiver);
   } else {
-    return UNINTERCEPTED(receiver.isNaN());
+    return UNINTERCEPTED(receiver.isNaN);
   }
 }
 
 remainder(a, b) {
   if (checkNumbers(a, b)) {
     return JS('num', r'# % #', a, b);
   } else {
     return UNINTERCEPTED(a.remainder(b));
   }
 }
 
 abs(receiver) {
   if (receiver is !num) return UNINTERCEPTED(receiver.abs());
 
   return JS('num', r'Math.abs(#)', receiver);
 }
 
 toInt(receiver) {
   if (receiver is !num) return UNINTERCEPTED(receiver.toInt());
 
-  if (receiver.isNaN()) throw new FormatException('NaN');
+  if (receiver.isNaN) throw new FormatException('NaN');
 
-  if (receiver.isInfinite()) throw new FormatException('Infinity');
+  if (receiver.isInfinite) throw new FormatException('Infinity');
 
   var truncated = receiver.truncate();
   return JS('bool', r'# == -0.0', truncated) ? 0 : truncated;
 }
 
 ceil(receiver) {
   if (receiver is !num) return UNINTERCEPTED(receiver.ceil());
 
   return JS('num', r'Math.ceil(#)', receiver);
 }
 
 floor(receiver) {
   if (receiver is !num) return UNINTERCEPTED(receiver.floor());
 
   return JS('num', r'Math.floor(#)', receiver);
 }
 
-isInfinite(receiver) {
-  if (receiver is !num) return UNINTERCEPTED(receiver.isInfinite());
+get$isInfinite(receiver) {
+  if (receiver is !num) return UNINTERCEPTED(receiver.isInfinite);
 
   return JS('bool', r'# == Infinity', receiver)
     || JS('bool', r'# == -Infinity', receiver);
 }
 
 round(receiver) {
   if (receiver is !num) return UNINTERCEPTED(receiver.round());
 
   if (JS('bool', r'# < 0', receiver)) {
     return JS('num', r'-Math.round(-#)', receiver);
@@ skipping 14 matching lines @@
   return receiver < 0 ? receiver.ceil() : receiver.floor();
 }
 
 toStringAsFixed(receiver, fractionDigits) {
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsFixed(fractionDigits));
   }
   checkNum(fractionDigits);
 
   String result = JS('String', r'#.toFixed(#)', receiver, fractionDigits);
-  if (receiver == 0 && receiver.isNegative()) return "-$result";
+  if (receiver == 0 && receiver.isNegative) return "-$result";
   return result;
 }
 
 toStringAsExponential(receiver, fractionDigits) {
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsExponential(fractionDigits));
   }
   String result;
   if (fractionDigits != null) {
     checkNum(fractionDigits);
     result = JS('String', r'#.toExponential(#)', receiver, fractionDigits);
   } else {
     result = JS('String', r'#.toExponential()', receiver);
   }
-  if (receiver == 0 && receiver.isNegative()) return "-$result";
+  if (receiver == 0 && receiver.isNegative) return "-$result";
   return result;
 }
 
 toStringAsPrecision(receiver, fractionDigits) {
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsPrecision(fractionDigits));
   }
   checkNum(fractionDigits);
 
   String result = JS('String', r'#.toPrecision(#)',
                      receiver, fractionDigits);
-  if (receiver == 0 && receiver.isNegative()) return "-$result";
+  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 ArgumentError(radix);
   return JS('String', r'#.toString(#)', receiver, radix);
@@ skipping 146 matching lines @@
 charCodes(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;
 }
 
-isEven(receiver) {
-  if (receiver is !int) return UNINTERCEPTED(receiver.isEven());
+get$isEven(receiver) {
+  if (receiver is !int) return UNINTERCEPTED(receiver.isEven);
   return (receiver & 1) == 0;
 }
 
-isOdd(receiver) {
-  if (receiver is !int) return UNINTERCEPTED(receiver.isOdd());
+get$isOdd(receiver) {
+  if (receiver is !int) return UNINTERCEPTED(receiver.isOdd);
   return (receiver & 1) == 1;
 }
 
 get$runtimeType(receiver) {
   if (receiver is int) {
     return getOrCreateCachedRuntimeType('int');
   } else if (receiver is String) {
     return getOrCreateCachedRuntimeType('String');
   } else if (receiver is double) {
     return getOrCreateCachedRuntimeType('double');
   } else if (receiver is bool) {
     return getOrCreateCachedRuntimeType('bool');
   } else if (receiver == null) {
     return getOrCreateCachedRuntimeType('Null');
   } else if (isJsArray(receiver)) {
     return getOrCreateCachedRuntimeType('List');
   } else {
     return UNINTERCEPTED(receiver.runtimeType);
   }
 }
 
 // TODO(lrn): These getters should be generated automatically for all
 // intercepted methods.
 get$toString(receiver) => () => toString(receiver);