feat(specializer): wave-B regexp family — rust-regex behind an RE2 translation layer, corpus 484 -> 505 (TASK-53)

The engine is regex 1.x with the measured parity recipe (pins-waveB/
re2-vs-rust-regex.json): RegexBuilder::octal(true), default Unicode mode
(unicode(false) BREAKS (?i) folding parity — measured), and a bind-time
pattern rewrite in retrans.rs closing the whole Perl-class gap (\d ->
(?-u:\d) etc, in-class variants included) plus a reject list for the
irreconcilables (\B, (?<name>), duplicate group names, bounds > 1000,
stacked quantifiers — the last silently WRONG in rust, not just
error-shaped different). Replacement templates translate \N -> ${N},
$ -> $$, with RE2's invalid-rewrite quirks resolved at bind (out-of-
range backref = identity; global bad escape = consume-with-prefix).

Program grows a prepare-time regex table (print/parse round-trips it);
ReMatch/ReExtract/ReReplace run on both backends. Frontend serves
regexp_matches (SEARCH) / regexp_full_match / regexp_extract (''-on-miss,
flat 0..9 group check, NULL-group -> '') / regexp_replace (backslash
backrefs, 'g', NULL options -> NULL — the pinned asymmetry); ~ / !~ are
FULL match (NOT the Postgres search — measured, the DuckDB binder error
names regexp_full_match); SIMILAR TO passes the RAW pattern (no %%
translation) full-anchored; star * SIMILAR TO filters names by unanchored
search while NOT SIMILAR TO negates a full match (independent predicates
— pinned asymmetry); bare COLUMNS('re')/COLUMNS(*) expand in declared
order with alias stamping. List-valued forms stay clean-unsupported.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ahrzb

Cargo.lock

@@ -16,5 +16,6 @@ cranelift-frontend = "0.126"
 cranelift-jit = "0.126"
 cranelift-module = "0.126"
 pyo3 = { version = "0.29", features = ["abi3-py314"] }
+regex = "1"
 sqlparser = "0.62"
 target-lexicon = "0.13.5"

Cargo.toml

@@ -57,9 +57,18 @@ struct Cx {
     input: *const Batch,
     statics: *const PreparedStatic,
     statics_len: usize,
+    regexes: *const CompiledRe,
+    regexes_len: usize,
     trap: Option<Trap>,
 }
 
+/// One program regex, compiled, with its replace template (if any) — owned
+/// by the [`CraneliftFn`], read by the h_re* helpers through [`Cx`].
+pub(super) struct CompiledRe {
+    rx: std::rc::Rc<regex::Regex>,
+    template: Option<String>,
+}
+
 impl Cx {
     fn arena(&mut self) -> &mut Arena {
         unsafe { &mut *self.arena }
@@ -591,6 +600,63 @@ extern "C" fn h_srepeat(p: *mut Cx, ao: i64, al: i64, n: i64, len_out: *mut i64)
     }
 }
 
+extern "C" fn h_rematch(p: *mut Cx, re: i64, ao: i64, al: i64) -> u8 {
+    let c = unsafe { cx(p) };
+    let rx = &unsafe { std::slice::from_raw_parts(c.regexes, c.regexes_len) }[re as usize];
+    let arena = unsafe { &*c.arena };
+    rx.rx.is_match(arena.get(span(ao, al))) as u8
+}
+
+extern "C" fn h_reextract(
+    p: *mut Cx,
+    re: i64,
+    group: i64,
+    ao: i64,
+    al: i64,
+    len_out: *mut i64,
+) -> i64 {
+    let c = unsafe { cx(p) };
+    let rx = &unsafe { std::slice::from_raw_parts(c.regexes, c.regexes_len) }[re as usize];
+    let arena = unsafe { &mut *c.arena };
+    // No match / non-participating group -> '' (wave-B pins).
+    let out = {
+        let s = arena.get(span(ao, al));
+        rx.rx
+            .captures(s)
+            .and_then(|caps| caps.get(group as usize))
+            .map(|m| m.as_str().to_string())
+            .unwrap_or_default()
+    };
+    let r = arena.push_str(&out);
+    unsafe { *len_out = r.len as i64 };
+    r.off as i64
+}
+
+extern "C" fn h_rereplace(
+    p: *mut Cx,
+    re: i64,
+    global: i64,
+    ao: i64,
+    al: i64,
+    len_out: *mut i64,
+) -> i64 {
+    let c = unsafe { cx(p) };
+    let rx = &unsafe { std::slice::from_raw_parts(c.regexes, c.regexes_len) }[re as usize];
+    let arena = unsafe { &mut *c.arena };
+    let template = rx.template.as_deref().unwrap_or_default();
+    let out = {
+        let s = arena.get(span(ao, al));
+        if global != 0 {
+            rx.rx.replace_all(s, template).into_owned()
+        } else {
+            rx.rx.replace(s, template).into_owned()
+        }
+    };
+    let r = arena.push_str(&out);
+    unsafe { *len_out = r.len as i64 };
+    r.off as i64
+}
+
 extern "C" fn h_ishl(p: *mut Cx, x: i64, y: i64) -> i64 {
     match interp::duck_shl(x, y) {
         Ok(v) => v,
@@ -836,6 +902,8 @@ pub struct CraneliftFn {
     row_fn: RowFn,
     interp: InterpFn,
     trap_msgs: Vec<String>,
+    /// Program regexes compiled once, read by helpers through Cx.
+    regexes: Vec<CompiledRe>,
     /// Owned backing for absolute addresses baked into the code.
     _const_strs: Vec<Box<str>>,
     _probe_descs: Vec<Box<ProbeDesc>>,
@@ -1084,11 +1152,21 @@ pub fn compile(p: &Program, statics: Vec<super::StaticData>) -> Result<Cranelift
     let code = module.get_finalized_function(fid);
     let row_fn: RowFn = unsafe { std::mem::transmute(code) };
 
+    let regexes = interp::compile_regexes(p)
+        .map_err(CompileError::Regex)?
+        .into_iter()
+        .zip(&p.regexes)
+        .map(|(rx, spec)| CompiledRe {
+            rx,
+            template: spec.rewrite.clone(),
+        })
+        .collect();
     Ok(CraneliftFn {
         _module: module,
         row_fn,
         interp,
         trap_msgs,
+        regexes,
         _const_strs: const_strs,
         _probe_descs: probe_descs,
     })
@@ -1122,6 +1200,8 @@ impl CraneliftFn {
                 input,
                 statics: statics.as_ptr(),
                 statics_len: statics.len(),
+                regexes: self.regexes.as_ptr(),
+                regexes_len: self.regexes.len(),
                 trap: None,
             };
             match (self.row_fn)(&mut cx) {
@@ -1456,6 +1536,30 @@ fn translate_inst(
             let len = b.ins().stack_load(types::I64, slot_out, 0);
             vals.insert(dst.0, V::Str(off, len));
         }
+        Inst::ReMatch { re, dst, a } => {
+            let (ao, al) = vals[&a.0].str2();
+            let rev = icon(b, *re as i64);
+            let v = call_h(b, module, "h_rematch", &[cxp, rev, ao, al]).unwrap();
+            vals.insert(dst.0, V::S(v));
+        }
+        Inst::ReExtract { re, group, dst, a } => {
+            let (ao, al) = vals[&a.0].str2();
+            let rev = icon(b, *re as i64);
+            let gv = icon(b, *group as i64);
+            let lp = b.ins().stack_addr(types::I64, slot_out, 0);
+            let off = call_h(b, module, "h_reextract", &[cxp, rev, gv, ao, al, lp]).unwrap();
+            let len = b.ins().stack_load(types::I64, slot_out, 0);
+            vals.insert(dst.0, V::Str(off, len));
+        }
+        Inst::ReReplace { re, global, dst, a } => {
+            let (ao, al) = vals[&a.0].str2();
+            let rev = icon(b, *re as i64);
+            let gv = icon(b, *global as i64);
+            let lp = b.ins().stack_addr(types::I64, slot_out, 0);
+            let off = call_h(b, module, "h_rereplace", &[cxp, rev, gv, ao, al, lp]).unwrap();
+            let len = b.ins().stack_load(types::I64, slot_out, 0);
+            vals.insert(dst.0, V::Str(off, len));
+        }
         Inst::Sord {
             empty_zero,
             dst,
@@ -1850,6 +1954,9 @@ const HELPERS: &[(&str, *const u8)] = &[
     ("h_sjaccard", h_sjaccard as *const u8),
     ("h_str3", h_str3 as *const u8),
     ("h_srepeat", h_srepeat as *const u8),
+    ("h_rematch", h_rematch as *const u8),
+    ("h_reextract", h_reextract as *const u8),
+    ("h_rereplace", h_rereplace as *const u8),
     ("h_ishl", h_ishl as *const u8),
     ("h_sextract", h_sextract as *const u8),
     ("h_spad", h_spad as *const u8),
@@ -1887,6 +1994,9 @@ fn helper_sig(name: &str, sig: &mut cranelift_codegen::ir::Signature, ptr: types
         "h_sjaccard" => (&[ptr, I64, I64, I64, I64], Some(F64)),
         "h_str3" => (&[ptr, I64, I64, I64, I64, I64, I64, I64, I64], Some(I64)),
         "h_srepeat" => (&[ptr, I64, I64, I64, I64], Some(I64)),
+        "h_rematch" => (&[ptr, I64, I64, I64], Some(I8)),
+        "h_reextract" => (&[ptr, I64, I64, I64, I64, I64], Some(I64)),
+        "h_rereplace" => (&[ptr, I64, I64, I64, I64, I64], Some(I64)),
         "h_ishl" => (&[ptr, I64, I64], Some(I64)),
         "h_sextract" => (&[ptr, I64, I64, I64, I64], Some(I64)),
         "h_spad" => (&[ptr, I64, I64, I64, I64, I64, I64, I64], Some(I64)),

src/specializer/exec/cranelift.rs

@@ -41,6 +41,9 @@ pub enum CompileError {
     Verify(Vec<VerifyError>),
     /// The static data does not match the program's static declarations.
     Static(String),
+    /// A ReSpec pattern failed to compile — the frontend validates patterns
+    /// at bind, so this only fires on hand-written IR.
+    Regex(String),
 }
 
 impl std::fmt::Display for CompileError {
@@ -54,10 +57,28 @@ impl std::fmt::Display for CompileError {
                 Ok(())
             }
             CompileError::Static(msg) => write!(f, "static data mismatch: {msg}"),
+            CompileError::Regex(msg) => write!(f, "regex table entry failed to compile: {msg}"),
         }
     }
 }
 
+/// Compile every [`ir::ReSpec`] in the program with the wave-B builder
+/// settings (octal(true), default Unicode — see retrans.rs).
+pub(super) fn compile_regexes(p: &Program) -> Result<Vec<std::rc::Rc<regex::Regex>>, String> {
+    p.regexes
+        .iter()
+        .map(|r| {
+            regex::RegexBuilder::new(&r.pattern)
+                .case_insensitive(r.ci)
+                .dot_matches_new_line(r.dotall)
+                .octal(true)
+                .build()
+                .map(std::rc::Rc::new)
+                .map_err(|e| e.to_string())
+        })
+        .collect()
+}
+
 /// One compiled instruction: reads registers/input/statics, writes registers
 /// or output builders. `Ok(())` or a call-aborting trap.
 type InstFn = Box<dyn for<'a> Fn(&mut Ctx<'a>) -> Result<(), Trap>>;
@@ -120,6 +141,7 @@ pub struct InterpFn {
 pub fn compile(p: &Program, statics: Vec<StaticData>) -> Result<InterpFn, CompileError> {
     verify(p).map_err(CompileError::Verify)?;
     let prepared = prepare_statics(p, statics)?;
+    let regexes = compile_regexes(p).map_err(CompileError::Regex)?;
 
     // Register slots are assigned densely in definition order, decoupling
     // the frame size from raw value ids — a verified program with sparse ids
@@ -143,7 +165,7 @@ pub fn compile(p: &Program, statics: Vec<StaticData>) -> Result<InterpFn, Compil
     for b in &p.blocks {
         let mut insts: Vec<InstFn> = Vec::with_capacity(b.insts.len());
         for inst in &b.insts {
-            insts.push(compile_inst(p, inst, &slots));
+            insts.push(compile_inst(p, inst, &slots, &regexes));
         }
         blocks.push(CBlock {
             insts,
@@ -1432,8 +1454,59 @@ fn sl(slots: &HashMap<u32, u32>, v: Value) -> usize {
     slots[&v.0] as usize
 }
 
-fn compile_inst(p: &Program, inst: &Inst, slots: &HashMap<u32, u32>) -> InstFn {
+fn compile_inst(
+    p: &Program,
+    inst: &Inst,
+    slots: &HashMap<u32, u32>,
+    regexes: &[std::rc::Rc<regex::Regex>],
+) -> InstFn {
     match inst.clone() {
+        Inst::ReMatch { re, dst, a } => {
+            let rx = regexes[re as usize].clone();
+            let (dst, a) = (sl(slots, dst), sl(slots, a));
+            Box::new(move |ctx| {
+                let s = ctx.arena.get(as_str(ctx.regs[a]));
+                let m = rx.is_match(s);
+                ctx.regs[dst] = RegVal::I1(m);
+                Ok(())
+            })
+        }
+        Inst::ReExtract { re, group, dst, a } => {
+            let rx = regexes[re as usize].clone();
+            let (dst, a) = (sl(slots, dst), sl(slots, a));
+            Box::new(move |ctx| {
+                // No match / non-participating group -> '' (wave-B pins).
+                let out = {
+                    let s = ctx.arena.get(as_str(ctx.regs[a]));
+                    rx.captures(s)
+                        .and_then(|c| c.get(group as usize))
+                        .map(|m| m.as_str().to_string())
+                        .unwrap_or_default()
+                };
+                ctx.regs[dst] = RegVal::Str(ctx.arena.push_str(&out));
+                Ok(())
+            })
+        }
+        Inst::ReReplace { re, global, dst, a } => {
+            let rx = regexes[re as usize].clone();
+            let template = p.regexes[re as usize]
+                .rewrite
+                .clone()
+                .expect("verified: rereplace has a template");
+            let (dst, a) = (sl(slots, dst), sl(slots, a));
+            Box::new(move |ctx| {
+                let out = {
+                    let s = ctx.arena.get(as_str(ctx.regs[a]));
+                    if global {
+                        rx.replace_all(s, template.as_str()).into_owned()
+                    } else {
+                        rx.replace(s, template.as_str()).into_owned()
+                    }
+                };
+                ctx.regs[dst] = RegVal::Str(ctx.arena.push_str(&out));
+                Ok(())
+            })
+        }
         Inst::Const { dst, lit } => {
             let dst = sl(slots, dst);
             match lit {

src/specializer/exec/interp.rs

@@ -188,7 +188,9 @@ entry:
     );
     match compile(&p, vec![]) {
         Err(CompileError::Verify(errs)) => assert!(!errs.is_empty()),
-        Err(CompileError::Static(m)) => panic!("wrong error kind: {m}"),
+        Err(CompileError::Static(m)) | Err(CompileError::Regex(m)) => {
+            panic!("wrong error kind: {m}")
+        }
         Ok(_) => panic!("compile accepted an unverified program"),
     }
 }
@@ -224,7 +226,9 @@ fn rejects_mismatched_statics() {
             Err(CompileError::Static(msg)) => {
                 assert!(msg.contains(needle), "expected '{needle}' in '{msg}'")
             }
-            Err(CompileError::Verify(_)) => panic!("fixture failed verify?"),
+            Err(CompileError::Verify(_)) | Err(CompileError::Regex(_)) => {
+                panic!("fixture failed verify?")
+            }
             Ok(_) => panic!("compile accepted bad statics (wanted '{needle}')"),
         }
     }
@@ -451,6 +455,7 @@ fn sparse_value_ids_use_dense_register_slots() {
     use super::super::ir::{Block, Col, ColTy, Inst, Lit, Program, Term, Ty, Value};
     let p = Program {
         statics: vec![],
+        regexes: vec![],
         name: "sparse".into(),
         in_cols: vec![],
         out_cols: vec![Col {