Use metadata annotation @patch for patch classes

runtime/lib/collection_patch.dart

 // Copyright (c) 2013, 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.
 
-patch class HashMap<K, V> {
-  /* patch */ factory HashMap({ bool equals(K key1, K key2),
-                                int hashCode(K key),
-                                bool isValidKey(potentialKey) }) {
+@patch class HashMap<K, V> {
+  /* @patch */ factory HashMap({ bool equals(K key1, K key2),
+                                 int hashCode(K key),
+                                 bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _HashMap<K, V>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _IdentityHashMap<K, V>();
@@ skipping 492 matching lines @@
 }
 
 class _HashMapValueIterator<V> extends _HashMapIterator<V> {
   _HashMapValueIterator(HashMap map) : super(map);
   V get current {
     _HashMapEntry entry = _entry;
     return (entry == null) ? null : entry.value;
   }
 }
 
-patch class HashSet<E> {
-  /* patch */ factory HashSet({ bool equals(E e1, E e2),
-                                int hashCode(E e),
-                                bool isValidKey(potentialKey) }) {
+@patch class HashSet<E> {
+  /* @patch */ factory HashSet({ bool equals(E e1, E e2),
+                                 int hashCode(E e),
+                                 bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _HashSet<E>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _IdentityHashSet<E>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
-  /* patch */ factory HashSet.identity() = _IdentityHashSet<E>;
+  /* @patch */ factory HashSet.identity() = _IdentityHashSet<E>;
 }
 
 class _HashSet<E> extends _HashSetBase<E> implements HashSet<E> {
   static const int _INITIAL_CAPACITY = 8;
 
   List<_HashSetEntry> _buckets = new List(_INITIAL_CAPACITY);
   int _elementCount = 0;
   int _modificationCount = 0;
 
   bool _equals(e1, e2) => e1 == e2;
@@ skipping 332 matching lines @@
 
 class _LinkedHashMapValueIterator<V> extends _LinkedHashMapIterator<V> {
   _LinkedHashMapValueIterator(LinkedHashMap map) : super(map);
   V _getValue(_LinkedHashMapEntry entry) => entry.value;
 }
 
 
 /**
  * A hash-based map that iterates keys and values in key insertion order.
  */
-patch class LinkedHashMap<K, V> {
+@patch class LinkedHashMap<K, V> {
   /// Holds a double-linked list of entries in insertion order.
   /// The fields have the same name as the ones in [_LinkedHashMapEntry],
   /// and this map is itself used as the head entry of the list.
   /// Set to `this` when initialized, representing the empty list (containing
   /// only the head entry itself).
   var _nextEntry;
   var _previousEntry;
 
-  /* patch */ factory LinkedHashMap({ bool equals(K key1, K key2),
-                                      int hashCode(K key),
-                                      bool isValidKey(potentialKey) }) {
+  /* @patch */ factory LinkedHashMap({ bool equals(K key1, K key2),
+                                       int hashCode(K key),
+                                       bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _InternalLinkedHashMap<K, V>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _CompactLinkedIdentityHashMap<K, V>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CompactLinkedCustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 
-  /* patch */ factory LinkedHashMap.identity() =
+  /* @patch */ factory LinkedHashMap.identity() =
       _CompactLinkedIdentityHashMap<K, V>;
 }
 
-patch class LinkedHashSet<E> {
-  /* patch */ factory LinkedHashSet({ bool equals(E e1, E e2),
-                                      int hashCode(E e),
-                                      bool isValidKey(potentialKey) }) {
+@patch class LinkedHashSet<E> {
+  /* @patch */ factory LinkedHashSet({ bool equals(E e1, E e2),
+                                       int hashCode(E e),
+                                       bool isValidKey(potentialKey) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _CompactLinkedHashSet<E>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _CompactLinkedIdentityHashSet<E>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CompactLinkedCustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
-  /* patch */ factory LinkedHashSet.identity() =
+  /* @patch */ factory LinkedHashSet.identity() =
       _CompactLinkedIdentityHashSet<E>;
 }