anchor.diff:        // Do nothing.
       }
       resultDay = days - daysUntilMonth[resultMonth - 1] + 1;
  -    return <int>[resultYear, resultMonth, resultDay];
  -  }
  +
  +    int resultMillisecond = localMs % Duration.MILLISECONDS_PER_SECOND;
  +    int resultSecond =
  +        _flooredDivision(localMs, Duration.MILLISECONDS_PER_SECOND) %
  +            Duration.SECONDS_PER_MINUTE;
  +
  +    int resultMinute = _flooredDivision(localMs,
  +                                        Duration.MILLISECONDS_PER_MINUTE);
  +    resultMinute %= Duration.MINUTES_PER_HOUR;
  +
  +    int resultHour = _flooredDivision(localMs, Duration.MILLISECONDS_PER_HOUR);
  +    resultHour %= Duration.HOURS_PER_DAY;
  +
  +    // In accordance with ISO 8601 a week
  +    // starts with Monday. Monday has the value 1 up to Sunday with 7.
  +    // 1970-1-1 was a Thursday.
  +    int resultWeekday = ((daysSince1970 + DateTime.THURSDAY - DateTime.MONDAY) %
  +          DateTime.DAYS_PER_WEEK) + DateTime.MONDAY;
  +
  +    List list = new List(_YEAR_INDEX + 1);
  +    list[_MILLISECOND_INDEX] = resultMillisecond;
  +    list[_SECOND_INDEX] = resultSecond;
  +    list[_MINUTE_INDEX] = resultMinute;
  +    list[_HOUR_INDEX] = resultHour;
  +    list[_DAY_INDEX] = resultDay;
  +    list[_WEEKDAY_INDEX] = resultWeekday;
  +    list[_MONTH_INDEX] = resultMonth;
  +    list[_YEAR_INDEX] = resultYear;
  +    return list;
  +  }
  +
  +  get _parts {
  +    if (__parts == null) {
  +      __parts = _computeUpperPart(_localDateInUtcMs);
  +    }
  +    return __parts;
  +  }
  +
  +  /* patch */ int get millisecond => _parts[_MILLISECOND_INDEX];
  +
  +  /* patch */ int get second => _parts[_SECOND_INDEX];
  +
  +  /* patch */ int get minute => _parts[_MINUTE_INDEX];
  +
  +  /* patch */ int get hour => _parts[_HOUR_INDEX];
  +
  +  /* patch */ int get day => _parts[_DAY_INDEX];
  +
  +  /* patch */ int get weekday => _parts[_WEEKDAY_INDEX];
  +
  +  /* patch */ int get month => _parts[_MONTH_INDEX];
  +
  +  /* patch */ int get year => _parts[_YEAR_INDEX];
   
     /**
      * Returns the amount of milliseconds in UTC that represent the same values
  
positive.code:     int resultDay = 0;
  
      // Always round down.
      int days = _flooredDivision(millisecondsSinceEpoch,
                                  Duration.MILLISECONDS_PER_DAY);
      days += DAYS_OFFSET;
      resultYear = 400 * (days ~/ DAYS_IN_400_YEARS) - YEARS_OFFSET;
      days = days.remainder(DAYS_IN_400_YEARS);
  
negative.code:     return new Duration(seconds: offsetInSeconds);
    }
  
    /** 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]];
  
    static List _computeUpperPart(int localMs) {
      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;
  