Use iterator, moveNext(), current.

sdk/lib/html/dart2js/html_dart2js.dart

 library html;
 
 import 'dart:async';
 import 'dart:isolate';
 import 'dart:json';
 import 'dart:svg' as svg;
 // 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.
 
@@ skipping 5293 matching lines @@
   DOMMimeType operator[](int index) => JS("DOMMimeType", "#[#]", this, index);
 
   void operator[]=(int index, DOMMimeType value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<DOMMimeType> mixins.
   // DOMMimeType is the element type.
 
   // From Iterable<DOMMimeType>:
 
-  Iterator<DOMMimeType> iterator() {
+  Iterator<DOMMimeType> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<DOMMimeType>(this);
   }
 
   // From Collection<DOMMimeType>:
 
   void add(DOMMimeType value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 118 matching lines @@
   DOMPlugin operator[](int index) => JS("DOMPlugin", "#[#]", this, index);
 
   void operator[]=(int index, DOMPlugin value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<DOMPlugin> mixins.
   // DOMPlugin is the element type.
 
   // From Iterable<DOMPlugin>:
 
-  Iterator<DOMPlugin> iterator() {
+  Iterator<DOMPlugin> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<DOMPlugin>(this);
   }
 
   // From Collection<DOMPlugin>:
 
   void add(DOMPlugin value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 1331 matching lines @@
      throw new UnsupportedError('');
    }
 
   Element add(Element value) {
     _element.$dom_appendChild(value);
     return value;
   }
 
   Element addLast(Element value) => add(value);
 
-  Iterator<Element> iterator() => _toList().iterator();
+  Iterator<Element> get iterator => _toList().iterator;
 
   void addAll(Collection<Element> collection) {
     for (Element element in collection) {
       _element.$dom_appendChild(element);
     }
   }
 
   void sort([Comparator<Element> compare = Comparable.compare]) {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
@@ skipping 116 matching lines @@
   }
 
   void add(Element value) {
     throw new UnsupportedError('');
   }
 
   void addLast(Element value) {
     throw new UnsupportedError('');
   }
 
-  Iterator<Element> iterator() => new _FrozenElementListIterator(this);
+  Iterator<Element> get iterator => new _FrozenElementListIterator(this);
 
   void addAll(Collection<Element> collection) {
     throw new UnsupportedError('');
   }
 
   void sort([Comparator<Element> compare = Comparable.compare]) {
     throw new UnsupportedError('');
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
@@ skipping 28 matching lines @@
   Element get last => _nodeList.last;
 }
 
 class _FrozenElementListIterator implements Iterator<Element> {
   final _FrozenElementList _list;
   int _index = 0;
 
   _FrozenElementListIterator(this._list);
 
   /**
-   * Gets the next element in the iteration. Throws a
-   * [StateError("No more elements")] if no element is left.
+   * Moves to the next element. Returns true if the iterator is positioned
+   * at an element. Returns false if it is positioned after the last element.
    */
-  Element next() {
-    if (!hasNext) {
-      throw new StateError("No more elements");
-    }
-
-    return _list[_index++];
+  bool moveNext() {
+    _index++;
+    if (_index < _list.length) return true;
+    _index = _list.length;
+    return false;
   }
 
   /**
-   * Returns whether the [Iterator] has elements left.
+   * Returns the element the [Iterator] is positioned at.
+   *
+   * Throws a [StateError] if the iterator is positioned before the first, or
+   * after the last element.
    */
-  bool get hasNext => _index < _list.length;
+  bool get current {
+    if (0 <= _index && _index < _list.length) {
+      return _list[_index];
+    }
+    // TODO(floitsch): adapt the error message.
+    throw new StateError("No more elements");
+  }
 }
 
 /**
  * All your attribute manipulation needs in one place.
  * Extends the regular Map interface by automatically coercing non-string
  * values to strings.
  */
 abstract class AttributeMap implements Map<String, String> {
   void operator []=(String key, value);
 }
@@ skipping 1572 matching lines @@
   final int length;
 
   num operator[](int index) => JS("num", "#[#]", this, index);
 
   void operator[]=(int index, num value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<num> mixins.
   // num is the element type.
 
   // From Iterable<num>:
 
-  Iterator<num> iterator() {
+  Iterator<num> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<num>(this);
   }
 
   // From Collection<num>:
 
   void add(num value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 88 matching lines @@
   final int length;
 
   num operator[](int index) => JS("num", "#[#]", this, index);
 
   void operator[]=(int index, num value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<num> mixins.
   // num is the element type.
 
   // From Iterable<num>:
 
-  Iterator<num> iterator() {
+  Iterator<num> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<num>(this);
   }
 
   // From Collection<num>:
 
   void add(num value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 345 matching lines @@
   Node operator[](int index) => JS("Node", "#[#]", this, index);
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
   // From Collection<Node>:
 
   void add(Node value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 82 matching lines @@
   Node operator[](int index) => JS("Node", "#[#]", this, index);
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
   // From Collection<Node>:
 
   void add(Node value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 1547 matching lines @@
   final int length;
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 88 matching lines @@
   final int length;
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 88 matching lines @@
   final int length;
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 2129 matching lines @@
   Node operator[](int index) => JS("Node", "#[#]", this, index);
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
   // From Collection<Node>:
 
   void add(Node value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 231 matching lines @@
   }
 
   void clear() {
     _this.text = '';
   }
 
   void operator []=(int index, Node value) {
     _this.$dom_replaceChild(value, this[index]);
   }
 
-  Iterator<Node> iterator() => _this.$dom_childNodes.iterator();
+  Iterator<Node> get iterator => _this.$dom_childNodes.iterator;
 
   // TODO(jacobr): We can implement these methods much more efficiently by
   // looking up the nodeList only once instead of once per iteration.
   bool contains(Node element) => _Collections.contains(this, element);
 
   void forEach(void f(Node element)) => _Collections.forEach(this, f);
 
   Collection map(f(Node element)) => _Collections.map(this, [], f);
 
   Collection<Node> filter(bool f(Node element)) =>
@@ skipping 272 matching lines @@
 // BSD-style license that can be found in the LICENSE file.
 
 
 // TODO(nweiz): when all implementations we target have the same name for the
 // implementation of List<E>, extend that rather than wrapping.
 class _ListWrapper<E> implements List<E> {
   List _list;
 
   _ListWrapper(List this._list);
 
-  Iterator<E> iterator() => _list.iterator();
+  Iterator<E> get iterator => _list.iterator;
 
   bool contains(E element) => _list.contains(element);
 
   void forEach(void f(E element)) => _list.forEach(f);
 
   Collection map(f(E element)) => _list.map(f);
 
   List<E> filter(bool f(E element)) => _list.filter(f);
 
   bool every(bool f(E element)) => _list.every(f);
@@ skipping 59 matching lines @@
 }
 
 class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeList" {
   Node _parent;
 
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
   // From Collection<Node>:
 
   void add(Node value) {
     _parent.$dom_appendChild(value);
@@ skipping 1670 matching lines @@
   Map operator[](int index) => JS("Map", "#[#]", this, index);
 
   void operator[]=(int index, Map value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Map> mixins.
   // Map is the element type.
 
   // From Iterable<Map>:
 
-  Iterator<Map> iterator() {
+  Iterator<Map> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Map>(this);
   }
 
   // From Collection<Map>:
 
   void add(Map value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 493 matching lines @@
   SourceBuffer operator[](int index) => JS("SourceBuffer", "#[#]", this, index);
 
   void operator[]=(int index, SourceBuffer value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SourceBuffer> mixins.
   // SourceBuffer is the element type.
 
   // From Iterable<SourceBuffer>:
 
-  Iterator<SourceBuffer> iterator() {
+  Iterator<SourceBuffer> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SourceBuffer>(this);
   }
 
   // From Collection<SourceBuffer>:
 
   void add(SourceBuffer value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 132 matching lines @@
   SpeechGrammar operator[](int index) => JS("SpeechGrammar", "#[#]", this, index);
 
   void operator[]=(int index, SpeechGrammar value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SpeechGrammar> mixins.
   // SpeechGrammar is the element type.
 
   // From Iterable<SpeechGrammar>:
 
-  Iterator<SpeechGrammar> iterator() {
+  Iterator<SpeechGrammar> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SpeechGrammar>(this);
   }
 
   // From Collection<SpeechGrammar>:
 
   void add(SpeechGrammar value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 998 matching lines @@
   TextTrackCue operator[](int index) => JS("TextTrackCue", "#[#]", this, index);
 
   void operator[]=(int index, TextTrackCue value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<TextTrackCue> mixins.
   // TextTrackCue is the element type.
 
   // From Iterable<TextTrackCue>:
 
-  Iterator<TextTrackCue> iterator() {
+  Iterator<TextTrackCue> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<TextTrackCue>(this);
   }
 
   // From Collection<TextTrackCue>:
 
   void add(TextTrackCue value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 85 matching lines @@
   TextTrack operator[](int index) => JS("TextTrack", "#[#]", this, index);
 
   void operator[]=(int index, TextTrack value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<TextTrack> mixins.
   // TextTrack is the element type.
 
   // From Iterable<TextTrack>:
 
-  Iterator<TextTrack> iterator() {
+  Iterator<TextTrack> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<TextTrack>(this);
   }
 
   // From Collection<TextTrack>:
 
   void add(TextTrack value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 203 matching lines @@
   Touch operator[](int index) => JS("Touch", "#[#]", this, index);
 
   void operator[]=(int index, Touch value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Touch> mixins.
   // Touch is the element type.
 
   // From Iterable<Touch>:
 
-  Iterator<Touch> iterator() {
+  Iterator<Touch> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Touch>(this);
   }
 
   // From Collection<Touch>:
 
   void add(Touch value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 253 matching lines @@
   final int length;
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 88 matching lines @@
   final int length;
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 88 matching lines @@
   final int length;
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) => JS("void", "#[#] = #", this, index, value);
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 2165 matching lines @@
   CSSRule operator[](int index) => JS("CSSRule", "#[#]", this, index);
 
   void operator[]=(int index, CSSRule value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<CSSRule> mixins.
   // CSSRule is the element type.
 
   // From Iterable<CSSRule>:
 
-  Iterator<CSSRule> iterator() {
+  Iterator<CSSRule> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<CSSRule>(this);
   }
 
   // From Collection<CSSRule>:
 
   void add(CSSRule value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 76 matching lines @@
   CSSValue operator[](int index) => JS("CSSValue", "#[#]", this, index);
 
   void operator[]=(int index, CSSValue value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<CSSValue> mixins.
   // CSSValue is the element type.
 
   // From Iterable<CSSValue>:
 
-  Iterator<CSSValue> iterator() {
+  Iterator<CSSValue> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<CSSValue>(this);
   }
 
   // From Collection<CSSValue>:
 
   void add(CSSValue value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 76 matching lines @@
   ClientRect operator[](int index) => JS("ClientRect", "#[#]", this, index);
 
   void operator[]=(int index, ClientRect value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<ClientRect> mixins.
   // ClientRect is the element type.
 
   // From Iterable<ClientRect>:
 
-  Iterator<ClientRect> iterator() {
+  Iterator<ClientRect> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<ClientRect>(this);
   }
 
   // From Collection<ClientRect>:
 
   void add(ClientRect value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 85 matching lines @@
   String operator[](int index) => JS("String", "#[#]", this, index);
 
   void operator[]=(int index, String value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<String> mixins.
   // String is the element type.
 
   // From Iterable<String>:
 
-  Iterator<String> iterator() {
+  Iterator<String> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<String>(this);
   }
 
   // From Collection<String>:
 
   void add(String value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 401 matching lines @@
   Entry operator[](int index) => JS("Entry", "#[#]", this, index);
 
   void operator[]=(int index, Entry value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Entry> mixins.
   // Entry is the element type.
 
   // From Iterable<Entry>:
 
-  Iterator<Entry> iterator() {
+  Iterator<Entry> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Entry>(this);
   }
 
   // From Collection<Entry>:
 
   void add(Entry value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 76 matching lines @@
   EntrySync operator[](int index) => JS("EntrySync", "#[#]", this, index);
 
   void operator[]=(int index, EntrySync value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<EntrySync> mixins.
   // EntrySync is the element type.
 
   // From Iterable<EntrySync>:
 
-  Iterator<EntrySync> iterator() {
+  Iterator<EntrySync> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<EntrySync>(this);
   }
 
   // From Collection<EntrySync>:
 
   void add(EntrySync value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 85 matching lines @@
   File operator[](int index) => JS("File", "#[#]", this, index);
 
   void operator[]=(int index, File value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<File> mixins.
   // File is the element type.
 
   // From Iterable<File>:
 
-  Iterator<File> iterator() {
+  Iterator<File> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<File>(this);
   }
 
   // From Collection<File>:
 
   void add(File value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 105 matching lines @@
   Gamepad operator[](int index) => JS("Gamepad", "#[#]", this, index);
 
   void operator[]=(int index, Gamepad value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Gamepad> mixins.
   // Gamepad is the element type.
 
   // From Iterable<Gamepad>:
 
-  Iterator<Gamepad> iterator() {
+  Iterator<Gamepad> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Gamepad>(this);
   }
 
   // From Collection<Gamepad>:
 
   void add(Gamepad value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 129 matching lines @@
   MediaStream operator[](int index) => JS("MediaStream", "#[#]", this, index);
 
   void operator[]=(int index, MediaStream value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<MediaStream> mixins.
   // MediaStream is the element type.
 
   // From Iterable<MediaStream>:
 
-  Iterator<MediaStream> iterator() {
+  Iterator<MediaStream> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<MediaStream>(this);
   }
 
   // From Collection<MediaStream>:
 
   void add(MediaStream value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 239 matching lines @@
   SpeechInputResult operator[](int index) => JS("SpeechInputResult", "#[#]", this, index);
 
   void operator[]=(int index, SpeechInputResult value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SpeechInputResult> mixins.
   // SpeechInputResult is the element type.
 
   // From Iterable<SpeechInputResult>:
 
-  Iterator<SpeechInputResult> iterator() {
+  Iterator<SpeechInputResult> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SpeechInputResult>(this);
   }
 
   // From Collection<SpeechInputResult>:
 
   void add(SpeechInputResult value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 85 matching lines @@
   SpeechRecognitionResult operator[](int index) => JS("SpeechRecognitionResult", "#[#]", this, index);
 
   void operator[]=(int index, SpeechRecognitionResult value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SpeechRecognitionResult> mixins.
   // SpeechRecognitionResult is the element type.
 
   // From Iterable<SpeechRecognitionResult>:
 
-  Iterator<SpeechRecognitionResult> iterator() {
+  Iterator<SpeechRecognitionResult> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SpeechRecognitionResult>(this);
   }
 
   // From Collection<SpeechRecognitionResult>:
 
   void add(SpeechRecognitionResult value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 76 matching lines @@
   StyleSheet operator[](int index) => JS("StyleSheet", "#[#]", this, index);
 
   void operator[]=(int index, StyleSheet value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<StyleSheet> mixins.
   // StyleSheet is the element type.
 
   // From Iterable<StyleSheet>:
 
-  Iterator<StyleSheet> iterator() {
+  Iterator<StyleSheet> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<StyleSheet>(this);
   }
 
   // From Collection<StyleSheet>:
 
   void add(StyleSheet value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 100 matching lines @@
   Animation operator[](int index) => JS("Animation", "#[#]", this, index);
 
   void operator[]=(int index, Animation value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Animation> mixins.
   // Animation is the element type.
 
   // From Iterable<Animation>:
 
-  Iterator<Animation> iterator() {
+  Iterator<Animation> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Animation>(this);
   }
 
   // From Collection<Animation>:
 
   void add(Animation value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 1237 matching lines @@
   static List filter(Iterable<Object> source,
                      List<Object> destination,
                      bool f(o)) {
     for (final e in source) {
       if (f(e)) destination.add(e);
     }
     return destination;
   }
 
   static bool isEmpty(Iterable<Object> iterable) {
-    return !iterable.iterator().hasNext;
+    return !iterable.iterator.moveNext();
   }
 }
 // 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.
 
 
 class _HttpRequestUtils {
 
   // Helper for factory HttpRequest.get
@@ skipping 1669 matching lines @@
     if (length < 0) throw new ArgumentError('length');
     if (start < 0) throw new RangeError.value(start);
     int end = start + length;
     if (end > a.length) throw new RangeError.value(end);
     for (int i = start; i < end; i++) {
       accumulator.add(a[i]);
     }
     return accumulator;
   }
 }