Change ListIterator to only check for concurrent modification at each iteration

sdk/lib/internal/iterable.dart

 // Copyright (c) 2011, 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._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
@@ skipping 302 matching lines @@
 
 /**
  * An [Iterator] that iterates a list-like [Iterable].
  *
  * All iterations is done in terms of [Iterable.length] and
  * [Iterable.elementAt]. These operations are fast for list-like
  * iterables.
  */
 class ListIterator<E> implements Iterator<E> {
   final Iterable<E> _iterable;
-  final int _length;
+  final int _originalLength;
   int _index;
   E _current;
 
   ListIterator(Iterable<E> iterable)
-      : _iterable = iterable, _length = iterable.length, _index = 0;
+      : _iterable = iterable, _originalLength = iterable.length, _index = 0;
 
   E get current => _current;
 
   bool moveNext() {
-    int length = _iterable.length;
-    if (_length != length) {
+    // Check for concurrent modifiction at each step in checked mode.
+    assert((_originalLength == _iterable.length) ||
+           (throw new ConcurrentModificationError(_iterable)));
+    if (_index < _iterable.length) {
+      _current = _iterable.elementAt(_index);
+      _index++;
+      return true;
+    }
+    // Check for concurrent modification only at the end in production mode.
+    if (_originalLength != _iterable.length) {
       throw new ConcurrentModificationError(_iterable);
     }
-    if (_index >= length) {
-      _current = null;
-      return false;
-    }
-    _current = _iterable.elementAt(_index);
-    _index++;
-    return true;
+    _current = null;
+    return false;
   }
 }
 
 typedef T _Transformation<S, T>(S value);
 
 class MappedIterable<S, T> extends Iterable<T> {
   final Iterable<S> _iterable;
   final _Transformation<S, T> _f;
 
   factory MappedIterable(Iterable iterable, T function(S value)) {
@@ skipping 408 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }