anchor.diff:  
     bool contains(Object object) {
       int index = _hashCode(object) & (_buckets.length - 1);
  -    _HashSetEntry entry = _buckets[index];
  +    _HashSetEntry<E> entry = _buckets[index];
       while (entry != null) {
         if (_equals(entry.key, object)) return true;
         entry = entry.next;
  
positive.code:   Set<K> _newKeySet() => new _IdentityHashSet<K>();
  }
  
  class _HashMapEntry {
    final key;
    var value;
    final int hashCode;
    _HashMapEntry next;
    _HashMapEntry(this.key, this.value, this.hashCode, this.next);
  }
  
  abstract class _HashMapIterable<E> extends internal.EfficientLengthIterable<E> {
    final HashMap _map;
    _HashMapIterable(this._map);
    int get length => _map.length;
    bool get isEmpty => _map.isEmpty;
    bool get isNotEmpty => _map.isNotEmpty;
  }
  
  class _HashMapKeyIterable<K> extends _HashMapIterable<K> {
    _HashMapKeyIterable(HashMap map) : super(map);
    Iterator<K> get iterator => new _HashMapKeyIterator<K>(_map);
    bool contains(Object key) => _map.containsKey(key);
    void forEach(void action(K key)) {
      _map.forEach((K key, _) {
  
negative.code: 
  class _IdentityHashMap<K, V> extends _HashMap<K, V> {
    bool containsKey(Object key) {
      final hashCode = identityHashCode(key);
      final buckets = _buckets;
      final index = hashCode & (buckets.length - 1);
      var entry = buckets[index];
      while (entry != null) {
        if (hashCode == entry.hashCode && identical(entry.key, key)) return true;
        entry = entry.next;
  