Make modInv throw Exception on incompatible operands.

runtime/lib/bigint.dart

 // Copyright (c) 2014, 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.
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 /*
  * Copyright (c) 2003-2005  Tom Wu
@@ skipping 1202 matching lines @@
 
   int get bitLength {
     if (_used == 0) return 0;
     if (_neg) return (~this).bitLength;
     return _DIGIT_BITS*(_used - 1) + _nbits(_digits[_used - 1]);
   }
 
   // This method must support smi._toBigint()._shrFromInt(int).
   int _shrFromInt(int other) {
     if (_used == 0) return other;  // Shift amount is zero.
-    if (_neg) throw new RangeError(this);
+    if (_neg) throw new RangeError.range(this, 0, null);
     assert(_DIGIT_BITS == 32);  // Otherwise this code needs to be revised.
     var shift;
     if ((_used > 2) || ((_used == 2) && (_digits[1] > 0x10000000))) {
       if (other < 0) {
         return -1;
       } else {
         return 0;
       }
     } else {
       shift = ((_used == 2) ? (_digits[1] << _DIGIT_BITS) : 0) + _digits[0];
     }
     return other._toBigint()._rShift(shift)._toValidInt();
   }
 
   // This method must support smi._toBigint()._shlFromInt(int).
   // An out of memory exception is thrown if the result cannot be allocated.
   int _shlFromInt(int other) {
     if (_used == 0) return other;  // Shift amount is zero.
-    if (_neg) throw new RangeError(this);
+    if (_neg) throw new RangeError.range(this, 0, null);
     assert(_DIGIT_BITS == 32);  // Otherwise this code needs to be revised.
     var shift;
     if (_used > 2 || (_used == 2 && _digits[1] > 0x10000000)) {
       if (other == 0) return 0;  // Shifted value is zero.
       throw new OutOfMemoryError();
     } else {
       shift = ((_used == 2) ? (_digits[1] << _DIGIT_BITS) : 0) + _digits[0];
     }
     return other._toBigint()._lShift(shift)._toValidInt();
   }
@@ skipping 137 matching lines @@
   }
   bool _greaterThanFromInteger(int other) {
     return other._toBigint()._compare(this) > 0;
   }
   bool _equalToInteger(int other) {
     return other._toBigint()._compare(this) == 0;
   }
 
   // Returns pow(this, e) % m, with e >= 0, m > 0.
   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]

Below, you added "not an integer"

[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 (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;
     m = m._toBigint();
     final m_used = m._used;
     final m_used2p4 = 2*m_used + 4;
     final e_bitlen = e.bitLength;
     if (e_bitlen <= 0) return 1;
     final bool cannotUseMontgomery = m.isEven || _abs() >= m;
     if (cannotUseMontgomery || e_bitlen < 64) {
       _Reduction z = (cannotUseMontgomery || e_bitlen < 8) ?
           new _Classic(m) : new _Montgomery(m);
@@ skipping 120 matching lines @@
           --j;
         }
       }
     }
     assert(!is1);
     return z._revert(r_digits, r_used)._toValidInt();
   }
 
   // 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(_Bigint x, _Bigint y, bool inv) {
     var x_digits = x._digits;
     var y_digits = y._digits;
     var x_used = x._used;
     var y_used = y._used;
     var m_used = x_used > y_used ? x_used : y_used;
     final m_len = m_used + (m_used & 1);
     x_digits = _cloneDigits(x_digits, 0, x_used, m_len);
     y_digits = _cloneDigits(y_digits, 0, y_used, m_len);
     int s = 0;
     if (inv) {
       if ((y_used == 1) && (y_digits[0] == 1)) return 1;
       if ((y_used == 0) || (y_digits[0].isEven && x_digits[0].isEven)) {
-        throw new RangeError("Not coprime");
+        throw new UnsupportedError("Not coprime");
       }
     } else {
-      if ((x_used == 0) || (y_used == 0)) throw new RangeError(0);
+      if (x_used == 0) {
+        throw new ArgumentError.value(0, "first operand", "must not be zero");

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

x is 'this' at this point, i.e. the receiver for gcd.

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

I wasn't able to convince myself that this was always the case since _binaryGcd
is called from multiple places.
If it is, then it should just be `this` and `other`.

+      }
+      if (y_used == 0) {
+        throw new ArgumentError.value(0, "second operand", "must not be zero");

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

y is the 'other' argument of gcd.

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

Done.

+      }
       if (((x_used == 1) && (x_digits[0] == 1)) ||
           ((y_used == 1) && (y_digits[0] == 1))) return 1;
       bool xy_cloned = false;
       while (x.isEven && y.isEven) {
         _rsh(x_digits, x_used, 1, x_digits);
         _rsh(y_digits, y_used, 1, y_digits);
         s++;
       }
       if (s >= _DIGIT_BITS) {
         var sd = s >> _LOG2_DIGIT_BITS;
@@ skipping 175 matching lines @@
     }
     if (!inv) {
       if (s > 0) {
         _lsh(v_digits, m_used, s, v_digits);
       }
       return new _Bigint(false, m_used, v_digits)._toValidInt();
     }
     // No inverse if v != 1.
     var i = m_used - 1;
     while ((i > 0) && (v_digits[i] == 0)) --i;
-    if ((i != 0) || (v_digits[0] != 1)) throw new RangeError("Not coprime");
+    if ((i != 0) || (v_digits[0] != 1)) {
+      throw new UnsupportedError("Not coprime");
+    }
 
     if (d_neg) {
       if ((d_digits[m_used] != 0) ||
           (_compareDigits(d_digits, m_used, x_digits, m_used) > 0)) {
         _absSub(d_digits, abcd_used, x_digits, m_used, d_digits);
         if ((d_digits[m_used] != 0) ||
             (_compareDigits(d_digits, m_used, x_digits, m_used) > 0)) {
           _absSub(d_digits, abcd_used, x_digits, m_used, d_digits);
         } else {
           _absSub(x_digits, m_used, d_digits, m_used, d_digits);
           d_neg = false;
         }
       } else {
         _absSub(x_digits, m_used, d_digits, m_used, d_digits);
         d_neg = false;
       }
     } else if ((d_digits[m_used] != 0) ||
                (_compareDigits(d_digits, m_used, x_digits, m_used) > 0)) {
       _absSub(d_digits, abcd_used, x_digits, m_used, d_digits);
       if ((d_digits[m_used] != 0) ||
           (_compareDigits(d_digits, m_used, x_digits, m_used) > 0)) {
         _absSub(d_digits, abcd_used, x_digits, m_used, d_digits);
       }
     }
     return new _Bigint(false, m_used, d_digits)._toValidInt();
   }
 
   // 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;
     m = m._toBigint();
     var t = this;
     if (t._neg || (t._absCompare(m) >= 0)) {
       t %= m;
       t = t._toBigint();
     }
     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 (other is! int) {
+      throw new ArgumentError.value(other, "other", "not an integer");
+    }
     return _binaryGcd(this, other._toBigint(), false);
   }
 }
 
 // Interface for modular reduction.
 class _Reduction {
   // Return the number of digits used by r_digits.
   int _convert(_Bigint x, Uint32List r_digits);
   int _mul(Uint32List x_digits, int x_used,
            Uint32List y_digits, int y_used, Uint32List r_digits);
@@ skipping 258 matching lines @@
 
   int _mul(Uint32List x_digits, int x_used,
            Uint32List y_digits, int y_used,
            Uint32List r_digits) {
     var r_used = _Bigint._mulDigits(x_digits, x_used,
                                     y_digits, y_used,
                                     r_digits);
     return _reduce(r_digits, r_used);
   }
 }