Change engine fallbacks

shilangyu · shilangyu · commit 6192349ad610 · 2025-08-25T10:36:46.000+02:00
diff --git a/regex-automata/src/dfa/dense.rs b/regex-automata/src/dfa/dense.rs
@@ -5097,7 +5097,7 @@ impl BuildError {
     }
 
     pub(crate) fn unsupported_lookaround() -> BuildError {
-        let msg = "cannot build DFAs for regexes with look-around\
+        let msg = "cannot build DFAs for regexes with look-around \
                    sub-expressions; use a different regex engine";
         BuildError { kind: BuildErrorKind::Unsupported(msg) }
     }
diff --git a/regex-automata/src/dfa/onepass.rs b/regex-automata/src/dfa/onepass.rs
@@ -602,6 +602,9 @@ impl<'a> InternalBuilder<'a> {
             ));
         }
         assert_eq!(DEAD, self.add_empty_state()?);
+        if self.nfa.lookaround_count() > 0 {
+            return Err(BuildError::unsupported_lookaround());
+        }
 
         // This is where the explicit slots start. We care about this because
         // we only need to track explicit slots. The implicit slots---two for
@@ -640,7 +643,7 @@ impl<'a> InternalBuilder<'a> {
                 match *self.nfa.state(id) {
                     thompson::State::WriteLookAround { .. }
                     | thompson::State::CheckLookAround { .. } => {
-                        todo!("check how to handle")
+                        return Err(BuildError::unsupported_lookaround());
                     }
                     thompson::State::ByteRange { ref trans } => {
                         self.compile_transition(dfa_id, trans, epsilons)?;
@@ -3000,6 +3003,7 @@ enum BuildErrorKind {
     UnsupportedLook { look: Look },
     ExceededSizeLimit { limit: usize },
     NotOnePass { msg: &'static str },
+    UnsupportedLookAround,
 }
 
 impl BuildError {
@@ -3030,6 +3034,10 @@ impl BuildError {
     fn not_one_pass(msg: &'static str) -> BuildError {
         BuildError { kind: BuildErrorKind::NotOnePass { msg } }
     }
+
+    fn unsupported_lookaround() -> BuildError {
+        BuildError { kind: BuildErrorKind::UnsupportedLookAround }
+    }
 }
 
 #[cfg(feature = "std")]
@@ -3078,6 +3086,9 @@ impl core::fmt::Display for BuildError {
                  pattern is not one-pass: {}",
                 msg,
             ),
+            UnsupportedLookAround => {
+                write!(f, "one-pass DFA does not support look-arounds")
+            }
         }
     }
 }
diff --git a/regex-automata/src/hybrid/error.rs b/regex-automata/src/hybrid/error.rs
@@ -63,7 +63,7 @@ impl BuildError {
     }
 
     pub(crate) fn unsupported_lookaround() -> BuildError {
-        let msg = "cannot build DFAs for regexes with look-around\
+        let msg = "cannot build DFAs for regexes with look-around \
                    sub-expressions; use a different regex engine";
         BuildError { kind: BuildErrorKind::Unsupported(msg) }
     }
diff --git a/regex-automata/src/meta/strategy.rs b/regex-automata/src/meta/strategy.rs
@@ -490,49 +490,52 @@ impl Core {
         // we know we aren't going to use the lazy DFA. So we do a config check
         // up front, which is in practice the only way we won't try to use the
         // DFA.
-        let (nfarev, hybrid, dfa) =
-            if !info.config().get_hybrid() && !info.config().get_dfa() {
-                (None, wrappers::Hybrid::none(), wrappers::DFA::none())
+        let (nfarev, hybrid, dfa) = if !info.config().get_hybrid()
+            && !info.config().get_dfa()
+            // With look-arounds, the lazy DFA and dense DFA would fail to build
+            || nfa.lookaround_count() > 0
+        {
+            (None, wrappers::Hybrid::none(), wrappers::DFA::none())
+        } else {
+            // FIXME: Technically, we don't quite yet KNOW that we need
+            // a reverse NFA. It's possible for the DFAs below to both
+            // fail to build just based on the forward NFA. In which case,
+            // building the reverse NFA was totally wasted work. But...
+            // fixing this requires breaking DFA construction apart into
+            // two pieces: one for the forward part and another for the
+            // reverse part. Quite annoying. Making it worse, when building
+            // both DFAs fails, it's quite likely that the NFA is large and
+            // that it will take quite some time to build the reverse NFA
+            // too. So... it's really probably worth it to do this!
+            let nfarev = thompson::Compiler::new()
+                // Currently, reverse NFAs don't support capturing groups,
+                // so we MUST disable them. But even if we didn't have to,
+                // we would, because nothing in this crate does anything
+                // useful with capturing groups in reverse. And of course,
+                // the lazy DFA ignores capturing groups in all cases.
+                .configure(
+                    thompson_config
+                        .clone()
+                        .which_captures(WhichCaptures::None)
+                        .reverse(true),
+                )
+                .build_many_from_hir(hirs)
+                .map_err(BuildError::nfa)?;
+            let dfa = if !info.config().get_dfa() {
+                wrappers::DFA::none()
             } else {
-                // FIXME: Technically, we don't quite yet KNOW that we need
-                // a reverse NFA. It's possible for the DFAs below to both
-                // fail to build just based on the forward NFA. In which case,
-                // building the reverse NFA was totally wasted work. But...
-                // fixing this requires breaking DFA construction apart into
-                // two pieces: one for the forward part and another for the
-                // reverse part. Quite annoying. Making it worse, when building
-                // both DFAs fails, it's quite likely that the NFA is large and
-                // that it will take quite some time to build the reverse NFA
-                // too. So... it's really probably worth it to do this!
-                let nfarev = thompson::Compiler::new()
-                    // Currently, reverse NFAs don't support capturing groups,
-                    // so we MUST disable them. But even if we didn't have to,
-                    // we would, because nothing in this crate does anything
-                    // useful with capturing groups in reverse. And of course,
-                    // the lazy DFA ignores capturing groups in all cases.
-                    .configure(
-                        thompson_config
-                            .clone()
-                            .which_captures(WhichCaptures::None)
-                            .reverse(true),
-                    )
-                    .build_many_from_hir(hirs)
-                    .map_err(BuildError::nfa)?;
-                let dfa = if !info.config().get_dfa() {
-                    wrappers::DFA::none()
-                } else {
-                    wrappers::DFA::new(&info, pre.clone(), &nfa, &nfarev)
-                };
-                let hybrid = if !info.config().get_hybrid() {
-                    wrappers::Hybrid::none()
-                } else if dfa.is_some() {
-                    debug!("skipping lazy DFA because we have a full DFA");
-                    wrappers::Hybrid::none()
-                } else {
-                    wrappers::Hybrid::new(&info, pre.clone(), &nfa, &nfarev)
-                };
-                (Some(nfarev), hybrid, dfa)
+                wrappers::DFA::new(&info, pre.clone(), &nfa, &nfarev)
             };
+            let hybrid = if !info.config().get_hybrid() {
+                wrappers::Hybrid::none()
+            } else if dfa.is_some() {
+                debug!("skipping lazy DFA because we have a full DFA");
+                wrappers::Hybrid::none()
+            } else {
+                wrappers::Hybrid::new(&info, pre.clone(), &nfa, &nfarev)
+            };
+            (Some(nfarev), hybrid, dfa)
+        };
         Ok(Core {
             info,
             pre,
diff --git a/regex-automata/src/nfa/thompson/backtrack.rs b/regex-automata/src/nfa/thompson/backtrack.rs
@@ -301,6 +301,9 @@ impl Builder {
         nfa: NFA,
     ) -> Result<BoundedBacktracker, BuildError> {
         nfa.look_set_any().available().map_err(BuildError::word)?;
+        if nfa.lookaround_count() > 0 {
+            return Err(BuildError::unsupported_lookarounds());
+        }
         Ok(BoundedBacktracker { config: self.config.clone(), nfa })
     }
 
@@ -1521,7 +1524,9 @@ impl BoundedBacktracker {
                 }
                 State::WriteLookAround { .. }
                 | State::CheckLookAround { .. } => {
-                    todo!("check how to handle")
+                    unimplemented!(
+                        "backtracking engine does not support look-arounds"
+                    );
                 }
                 State::Union { ref alternates } => {
                     sid = match alternates.get(0) {
diff --git a/regex-automata/src/nfa/thompson/compiler.rs b/regex-automata/src/nfa/thompson/compiler.rs
@@ -954,6 +954,13 @@ impl Compiler {
         {
             return Err(BuildError::unsupported_captures());
         }
+        if self.config.get_reverse()
+            && exprs.iter().any(|e| {
+                (e.borrow() as &Hir).properties().contains_lookaround_expr()
+            })
+        {
+            return Err(BuildError::unsupported_lookarounds());
+        }
 
         self.builder.borrow_mut().clear();
         self.builder.borrow_mut().set_utf8(self.config.get_utf8());
diff --git a/regex-automata/src/nfa/thompson/error.rs b/regex-automata/src/nfa/thompson/error.rs
@@ -81,6 +81,13 @@ enum BuildErrorKind {
     /// should support it at some point.
     #[cfg(feature = "syntax")]
     UnsupportedCaptures,
+    /// An error that occurs when one tries to build a reverse NFA with
+    /// look-around sub-expressions. Currently, this isn't supported, but we
+    /// probably should support it at some point.
+    ///
+    /// This is also emmitted by the backtracking engine which does not
+    /// support look-around sub-expressions.
+    UnsupportedLookArounds,
 }
 
 impl BuildError {
@@ -142,6 +149,10 @@ impl BuildError {
     pub(crate) fn unsupported_captures() -> BuildError {
         BuildError { kind: BuildErrorKind::UnsupportedCaptures }
     }
+
+    pub(crate) fn unsupported_lookarounds() -> BuildError {
+        BuildError { kind: BuildErrorKind::UnsupportedLookArounds }
+    }
 }
 
 #[cfg(feature = "std")]
@@ -201,6 +212,11 @@ impl core::fmt::Display for BuildError {
                 "currently captures must be disabled when compiling \
                  a reverse NFA",
             ),
+            BuildErrorKind::UnsupportedLookArounds => write!(
+                f,
+                "currently look-around sub-expressions cannot be in the pattern \
+                 when compiling a reverse NFA or using the backtracking engine",
+            ),
         }
     }
 }
diff --git a/regex-automata/src/util/determinize/mod.rs b/regex-automata/src/util/determinize/mod.rs
@@ -253,7 +253,7 @@ pub(crate) fn next(
             | thompson::State::Capture { .. } => {}
             thompson::State::CheckLookAround { .. }
             | thompson::State::WriteLookAround { .. } => {
-                todo!("check how to handle")
+                unimplemented!("look-around support in DFA")
             }
             thompson::State::Match { pattern_id } => {
                 // Notice here that we are calling the NEW state a match
@@ -405,7 +405,7 @@ pub(crate) fn epsilon_closure(
                 | thompson::State::Match { .. } => break,
                 thompson::State::WriteLookAround { .. }
                 | thompson::State::CheckLookAround { .. } => {
-                    todo!("check how to handle")
+                    unimplemented!("look-around support in DFA")
                 }
                 thompson::State::Look { look, next } => {
                     if !look_have.contains(look) {
@@ -475,7 +475,7 @@ pub(crate) fn add_nfa_states(
             }
             thompson::State::CheckLookAround { .. }
             | thompson::State::WriteLookAround { .. } => {
-                todo!("check how to handle")
+                unimplemented!("look-around support in DFA")
             }
             thompson::State::Union { .. }
             | thompson::State::BinaryUnion { .. } => {
diff --git a/regex-automata/tests/nfa/thompson/backtrack/suite.rs b/regex-automata/tests/nfa/thompson/backtrack/suite.rs
@@ -108,7 +108,17 @@ fn compiler(
         if !configure_backtrack_builder(test, &mut builder) {
             return Ok(CompiledRegex::skip());
         }
-        let re = builder.build_many(&regexes)?;
+        let re = match builder.build_many(&regexes) {
+            Ok(re) => re,
+            // Due to errors being opaque, we need to check the error message to skip tests with look-arounds
+            Err(err) => {
+                if test.compiles() && err.to_string().contains("look-around") {
+                    return Ok(CompiledRegex::skip());
+                }
+
+                return Err(err.into());
+            }
+        };
         // The backtracker doesn't support lookarounds, so skip if there are any.
         if re.get_nfa().lookaround_count() > 0 {
             return Ok(CompiledRegex::skip());

Original file line number	Diff line number	Diff line change
`@@ -5097,7 +5097,7 @@ impl BuildError {`
`5097`	`5097`	`}`
`5098`	`5098`
`5099`	`5099`	`pub(crate) fn unsupported_lookaround() -> BuildError {`
`5100`		`- let msg = "cannot build DFAs for regexes with look-around\`
	`5100`	`+ let msg = "cannot build DFAs for regexes with look-around \`
`5101`	`5101`	`sub-expressions; use a different regex engine";`
`5102`	`5102`	`BuildError { kind: BuildErrorKind::Unsupported(msg) }`
`5103`	`5103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -602,6 +602,9 @@ impl<'a> InternalBuilder<'a> {`
`602`	`602`	`));`
`603`	`603`	`}`
`604`	`604`	`assert_eq!(DEAD, self.add_empty_state()?);`
	`605`	`+ if self.nfa.lookaround_count() > 0 {`
	`606`	`+ return Err(BuildError::unsupported_lookaround());`
	`607`	`+ }`
`605`	`608`
`606`	`609`	`// This is where the explicit slots start. We care about this because`
`607`	`610`	`// we only need to track explicit slots. The implicit slots---two for`
`@@ -640,7 +643,7 @@ impl<'a> InternalBuilder<'a> {`
`640`	`643`	`match *self.nfa.state(id) {`
`641`	`644`	`thompson::State::WriteLookAround { .. }`
`642`	`645`	`\| thompson::State::CheckLookAround { .. } => {`
`643`		`- todo!("check how to handle")`
	`646`	`+ return Err(BuildError::unsupported_lookaround());`
`644`	`647`	`}`
`645`	`648`	`thompson::State::ByteRange { ref trans } => {`
`646`	`649`	`self.compile_transition(dfa_id, trans, epsilons)?;`
`@@ -3000,6 +3003,7 @@ enum BuildErrorKind {`
`3000`	`3003`	`UnsupportedLook { look: Look },`
`3001`	`3004`	`ExceededSizeLimit { limit: usize },`
`3002`	`3005`	`NotOnePass { msg: &'static str },`
	`3006`	`+ UnsupportedLookAround,`
`3003`	`3007`	`}`
`3004`	`3008`
`3005`	`3009`	`impl BuildError {`
`@@ -3030,6 +3034,10 @@ impl BuildError {`
`3030`	`3034`	`fn not_one_pass(msg: &'static str) -> BuildError {`
`3031`	`3035`	`BuildError { kind: BuildErrorKind::NotOnePass { msg } }`
`3032`	`3036`	`}`
	`3037`	`+`
	`3038`	`+ fn unsupported_lookaround() -> BuildError {`
	`3039`	`+ BuildError { kind: BuildErrorKind::UnsupportedLookAround }`
	`3040`	`+ }`
`3033`	`3041`	`}`
`3034`	`3042`
`3035`	`3043`	`#[cfg(feature = "std")]`
`@@ -3078,6 +3086,9 @@ impl core::fmt::Display for BuildError {`
`3078`	`3086`	`pattern is not one-pass: {}",`
`3079`	`3087`	`msg,`
`3080`	`3088`	`),`
	`3089`	`+ UnsupportedLookAround => {`
	`3090`	`+ write!(f, "one-pass DFA does not support look-arounds")`
	`3091`	`+ }`
`3081`	`3092`	`}`
`3082`	`3093`	`}`
`3083`	`3094`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ impl BuildError {`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`pub(crate) fn unsupported_lookaround() -> BuildError {`
`66`		`- let msg = "cannot build DFAs for regexes with look-around\`
	`66`	`+ let msg = "cannot build DFAs for regexes with look-around \`
`67`	`67`	`sub-expressions; use a different regex engine";`
`68`	`68`	`BuildError { kind: BuildErrorKind::Unsupported(msg) }`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -301,6 +301,9 @@ impl Builder {`
`301`	`301`	`nfa: NFA,`
`302`	`302`	`) -> Result<BoundedBacktracker, BuildError> {`
`303`	`303`	`nfa.look_set_any().available().map_err(BuildError::word)?;`
	`304`	`+ if nfa.lookaround_count() > 0 {`
	`305`	`+ return Err(BuildError::unsupported_lookarounds());`
	`306`	`+ }`
`304`	`307`	`Ok(BoundedBacktracker { config: self.config.clone(), nfa })`
`305`	`308`	`}`
`306`	`309`
`@@ -1521,7 +1524,9 @@ impl BoundedBacktracker {`
`1521`	`1524`	`}`
`1522`	`1525`	`State::WriteLookAround { .. }`
`1523`	`1526`	`\| State::CheckLookAround { .. } => {`
`1524`		`- todo!("check how to handle")`
	`1527`	`+ unimplemented!(`
	`1528`	`+ "backtracking engine does not support look-arounds"`
	`1529`	`+ );`
`1525`	`1530`	`}`
`1526`	`1531`	`State::Union { ref alternates } => {`
`1527`	`1532`	`sid = match alternates.get(0) {`
Original file line number	Diff line number	Diff line change
`@@ -954,6 +954,13 @@ impl Compiler {`
`954`	`954`	`{`
`955`	`955`	`return Err(BuildError::unsupported_captures());`
`956`	`956`	`}`
	`957`	`+ if self.config.get_reverse()`
	`958`	`+ && exprs.iter().any(\|e\| {`
	`959`	`+ (e.borrow() as &Hir).properties().contains_lookaround_expr()`
	`960`	`+ })`
	`961`	`+ {`
	`962`	`+ return Err(BuildError::unsupported_lookarounds());`
	`963`	`+ }`
`957`	`964`
`958`	`965`	`self.builder.borrow_mut().clear();`
`959`	`966`	`self.builder.borrow_mut().set_utf8(self.config.get_utf8());`
Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,13 @@ enum BuildErrorKind {`
`81`	`81`	`/// should support it at some point.`
`82`	`82`	`#[cfg(feature = "syntax")]`
`83`	`83`	`UnsupportedCaptures,`
	`84`	`+ /// An error that occurs when one tries to build a reverse NFA with`
	`85`	`+ /// look-around sub-expressions. Currently, this isn't supported, but we`
	`86`	`+ /// probably should support it at some point.`
	`87`	`+ ///`
	`88`	`+ /// This is also emmitted by the backtracking engine which does not`
	`89`	`+ /// support look-around sub-expressions.`
	`90`	`+ UnsupportedLookArounds,`
`84`	`91`	`}`
`85`	`92`
`86`	`93`	`impl BuildError {`
`@@ -142,6 +149,10 @@ impl BuildError {`
`142`	`149`	`pub(crate) fn unsupported_captures() -> BuildError {`
`143`	`150`	`BuildError { kind: BuildErrorKind::UnsupportedCaptures }`
`144`	`151`	`}`
	`152`	`+`
	`153`	`+ pub(crate) fn unsupported_lookarounds() -> BuildError {`
	`154`	`+ BuildError { kind: BuildErrorKind::UnsupportedLookArounds }`
	`155`	`+ }`
`145`	`156`	`}`
`146`	`157`
`147`	`158`	`#[cfg(feature = "std")]`
`@@ -201,6 +212,11 @@ impl core::fmt::Display for BuildError {`
`201`	`212`	`"currently captures must be disabled when compiling \`
`202`	`213`	`a reverse NFA",`
`203`	`214`	`),`
	`215`	`+ BuildErrorKind::UnsupportedLookArounds => write!(`
	`216`	`+ f,`
	`217`	`+ "currently look-around sub-expressions cannot be in the pattern \`
	`218`	`+ when compiling a reverse NFA or using the backtracking engine",`
	`219`	`+ ),`
`204`	`220`	`}`
`205`	`221`	`}`
`206`	`222`	`}`