Create 'unified' version of Date, with a dart2js implementation.

corelib/unified/core/implementation/date.dart

Index: corelib/unified/core/implementation/date.dart
diff --git a/corelib/unified/core/implementation/date.dart b/corelib/unified/core/implementation/date.dart
new file mode 100644
index 0000000000000000000000000000000000000000..d195e9482a515ac25451c98aa05d5b0b4c851c83
--- /dev/null
+++ b/corelib/unified/core/implementation/date.dart
@@ -0,0 +1,192 @@
+// 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.
+
+class DateImplementation implements Date {
+  final int millisecondsSinceEpoch;
+  final bool isUtc;
+
+  external DateImplementation(int year,
+                            [int month,
+                            int day,
+                            int hour,
+                            int minute,
+                            int second,
+                            int millisecond,
+                            bool isUtc]);
+
+  external DateImplementation.now();
+
+  factory DateImplementation.fromString(String formattedString) {
+    // Read in (a subset of) ISO 8601.
+    // Examples:
+    //    - "2012-02-27 13:27:00"
+    //    - "2012-02-27 13:27:00.423z"
+    //    - "20120227 13:27:00"
+    //    - "20120227T132700"
+    //    - "20120227"
+    //    - "2012-02-27T14Z"
+    //    - "-123450101 00:00:00 Z"  // In the year -12345.
+    final RegExp re = const RegExp(
+        @'^([+-]?\d?\d\d\d\d)-?(\d\d)-?(\d\d)' // The day part.
+        @'(?:[ T](\d\d)(?::?(\d\d)(?::?(\d\d)(.\d{1,6})?)?)? ?([zZ])?)?$');
+    Match match = re.firstMatch(formattedString);
+    if (match !== null) {
+      int parseIntOrZero(String matched) {
+        // TODO(floitsch): we should not need to test against the empty string.
+        if (matched === null || matched == "") return 0;
+        return Math.parseInt(matched);
+      }
+
+      double parseDoubleOrZero(String matched) {
+        // TODO(floitsch): we should not need to test against the empty string.
+        if (matched === null || matched == "") return 0.0;
+        return Math.parseDouble(matched);
+      }
+
+      int years = Math.parseInt(match[1]);
+      int month = Math.parseInt(match[2]);
+      int day = Math.parseInt(match[3]);
+      int hour = parseIntOrZero(match[4]);
+      int minute = parseIntOrZero(match[5]);
+      int second = parseIntOrZero(match[6]);
+      bool addOneMillisecond = false;
+      int millisecond = (parseDoubleOrZero(match[7]) * 1000).round().toInt();
+      if (millisecond == 1000) {
+        addOneMillisecond = true;
+        millisecond = 999;
+      }
+      // TODO(floitsch): we should not need to test against the empty string.
+      bool isUtc = (match[8] !== null) && (match[8] != "");
+      int millisecondsSinceEpoch = Primitives.valueFromDecomposedDate(
+          years, month, day, hour, minute, second, millisecond, isUtc);
+      if (millisecondsSinceEpoch === null) {
+        throw new IllegalArgumentException(formattedString);
+      }
+      if (addOneMillisecond) millisecondsSinceEpoch++;
+      return new Date.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, isUtc);
+    } else {
+      throw new IllegalArgumentException(formattedString);
+    }
+  }
+
+  static final int _MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
+
+  DateImplementation.fromMillisecondsSinceEpoch(this.millisecondsSinceEpoch,
+                                                [this.isUtc = false]) {
+    if (millisecondsSinceEpoch.abs() > _MAX_MILLISECONDS_SINCE_EPOCH) {
+      throw new IllegalArgumentException(millisecondsSinceEpoch);
+    }
+    if (isUtc === null) throw new IllegalArgumentException(isUtc);
+  }
+
+  bool operator ==(other) {
+    if (!(other is Date)) return false;
+    return (millisecondsSinceEpoch == other.millisecondsSinceEpoch);
+  }
+
+  bool operator <(Date other)
+      => millisecondsSinceEpoch < other.millisecondsSinceEpoch;
+
+  bool operator <=(Date other)
+      => millisecondsSinceEpoch <= other.millisecondsSinceEpoch;
+
+  bool operator >(Date other)
+      => millisecondsSinceEpoch > other.millisecondsSinceEpoch;
+
+  bool operator >=(Date other)
+      => millisecondsSinceEpoch >= other.millisecondsSinceEpoch;
+
+  int compareTo(Date other)
+      => millisecondsSinceEpoch.compareTo(other.millisecondsSinceEpoch);
+
+  int hashCode() => millisecondsSinceEpoch;
+
+  Date toLocal() {
+    if (isUtc) {
+      return new Date.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, false);
+    }
+    return this;
+  }
+
+  Date toUtc() {
+    if (isUtc) return this;
+    return new Date.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, true);
+  }
+
+  external String get timeZoneName();

[Mads Ager (google), 2012/08/01 08:08:31]

Maybe group all of the external methods at the end or top of the block of
methods to make them stand out as much as possible? Also, I think I would remove
the newlines between them since there is no implementation.

[Anders Johnsen, 2012/08/01 08:35:50]

As I see it, we have two options. Keeping them in line with the interface
ordering or moving them to the bottom. Moving them to the bottom for now.

+
+  external Duration get timeZoneOffset();
+
+  external int get year();
+
+  external int get month();
+
+  external int get day();
+
+  external int get hour();
+
+  external int get minute();
+
+  external int get second();
+
+  external int get millisecond();
+
+  external int get weekday();
+
+  String toString() {
+    String fourDigits(int n) {
+      int absN = n.abs();
+      String sign = n < 0 ? "-" : "";
+      if (absN >= 1000) return "$n";
+      if (absN >= 100) return "${sign}0$absN";
+      if (absN >= 10) return "${sign}00$absN";
+      return "${sign}000$absN";
+    }
+
+    String threeDigits(int n) {
+      if (n >= 100) return "${n}";
+      if (n >= 10) return "0${n}";
+      return "00${n}";
+    }
+
+    String twoDigits(int n) {
+      if (n >= 10) return "${n}";
+      return "0${n}";
+    }
+
+    String y = fourDigits(year);
+    String m = twoDigits(month);
+    String d = twoDigits(day);
+    String h = twoDigits(hour);
+    String min = twoDigits(minute);
+    String sec = twoDigits(second);
+    String ms = threeDigits(millisecond);
+    if (isUtc) {
+      return "$y-$m-$d $h:$min:$sec.${ms}Z";
+    } else {
+      return "$y-$m-$d $h:$min:$sec.$ms";
+    }
+  }
+
+  // Adds the [duration] to this Date instance.
+  Date add(Duration duration) {
+    int ms = millisecondsSinceEpoch;
+    return new Date.fromMillisecondsSinceEpoch(
+        ms + duration.inMilliseconds, isUtc);
+  }
+
+  // Subtracts the [duration] from this Date instance.
+  Date subtract(Duration duration) {
+    int ms = millisecondsSinceEpoch;
+    return new Date.fromMillisecondsSinceEpoch(
+        ms - duration.inMilliseconds, isUtc);
+  }
+
+  // Returns a [Duration] with the difference of [this] and [other].
+  Duration difference(Date other) {
+    int ms = millisecondsSinceEpoch;
+    int otherMs = other.millisecondsSinceEpoch;
+    return new Duration(milliseconds: ms - otherMs);
+  }
+}