Implement updated method overriding rules 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 _getCurrentMs() native "DateNatives_currentTimeMillis";
@@ skipping 172 matching lines @@
             + _flooredDivision(year - 1969, 4)
             - _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(
+  /* patch */ static int _brokenDownDateToMillisecondsSinceEpoch(
       int year, 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();
     month = month % 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(year) ? 1 : 0][month];
     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
     // margin of one day should be enough.
     if (millisecondsSinceEpoch.abs() >
         (_MAX_MILLISECONDS_SINCE_EPOCH + Duration.MILLISECONDS_PER_DAY)) {
       return null;

[siva, 2013/08/12 02:56:43]

should this now return 0 or -1 and not null?

[regis, 2013/08/12 17:45:27]

null is actually a valid value to return to indicate an error. I see the caller
checking for null in the core lib. 

     }
 
     if (!isUtc) {
       // Note that we need to remove the local timezone adjustement before
       // asking for the correct zone offset.
       int adjustment = _localTimeZoneAdjustmentInSeconds() *
           Duration.MILLISECONDS_PER_SECOND;
       int zoneOffset =
           _timeZoneOffsetInSeconds(millisecondsSinceEpoch - adjustment);
       millisecondsSinceEpoch -= zoneOffset * Duration.MILLISECONDS_PER_SECOND;
     }
     if (millisecondsSinceEpoch.abs() > _MAX_MILLISECONDS_SINCE_EPOCH) {
       return null;

[siva, 2013/08/12 02:56:43]

ditto comment here.

[regis, 2013/08/12 17:45:27]

ditto

     }
     return millisecondsSinceEpoch;
   }
 
   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 _equivalentYear(int year) {
+  static int _equivalentYear(int year) {
     // 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.
@@ skipping 54 matching lines @@
   static int _timeZoneOffsetInSeconds(int millisecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(millisecondsSinceEpoch);
     return _timeZoneOffsetInSecondsForClampedSeconds(equivalentSeconds);
   }
 
   static String _timeZoneName(int millisecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(millisecondsSinceEpoch);
     return _timeZoneNameForClampedSeconds(equivalentSeconds);
   }
 }