Add concurrent modification check to ListMixin/IterableMixin.reduce.

sdk/lib/collection/list.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;
 
 /**
  * Abstract implementation of a list.
  *
  * `ListBase` can be used as a base class for implementing the `List` interface.
@@ skipping 54 matching lines @@
         throw new ConcurrentModificationError(this);
       }
     }
   }
 
   bool get isEmpty => length == 0;
 
   bool get isNotEmpty => !isEmpty;
 
   E get first {
-    if (length == 0) throw new StateError("No elements");
+    if (length == 0) throw IterableElementError.noElement();
     return this[0];
   }
 
   E get last {
-    if (length == 0) throw new StateError("No elements");
+    if (length == 0) throw IterableElementError.noElement();
     return this[length - 1];
   }
 
   E get single {
-    if (length == 0) throw new StateError("No elements");
-    if (length > 1) throw new StateError("Too many elements");
+    if (length == 0) throw IterableElementError.noElement();
+    if (length > 1) throw IterableElementError.tooMany();
     return this[0];
   }
 
   bool contains(Object element) {
     int length = this.length;
     for (int i = 0; i < this.length; i++) {
       if (this[i] == element) return true;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
@@ skipping 26 matching lines @@
   dynamic firstWhere(bool test(E element), { Object orElse() }) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
       E element = this[i];
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
-    throw new StateError("No matching element");
+    throw IterableElementError.noElement();
   }
 
   dynamic lastWhere(bool test(E element), { Object orElse() }) {
     int length = this.length;
     for (int i = length - 1; i >= 0; i--) {
       E element = this[i];
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
-    throw new StateError("No matching element");
+    throw IterableElementError.noElement();
   }
 
   E singleWhere(bool test(E element)) {
     int length = this.length;
     E match = null;
     bool matchFound = false;
     for (int i = 0; i < length; i++) {
       E element = this[i];
       if (test(element)) {
         if (matchFound) {
-          throw new StateError("More than one matching element");
+          throw IterableElementError.tooMany();
         }
         matchFound = true;
         match = element;
       }
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (matchFound) return match;
-    throw new StateError("No matching element");
+    throw IterableElementError.noElement();
   }
 
   String join([String separator = ""]) {
     if (length == 0) return "";
     StringBuffer buffer = new StringBuffer()..writeAll(this, separator);
     return buffer.toString();
   }
 
   Iterable<E> where(bool test(E element)) => new WhereIterable<E>(this, test);
 
   Iterable map(f(E element)) => new MappedListIterable(this, f);
 
   Iterable expand(Iterable f(E element)) =>
       new ExpandIterable<E, dynamic>(this, f);
 
   E reduce(E combine(E previousValue, E element)) {
-    if (length == 0) throw new StateError("No elements");
+    int length = this.length;
+    if (length == 0) throw IterableElementError.noElement();
     E value = this[0];
     for (int i = 1; i < length; i++) {
       value = combine(value, this[i]);
+      if (length != this.length) {

[Anders Johnsen, 2014/10/14 09:08:24]

Can this be changed to only check at end?

[Lasse Reichstein Nielsen, 2014/10/14 09:12:05]

Not really. We check for non-change after each call to the user function,
because it might have reduced the length so low that this[i] will throw - and to
err early, so we don't get two modifications that end up with the correct
length.

+        throw new ConcurrentModificationError(this);
+      }
     }
     return value;
   }
 
   fold(var initialValue, combine(var previousValue, E element)) {
     var value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
       value = combine(value, this[i]);
       if (length != this.length) {
@@ skipping 85 matching lines @@
       source.length = retained.length;
     }
   }
 
   void clear() { this.length = 0; }
 
   // List interface.
 
   E removeLast() {
     if (length == 0) {
-      throw new StateError("No elements");
+      throw IterableElementError.noElement();
     }
     E result = this[length - 1];
     length--;
     return result;
   }
 
   void sort([int compare(E a, E b)]) {
     if (compare == null) {
       var defaultCompare = Comparable.compare;
       compare = defaultCompare;
@@ skipping 67 matching lines @@
     int otherStart;
     // TODO(floitsch): Make this accept more.
     if (iterable is List) {
       otherList = iterable;
       otherStart = skipCount;
     } else {
       otherList = iterable.skip(skipCount).toList(growable: false);
       otherStart = 0;
     }
     if (otherStart + length > otherList.length) {
-      throw new StateError("Not enough elements");
+      throw IterableElementError.tooFew();
     }
     if (otherStart < start) {
       // Copy backwards to ensure correct copy if [from] is this.
       for (int i = length - 1; i >= 0; i--) {
         this[start + i] = otherList[otherStart + i];
       }
     } else {
       for (int i = 0; i < length; i++) {
         this[start + i] = otherList[otherStart + i];
       }
@@ skipping 112 matching lines @@
       for (E element in iterable) {
         this[index++] = element;
       }
     }
   }
 
   Iterable<E> get reversed => new ReversedListIterable(this);
 
   String toString() => IterableBase.iterableToFullString(this, '[', ']');
 }