[RegExp] NFA matching: implement copy-free prefix-tracking tryMatch and simplify and fix allMatches.

Author: renggli

lib/src/regexp/nfa.dart

@@ -11,10 +11,15 @@ class Nfa extends RegexpPattern {
   final NfaState end;
 
   @override
-  bool tryMatch(String input) {
+  int tryMatch(String input, int start, int end) {
+    var result = -1;
     var currentStates = <NfaState>{};
-    _addStates(start, currentStates);
-    for (final value in input.runes) {
+    _addStates(this.start, currentStates);
+    if (currentStates.any((state) => state.isEnd)) {
+      result = start;
+    }
+    for (var i = start; i < end; i++) {
+      final value = input.codeUnitAt(i);
       final nextStates = <NfaState>{};
       for (final state in currentStates) {
         final nextState = state.transitions[value];
@@ -25,10 +30,15 @@ class Nfa extends RegexpPattern {
           _addStates(nextState, nextStates);
         }
       }
-      if (nextStates.isEmpty) return false;
+      if (nextStates.isEmpty) {
+        break;
+      }
       currentStates = nextStates;
+      if (currentStates.any((state) => state.isEnd)) {
+        result = i + 1;
+      }
     }
-    return currentStates.any((state) => state.isEnd);
+    return result;
   }
 
   void _addStates(NfaState state, Set<NfaState> states) {
@@ -43,10 +53,7 @@ class NfaState {
   NfaState({required this.isEnd});
 
   bool isEnd;
-
   final Map<int, NfaState> transitions = {};
-
   final List<NfaState> epsilons = [];
-
   final List<NfaState> dots = [];
 }

lib/src/regexp/pattern.dart

@@ -1,23 +1,33 @@
 import 'package:meta/meta.dart';
 
 abstract class RegexpPattern implements Pattern {
-  // TODO: make it correctly match sub-strings
   @override
-  Match? matchAsPrefix(String input, [int start = 0]) =>
-      tryMatch(input.substring(start))
-      ? RegexpMatch(this, input, start, input.length)
-      : null;
+  Iterable<Match> allMatches(String input, [int start = 0]) sync* {
+    while (start <= input.length) {
+      final match = matchAsPrefix(input, start);
+      if (match == null) {
+        start++;
+      } else {
+        yield match;
+        start = match.start < match.end ? match.end : match.start + 1;
+      }
+    }
+  }
 
   @override
-  Iterable<Match> allMatches(String input, [int start = 0]) sync* {
-    for (var i = start; i < input.length; i++) {
-      final match = matchAsPrefix(input, i);
-      if (match != null) yield match;
+  Match? matchAsPrefix(String input, [int start = 0]) {
+    RangeError.checkValueInInterval(start, 0, input.length, 'start');
+    final end = tryMatch(input, start, input.length);
+    if (end >= start) {
+      return RegexpMatch(this, input, start, end);
     }
+    return null;
   }
 
+  /// Returns the end index (exclusive) of the longest prefix of [input] matched
+  /// by this pattern, or `-1` if no prefix of [input] matches.
   @internal
-  bool tryMatch(String input);
+  int tryMatch(String input, int start, int end);
 }
 
 class RegexpMatch implements Match {

test/regexp_test.dart

@@ -124,7 +124,8 @@ void main() {
         final pattern = Nfa.fromString(testData.pattern);
         for (final expectData in testData.expects) {
           expect(
-            pattern.tryMatch(expectData.input),
+            pattern.tryMatch(expectData.input, 0, expectData.input.length) ==
+                expectData.input.length,
             expectData.match,
             reason:
                 '"${testData.pattern}" '
@@ -153,11 +154,40 @@ void main() {
       expect(match[0], 'aaa');
       expect(match.groups([0, 1]), ['aaa', null]);
     });
+    test('matchAsPrefix with non-matching input', () {
+      final noMatch = pattern.matchAsPrefix('baaa');
+      expect(noMatch, isNull);
+    });
+    test('matchAsPrefix with start index', () {
+      final match = pattern.matchAsPrefix('baaa', 1)!;
+      expect(match.pattern, pattern);
+      expect(match.input, 'baaa');
+      expect(match.start, 1);
+      expect(match.end, 4);
+      expect(match.group(0), 'aaa');
+    });
     test('allMatches', () {
-      expect(pattern.allMatches('aaa').map((each) => each[0]), [
-        'aaa',
+      expect(pattern.allMatches('').map((each) => each[0]), []);
+      expect(pattern.allMatches('a').map((each) => each[0]), ['a']);
+      expect(pattern.allMatches('aa').map((each) => each[0]), ['aa']);
+      expect(pattern.allMatches('aaa').map((each) => each[0]), ['aaa']);
+      expect(pattern.allMatches('baab').map((each) => each[0]), ['aa']);
+      expect(pattern.allMatches('babaab').map((each) => each[0]), ['a', 'aa']);
+    });
+    test('allMatches with start index', () {
+      expect(pattern.allMatches('babaab', 2).map((each) => each[0]), ['aa']);
+      expect(pattern.allMatches('babaab', 3).map((each) => each[0]), ['aa']);
+      expect(pattern.allMatches('babaab', 4).map((each) => each[0]), ['a']);
+    });
+    test('allMatches with zero-length matches', () {
+      final starPattern = Node.fromString(r'a*').toNfa();
+      expect(starPattern.allMatches('').map((each) => each[0]), ['']);
+      expect(starPattern.allMatches('b').map((each) => each[0]), ['', '']);
+      expect(starPattern.allMatches('baab').map((each) => each[0]), [
+        '',
         'aa',
-        'a',
+        '',
+        '',
       ]);
     });
   });