Address review comments

Rename certain enums to be consistent with rest of codebase.

Author: Multimodcrafter

regex-automata/src/dfa/onepass.rs

@@ -638,8 +638,8 @@ impl<'a> InternalBuilder<'a> {
             self.stack_push(nfa_id, Epsilons::empty())?;
             while let Some((id, epsilons)) = self.stack.pop() {
                 match *self.nfa.state(id) {
-                    thompson::State::WriteLookaround { .. }
-                    | thompson::State::CheckLookaround { .. } => {
+                    thompson::State::WriteLookAround { .. }
+                    | thompson::State::CheckLookAround { .. } => {
                         todo!("check how to handle")
                     }
                     thompson::State::ByteRange { ref trans } => {

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

@@ -1519,8 +1519,8 @@ impl BoundedBacktracker {
                     }
                     sid = next;
                 }
-                State::WriteLookaround { .. }
-                | State::CheckLookaround { .. } => {
+                State::WriteLookAround { .. }
+                | State::CheckLookAround { .. } => {
                     todo!("check how to handle")
                 }
                 State::Union { ref alternates } => {

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

@@ -93,11 +93,11 @@ enum State {
     },
     /// 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 },
+    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 {
+    CheckLookAround {
         lookaround_index: SmallIndex,
         positive: bool,
         next: StateID,
@@ -166,8 +166,8 @@ impl State {
             | State::CaptureEnd { .. }
             | State::Fail
             | State::Match { .. }
-            | State::CheckLookaround { .. }
-            | State::WriteLookaround { .. } => 0,
+            | State::CheckLookAround { .. }
+            | State::WriteLookAround { .. } => 0,
             State::Sparse { ref transitions } => {
                 transitions.len() * mem::size_of::<Transition>()
             }
@@ -483,18 +483,18 @@ impl Builder {
                 State::Look { look, next } => {
                     remap[sid] = nfa.add(nfa::State::Look { look, next });
                 }
-                State::WriteLookaround { lookaround_index } => {
-                    remap[sid] = nfa.add(nfa::State::WriteLookaround {
-                        look_idx: lookaround_index,
+                State::WriteLookAround { lookaround_index } => {
+                    remap[sid] = nfa.add(nfa::State::WriteLookAround {
+                        lookaround_idx: lookaround_index,
                     });
                 }
-                State::CheckLookaround {
+                State::CheckLookAround {
                     lookaround_index,
                     positive,
                     next,
                 } => {
-                    remap[sid] = nfa.add(nfa::State::CheckLookaround {
-                        look_idx: lookaround_index,
+                    remap[sid] = nfa.add(nfa::State::CheckLookAround {
+                        lookaround_idx: lookaround_index,
                         positive,
                         next,
                     });
@@ -728,7 +728,7 @@ impl Builder {
         &mut self,
         index: SmallIndex,
     ) -> Result<StateID, BuildError> {
-        self.add(State::WriteLookaround { lookaround_index: index })
+        self.add(State::WriteLookAround { lookaround_index: index })
     }
 
     /// Add a state which will check whether the lookaround with the given
@@ -739,7 +739,7 @@ impl Builder {
         positive: bool,
         next: StateID,
     ) -> Result<StateID, BuildError> {
-        self.add(State::CheckLookaround {
+        self.add(State::CheckLookAround {
             lookaround_index: index,
             positive,
             next,
@@ -1212,7 +1212,7 @@ impl Builder {
             State::Look { ref mut next, .. } => {
                 *next = to;
             }
-            State::CheckLookaround { ref mut next, .. } => {
+            State::CheckLookAround { ref mut next, .. } => {
                 *next = to;
             }
             State::Union { ref mut alternates } => {
@@ -1229,7 +1229,7 @@ impl Builder {
             State::CaptureEnd { ref mut next, .. } => {
                 *next = to;
             }
-            State::WriteLookaround { .. } => {}
+            State::WriteLookAround { .. } => {}
             State::Fail => {}
             State::Match { .. } => {}
         }

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

@@ -1045,10 +1045,7 @@ impl Compiler {
         &self,
         lookaround: &LookAround,
     ) -> Result<ThompsonRef, BuildError> {
-        let sub = match lookaround {
-            LookAround::NegativeLookBehind(ref sub)
-            | LookAround::PositiveLookBehind(ref sub) => self.c(sub)?,
-        };
+        let sub = self.c(lookaround.sub());
         let pos = match lookaround {
             LookAround::NegativeLookBehind(_) => false,
             LookAround::PositiveLookBehind(_) => true,
@@ -1064,7 +1061,7 @@ impl Compiler {
         self.patch(
             self.lookaround_alt
                 .borrow()
-                .expect("Cannot compile lookaround outside pattern"),
+                .expect("Cannot compile look-around outside pattern"),
             sub.start,
         )?;
         Ok(ThompsonRef { start: check, end: check })
@@ -2038,15 +2035,15 @@ mod tests {
     }
 
     fn s_write_lookaround(id: usize) -> State {
-        State::WriteLookaround {
-            look_idx: SmallIndex::new(id)
+        State::WriteLookAround {
+            lookaround_idx: SmallIndex::new(id)
                 .expect("look-around index too large"),
         }
     }
 
     fn s_check_lookaround(id: usize, positive: bool, next: usize) -> State {
-        State::CheckLookaround {
-            look_idx: SmallIndex::new(id)
+        State::CheckLookAround {
+            lookaround_idx: SmallIndex::new(id)
                 .expect("look-around index too large"),
             positive,
             next: sid(next),

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

@@ -1100,7 +1100,7 @@ impl NFA {
         self.0.look_set_prefix_any
     }
 
-    /// Returns how many lookaround sub-expressions this nfa contains
+    /// Returns how many look-around sub-expressions this nfa contains
     #[inline]
     pub fn lookaround_count(&self) -> SmallIndex {
         self.0.lookaround_count
@@ -1299,8 +1299,8 @@ impl Inner {
                     State::ByteRange { .. }
                     | State::Dense { .. }
                     | State::Fail
-                    | State::WriteLookaround { .. } => continue,
-                    State::CheckLookaround { next, .. } => {
+                    | State::WriteLookAround { .. } => continue,
+                    State::CheckLookAround { next, .. } => {
                         stack.push(next);
                     }
                     State::Sparse(_) => {
@@ -1385,8 +1385,8 @@ impl Inner {
             State::Capture { .. } => {
                 self.has_capture = true;
             }
-            State::CheckLookaround { look_idx, .. }
-            | State::WriteLookaround { look_idx } => {
+            State::CheckLookAround { lookaround_idx: look_idx, .. }
+            | State::WriteLookAround { lookaround_idx: look_idx } => {
                 self.lookaround_count = self.lookaround_count.max(look_idx);
             }
             State::Union { .. }
@@ -1563,23 +1563,24 @@ pub enum State {
         /// satisfied.
         next: StateID,
     },
-    /// This is like a match state but for a lookaround expression
-    /// executing this state will write a `true` into the lookaround oracle at
-    /// index `look_idx`
-    WriteLookaround {
-        /// The index of the lookaround expression that matches
-        look_idx: SmallIndex,
+    /// This is like a match state but for a look-around expression.
+    /// Executing this state will write the current haystack offset into the
+    /// look-around oracle at index `lookaround_idx`.
+    WriteLookAround {
+        /// The index of the look-around expression that matches.
+        lookaround_idx: SmallIndex,
     },
     /// This indicates that we need to check whether lookaround expression with
-    /// index `look_idx` holds at the current position in the haystack
+    /// index `lookaround_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: SmallIndex,
-        /// Whether this is a positive lookaround expression
+    CheckLookAround {
+        /// The index of the look-around expression that must be satisfied.
+        lookaround_idx: SmallIndex,
+        /// Whether this is a positive lookaround expression.
         positive: bool,
-        /// The next state to transition if the lookaround assertion is satisfied
+        /// The next state to transition if the look-around assertion is
+        /// satisfied.
         next: StateID,
     },
     /// An alternation such that there exists an epsilon transition to all
@@ -1696,12 +1697,12 @@ impl State {
             | State::Dense { .. }
             | State::Fail
             | State::Match { .. }
-            | State::WriteLookaround { .. } => false,
+            | State::WriteLookAround { .. } => false,
             State::Look { .. }
             | State::Union { .. }
             | State::BinaryUnion { .. }
             | State::Capture { .. }
-            | State::CheckLookaround { .. } => true,
+            | State::CheckLookAround { .. } => true,
         }
     }
 
@@ -1714,8 +1715,8 @@ impl State {
             | State::Capture { .. }
             | State::Match { .. }
             | State::Fail
-            | State::WriteLookaround { .. }
-            | State::CheckLookaround { .. } => 0,
+            | State::WriteLookAround { .. }
+            | State::CheckLookAround { .. } => 0,
             State::Sparse(SparseTransitions { ref transitions }) => {
                 transitions.len() * mem::size_of::<Transition>()
             }
@@ -1748,7 +1749,7 @@ impl State {
                 }
             }
             State::Look { ref mut next, .. } => *next = remap[*next],
-            State::CheckLookaround { ref mut next, .. } => {
+            State::CheckLookAround { ref mut next, .. } => {
                 *next = remap[*next]
             }
             State::Union { ref mut alternates } => {
@@ -1763,7 +1764,7 @@ impl State {
             State::Capture { ref mut next, .. } => *next = remap[*next],
             State::Fail
             | State::Match { .. }
-            | State::WriteLookaround { .. } => {}
+            | State::WriteLookAround { .. } => {}
         }
     }
 }
@@ -1793,15 +1794,19 @@ impl fmt::Debug for State {
             State::Look { ref look, next } => {
                 write!(f, "{:?} => {:?}", look, next.as_usize())
             }
-            State::WriteLookaround { look_idx } => {
-                write!(f, "Write Lookaround: {}", look_idx.as_u32())
+            State::WriteLookAround { lookaround_idx: look_idx } => {
+                write!(f, "write-look-around({})", look_idx.as_u32())
             }
-            State::CheckLookaround { look_idx, positive, next } => {
+            State::CheckLookAround {
+                lookaround_idx: look_idx,
+                positive,
+                next,
+            } => {
                 write!(
                     f,
-                    "Check Lookaround {} is {} => {}",
+                    "check-look-around({} is {}) => {}",
                     look_idx.as_u32(),
-                    positive,
+                    if positive { "matched" } else { "not matched" },
                     next.as_usize()
                 )
             }

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

@@ -1593,8 +1593,8 @@ impl PikeVM {
             | State::Union { .. }
             | State::BinaryUnion { .. }
             | State::Capture { .. }
-            | State::WriteLookaround { .. }
-            | State::CheckLookaround { .. } => None,
+            | State::WriteLookAround { .. }
+            | State::CheckLookAround { .. } => None,
             State::ByteRange { ref trans } => {
                 if trans.matches(input.haystack(), at) {
                     let slots = curr_slot_table.for_state(sid);
@@ -1772,12 +1772,16 @@ impl PikeVM {
                     }
                     sid = next;
                 }
-                State::WriteLookaround { look_idx } => {
+                State::WriteLookAround { lookaround_idx: look_idx } => {
                     // This is ok since `at` is always less than `usize::MAX`.
                     lookarounds[look_idx] = NonMaxUsize::new(at);
                     return;
                 }
-                State::CheckLookaround { look_idx, positive, next } => {
+                State::CheckLookAround {
+                    lookaround_idx: look_idx,
+                    positive,
+                    next,
+                } => {
                     let state = match lookarounds[look_idx] {
                         None => usize::MAX,
                         Some(pos) => pos.get(),
@@ -1988,11 +1992,7 @@ impl Cache {
             stack: vec![],
             curr: ActiveStates::new(re),
             next: ActiveStates::new(re),
-            lookaround: {
-                let mut res = Vec::new();
-                res.resize(re.lookaround_count().as_usize(), None);
-                res
-            },
+            lookaround: vec![None; re.lookaround_count().as_usize()],
         }
     }
 

regex-automata/src/util/determinize/mod.rs

@@ -251,8 +251,8 @@ pub(crate) fn next(
             | thompson::State::Fail
             | thompson::State::Look { .. }
             | thompson::State::Capture { .. } => {}
-            thompson::State::CheckLookaround { .. }
-            | thompson::State::WriteLookaround { .. } => {
+            thompson::State::CheckLookAround { .. }
+            | thompson::State::WriteLookAround { .. } => {
                 todo!("check how to handle")
             }
             thompson::State::Match { pattern_id } => {
@@ -403,8 +403,8 @@ pub(crate) fn epsilon_closure(
                 | thompson::State::Dense { .. }
                 | thompson::State::Fail
                 | thompson::State::Match { .. } => break,
-                thompson::State::WriteLookaround { .. }
-                | thompson::State::CheckLookaround { .. } => {
+                thompson::State::WriteLookAround { .. }
+                | thompson::State::CheckLookAround { .. } => {
                     todo!("check how to handle")
                 }
                 thompson::State::Look { look, next } => {
@@ -473,8 +473,8 @@ pub(crate) fn add_nfa_states(
                 builder.add_nfa_state_id(nfa_id);
                 builder.set_look_need(|need| need.insert(look));
             }
-            thompson::State::CheckLookaround { .. }
-            | thompson::State::WriteLookaround { .. } => {
+            thompson::State::CheckLookAround { .. }
+            | thompson::State::WriteLookAround { .. } => {
                 todo!("check how to handle")
             }
             thompson::State::Union { .. }

regex-syntax/src/hir/mod.rs

@@ -2139,8 +2139,6 @@ impl Properties {
     ///
     /// Only returns true for [`HirKind::LookAround`] and not for
     /// [`HirKind::Look`], which can be queried by [`look_set`] instead.
-    /// Currently, only lookbehind assertions without capture groups are
-    /// supported.
     #[inline]
     pub fn contains_lookaround_expr(&self) -> bool {
         self.0.contains_lookaround_expr