add dense dfa

Author: addisoncrump

fuzz/Cargo.toml

@@ -71,6 +71,10 @@ path = "fuzz_targets/ast_fuzz_match_bytes.rs"
 name = "ast_diff_default"
 path = "fuzz_targets/ast_diff_default.rs"
 
+[[bin]]
+name = "ast_diff_dense_dfa"
+path = "fuzz_targets/ast_diff_dense_dfa.rs"
+
 [[bin]]
 name = "ast_diff_nfas"
 path = "fuzz_targets/ast_diff_nfas.rs"

fuzz/fuzz_targets/ast_diff_default.rs

@@ -26,9 +26,6 @@ fn do_fuzz(data: FuzzData) -> Corpus {
     let _ = env_logger::try_init();
 
     let pattern = format!("{}", data.ast);
-    let Ok(re) = RegexBuilder::new(&pattern).size_limit(1 << 20).build() else {
-        return Corpus::Reject;
-    };
     let config = NFA::config().nfa_size_limit(Some(1 << 20));
     let Ok(nfa) = NFA::compiler().configure(config).build(&pattern) else {
         return Corpus::Reject;
@@ -38,6 +35,10 @@ fn do_fuzz(data: FuzzData) -> Corpus {
     };
     let mut cache = baseline.create_cache();
 
+    let Ok(re) = RegexBuilder::new(&pattern).size_limit(1 << 20).build() else {
+        return Corpus::Reject;
+    };
+
     assert_eq!(
         re.is_match(&data.haystack),
         baseline.is_match(&mut cache, &data.haystack)

fuzz/fuzz_targets/ast_diff_dense_dfa.rs

@@ -0,0 +1,62 @@
+#![no_main]
+
+use {
+    libfuzzer_sys::{fuzz_target, Corpus},
+    regex_automata::{
+        dfa::{dense::DFA, regex::Builder as RegexBuilder},
+        nfa::thompson::{pikevm::PikeVM as NfaRegex, NFA},
+    },
+    regex_syntax::ast::Ast,
+};
+
+#[derive(Eq, PartialEq, arbitrary::Arbitrary)]
+struct FuzzData {
+    ast: Ast,
+    haystack: String,
+}
+
+impl std::fmt::Debug for FuzzData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_struct("FuzzData");
+        builder.field("ast", &format!("{}", self.ast));
+        builder.field("haystack", &self.haystack);
+        builder.finish()
+    }
+}
+
+fn do_fuzz(data: FuzzData) -> Corpus {
+    let _ = env_logger::try_init();
+
+    let pattern = format!("{}", data.ast);
+    let config = NFA::config().nfa_size_limit(Some(1 << 20));
+    let Ok(nfa) = NFA::compiler().configure(config).build(&pattern) else {
+        return Corpus::Reject;
+    };
+    let Ok(baseline) = NfaRegex::new_from_nfa(nfa) else {
+        return Corpus::Reject;
+    };
+    let mut cache = baseline.create_cache();
+
+    let config = DFA::config().dfa_size_limit(Some(1 << 20));
+    let Ok(re) = RegexBuilder::new().dense(config).build(&pattern) else {
+        return Corpus::Reject;
+    };
+
+    assert_eq!(
+        re.is_match(&data.haystack),
+        baseline.is_match(&mut cache, &data.haystack)
+    );
+    let found1 = re.find(&data.haystack);
+    let found2 = baseline.find(&mut cache, &data.haystack);
+    if let Some(found1) = found1 {
+        let found2 = found2.expect("Found in target, but not in baseline!");
+        assert_eq!(found1.start(), found2.start());
+        assert_eq!(found1.end(), found2.end());
+    }
+
+    // no captures
+
+    Corpus::Keep
+}
+
+fuzz_target!(|data: FuzzData| -> Corpus { do_fuzz(data) });

fuzz/fuzz_targets/ast_diff_nfas.rs

@@ -31,14 +31,16 @@ fn do_fuzz(data: FuzzData) -> Corpus {
     let Ok(nfa) = NFA::compiler().configure(config).build(&pattern) else {
         return Corpus::Reject;
     };
-    let Ok(backtracker) = BoundedBacktracker::new_from_nfa(nfa.clone()) else {
-        return Corpus::Reject; };
-    let mut backtracker_cache = backtracker.create_cache();
-    let Ok(baseline) = PikeVM::new_from_nfa(nfa) else {
+    let Ok(baseline) = PikeVM::new_from_nfa(nfa.clone()) else {
         return Corpus::Reject;
     };
     let mut baseline_cache = baseline.create_cache();
 
+    let Ok(backtracker) = BoundedBacktracker::new_from_nfa(nfa) else {
+        return Corpus::Reject;
+    };
+    let mut backtracker_cache = backtracker.create_cache();
+
     if let Ok(backtracked) =
         backtracker.try_is_match(&mut backtracker_cache, &data.haystack)
     {