Add error messages and fix pre-filter

We need to disable pre-filters when a regex contains lookarounds.
This is because the relevant information for a lookbehind can be before
the start of the match.

Author: Multimodcrafter

regex-automata/src/dfa/dense.rs

@@ -5083,6 +5083,12 @@ impl BuildError {
         BuildError { kind: BuildErrorKind::Unsupported(msg) }
     }
 
+    pub(crate) fn unsupported_lookaround() -> BuildError {
+        let msg = "cannot build DFAs for regexes with look-around\
+                   sub-expressions; use a different regex engine";
+        BuildError { kind: BuildErrorKind::Unsupported(msg) }
+    }
+
     pub(crate) fn too_many_states() -> BuildError {
         BuildError { kind: BuildErrorKind::TooManyStates }
     }

regex-automata/src/dfa/determinize.rs

@@ -219,6 +219,10 @@ impl<'a> Runner<'a> {
             return Err(BuildError::unsupported_dfa_word_boundary_unicode());
         }
 
+        if self.nfa.lookaround_count() > 0 {
+            return Err(BuildError::unsupported_lookaround());
+        }
+
         // A sequence of "representative" bytes drawn from each equivalence
         // class. These representative bytes are fed to the NFA to compute
         // state transitions. This allows us to avoid re-computing state

regex-automata/src/hybrid/dfa.rs

@@ -4056,6 +4056,9 @@ impl Builder {
         &self,
         nfa: thompson::NFA,
     ) -> Result<DFA, BuildError> {
+        if nfa.lookaround_count() > 0 {
+            return Err(BuildError::unsupported_lookaround());
+        }
         let quitset = self.config.quit_set_from_nfa(&nfa)?;
         let classes = self.config.byte_classes_from_nfa(&nfa, &quitset);
         // Check that we can fit at least a few states into our cache,

regex-automata/src/hybrid/error.rs

@@ -61,6 +61,12 @@ impl BuildError {
                    different regex engine";
         BuildError { kind: BuildErrorKind::Unsupported(msg) }
     }
+
+    pub(crate) fn unsupported_lookaround() -> BuildError {
+        let msg = "cannot build DFAs for regexes with look-around\
+                   sub-expressions; use a different regex engine";
+        BuildError { kind: BuildErrorKind::Unsupported(msg) }
+    }
 }
 
 #[cfg(feature = "std")]

regex-automata/src/meta/wrappers.rs

@@ -204,6 +204,8 @@ impl BoundedBacktrackerEngine {
         {
             if !info.config().get_backtrack()
                 || info.config().get_match_kind() != MatchKind::LeftmostFirst
+                // TODO: remove once look-around support is added.
+                || nfa.lookaround_count() > 0
             {
                 return Ok(None);
             }

regex-syntax/src/hir/literal.rs

@@ -172,9 +172,8 @@ impl Extractor {
         use crate::hir::HirKind::*;
 
         match *hir.kind() {
-            Empty | Look(_) | LookAround(_) => {
-                Seq::singleton(self::Literal::exact(vec![]))
-            }
+            Empty | Look(_) => Seq::singleton(self::Literal::exact(vec![])),
+            LookAround(_) => Seq::infinite(),
             Literal(hir::Literal(ref bytes)) => {
                 let mut seq =
                     Seq::singleton(self::Literal::exact(bytes.to_vec()));