Keep track of maximum look-behind length

Author: shilangyu

regex-automata/src/nfa/thompson/builder.rs

@@ -342,6 +342,9 @@ pub struct Builder {
     start_pattern: Vec<StateID>,
     /// The starting states for each individual look-behind sub-expression.
     start_look_behind: Vec<StateID>,
+    /// The length (in bytes) of the longest string matched by any
+    /// look-behind sub-expression. If `None`, the length is unbounded.
+    maximum_look_behind_len: Option<usize>,
     /// A map from pattern ID to capture group index to name. (If no name
     /// exists, then a None entry is present. Thus, all capturing groups are
     /// present in this mapping.)
@@ -374,7 +377,7 @@ pub struct Builder {
 impl Builder {
     /// Create a new builder for hand-assembling NFAs.
     pub fn new() -> Builder {
-        Builder::default()
+        Builder { maximum_look_behind_len: Some(0), ..Builder::default() }
     }
 
     /// Clear this builder.
@@ -453,6 +456,7 @@ impl Builder {
 
         nfa.set_starts(start_anchored, start_unanchored, &self.start_pattern);
         nfa.set_look_behind_starts(self.start_look_behind.as_slice());
+        nfa.set_maximum_look_behind_len(self.maximum_look_behind_len);
         nfa.set_captures(&self.captures).map_err(BuildError::captures)?;
         // The idea here is to convert our intermediate states to their final
         // form. The only real complexity here is the process of converting
@@ -711,9 +715,21 @@ impl Builder {
     }
 
     /// Adds the `start_id` to the set of starting states that is used when
-    /// running look-behind expressions.
-    pub fn start_look_behind(&mut self, start_id: StateID) {
+    /// running look-behind expressions. Additionally registers the maximum
+    /// length (in bytes) that the sub-expression of the look-behind can match.
+    pub fn start_look_behind(
+        &mut self,
+        start_id: StateID,
+        maximum_len: Option<usize>,
+    ) {
         self.start_look_behind.push(start_id);
+
+        self.maximum_look_behind_len =
+            match (self.maximum_look_behind_len, maximum_len) {
+                (Some(l1), Some(l2)) => Some(usize::max(l1, l2)),
+                // A None subsumes the entire result.
+                (None, _) | (_, None) => None,
+            };
     }
 
     /// Add an "empty" NFA state.

regex-automata/src/nfa/thompson/compiler.rs

@@ -1039,7 +1039,10 @@ impl Compiler {
 
         let unanchored =
             self.c_at_least(&Hir::dot(hir::Dot::AnyByte), false, 0)?;
-        self.builder.borrow_mut().start_look_behind(unanchored.start);
+        let maximum_len = lookaround.sub().properties().maximum_len();
+        self.builder
+            .borrow_mut()
+            .start_look_behind(unanchored.start, maximum_len);
 
         let sub = self.c(lookaround.sub())?;
         let write = self.add_write_lookaround(idx)?;

regex-automata/src/nfa/thompson/nfa.rs

@@ -1112,6 +1112,13 @@ impl NFA {
         &self.0.start_look_behind
     }
 
+    /// Returns the length (in bytes) of the longest string matched by any
+    /// look-behind sub-expression. If `None`, the length is unbounded.
+    #[inline]
+    pub fn maximum_look_behind_len(&self) -> Option<usize> {
+        self.0.maximum_look_behind_len
+    }
+
     // FIXME: The `look_set_prefix_all` computation was not correct, and it
     // seemed a little tricky to fix it. Since I wasn't actually using it for
     // anything, I just decided to remove it in the run up to the regex 1.9
@@ -1279,6 +1286,9 @@ pub(super) struct Inner {
     lookaround_count: usize,
     /// Contains the start state for each of the look-behind subexpressions.
     start_look_behind: Vec<StateID>,
+    /// The length (in bytes) of the longest string matched by any
+    /// look-behind sub-expression. If `None`, the length is unbounded.
+    maximum_look_behind_len: Option<usize>,
     /// Heap memory used indirectly by NFA states and other things (like the
     /// various capturing group representations above). Since each state
     /// might use a different amount of heap, we need to keep track of this
@@ -1435,6 +1445,13 @@ impl Inner {
         self.start_look_behind = look_behind_starts.to_vec();
     }
 
+    pub(super) fn set_maximum_look_behind_len(
+        &mut self,
+        maximum_look_behind_len: Option<usize>,
+    ) {
+        self.maximum_look_behind_len = maximum_look_behind_len;
+    }
+
     /// Sets the UTF-8 mode of this NFA.
     pub(super) fn set_utf8(&mut self, yes: bool) {
         self.utf8 = yes;