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

runtime/lib/date_patch.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.
 // Dart core library.
 
 // VM implementation of DateImplementation.
 patch class DateImplementation {
-  /* patch */ DateImplementation(int year,
+  /* patch */ DateImplementation(int years,
                                  [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(
-            year, month, day, hour, minute, second, millisecond, isUtc) {
+            years, month, day, hour, minute, second, millisecond, isUtc) {
     if (millisecondsSinceEpoch === null) throw new IllegalArgumentException();
     if (isUtc === null) throw new IllegalArgumentException();
   }
 
   /* patch */ DateImplementation.now()
       : isUtc = false,
         millisecondsSinceEpoch = _getCurrentMs() {
   }
 
   /* patch */ String get timeZoneName() {
@@ skipping 141 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 year, int month, int day,
+      int years, int month, int day,
       int hour, int minute, int second, int millisecond,
       bool isUtc) {
-    // Simplify calculations by working with zero-based month.
-    --month;
-    // Deal with under and overflow.
-    year += (month / 12).floor().toInt();
-    month = month % 12;
+    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;
 
     // 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(year) ? 1 : 0][month];
-    days += _dayFromYear(year);
+    days += _DAYS_UNTIL_MONTH[_isLeapYear(years) ? 1 : 0][month - 1];
+    days += _dayFromYear(years);
     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 111 matching lines @@
 
   static String _timeZoneNameForClampedSeconds(int secondsSinceEpoch)
       native "DateNatives_timeZoneName";
 
   static int _timeZoneOffsetInSecondsForClampedSeconds(int secondsSinceEpoch)
       native "DateNatives_timeZoneOffsetInSeconds";
 
   static int _localTimeZoneAdjustmentInSeconds()
       native "DateNatives_localTimeZoneAdjustmentInSeconds";
 }