revert(strings): remove replacement-array overload

fffonion · fffonion · commit 41fd6cd83c99 · 2026-07-17T17:45:14.000+08:00
diff --git a/README.md b/README.md
@@ -761,6 +761,9 @@ frontend/source patterns may still reach a `Bridge/Exit` path even when an SSA i
 | `len(map)` | Bridge/Exit | Inline |
 | `get(map)` | Bridge/Exit | Helper |
 | `has(map)` | Bridge/Exit | Helper |
+| `string_contains`, `string_replace_literal`, `string_lower_ascii`, `string_split_literal` | Bridge/Exit | Helper |
+| `re::match`, `re::replace` | Bridge/Exit | Helper |
+| Dynamic `type`, `to_string`, equality, and `len` | Bridge/Exit | Helper (known `type` / string `to_string` cases are folded) |
 | All other builtins | Bridge/Exit | Bridge/Exit or NYI, depending on trace shape |
 | Host imports | Bridge/Exit | Bridge/Exit or branch-exit trace, never inline |
 
diff --git a/src/builtins/runtime/core.rs b/src/builtins/runtime/core.rs
@@ -792,38 +792,6 @@ pub(crate) fn builtin_string_replace_literal_impl(
     text.replace(needle, replacement)
 }
 
-/// 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<'_>,
-    needles: VmArrayRef<'_>,
-    replacements: VmArrayRef<'_>,
-) -> VmResult<String> {
-    if needles.len() != replacements.len() {
-        return Err(VmError::HostError(
-            "string_replace_literal array lengths must match".to_string(),
-        ));
-    }
-    let mut out = text.to_string();
-    for (needle, replacement) in needles.iter().zip(replacements.iter()) {
-        let (Value::String(needle), Value::String(replacement)) = (needle, replacement) else {
-            return Err(VmError::TypeMismatch("string arrays"));
-        };
-        if needle.is_empty() || out.contains(needle.as_str()) {
-            out = builtin_string_replace_literal_impl(
-                out.as_str(),
-                needle.as_str(),
-                replacement.as_str(),
-            );
-        }
-    }
-    Ok(out)
-}
-
 /// Lower ASCII `A`-`Z` bytes in `text` while preserving UTF-8.
 #[pd_host_function(name = "string_lower_ascii")]
 pub(crate) fn builtin_string_lower_ascii_impl(text: VmStringRef<'_>) -> String {
diff --git a/src/builtins/runtime/mod.rs b/src/builtins/runtime/mod.rs
@@ -76,15 +76,8 @@ pub(crate) fn execute_builtin_call(
         BuiltinFunction::MapIterClose => map_iter::close(vm, args).map(BuiltinCallOutcome::Return),
         BuiltinFunction::StringContains => core::builtin_string_contains(args)
             .map(IntoBuiltinCallOutcome::into_builtin_call_outcome),
-        BuiltinFunction::StringReplaceLiteral => {
-            if matches!(args, [Value::String(_), Value::Array(_), Value::Array(_)]) {
-                core::builtin_string_replace_literal_many(args)
-                    .map(IntoBuiltinCallOutcome::into_builtin_call_outcome)
-            } else {
-                core::builtin_string_replace_literal(args)
-                    .map(IntoBuiltinCallOutcome::into_builtin_call_outcome)
-            }
-        }
+        BuiltinFunction::StringReplaceLiteral => core::builtin_string_replace_literal(args)
+            .map(IntoBuiltinCallOutcome::into_builtin_call_outcome),
         BuiltinFunction::StringLowerAscii => core::builtin_string_lower_ascii(args)
             .map(IntoBuiltinCallOutcome::into_builtin_call_outcome),
         BuiltinFunction::StringSplitLiteral => core::builtin_string_split_literal(args)
diff --git a/src/vm/jit/ir.rs b/src/vm/jit/ir.rs
@@ -156,11 +156,6 @@ pub(crate) enum SsaInstKind {
         needle: SsaValueId,
         replacement: SsaValueId,
     },
-    StringReplaceLiteralMany {
-        text: SsaValueId,
-        needles: SsaValueId,
-        replacements: SsaValueId,
-    },
     StringLowerAscii {
         text: SsaValueId,
     },
@@ -418,11 +413,6 @@ impl SsaInstKind {
                 needle,
                 replacement,
             } => vec![*text, *needle, *replacement],
-            Self::StringReplaceLiteralMany {
-                text,
-                needles,
-                replacements,
-            } => vec![*text, *needles, *replacements],
             Self::StringLowerAscii { text } => vec![*text],
             Self::TypeOf { value } | Self::ToString { value } => vec![*value],
             Self::StringSplitLiteral { text, delimiter } => vec![*text, *delimiter],
@@ -1050,13 +1040,6 @@ fn render_inst_kind(kind: &SsaInstKind) -> String {
         } => {
             format!("string_replace_literal {text}, {needle}, {replacement}")
         }
-        SsaInstKind::StringReplaceLiteralMany {
-            text,
-            needles,
-            replacements,
-        } => {
-            format!("string_replace_literal_many {text}, {needles}, {replacements}")
-        }
         SsaInstKind::StringLowerAscii { text } => format!("string_lower_ascii {text}"),
         SsaInstKind::TypeOf { value } => format!("type_of {value}"),
         SsaInstKind::ToString { value } => format!("to_string {value}"),
diff --git a/src/vm/jit/native/lower.rs b/src/vm/jit/native/lower.rs
@@ -26,11 +26,10 @@ use crate::vm::native::{
     shared_string_from_buffer_entry_address, sparse_restore_exit_signature,
     string_binary_transform_signature, string_contains_entry_address, string_contains_signature,
     string_lower_ascii_entry_address, string_replace_literal_entry_address,
-    string_replace_literal_many_entry_address, string_replace_signature,
-    string_split_literal_entry_address, string_unary_transform_signature, to_string_entry_address,
-    type_of_entry_address, value_eq_entry_address, value_eq_signature, value_len_entry_address,
-    value_len_signature, value_slot_signature, write_heap_value_to_slot_entry_address,
-    zero_bytes_entry_address,
+    string_replace_signature, string_split_literal_entry_address, string_unary_transform_signature,
+    to_string_entry_address, type_of_entry_address, value_eq_entry_address, value_eq_signature,
+    value_len_entry_address, value_len_signature, value_slot_signature,
+    write_heap_value_to_slot_entry_address, zero_bytes_entry_address,
 };
 use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
 use cranelift_codegen::ir::immediates::Ieee64;
@@ -171,7 +170,6 @@ fn try_compile_ssa_trace(
             regex_match: regex_match_entry_address(),
             regex_replace: regex_replace_entry_address(),
             replace_literal: string_replace_literal_entry_address(),
-            replace_literal_many: string_replace_literal_many_entry_address(),
             lower_ascii: string_lower_ascii_entry_address(),
             type_of: type_of_entry_address(),
             to_string: to_string_entry_address(),
@@ -501,7 +499,6 @@ struct SsaStringHelperAddrs {
     regex_match: usize,
     regex_replace: usize,
     replace_literal: usize,
-    replace_literal_many: usize,
     lower_ascii: usize,
     type_of: usize,
     to_string: usize,
@@ -593,7 +590,6 @@ fn ssa_trace_supported(ssa: &SsaTrace) -> bool {
                     | SsaInstKind::RegexMatch { .. }
                     | SsaInstKind::RegexReplace { .. }
                     | SsaInstKind::StringReplaceLiteral { .. }
-                    | SsaInstKind::StringReplaceLiteralMany { .. }
                     | SsaInstKind::StringLowerAscii { .. }
                     | SsaInstKind::TypeOf { .. }
                     | SsaInstKind::ToString { .. }
@@ -877,7 +873,6 @@ fn ssa_inst_requires_owned_value_slot(kind: &SsaInstKind) -> bool {
             | SsaInstKind::StringGet { .. }
             | SsaInstKind::RegexReplace { .. }
             | SsaInstKind::StringReplaceLiteral { .. }
-            | SsaInstKind::StringReplaceLiteralMany { .. }
             | SsaInstKind::StringLowerAscii { .. }
             | SsaInstKind::TypeOf { .. }
             | SsaInstKind::ToString { .. }
@@ -1831,41 +1826,6 @@ fn lower_ssa_inst(
             ssa_store_heap_ptr_in_value(b, layout.value, out, layout.value.string_tag, out_raw);
             out
         }
-        SsaInstKind::StringReplaceLiteralMany {
-            text,
-            needles,
-            replacements,
-        } => {
-            let text = values[text];
-            let needles = values[needles];
-            let replacements = values[replacements];
-            let out_raw = ssa_call_string_replace_literal_many(
-                b,
-                pointer_type,
-                string_refs,
-                string_addrs,
-                text,
-                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
-        }
         SsaInstKind::StringReplaceLiteral {
             text,
             needle,
@@ -4025,24 +3985,6 @@ fn ssa_call_string_replace_literal(
     Ok(b.inst_results(call)[0])
 }
 
-fn ssa_call_string_replace_literal_many(
-    b: &mut FunctionBuilder,
-    pointer_type: cranelift_codegen::ir::Type,
-    string_refs: SsaStringHelperRefs,
-    string_addrs: SsaStringHelperAddrs,
-    text: cranelift_codegen::ir::Value,
-    needles: cranelift_codegen::ir::Value,
-    replacements: cranelift_codegen::ir::Value,
-) -> VmResult<cranelift_codegen::ir::Value> {
-    let helper_ptr = iconst_ptr_from_addr(b, pointer_type, string_addrs.replace_literal_many)?;
-    let call = b.ins().call_indirect(
-        string_refs.replace_ref,
-        helper_ptr,
-        &[text, needles, replacements],
-    );
-    Ok(b.inst_results(call)[0])
-}
-
 fn ssa_call_string_lower_ascii(
     b: &mut FunctionBuilder,
     pointer_type: cranelift_codegen::ir::Type,
diff --git a/src/vm/jit/recorder.rs b/src/vm/jit/recorder.rs
@@ -482,7 +482,6 @@ enum SpecializedBuiltinKind {
     RegexMatch,
     RegexReplace,
     StringReplaceLiteral,
-    StringReplaceLiteralMany,
     StringLowerAscii,
     TypeOf,
     TypeOfKnown(ValueType),
@@ -1154,26 +1153,13 @@ pub(crate) fn record_trace(
                                 .iter()
                                 .all(|arg| arg.info.source_local != Some(local))
                     });
-                    let replace_many = builtin == BuiltinFunction::StringReplaceLiteral
-                        && (operand_types(program, ip).1 == ValueType::Array
-                            || (args.get(1).is_some_and(|arg| {
-                                observed_heap_container_kind(arg.info)
-                                    == Some(HeapContainerKind::Array)
-                            }) && args.get(2).is_some_and(|arg| {
-                                observed_heap_container_kind(arg.info)
-                                    == Some(HeapContainerKind::Array)
-                            })));
-                    let specialized_kind = if replace_many {
-                        Some(SpecializedBuiltinKind::StringReplaceLiteralMany)
-                    } else {
-                        select_specialized_builtin_kind(
-                            program,
-                            ip,
-                            builtin,
-                            args[0].info,
-                            container_was_moved,
-                        )
-                    };
+                    let specialized_kind = select_specialized_builtin_kind(
+                        program,
+                        ip,
+                        builtin,
+                        args[0].info,
+                        container_was_moved,
+                    );
                     if let Some(kind) = specialized_kind {
                         let (name, out) = emit_specialized_builtin_call(
                             &mut builder,
@@ -2847,19 +2833,12 @@ fn analyze_specialized_builtin_call(
             frame.push(ValueInfo::tagged_typed(ValueType::String));
             Ok("regex_replace")
         }
-        SpecializedBuiltinKind::StringReplaceLiteral
-        | SpecializedBuiltinKind::StringReplaceLiteralMany => {
+        SpecializedBuiltinKind::StringReplaceLiteral => {
             let _ = frame.pop()?;
             let _ = frame.pop()?;
             let _ = frame.pop()?;
             frame.push(ValueInfo::tagged_typed(ValueType::String));
-            Ok(
-                if matches!(kind, SpecializedBuiltinKind::StringReplaceLiteralMany) {
-                    "string_replace_literal_many"
-                } else {
-                    "string_replace_literal"
-                },
-            )
+            Ok("string_replace_literal")
         }
         SpecializedBuiltinKind::StringLowerAscii => {
             let _ = frame.pop()?;
@@ -3296,28 +3275,6 @@ fn emit_specialized_builtin_call(
                 .map_err(|err| TraceRecordError::InvalidIr(err.to_string()))?;
             Ok(("regex_replace", out))
         }
-        SpecializedBuiltinKind::StringReplaceLiteralMany => {
-            let replacements = ensure_heap_ptr(builder, block, ip, frame.pop()?, ValueType::Array)?;
-            let needles = ensure_heap_ptr(builder, block, ip, frame.pop()?, ValueType::Array)?;
-            let text = ensure_heap_ptr(builder, block, ip, frame.pop()?, ValueType::String)?;
-            let value = builder
-                .append_value_inst(
-                    block,
-                    ip,
-                    SsaValueRepr::Tagged,
-                    SsaInstKind::StringReplaceLiteralMany {
-                        text: text.value.id,
-                        needles: needles.value.id,
-                        replacements: replacements.value.id,
-                    },
-                )
-                .map(|value| SymbolicValue {
-                    value,
-                    info: ValueInfo::tagged_typed(ValueType::String),
-                })
-                .map_err(|err| TraceRecordError::InvalidIr(err.to_string()))?;
-            Ok(("string_replace_literal_many", value))
-        }
         SpecializedBuiltinKind::StringReplaceLiteral => {
             let replacement = ensure_heap_ptr(
                 builder,
diff --git a/src/vm/native/bridge.rs b/src/vm/native/bridge.rs
@@ -215,10 +215,6 @@ pub(crate) fn string_replace_literal_entry_address() -> usize {
     pd_vm_native_string_replace_literal as *const () as usize
 }
 
-pub(crate) fn string_replace_literal_many_entry_address() -> usize {
-    pd_vm_native_string_replace_literal_many as *const () as usize
-}
-
 pub(crate) fn string_lower_ascii_entry_address() -> usize {
     pd_vm_native_string_lower_ascii as *const () as usize
 }
@@ -502,29 +498,6 @@ pub(crate) extern "C" fn pd_vm_native_string_replace_literal(
     ))
 }
 
-pub(crate) extern "C" fn pd_vm_native_string_replace_literal_many(
-    text_ptr: *mut u8,
-    needles_ptr: *mut u8,
-    replacements_ptr: *mut u8,
-) -> *mut u8 {
-    let text = unsafe { std::mem::ManuallyDrop::new(arc_from_repr_ptr::<String>(text_ptr)) };
-    let needles =
-        unsafe { std::mem::ManuallyDrop::new(arc_from_repr_ptr::<Vec<Value>>(needles_ptr)) };
-    let replacements =
-        unsafe { std::mem::ManuallyDrop::new(arc_from_repr_ptr::<Vec<Value>>(replacements_ptr)) };
-    match crate::builtins::runtime::core::builtin_string_replace_literal_many_impl(
-        text.as_str(),
-        needles.as_slice(),
-        replacements.as_slice(),
-    ) {
-        Ok(value) => arc_into_repr_ptr(Arc::new(value)),
-        Err(error) => {
-            store_bridge_error(error);
-            std::ptr::null_mut()
-        }
-    }
-}
-
 pub(crate) extern "C" fn pd_vm_native_string_lower_ascii(text_ptr: *mut u8) -> *mut u8 {
     let text = unsafe { std::mem::ManuallyDrop::new(arc_from_repr_ptr::<String>(text_ptr)) };
     arc_into_repr_ptr(Arc::new(
diff --git a/src/vm/native/mod.rs b/src/vm/native/mod.rs
@@ -21,10 +21,9 @@ pub(crate) use bridge::{
     restore_sparse_exit_state_entry_address, shared_array_from_buffer_entry_address,
     shared_bytes_from_buffer_entry_address, shared_string_from_buffer_entry_address,
     store_bridge_error, string_contains_entry_address, string_lower_ascii_entry_address,
-    string_replace_literal_entry_address, string_replace_literal_many_entry_address,
-    string_split_literal_entry_address, take_bridge_error, to_string_entry_address,
-    type_of_entry_address, value_eq_entry_address, value_len_entry_address,
-    write_heap_value_to_slot_entry_address, zero_bytes_entry_address,
+    string_replace_literal_entry_address, string_split_literal_entry_address, take_bridge_error,
+    to_string_entry_address, type_of_entry_address, value_eq_entry_address,
+    value_len_entry_address, write_heap_value_to_slot_entry_address, zero_bytes_entry_address,
 };
 #[cfg(feature = "cranelift-jit")]
 pub(crate) use codegen::{
diff --git a/stdlib/tests/strings.rss b/stdlib/tests/strings.rss
@@ -10,10 +10,6 @@ assert(contains("hello", "ell"));
 assert(contains("hello", "zzz") == false);
 assert(equals(trim("  rustscript\n"), "rustscript"));
 assert(equals(replace("go gopher go", "go", "rs"), "rs rspher rs"));
-assert(equals(
-    string_replace_literal("%27x%20y+z", ["%27", "%20", "+"], ["'", " ", " "]),
-    "'x y z"
-));
 
 let mut parts = split("a,b,c", ",");
 assert(parts.length == 3);
diff --git a/tests/jit/jit_tests.rs b/tests/jit/jit_tests.rs
