Use ArgumentError.value in more places in js_lib.

sdk/lib/_internal/compiler/js_lib/js_number.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.
 
 part of _interceptors;
 
 /**
  * The super interceptor class for [JSInt] and [JSDouble]. The compiler
  * recognizes this class as an interceptor, and changes references to
  * [:this:] to actually use the receiver of the method, which is
  * generated as an extra argument added to each member.
  *
  * Note that none of the methods here delegate to a method defined on JSInt or
  * JSDouble.  This is exploited in [tryComputeConstantInterceptor].
  */
 class JSNumber extends Interceptor implements num {
   const JSNumber();
 
   int compareTo(num b) {
-    if (b is! num) throw new ArgumentError(b);
+    if (b is! num) throw argumentErrorValue(b);
     if (this < b) {
       return -1;
     } else if (this > b) {
       return 1;
     } else if (this == b) {
       if (this == 0) {
         bool bIsNegative = b.isNegative;
         if (isNegative == bIsNegative) return 0;
         if (isNegative) return -1;
         return 1;
       }
       return 0;
     } else if (isNaN) {
       if (b.isNaN) {
         return 0;
       }
       return 1;
     } else {
       return -1;
     }
   }
 
   bool get isNegative => (this == 0) ? (1 / this) < 0 : this < 0;
 
   bool get isNaN => JS('bool', r'isNaN(#)', this);
 
   bool get isInfinite {
-    return JS('bool', r'# == Infinity', this)
-        || JS('bool', r'# == -Infinity', this);
+    return JS('bool', r'# == (1/0)', this)
+        || JS('bool', r'# == (-1/0)', this);
   }
 
   bool get isFinite => JS('bool', r'isFinite(#)', this);
 
   num remainder(num b) {
-    checkNull(b); // TODO(ngeoffray): This is not specified but co19 tests it.
-    if (b is! num) throw new ArgumentError(b);
+    if (b is! num) throw argumentErrorValue(b);
     return JS('num', r'# % #', this, b);
   }
 
   num abs() => JS('returns:num;effects:none;depends:none;throws:never',
       r'Math.abs(#)', this);
 
   num get sign => this > 0 ? 1 : this < 0 ? -1 : this;
 
   static const int _MIN_INT32 = -0x80000000;
   static const int _MAX_INT32 = 0x7FFFFFFF;
@@ skipping 42 matching lines @@
     if (this < 0) {
       return JS('num', r'-Math.round(-#)', this);
     } else {
       return JS('num', r'Math.round(#)', this);
     }
   }
 
   double truncateToDouble() => this < 0 ? ceilToDouble() : floorToDouble();
 
   num clamp(lowerLimit, upperLimit) {
-    if (lowerLimit is! num) throw new ArgumentError(lowerLimit);
-    if (upperLimit is! num) throw new ArgumentError(upperLimit);
+    if (lowerLimit is! num) throw argumentErrorValue(lowerLimit);
+    if (upperLimit is! num) throw argumentErrorValue(upperLimit);
     if (lowerLimit.compareTo(upperLimit) > 0) {
-      throw new ArgumentError(lowerLimit);
+      throw argumentErrorValue(lowerLimit);
     }
     if (this.compareTo(lowerLimit) < 0) return lowerLimit;
     if (this.compareTo(upperLimit) > 0) return upperLimit;
     return this;
   }
 
   // The return type is intentionally omitted to avoid type checker warnings
   // from assigning JSNumber to double.
   toDouble() => this;
 
@@ skipping 72 matching lines @@
     } else {
       return JS('String', r'"" + (#)', this);
     }
   }
 
   int get hashCode => JS('int', '# & 0x1FFFFFFF', this);
 
   num operator -() => JS('num', r'-#', this);
 
   num operator +(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('num', '# + #', this, other);
   }
 
   num operator -(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('num', '# - #', this, other);
   }
 
   num operator /(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('num', '# / #', this, other);
   }
 
   num operator *(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('num', '# * #', this, other);
   }
 
   num operator %(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     // Euclidean Modulo.
     num result = JS('num', r'# % #', this, other);
     if (result == 0) return 0;  // Make sure we don't return -0.0.
     if (result > 0) return result;
     if (JS('num', '#', other) < 0) {
       return result - JS('num', '#', other);
     } else {
       return result + JS('num', '#', other);
     }
   }
 
   bool _isInt32(value) => JS('bool', '(# | 0) === #', value, value);
 
   int operator ~/(num other) {
     if (false) _tdivFast(other); // Ensure resolution.
     if (_isInt32(this) && _isInt32(other) && 0 != other && -1 != other) {
       return JS('int', r'(# / #) | 0', this, other);
     } else {
       return _tdivSlow(other);
     }
   }
 
   int _tdivFast(num other) {
     return _isInt32(this)
         ? JS('int', r'(# / #) | 0', this, other)
         : (JS('num', r'# / #', this, other)).toInt();
   }
 
   int _tdivSlow(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return (JS('num', r'# / #', this, other)).toInt();
   }
 
   // TODO(ngeoffray): Move the bit operations below to [JSInt] and
   // make them take an int. Because this will make operations slower,
   // we define these methods on number for now but we need to decide
   // the grain at which we do the type checks.
 
   num operator <<(num other) {
-    if (other is !num) throw new ArgumentError(other);
-    if (JS('num', '#', other) < 0) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
+    if (JS('num', '#', other) < 0) throw argumentErrorValue(other);
     return _shlPositive(other);
   }
 
   num _shlPositive(num other) {
     // JavaScript only looks at the last 5 bits of the shift-amount. Shifting
     // by 33 is hence equivalent to a shift by 1.
     return JS('bool', r'# > 31', other)
         ? 0
         : JS('JSUInt32', r'(# << #) >>> 0', this, other);
   }
 
   num operator >>(num other) {
     if (false) _shrReceiverPositive(other);
-    if (other is !num) throw new ArgumentError(other);
-    if (JS('num', '#', other) < 0) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
+    if (JS('num', '#', other) < 0) throw argumentErrorValue(other);
     return _shrOtherPositive(other);
   }
 
   num _shrOtherPositive(num other) {
     return JS('num', '#', this) > 0
         ? _shrBothPositive(other)
         // For negative numbers we just clamp the shift-by amount.
         // `this` could be negative but not have its 31st bit set.
         // The ">>" would then shift in 0s instead of 1s. Therefore
         // we cannot simply return 0xFFFFFFFF.
         : JS('JSUInt32', r'(# >> #) >>> 0', this, other > 31 ? 31 : other);
   }
 
   num _shrReceiverPositive(num other) {
-    if (JS('num', '#', other) < 0) throw new ArgumentError(other);
+    if (JS('num', '#', other) < 0) throw argumentErrorValue(other);
     return _shrBothPositive(other);
   }
 
   num _shrBothPositive(num other) {
     return JS('bool', r'# > 31', other)
         // 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.
         ? 0
         // Given that `this` is positive we must not use '>>'. Otherwise a
         // number that has the 31st bit set would be treated as negative and
         // shift in ones.
         : JS('JSUInt32', r'# >>> #', this, other);
   }
 
   num operator &(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('JSUInt32', r'(# & #) >>> 0', this, other);
   }
 
   num operator |(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('JSUInt32', r'(# | #) >>> 0', this, other);
   }
 
   num operator ^(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('JSUInt32', r'(# ^ #) >>> 0', this, other);
   }
 
   bool operator <(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('bool', '# < #', this, other);
   }
 
   bool operator >(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('bool', '# > #', this, other);
   }
 
   bool operator <=(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('bool', '# <= #', this, other);
   }
 
   bool operator >=(num other) {
-    if (other is !num) throw new ArgumentError(other);
+    if (other is !num) throw argumentErrorValue(other);
     return JS('bool', '# >= #', this, other);
   }
 
   Type get runtimeType => num;
 }
 
 /**
  * The interceptor class for [int]s.
  *
  * This class implements double since in JavaScript all numbers are doubles, so
@@ skipping 20 matching lines @@
     int nonneg = this < 0 ? -this - 1 : this;
     if (nonneg >= 0x100000000) {
       nonneg = nonneg ~/ 0x100000000;
       return _bitCount(_spread(nonneg)) + 32;
     }
     return _bitCount(_spread(nonneg));
   }
 
   // Returns pow(this, e) % m.
   int modPow(int e, int m) {
-    if (e is! int) throw new ArgumentError(e);
-    if (m is! int) throw new ArgumentError(m);
+    if (e is! int) throw argumentErrorValue(e);
+    if (m is! int) throw argumentErrorValue(m);
     if (e < 0) throw new RangeError(e);
     if (m <= 0) throw new RangeError(m);
     if (e == 0) return 1;
     int b = this;
     if (b < 0 || b > m) {
       b %= m;
     }
     int r = 1;
     while (e > 0) {
       if (e.isOdd) {
         r = (r * b) % m;
       }
       e ~/= 2;
       b = (b * b) % m;
     }
     return r;
   }
 
   // Returns 1/this % m, with m > 0.
   int modInverse(int m) {
-    if (m is! int) throw new ArgumentError(m);
+    if (m is! int) throw argumentErrorValue(m);
     if (m <= 0) throw new RangeError(m);
     if (m == 1) return 0;
     int t = this;
     if ((t < 0) || (t >= m)) t %= m;
     if (t == 1) return 1;
     final bool ac = m.isEven;
     if ((t == 0) || (ac && t.isEven)) throw new RangeError("Not coprime");
     int u = m;
     int v = t;
     int a = 1,
@@ skipping 95 matching lines @@
 }
 
 class JSDouble extends JSNumber implements double {
   const JSDouble();
   Type get runtimeType => double;
 }
 
 class JSPositiveInt extends JSInt {}
 class JSUInt32 extends JSPositiveInt {}
 class JSUInt31 extends JSUInt32 {}