Updated VM and JS versions of Date to allow underflow and overflow.

runtime/lib/date.dart

 // Copyright (c) 2011, 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.
 // Dart core library.
 
 // VM implementation of DateImplementation.
 class DateImplementation implements Date {
   static final int _MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
 
-  DateImplementation(int years,
+  DateImplementation(int year,
                      [int month = 1,
                       int day = 1,
                       int hour = 0,
                       int minute = 0,
                       int second = 0,
                       int millisecond = 0,
                       bool isUtc = false])
       : this.isUtc = isUtc,
         this.millisecondsSinceEpoch = _brokenDownDateToMillisecondsSinceEpoch(
-            years, month, day, hour, minute, second, millisecond, isUtc) {
+            year, month, day, hour, minute, second, millisecond, isUtc) {
     if (millisecondsSinceEpoch === null) throw new IllegalArgumentException();
     if (isUtc === null) throw new IllegalArgumentException();
   }
 
   DateImplementation.now()
       : isUtc = false,
         millisecondsSinceEpoch = _getCurrentMs() {
   }
 
   factory DateImplementation.fromString(String formattedString) {
@@ skipping 16 matching lines @@
         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 year = 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 = _brokenDownDateToMillisecondsSinceEpoch(
-          years, month, day, hour, minute, second, millisecond, isUtc);
+          year, month, day, hour, minute, second, millisecond, isUtc);
       if (millisecondsSinceEpoch === null) {
         throw new IllegalArgumentException(formattedString);
       }
       if (addOneMillisecond) millisecondsSinceEpoch++;
       return new DateImplementation.fromMillisecondsSinceEpoch(
           millisecondsSinceEpoch, isUtc);
     } else {
       throw new IllegalArgumentException(formattedString);
     }
   }
@@ skipping 156 matching lines @@
   /** Returns a [Duration] with the difference of [this] and [other]. */
   Duration difference(Date other) {
     int ms = millisecondsSinceEpoch;
     int otherMs = other.millisecondsSinceEpoch;
     return new DurationImplementation(milliseconds: ms - otherMs);
   }
 
   /** The first list contains the days until each month in non-leap years. The
     * second list contains the days in leap years. */
   static final List<List<int>> _DAYS_UNTIL_MONTH =
-      const [const [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
-             const [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]];
+      const [const [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365],
+             const [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366]];

[floitsch, 2012/08/06 21:00:58]

80chars.

[dominich, 2012/08/06 21:20:58]

Done.

 
   // Returns the UTC year, month and day for the corresponding
   // [millisecondsSinceEpoch].
   // Code is adapted from V8.
   static List<int> _decomposeIntoYearMonthDay(int millisecondsSinceEpoch) {
     // TODO(floitsch): cache result.
     final int DAYS_IN_4_YEARS = 4 * 365 + 1;
     final int DAYS_IN_100_YEARS = 25 * DAYS_IN_4_YEARS - 1;
     final int DAYS_IN_400_YEARS = 4 * DAYS_IN_100_YEARS + 1;
     final int DAYS_1970_TO_2000 = 30 * 365 + 7;
@@ skipping 72 matching lines @@
             - _flooredDivision(year - 1901, 100)
             + _flooredDivision(year - 1601, 400);
   }
 
   static bool _isLeapYear(y) {
     return (y.remainder(4) == 0) &&
         ((y.remainder(100) != 0) || (y.remainder(400) == 0));
   }
 
   static _brokenDownDateToMillisecondsSinceEpoch(
-      int years, int month, int day,
+      int year, int month, int day,
       int hour, int minute, int second, int millisecond,
       bool isUtc) {
-    if ((month < 1) || (month > 12)) return null;
-    if ((day < 1) || (day > 31)) return null;
-    // Leap seconds can lead to hour == 24.
-    if ((hour < 0) || (hour > 24)) return null;
-    if ((hour == 24) && ((minute != 0) || (second != 0))) return null;
-    if ((minute < 0) || (minute > 59)) return null;
-    if ((second < 0) || (second > 59)) return null;
-    if ((millisecond < 0) || (millisecond > 999)) return null;
+    // Deal with under and overflow.
+    second += (millisecond / 1000).floor().toInt();
+    millisecond = millisecond % 1000;
+    minute += (second / 60).floor().toInt();
+    second = second % 60;
+    hour += (minute / 60).floor().toInt();
+    minute = minute % 60;
+    day += (hour / 24).floor().toInt();
+    hour = hour % 24;
+    year += ((month - 1) / 12).floor().toInt();
+    month = (month - 1) % 12 + 1;
+
+    // Start with the current month and add _DAYS_UNTIL_MONTH until day > 1
+    // (and <= numDaysInMonth).
+    while (day < 1) {
+      int numDaysInMonth = _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month] -
+          _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month - 1];
+      day += numDaysInMonth;
+      --month;
+      if (month < 1) {
+        --year;
+        month = 12;
+      }
+    }
+
+    // And in reverse.
+    int numDaysInMonth = _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month] -
+        _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month - 1];
+    while (day > numDaysInMonth) {
+      day -= numDaysInMonth;
+      ++month;
+      if (month > 12) {
+        ++year;
+        month = 1;
+      }
+      numDaysInMonth = _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month] -
+          _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month - 1];
+    }
 
     // First compute the seconds in UTC, independent of the [isUtc] flag. If
     // necessary we will add the time-zone offset later on.
     int days = day - 1;
-    days += _DAYS_UNTIL_MONTH[_isLeapYear(years) ? 1 : 0][month - 1];

[floitsch, 2012/08/06 21:00:58]

Isn't it enough to:
years += (month - 1) ~/ 12;
int clampedMonth = (month - 1).remainder(12);
if (clampedMonth < 0) { years--; clampedMonth += 12; }

The hour, minute, second and milliseconds are correctly added later and don't
depend on the month/year anyways.

[dominich, 2012/08/06 21:20:58]

No - clampedMonth could be -50 in which case years should be decremented
further.

[floitsch, 2012/08/07 09:10:07]

I don't see how this could happen since it is .remainder(12).

[dominich, 2012/08/13 19:26:35]

i've just realised - i'm not sure which bit of the code you're suggesting
replacing. The comment is under the day loop (that needs to evaluate every
month) and the code above that changes the years/months is just a divide and
floor, rather than the remainder, and doesn't have the branch.

why would your suggestion be better, and which bit of the code is it suggested
to improve?

[floitsch, 2012/08/13 19:41:34]

Unless I'm wrong you don't need to do any loops. The beginning of this function
could be:
_brokenDown...(int year, ...) {
  // First compute the seconds ...
  years += (month - 1) ~/ 12;
  int clampedMonth = (month - 1).remainder(12);
  if (clampedMonth < 0) { years--; clampedMonth += 12; }
  int days = day - 1;
  days += _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][clampedMonth - 1];
  days += _dayFromYear(year);
  ... // same as before.

-    days += _dayFromYear(years);
+    days += _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][month - 1];
+    days += _dayFromYear(year);
     int millisecondsSinceEpoch = days * Duration.MILLISECONDS_PER_DAY +
         hour * Duration.MILLISECONDS_PER_HOUR +
         minute * Duration.MILLISECONDS_PER_MINUTE+
         second * Duration.MILLISECONDS_PER_SECOND +
         millisecond;
 
     // Since [_timeZoneOffsetInSeconds] will crash if the input is far out of
     // the valid range we do a preliminary test that weeds out values that can
     // not become valid even with timezone adjustments.
     // The timezone adjustment is always less than a day, so adding a security
@@ skipping 113 matching lines @@
 
   static String _timeZoneNameForClampedSeconds(int secondsSinceEpoch)
       native "DateNatives_timeZoneName";
 
   static int _timeZoneOffsetInSecondsForClampedSeconds(int secondsSinceEpoch)
       native "DateNatives_timeZoneOffsetInSeconds";
 
   static int _localTimeZoneAdjustmentInSeconds()
       native "DateNatives_localTimeZoneAdjustmentInSeconds";
 }