VM: Use const instead of final for constants in runtime libraries.

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 49 matching lines @@
     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;
-    final int DAYS_1970_TO_2000 = 30 * 365 + 7;
-    final int DAYS_OFFSET = 1000 * DAYS_IN_400_YEARS + 5 * DAYS_IN_400_YEARS -
+    const int DAYS_IN_4_YEARS = 4 * 365 + 1;
+    const int DAYS_IN_100_YEARS = 25 * DAYS_IN_4_YEARS - 1;
+    const int DAYS_IN_400_YEARS = 4 * DAYS_IN_100_YEARS + 1;
+    const int DAYS_1970_TO_2000 = 30 * 365 + 7;
+    const int DAYS_OFFSET = 1000 * DAYS_IN_400_YEARS + 5 * DAYS_IN_400_YEARS -
                             DAYS_1970_TO_2000;
-    final int YEARS_OFFSET = 400000;
+    const int YEARS_OFFSET = 400000;
 
     int resultYear = 0;
     int resultMonth = 0;
     int resultDay = 0;
 
     // Always round down.
     final int daysSince1970 = _flooredDivision(localMs,
                                                Duration.MILLISECONDS_PER_DAY);
     int days = daysSince1970;
     days += DAYS_OFFSET;
@@ skipping 201 matching lines @@
     return 2008 + (recentYear - 2008) % 28;
   }
 
   /**
    * 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) {
-    final int DAYS_IN_4_YEARS = 4 * 365 + 1;
-    final int DAYS_IN_100_YEARS = 25 * DAYS_IN_4_YEARS - 1;
-    final int DAYS_YEAR_2098 = DAYS_IN_100_YEARS + 6 * DAYS_IN_4_YEARS;
+    const int DAYS_IN_4_YEARS = 4 * 365 + 1;
+    const int DAYS_IN_100_YEARS = 25 * DAYS_IN_4_YEARS - 1;
+    const int DAYS_YEAR_2098 = DAYS_IN_100_YEARS + 6 * DAYS_IN_4_YEARS;
 
     int days = secondsSinceEpoch ~/ Duration.SECONDS_PER_DAY;
     if (days > 0 && days < DAYS_YEAR_2098) {
       // According to V8 this fast case works for dates from 1970 to 2099.
       return 1970 + (4 * days + 2) ~/ DAYS_IN_4_YEARS;
     }
     int ms = secondsSinceEpoch * Duration.MILLISECONDS_PER_SECOND;
     return _computeUpperPart(ms)[_YEAR_INDEX];
   }
 
   /**
    * Returns a date in seconds that is equivalent to the current date. An
    * equivalent date has the same fields ([:month:], [:day:], etc.) as the
    * [this], but the [:year:] is in the range [1970..2037].
    *
    * * The time since the beginning of the year is the same.
    * * If [this] is in a leap year then the returned seconds are in a leap
    *   year, too.
    * * The week day of [this] is the same as the one for the returned date.
    */
   static int _equivalentSeconds(int millisecondsSinceEpoch) {
-    final int CUT_OFF_SECONDS = 2100000000;
+    const int CUT_OFF_SECONDS = 2100000000;
 
     int secondsSinceEpoch = _flooredDivision(millisecondsSinceEpoch,
                                              Duration.MILLISECONDS_PER_SECOND);
 
     if (secondsSinceEpoch < 0 || secondsSinceEpoch >= CUT_OFF_SECONDS) {
       int year = _yearsFromSecondsSinceEpoch(secondsSinceEpoch);
       int days = _dayFromYear(year);
       int equivalentYear = _equivalentYear(year);
       int equivalentDays = _dayFromYear(equivalentYear);
       int diffDays = equivalentDays - days;
       secondsSinceEpoch += diffDays * Duration.SECONDS_PER_DAY;
     }
     return secondsSinceEpoch;
   }
 
   static int _timeZoneOffsetInSeconds(int millisecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(millisecondsSinceEpoch);
     return _timeZoneOffsetInSecondsForClampedSeconds(equivalentSeconds);
   }
 
   static String _timeZoneName(int millisecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(millisecondsSinceEpoch);
     return _timeZoneNameForClampedSeconds(equivalentSeconds);
   }
 }