Make modInv throw Exception on incompatible operands.

runtime/lib/integers.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.
 
 // TODO(srdjan): fix limitations.
 // - shift amount must be a Smi.
 class _IntegerImplementation extends _Num {
   // The Dart class _Bigint extending _IntegerImplementation requires a
   // default constructor.
 
@@ skipping 157 matching lines @@
   int floor() { return this; }
   int ceil() { return this; }
   int truncate() { return this; }
 
   double roundToDouble() { return this.toDouble(); }
   double floorToDouble() { return this.toDouble(); }
   double ceilToDouble() { return this.toDouble(); }
   double truncateToDouble() { return this.toDouble(); }
 
   num clamp(num lowerLimit, num upperLimit) {
-    if (lowerLimit is! num) throw new ArgumentError(lowerLimit);
-    if (upperLimit is! num) throw new ArgumentError(upperLimit);
+    if (lowerLimit is! num) {
+      throw new ArgumentError.value(lowerLimit, "lowerLimit");
+    }
+    if (upperLimit is! num) {
+      throw new ArgumentError.value(upperLimit, "upperLimit");
+    }
 
     // Special case for integers.
-    if (lowerLimit is int && upperLimit is int) {
-      if (lowerLimit > upperLimit) {
-        throw new ArgumentError(lowerLimit);
-      }
+    if (lowerLimit is int && upperLimit is int &&
+        lowerLimit <= upperLimit) {
       if (this < lowerLimit) return lowerLimit;
       if (this > upperLimit) return upperLimit;
       return this;
     }
-    // Generic case involving doubles.
+    // Generic case involving doubles, and invalid integer ranges.
     if (lowerLimit.compareTo(upperLimit) > 0) {
-      throw new ArgumentError(lowerLimit);
+      throw new RangeError.range(upperLimit, lowerLimit, null, "upperLimit");
     }
     if (lowerLimit.isNaN) return lowerLimit;
     // Note that we don't need to care for -0.0 for the lower limit.
     if (this < lowerLimit) return lowerLimit;
     if (this.compareTo(upperLimit) > 0) return upperLimit;
     return this;
   }
 
   int toInt() { return this; }
   double toDouble() { return new _Double.fromInteger(this); }
   _Bigint _toBigint() { return new _Bigint._fromInt(this); }
   num _toBigintOrDouble() { return _toBigint(); }
 
   String toStringAsFixed(int fractionDigits) {
     return this.toDouble().toStringAsFixed(fractionDigits);
   }
   String toStringAsExponential([int fractionDigits]) {
     return this.toDouble().toStringAsExponential(fractionDigits);
   }
   String toStringAsPrecision(int precision) {
     return this.toDouble().toStringAsPrecision(precision);
   }
 
   static const _digits = "0123456789abcdefghijklmnopqrstuvwxyz";
 
   String toRadixString(int radix) {
     if (radix is! int || radix < 2 || radix > 36) {
-      throw new ArgumentError(radix);
+      throw new RangeError.range(radix, 2, 36, "radix");

[regis, 2015/06/24 15:40:43]

To be consistent, we should throw an ArgumentError if radix is not an integer.

[Lasse Reichstein Nielsen, 2015/06/25 07:22:21]

True. 
Or maybe should just stop testing if the argument is an integer when it's
decared as "int radix".

If we just change it to (radix < 2 || 36 < radix) then that restricts it to
working with int and double, then the & in the next section will fail for
doubles, so it's not really needed.

[regis, 2015/06/25 16:51:45]

Good point.

[sra1, 2015/06/25 21:28:48]

I have been writing this range check in the dart2js versions as

    2 <= radix && radix <= 36

It is a way of putting the constant in receiver position (which generates the
best JavaScript) without looking unnatural.

[Lasse Reichstein Nielsen, 2015/06/30 05:50:47]

I'll go for (radix < 2 || 36 < radix) for the reverse test.

     }
     if (radix & (radix - 1) == 0) {
       return _toPow2String(radix);
     }
     if (radix == 10) return this.toString();
     final bool isNegative = this < 0;
     int value = isNegative ? -this : this;
     List temp = new List();
     do {
       int digit = value % radix;
@@ skipping 29 matching lines @@
       string._setAt(--length, _digits.codeUnitAt(value & mask));
       value >>= bitsPerDigit;
     } while (value > 0);
     return string;
   }
 
   _leftShiftWithMask32(count, mask)  native "Integer_leftShiftWithMask32";
 
   // 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 < 0) throw new RangeError(e);
-    if (m <= 0) throw new RangeError(m);
+    if (e is! int) throw new ArgumentError.value(e, "exponent");

[regis, 2015/06/24 15:40:43]

We should add "not an integer" as in other places.

[Lasse Reichstein Nielsen, 2015/06/30 05:50:47]

Done.

+    if (m is! int) throw new ArgumentError.value(m, "modulus");

[regis, 2015/06/24 15:40:43]

ditto

[Lasse Reichstein Nielsen, 2015/06/30 05:50:47]

Done.

If we simply removed the tests, what is the worst that could happen?
A double e would get caught at .isOdd, a double m would probably work all the
way through and give a meaningful result. Or wrong result if it goes to the
bigint case - but still, the world won't crash, and the analyzer should warn, so
it'll still be fine.

+    if (e < 0) throw new RangeError.range(e, 0, null, "exponent");
+    if (m <= 0) throw new RangeError.range(m, 1, null, "modulus");
     if (e == 0) return 1;
     if (e is _Bigint || m is _Bigint) {
       return _toBigint().modPow(e, m);
     }
     int b = this;
     if (b < 0 || b > m) {
       b %= m;
     }
     int r = 1;
     while (e > 0) {
       if (e.isOdd) {
         r = (r * b) % m;
       }
       e >>= 1;
       b = (b * b) % m;
     }
     return r;
   }
 
   // If inv is false, returns gcd(x, y).
   // If inv is true and gcd(x, y) = 1, returns d, so that c*x + d*y = 1.
-  // If inv is true and gcd(x, y) != 1, throws RangeError("Not coprime").
+  // If inv is true and gcd(x, y) != 1, throws UnsupportedError("Not coprime").
   static int _binaryGcd(int x, int y, bool inv) {
     int s = 0;
     if (!inv) {
       while (x.isEven && y.isEven) {
         x >>= 1;
         y >>= 1;
         s++;
       }
       if (y.isOdd) {
         var t = x;
@@ skipping 39 matching lines @@
         u -= v;
         if (ac) a -= c;
         b -= d;
       } else {
         v -= u;
         if (ac) c -= a;
         d -= b;
       }
     } while (u != 0);
     if (!inv) return v << s;
-    if (v != 1) throw new RangeError("Not coprime");
+    if (v != 1) {
+      throw new UnsupportedError("Not coprime");
+    }
     if (d < 0) {
       d += x;
       if (d < 0) d += x;
     } else if (d > x) {
       d -= x;
       if (d > x) d -= x;
     }
     return d;
   }
 
   // Returns 1/this % m, with m > 0.
   int modInverse(int m) {
-    if (m is! int) throw new ArgumentError(m);
-    if (m <= 0) throw new RangeError(m);
+    if (m is! int) {
+      throw new ArgumentError.value(m, "modulus", "not an integer");
+    }
+    if (m <= 0) throw new RangeError.range(m, 1, null, "modulus");
     if (m == 1) return 0;
     if (m is _Bigint) {
       return _toBigint().modInverse(m);
     }
     int t = this;
     if ((t < 0) || (t >= m)) t %= m;
     if (t == 1) return 1;
-    if ((t == 0) || (t.isEven && m.isEven)) throw new RangeError("Not coprime");
+    if ((t == 0) || (t.isEven && m.isEven)) {
+      throw new UnsupportedError("Not coprime");
+    }
     return _binaryGcd(m, t, true);
   }
 
   // Returns gcd of abs(this) and abs(other), with this != 0 and other !=0.
   int gcd(int other) {
-    if (other is! int) throw new ArgumentError(other);
-    if ((this == 0) || (other == 0)) throw new RangeError(0);
+    if (other is! int) {
+      throw new ArgumentError.value(other, "other", "not an integer");
+    }
+    if (this == 0) {
+      throw new ArgumentError.value(this, "first operand", "must not be zero");
+    }
+    if (other == 0) {
+      throw new ArgumentError.value(this, "second operand", "must not be zero");
+    }
     int x = this.abs();
     int y = other.abs();
     if ((x == 1) || (y == 1)) return 1;
     if (other is _Bigint) {
       return _toBigint().gcd(other);
     }
     return _binaryGcd(x, y, false);
   }
 }
 
@@ skipping 209 matching lines @@
   // Shift by mint exceeds range that can be handled by the VM.
   int _shrFromInt(int other) {
     if (other < 0) {
       return -1;
     } else {
       return 0;
     }
   }
   int _shlFromInt(int other) native "Mint_shlFromInt";
 }