Proof-of-concept matchPrefix on Pattern.

sdk/lib/_internal/compiler/implementation/lib/regexp_helper.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 _js_helper;
 
 // Helper method used by internal libraries.
 regExpGetNative(JSSyntaxRegExp regexp) => regexp._nativeRegExp;
 
 class JSSyntaxRegExp implements RegExp {
@@ skipping 15 matching lines @@
                  {bool multiLine: false,
                   bool caseSensitive: true})
       : this._internal(pattern, multiLine, caseSensitive, false);
 
   JSSyntaxRegExp._globalVersionOf(JSSyntaxRegExp other)
       : this._internal(other.pattern,
                        other.isMultiLine,
                        other.isCaseSensitive,
                        true);
 
+  JSSyntaxRegExp._anchoredVersionOf(JSSyntaxRegExp other)
+      : this._internal(other.pattern + "|()",
+                       other.isMultiLine,
+                       other.isCaseSensitive,
+                       true);
+
   static makeNative(
       String pattern, bool multiLine, bool caseSensitive, bool global) {
     checkString(pattern);
     String m = multiLine ? 'm' : '';
     String i = caseSensitive ? '' : 'i';
     String g = global ? 'g' : '';
     // We're using the JavaScript's try catch instead of the Dart one
     // to avoid dragging in Dart runtime support just because of using
     // RegExp.
     var regexp = JS('',
@@ skipping 29 matching lines @@
   String stringMatch(String str) {
     var match = firstMatch(str);
     return match == null ? null : match.group(0);
   }
 
   Iterable<Match> allMatches(String str) {
     checkString(str);
     return new _AllMatchesIterable(this, str);
   }
 
+  Match matchAsPrefix(String string, [int start = 0]) {
+    if (start < 0 || start > string.length) {
+      throw new RangeError.range(start, 0, string.length);
+    }
+    // An "anchored version" of a regexp is created by adding "|()" to the
+    // source. This means that the regexp always matches at the first position
+    // that it tries, and you can see if the original regexp matched, or it
+    // was the added zero-width match that matched, by looking at the last
+    // capture. If it is a String, the match participated, otherwise it didn't.
+    JSSyntaxRegExp regexp = new JSSyntaxRegExp._anchoredVersionOf(this);
+    if (start > 0) {
+      JS("void", "#.lastIndex = #", regExpGetNative(regexp), start);
+    }
+    _MatchImplementation match = regexp.firstMatch(string);
+    if (match == null) return null;
+    if (match._groups[match._groups.length - 1] != null) return null;
+    match._groups.length -= 1;
+    return match;
+  }
+
   String get pattern => _pattern;
   bool get isMultiLine => _isMultiLine;
   bool get isCaseSensitive => _isCaseSensitive;
 }
 
 class _MatchImplementation implements Match {
   final String pattern;
   final String str;
   final int start;
   final int end;
@@ skipping 42 matching lines @@
     // firstMatch actually acts as nextMatch because of
     // hidden global flag.
     if (_current != null && _current.start == _current.end) {
       // Advance implicit start-position if last match was empty.
       JS("void", "#.lastIndex++", regExpGetNative(_re));
     }
     _current = _re.firstMatch(_str);
     return _current != null;
   }
 }