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

tests/corelib/hash_set_test.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.
 
 // Tests of hash set behavior, with focus in iteration and concurrent
 // modification errors.
 
 library hash_map2_test;
 import "package:expect/expect.dart";
 import 'dart:collection';
 
-testSet(Set newSet(), Set newSetFrom(Set from)) {
+testSet(Set newSet(), Set newSetFrom(Iterable from)) {
 
   Set gen(int from, int to) =>
       new Set.from(new Iterable.generate(to - from, (n) => n + from));
 
   bool odd(int n) => (n & 1) == 1;
   bool even(int n) => (n & 1) == 0;
 
   {  // Test growing to largish capacity.
     Set set = newSet();
 
@@ skipping 190 matching lines @@
     Expect.isFalse(set.contains(2));
     Expect.isTrue(set.contains(3));
     set.retainWhere((each) => each == 3);
     Expect.equals(1, set.length);
     Expect.isFalse(set.contains(1));
     Expect.isFalse(set.contains(2));
     Expect.isTrue(set.contains(3));
   }
 }
 
-void main() {
-  testSet(() => new HashSet(), (m) => new HashSet.from(m));
-  testSet(() => new LinkedHashSet(), (m) => new LinkedHashSet.from(m));
+
+void testIdentitySet(Set create()) {
+  Set set = create();
+  set.add(1);
+  set.add(2);
+  set.add(1);  // Integers are identical if equal.
+  Expect.equals(2, set.length);
+  var complex = 4;
+  complex = set.length == 2 ? complex ~/ 4 : 87;  // Avoid compile-time constant.
+  Expect.isTrue(set.contains(complex));  // 1 is in set, even if computed.
+  set.clear();
+
+  // All compile time constants are identical to themselves.
+  var constants = [double.INFINITY,
+                   double.NAN, -0.0, /// 01: ok
+                   0.0, 42, "", null, false, true, #bif, testIdentitySet];
+  set.addAll(constants);
+  Expect.equals(constants.length, set.length);
+  for (var c in constants) {
+    Expect.isTrue(set.contains(c), "constant: $c");
+  }
+  Expect.isTrue(set.containsAll(constants), "constants: $set");
+  set.clear();
+
+  var m1 = new Mutable(1);
+  var m2 = new Mutable(2);
+  var m3 = new Mutable(3);
+  var m4 = new Mutable(2);  // Equal to m2, but not identical.
+  set.addAll([m1, m2, m3, m4]);
+  Expect.equals(4, set.length);
+  Expect.equals(3, m3.hashCode);
+  m3.id = 1;
+  Expect.equals(1, m3.hashCode);
+  // Changing hashCode doesn't affect lookup.
+  Expect.isTrue(set.contains(m3));
+  Expect.isTrue(set.contains(m1));
+  set.remove(m3);
+  Expect.isFalse(set.contains(m3));
+  Expect.isTrue(set.contains(m1));
 }
 
 
+void main() {
+  testSet(() => new Set(), (m) => new Set.from(m));
+  testSet(() => new HashSet(), (m) => new HashSet.from(m));
+  testSet(() => new LinkedHashSet(), (m) => new LinkedHashSet.from(m));
+  testIdentitySet(() => new Set.identity());
+  testIdentitySet(() => new HashSet.identity());
+  testIdentitySet(() => new LinkedHashSet.identity());
+  testIdentitySet(() => new HashSet(equals: (x, y) => identical(x, y),
+                                    hashCode: (x) => identityHashCode(x)));
+  testIdentitySet(
+      () => new LinkedHashSet(equals: (x, y) => identical(x, y),
+                              hashCode: (x) => identityHashCode(x)));
+}
+
+
 class BadHashCode {
   static int idCounter = 0;
   final int id;
   BadHashCode() : id = idCounter++;
   int get hashCode => 42;
   // operator == is identity.
   // Can't make a bad compareTo that isn't invalid.
   int compareTo(BadHashCode other) => id - other.id;
 }
+
+class Mutable {
+  int id;
+  Mutable(this.id);
+  int get hashCode => id;
+  bool operator==(other) => other is Mutable && id == other.id;
+}