Fix bugs in GrowableList.remove*.

sdk/lib/collection/collections.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.
 
 part of dart.collection;
 
 /**
  * This class provides default implementations for Iterables (including Lists).
  *
  * Once Dart receives Mixins it will be replaced with mixin classes.
@@ skipping 50 matching lines @@
 
   /**
    * Implementation of [Collection.removeAll] for lists.
    *
    * This implementation assumes that [Collection.remove] is not efficient
    * (as it usually isn't on a [List]) and uses [Collection.removeMathcing]
    * instead of just repeatedly calling remove.
    */
   static void removeAllList(Collection collection, Iterable elementsToRemove) {
     Set setToRemove;
-    // Assume contains is efficient on a Set.
+    // Assume [contains] is efficient on a Set.
     if (elementsToRemove is Set) {
       setToRemove = elementsToRemove;
     } else {
       setToRemove = elementsToRemove.toSet();
     }
     collection.removeMatching(setToRemove.contains);
   }
 
   /**
    * Simple implemenation for [Collection.retainAll].
    *
    * This implementation assumes that [Collecton.retainMatching] on [collection]
    * is efficient.
    */
   static void retainAll(Collection collection, Iterable elementsToRetain) {
     Set lookup;
     if (elementsToRetain is Set) {
       lookup = elementsToRetain;
     } else {
       lookup = elementsToRetain.toSet();
     }
+    if (lookup.isEmpty) {
+      collection.clear();
+      return;
+    }
     collection.retainMatching(lookup.contains);
   }
 
   /**
    * Simple implemenation for [Collection.removeMatching].
    *
    * This implementation assumes that [Collecton.removeAll] on [collection] is
    * efficient.
    */
   static void removeMatching(Collection collection, bool test(var element)) {
     List elementsToRemove = [];
     for (var element in collection) {
       if (test(element)) elementsToRemove.add(element);
     }
     collection.removeAll(elementsToRemove);
   }
 
   /**
+   * Removes elements matching [test] from [list].
+   *
+   * This is performed in two steps, to avoid exposing an inconsistent state
+   * to the [test] function. First the elements to ratain are found, and then
+   * the original list is updated to contain those elements.
+   */
+  static void removeMatchingList(List list, bool test(var element)) {
+    List retained = [];
+    int length = list.length;
+    for (int i = 0; i < length; i++) {
+      var element = list[i];
+      if (!test(element)) {
+        retained.add(element);
+      }
+      if (length != list.length) {
+        throw new ConcurrentModificationError(list);
+      }
+    }
+    if (retained.length == length) return;
+    for (int i = 0; i < retained.length; i++) {
+      list[i] = retained[i];
+    }
+    list.length = retained.length;
+  }
+
+  /**
    * Simple implemenation for [Collection.retainMatching].
    *
    * This implementation assumes that [Collecton.removeAll] on [collection] is
    * efficient.
    */
   static void retainMatching(Collection collection, bool test(var element)) {
     List elementsToRemove = [];
     for (var element in collection) {
       if (!test(element)) elementsToRemove.add(element);
     }
     collection.removeAll(elementsToRemove);
   }
+
   static bool isEmpty(Iterable iterable) {
     return !iterable.iterator.moveNext();
   }
 
   static dynamic first(Iterable iterable) {
     Iterator it = iterable.iterator;
     if (!it.moveNext()) {
       throw new StateError("No elements");
     }
     return it.current;
@@ skipping 383 matching lines @@
    * Returns true if the specified collection contains the specified object
    * reference.
    */
   static _containsRef(Collection c, Object ref) {
     for (var e in c) {
       if (identical(e, ref)) return true;
     }
     return false;
   }
 }