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

tests/corelib/map_test.dart

 // Copyright (c) 2011, 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.
 
 library map_test;
 import "package:expect/expect.dart";
 import 'dart:collection';
 
 void main() {
   test(new HashMap());
@@ skipping 11 matching lines @@
   testWeirdStringKeys(new HashMap<String, String>());
   testWeirdStringKeys(new LinkedHashMap());
   testWeirdStringKeys(new LinkedHashMap<String, String>());
   testWeirdStringKeys(new SplayTreeMap());
   testWeirdStringKeys(new SplayTreeMap<String, String>());
 
   testNumericKeys(new Map());
   testNumericKeys(new Map<num, String>());
   testNumericKeys(new HashMap());
   testNumericKeys(new HashMap<num, String>());
-  testNumericKeys(new HashMap(equals: identical));
-  testNumericKeys(new HashMap<num, String>(equals: identical));
+  testNumericKeys(new HashMap.identity());
+  testNumericKeys(new HashMap<num, String>.identity());
   testNumericKeys(new LinkedHashMap());
   testNumericKeys(new LinkedHashMap<num, String>());
-  testNumericKeys(new LinkedHashMap(equals: identical));
-  testNumericKeys(new LinkedHashMap<num, String>(equals: identical));
+  testNumericKeys(new LinkedHashMap.identity());
+  testNumericKeys(new LinkedHashMap<num, String>.identity());
 
   testNaNKeys(new Map());
   testNaNKeys(new Map<num, String>());
   testNaNKeys(new HashMap());
   testNaNKeys(new HashMap<num, String>());
   testNaNKeys(new LinkedHashMap());
   testNaNKeys(new LinkedHashMap<num, String>());
   // Identity maps fail the NaN-keys tests because the test assumes that
   // NaN is not equal to NaN.
 
-  testIdentityMap(new HashMap(equals: identical));
-  testIdentityMap(new LinkedHashMap(equals: identical));
+  testIdentityMap(new Map.identity());
+  testIdentityMap(new HashMap.identity());
+  testIdentityMap(new LinkedHashMap.identity());
+  testIdentityMap(new HashMap(equals: identical,
+                              hashCode: identityHashCode));
+  testIdentityMap(new LinkedHashMap(equals: identical,
+                                    hashCode: identityHashCode));
+  testIdentityMap(new HashMap(equals: (x, y) => identical(x, y),
+                              hashCode: (x) => identityHashCode(x)));
+  testIdentityMap(new LinkedHashMap(equals: (x, y) => identical(x, y),
+                                    hashCode: (x) => identityHashCode(x)));
 
   testCustomMap(new HashMap(equals: myEquals, hashCode: myHashCode,
                             isValidKey: (v) => v is Customer));
   testCustomMap(new LinkedHashMap(equals: myEquals, hashCode: myHashCode,
                                   isValidKey: (v) => v is Customer));
   testCustomMap(new HashMap<Customer,dynamic>(equals: myEquals,
                                               hashCode: myHashCode));
 
   testCustomMap(new LinkedHashMap<Customer,dynamic>(equals: myEquals,
                                                     hashCode: myHashCode));
 
   testIterationOrder(new LinkedHashMap());
-  testIterationOrder(new LinkedHashMap(equals: identical));
+  testIterationOrder(new LinkedHashMap.identity());
 
   testOtherKeys(new SplayTreeMap<int, int>());
   testOtherKeys(new SplayTreeMap<int, int>((int a, int b) => a - b,
                                            (v) => v is int));
   testOtherKeys(new SplayTreeMap((int a, int b) => a - b,
                                  (v) => v is int));
   testOtherKeys(new HashMap<int, int>());
-  testOtherKeys(new HashMap<int, int>(equals: identical));
+  testOtherKeys(new HashMap<int, int>.identity());
   testOtherKeys(new HashMap<int, int>(hashCode: (v) => v.hashCode,
                                       isValidKey: (v) => v is int));
   testOtherKeys(new HashMap(equals: (int x, int y) => x == y,
                             hashCode: (int v) => v.hashCode,
                             isValidKey: (v) => v is int));
   testOtherKeys(new LinkedHashMap<int, int>());
-  testOtherKeys(new LinkedHashMap<int, int>(equals: identical));
+  testOtherKeys(new LinkedHashMap<int, int>.identity());
   testOtherKeys(new LinkedHashMap<int, int>(hashCode: (v) => v.hashCode,
                                        isValidKey: (v) => v is int));
   testOtherKeys(new LinkedHashMap(equals: (int x, int y) => x == y,
                                   hashCode: (int v) => v.hashCode,
                                   isValidKey: (v) => v is int));
 }
 
 
 void test(Map map) {
   testDeletedElement(map);
@@ skipping 489 matching lines @@
   testLength(4, map);
 
   // Transfer to equality-based map will collapse elements.
   Map eqMap = new HashMap();
   eqMap.addAll(map);
   testLength(2, eqMap);
   Expect.isTrue(eqMap.containsKey(eq01));
   Expect.isTrue(eqMap.containsKey(eq02));
   Expect.isTrue(eqMap.containsKey(eq11));
   Expect.isTrue(eqMap.containsKey(eq12));
+
+  // Changing objects will not affect identity map.
+  map.clear();
+  var m1 = new Mutable(1);
+  var m2 = new Mutable(2);
+  var m3 = new Mutable(3);
+  map[m1] = 1;
+  map[m2] = 2;
+  map[m3] = 3;
+  Expect.equals(3, map.length);
+  Expect.isTrue(map.containsKey(m1));
+  Expect.isTrue(map.containsKey(m2));
+  Expect.isTrue(map.containsKey(m3));
+  Expect.notEquals(m1, m3);
+  m3.id = 1;
+  Expect.equals(m1, m3);
+  // Even if keys are equal, they are still not identical.
+  // Even if hashcode of m3 changed, it can still be found.
+  Expect.equals(1, map[m1]);
+  Expect.equals(3, map[m3]);
 }
 
 /** Class of objects that are equal if they hold the same id. */
 class Equalizer {
   int id;
   Equalizer(this.id);
   int get hashCode => id;
   bool operator==(Object other) =>
       other is Equalizer && id == (other as Equalizer).id;
 }
@@ skipping 109 matching lines @@
   map[0] = 0;
   map[1] = 1;
   map[2] = 2;
   Expect.isFalse(map.containsKey("not an int"));
   Expect.isFalse(map.containsKey(1.5));
   Expect.isNull(map.remove("not an int"));
   Expect.isNull(map.remove(1.5));
   Expect.isNull(map["not an int"]);
   Expect.isNull(map[1.5]);
 }
+
+class Mutable {
+  int id;
+  Mutable(this.id);
+  int get hashCode => id;
+  bool operator==(other) => other is Mutable && other.id == id;
+}