Int64 tweaks for type inference

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.
  */
 class Int64 implements IntX {
 
   // A 64-bit integer is represented internally as three non-negative
   // integers, storing the 22 low, 22 middle, and 20 high bits of the
   // 64-bit value.  _l (low) and _m (middle) are in the range
   // [0, 2^22 - 1] and _h (high) is in the range [0, 2^20 - 1].
+  //
+  // The values being assigned to _l, _m and _h in initialization are masked to
+  // force them into the above ranges.  Sometimes we know that the value is a
+  // small non-negative integer but the dart2js compiler can't infer that, so a
+  // few of the masking operations are not needed for correctness but are
+  // helpful for dart2js code quality.
+
   final int _l, _m, _h;
 
   // Note: several functions require _BITS == 22 -- do not change this value.
   static const int _BITS = 22;
   static const int _BITS01 = 44; // 2 * _BITS
   static const int _BITS2 = 20; // 64 - _BITS01
   static const int _MASK = 4194303; // (1 << _BITS) - 1
   static const int _MASK2 = 1048575; // (1 << _BITS2) - 1
   static const int _SIGN_BIT = 19; // _BITS2 - 1
   static const int _SIGN_BIT_MASK = 524288; // 1 << _SIGN_BIT
@@ skipping 107 matching lines @@
     } else {
       // Avoid using bitwise operations that coerce their input to 32 bits.
       v2 = value ~/ 17592186044416; // 2^44
       value -= v2 * 17592186044416;
       v1 = value ~/ 4194304; // 2^22
       value -= v1 * 4194304;
       v0 = value;
     }
 
     if (negative) {
-      v0 = _MASK & ~v0;
-      v1 = _MASK & ~v1;
-      v2 = _MASK2 & ~v2;
+      v0 = ~v0;
+      v1 = ~v1;
+      v2 = ~v2;
     }
-    return new Int64._bits(v0, v1, v2);
+    return Int64._masked(v0, v1, v2);
   }
 
   factory Int64.fromBytes(List<int> bytes) {
     int top = bytes[7] & 0xff;
     top <<= 8;
     top |= bytes[6] & 0xff;
     top <<= 8;
     top |= bytes[5] & 0xff;
     top <<= 8;
     top |= bytes[4] & 0xff;
@@ skipping 427 matching lines @@
     // All zeros
     return 64;
   }
 
   Int64 toSigned(int width) {
     if (width < 1 || width > 64) throw new ArgumentError(width);
     if (width > _BITS01) {
       return Int64._masked(_l, _m, _h.toSigned(width - _BITS01));
     } else if (width > _BITS) {
       int m = _m.toSigned(width - _BITS);
-      return m.isNegative ? Int64._masked(_l, m, _MASK2) :
-          new Int64._bits(_l, m, 0);
+      return m.isNegative
+          ? Int64._masked(_l, m, _MASK2)
+          : Int64._masked(_l, m, 0);  // Masking for type inferrer.
     } else {
       int l = _l.toSigned(width);
-      return l.isNegative ? Int64._masked(l, _MASK, _MASK2) :
-          new Int64._bits(l, 0, 0);
+      return l.isNegative
+          ? Int64._masked(l, _MASK, _MASK2)
+          : Int64._masked(l, 0, 0);  // Masking for type inferrer.
     }
   }
 
   Int64 toUnsigned(int width) {
     if (width < 0 || width > 64) throw new ArgumentError(width);
     if (width > _BITS01) {
       int h = _h.toUnsigned(width - _BITS01);
       return Int64._masked(_l, _m, h);
     } else if (width > _BITS) {
       int m = _m.toUnsigned(width - _BITS);
@@ skipping 405 matching lines @@
     }
 
     // 0 <= R < B
     assert(Int64.ZERO <= new Int64._bits(r0, r1, r2));
     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 new Int64._bits(q0, q1, q2);
+      return Int64._masked(q0, q1, q2);  // Masking for type inferrer.
     }
 
-    if (!aNeg) return new Int64._bits(r0, r1, r2);
+    if (!aNeg) {
+      return new Int64._bits(_MASK & 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);
     }
   }
 }