Address review comments

Author: Multimodcrafter

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

@@ -41,9 +41,7 @@ enum State {
     },
     /// A state that only transitions to another state if the current input
     /// byte is in a particular range of bytes.
-    ByteRange {
-        trans: Transition,
-    },
+    ByteRange { trans: Transition },
     /// A state with possibly many transitions, represented in a sparse
     /// fashion. Transitions must be ordered lexicographically by input range
     /// and be non-overlapping. As such, this may only be used when every
@@ -57,15 +55,10 @@ enum State {
     /// that `Sparse` is used for via `Union`. But this creates a more bloated
     /// NFA with more epsilon transitions than is necessary in the special case
     /// of character classes.
-    Sparse {
-        transitions: Vec<Transition>,
-    },
+    Sparse { transitions: Vec<Transition> },
     /// A conditional epsilon transition satisfied via some sort of
     /// look-around.
-    Look {
-        look: Look,
-        next: StateID,
-    },
+    Look { look: Look, next: StateID },
     /// An empty state that records the start of a capture location. This is an
     /// unconditional epsilon transition like `Empty`, except it can be used to
     /// record position information for a capture group when using the NFA for
@@ -98,20 +91,21 @@ enum State {
         /// The next state that this state should transition to.
         next: StateID,
     },
-    WriteLookaround {
-        lookaround_index: usize,
-    },
+    /// An empty state that behaves analogously to a `Match` state but for
+    /// the look-around sub-expression with the given index.
+    WriteLookaround { lookaround_index: SmallIndex },
+    /// A conditional epsilon transition that will only be taken if the
+    /// look-around sub-expression with the given index evaluates to `positive`
+    /// at the current position in the haystack.
     CheckLookaround {
-        lookaround_index: usize,
+        lookaround_index: SmallIndex,
         positive: bool,
         next: StateID,
     },
     /// An alternation such that there exists an epsilon transition to all
     /// states in `alternates`, where matches found via earlier transitions
     /// are preferred over later transitions.
-    Union {
-        alternates: Vec<StateID>,
-    },
+    Union { alternates: Vec<StateID> },
     /// An alternation such that there exists an epsilon transition to all
     /// states in `alternates`, where matches found via later transitions are
     /// preferred over earlier transitions.
@@ -127,9 +121,7 @@ enum State {
     /// to be amortized constant time. But if we used a `Union`, we'd need to
     /// prepend the state, which takes O(n) time. There are other approaches we
     /// could use to solve this, but this seems simple enough.
-    UnionReverse {
-        alternates: Vec<StateID>,
-    },
+    UnionReverse { alternates: Vec<StateID> },
     /// A state that cannot be transitioned out of. This is useful for cases
     /// where you want to prevent matching from occurring. For example, if your
     /// regex parser permits empty character classes, then one could choose a
@@ -143,9 +135,7 @@ enum State {
     ///
     /// `pattern_id` refers to the ID of the pattern itself, which corresponds
     /// to the pattern's index (starting at 0).
-    Match {
-        pattern_id: PatternID,
-    },
+    Match { pattern_id: PatternID },
 }
 
 impl State {
@@ -736,7 +726,7 @@ impl Builder {
     /// is satisfied at the current position.
     pub fn add_write_lookaround(
         &mut self,
-        index: usize,
+        index: SmallIndex,
     ) -> Result<StateID, BuildError> {
         self.add(State::WriteLookaround { lookaround_index: index })
     }
@@ -745,7 +735,7 @@ impl Builder {
     /// index is satisfied at the current position.
     pub fn add_check_lookaround(
         &mut self,
-        index: usize,
+        index: SmallIndex,
         positive: bool,
         next: StateID,
     ) -> Result<StateID, BuildError> {

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

@@ -19,7 +19,7 @@ use crate::{
     },
     util::{
         look::{Look, LookMatcher},
-        primitives::{PatternID, StateID},
+        primitives::{PatternID, SmallIndex, StateID},
     },
 };
 
@@ -1681,14 +1681,14 @@ impl Compiler {
 
     fn add_write_lookaround(
         &self,
-        index: usize,
+        index: SmallIndex,
     ) -> Result<StateID, BuildError> {
         self.builder.borrow_mut().add_write_lookaround(index)
     }
 
     fn add_check_lookaround(
         &self,
-        index: usize,
+        index: SmallIndex,
         positive: bool,
     ) -> Result<StateID, BuildError> {
         self.builder.borrow_mut().add_check_lookaround(

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

@@ -1102,8 +1102,8 @@ impl NFA {
 
     /// Returns how many lookaround sub-expressions this nfa contains
     #[inline]
-    pub fn look_count(&self) -> usize {
-        self.0.look_count
+    pub fn lookaround_count(&self) -> SmallIndex {
+        self.0.lookaround_count
     }
 
     // FIXME: The `look_set_prefix_all` computation was not correct, and it
@@ -1266,7 +1266,10 @@ pub(super) struct Inner {
     /// zero-length prefix for any of the patterns in this NFA.
     look_set_prefix_all: LookSet,
     */
-    look_count: usize,
+    /// How many look-around expression this NFA contains.
+    /// This is needed to initialize the table for storing the result of
+    /// look-around evaluation
+    lookaround_count: SmallIndex,
     /// 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
@@ -1384,7 +1387,7 @@ impl Inner {
             }
             State::CheckLookaround { look_idx, .. }
             | State::WriteLookaround { look_idx } => {
-                self.look_count = self.look_count.max(look_idx);
+                self.lookaround_count = self.lookaround_count.max(look_idx);
             }
             State::Union { .. }
             | State::BinaryUnion { .. }
@@ -1565,15 +1568,15 @@ pub enum State {
     /// index `look_idx`
     WriteLookaround {
         /// The index of the lookaround expression that matches
-        look_idx: usize,
+        look_idx: SmallIndex,
     },
     /// This indicates that we need to check whether lookaround expression with
     /// index `look_idx` holds at the current position in the haystack
     /// If `positive` is false, then the lookaround expression is negative and
     /// hence must NOT hold.
     CheckLookaround {
         /// The index of the lookaround expression that must be satisfied
-        look_idx: usize,
+        look_idx: SmallIndex,
         /// Whether this is a positive lookaround expression
         positive: bool,
         /// The next state to transition if the lookaround assertion is satisfied
@@ -1791,13 +1794,13 @@ impl fmt::Debug for State {
                 write!(f, "{:?} => {:?}", look, next.as_usize())
             }
             State::WriteLookaround { look_idx } => {
-                write!(f, "Write Lookaround: {}", look_idx)
+                write!(f, "Write Lookaround: {}", look_idx.as_u32())
             }
             State::CheckLookaround { look_idx, positive, next } => {
                 write!(
                     f,
                     "Check Lookaround {} is {} => {}",
-                    look_idx,
+                    look_idx.as_u32(),
                     positive,
                     next.as_usize()
                 )

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

@@ -1216,8 +1216,8 @@ impl PikeVM {
 }
 
 impl PikeVM {
-    fn look_count(&self) -> usize {
-        self.nfa.look_count()
+    fn lookaround_count(&self) -> SmallIndex {
+        self.nfa.lookaround_count()
     }
 
     /// The implementation of standard leftmost search.
@@ -1984,7 +1984,7 @@ impl Cache {
             next: ActiveStates::new(re),
             lookaround: {
                 let mut res = Vec::new();
-                res.resize(re.look_count(), false);
+                res.resize(re.lookaround_count().as_usize(), false);
                 res
             },
         }