Migrate date.dart from old suffix_ to _prefix privacy.

runtime/lib/date.dart

 // Copyright (c) 2011, 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.
 
 class TimeZoneImplementation implements TimeZone {
   const TimeZoneImplementation.utc() : isUtc = true;
   TimeZoneImplementation.local() : isUtc = false {}
 
   bool operator ==(Object other) {
@@ skipping 29 matching lines @@
                                   TimeZone timeZone)
   : timeZone = timeZone,
     value = _brokenDownDateToMillisecondsSinceEpoch(
                years, month, day, hours, minutes, seconds, milliseconds,
                timeZone.isUtc) {
     if (value === null) throw new IllegalArgumentException();
   }
 
   DateImplementation.now()
   : timeZone = new TimeZone.local(),
-    value = getCurrentMs_() {
+    value = _getCurrentMs() {
   }
 
   factory DateImplementation.fromString(String formattedString) {
     // Read in (a subset of) ISO 8601.
     // Examples:
     //    - "2012-02-27 13:27:00"
     //    - "2012-02-27 13:27:00.423z"
     //    - "20120227 13:27:00"
     //    - "20120227T132700"
     //    - "20120227"
@@ skipping 63 matching lines @@
   int hashCode() => value;
 
   Date changeTimeZone(TimeZone targetTimeZone) {
     if (targetTimeZone === null) {
       targetTimeZone = new TimeZoneImplementation.local();
     }
     return new Date.fromEpoch(value, targetTimeZone);
   }
 
   int get year() {
-    int secondsSinceEpoch = secondsSinceEpoch_;
+    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);
+    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);
+    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);
+    return _getMonth(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
   }
 
   int get day() {
-    return getDay_(equivalentSeconds_(secondsSinceEpoch_), timeZone.isUtc);
+    return _getDay(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
   }
 
   int get hours() {
-    return getHours_(equivalentSeconds_(secondsSinceEpoch_), timeZone.isUtc);
+    return _getHours(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
   }
 
   int get minutes() {
-    return getMinutes_(equivalentSeconds_(secondsSinceEpoch_), timeZone.isUtc);
+    return _getMinutes(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
   }
 
   int get seconds() {
-    return getSeconds_(equivalentSeconds_(secondsSinceEpoch_), timeZone.isUtc);
+    return _getSeconds(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
   }
 
   int get milliseconds() {
     return value % Duration.MILLISECONDS_PER_SECOND;
   }
 
-  int get secondsSinceEpoch_() {
+  int get _secondsSinceEpoch() {
     // Always round down.
     if (value < 0) {
       return (value + 1) ~/ Duration.MILLISECONDS_PER_SECOND - 1;
     } else {
       return value ~/ Duration.MILLISECONDS_PER_SECOND;
     }
   }
 
   int get weekday() {
     final Date unixTimeStart =
@@ skipping 69 matching lines @@
   }
 
   // Returns a [Duration] with the difference of [this] and [other].
   Duration difference(Date other) {
     return new DurationImplementation(milliseconds: value - other.value);
   }
 
   final int value;
   final TimeZoneImplementation timeZone;
 
-  static final int SECONDS_YEAR_2035_ = 2051222400;
+  static final int _SECONDS_YEAR_2035 = 2051222400;
 
   // Returns the UTC year for the corresponding [secondsSinceEpoch].
   // It is relatively fast for values in the range 0 to year 2098.
   // Code is adapted from V8.
-  static int yearsFromSecondsSinceEpoch_(int secondsSinceEpoch) {
+  static int _yearsFromSecondsSinceEpoch(int secondsSinceEpoch) {
     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;
     final int DAYS_1970_TO_2000 = 30 * 365 + 7;
     final int DAYS_OFFSET = 1000 * DAYS_IN_400_YEARS + 5 * DAYS_IN_400_YEARS -
                             DAYS_1970_TO_2000;
     final int YEARS_OFFSET = 400000;
     final int DAYS_YEAR_2098 = DAYS_IN_100_YEARS + 6 * DAYS_IN_4_YEARS;
 
     int days = secondsSinceEpoch ~/ Duration.SECONDS_PER_DAY;
@@ skipping 14 matching lines @@
       result += 4 * yd2;
       days--;
       int yd3 = days ~/ 365;
       days = days.remainder(365);
       result += yd3;
       return result;
     }
   }
 
   // Given [secondsSinceEpoch] returns seconds such that they are at the same
-  // time in an equivalent year (see [equivalentYear_]).
+  // time in an equivalent year (see [_equivalentYear]).
   // Leap seconds are ignored.
-  static int equivalentSeconds_(int secondsSinceEpoch) {
-    if (secondsSinceEpoch >= 0 && secondsSinceEpoch < SECONDS_YEAR_2035_) {
+  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 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) {
+  static int _dayFromYear(int year) {
     int flooredDivision(int a, int b) {
       return (a - (a < 0 ? b - 1 : 0)) ~/ b;
     }
 
     return 365 * (year - 1970)
             + flooredDivision(year - 1969, 4)
             - flooredDivision(year - 1901, 100)
             + flooredDivision(year - 1601, 400);
   }
 
   // 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 _equivalentYear(int year) {
     // Returns 1 if in leap year. 0 otherwise.
     bool inLeapYear(year) {
       return (year.remainder(4) == 0) &&
              ((year.remainder(100) != 0) || (year.remainder(400) == 0));
     }
 
     // Returns the week day (in range 0 - 6).
     int weekDay(year) {
       // 1/1/1970 was a Thursday.
-      return (dayFromYear_(year) + 4) % 7;
+      return (_dayFromYear(year) + 4) % 7;
     }
     // 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 18 matching lines @@
     if ((milliseconds < 0) || (milliseconds > 999)) return null;
 
     int equivalentYear;
     int offsetInSeconds;
     // According to V8 some library calls have troubles with negative values.
     // Therefore clamp to 1970 - year 2035 (which is less than the size of
     // 32bit).
     // We exclude the year 1970 when the time is not UTC, since the epoch
     // value could then be negative.
     if (years < (isUtc ? 1970 : 1971) || years > 2035) {
-      equivalentYear = equivalentYear_(years);
-      int offsetInDays = (dayFromYear_(years) - dayFromYear_(equivalentYear));
+      equivalentYear = _equivalentYear(years);
+      int offsetInDays = (_dayFromYear(years) - _dayFromYear(equivalentYear));
       // Leap seconds are ignored.
       offsetInSeconds = offsetInDays * Duration.SECONDS_PER_DAY;
     } else {
       equivalentYear = years;
       offsetInSeconds = 0;
     }
     int secondsSinceEpoch = _brokenDownDateToSecondsSinceEpoch(
         equivalentYear, month, day, hours, minutes, seconds, isUtc);
     int adjustedSeconds = secondsSinceEpoch + offsetInSeconds;
     return adjustedSeconds * Duration.MILLISECONDS_PER_SECOND + milliseconds;
   }
 
   // Natives
   static _brokenDownDateToSecondsSinceEpoch(
       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";
 }