Reduce usage of ItearbleMixinWorkaround.

sdk/lib/collection/hash_set.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.
 
 part of dart.collection;
 
-class HashSet<E> extends Collection<E> implements Set<E> {
+class HashSet<E> extends Collection<E> with _SetMixin<E> implements Set<E> {

[floitsch, 2013/04/05 12:38:17]

I would prefer a common super-class (_SetBase ?) instead of using Mixins.

   static const int _INITIAL_CAPACITY = 8;
   final _HashTable<E> _table;
 
   HashSet() : _table = new _HashTable(_INITIAL_CAPACITY) {
     _table._container = this;
   }
 
   factory HashSet.from(Iterable<E> iterable) {
     return new HashSet<E>()..addAll(iterable);
   }
@@ skipping 26 matching lines @@
     return offset >= 0;
   }
 
   void removeAll(Iterable objectsToRemove) {
     for (Object object in objectsToRemove) {
       _table._remove(object);
       _table._checkCapacity();
     }
   }
 
-  void retainAll(Iterable objectsToRetain) {
-    IterableMixinWorkaround.retainAll(this, objectsToRetain);
-  }
-
   void _filterWhere(bool test(E element), bool removeMatching) {
     int entrySize = _table._entrySize;
     int length = _table._table.length;
     for (int offset =  0; offset < length; offset += entrySize) {
       Object entry = _table._table[offset];
       if (!_table._isFree(entry)) {
         E key = identical(entry, _NULL) ? null : entry;
         int modificationCount = _table._modificationCount;
         bool shouldRemove = (removeMatching == test(key));
         _table._checkModification(modificationCount);
@@ skipping 10 matching lines @@
   }
 
   void retainWhere(bool test(E element)) {
     _filterWhere(test, false);
   }
 
   void clear() {
     _table._clear();
   }
 
+  Set<E> _newSet() => new HashSet<E>();
+
+  String toString() => Collections.collectionToString(this);

[floitsch, 2013/04/05 12:38:17]

move to _SetMixin.

+}
+
+// Implementation of Set methods shared by Set implementations.
+abstract class _SetMixin<E> {
+  Set<E> _newSet();
+
   // Set.
   bool isSubsetOf(Collection<E> other) {
     // Deprecated, and using old signature.
     Set otherSet;
     if (other is Set) {
       otherSet = other;
     } else {
       otherSet = other.toSet();
     }
-    return IterableMixinWorkaround.setContainsAll(otherSet, this);
+    return otherSet.containsAll(this);
   }
 
   bool containsAll(Iterable<E> other) {
-    return IterableMixinWorkaround.setContainsAll(this, other);
+    for (E object in other) {
+      if (_table._get(object) < 0) return false;
+    }
+    return true;
   }
 
   Set<E> intersection(Set<E> other) {
-    return IterableMixinWorkaround.setIntersection(
-        this, other, new HashSet<E>());
+    Set<E> result = _newSet();
+    if (other.length < this.length) {
+      for (E element in other) {
+        if (this.contains(element)) result.add(element);
+      }
+    } else {
+      for (E element in this) {
+        if (other.contains(element)) result.add(element);
+      }
+    }
+    return result;
   }
 
   Set<E> union(Set<E> other) {
-    return IterableMixinWorkaround.setUnion(this, other, new HashSet<E>());
+    return _newSet()..addAll(this)..addAll(other);
   }
 
   Set<E> difference(Set<E> other) {
-    return IterableMixinWorkaround.setDifference(this, other, new HashSet<E>());
+    HashSet<E> result = _newSet();
+    for (E element in this) {
+      if (!other.contains(element)) result.add(element);
+    }
+    return result;
   }
-
-  String toString() => Collections.collectionToString(this);
 }