Add SetBase/SetMixin.

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 522 matching lines @@
       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> {
+class _HashSet<E> extends SetBase<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;
   int _hashCode(e) => e.hashCode;
 
   // Iterable.
@@ skipping 73 matching lines @@
   }
 
   bool remove(Object object) => _remove(object, _hashCode(object));
 
   void removeAll(Iterable<Object> objectsToRemove) {
     for (Object object in objectsToRemove) {
       _remove(object, _hashCode(object));
     }
   }
 
-  void retainAll(Iterable<Object> objectsToRetain) {
-    super._retainAll(objectsToRetain, (o) => o is E);
-  }
-
   void _filterWhere(bool test(E element), bool removeMatching) {
     int length = _buckets.length;
     for (int index =  0; index < length; index++) {
       _HashSetEntry entry = _buckets[index];
       _HashSetEntry previous = null;
       while (entry != null) {
         int modificationCount = _modificationCount;
         bool testResult = test(entry.key);
         if (modificationCount != _modificationCount) {
           throw new ConcurrentModificationError(this);
@@ skipping 53 matching lines @@
         _HashSetEntry next = entry.next;
         int newIndex = entry.hashCode & (newLength - 1);
         entry.next = newBuckets[newIndex];
         newBuckets[newIndex] = entry;
         entry = next;
       }
     }
     _buckets = newBuckets;
   }
 
-  HashSet<E> _newSet() => new _HashSet<E>();
+  HashSet<E> cloneEmpty() => 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>();
+  HashSet<E> cloneEmpty() => 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, bool validKey(Object o))
       : _validKey = (validKey != null) ? validKey : new _TypeTest<E>().test;
 
   bool remove(Object element) {
@@ skipping 19 matching lines @@
   }
 
   void removeAll(Iterable<Object> elements) {
     for (Object element in elements) {
       if (_validKey(element)) {
         super._remove(element, _hasher(element));
       }
     }
   }
 
-  void retainAll(Iterable<Object> elements) {
-    super._retainAll(elements, _validKey);
-  }
-
   bool _equals(e1, e2) => _equality(e1, e2);
   int _hashCode(e) => _hasher(e);
 
-  HashSet<E> _newSet() => new _CustomHashSet<E>(_equality, _hasher, _validKey);
+  HashSet<E> cloneEmpty() =>
+      new _CustomHashSet<E>(_equality, _hasher, _validKey);
 }
 
 class _HashSetEntry {
   final key;
   final int hashCode;
   _HashSetEntry next;
   _HashSetEntry(this.key, this.hashCode, this.next);
 
   _HashSetEntry remove() {
     _HashSetEntry result = next;
@@ skipping 389 matching lines @@
     // resize the backing store.
     if ((newElements << 2) > ((length << 1) + length)) _resize();
     _modificationCount = (_modificationCount + 1) & _MODIFICATION_COUNT_MASK;
   }
 
   void clear() {
     _nextEntry = _previousEntry = this;
     super.clear();
   }
 
-  HashSet<E> _newSet() => new _LinkedHashSet<E>();
+  HashSet<E> cloneEmpty() => 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>();
+  HashSet<E> cloneEmpty() => 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 o))
       : _validKey = (validKey != null) ? validKey : new _TypeTest<E>().test;
 
@@ skipping 24 matching lines @@
   }
 
   void removeAll(Iterable<Object> elements) {
     for (Object element in elements) {
       if (_validKey(element)) {
         super._remove(element, _hasher(element));
       }
     }
   }
 
-  void retainAll(Iterable<Object> elements) {
-    super._retainAll(elements, _validKey);
-  }
-
-  HashSet<E> _newSet() =>
+  HashSet<E> cloneEmpty() =>
       new _LinkedCustomHashSet<E>(_equality, _hasher, _validKey);
 }
 
 class _LinkedHashSetIterator<E> implements Iterator<E> {
   final _LinkedHashSet _set;
   final int _modificationCount;
   var _next;
   E _current;
 
   _LinkedHashSetIterator(_LinkedHashSet hashSet)
@@ skipping 10 matching lines @@
       return false;
     }
     _LinkedHashSetEntry entry = _next;
     _current = entry.key;
     _next = entry._nextEntry;
     return true;
   }
 
   E get current => _current;
 }