Adjust some docs

Author: shilangyu

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

@@ -1453,7 +1453,7 @@ impl BoundedBacktracker {
     /// Execute a "step" in the backtracing algorithm.
     ///
     /// A "step" is somewhat of a misnomer, because this routine keeps going
-    /// until it either runs out of things to try or fins a match. In the
+    /// until it either runs out of things to try or finds a match. In the
     /// former case, it may have pushed some things on to the backtracking
     /// stack, in which case, those will be tried next as part of the
     /// 'backtrack' routine above.

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

@@ -92,7 +92,7 @@ enum State {
         next: StateID,
     },
     /// An empty state that behaves analogously to a `Match` state but for
-    /// the look-around sub-expression with the given index.
+    /// the look-around sub-expression with the given look-around 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`
@@ -484,17 +484,16 @@ impl Builder {
                     remap[sid] = nfa.add(nfa::State::Look { look, next });
                 }
                 State::WriteLookAround { lookaround_index } => {
-                    remap[sid] = nfa.add(nfa::State::WriteLookAround {
-                        lookaround_idx: lookaround_index,
-                    });
+                    remap[sid] = nfa
+                        .add(nfa::State::WriteLookAround { lookaround_index });
                 }
                 State::CheckLookAround {
                     lookaround_index,
                     positive,
                     next,
                 } => {
                     remap[sid] = nfa.add(nfa::State::CheckLookAround {
-                        lookaround_idx: lookaround_index,
+                        lookaround_index,
                         positive,
                         next,
                     });
@@ -722,7 +721,7 @@ impl Builder {
         self.add(State::Empty { next: StateID::ZERO })
     }
 
-    /// Add a state which will record that the lookaround with the given index
+    /// Add a state which will record that the look-around with the given index
     /// is satisfied at the current position.
     pub fn add_write_lookaround(
         &mut self,
@@ -731,7 +730,7 @@ impl Builder {
         self.add(State::WriteLookAround { lookaround_index: index })
     }
 
-    /// Add a state which will check whether the lookaround with the given
+    /// Add a state which will check whether the look-around with the given
     /// index is satisfied at the current position.
     pub fn add_check_lookaround(
         &mut self,

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

@@ -2036,14 +2036,14 @@ mod tests {
 
     fn s_write_lookaround(id: usize) -> State {
         State::WriteLookAround {
-            lookaround_idx: SmallIndex::new(id)
+            lookaround_index: SmallIndex::new(id)
                 .expect("look-around index too large"),
         }
     }
 
     fn s_check_lookaround(id: usize, positive: bool, next: usize) -> State {
         State::CheckLookAround {
-            lookaround_idx: SmallIndex::new(id)
+            lookaround_index: 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 look-around sub-expressions this nfa contains
+    /// Returns how many look-around sub-expressions this nfa contains.
     #[inline]
     pub fn lookaround_count(&self) -> usize {
         self.0.lookaround_count
@@ -1268,7 +1268,7 @@ pub(super) struct Inner {
     */
     /// How many look-around expression this NFA contains.
     /// This is needed to initialize the table for storing the result of
-    /// look-around evaluation
+    /// look-around evaluation.
     lookaround_count: usize,
     /// Heap memory used indirectly by NFA states and other things (like the
     /// various capturing group representations above). Since each state
@@ -1385,8 +1385,8 @@ impl Inner {
             State::Capture { .. } => {
                 self.has_capture = true;
             }
-            State::CheckLookAround { lookaround_idx: look_idx, .. }
-            | State::WriteLookAround { lookaround_idx: look_idx } => {
+            State::CheckLookAround { lookaround_index: look_idx, .. }
+            | State::WriteLookAround { lookaround_index: look_idx } => {
                 self.lookaround_count =
                     self.lookaround_count.max(look_idx.as_usize() + 1);
             }
@@ -1566,19 +1566,19 @@ pub enum State {
     },
     /// 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`.
+    /// look-around oracle at index `lookaround_index`.
     WriteLookAround {
         /// The index of the look-around expression that matches.
-        lookaround_idx: SmallIndex,
+        lookaround_index: SmallIndex,
     },
-    /// This indicates that we need to check whether lookaround expression with
-    /// index `lookaround_idx` holds at the current position in the haystack
-    /// If `positive` is false, then the lookaround expression is negative and
+    /// This indicates that we need to check whether look-around expression with
+    /// index `lookaround_index` holds at the current position in the haystack.
+    /// If `positive` is false, then the look-around expression is negative and
     /// hence must NOT hold.
     CheckLookAround {
         /// The index of the look-around expression that must be satisfied.
-        lookaround_idx: SmallIndex,
-        /// Whether this is a positive lookaround expression.
+        lookaround_index: SmallIndex,
+        /// Whether this is a positive look-around expression.
         positive: bool,
         /// The next state to transition if the look-around assertion is
         /// satisfied.
@@ -1795,11 +1795,11 @@ impl fmt::Debug for State {
             State::Look { ref look, next } => {
                 write!(f, "{:?} => {:?}", look, next.as_usize())
             }
-            State::WriteLookAround { lookaround_idx: look_idx } => {
+            State::WriteLookAround { lookaround_index: look_idx } => {
                 write!(f, "write-look-around({})", look_idx.as_u32())
             }
             State::CheckLookAround {
-                lookaround_idx: look_idx,
+                lookaround_index: look_idx,
                 positive,
                 next,
             } => {

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

@@ -1772,13 +1772,13 @@ impl PikeVM {
                     }
                     sid = next;
                 }
-                State::WriteLookAround { lookaround_idx: look_idx } => {
+                State::WriteLookAround { lookaround_index: look_idx } => {
                     // This is ok since `at` is always less than `usize::MAX`.
                     lookarounds[look_idx] = NonMaxUsize::new(at);
                     return;
                 }
                 State::CheckLookAround {
-                    lookaround_idx: look_idx,
+                    lookaround_index: look_idx,
                     positive,
                     next,
                 } => {
@@ -1973,8 +1973,8 @@ pub struct Cache {
     /// next byte in the haystack.
     next: ActiveStates,
     /// This answers the question: "What is the maximum position in the
-    /// haystack at which lookaround assertion x holds and which is <= to the
-    /// current position"
+    /// haystack at which look-around indexed x holds and which is <= to the
+    /// current position".
     lookaround: Vec<Option<NonMaxUsize>>,
 }
 

regex-syntax/src/hir/mod.rs

@@ -1819,7 +1819,7 @@ impl LookAround {
         }
     }
 
-    /// Returns a mutable reference to the inner expression
+    /// Returns a mutable reference to the inner expression.
     pub fn sub_mut(&mut self) -> &mut Hir {
         match self {
             Self::PositiveLookBehind(sub) | Self::NegativeLookBehind(sub) => {
@@ -2556,7 +2556,7 @@ impl Properties {
             look_set_prefix_any: LookSet::singleton(look),
             look_set_suffix_any: LookSet::singleton(look),
             // Note, this field represents _general_ lookarounds (ones using
-            // LookAround) and not simple ones (using Look).
+            // LookAround) and not assertions (using Look).
             contains_lookaround_expr: false,
             // This requires a little explanation. Basically, we don't consider
             // matching an empty string to be equivalent to matching invalid