Implement @patch annotation for patch class members

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),
+  @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>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 
-  /* patch */ factory HashMap.identity() = _IdentityHashMap<K, V>;
+  @patch factory HashMap.identity() = _IdentityHashMap<K, V>;
 
   Set<K> _newKeySet();
 }
 
 
 const int _MODIFICATION_COUNT_MASK = 0x3fffffff;
 
 class _HashMap<K, V> implements HashMap<K, V> {
   static const int _INITIAL_CAPACITY = 8;
 
@@ skipping 466 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 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 341 matching lines @@
  */
 @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),
+  @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),
+  @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>;
 }