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. Throws
+  // [ArgumentError] for non-integer arguments.
+  int64 _promote(val) {
+    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;
+    throw new ArgumentError(val);
   }
 
   int64 operator +(other) {
     int64 o = _promote(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);
-
     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);
+
     // 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 209 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) {
-      return false;
+    int64 o;
+    if (other is int64) {
+      o = other;
+    } else if (other is int) {
+      o = new int64.fromInt(other);
+    } else if (other is int32) {
+      o = other.toInt64();
     }
-    int64 o = _promote(other);
-    return _l == o._l && _m == o._m && _h == o._h;
+    if (o != null) {
+      return _l == o._l && _m == o._m && _h == o._h;
+    }
+    return false;
   }
 
   int compareTo(Comparable other) {
     int64 o = _promote(other);
     int signa = _h >> (_BITS2 - 1);
     int signb = o._h >> (_BITS2 - 1);
     if (signa != signb) {
       return signa == 0 ? 1 : -1;
     }
     if (_h > o._h) {
@@ skipping 404 matching lines @@
       b0 = _l;
       b1 = _m;
       b2 = _h & ((1 << (bits - _BITS01)) - 1);
     }
 
     _l = b0;
     _m = b1;
     _h = b2;
   }
 
-  int64 _divModByShift(int64 a, int bpower, bool negative, bool aIsCopy,
+  static int64 _divModByShift(int64 a, int bpower, bool negative, bool aIsCopy,
       bool aIsNegative, bool computeRemainder) {
     int64 c = a >> bpower;
     if (negative) {
       c._negate();
     }
 
     if (computeRemainder) {
       if (!aIsCopy) {
         a = new int64._copy(a);
       }
@@ skipping 32 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) {
+  static int64 _divMod(int64 a, int64 b, bool computeRemainder) {
     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);
   }
 }