Make VM's RegExp.allMatches lazy.

runtime/lib/regexp_patch.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.
 
 patch class RegExp {
   /* patch */ factory RegExp(String pattern,
                              {bool multiLine: false,
                               bool caseSensitive: true}) {
     return new _JSSyntaxRegExp(pattern,
                                multiLine: multiLine,
@@ skipping 60 matching lines @@
   Match firstMatch(String str) {
     List match = _ExecuteMatch(str, 0);
     if (match == null) {
       return null;
     }
     return new _JSRegExpMatch(this, str, match);
   }
 
   Iterable<Match> allMatches(String str) {
     if (str is! String) throw new ArgumentError(str);
-    List<Match> result = new List<Match>();
-    int length = str.length;
-    int index = 0;
-    while (true) {
-      List match = _ExecuteMatch(str, index);
-      if (match == null) {
-        break;
-      }
-      result.add(new _JSRegExpMatch(this, str, match));
-      // Find the index at which to start searching for the next match.
-      index = match[1];
-      if (match[0] == index) {
-        // Zero-length match.
-        if (index == length) {
-          break;
-        }
-        index++;
-      }
-    }
-    return result;
+    return new _AllMatchesIterable(this, str);
   }
 
   bool hasMatch(String str) {
     List match = _ExecuteMatch(str, 0);
     return (match == null) ? false : true;
   }
 
   String stringMatch(String str) {
     List match = _ExecuteMatch(str, 0);
     if (match == null) {
       return null;
     }
     return str._substringUnchecked(match[0], match[1]);
   }
 
   String get pattern native "JSSyntaxRegExp_getPattern";
 
   bool get isMultiLine native "JSSyntaxRegExp_getIsMultiLine";
 
   bool get isCaseSensitive native "JSSyntaxRegExp_getIsCaseSensitive";
 
   int get _groupCount native "JSSyntaxRegExp_getGroupCount";
 
   List _ExecuteMatch(String str, int start_index)
       native "JSSyntaxRegExp_ExecuteMatch";
 }
+
+class _AllMatchesIterable extends IterableBase<Match> {
+  final _JSSyntaxRegExp _re;
+  final String _str;
+
+  const _AllMatchesIterable(this._re, this._str);
+
+  Iterator<Match> get iterator => new _AllMatchesIterator(_re, _str);
+}
+
+class _AllMatchesIterator implements Iterator<Match> {
+  final String _str;
+  _JSSyntaxRegExp _re;
+  Match _current;
+
+  _AllMatchesIterator(this._re, this._str);
+
+  Match get current => _current;
+
+  bool moveNext() {
+    if (_re == null) return false;  // Cleared after a failed match.
+    int nextIndex = 0;
+    if (_current != null) {
+      nextIndex = _current.end;
+      if (nextIndex == _current.start) {
+        // Zero-width match. Advance by one more.
+        nextIndex++;
+        if (nextIndex > _str.length) {
+          _re = null;
+          _current = null;
+          return false;
+        }
+      }
+    }
+    var match = _re._ExecuteMatch(_str, nextIndex);
+    if (match == null) {
+      _current = null;
+      _re = null;
+      return false;
+    }
+    _current = new _JSRegExpMatch(_re, _str, match);
+    return true;
+  }
+}