Don't throw exception for non-integer args to fixnum int32,int64 op ==

pkg/fixnum/lib/src/int64.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 fixnum;
 
 /**
  * An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
  * Arithmetic operations may overflow in order to maintain this range.
  */
@@ skipping 222 matching lines @@
    * [:((top & 0xffffffff) << 32) | (bottom & 0xffffffff):].
    */
   int64.fromInts(int top, int bottom) {
     top &= 0xffffffff;
     bottom &= 0xffffffff;
     _l = bottom & _MASK;
     _m = ((top & 0xfff) << 10) | ((bottom >> _BITS) & 0x3ff);
     _h = (top >> 12) & _MASK_2;
   }
 
-  int64 _promote(other) {
-    if (other == null) {
-      throw new ArgumentError(null);
-    } else if (other is intx) {
-      other = other.toInt64();
-    } else if (other is int) {
-      other = new int64.fromInt(other);
+  // Returns the [int64] representation of the specified value or null for
+  // incompatible types.
+  int64 _promote(val) {

[justinfagnani, 2013/07/26 23:44:40]

Same as the int32 comment here, all but == throws an ArgumentError

[Chris Bracken, 2013/07/27 01:07:11]

Done.

+    if (val is int64) {
+      return val;
+    } else if (val is int) {
+      return new int64.fromInt(val);
+    } else if (val is int32) {
+      return val.toInt64();
     }
-    if (other is !int64) {
-      throw new Exception("Can't promote $other to int64");
-    }
-    return other;
+    return null;
   }
 
   int64 operator +(other) {
     int64 o = _promote(other);
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     int sum0 = _l + o._l;
     int sum1 = _m + o._m + _shiftRight(sum0, _BITS);
     int sum2 = _h + o._h + _shiftRight(sum1, _BITS);
 
     int64 result = new int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
     return result;
   }
 
   int64 operator -(other) {
     int64 o = _promote(other);
-
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     int sum0 = _l - o._l;
     int sum1 = _m - o._m + _shiftRight(sum0, _BITS);
     int sum2 = _h - o._h + _shiftRight(sum1, _BITS);
 
     int64 result = new int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
     return result;
   }
 
   int64 operator -() {
     // Like 0 - this.
     int sum0 = -_l;
     int sum1 = -_m + _shiftRight(sum0, _BITS);
     int sum2 = -_h + _shiftRight(sum1, _BITS);
 
     return new int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
   }
 
   int64 operator *(other) {
     int64 o = _promote(other);
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     // Grab 13-bit chunks.
     int a0 = _l & 0x1fff;
     int a1 = (_l >> 13) | ((_m & 0xf) << 9);
     int a2 = (_m >> 4) & 0x1fff;
     int a3 = (_m >> 17) | ((_h & 0xff) << 5);
     int a4 = (_h & 0xfff00) >> 8;
 
     int b0 = o._l & 0x1fff;
     int b1 = (o._l >> 13) | ((o._m & 0xf) << 9);
     int b2 = (o._m >> 4) & 0x1fff;
@@ skipping 69 matching lines @@
   }
 
   int64 operator %(other) {
     if (other.isZero) {
       throw new IntegerDivisionByZeroException();
     }
     if (this.isZero) {
       return ZERO;
     }
     int64 o = _promote(other).abs();
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     _divMod(this, o, true);
     return _remainder < 0 ? (_remainder + o) : _remainder;
   }
 
   int64 operator ~/(other) => _divMod(this, _promote(other), false);

[justinfagnani, 2013/07/26 23:44:40]

This will end up throwing a NoSuchMethodError (null pointer) in _divMode if
other in not int-ish, might as well throw the ArgumentError

[Chris Bracken, 2013/07/27 01:07:11]

Done.

 
   // int64 remainder(other) => this - (this ~/ other) * other;
   int64 remainder(other) {
     if (other.isZero) {
       throw new IntegerDivisionByZeroException();
     }
     int64 o = _promote(other).abs();
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     _divMod(this, o, true);
     return _remainder;
   }
 
   int64 operator &(other) {
     int64 o = _promote(other);
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     int a0 = _l & o._l;
     int a1 = _m & o._m;
     int a2 = _h & o._h;
     return new int64._bits(a0, a1, a2);
   }
 
   int64 operator |(other) {
     int64 o = _promote(other);
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     int a0 = _l | o._l;
     int a1 = _m | o._m;
     int a2 = _h | o._h;
     return new int64._bits(a0, a1, a2);
   }
 
   int64 operator ^(other) {
     int64 o = _promote(other);
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     int a0 = _l ^ o._l;
     int a1 = _m ^ o._m;
     int a2 = _h ^ o._h;
     return new int64._bits(a0, a1, a2);
   }
 
   int64 operator ~() {
     var result = new int64._bits((~_l) & _MASK, (~_m) & _MASK, (~_h) & _MASK_2);
     return result;
   }
@@ skipping 86 matching lines @@
     }
 
     return new int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
   }
 
   /**
    * Returns [true] if this [int64] has the same numeric value as the
    * given object.  The argument may be an [int] or an [intx].
    */
   bool operator ==(other) {
-    if (other == null) {
+    int64 o = _promote(other);
+    if (o == null) {
       return false;
     }
-    int64 o = _promote(other);
     return _l == o._l && _m == o._m && _h == o._h;
   }
 
   int compareTo(Comparable other) {
     int64 o = _promote(other);
+    if (o == null) {
+      throw new ArgumentError(other);
+    }
     int signa = _h >> (_BITS2 - 1);
     int signb = o._h >> (_BITS2 - 1);
     if (signa != signb) {
       return signa == 0 ? 1 : -1;
     }
     if (_h > o._h) {
       return 1;
     } else if (_h < o._h) {
       return -1;
     }
@@ skipping 453 matching lines @@
     if (h == 0 && m != 0 && l == 0) {
       return int32._numberOfTrailingZeros(m) + _BITS;
     }
     if (h != 0 && m == 0 && l == 0) {
       return int32._numberOfTrailingZeros(h) + _BITS01;
     }
 
     return -1;
   }
 
   int64 _divMod(int64 a, int64 b, bool computeRemainder) {

[justinfagnani, 2013/07/26 23:44:40]

It looks like this is acting like a static method, even though it's an instance
method. I think the first argument should be removed in favor of using "this".

[Chris Bracken, 2013/07/27 01:07:11]

It's used in toString() and toRadixString() with non-this values. I've made
_divMod() and _divModByShift() static for now.

[justinfagnani, 2013/07/27 01:23:54]

What I mean is that this method doesn't mix a and 'this'. Those calls can just
use a._divMod(...), rather than _divMod(a, ...)

     if (b.isZero) {
       throw new IntegerDivisionByZeroException();
     }
     if (a.isZero) {
       if (computeRemainder) {
         _remainder = ZERO;
       }
       return ZERO;
     }
     // MIN_VALUE / MIN_VALUE = 1, anything other a / MIN_VALUE is 0.
@@ skipping 77 matching lines @@
         }
       }
       return ZERO;
     }
 
     // Generate the quotient using bit-at-a-time long division.
     return _divModHelper(aIsCopy ? a : new int64._copy(a), b, negative,
         aIsNegative, aIsMinValue, computeRemainder);
   }
 }