feat: 提取 oxide_builtins 独立 crate，泛型化 <H: VmHost>

crates/oxide_builtins/src/string.rs

@@ -0,0 +1,613 @@
+use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
+use oxide_types::object::JsObject;
+use oxide_types::value::JsValue;
+
+use memchr::memchr;
+use oxide_runtime_api::{NativeResult, VmHost};
+
+fn this_string<H: VmHost>(vm: &H, args: &[u8]) -> String {
+    oxide_runtime_api::to_string(vm.reg(args[0]))
+}
+
+pub fn string_from_char_code<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let mut out = String::new();
+    for &arg_reg in args.iter().skip(1) {
+        let code = oxide_runtime_api::to_uint32(vm.reg(arg_reg)) & 0xFFFF;
+        if let Some(ch) = char::from_u32(code) {
+            out.push(ch);
+        } else {
+            out.push('\u{FFFD}');
+        }
+    }
+    NativeResult::Ok(vm.new_string(&out))
+}
+
+pub fn string_value_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(args[0]);
+    if this_val.is_string() {
+        return NativeResult::Ok(this_val);
+    }
+    if this_val.is_object() {
+        let ptr = this_val.as_js_object_ptr();
+        if !ptr.is_null() {
+            let obj = unsafe { &*ptr };
+            if obj.is_string_obj() {
+                return NativeResult::Ok(obj.get_prop_at(0));
+            }
+        }
+    }
+    NativeResult::Err(crate::error::create_type_error(
+        vm,
+        "String.prototype.valueOf called on non-String object",
+    ))
+}
+
+pub fn string_constructor<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = if args.len() > 1 {
+        oxide_runtime_api::to_string(vm.reg(args[1]))
+    } else {
+        String::new()
+    };
+    let str_val = vm.new_string(&s);
+
+    let string_proto = vm.session().builtin_world().string_proto.as_ptr() as *mut JsObject;
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let is_ctor = if this_val.is_object() {
+        let ptr = this_val.as_js_object_ptr();
+        if ptr.is_null() {
+            false
+        } else {
+            let proto_ptr = unsafe { (*ptr).proto().as_js_object_ptr() };
+            !proto_ptr.is_null() && std::ptr::eq(proto_ptr, string_proto)
+        }
+    } else {
+        false
+    };
+
+    if !is_ctor {
+        return NativeResult::Ok(str_val);
+    }
+
+    let obj = unsafe { &mut *this_val.as_js_object_ptr() };
+    obj.type_tag = JsObject::OBJ_TYPE_STRING_OBJ;
+    obj.push_prop(str_val);
+    NativeResult::Ok(this_val)
+}
+
+pub fn string_to_string<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(args[0]);
+    if this_val.is_string() {
+        return NativeResult::Ok(this_val);
+    }
+    if this_val.is_object() {
+        let ptr = this_val.as_js_object_ptr();
+        if !ptr.is_null() {
+            let obj = unsafe { &*ptr };
+            if obj.is_string_obj() {
+                return NativeResult::Ok(obj.get_prop_at(0));
+            }
+        }
+    }
+    NativeResult::Err(crate::error::create_type_error(
+        vm,
+        "String.prototype.toString called on non-String object",
+    ))
+}
+
+fn make_string_array<H: VmHost>(vm: &mut H, parts: &[String]) -> JsValue {
+    let proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject;
+    let n = parts.len();
+    let arr =
+        vm.epoch()
+            .alloc(JsObject::new_array(EMPTY_SHAPE_ID, JsValue::from_js_object(proto), n, vm.epoch().bump()));
+    unsafe {
+        for (i, s) in parts.iter().enumerate() {
+            let sv = vm.new_string(s);
+            (*arr).set_prop_at(i, sv);
+        }
+        (*arr).set_prop_count(n);
+    }
+    JsValue::from_js_object(arr)
+}
+
+fn as_string<H: VmHost>(_vm: &H, val: JsValue) -> String {
+    oxide_runtime_api::to_string(val)
+}
+
+fn char_len(s: &str) -> usize {
+    s.chars().count()
+}
+
+fn byte_index_at_char(s: &str, char_pos: usize) -> usize {
+    if char_pos == 0 {
+        return 0;
+    }
+    s.char_indices().nth(char_pos).map(|(idx, _)| idx).unwrap_or(s.len())
+}
+
+fn char_slice(s: &str, start: usize, end: usize) -> &str {
+    let start_byte = byte_index_at_char(s, start);
+    let end_byte = byte_index_at_char(s, end);
+    &s[start_byte..end_byte]
+}
+
+fn take_chars(s: &str, count: usize) -> String {
+    s.chars().take(count).collect()
+}
+
+fn is_regexp_obj<H: VmHost>(val: JsValue, vm: &H) -> bool {
+    if !val.is_object() {
+        return false;
+    }
+    let ptr = val.as_js_object_ptr();
+    if ptr.is_null() {
+        return false;
+    }
+    let obj = unsafe { &*ptr };
+    let proto = obj.proto();
+    if !proto.is_object() {
+        return false;
+    }
+    let proto_ptr = proto.as_js_object_ptr();
+    if proto_ptr.is_null() {
+        return false;
+    }
+    let rp = vm.session().builtin_world().regexp_proto.as_ptr() as *mut JsObject;
+    std::ptr::eq(proto_ptr, rp)
+}
+
+pub fn string_index_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = char_len(&s);
+    if args.len() < 2 {
+        return NativeResult::Ok(JsValue::int(-1));
+    }
+    let search = as_string(vm, vm.reg(args[1]));
+    let pos = if args.len() > 2 {
+        (oxide_runtime_api::to_number(vm.reg(args[2])) as usize).min(n)
+    } else {
+        0
+    };
+
+    if search.is_empty() {
+        return NativeResult::Ok(JsValue::int(pos as i32));
+    }
+
+    let start_byte = byte_index_at_char(&s, pos);
+    let haystack = &s[start_byte..];
+    if search.len() == 1 {
+        if let Some(idx) = memchr(search.as_bytes()[0], haystack.as_bytes()) {
+            let matched_byte = start_byte + idx;
+            return NativeResult::Ok(JsValue::int(char_len(&s[..matched_byte]) as i32));
+        }
+    } else if let Some(idx) = haystack.find(&search) {
+        let matched_byte = start_byte + idx;
+        return NativeResult::Ok(JsValue::int(char_len(&s[..matched_byte]) as i32));
+    }
+    NativeResult::Ok(JsValue::int(-1))
+}
+
+pub fn string_includes<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = char_len(&s);
+    if args.len() < 2 {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let search = as_string(vm, vm.reg(args[1]));
+    let pos = if args.len() > 2 {
+        (oxide_runtime_api::to_number(vm.reg(args[2])) as usize).min(n)
+    } else {
+        0
+    };
+
+    if search.is_empty() {
+        return NativeResult::Ok(JsValue::bool(true));
+    }
+
+    let haystack = &s[byte_index_at_char(&s, pos)..];
+    if search.len() == 1 {
+        NativeResult::Ok(JsValue::bool(memchr(search.as_bytes()[0], haystack.as_bytes()).is_some()))
+    } else {
+        NativeResult::Ok(JsValue::bool(haystack.contains(&search)))
+    }
+}
+
+pub fn string_char_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        if s.is_empty() {
+            return NativeResult::Ok(vm.new_string(""));
+        }
+        return NativeResult::Ok(vm.new_string(&take_chars(&s, 1)));
+    }
+    let idx = oxide_runtime_api::to_number(vm.reg(args[1])) as i32;
+    if idx < 0 || idx as usize >= char_len(&s) {
+        return NativeResult::Ok(vm.new_string(""));
+    }
+    let ch = s.chars().nth(idx as usize).map(|c| c.to_string()).unwrap_or_default();
+    NativeResult::Ok(vm.new_string(&ch))
+}
+
+pub fn string_char_code_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        if s.is_empty() {
+            return NativeResult::Ok(JsValue::float(f64::NAN));
+        }
+        return NativeResult::Ok(JsValue::int(s.chars().next().unwrap() as i32));
+    }
+    let idx = oxide_runtime_api::to_number(vm.reg(args[1])) as i32;
+    if idx < 0 || idx as usize >= char_len(&s) {
+        return NativeResult::Ok(JsValue::float(f64::NAN));
+    }
+    NativeResult::Ok(JsValue::int(s.chars().nth(idx as usize).unwrap() as i32))
+}
+
+pub fn string_concat<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let mut result = this_string(vm, args);
+    for &arg_reg in args.iter().skip(1) {
+        result.push_str(&oxide_runtime_api::to_string(vm.reg(arg_reg)));
+    }
+    NativeResult::Ok(vm.new_string(&result))
+}
+
+pub fn string_slice<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = char_len(&s) as i32;
+    let start = if args.len() > 1 {
+        let v = oxide_runtime_api::to_number(vm.reg(args[1])) as i32;
+        if v < 0 {
+            (n + v).max(0)
+        } else {
+            v.min(n)
+        }
+    } else {
+        0
+    };
+    let end = if args.len() > 2 {
+        let v = oxide_runtime_api::to_number(vm.reg(args[2])) as i32;
+        if v < 0 {
+            (n + v).max(0)
+        } else {
+            v.min(n)
+        }
+    } else {
+        n
+    };
+    let start = start as usize;
+    let end = end as usize;
+    let result = if start < end { char_slice(&s, start, end) } else { "" };
+    NativeResult::Ok(vm.new_string(result))
+}
+
+pub fn string_substring<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = char_len(&s) as i32;
+    let mut start = if args.len() > 1 {
+        (oxide_runtime_api::to_number(vm.reg(args[1])) as i32).max(0).min(n)
+    } else {
+        0
+    };
+    let mut end = if args.len() > 2 {
+        (oxide_runtime_api::to_number(vm.reg(args[2])) as i32).max(0).min(n)
+    } else {
+        n
+    };
+    if start > end {
+        std::mem::swap(&mut start, &mut end);
+    }
+    let result = char_slice(&s, start as usize, end as usize);
+    NativeResult::Ok(vm.new_string(result))
+}
+
+pub fn string_to_upper_case<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    NativeResult::Ok(vm.new_string(&s.to_uppercase()))
+}
+
+pub fn string_to_lower_case<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    NativeResult::Ok(vm.new_string(&s.to_lowercase()))
+}
+
+pub fn string_trim<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    NativeResult::Ok(vm.new_string(s.trim()))
+}
+
+pub fn string_repeat<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = if args.len() > 1 {
+        (oxide_runtime_api::to_number(vm.reg(args[1])) as usize).min(10000)
+    } else {
+        1
+    };
+    NativeResult::Ok(vm.new_string(&s.repeat(n)))
+}
+
+pub fn string_pad_start<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let s_len = char_len(&s);
+    let target = if args.len() > 1 {
+        oxide_runtime_api::to_number(vm.reg(args[1])) as usize
+    } else {
+        s_len
+    };
+    if target > 10000 {
+        return NativeResult::Err(crate::error::create_range_error(vm, "Invalid string length"));
+    }
+    let pad = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { " ".to_string() };
+    if s_len >= target || pad.is_empty() {
+        return NativeResult::Ok(vm.new_string(&s));
+    }
+    let needed = target - s_len;
+    let pad_len = char_len(&pad).max(1);
+    let reps = needed.div_ceil(pad_len);
+    let mut out = take_chars(&pad.repeat(reps), needed);
+    out.push_str(&s);
+    NativeResult::Ok(vm.new_string(&out))
+}
+
+pub fn string_pad_end<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let s_len = char_len(&s);
+    let target = if args.len() > 1 {
+        oxide_runtime_api::to_number(vm.reg(args[1])) as usize
+    } else {
+        s_len
+    };
+    if target > 10000 {
+        return NativeResult::Err(crate::error::create_range_error(vm, "Invalid string length"));
+    }
+    let pad = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { " ".to_string() };
+    if s_len >= target || pad.is_empty() {
+        return NativeResult::Ok(vm.new_string(&s));
+    }
+    let needed = target - s_len;
+    let pad_len = char_len(&pad).max(1);
+    let reps = needed.div_ceil(pad_len);
+    let mut out = s;
+    out.push_str(&take_chars(&pad.repeat(reps), needed));
+    NativeResult::Ok(vm.new_string(&out))
+}
+
+pub fn string_starts_with<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = char_len(&s);
+    if args.len() < 2 {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let search = as_string(vm, vm.reg(args[1]));
+    let pos = if args.len() > 2 {
+        (oxide_runtime_api::to_number(vm.reg(args[2])) as usize).min(n)
+    } else {
+        0
+    };
+    NativeResult::Ok(JsValue::bool(s[byte_index_at_char(&s, pos)..].starts_with(&search)))
+}
+
+pub fn string_ends_with<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let n = char_len(&s);
+    if args.len() < 2 {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let search = as_string(vm, vm.reg(args[1]));
+    let end_pos = if args.len() > 2 {
+        (oxide_runtime_api::to_number(vm.reg(args[2])) as usize).min(n)
+    } else {
+        n
+    };
+    NativeResult::Ok(JsValue::bool(s[..byte_index_at_char(&s, end_pos)].ends_with(&search)))
+}
+
+pub fn string_split<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        let parts = vec![s.clone()];
+        return NativeResult::Ok(make_string_array(vm, &parts));
+    }
+    let sep_val = vm.reg(args[1]);
+    let limit = if args.len() > 2 {
+        oxide_runtime_api::to_number(vm.reg(args[2])) as usize
+    } else {
+        usize::MAX
+    };
+
+    if is_regexp_obj(sep_val, vm) {
+        let re_ptr = sep_val.as_js_object_ptr();
+        let re = unsafe { &*re_ptr };
+        let fn_ptr = match re.native_fn() {
+            Some(p) => p,
+            None => {
+                let parts = vec![s.clone()];
+                return NativeResult::Ok(make_string_array(vm, &parts));
+            }
+        };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
+        let raw: Vec<&str> = regex.split(&s).collect();
+        let parts: Vec<String> = raw.iter().map(|p| p.to_string()).take(limit).collect();
+        return NativeResult::Ok(make_string_array(vm, &parts));
+    }
+
+    let sep = as_string(vm, sep_val);
+    let parts: Vec<String> = if sep.is_empty() {
+        s.chars().map(|c| c.to_string()).take(limit).collect()
+    } else {
+        s.split(&sep).map(|p| p.to_string()).take(limit).collect()
+    };
+    NativeResult::Ok(make_string_array(vm, &parts))
+}
+
+pub fn string_replace<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        return NativeResult::Ok(vm.new_string(&s));
+    }
+    let pattern_val = vm.reg(args[1]);
+    let replacement = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { String::new() };
+
+    if is_regexp_obj(pattern_val, vm) {
+        let re_ptr = pattern_val.as_js_object_ptr();
+        let re = unsafe { &*re_ptr };
+        let fn_ptr = match re.native_fn() {
+            Some(p) => p,
+            None => return NativeResult::Ok(vm.new_string(&s)),
+        };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
+        let result = regex.replace_all(&s, replacement.as_str()).to_string();
+        return NativeResult::Ok(vm.new_string(&result));
+    }
+
+    let pattern = as_string(vm, pattern_val);
+    let result = s.replacen(&pattern, &replacement, 1);
+    NativeResult::Ok(vm.new_string(&result))
+}
+
+pub fn string_match_fn<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        return NativeResult::Ok(JsValue::undefined());
+    }
+    let pattern_val = vm.reg(args[1]);
+
+    if is_regexp_obj(pattern_val, vm) {
+        let re_ptr = pattern_val.as_js_object_ptr();
+        let re = unsafe { &*re_ptr };
+        let fn_ptr = match re.native_fn() {
+            Some(p) => p,
+            None => return NativeResult::Ok(JsValue::undefined()),
+        };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
+        let matches: Vec<String> = regex.find_iter(&s).map(|m| m.as_str().to_string()).collect();
+        return NativeResult::Ok(make_string_array(vm, &matches));
+    }
+
+    let pattern = as_string(vm, pattern_val);
+    if let Some(pos) = s.find(&pattern) {
+        return NativeResult::Ok(make_string_array(vm, &[s[pos..pos + pattern.len()].to_string()]));
+    }
+    NativeResult::Ok(JsValue::undefined())
+}
+
+pub fn string_search<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        return NativeResult::Ok(JsValue::int(-1));
+    }
+    let pattern_val = vm.reg(args[1]);
+
+    if is_regexp_obj(pattern_val, vm) {
+        let re_ptr = pattern_val.as_js_object_ptr();
+        let re = unsafe { &*re_ptr };
+        let fn_ptr = match re.native_fn() {
+            Some(p) => p,
+            None => return NativeResult::Ok(JsValue::int(-1)),
+        };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
+        if let Some(m) = regex.find(&s) {
+            return NativeResult::Ok(JsValue::int(m.start() as i32));
+        }
+        return NativeResult::Ok(JsValue::int(-1));
+    }
+
+    let pattern = as_string(vm, pattern_val);
+    if let Some(pos) = s.find(&pattern) {
+        return NativeResult::Ok(JsValue::int(pos as i32));
+    }
+    NativeResult::Ok(JsValue::int(-1))
+}
+
+pub fn string_trim_start<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    NativeResult::Ok(vm.new_string(s.trim_start()))
+}
+
+pub fn string_trim_end<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    NativeResult::Ok(vm.new_string(s.trim_end()))
+}
+
+pub fn string_code_point_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    let pos = if args.len() > 1 {
+        oxide_runtime_api::to_number(vm.reg(args[1])) as usize
+    } else {
+        0
+    };
+    let chars: Vec<char> = s.chars().collect();
+    if pos >= chars.len() {
+        return NativeResult::Ok(JsValue::undefined());
+    }
+    let c = chars[pos] as u32;
+    if (0xD800..=0xDBFF).contains(&c) && pos + 1 < chars.len() {
+        let next = chars[pos + 1] as u32;
+        if (0xDC00..=0xDFFF).contains(&next) {
+            let cp = 0x10000 + ((c - 0xD800) << 10) + (next - 0xDC00);
+            return NativeResult::Ok(JsValue::int(cp as i32));
+        }
+    }
+    NativeResult::Ok(JsValue::int(c as i32))
+}
+
+pub fn string_normalize<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    use unicode_normalization::UnicodeNormalization;
+    let s = this_string(vm, args);
+    let form = if args.len() > 1 { as_string(vm, vm.reg(args[1])) } else { "NFC".to_string() };
+    let result: String = match form.as_str() {
+        "NFD" => s.nfd().collect(),
+        "NFKC" => s.nfkc().collect(),
+        "NFKD" => s.nfkd().collect(),
+        _ => s.nfc().collect(),
+    };
+    NativeResult::Ok(vm.new_string(&result))
+}
+
+pub fn string_match_all<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        return NativeResult::Err(JsValue::undefined());
+    }
+    let pattern_val = vm.reg(args[1]);
+    if is_regexp_obj(pattern_val, vm) {
+        let re_ptr = pattern_val.as_js_object_ptr();
+        let re = unsafe { &*re_ptr };
+        let fn_ptr = match re.native_fn() {
+            Some(p) => p,
+            None => return NativeResult::Ok(JsValue::undefined()),
+        };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
+        let matches: Vec<String> = regex.find_iter(&s).map(|m| m.as_str().to_string()).collect();
+        return NativeResult::Ok(make_string_array(vm, &matches));
+    }
+    NativeResult::Ok(JsValue::undefined())
+}
+
+pub fn string_replace_all<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let s = this_string(vm, args);
+    if args.len() < 2 {
+        return NativeResult::Ok(vm.new_string(&s));
+    }
+    let pattern_val = vm.reg(args[1]);
+    let replacement = if args.len() > 2 { as_string(vm, vm.reg(args[2])) } else { String::new() };
+    if is_regexp_obj(pattern_val, vm) {
+        let re_ptr = pattern_val.as_js_object_ptr();
+        let re = unsafe { &*re_ptr };
+        let fn_ptr = match re.native_fn() {
+            Some(p) => p,
+            None => return NativeResult::Ok(vm.new_string(&s)),
+        };
+        // SAFETY: fn_ptr holds a Box<regex::Regex> pointer stored by regexp_constructor.
+        let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) };
+        let result = regex.replace_all(&s, replacement.as_str()).to_string();
+        return NativeResult::Ok(vm.new_string(&result));
+    }
+    let pattern = as_string(vm, pattern_val);
+    let result = s.replace(&pattern, &replacement);
+    NativeResult::Ok(vm.new_string(&result))
+}