automata: fix a bug in the reverse suffix/inner search

Author: BurntSushi

regex-automata/src/meta/strategy.rs

@@ -1215,9 +1215,10 @@ impl ReverseSuffix {
     ) -> Result<Option<HalfMatch>, RetryError> {
         let mut span = input.get_span();
         let mut min_start = 0;
+        let mut first: Option<HalfMatch> = None;
         loop {
             let litmatch = match self.pre.find(input.haystack(), span) {
-                None => return Ok(None),
+                None => break,
                 Some(span) => span,
             };
             trace!("reverse suffix scan found suffix match at {litmatch:?}");
@@ -1228,7 +1229,13 @@ impl ReverseSuffix {
             if let Some(hm) =
                 self.try_search_half_rev_limited(cache, &revinput, min_start)?
             {
-                return Ok(Some(hm));
+                // We only track the first half-match. We can never find a
+                // half-match with lower offset than the first half-match, it
+                // would mean quadratic behavior. We can only confirm this
+                // half-match or return a quadratic error.
+                if first.is_none() {
+                    first = Some(hm);
+                }
             }
 
             if span.start >= span.end {
@@ -1237,7 +1244,7 @@ impl ReverseSuffix {
             span.start = litmatch.start.checked_add(1).unwrap();
             min_start = litmatch.end;
         }
-        Ok(None)
+        Ok(first)
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
@@ -1623,9 +1630,10 @@ impl ReverseInner {
         let mut span = input.get_span();
         let mut min_match_start = 0;
         let mut min_pre_start = 0;
+        let mut first: Option<Match> = None;
         loop {
             let litmatch = match self.preinner.find(input.haystack(), span) {
-                None => return Ok(None),
+                None => break,
                 Some(span) => span,
             };
             if litmatch.start < min_pre_start {
@@ -1662,10 +1670,12 @@ impl ReverseInner {
                         span.start = litmatch.start.checked_add(1).unwrap();
                     }
                     Ok(hm_end) => {
-                        return Ok(Some(Match::new(
-                            hm_start.pattern(),
-                            hm_start.offset()..hm_end.offset(),
-                        )))
+                        if first.is_none() {
+                            first = Some(Match::new(
+                                hm_start.pattern(),
+                                hm_start.offset()..hm_end.offset(),
+                            ));
+                        }
                     }
                 }
             }
@@ -1676,7 +1686,7 @@ impl ReverseInner {
             span.start = litmatch.start.checked_add(1).unwrap();
             min_match_start = litmatch.end;
         }
-        Ok(None)
+        Ok(first)
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]

testdata/regression.toml

@@ -409,6 +409,21 @@ matches = []
 unicode = false
 utf8 = false
 
+# See: https://github.com/rust-lang/regex/issues/1354
+[[test]]
+name = 'reverse-suffix-start-of-match-failure-010'
+regex = '.abb|b'
+haystack = 'zabb'
+matches = [[0, 4]]
+
+# See: https://github.com/rust-lang/regex/issues/1354
+# See: https://github.com/rust-lang/regex/pull/1355
+[[test]]
+name = 'reverse-suffix-start-of-match-failure-011'
+regex = '.abb|b'
+haystack = 'zzzabbz'
+matches = [[2, 6]]
+
 # See: https://github.com/BurntSushi/ripgrep/issues/1247
 [[test]]
 name = "stops"
@@ -757,6 +772,14 @@ regex = '(?:([0-9][0-9][0-9]):)?([0-9][0-9]):([0-9][0-9])'
 haystack = '102:12:39'
 matches = [[[0, 9], [0, 3], [4, 6], [7, 9]]]
 
+
+# See: https://github.com/rust-lang/regex/issues/1354
+[[test]]
+name = 'reverse-inner-start-of-match-failure-010'
+regex = '(?:..acbb|b)a(?:c|d)'
+haystack = 'xzbacbbac'
+matches = [[1, 9]]
+
 # This regression test was found via the RegexSet APIs. It triggered a
 # particular code path where a regex was compiled with 'All' match semantics
 # (to support overlapping search), but got funneled down into a standard