anchor.diff:        int years, int month, int day, int hours, int minutes, int seconds,
         bool isUtc) native "DateNatives_brokenDownToSecondsSinceEpoch";
   
  -  static int getCurrentMs_() native "DateNatives_currentTimeMillis";
  +  static int _getCurrentMs() native "DateNatives_currentTimeMillis";
   
     // TODO(floitsch): it would be more efficient if we didn't call the native
     // function for every member, but cached the broken-down date.
  -  static int getYear_(int secondsSinceEpoch, bool isUtc)
  +  static int _getYear(int secondsSinceEpoch, bool isUtc)
         native "DateNatives_getYear";
   
  -  static int getMonth_(int secondsSinceEpoch, bool isUtc)
  +  static int _getMonth(int secondsSinceEpoch, bool isUtc)
         native "DateNatives_getMonth";
   
  -  static int getDay_(int secondsSinceEpoch, bool isUtc)
  +  static int _getDay(int secondsSinceEpoch, bool isUtc)
         native "DateNatives_getDay";
   
  -  static int getHours_(int secondsSinceEpoch, bool isUtc)
  +  static int _getHours(int secondsSinceEpoch, bool isUtc)
         native "DateNatives_getHours";
   
  -  static int getMinutes_(int secondsSinceEpoch, bool isUtc)
  +  static int _getMinutes(int secondsSinceEpoch, bool isUtc)
         native "DateNatives_getMinutes";
   
  -  static int getSeconds_(int secondsSinceEpoch, bool isUtc)
  +  static int _getSeconds(int secondsSinceEpoch, bool isUtc)
         native "DateNatives_getSeconds";
   }
  
positive.code:   }
  
    // Given [secondsSinceEpoch] returns seconds such that they are at the same
    // time in an equivalent year (see [equivalentYear_]).
    // Leap seconds are ignored.
    static int equivalentSeconds_(int secondsSinceEpoch) {
      if (secondsSinceEpoch >= 0 && secondsSinceEpoch < SECONDS_YEAR_2035_) {
        return secondsSinceEpoch;
      }
      int year = yearsFromSecondsSinceEpoch_(secondsSinceEpoch);
      int days = dayFromYear_(year);
      int equivalentYear = equivalentYear_(year);
      int equivalentDays = dayFromYear_(equivalentYear);
      int diffDays = equivalentDays - days;
      return secondsSinceEpoch + diffDays * Duration.SECONDS_PER_DAY;
    }
  
    // Returns the days since 1970 for the start of the given [year].
    // [year] may be before epoch.
    static int dayFromYear_(int year) {
      int flooredDivision(int a, int b) {
        return (a - (a < 0 ? b - 1 : 0)) ~/ b;
      }
  
negative.code:   }
  
    int get year() {
      int secondsSinceEpoch = _secondsSinceEpoch;
      // According to V8 some library calls have troubles with negative values.
      // Therefore clamp to 0 - year 2035 (which is less than the size of 32bit).
      if (secondsSinceEpoch >= 0 && secondsSinceEpoch < _SECONDS_YEAR_2035) {
        return _getYear(secondsSinceEpoch, timeZone.isUtc);
      }
  
      // Approximate the result. We don't take timeZone into account.
      int approximateYear = _yearsFromSecondsSinceEpoch(secondsSinceEpoch);
      int equivalentYear = _equivalentYear(approximateYear);
      int y = _getYear(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
      return approximateYear + (y - equivalentYear);
    }
  
    int get month() {
      return _getMonth(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
    }
  
    int get day() {
      return _getDay(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
    }
  
    int get hours() {
      return _getHours(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
    }
  
    int get minutes() {
      return _getMinutes(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
    }
  
    int get seconds() {
      return _getSeconds(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
    }
  
    int get milliseconds() {
      return value % Duration.MILLISECONDS_PER_SECOND;
    }
  
    int get _secondsSinceEpoch() {
      // Always round down.
      if (value < 0) {
        return (value + 1) ~/ Duration.MILLISECONDS_PER_SECOND - 1;
  