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],

[floitsch, 2012/08/15 08:44:26]

No need for the additional days anymore.

[dominich, 2012/08/17 16:38:33]

Done.

+          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;
+    // JavaScript month is zero-based while Dart is one-based. This should
+    // simplify some calculations.
+    --month;
+    // Deal with under and overflow.
+    year += (month / 12).floor().toInt();
+    month = month % 12;
+    int clampedMonth = month.remainder(12);
+    if (clampedMonth < 0) {
+      --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];
+    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";
 }