Fix core lib DateTime in the VM.

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 DateTime.
 patch class DateTime {
   // Natives.
   // The natives have been moved up here to work around Issue 10401.
   static int _getCurrentMicros() native "DateTime_currentTimeMicros";
@@ skipping 266 matching lines @@
     // 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
     // margin of one day should be enough.
     if (microsecondsSinceEpoch.abs() >
         _MAX_MILLISECONDS_SINCE_EPOCH * 1000 + Duration.MICROSECONDS_PER_DAY) {
       return null;
     }
 
     if (!isUtc) {
-      // Note that we need to remove the local timezone adjustement before
+      // Note that we need to remove the local timezone adjustment before
       // asking for the correct zone offset.
       int adjustment = _localTimeZoneAdjustmentInSeconds() *
           Duration.MICROSECONDS_PER_SECOND;
+      // The adjustment is independent of the actual date and of the daylight
+      // saving time. It is positive east of the Prime Meridian and negative
+      // west of it, e.g. -28800 sec for America/Los_Angeles timezone.
 
       int zoneOffset =
           _timeZoneOffsetInSeconds(microsecondsSinceEpoch - adjustment);
+      // The zoneOffset depends on the actual date and reflects any daylight
+      // saving time and/or historical deviation relative to UTC time.
+      // It is positive east of the Prime Meridian and negative west of it,
+      // e.g. -25200 sec for America/Los_Angeles timezone during DST.
       microsecondsSinceEpoch -= zoneOffset * Duration.MICROSECONDS_PER_SECOND;
+      // The resulting microsecondsSinceEpoch value is therefore the calculated
+      // UTC value decreased by a (positive if east of GMT) timezone adjustment
+      // and decreased by typically one hour if DST is in effect.
     }
     if (microsecondsSinceEpoch.abs() >
         _MAX_MILLISECONDS_SINCE_EPOCH * Duration.MICROSECONDS_PER_MILLISECOND) {
       return null;
     }
     return microsecondsSinceEpoch;
   }
 
   static int _weekDay(y) {
     // 1/1/1970 was a Thursday.
     return (_dayFromYear(y) + 4) % 7;
   }
 
   /**
    * Returns a year in the range 2008-2035 matching
    * * leap year, and
    * * week day of first day.
    *
    * Leap seconds are ignored.
    * Adapted from V8's date implementation. See ECMA 262 - 15.9.1.9.
    */
   static int _equivalentYear(int year) {
-    // Returns the week day (in range 0 - 6).
+    // Returns year y so that _weekDay(y) == _weekDay(year).
+    // _weekDay returns the week day (in range 0 - 6).
     // 1/1/1956 was a Sunday (i.e. weekday 0). 1956 was a leap-year.
     // 1/1/1967 was a Sunday (i.e. weekday 0).
     // Without leap years a subsequent year has a week day + 1 (for example
     // 1/1/1968 was a Monday). With leap-years it jumps over one week day
     // (e.g. 1/1/1957 was a Tuesday).
     // After 12 years the weekdays have advanced by 12 days + 3 leap days =
     // 15 days. 15 % 7 = 1. So after 12 years the week day has always
     // (now independently of leap-years) advanced by one.
     // weekDay * 12 gives thus a year starting with the wanted weekDay.
     int recentYear = (_isLeapYear(year) ? 1956 : 1967) + (_weekDay(year) * 12);
@@ skipping 17 matching lines @@
     int days = secondsSinceEpoch ~/ Duration.SECONDS_PER_DAY;
     if (days > 0 && days < DAYS_YEAR_2098) {
       // According to V8 this fast case works for dates from 1970 to 2099.
       return 1970 + (4 * days + 2) ~/ DAYS_IN_4_YEARS;
     }
     int micros = secondsSinceEpoch * Duration.MICROSECONDS_PER_SECOND;
     return _computeUpperPart(micros)[_YEAR_INDEX];
   }
 
   /**
-   * Returns a date in seconds that is equivalent to the current date. An
-   * equivalent date has the same fields (`month`, `day`, etc.) as the
-   * [this], but the `year` is in the range [1970..2037].
+   * Returns a date in seconds that is equivalent to the given
+   * date in microseconds [microsecondsSinceEpoch]. An equivalent
+   * date has the same fields (`month`, `day`, etc.) as the given
+   * date, but the `year` is in the range [1901..2038].
    *
    * * The time since the beginning of the year is the same.
-   * * If [this] is in a leap year then the returned seconds are in a leap
-   *   year, too.
-   * * The week day of [this] is the same as the one for the returned date.
+   * * If the given date is in a leap year then the returned
+   *   seconds are in a leap year, too.
+   * * The week day of given date is the same as the one for the
+   *   returned date.
    */
   static int _equivalentSeconds(int microsecondsSinceEpoch) {
-    const int CUT_OFF_SECONDS = 2100000000;
+    const int CUT_OFF_SECONDS = 0x7FFFFFFF;
 
     int secondsSinceEpoch = _flooredDivision(microsecondsSinceEpoch,
                                              Duration.MICROSECONDS_PER_SECOND);
 
-    if (secondsSinceEpoch < 0 || secondsSinceEpoch >= CUT_OFF_SECONDS) {
+    if (secondsSinceEpoch.abs() > CUT_OFF_SECONDS) {
       int year = _yearsFromSecondsSinceEpoch(secondsSinceEpoch);
       int days = _dayFromYear(year);
       int equivalentYear = _equivalentYear(year);
       int equivalentDays = _dayFromYear(equivalentYear);
       int diffDays = equivalentDays - days;
       secondsSinceEpoch += diffDays * Duration.SECONDS_PER_DAY;
     }
     return secondsSinceEpoch;
   }
 
   static int _timeZoneOffsetInSeconds(int microsecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(microsecondsSinceEpoch);
     return _timeZoneOffsetInSecondsForClampedSeconds(equivalentSeconds);
   }
 
   static String _timeZoneName(int microsecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(microsecondsSinceEpoch);
     return _timeZoneNameForClampedSeconds(equivalentSeconds);
   }
 }