automata: make the PikeVM optional in the meta engine

Author: jerguslejko

regex-automata/src/meta/error.rs

@@ -205,6 +205,10 @@ impl RetryFailError {
     pub(crate) fn from_offset(offset: usize) -> RetryFailError {
         RetryFailError { offset }
     }
+
+    pub(crate) fn offset(&self) -> usize {
+        self.offset
+    }
 }
 
 #[cfg(feature = "std")]

regex-automata/src/meta/regex.rs

@@ -24,7 +24,9 @@ use crate::{
         pool::{Pool, PoolGuard},
         prefilter::Prefilter,
         primitives::{NonMaxUsize, PatternID},
-        search::{HalfMatch, Input, Match, MatchKind, PatternSet, Span},
+        search::{
+            HalfMatch, Input, Match, MatchError, MatchKind, PatternSet, Span,
+        },
     },
 };
 
@@ -540,6 +542,59 @@ impl Regex {
         result
     }
 
+    /// Executes a leftmost is-match search, returning an error instead of
+    /// falling back to the PikeVM.
+    ///
+    /// This is like [`Regex::is_match`], but for a `Regex` built with
+    /// [`Config::pikevm`] disabled. The meta regex engine's fast engines (the
+    /// DFAs) can give up on a search, either because a lazy DFA's cache is
+    /// being used ineffectively or because a Unicode word boundary was seen
+    /// alongside a non-ASCII byte. Without the PikeVM to fall back to, such a
+    /// search has no engine left to run, and this routine reports that as a
+    /// [`MatchError`] rather than paying for the PikeVM's NFA simulation.
+    /// Fallbacks with bounded runtime (the one-pass DFA and the bounded
+    /// backtracker) are still used when the meta engine would otherwise
+    /// choose them.
+    ///
+    /// A `Regex` built with the PikeVM enabled (the default) never returns an
+    /// error here.
+    ///
+    /// This is a `topk-io/regex` fork addition.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex_automata::meta::Regex;
+    ///
+    /// let re = Regex::builder()
+    ///     .configure(Regex::config().pikevm(false))
+    ///     .build(r"\b\w+\b")?;
+    /// let mut cache = re.create_cache();
+    ///
+    /// assert_eq!(Ok(true), re.try_is_match_with(&mut cache, "quux"));
+    /// // A Unicode word boundary against a long non-ASCII haystack makes the
+    /// // lazy DFA quit, and the haystack is too long for the backtracker.
+    /// let haystack = "☃".repeat(100);
+    /// assert!(re.try_is_match_with(&mut cache, &haystack).is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn try_is_match_with<'h, I: Into<Input<'h>>>(
+        &self,
+        cache: &mut Cache,
+        input: I,
+    ) -> Result<bool, MatchError> {
+        let input = input.into().earliest(true);
+        if self.imp.info.is_impossible(&input) {
+            return Ok(false);
+        }
+        self.imp
+            .strat
+            .try_is_match(cache, &input)
+            .map_err(|err| MatchError::gave_up(err.offset()))
+    }
+
     /// Executes a leftmost search and returns the first match that is found,
     /// if one exists.
     ///
@@ -2481,6 +2536,7 @@ pub struct Config {
     dfa_state_limit: Option<Option<usize>>,
     onepass: Option<bool>,
     backtrack: Option<bool>,
+    pikevm: Option<bool>,
     byte_classes: Option<bool>,
     line_terminator: Option<u8>,
 }
@@ -3097,6 +3153,26 @@ impl Config {
         Config { backtrack: Some(yes), ..self }
     }
 
+    /// Whether to permit the use of the PikeVM.
+    ///
+    /// The PikeVM is the meta regex engine's engine of last resort: it can
+    /// handle any regex against any haystack, but its NFA simulation can be
+    /// orders of magnitude slower than the DFAs. Disabling it means a search
+    /// that the faster engines give up on has nothing left to fall back to.
+    /// Only [`Regex::try_is_match_with`] can report that condition, by
+    /// returning a [`MatchError`]; the other search routines require the
+    /// PikeVM and will panic if it is disabled.
+    ///
+    /// This is useful for rejecting a pathological regex outright rather than
+    /// paying for it.
+    ///
+    /// This is enabled by default.
+    ///
+    /// This is a `topk-io/regex` fork addition.
+    pub fn pikevm(self, yes: bool) -> Config {
+        Config { pikevm: Some(yes), ..self }
+    }
+
     /// Returns the match kind on this configuration, as set by
     /// [`Config::match_kind`].
     ///
@@ -3270,6 +3346,13 @@ impl Config {
         }
     }
 
+    /// Returns whether the PikeVM may be used, as set by [`Config::pikevm`].
+    ///
+    /// This is a `topk-io/regex` fork addition.
+    pub fn get_pikevm(&self) -> bool {
+        self.pikevm.unwrap_or(true)
+    }
+
     /// Returns a "baseline" Thompson configuration for constructing NFAs based
     /// on this configuration.
     ///
@@ -3315,6 +3398,7 @@ impl Config {
             dfa_state_limit: o.dfa_state_limit.or(self.dfa_state_limit),
             onepass: o.onepass.or(self.onepass),
             backtrack: o.backtrack.or(self.backtrack),
+            pikevm: o.pikevm.or(self.pikevm),
             byte_classes: o.byte_classes.or(self.byte_classes),
             line_terminator: o.line_terminator.or(self.line_terminator),
         }

regex-automata/src/meta/strategy.rs

@@ -61,7 +61,18 @@ pub(super) trait Strategy:
         input: &Input<'_>,
     ) -> Option<HalfMatch>;
 
-    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool;
+    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
+        self.try_is_match(cache, input)
+            .expect("PikeVM is disabled, use Regex::try_is_match_with")
+    }
+
+    // Returns an error only when the search needed the PikeVM but it was
+    // disabled via 'Config::pikevm'.
+    fn try_is_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError>;
 
     fn search_slots(
         &self,
@@ -414,8 +425,12 @@ impl<P: PrefilterI> Strategy for Pre<P> {
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
-        self.search(cache, input).is_some()
+    fn try_is_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError> {
+        Ok(self.search(cache, input).is_some())
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
@@ -590,7 +605,7 @@ impl Core {
             e.search_slots(&mut cache.backtrack, input, caps.slots_mut())
         } else {
             trace!("using PikeVM for search at {:?}", input.get_span());
-            let e = self.pikevm.get();
+            let e = self.pikevm.get().expect("PikeVM is required");
             e.search_slots(&mut cache.pikevm, input, caps.slots_mut())
         };
         caps.set_pattern(pid);
@@ -633,31 +648,38 @@ impl Core {
                 "using PikeVM for capture search at {:?}",
                 input.get_span()
             );
-            let e = self.pikevm.get();
+            let e = self.pikevm.get().expect("PikeVM is required");
             e.search_slots(&mut cache.pikevm, input, slots)
         }
     }
 
-    fn is_match_nofail(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
+    fn try_is_match_nofail(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError> {
         if let Some(ref e) = self.onepass.get(input) {
             trace!(
                 "using OnePass for is-match search at {:?}",
                 input.get_span()
             );
-            e.search_slots(&mut cache.onepass, input, &mut []).is_some()
+            Ok(e.search_slots(&mut cache.onepass, input, &mut []).is_some())
         } else if let Some(ref e) = self.backtrack.get(input) {
             trace!(
                 "using BoundedBacktracker for is-match search at {:?}",
                 input.get_span()
             );
-            e.is_match(&mut cache.backtrack, input)
+            Ok(e.is_match(&mut cache.backtrack, input))
         } else {
             trace!(
                 "using PikeVM for is-match search at {:?}",
                 input.get_span()
             );
-            let e = self.pikevm.get();
-            e.is_match(&mut cache.pikevm, input)
+            let e = self
+                .pikevm
+                .get()
+                .ok_or_else(|| RetryFailError::from_offset(input.start()))?;
+            Ok(e.is_match(&mut cache.pikevm, input))
         }
     }
 
@@ -769,17 +791,21 @@ impl Strategy for Core {
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
+    fn try_is_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError> {
         if let Some(e) = self.dfa.get(input) {
             trace!(
                 "using full DFA for is-match search at {:?}",
                 input.get_span()
             );
             match e.try_search_half_fwd(input) {
-                Ok(x) => x.is_some(),
+                Ok(x) => Ok(x.is_some()),
                 Err(_err) => {
                     trace!("full DFA half search failed: {_err}");
-                    self.is_match_nofail(cache, input)
+                    self.try_is_match_nofail(cache, input)
                 }
             }
         } else if let Some(e) = self.hybrid.get(input) {
@@ -788,14 +814,14 @@ impl Strategy for Core {
                 input.get_span()
             );
             match e.try_search_half_fwd(&mut cache.hybrid, input) {
-                Ok(x) => x.is_some(),
+                Ok(x) => Ok(x.is_some()),
                 Err(_err) => {
                     trace!("lazy DFA half search failed: {_err}");
-                    self.is_match_nofail(cache, input)
+                    self.try_is_match_nofail(cache, input)
                 }
             }
         } else {
-            self.is_match_nofail(cache, input)
+            self.try_is_match_nofail(cache, input)
         }
     }
 
@@ -902,7 +928,7 @@ impl Strategy for Core {
             "using PikeVM for overlapping search at {:?}",
             input.get_span()
         );
-        let e = self.pikevm.get();
+        let e = self.pikevm.get().expect("PikeVM is required");
         e.which_overlapping_matches(&mut cache.pikevm, input, patset)
     }
 }
@@ -1061,17 +1087,21 @@ impl Strategy for ReverseAnchored {
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
+    fn try_is_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError> {
         if input.get_anchored().is_anchored() {
-            return self.core.is_match(cache, input);
+            return self.core.try_is_match(cache, input);
         }
         match self.try_search_half_anchored_rev(cache, input) {
             Err(_err) => {
                 trace!("fast reverse anchored search failed: {_err}");
-                self.core.is_match_nofail(cache, input)
+                self.core.try_is_match_nofail(cache, input)
             }
-            Ok(None) => false,
-            Ok(Some(_)) => true,
+            Ok(None) => Ok(false),
+            Ok(Some(_)) => Ok(true),
         }
     }
 
@@ -1446,23 +1476,27 @@ impl Strategy for ReverseSuffix {
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
+    fn try_is_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError> {
         if input.get_anchored().is_anchored() {
-            return self.core.is_match(cache, input);
+            return self.core.try_is_match(cache, input);
         }
         match self.try_search_half_start(cache, input) {
             Err(RetryError::Quadratic(_err)) => {
                 trace!("reverse suffix half optimization failed: {_err}");
-                self.core.is_match_nofail(cache, input)
+                self.core.try_is_match_nofail(cache, input)
             }
             Err(RetryError::Fail(_err)) => {
                 trace!(
                     "reverse suffix reverse fast half search failed: {_err}"
                 );
-                self.core.is_match_nofail(cache, input)
+                self.core.try_is_match_nofail(cache, input)
             }
-            Ok(None) => false,
-            Ok(Some(_)) => true,
+            Ok(None) => Ok(false),
+            Ok(Some(_)) => Ok(true),
         }
     }
 
@@ -1851,21 +1885,25 @@ impl Strategy for ReverseInner {
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
-    fn is_match(&self, cache: &mut Cache, input: &Input<'_>) -> bool {
+    fn try_is_match(
+        &self,
+        cache: &mut Cache,
+        input: &Input<'_>,
+    ) -> Result<bool, RetryFailError> {
         if input.get_anchored().is_anchored() {
-            return self.core.is_match(cache, input);
+            return self.core.try_is_match(cache, input);
         }
         match self.try_search_full(cache, input) {
             Err(RetryError::Quadratic(_err)) => {
                 trace!("reverse inner half optimization failed: {_err}");
-                self.core.is_match_nofail(cache, input)
+                self.core.try_is_match_nofail(cache, input)
             }
             Err(RetryError::Fail(_err)) => {
                 trace!("reverse inner fast half search failed: {_err}");
-                self.core.is_match_nofail(cache, input)
+                self.core.try_is_match_nofail(cache, input)
             }
-            Ok(None) => false,
-            Ok(Some(_)) => true,
+            Ok(None) => Ok(false),
+            Ok(Some(_)) => Ok(true),
         }
     }