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]];
 
   // 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();

[floitsch, 2012/08/14 08:31:38]

You shouldn't need to look at the hours, minutes, seconds and milliseconds. We
don't care if they over or underflow since we end up adding them anyways.
Lines 347 to 355 can be removed.

[dominich, 2012/08/14 16:49:20]

Of course - good point :)

+    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;

[floitsch, 2012/08/14 08:31:38]

Instead of dealing with +/- 1 all over the place do it once in the beginning
with a comment. For example:
// Dart's month is 1-indexed. Remove 1 to make it zero-based to simplify
computations.
month--;

[dominich, 2012/08/14 16:49:20]

Done.

+    int clampedMonth = (month - 1).remainder(12) + 1;
+    if (clampedMonth < 1) {
+      --year;
+      clampedMonth += 12;
+    }
 
     // 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];
-    days += _dayFromYear(years);
+    days += _DAYS_UNTIL_MONTH[_isLeapYear(year) ? 1 : 0][clampedMonth - 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";
 }