Make modInv throw Exception on incompatible operands.

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
@@ skipping 114 matching lines @@
     return this;
   }
 
   // The return type is intentionally omitted to avoid type checker warnings
   // from assigning JSNumber to double.
   toDouble() => this;
 
   String toStringAsFixed(int fractionDigits) {
     checkInt(fractionDigits);
     if (fractionDigits < 0 || fractionDigits > 20) {
-      throw new RangeError(fractionDigits);
+      throw new RangeError.range(fractionDigits, 0, 20, "fractionDigits");
     }
     String result = JS('String', r'#.toFixed(#)', this, fractionDigits);
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toStringAsExponential([int fractionDigits]) {
     String result;
     if (fractionDigits != null) {
       checkInt(fractionDigits);
       if (fractionDigits < 0 || fractionDigits > 20) {
-        throw new RangeError(fractionDigits);
+        throw new RangeError.range(fractionDigits, 0, 20, "fractionDigits");
       }
       result = JS('String', r'#.toExponential(#)', this, fractionDigits);
     } else {
       result = JS('String', r'#.toExponential()', this);
     }
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toStringAsPrecision(int precision) {
     checkInt(precision);
     if (precision < 1 || precision > 21) {
-      throw new RangeError(precision);
+      throw new RangeError.range(precision, 1, 21, "precision");
     }
     String result = JS('String', r'#.toPrecision(#)',
                        this, precision);
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toRadixString(int radix) {
     checkInt(radix);
     if (radix < 2 || radix > 36) {
@@ skipping 212 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 argumentErrorValue(e);

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

Why not ArgumentError.value(e, "exponent", "not an integer") ?

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

I think the argumentErrorValue function might be there to deliberately not be
inlined. But not sure.
It could still take more arguments to give better errors.

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

If you want to pass more arguments to ArgumentError.value just use the
constructor.  It makes perfect sense to name the argument here since there is
more than one.

----

Don't add arguments to argumentErrorValue.

Dart2js compiles calls to static functions (and factory constructors) by
inserting the default constants. So

  new ArgumentError.value(x)

generates one of

  P.ArgumentError$value(x, null, null)       // call factory
  new P.ArgumentError(true, x, null, null)   // inlined factory -> allocation

or when minified, something like:

  P.xy(x,null,null)
  new P.uv(!0,x,null,null)

I added argumentErrorValue(x) for two reasons:

(1) to have a common function that is called from 'canned' optimized code and
the js_lib implementations to ensure that optimization does not change the
exception.  

(2) to have a static function that has only one argument to get rid of the nulls
everywhere in the js_lib code. It generates

  P.argumentErrorValue(x)
minified:
  P.jk(x)

argumentErrorValue is marked as NoInline to stop it being reexpanded to one of
the above expressions (though it should not in a throw expression, it is used in
other contexts in js_lib).

Ideally the compiler would be smart enough to do this tedious task for common
cold-code patterns but it is not.

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

Done.

     if (m is! int) throw argumentErrorValue(m);

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

ditto

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

Done.

-    if (e < 0) throw new RangeError(e);
-    if (m <= 0) throw new RangeError(m);
+    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;
     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;
   }
 
   // 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 = 1;
     if (!inv) {
       while (x.isEven && y.isEven) {
         x ~/= 2;
         y ~/= 2;
         s *= 2;
       }
       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 s*v;
-    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;
     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 (m is! int) {
+      throw new ArgumentError.value(m, "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;
     return _binaryGcd(x, y, false);
   }
 
   // Assumes i is <= 32-bit and unsigned.
   static int _bitCount(int i) {
     // See "Hacker's Delight", section 5-1, "Counting 1-Bits".
 
@@ skipping 40 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 {}