anchor.diff:  
     static int _localTimeZoneAdjustmentInSeconds()
         native "DateNatives_localTimeZoneAdjustmentInSeconds";
  +
  +  static const _MILLISECOND_INDEX = 0;
  +  static const _SECOND_INDEX = 1;
  +  static const _MINUTE_INDEX = 2;
  +  static const _HOUR_INDEX = 3;
  +  static const _DAY_INDEX = 4;
  +  static const _WEEKDAY_INDEX = 5;
  +  static const _MONTH_INDEX = 6;
  +  static const _YEAR_INDEX = 7;
  +
  +  List __parts;
   
     /* patch */ DateTime._internal(int year,
                                    int month,
  
positive.code:     return new Duration(seconds: offsetInSeconds);
    }
  
    /* patch */ int get year => _decomposeIntoYearMonthDay(_localDateInUtcMs)[0];
  
    /* patch */ int get month => _decomposeIntoYearMonthDay(_localDateInUtcMs)[1];
  
    /* patch */ int get day => _decomposeIntoYearMonthDay(_localDateInUtcMs)[2];
  
    /* patch */ int get hour {
      int valueInHours = _flooredDivision(_localDateInUtcMs,
                                          Duration.MILLISECONDS_PER_HOUR);
      return valueInHours % Duration.HOURS_PER_DAY;
    }
  
    /* patch */ int get minute {
      int valueInMinutes = _flooredDivision(_localDateInUtcMs,
                                            Duration.MILLISECONDS_PER_MINUTE);
      return valueInMinutes % Duration.MINUTES_PER_HOUR;
    }
  
    /* patch */ int get second {
      // Seconds are unaffected by the timezone the user is in. So we can
      // directly use the millisecondsSinceEpoch and not [_localDateInUtcMs].
      int valueInSeconds =
          _flooredDivision(millisecondsSinceEpoch,
                           Duration.MILLISECONDS_PER_SECOND);
      return valueInSeconds % Duration.SECONDS_PER_MINUTE;
    }
  
    /* patch */ int get millisecond {
      // Milliseconds are unaffected by the timezone the user is in. So we can
      // directly use the value and not the [_localDateInUtcValue].
      return millisecondsSinceEpoch % Duration.MILLISECONDS_PER_SECOND;
    }
  
    /** Returns the weekday of [this]. In accordance with ISO 8601 a week
      * starts with Monday. Monday has the value 1 up to Sunday with 7. */
    /* patch */ int get weekday {
      int daysSince1970 =
          _flooredDivision(_localDateInUtcMs, Duration.MILLISECONDS_PER_DAY);
      // 1970-1-1 was a Thursday.
      return ((daysSince1970 + DateTime.THURSDAY - DateTime.MONDAY)
              % DateTime.DAYS_PER_WEEK) +
          DateTime.MONDAY;
    }
  
  
    /** The first list contains the days until each month in non-leap years. The
      * second list contains the days in leap years. */
    static const 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]];
  
    // 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;
  
negative.code:     int resultDay = 0;
  
      // Always round down.
      final int daysSince1970 = _flooredDivision(localMs,
                                                 Duration.MILLISECONDS_PER_DAY);
      int days = daysSince1970;
      days += DAYS_OFFSET;
      resultYear = 400 * (days ~/ DAYS_IN_400_YEARS) - YEARS_OFFSET;
      days = days.remainder(DAYS_IN_400_YEARS);
  