Int32, Int64 default constructor now takes an optional int parameter.

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 100 matching lines @@
   /**
    * Parses a hexadecimal [String] and returns an [Int64].
    */
   static Int64 parseHex(String s) => _parseRadix(s, 16);
 
   //
   // Public constructors
   //
 
   /**
-   * Constructs an [Int64] equal to 0.
+   * Constructs an [Int64] with a given [int] value; zero by default.
    */
-  Int64() : _l = 0, _m = 0, _h = 0;
-
-  /**
-   * Constructs an [Int64] with a given [int] value.
-   */
-  factory Int64.fromInt(int value) {
+  factory Int64([int value=0]) {
     int v0 = 0, v1 = 0, v2 = 0;
     bool negative = false;
     if (value < 0) {
       negative = true;
       value = -value - 1;
     }
     if (_haveBigInts) {
       v0 = _MASK & value;
       v1 = _MASK & (value >> _BITS);
       v2 = _MASK2 & (value >> _BITS01);
     } 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;
     }
     return new Int64._bits(v0, v1, v2);
   }
 
+  /**
+   * Constructs an [Int64] with a given [int] value.
+   */
+  @deprecated
+  factory Int64.fromInt(int value) => new Int64(value);
+
   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;
 
     int bottom = bytes[3] & 0xff;
@@ skipping 39 matching lines @@
     int d2 = (top >> 12) & _MASK2;
     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.fromInt(val);
+      return new Int64(val);
     } else if (val is Int32) {
       return val.toInt64();
     }
     throw new ArgumentError(val);
   }
 
   Int64 operator +(other) {
     Int64 o = _promote(other);
     int sum0 = _l + o._l;
     int sum1 = _m + o._m + (sum0 >> _BITS);
@@ skipping 224 matching lines @@
    */
   bool operator ==(other) {
     Int64 o;
     if (other is Int64) {
       o = other;
     } else if (other is int) {
       if (_h == 0 && _m == 0) return _l == other;
       // Since we know one of [_h] or [_m] is non-zero, if [other] fits in the
       // low word then it can't be numerically equal.
       if ((_MASK & other) == other) return false;
-      o = new Int64.fromInt(other);
+      o = new Int64(other);
     } else if (other is Int32) {
       o = other.toInt64();
     }
     if (o != null) {
       return _l == o._l && _m == o._m && _h == o._h;
     }
     return false;
   }
 
   int compareTo(Comparable other) {
@@ skipping 42 matching lines @@
   bool get isMinValue => _h == _SIGN_BIT_MASK && _m == 0 && _l == 0;
   bool get isNegative => (_h & _SIGN_BIT_MASK) != 0;
   bool get isOdd => (_l & 0x1) == 1;
   bool get isZero => _h == 0 && _m == 0 && _l == 0;
 
   /**
    * Returns a hash code based on all the bits of this [Int64].
    */
   int get hashCode {
     // TODO(sra): Should we ensure that hashCode values match corresponding int?
-    // i.e. should `new Int64.fromInt(x).hashCode == x.hashCode`?
+    // i.e. should `new Int64(x).hashCode == x.hashCode`?
     int bottom = ((_m & 0x3ff) << _BITS) | _l;
     int top = (_h << 12) | ((_m >> 10) & 0xfff);
     return bottom ^ top;
   }
 
   Int64 abs() {
     return this.isNegative ? -this : this;
   }
 
   /**
@@ skipping 68 matching lines @@
     } else {
       result = (h * 17592186044416) + (m * 4194304) + l;
     }
     return negative ? -result - 1 : result;
   }
 
   /**
    * Returns an [Int32] containing the low 32 bits of this [Int64].
    */
   Int32 toInt32() {
-    return new Int32.fromInt(((_m & 0x3ff) << _BITS) | _l);
+    return new Int32(((_m & 0x3ff) << _BITS) | _l);
   }
 
   /**
    * Returns [this].
    */
   Int64 toInt64() => this;
 
   /**
    * Returns the value of this [Int64] as a decimal [String].
    */
   String toString() => _toRadixString(10);
 
   // TODO(rice) - Make this faster by avoiding arithmetic.
   String toHexString() {
     if (isZero) return "0";
     Int64 x = this;
     String hexStr = "";
-    Int64 digit_f = new Int64.fromInt(0xf);
+    Int64 digit_f = new Int64(0xf);
     while (!x.isZero) {
       int digit = x._l & 0xf;
       hexStr = "${_hexDigit(digit)}$hexStr";
       x = x.shiftRightUnsigned(4);
     }
     return hexStr;
   }
 
   String toRadixString(int radix) {
     if ((radix <= 1) || (radix > 36)) {
@@ skipping 342 matching lines @@
       if (r0 == 0 && r1 == 0 && r2 == 0) {
         return ZERO;
       } else {
         return _sub(b0, b1, b2, r0, r1, r2);
       }
     } else {
       return _negate(r0, r1, r2);
     }
   }
 }