Int64 tweaks for better type infererence

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 81 matching lines @@
       }
 
       // [radix] and [digit] are at most 6 bits, component is 22, so we can
       // multiply and add within 30 bit temporary values.
       d0 = d0 * radix + digit;
       int carry = d0 >> _BITS;
       d0 = _MASK & d0;
 
       d1 = d1 * radix + carry;
       carry = d1 >> _BITS;
-      d1 = _MASK & d1;;
+      d1 = _MASK & d1;
 
       d2 = d2 * radix + carry;
       d2 = _MASK2 & d2;
     }
 
     if (negative) return _negate(d0, d1, d2);
 
     return new Int64._bits(d0, d1, d2);
   }
 
@@ skipping 82 matching lines @@
     return new Int64.fromInts(top, bottom);
  }
 
   /**
    * Constructs an [Int64] from a pair of 32-bit integers having the value
    * [:((top & 0xffffffff) << 32) | (bottom & 0xffffffff):].
    */
   factory Int64.fromInts(int top, int bottom) {
     top &= 0xffffffff;
     bottom &= 0xffffffff;
-    int d0 = bottom & _MASK;
-    int d1 = ((top & 0xfff) << 10) | ((bottom >> _BITS) & 0x3ff);
-    int d2 = (top >> 12) & _MASK2;
+    int d0 = _MASK & bottom;
+    int d1 = ((0xfff & top) << 10) | (0x3ff & (bottom >> _BITS));
+    int d2 = _MASK2 & (top >> 12);
     return new Int64._bits(d0, d1, d2);
   }
 
   // Returns the [Int64] representation of the specified value. Throws
   // [ArgumentError] for non-integer arguments.
   static Int64 _promote(val) {
     if (val is Int64) {
       return val;
     } else if (val is int) {
       return new Int64(val);
@@ skipping 87 matching lines @@
     int c13 = (p3 & 0x1f) << 17;
     int c1 = c10 + c11 + c12 + c13;
 
     int c22 = p2 >> 18;
     int c23 = p3 >> 5;
     int c24 = (p4 & 0xfff) << 8;
     int c2 = c22 + c23 + c24;
 
     // Propagate high bits from c0 -> c1, c1 -> c2.
     c1 += c0 >> _BITS;
-    c0 &= _MASK;
     c2 += c1 >> _BITS;
-    c1 &= _MASK;
-    c2 &= _MASK2;
 
-    return new Int64._bits(c0, c1, c2);
+    return Int64._masked(c0, c1, c2);
   }
 
   Int64 operator %(other) => _divide(this, other, _RETURN_MOD);
 
   Int64 operator ~/(other) => _divide(this, other, _RETURN_DIV);
 
   Int64 remainder(other) => _divide(this, other, _RETURN_REM);
 
   Int64 operator &(other) {
     Int64 o = _promote(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);
     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);
     int a0 = _l ^ o._l;
     int a1 = _m ^ o._m;
     int a2 = _h ^ o._h;
-    return new Int64._bits(a0, a1, a2);
+    return Int64._masked(a0, a1, a2);
   }
 
   Int64 operator ~() {
     return Int64._masked(~_l, ~_m, ~_h);
   }
 
   Int64 operator <<(int n) {
     if (n < 0) {
       throw new ArgumentError(n);
     }
@@ skipping 660 matching lines @@
     assert(r2 < b2 ||  // Handles case where B = -(MIN_VALUE)
         new Int64._bits(r0, r1, r2) < new Int64._bits(b0, b1, b2));
 
     assert(what == _RETURN_DIV || what == _RETURN_MOD || what == _RETURN_REM);
     if (what == _RETURN_DIV) {
       if (aNeg != bNeg) return _negate(q0, q1, q2);
       return Int64._masked(q0, q1, q2);  // Masking for type inferrer.
     }
 
     if (!aNeg) {
-      return new Int64._bits(_MASK & r0, r1, r2);  // Masking for type inferrer.
+      return Int64._masked(r0, r1, r2);  // Masking for type inferrer.
     }
 
     if (what == _RETURN_MOD) {
       if (r0 == 0 && r1 == 0 && r2 == 0) {
         return ZERO;
       } else {
         return _sub(b0, b1, b2, r0, r1, r2);
       }
     } else {
       return _negate(r0, r1, r2);
     }
   }
 }