anchor.diff:    }
   }
   
  -class _HashMapKeyIterator<K> extends _HashMapIterator<K> {
  -  _HashMapKeyIterator(HashMap map) : super(map);
  -  K get current {
  -    _HashMapEntry entry = _entry;
  -    return (entry == null) ? null : entry.key;
  -  }
  -}
  -
  -class _HashMapValueIterator<V> extends _HashMapIterator<V> {
  -  _HashMapValueIterator(HashMap map) : super(map);
  -  V get current {
  -    _HashMapEntry entry = _entry;
  -    return (entry == null) ? null : entry.value;
  -  }
  +class _HashMapKeyIterator<K, V> extends _HashMapIterator<K, V, K> {
  +  _HashMapKeyIterator(_HashMap<K, V> map) : super(map);
  +  K get current => _entry?.key;
  +}
  +
  +class _HashMapValueIterator<K, V> extends _HashMapIterator<K, V, V> {
  +  _HashMapValueIterator(_HashMap<K, V> map) : super(map);
  +  V get current => _entry?.value;
   }
   
   @patch
  
positive.code:   }
  
    V putIfAbsent(K key, V ifAbsent()) {
      int hashCode = key.hashCode;
      List buckets = _buckets;
      int length = buckets.length;
      int index = hashCode & (length - 1);
      _HashMapEntry entry = buckets[index];
      while (entry != null) {
        if (hashCode == entry.hashCode && entry.key == key) {
          return entry.value;
        }
        entry = entry.next;
  
negative.code:   }
  
    void operator []=(K key, V value) {
      final hashCode = key.hashCode;
      final buckets = _buckets;
      final length = buckets.length;
      final index = hashCode & (length - 1);
      var entry = buckets[index];
      while (entry != null) {
        if (hashCode == entry.hashCode && entry.key == key) {
          entry.value = value;
  