Update implementations to use Object.identityHashCode for identity map/set

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) }) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _HashMap<K, V>();
         }
-        if (identical(identical, equals)) {
+        hashCode = _defaultHashCode;
+      } else {
+        if (identical(identityHashCode, hashCode) &&
+            identical(identical, equals)) {
           return new _IdentityHashMap<K, V>();
         }
-        hashCode = _defaultHashCode;
-      } else if (equals == null) {
-        equals = _defaultEquals;
+        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>;
 }
 
+
 const int _MODIFICATION_COUNT_MASK = 0x3fffffff;
 
 class _HashMap<K, V> implements HashMap<K, V> {
   static const int _INITIAL_CAPACITY = 8;
 
 
   int _elementCount = 0;
   List<_HashMapEntry> _buckets = new List(_INITIAL_CAPACITY);
   int _modificationCount = 0;
 
@@ skipping 270 matching lines @@
     }
     return null;
   }
 
   String toString() => Maps.mapToString(this);
 }
 
 class _IdentityHashMap<K, V> extends _HashMap<K, V> {
 
   bool containsKey(Object key) {
-    int hashCode = key.hashCode;
+    int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) return true;
       entry = entry.next;
     }
     return false;
   }
 
   V operator[](Object key) {
-    int hashCode = key.hashCode;
+    int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) {
         return entry.value;
       }
       entry = entry.next;
     }
     return null;
   }
 
   void operator []=(K key, V value) {
-    int hashCode = key.hashCode;
+    int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int length = buckets.length;
     int index = hashCode & (length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) {
         entry.value = value;
         return;
       }
       entry = entry.next;
     }
     _addEntry(buckets, index, length, key, value, hashCode);
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
-    int hashCode = key.hashCode;
+    int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int length = buckets.length;
     int index = hashCode & (length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) {
         return entry.value;
       }
       entry = entry.next;
     }
     int stamp = _modificationCount;
     V value = ifAbsent();
     if (stamp == _modificationCount) {
       _addEntry(buckets, index, length, key, value, hashCode);
     } else {
       this[key] = value;
     }
     return value;
   }
 
   V remove(Object key) {
-    int hashCode = key.hashCode;
+    int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     _HashMapEntry previous = null;
     while (entry != null) {
       _HashMapEntry next = entry.next;
       if (hashCode == entry.hashCode && identical(entry.key, key)) {
         _removeEntry(entry, previous, index);
         _elementCount--;
         _modificationCount =
@@ skipping 104 matching lines @@
 
 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>();
         }
-        if (identical(identical, equals)) {
+        hashCode = _defaultHashCode;
+      } else {
+        if (identical(identityHashCode, hashCode) &&
+            identical(identical, equals)) {
           return new _IdentityHashSet<E>();
         }
-        _hashCode = _defaultHashCode;
-      } else if (equals == null) {
-        _equals = _defaultEquals;
+        if (equals == null) {
+          equals = _defaultEquals;
+        }
       }
-      isValidKey = new _TypeTest<E>().test;
     } else {
-      if (hashCode == null) hashCode = _defaultHashCode;
-      if (equals == null) equals = _defaultEquals;
+      if (hashCode == null) {
+        hashCode = _defaultHashCode;
+      }
+      if (equals == null) {
+        equals = _defaultEquals;
+      }
     }
     return new _CustomHashSet<E>(equals, hashCode, isValidKey);
   }
+
+  /* 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 145 matching lines @@
         entry = next;
       }
     }
     _buckets = newBuckets;
   }
 
   HashSet<E> _newSet() => new _HashSet<E>();
 }
 
 class _IdentityHashSet<E> extends _HashSet<E> {
+  int _hashCode(e) => identityHashCode(e);
   bool _equals(e1, e2) => identical(e1, e2);
   HashSet<E> _newSet() => new _IdentityHashSet<E>();
 }
 
 class _CustomHashSet<E> extends _HashSet<E> {
   final _Equality<E> _equality;
   final _Hasher<E> _hasher;
   final _Predicate _validKey;
-  _CustomHashSet(this._equality, this._hasher, this._validKey);
+  _CustomHashSet(this._equality, this._hasher, bool validKey(Object o))
+      : _validKey = (validKey != null) ? validKey : new _TypeTest<E>().test;
 
   bool remove(Object element) {
     if (!_validKey(element)) return false;
     return super.remove(element);
   }
 
   bool contains(Object element) {
     if (!_validKey(element)) return false;
     return super.contains(element);
   }
@@ skipping 160 matching lines @@
   var _previousEntry;
 
   /* 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 _LinkedHashMap<K, V>();
         }
-        if (identical(identical, equals)) {
+        hashCode = _defaultHashCode;
+      } else {
+        if (identical(identityHashCode, hashCode) &&
+            identical(identical, equals)) {
           return new _LinkedIdentityHashMap<K, V>();
         }
-        hashCode = _defaultHashCode;
-      } else if (equals == null) {
-        equals = _defaultEquals;
+        if (equals == null) {
+          equals = _defaultEquals;
+        }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _LinkedCustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
+
+  /* patch */ factory LinkedHashMap.identity() = _LinkedIdentityHashMap<K, V>;
 }
 
 // Methods that are exactly the same in all three linked hash map variants.
 abstract class _LinkedHashMapMixin<K, V> implements LinkedHashMap<K, V> {
   var _nextEntry;
   var _previousEntry;
 
 
   bool containsValue(Object value) {
     int modificationCount = _modificationCount;
@@ skipping 90 matching lines @@
 
 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 _LinkedHashSet<E>();
         }
-        if (identical(identical, equals)) {
+        hashCode = _defaultHashCode;
+      } else {
+        if (identical(identityHashCode, hashCode) &&
+            identical(identical, equals)) {
           return new _LinkedIdentityHashSet<E>();
         }
-        _hashCode = _defaultHashCode;
-      } else if (equals == null) {
-        _equals = _defaultEquals;
+        if (equals == null) {
+          equals = _defaultEquals;
+        }
       }
-      isValidKey = new _TypeTest<E>().test;
     } else {
-      if (hashCode == null) hashCode = _defaultHashCode;
-      if (equals == null) equals = _defaultEquals;
+      if (hashCode == null) {
+        hashCode = _defaultHashCode;
+      }
+      if (equals == null) {
+        equals = _defaultEquals;
+      }
     }
     return new _LinkedCustomHashSet<E>(equals, hashCode, isValidKey);
   }
+
+  /* patch */ factory LinkedHashSet.identity() = _LinkedIdentityHashSet<E>;
 }
 
 class _LinkedHashSetEntry extends _HashSetEntry {
   /// Links this element into a double-linked list of elements of a hash set.
   /// The hash set object itself is used as the head entry of the list, so
   /// the field is typed as "var".
   /// Both links are initialized to `this` when the object is created.
   var _nextEntry;
   var _previousEntry;
   _LinkedHashSetEntry(var key, int hashCode, _LinkedHashSetEntry next,
@@ skipping 91 matching lines @@
 
   void clear() {
     _nextEntry = _previousEntry = this;
     super.clear();
   }
 
   HashSet<E> _newSet() => new _LinkedHashSet<E>();
 }
 
 class _LinkedIdentityHashSet<E> extends _LinkedHashSet<E> {
+  int _hashCode(e) => identityHashCode(e);
   bool _equals(e1, e2) => identical(e1, e2);
   HashSet<E> _newSet() => new _LinkedIdentityHashSet<E>();
 }
 
 class _LinkedCustomHashSet<E> extends _LinkedHashSet<E> {
   final _Equality<E> _equality;
   final _Hasher<E> _hasher;
   final _Predicate _validKey;
 
-  _LinkedCustomHashSet(this._equality, this._hasher, bool validKey(object))
+  _LinkedCustomHashSet(this._equality, this._hasher, bool validKey(Object o))
       : _validKey = (validKey != null) ? validKey : new _TypeTest<E>().test;
 
   bool _equals(e1, e2) => _equality(e1, e2);
 
   int _hashCode(e) => _hasher(e);
 
   bool contains(Object o) {
     if (!_validKey(o)) return false;
     return super.contains(o);
   }
@@ skipping 46 matching lines @@
       return false;
     }
     _LinkedHashSetEntry entry = _next;
     _current = entry.key;
     _next = entry._nextEntry;
     return true;
   }
 
   E get current => _current;
 }