Make Iterable.toSet say that it returns a Set with the same equality as the Iterable's contains met…

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) {
@@ skipping 15 matching lines @@
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 
   /* patch */ factory HashMap.identity() = _IdentityHashMap<K, V>;
+
+  Set<K> _newKeySet();
 }
 
 
 const int _MODIFICATION_COUNT_MASK = 0x3fffffff;
 
 class _HashMap<K, V> implements HashMap<K, V> {
   static const int _INITIAL_CAPACITY = 8;
 
 
   int _elementCount = 0;
@@ skipping 171 matching lines @@
         int index = hashCode & (newLength - 1);
         entry.next = newBuckets[index];
         newBuckets[index] = entry;
         entry = next;
       }
     }
     _buckets = newBuckets;
   }
 
   String toString() => Maps.mapToString(this);
+
+  Set<K> _newKeySet() => new _HashSet<K>();
 }
 
 class _CustomHashMap<K, V> extends _HashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate _validKey;
   _CustomHashMap(this._equals, this._hashCode, validKey)
       : _validKey = (validKey != null) ? validKey : new _TypeTest<K>().test;
 
 
@@ skipping 79 matching lines @@
             (_modificationCount + 1) & _MODIFICATION_COUNT_MASK;
         return entry.value;
       }
       previous = entry;
       entry = next;
     }
     return null;
   }
 
   String toString() => Maps.mapToString(this);
+
+  Set<K> _newKeySet() => new _CustomHashSet<K>(_equals, _hashCode, _validKey);
 }
 
 class _IdentityHashMap<K, V> extends _HashMap<K, V> {
 
   bool containsKey(Object key) {
     int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
@@ skipping 70 matching lines @@
             (_modificationCount + 1) & _MODIFICATION_COUNT_MASK;
         return entry.value;
       }
       previous = entry;
       entry = next;
     }
     return null;
   }
 
   String toString() => Maps.mapToString(this);
+
+  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 IterableBase<E>
                                    implements EfficientLength {
   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, _) {
       action(key);
     });
   }
+  Set<K> toSet() => _map._newKeySet()..addAll(this);
 }
 
 class _HashMapValueIterable<V> extends _HashMapIterable<V> {
   _HashMapValueIterable(HashMap map) : super(map);
   Iterator<V> get iterator => new _HashMapValueIterator<V>(_map);
   bool contains(Object value) => _map.containsValue(value);
   void forEach(void action(V value)) {
     _map.forEach((_, V value) {
       action(value);
     });
@@ skipping 373 matching lines @@
 
 class _LinkedHashMapKeyIterable<K> extends IterableBase<K>
                                    implements EfficientLength {
   LinkedHashMap<K, dynamic> _map;
   _LinkedHashMapKeyIterable(this._map);
   Iterator<K> get iterator => new _LinkedHashMapKeyIterator<K>(_map);
   bool contains(Object key) => _map.containsKey(key);
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
   int get length => _map.length;
+  Set<K> toSet() => _map._newKeySet()..addAll(this);
 }
 
 class _LinkedHashMapValueIterable<V> extends IterableBase<V>
                                      implements EfficientLength {
   LinkedHashMap<dynamic, V> _map;
   _LinkedHashMapValueIterable(this._map);
   Iterator<V> get iterator => new _LinkedHashMapValueIterator<V>(_map);
   bool contains(Object value) => _map.containsValue(value);
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
@@ skipping 165 matching lines @@
 
   Iterable<K> get keys => new _LinkedHashMapKeyIterable<K>(this);
   Iterable<V> get values => new _LinkedHashMapValueIterable<V>(this);
 }
 
 class _LinkedHashMap<K, V> extends _HashMap<K, V>
                            with _LinkedHashMapMixin<K, V> {
   _LinkedHashMap() {
     _nextEntry = _previousEntry = this;
   }
+
+  Set<K> _newKeySet() => new _LinkedHashSet<K>();
 }
 
 class _LinkedIdentityHashMap<K, V> extends _IdentityHashMap<K, V>
                                    with _LinkedHashMapMixin<K, V> {
   _LinkedIdentityHashMap() {
     _nextEntry = _previousEntry = this;
   }
+
+  Set<K> _newKeySet() => new _LinkedIdentityHashSet<K>();
 }
 
 class _LinkedCustomHashMap<K, V> extends _CustomHashMap<K, V>
                                  with _LinkedHashMapMixin<K, V> {
   _LinkedCustomHashMap(bool equals(K key1, K key2),
                        int hashCode(K key),
                        bool isValidKey(potentialKey))
       : super(equals, hashCode, isValidKey) {
     _nextEntry = _previousEntry = this;
   }
+  Set<K> _newKeySet() =>
+      new _LinkedCustomHashSet<K>(_equals, _hashCode, _validKey);
 }
 
 
 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) {
@@ skipping 203 matching lines @@
       return false;
     }
     _LinkedHashSetEntry entry = _next;
     _current = entry.key;
     _next = entry._nextEntry;
     return true;
   }
 
   E get current => _current;
 }