fix(jit): propagate replace-many bridge failures

Author: fffonion

src/builtins/runtime/core.rs

@@ -792,7 +792,11 @@ pub(crate) fn builtin_string_replace_literal_impl(
     text.replace(needle, replacement)
 }
 
-/// Apply ordered literal replacements from parallel needle/replacement arrays.
+/// Apply literal replacements in order from parallel `needles` and `replacements` arrays.
+///
+/// Each pair uses the same non-overlapping semantics as the scalar overload. Empty needles
+/// leave the current output unchanged. Both arrays must have equal length and contain strings.
+/// A length mismatch or a non-string element returns an error.
 #[pd_host_function(name = "string_replace_literal")]
 pub(crate) fn builtin_string_replace_literal_many_impl(
     text: VmStringRef<'_>,

src/vm/jit/native/lower.rs

@@ -1839,12 +1839,6 @@ fn lower_ssa_inst(
             let text = values[text];
             let needles = values[needles];
             let replacements = values[replacements];
-            let out = owned_value_temp_slot_addr(
-                b,
-                pointer_type,
-                owned_value_temps,
-                SsaTempValueSlotKey::Output(output.id),
-            )?;
             let out_raw = ssa_call_string_replace_literal_many(
                 b,
                 pointer_type,
@@ -1854,6 +1848,20 @@ fn lower_ssa_inst(
                 needles,
                 replacements,
             )?;
+            let error = b.ins().icmp_imm(IntCC::Equal, out_raw, 0);
+            let failed = b.create_block();
+            let replaced = b.create_block();
+            b.ins().brif(error, failed, &[], replaced, &[]);
+            b.switch_to_block(failed);
+            let status = b.ins().iconst(types::I32, STATUS_ERROR as i64);
+            jump_with_status(b, exit_block, status);
+            b.switch_to_block(replaced);
+            let out = owned_value_temp_slot_addr(
+                b,
+                pointer_type,
+                owned_value_temps,
+                SsaTempValueSlotKey::Output(output.id),
+            )?;
             clear_owned_value_temp_slot(b, pointer_type, helper_refs, helper_addrs, out)?;
             ssa_store_heap_ptr_in_value(b, layout.value, out, layout.value.string_tag, out_raw);
             out
@@ -3979,6 +3987,7 @@ fn ssa_call_regex_match(
     Ok(b.inst_results(call)[0])
 }
 
+#[allow(clippy::too_many_arguments)]
 fn ssa_call_regex_replace(
     b: &mut FunctionBuilder,
     pointer_type: cranelift_codegen::ir::Type,

tests/jit/jit_tests.rs

@@ -4858,3 +4858,39 @@ fn trace_jit_specializes_regex_builtins_without_call_boundary() {
     assert_eq!(vm.regex_cache_compile_count(), 2);
     assert!(vm.regex_cache_hit_count() >= 14);
 }
+
+#[test]
+fn trace_jit_propagates_replace_many_length_mismatch() {
+    if !native_jit_supported() {
+        return;
+    }
+    let source = r#"
+        let needles = ["a"];
+        let replacement_sets: [[string]] = [["x"], ["x"], ["x"], ["x"], ["x"], []];
+        let mut replacements: [string] = ["x"];
+        let mut i = 0;
+        let mut out = "";
+        while i < 6 {
+            replacements = (&replacement_sets)[i];
+            out = string_replace_literal("a", &needles, &replacements);
+            i = i + 1;
+        }
+        out;
+    "#;
+    let compiled = compile_source(source).expect("replace-many mismatch fixture should compile");
+    let mut vm = Vm::new_with_jit_config(
+        compiled.program.with_local_count(compiled.locals),
+        JitConfig {
+            enabled: true,
+            hot_loop_threshold: 1,
+            max_trace_len: 512,
+        },
+    );
+    let error = vm
+        .run()
+        .expect_err("replace-many mismatch should propagate its host error");
+    assert_eq!(
+        error.to_string(),
+        "host error: string_replace_literal array lengths must match"
+    );
+}