Use metadata annotation @patch for patch classes

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 {
+@patch class DateTime {
   // Natives.
   // The natives have been moved up here to work around Issue 10401.
   static int _getCurrentMicros() native "DateTime_currentTimeMicros";
 
   static String _timeZoneNameForClampedSeconds(int secondsSinceEpoch)
       native "DateTime_timeZoneName";
 
   static int _timeZoneOffsetInSecondsForClampedSeconds(int secondsSinceEpoch)
       native "DateTime_timeZoneOffsetInSeconds";
 
   static int _localTimeZoneAdjustmentInSeconds()
       native "DateTime_localTimeZoneAdjustmentInSeconds";
 
   static const _MICROSECOND_INDEX = 0;
   static const _MILLISECOND_INDEX = 1;
   static const _SECOND_INDEX = 2;
   static const _MINUTE_INDEX = 3;
   static const _HOUR_INDEX = 4;
   static const _DAY_INDEX = 5;
   static const _WEEKDAY_INDEX = 6;
   static const _MONTH_INDEX = 7;
   static const _YEAR_INDEX = 8;
 
   List __parts;
 
-  /* patch */ DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
+  /* @patch */ DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
                                                   {bool isUtc: false})
       : this._withValue(
           millisecondsSinceEpoch * Duration.MICROSECONDS_PER_MILLISECOND,
           isUtc: isUtc);
 
-  /* patch */ DateTime.fromMicrosecondsSinceEpoch(int microsecondsSinceEpoch,
+  /* @patch */ DateTime.fromMicrosecondsSinceEpoch(int microsecondsSinceEpoch,
                                                   {bool isUtc: false})
       : this._withValue(microsecondsSinceEpoch, isUtc: isUtc);
 
-  /* patch */ DateTime._internal(int year,
+  /* @patch */ DateTime._internal(int year,
                                  int month,
                                  int day,
                                  int hour,
                                  int minute,
                                  int second,
                                  int millisecond,
                                  int microsecond,
                                  bool isUtc)
       : this.isUtc = isUtc,
         this._value = _brokenDownDateToValue(
             year, month, day, hour, minute, second, millisecond, microsecond,
             isUtc) {
     if (_value == null) throw new ArgumentError();
     if (isUtc == null) throw new ArgumentError();
   }
 
-  /* patch */ DateTime._now()
+  /* @patch */ DateTime._now()
       : isUtc = false,
         _value = _getCurrentMicros() {
   }
 
-  /* patch */ String get timeZoneName {
+  /* @patch */ String get timeZoneName {
     if (isUtc) return "UTC";
     return _timeZoneName(microsecondsSinceEpoch);
   }
 
-  /* patch */ Duration get timeZoneOffset {
+  /* @patch */ Duration get timeZoneOffset {
     if (isUtc) return new Duration();
     int offsetInSeconds = _timeZoneOffsetInSeconds(microsecondsSinceEpoch);
     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]];
@@ skipping 77 matching lines @@
     return list;
   }
 
   get _parts {
     if (__parts == null) {
       __parts = _computeUpperPart(_localDateInUtcMicros);
     }
     return __parts;
   }
 
-  /* patch */ DateTime add(Duration duration) {
+  /* @patch */ DateTime add(Duration duration) {
     return new DateTime._withValue(
         _value + duration.inMicroseconds, isUtc: isUtc);
   }
 
-  /* patch */ DateTime subtract(Duration duration) {
+  /* @patch */ DateTime subtract(Duration duration) {
     return new DateTime._withValue(
         _value - duration.inMicroseconds, isUtc: isUtc);
   }
 
-  /* patch */ Duration difference(DateTime other) {
+  /* @patch */ Duration difference(DateTime other) {
     return new Duration(microseconds: _value - other._value);
   }
 
-  /* patch */ int get millisecondsSinceEpoch =>
+  /* @patch */ int get millisecondsSinceEpoch =>
       _value ~/ Duration.MICROSECONDS_PER_MILLISECOND;
 
-  /* patch */ int get microsecondsSinceEpoch => _value;
+  /* @patch */ int get microsecondsSinceEpoch => _value;
 
-  /* patch */ int get microsecond => _parts[_MICROSECOND_INDEX];
+  /* @patch */ int get microsecond => _parts[_MICROSECOND_INDEX];
 
-  /* patch */ int get millisecond => _parts[_MILLISECOND_INDEX];
+  /* @patch */ int get millisecond => _parts[_MILLISECOND_INDEX];
 
-  /* patch */ int get second => _parts[_SECOND_INDEX];
+  /* @patch */ int get second => _parts[_SECOND_INDEX];
 
-  /* patch */ int get minute => _parts[_MINUTE_INDEX];
+  /* @patch */ int get minute => _parts[_MINUTE_INDEX];
 
-  /* patch */ int get hour => _parts[_HOUR_INDEX];
+  /* @patch */ int get hour => _parts[_HOUR_INDEX];
 
-  /* patch */ int get day => _parts[_DAY_INDEX];
+  /* @patch */ int get day => _parts[_DAY_INDEX];
 
-  /* patch */ int get weekday => _parts[_WEEKDAY_INDEX];
+  /* @patch */ int get weekday => _parts[_WEEKDAY_INDEX];
 
-  /* patch */ int get month => _parts[_MONTH_INDEX];
+  /* @patch */ int get month => _parts[_MONTH_INDEX];
 
-  /* patch */ int get year => _parts[_YEAR_INDEX];
+  /* @patch */ int get year => _parts[_YEAR_INDEX];
 
   /**
    * Returns the amount of microseconds in UTC that represent the same values
    * as [this].
    *
    * Say `t` is the result of this function, then
    * * `this.year == new DateTime.fromMicrosecondsSinceEpoch(t, true).year`,
    * * `this.month == new DateTime.fromMicrosecondsSinceEpoch(t, true).month`,
    * * `this.day == new DateTime.fromMicrosecondsSinceEpoch(t, true).day`,
    * * `this.hour == new DateTime.fromMicrosecondsSinceEpoch(t, true).hour`,
@@ skipping 23 matching lines @@
             - _flooredDivision(year - 1901, 100)
             + _flooredDivision(year - 1601, 400);
   }
 
   static bool _isLeapYear(y) {
     // (y % 16 == 0) matches multiples of 400, and is faster than % 400.
     return (y % 4 == 0) && ((y % 16 == 0) || (y % 100 != 0));
   }
 
   /// Converts the given broken down date to microseconds.
-  /* patch */ static int _brokenDownDateToValue(
+  /* @patch */ static int _brokenDownDateToValue(
       int year, int month, int day,
       int hour, int minute, int second, int millisecond, int microsecond,
       bool isUtc) {
     // Simplify calculations by working with zero-based month.
     --month;
     // Deal with under and overflow.
     if (month >= 12) {
       year += month ~/ 12;
       month = month % 12;
     } else if (month < 0) {
@@ skipping 136 matching lines @@
   static int _timeZoneOffsetInSeconds(int microsecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(microsecondsSinceEpoch);
     return _timeZoneOffsetInSecondsForClampedSeconds(equivalentSeconds);
   }
 
   static String _timeZoneName(int microsecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(microsecondsSinceEpoch);
     return _timeZoneNameForClampedSeconds(equivalentSeconds);
   }
 }