Create mock versions set and sort implementations.

dart/frog/leg/lib/hash_map_set.dart

 // Copyright (c) 2012, 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.
 
+// TODO(ahe): Remove this file and use the shared one.
+
 // Hash map implementation with open addressing and quadratic probing.
 class HashMapImplementation<K extends Hashable, V> implements HashMap<K, V> {
 
   // The [_keys] list contains the keys inserted in the map.
   // The [_keys] list must be a raw list because it
   // will contain both elements of type K, and the [_DELETED_KEY] of type
   // [_DeletedKeySentinel].
   // The alternative of declaring the [_keys] list as of type Object
   // does not work, because the HashSetIterator constructor would fail:
   //  HashSetIterator(HashSet<E> set)
@@ skipping 134 matching lines @@
     int capacity = _keys.length;
     _loadLimit = _computeLoadLimit(newCapacity);
     List oldKeys = _keys;
     List<V> oldValues = _values;
     _keys = new List(newCapacity);
     _values = new List<V>(newCapacity);
     for (int i = 0; i < capacity; i++) {
       // [key] can be either of type [K] or [_DeletedKeySentinel].
       Object key = oldKeys[i];
       // If there is no key, we don't need to deal with the current slot.
-      if (key === null || key === _DELETED_KEY) {
-        continue;
+      if (key !== null && key !== _DELETED_KEY) {
+        V value = oldValues[i];
+        // Insert the {key, value} pair in their new slot.
+        int newIndex = _probeForAdding(key);
+        _keys[newIndex] = key;
+        _values[newIndex] = value;
       }
-      V value = oldValues[i];
-      // Insert the {key, value} pair in their new slot.
-      int newIndex = _probeForAdding(key);
-      _keys[newIndex] = key;
-      _values[newIndex] = value;
     }
     _numberOfDeleted = 0;
   }
 
   void clear() {
     _numberOfEntries = 0;
     _numberOfDeleted = 0;
     int length = _keys.length;
     for (int i = 0; i < length; i++) {
       _keys[i] = null;
@@ skipping 123 matching lines @@
     return _backingMap.containsKey(value);
   }
 
   bool remove(E value) {
     if (!_backingMap.containsKey(value)) return false;
     _backingMap.remove(value);
     return true;
   }
 
   void addAll(Collection<E> collection) {
+    var self = this;

[ahe, 2012/02/29 12:37:21]

I should be able to remove all the "self" references when I merge with Florian's
changes to fix this.

     collection.forEach(void _(E value) {
-      add(value);
+      self.add(value);
     });
   }
 
   Set<E> intersection(Collection<E> collection) {
+    var self = this;
     Set<E> result = new Set<E>();
     collection.forEach(void _(E value) {
-      if (contains(value)) result.add(value);
+      if (self.contains(value)) result.add(value);
     });
     return result;
   }
 
   bool isSubsetOf(Collection<E> other) {
-    return new Set<E>.from(other).containsAll(this);
+    return new Set.from(other).containsAll(this);
   }
 
   void removeAll(Collection<E> collection) {
+    var self = this;
     collection.forEach(void _(E value) {
-      remove(value);
+      self.remove(value);
     });
   }
 
   bool containsAll(Collection<E> collection) {
+    var self = this;
     return collection.every(bool _(E value) {
-      return contains(value);
+      return self.contains(value);
     });
   }
 
   void forEach(void f(E element)) {
     _backingMap.forEach(void _(E key, E value) {
       f(key);
     });
   }
 
   Set map(f(E element)) {
@@ skipping 94 matching lines @@
 
 /**
  * A singleton sentinel used to represent when a key is deleted from the map.
  * We can't use [: const Object() :] as a sentinel because it would end up
  * canonicalized and then we cannot distinguish the deleted key from the
  * canonicalized [: Object() :].
  */
 class _DeletedKeySentinel {
   const _DeletedKeySentinel();
 }