ITStudio_OUC/OxideJS-New
0
1
Fork 0
mirror of https://github.com/pjh456/OxideJS.git synced 2026-10-23 18:21:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: 脏重建方法 wrapper/构造器/global 槽跨轮复用迁移——FnWrapperKey 四分件键(加 label 消解同名原型 next/return/throw 碰撞)登记表继承止 S2 每轮 wrapper 无界累积，global 槽原位更新堵住旧构造器滞留 UAF 与每轮 +3 槽无界增长

Browse Source
This commit is contained in:
彭俊皓
2026-09-11 18:06:19 +00:00
parent 4095ad2c1d
commit b17119ce16
12 changed files with 805 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oxide_cli/src/bench/leak_detect.rs
+28 -2
View File
@@ -231,8 +231,12 @@ pub fn run_mem_vm_creation_leak(kernel: &Arc<KernelCore>) -> ExitCode {
/// 路径的每轮内存增量（斜率 + 窗口总增量）。
///
/// # 注意事项
/// 键名逐轮递增保证走新键写入路径（既有槽位写不 bump 世代、不脏家族）；
/// 修复释放路径后期望走平，残留本体钉在页粒度噪声级。
/// 键名逐轮递增保证走新键写入路径（既有槽位写不 bump 世代、不脏家族）。
/// 跨轮继承锚点（登记表对象数 / global 属性槽数）采样自每轮 full_reset
/// 后：wrapper 复用与槽位原位更新生效时两者应持平，增长即泄漏签名。
/// RSS 残差模型（post-91.1 裁定）：object/function 家族脏重建每轮钉住 4
/// 件本体（重指遗漏兜底，不进门）+ 逐轮唯一键在共享内核 shape/perm 缓存
/// 的追加式增长（append-only 缓存，非 session 数据泄漏）。
pub fn run_mem_dirty_rebuild_leak(kernel: &Arc<KernelCore>) -> ExitCode {
const ROUNDS: usize = 3000;
const SAMPLE_EVERY: usize = 10;
@@ -242,6 +246,10 @@ pub fn run_mem_dirty_rebuild_leak(kernel: &Arc<KernelCore>) -> ExitCode {
let mut sampler = LeakSampler::new(20);
let mut series: Vec<(usize, f64)> = Vec::new();
// 跨轮继承锚点（登记表对象数 / global 属性槽数）：wrapper 复用与槽位
// 原位更新生效时两者应跨轮持平，增长即泄漏的直接签名（无页粒度噪音）。
let mut first_anchor: Option<(usize, usize)> = None;
let mut last_anchor: (usize, usize) = (0, 0);
for round in 0..ROUNDS {
// 键名逐轮递增：新键写才 bump 原型世代，重建才有脏家族可换。
let source = format!(
@@ -265,6 +273,12 @@ pub fn run_mem_dirty_rebuild_leak(kernel: &Arc<KernelCore>) -> ExitCode {
}
vm.full_reset();
if round % SAMPLE_EVERY == 0 {
let registry = vm.session().builtin_world().leaked_object_count();
let global_slots = unsafe { (*vm.session().global_object().as_ptr()).prop_vec_len() };
if first_anchor.is_none() {
first_anchor = Some((registry, global_slots));
}
last_anchor = (registry, global_slots);
if let Some(kb) = read_vmrss_kb() {
let v = kb as f64;
series.push((round, v));
@@ -277,6 +291,18 @@ pub fn run_mem_dirty_rebuild_leak(kernel: &Arc<KernelCore>) -> ExitCode {
}
}
}
if let Some((r0, g0)) = first_anchor {
let (r1, g1) = last_anchor;
eprintln!(
"[dirty_rebuild] anchors: registry {} -> {} ({:+}) global_slots {} -> {} ({:+})",
r0,
r1,
r1 as i64 - r0 as i64,
g0,
g1,
g1 as i64 - g0 as i64
);
}
report_series("dirty_rebuild", "round", &series)
}
crates/oxide_kernel/src/builtin.rs
+199 -43
View File
@@ -39,6 +39,17 @@ macro_rules! bind_methods_static {
);
})*
};
($target:expr, $sf:expr, $sh:expr, $world:expr, $label:expr,
$(($name:literal, $func:expr, $nargs:expr)),* $(,)?) => {
$({
let _raw: *const () = $func as *const ();
// SAFETY: $func 是 NativeFn 函数项；强转并包装合法。
let _func_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(_raw) };
let _ = $crate::builtin::BuiltinWorld::bind_method_labeled_static(
$target, $sh, $sf, $name, _func_ptr, $nargs, $world, $label,
);
})*
};
}
/// Object 静态方法与原型方法的 native 函数指针集合，由 builtin 绑定层填充后交给
@@ -302,7 +313,38 @@ pub struct BuiltinWorld {
/// 这些对象本体在堆上、不属任何 arena，`session` 收尾时按表统一释放
/// （属性区 + 本体）；选择性重建换 world 时本表整体并入新 world
/// （`inherit_leaked_objects`），仍由 session 收尾统一释放，不悬垂、不双放。
leaked_objects: std::cell::RefCell<Vec<*mut JsObject>>,
///
/// 可复用 native 函数 wrapper 带复用键（[`FnWrapperKey`]）：选择性重建
/// 重绑按键命中前轮旧 wrapper，迁移到重建 P 对象槽位，登记表跨轮不增长。
leaked_objects: std::cell::RefCell<Vec<LeakedSlot>>,
}
/// native 函数 wrapper 的复用键：（目标家族，目标站点标签，属性槽位键，wrapper 名）。
///
/// 家族目标是 [`BuiltinWorld::all_p_fields`] 枚举的稳定下标（重建跨轮不变，
/// 1..=N），此时标签恒 0；非 P 目标（global 对象、Box 自建构造器、宿主对象、
/// VM 内建原型）家族为 0，以绑定站点标签（站点名的 perm intern 键）区分
/// 同名方法槽位——如 Generator/AsyncGenerator 原型同名的 next/return/throw。
/// 选择性重建重绑按键查找前轮旧 wrapper 并迁移，避免每轮新建导致
/// 登记表无界累积；同键重复登记意味着复用键设计缺陷（debug 断言守约）。
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct FnWrapperKey {
family: u16,
label: u32,
slot: u32,
name: u32,
}
impl FnWrapperKey {
pub const fn new(family: u16, label: u32, slot: u32, name: u32) -> Self {
Self { family, label, slot, name }
}
}
/// 登记表条目：对象指针 + 可选复用键（`None` = 不可复用对象）。
struct LeakedSlot {
ptr: *mut JsObject,
key: Option<FnWrapperKey>,
}
fn intern_label(string_forge: &PermInterner, label: &str) -> u32 {
@@ -688,10 +730,65 @@ impl BuiltinWorld {
JsValue::from_js_object(self.function_proto.as_ptr() as *mut JsObject)
}
/// 登记一个绑定层经 `Box::into_raw` 持有的函数/宿主对象，供
/// [`Self::teardown_heap_data`] 在 session 收尾时统一释放。
/// 登记一个绑定层经 `Box::into_raw` 持有的函数/宿主对象（不可复用对象），
/// 供 [`Self::teardown_heap_data`] 在 session 收尾时统一释放；可复用
/// native 函数 wrapper 走 [`Self::track_fn_wrapper`]。
pub fn track_leaked_object(&self, obj_ptr: *mut JsObject) {
self.leaked_objects.borrow_mut().push(obj_ptr);
self.leaked_objects.borrow_mut().push(LeakedSlot { ptr: obj_ptr, key: None });
}
/// 登记一个可复用 native 函数 wrapper（带复用键），随登记表在 session
/// 收尾统一释放。
///
/// # 注意事项
/// 同键重复登记意味着复用键设计缺陷（同家族槽位对应两个不同 wrapper
/// 对象）——debug 断言立即失败。
pub fn track_fn_wrapper(&self, obj_ptr: *mut JsObject, key: FnWrapperKey) {
debug_assert!(
!self.leaked_objects.borrow().iter().any(|s| s.key == Some(key)),
"同键 native 函数 wrapper 重复登记"
);
self.leaked_objects
.borrow_mut()
.push(LeakedSlot { ptr: obj_ptr, key: Some(key) });
}
/// 查找复用键相同且 native 函数/参数个数匹配的既有 wrapper（选择性重建
/// 重绑的复用入口）。
///
/// # 边界与前提
/// 登记表指针 session 存活期内有效（full_reset 安全点无并发读者）；
/// native 函数与参数个数一并校验，防绑定表漂移时误换旧实现。
pub fn find_fn_wrapper(
&self, key: FnWrapperKey, native_fn_ptr: NativeFnPtr, arg_count: u8,
) -> Option<*mut JsObject> {
self.leaked_objects
.borrow()
.iter()
.find(|s| {
s.key == Some(key) && {
// SAFETY: 登记表指针 session 存活期内有效。
let obj = unsafe { &*s.ptr };
obj.native_fn().map(|p| p.0) == Some(native_fn_ptr.0) && obj.native_arg_count() == arg_count
}
})
.map(|s| s.ptr)
}
/// wrapper 复用键的目标家族标签：目标对象是本 world 固定 P 字段时返回
/// 其枚举下标 + 1（`all_p_fields` 顺序跨重建轮不变），非 P 目标返回 0。
pub fn wrapper_family_of(&self, obj: *const JsObject) -> u16 {
for (i, p) in self.all_p_fields().iter().enumerate() {
if std::ptr::eq(p.as_ptr(), obj) {
return (i + 1) as u16;
}
}
0
}
/// 登记表对象数（泄漏校准的跨轮继承采样锚点）。
pub fn leaked_object_count(&self) -> usize {
self.leaked_objects.borrow().len()
}
/// 选择性重建时把旧 world 的登记表整体并入新 world（见
@@ -770,7 +867,8 @@ impl BuiltinWorld {
}
}
}
for &ptr in self.leaked_objects.borrow().iter() {
for slot in self.leaked_objects.borrow().iter() {
let ptr = slot.ptr;
// SAFETY: 登记表指针 session 存活期内有效，重指安全点无并发读者。
unsafe {
repoint(&mut *ptr);
@@ -788,8 +886,8 @@ impl BuiltinWorld {
);
}
}
for &ptr in self.leaked_objects.borrow().iter() {
let cur = unsafe { (*ptr).proto() };
for slot in self.leaked_objects.borrow().iter() {
let cur = unsafe { (*slot.ptr).proto() };
debug_assert!(
!cur.is_object() || !remap.contains_key(&cur.as_js_object_ptr()),
"登记表 wrapper proto 槽不得残留被替换旧指针"
@@ -933,7 +1031,8 @@ impl BuiltinWorld {
/// session 收尾统一释放；被替换家族的旧 P 字段属性区在重建收尾
/// （`retire_replaced`）恰好释放一次，与本路径对象集不相交，不双放。
pub fn teardown_heap_data(&self) {
for ptr in self.leaked_objects.borrow_mut().drain(..) {
for slot in self.leaked_objects.borrow_mut().drain(..) {
let ptr = slot.ptr;
if ptr.is_null() {
continue;
}
@@ -1962,46 +2061,103 @@ impl BuiltinWorld {
/// 按指定属性键安装方法 wrapper（键不要求字符串 intern，well-known symbol 键用此路径）。
///
/// `method_name` 只用于 wrapper 的 `name` 属性；`key` 是属性的实际存储键。
/// 目标站点标签取 0：P 目标由家族下标区分，非 P 目标须经
/// [`Self::bind_method_key_labeled_static`] 传站点标签。
#[expect(clippy::too_many_arguments)]
pub fn bind_method_key_static(
proto: &mut JsObject, shape_forge: &ShapeForge, string_forge: &PermInterner, key: u32, method_name: &str,
native_fn_ptr: NativeFnPtr, arg_count: u8, world: &BuiltinWorld,
) -> Result<(), String> {
let wrapper_proto_val = world.fn_proto_val();
let wrapper_proto_ptr = if wrapper_proto_val.is_object() {
wrapper_proto_val.as_js_object_ptr()
} else {
std::ptr::null_mut()
Self::bind_method_key_labeled_static(
proto,
shape_forge,
string_forge,
key,
method_name,
native_fn_ptr,
arg_count,
world,
0,
)
}
/// [`Self::bind_method_static`] 的站点标签版本：属性键由方法名 intern 得出，
/// 供非 P 目标（VM 内建原型 Box 对象）的静态绑定宏使用。
#[expect(clippy::too_many_arguments)]
pub fn bind_method_labeled_static(
proto: &mut JsObject, shape_forge: &ShapeForge, string_forge: &PermInterner, method_name: &str,
native_fn_ptr: NativeFnPtr, arg_count: u8, world: &BuiltinWorld, label: u32,
) -> Result<(), String> {
let si = string_forge.intern(method_name).0;
Self::bind_method_key_labeled_static(
proto,
shape_forge,
string_forge,
si,
method_name,
native_fn_ptr,
arg_count,
world,
label,
)
}
/// 按指定属性键安装方法 wrapper，显式指定非 P 目标的绑定站点标签。
///
/// 同一 session 内多个非 P 目标（VM 内建原型 Box 对象等）可绑定同名方法槽
/// （如 next/return/throw）：站点标签（站点名 perm intern 键）使复用键跨
/// 站点唯一，重绑时只迁移本站点的旧 wrapper。
#[expect(clippy::too_many_arguments)]
pub fn bind_method_key_labeled_static(
proto: &mut JsObject, shape_forge: &ShapeForge, string_forge: &PermInterner, key: u32, method_name: &str,
native_fn_ptr: NativeFnPtr, arg_count: u8, world: &BuiltinWorld, label: u32,
) -> Result<(), String> {
let si = string_forge.intern(method_name).0;
// 选择性重建复用：同键前轮旧 wrapper 迁移到新 proto 槽位——其 proto 槽
// 已由重建收尾重指（或 Function 家族保留而不变），length/name 属性区
// 随对象保留，不再新建对象、登记表跨轮不增长。
let reuse_key = FnWrapperKey::new(world.wrapper_family_of(proto as *const JsObject), label, key, si);
let wrapper_ptr = match world.find_fn_wrapper(reuse_key, native_fn_ptr, arg_count) {
Some(ptr) => ptr,
None => {
let wrapper_proto_val = world.fn_proto_val();
let wrapper_proto_ptr = if wrapper_proto_val.is_object() {
wrapper_proto_val.as_js_object_ptr()
} else {
std::ptr::null_mut()
};
let mut wrapper = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()));
if !wrapper_proto_ptr.is_null() {
wrapper.set_proto(wrapper_proto_val).ok();
}
wrapper.set_function(true);
// NativeFnPtr 不变量由调用方维护（见 bind_method / bind_method_static
// 的调用方，均使用函数项表达式）。
wrapper.set_native_fn(Some(native_fn_ptr));
wrapper.set_native_arg_count(arg_count);
// 设置 .length (ES spec: Function.length = formal parameter count,
// {[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true})
let si_length = string_forge.intern("length").0;
let length_shape = shape_forge.make_shape(wrapper.shape_id(), si_length);
wrapper.set_shape_id(length_shape);
wrapper.ensure_hash_props().push(JsValue::int(arg_count as i32));
let length_pos = wrapper.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
wrapper.set_data_meta(length_pos, oxide_types::object::PropAttributes::new(false, false, true));
// 设置 .name ({[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true})
let si_name = string_forge.intern("name").0;
let name_shape = shape_forge.make_shape(wrapper.shape_id(), si_name);
wrapper.set_shape_id(name_shape);
wrapper
.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(si)));
let name_pos = wrapper.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
wrapper.set_data_meta(name_pos, oxide_types::object::PropAttributes::new(false, false, true));
// 登记进 world 释放表：session 收尾时统一释放 wrapper 的属性区与本体。
let wrapper_ptr = Box::into_raw(wrapper);
world.track_fn_wrapper(wrapper_ptr, reuse_key);
wrapper_ptr
}
};
let mut wrapper = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()));
if !wrapper_proto_ptr.is_null() {
wrapper.set_proto(wrapper_proto_val).ok();
}
wrapper.set_function(true);
// NativeFnPtr 不变量由调用方维护（见 bind_method / bind_method_static
// 的调用方，均使用函数项表达式）。
wrapper.set_native_fn(Some(native_fn_ptr));
wrapper.set_native_arg_count(arg_count);
// 设置 .length (ES spec: Function.length = formal parameter count,
// {[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true})
let si_length = string_forge.intern("length").0;
let length_shape = shape_forge.make_shape(wrapper.shape_id(), si_length);
wrapper.set_shape_id(length_shape);
wrapper.ensure_hash_props().push(JsValue::int(arg_count as i32));
let length_pos = wrapper.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
wrapper.set_data_meta(length_pos, oxide_types::object::PropAttributes::new(false, false, true));
// 设置 .name ({[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true})
let si_name = string_forge.intern("name").0;
let name_shape = shape_forge.make_shape(wrapper.shape_id(), si_name);
wrapper.set_shape_id(name_shape);
wrapper
.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(method_name).0)));
let name_pos = wrapper.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
wrapper.set_data_meta(name_pos, oxide_types::object::PropAttributes::new(false, false, true));
// 登记进 world 释放表：session 收尾时统一释放 wrapper 的属性区与本体。
let wrapper_ptr = Box::into_raw(wrapper);
world.track_leaked_object(wrapper_ptr);
let wrapper_val = JsValue::from_js_object(wrapper_ptr);
let new_shape = shape_forge.make_shape(proto.shape_id(), key);
proto.set_shape_id(new_shape);
@@ -2198,6 +2354,6 @@ mod tests {
assert!(std::ptr::eq(unsafe { (*object_ctor).proto().as_js_object_ptr() }, new_fn_proto));
assert!(std::ptr::eq(unsafe { (*wrapper).proto().as_js_object_ptr() }, new_fn_proto));
// 登记表并入新 world：保留 wrapper 仍须由 session 收尾统一释放。
assert!(session.builtin_world.leaked_objects.borrow().contains(&wrapper));
assert!(session.builtin_world.leaked_objects.borrow().iter().any(|s| s.ptr == wrapper));
}
}
crates/oxide_vm/src/async_func.rs
+36 -19
View File
@@ -402,30 +402,41 @@ pub(crate) fn init_async_intrinsics(vm: &mut Vm) {
let sh = vm.kernel_core.shape_forge().as_ref();
let fn_proto_val = vm.session.builtin_world().fn_proto_val();
// %AsyncFunction% 构造器：proto = Function.prototype，调用抛错（动态创建未实现）。
let mut af_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
af_ctor.set_function(true);
af_ctor.set_native_arg_count(1);
// %AsyncFunction% 占位构造器：proto = Function.prototype，调用抛错（动态
// 创建未实现）。选择性重建复用：前轮占位构造器按键迁移（prototype 槽在
// 下方 P 槽换入后重指新原型），不再每轮新建对象。
let af_ctor_label = sf.intern("AsyncFunctionCtor").0;
let af_reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, af_ctor_label, 0, 0);
// SAFETY: async_function_stub 是 NativeFn 函数项。
af_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(async_function_stub as *const ()) }));
let af_stub_ptr = unsafe { NativeFnPtr::from_raw(async_function_stub as *const ()) };
let (af_ctor_ptr, af_ctor_is_new) = match vm.session.builtin_world().find_fn_wrapper(af_reuse_key, af_stub_ptr, 1) {
Some(ptr) => (ptr, false),
None => {
let mut af_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
af_ctor.set_function(true);
af_ctor.set_native_arg_count(1);
af_ctor.set_native_fn(Some(af_stub_ptr));
let name_si = sf.intern("name").0;
let ctor_shape = sh.make_shape(af_ctor.shape_id(), name_si);
af_ctor.set_shape_id(ctor_shape);
let npos = af_ctor.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncFunction").0)));
af_ctor.set_data_meta(npos, PropAttributes::new(false, false, true));
let proto_si = sf.intern("prototype").0;
let ctor_shape2 = sh.make_shape(af_ctor.shape_id(), proto_si);
af_ctor.set_shape_id(ctor_shape2);
let af_ctor_ptr = Box::into_raw(af_ctor);
// 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
vm.session.builtin_world().track_fn_wrapper(af_ctor_ptr, af_reuse_key);
(af_ctor_ptr, true)
}
};
// %AsyncFunction.prototype%：proto = Function.prototype，constructor = %AsyncFunction%。
let mut af_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
let name_si = sf.intern("name").0;
let ctor_shape = sh.make_shape(af_ctor.shape_id(), name_si);
af_ctor.set_shape_id(ctor_shape);
let npos = af_ctor.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncFunction").0)));
af_ctor.set_data_meta(npos, PropAttributes::new(false, false, true));
let proto_si = sf.intern("prototype").0;
let ctor_shape2 = sh.make_shape(af_ctor.shape_id(), proto_si);
af_ctor.set_shape_id(ctor_shape2);
// af_proto.constructor = %AsyncFunction%（构造器登记进 world 释放表，与 builtin 方法 wrapper 同生命周期）。
let ctor_si = sf.intern("constructor").0;
let pshape = sh.make_shape(af_proto.shape_id(), ctor_si);
af_proto.set_shape_id(pshape);
// 登记进释放表：session 收尾统一释放构造器本体与属性区。
let af_ctor_ptr = Box::into_raw(af_ctor);
vm.session.builtin_world().track_leaked_object(af_ctor_ptr);
let cpos = af_proto.push_prop(JsValue::from_js_object(af_ctor_ptr));
af_proto.set_data_meta(cpos, PropAttributes::new(false, false, true));
// af_proto[Symbol.toStringTag] = "AsyncFunction"（数据属性，w/e/c = false/false/true）。
@@ -438,12 +449,18 @@ pub(crate) fn init_async_intrinsics(vm: &mut Vm) {
// proto 本体只存在于 P 槽（Arc 副本，原 Box 随函数结束释放）：装入 P 槽后再把
// 构造器 prototype 属性指向 P 槽实例，使其与动态异步函数使用的 [[Prototype]]
// 同一对象，保证 `AsyncFunction.prototype === (async () => {}).__proto__`。
// 复用构造器 prototype 槽原位改指新 P 原型（旧原型已随 P 换出释放）。
Vm::swap_intrinsic_proto(&mut vm.async_function_proto, *af_proto);
// SAFETY: af_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），对象已建满、本 Vm 独占。
// SAFETY: af_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），本 Vm 独占。
unsafe {
let ctor_mut = &mut *af_ctor_ptr;
let ppos = ctor_mut.push_prop(JsValue::from_js_object(vm.async_function_proto.as_mut_ptr()));
ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
let proto_val = JsValue::from_js_object(vm.async_function_proto.as_ptr() as *mut JsObject);
if af_ctor_is_new {
let ppos = ctor_mut.push_prop(proto_val);
ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
} else if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), sf.intern("prototype").0) {
ctor_mut.set_prop_at(pos, proto_val);
}
}
}
crates/oxide_vm/src/async_generator.rs
+53 -23
View File
@@ -738,11 +738,14 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {
// %AsyncGeneratorPrototype%：proto = Object.prototype，方法 next/return/throw。
let mut ag_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, object_proto_val));
// 站点标签：与 Generator 原型的同名方法槽（next/return/throw）区分复用键。
let ag_label = sf.intern("AsyncGeneratorPrototype").0;
oxide_kernel::bind_methods_static!(
&mut ag_proto,
sf,
sh,
world,
ag_label,
("next", async_generator_next as *const (), 1),
("return", async_generator_return as *const (), 1),
("throw", async_generator_throw as *const (), 1),
@@ -755,7 +758,7 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {
ag_proto.set_data_meta(tag_pos, PropAttributes::new(false, false, true));
// @@asyncIterator：返回自身（异步生成器是异步可迭代对象，供 for-await-of 消费）。
let aiter_key = oxide_types::private_key::make_well_known_symbol_key(8);
let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_static(
let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_labeled_static(
&mut ag_proto,
sh,
sf,
@@ -764,30 +767,43 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {
unsafe { oxide_types::object::NativeFnPtr::from_raw(async_generator_symbol_async_iterator as *const ()) },
0,
world,
ag_label,
);
Vm::swap_intrinsic_proto(&mut vm.async_generator_proto, *ag_proto);
// %AsyncGeneratorFunction.prototype%：proto = Function.prototype，constructor = %AsyncGeneratorFunction%。
let mut agf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
agf_ctor.set_function(true);
agf_ctor.set_native_arg_count(1);
// %AsyncGeneratorFunction% 构造器：动态创建未实现，调用抛 TypeError。
agf_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(async_generator_function_stub as *const ()) }));
// %AsyncGeneratorFunction.prototype%：proto = Function.prototype，
// constructor = %AsyncGeneratorFunction%。占位构造器动态创建未实现，
// 调用抛 TypeError。选择性重建复用：前轮占位构造器按键迁移（prototype
// 槽在下方 P 槽换入后重指新原型），不再每轮新建对象。
let agf_ctor_label = sf.intern("AsyncGeneratorFunctionCtor").0;
let agf_reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, agf_ctor_label, 0, 0);
// SAFETY: async_generator_function_stub 是 NativeFn 函数项。
let agf_stub_ptr = unsafe { NativeFnPtr::from_raw(async_generator_function_stub as *const ()) };
let (agf_ctor_ptr, agf_ctor_is_new) = match world.find_fn_wrapper(agf_reuse_key, agf_stub_ptr, 1) {
Some(ptr) => (ptr, false),
None => {
let mut agf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
agf_ctor.set_function(true);
agf_ctor.set_native_arg_count(1);
agf_ctor.set_native_fn(Some(agf_stub_ptr));
// prototype/name 属性（构造器形状 [prototype, name]）。
let proto_si = sf.intern("prototype").0;
let ctor_shape = sh.make_shape(EMPTY_SHAPE_ID, proto_si);
agf_ctor.set_shape_id(ctor_shape);
let name_si = sf.intern("name").0;
let name_shape = sh.make_shape(agf_ctor.shape_id(), name_si);
agf_ctor.set_shape_id(name_shape);
let agf_ctor_ptr = Box::into_raw(agf_ctor);
// 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
world.track_fn_wrapper(agf_ctor_ptr, agf_reuse_key);
(agf_ctor_ptr, true)
}
};
let mut agf_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
// prototype/name 属性（构造器形状 [prototype, name]）。
let proto_si = sf.intern("prototype").0;
let ctor_shape = sh.make_shape(agf_ctor.shape_id(), proto_si);
agf_ctor.set_shape_id(ctor_shape);
let name_si = sf.intern("name").0;
let name_shape = sh.make_shape(agf_ctor.shape_id(), name_si);
agf_ctor.set_shape_id(name_shape);
// agf_proto.constructor = %AsyncGeneratorFunction%（构造器登记进 world 释放表，与 builtin 方法 wrapper 同生命周期）。
let ctor_si = sf.intern("constructor").0;
let ctor2_shape = sh.make_shape(agf_proto.shape_id(), ctor_si);
agf_proto.set_shape_id(ctor2_shape);
// 登记进释放表：session 收尾统一释放构造器本体与属性区。
let agf_ctor_ptr = Box::into_raw(agf_ctor);
world.track_leaked_object(agf_ctor_ptr);
let cpos = agf_proto.push_prop(JsValue::from_js_object(agf_ctor_ptr));
agf_proto.set_data_meta(cpos, PropAttributes::new(false, false, true));
// agf_proto.prototype = %AsyncGeneratorPrototype%。
@@ -805,15 +821,29 @@ pub(crate) fn init_async_generator_intrinsics(vm: &mut Vm) {
// proto 本体只存在于 P 槽（Arc 副本，原 Box 随函数结束释放）：装入 P 槽后再写
// 构造器 prototype/name 属性（按模板序 prototype 在前），prototype 指向 P 槽实例，
// 使其与动态异步生成器函数使用的 [[Prototype]] 同一对象。
// 使其与动态异步生成器函数使用的 [[Prototype]] 同一对象。复用构造器槽位已填充，
// prototype 原位改指新 P 原型（旧原型已随 P 换出释放）。
Vm::swap_intrinsic_proto(&mut vm.async_generator_function_proto, *agf_proto);
// SAFETY: agf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），对象已建满、本 Vm 独占。
// SAFETY: agf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），本 Vm 独占。
unsafe {
let ctor_mut = &mut *agf_ctor_ptr;
let ppos = ctor_mut.push_prop(JsValue::from_js_object(vm.async_generator_function_proto.as_mut_ptr()));
ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
let npos = ctor_mut.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncGeneratorFunction").0)));
ctor_mut.set_data_meta(npos, PropAttributes::new(false, false, true));
let proto_val = JsValue::from_js_object(vm.async_generator_function_proto.as_ptr() as *mut JsObject);
let name_val = JsValue::perm_string(sf.string_ptr(sf.intern("AsyncGeneratorFunction").0));
if agf_ctor_is_new {
let ppos = ctor_mut.push_prop(proto_val);
ctor_mut.set_data_meta(ppos, PropAttributes::new(false, false, false));
let npos = ctor_mut.push_prop(name_val);
ctor_mut.set_data_meta(npos, PropAttributes::new(false, false, true));
} else {
let si_prototype = sf.intern("prototype").0;
if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_prototype) {
ctor_mut.set_prop_at(pos, proto_val);
}
let si_name = sf.intern("name").0;
if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_name) {
ctor_mut.set_prop_at(pos, name_val);
}
}
}
}
crates/oxide_vm/src/bindings/bind_async_disposable_stack.rs
+49 -28
View File
@@ -2,7 +2,7 @@ use std::sync::Arc;
use oxide_kernel::kernel::{KernelCore, KernelSession};
use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
use oxide_types::object::{JsObject, PropAttributes};
use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
use oxide_types::value::JsValue;
use crate::async_disposable::dispose_async;
@@ -91,35 +91,56 @@ pub fn bind_async_disposable_stack(core: &Arc<KernelCore>, session: &KernelSessi
let ctor_val = if ctor_val.is_object() {
ctor_val
} else {
// Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
let function_proto = world.function_proto.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
ctor.set_function(true);
configure_native_constructor(
&mut ctor,
oxide_builtins::disposable_stack::async_disposable_stack_constructor::<crate::vm::Vm> as *const (),
0,
);
let sf = core.perm_interner().as_ref();
let sh = core.shape_forge().as_ref();
let si_prototype = sf.intern("prototype").0;
let si_name = sf.intern("name").0;
let si_length = sf.intern("length").0;
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
ctor.set_shape_id(ctor_shape3);
ctor.ensure_hash_props()
.push(JsValue::from_js_object(world.async_disposable_stack_proto.as_ptr() as *mut JsObject));
ctor.ensure_hash_props()
.push(JsValue::perm_string(sf.string_ptr(sf.intern("AsyncDisposableStack").0)));
ctor.ensure_hash_props().push(JsValue::int(0));
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
let ctor_ptr = Box::into_raw(ctor);
// 登记进 world 释放表：session 收尾统一释放构造器本体与属性区。
world.track_leaked_object(ctor_ptr);
let name_si = sf.intern("AsyncDisposableStack").0;
// 选择性重建复用：非 P 目标（家族 0）按键查找前轮旧构造器迁移，避免每轮
// 新建导致登记表无界累积；槽键取 global 槽名，该命名空间内全局唯一。
let ctor_fn =
oxide_builtins::disposable_stack::async_disposable_stack_constructor::<crate::vm::Vm> as *const ();
// SAFETY: ctor_fn 是转成 *const () 的 NativeFn 函数项指针。
let ctor_fn_ptr = unsafe { NativeFnPtr::from_raw(ctor_fn) };
let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, 0) {
Some(ptr) => {
// 迁移内引用：prototype 槽改指新 AsyncDisposableStack.prototype
// （旧原型已被重建替换释放）。
let ctor = unsafe { &mut *ptr };
let si_prototype = sf.intern("prototype").0;
if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
ctor.set_prop_at(
pos,
JsValue::from_js_object(world.async_disposable_stack_proto.as_ptr() as *mut JsObject),
);
}
ptr
}
None => {
// Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
let function_proto = world.function_proto.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
ctor.set_function(true);
configure_native_constructor(&mut ctor, ctor_fn, 0);
let si_prototype = sf.intern("prototype").0;
let si_name = sf.intern("name").0;
let si_length = sf.intern("length").0;
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
ctor.set_shape_id(ctor_shape3);
ctor.ensure_hash_props()
.push(JsValue::from_js_object(world.async_disposable_stack_proto.as_ptr() as *mut JsObject));
ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
ctor.ensure_hash_props().push(JsValue::int(0));
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
let ctor_ptr = Box::into_raw(ctor);
// 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
world.track_fn_wrapper(ctor_ptr, reuse_key);
ctor_ptr
}
};
JsValue::from_js_object(ctor_ptr)
};
crates/oxide_vm/src/bindings/bind_disposable_stack.rs
+48 -28
View File
@@ -2,7 +2,7 @@ use std::sync::Arc;
use oxide_kernel::kernel::{KernelCore, KernelSession};
use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
use oxide_types::object::{JsObject, PropAttributes};
use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
use oxide_types::value::JsValue;
use crate::bindings::{
@@ -109,35 +109,55 @@ pub fn bind_disposable_stack(core: &Arc<KernelCore>, session: &KernelSession, gl
let ctor_val = if ctor_val.is_object() {
ctor_val
} else {
// Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
let function_proto = world.function_proto.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
ctor.set_function(true);
configure_native_constructor(
&mut ctor,
oxide_builtins::disposable_stack::disposable_stack_constructor::<crate::vm::Vm> as *const (),
0,
);
let sf = core.perm_interner().as_ref();
let sh = core.shape_forge().as_ref();
let si_prototype = sf.intern("prototype").0;
let si_name = sf.intern("name").0;
let si_length = sf.intern("length").0;
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
ctor.set_shape_id(ctor_shape3);
ctor.ensure_hash_props()
.push(JsValue::from_js_object(world.disposable_stack_proto.as_ptr() as *mut JsObject));
ctor.ensure_hash_props()
.push(JsValue::perm_string(sf.string_ptr(sf.intern("DisposableStack").0)));
ctor.ensure_hash_props().push(JsValue::int(0));
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
let ctor_ptr = Box::into_raw(ctor);
// 登记进 world 释放表：session 收尾统一释放构造器本体与属性区。
world.track_leaked_object(ctor_ptr);
let name_si = sf.intern("DisposableStack").0;
// 选择性重建复用：非 P 目标（家族 0）按键查找前轮旧构造器迁移，避免每轮
// 新建导致登记表无界累积；槽键取 global 槽名，该命名空间内全局唯一。
let ctor_fn = oxide_builtins::disposable_stack::disposable_stack_constructor::<crate::vm::Vm> as *const ();
// SAFETY: ctor_fn 是转成 *const () 的 NativeFn 函数项指针。
let ctor_fn_ptr = unsafe { NativeFnPtr::from_raw(ctor_fn) };
let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, 0) {
Some(ptr) => {
// 迁移内引用：prototype 槽改指新 DisposableStack.prototype
// （旧原型已被重建替换释放）。
let ctor = unsafe { &mut *ptr };
let si_prototype = sf.intern("prototype").0;
if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
ctor.set_prop_at(
pos,
JsValue::from_js_object(world.disposable_stack_proto.as_ptr() as *mut JsObject),
);
}
ptr
}
None => {
// Box 自建：[[Prototype]] 指向 Function.prototype，prototype/name 描述符按规范。
let function_proto = world.function_proto.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto)));
ctor.set_function(true);
configure_native_constructor(&mut ctor, ctor_fn, 0);
let si_prototype = sf.intern("prototype").0;
let si_name = sf.intern("name").0;
let si_length = sf.intern("length").0;
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
ctor.set_shape_id(ctor_shape3);
ctor.ensure_hash_props()
.push(JsValue::from_js_object(world.disposable_stack_proto.as_ptr() as *mut JsObject));
ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
ctor.ensure_hash_props().push(JsValue::int(0));
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
let ctor_ptr = Box::into_raw(ctor);
// 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
world.track_fn_wrapper(ctor_ptr, reuse_key);
ctor_ptr
}
};
JsValue::from_js_object(ctor_ptr)
};
crates/oxide_vm/src/bindings/bind_error.rs
+86 -50
View File
@@ -12,55 +12,86 @@ fn bind_error_subtype_constructor(
) {
let sf = core.perm_interner().as_ref();
let sh = core.shape_forge().as_ref();
// 子类型构造器 [[Prototype]] 指向 Error 构造器（规范：NativeError 构造器继承 Error
// 构造器，而非直接继承 Function.prototype；instanceof 走 @@hasInstance 不受影响）。
let error_ctor_ptr = session.builtin_world().error_constructor.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
ctor.set_function(true);
// Error 子类型须标记可构造：new TypeError(...) 走 NEW_EXPRESSION 校验。
ctor.type_tag = JsObject::OBJ_TYPE_CONSTRUCTOR;
// SAFETY: ctor_fn 是调用方转成 *const () 的 NativeFn 函数项指针。
ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(ctor_fn) }));
ctor.set_native_arg_count(arg_count);
let si_prototype = sf.intern("prototype").0;
let si_name = sf.intern("name").0;
let si_length = sf.intern("length").0;
let world = session.builtin_world();
let name_si = sf.intern(name).0;
// SAFETY: ctor_fn 是调用方转成 *const () 的 NativeFn 函数项指针。
let ctor_fn_ptr = unsafe { NativeFnPtr::from_raw(ctor_fn) };
// 选择性重建复用：非 P 目标（家族 0）按键查找前轮旧构造器迁移，避免每轮
// 新建导致登记表无界累积；槽键取 global 槽名，该命名空间内全局唯一。
let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
let si_prototype = sf.intern("prototype").0;
let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, arg_count) {
Some(ptr) => {
// 迁移内引用：prototype 槽改指新子类型原型（旧原型已被重建替换释放）。
let ctor = unsafe { &mut *ptr };
if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
ctor.set_prop_at(pos, JsValue::from_js_object(proto_ptr));
}
ptr
}
None => {
// 子类型构造器 [[Prototype]] 指向 Error 构造器（规范：NativeError
// 构造器继承 Error 构造器，而非直接继承 Function.prototype；instanceof
// 走 @@hasInstance 不受影响）。
let error_ctor_ptr = world.error_constructor.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
ctor.set_function(true);
// Error 子类型须标记可构造：new TypeError(...) 走 NEW_EXPRESSION 校验。
ctor.type_tag = JsObject::OBJ_TYPE_CONSTRUCTOR;
ctor.set_native_fn(Some(ctor_fn_ptr));
ctor.set_native_arg_count(arg_count);
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
ctor.set_shape_id(ctor_shape3);
ctor.ensure_hash_props().push(JsValue::from_js_object(proto_ptr));
ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
ctor.ensure_hash_props().push(JsValue::int(arg_count as i32));
// 构造器 prototype 槽按规范 { writable:false, enumerable:false, configurable:false }。
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
// 构造器 name 槽按规范 { writable:false, enumerable:false, configurable:true }。
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
// 构造器 length 按规范为不可写不可枚举（Function.length 属性描述符约定）。
ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
let si_name = sf.intern("name").0;
let si_length = sf.intern("length").0;
let ctor_ptr = Box::into_raw(ctor);
// 登记进 world 释放表：session 收尾统一释放构造器本体与属性区。
session.builtin_world().track_leaked_object(ctor_ptr);
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
let ctor_shape3 = sh.make_shape(ctor_shape2, si_length);
ctor.set_shape_id(ctor_shape3);
ctor.ensure_hash_props().push(JsValue::from_js_object(proto_ptr));
ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
ctor.ensure_hash_props().push(JsValue::int(arg_count as i32));
// 构造器 prototype 槽按规范 { writable:false, enumerable:false, configurable:false }。
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
// 构造器 name 槽按规范 { writable:false, enumerable:false, configurable:true }。
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
// 构造器 length 按规范为不可写不可枚举（Function.length 属性描述符约定）。
ctor.set_data_meta(2u32, PropAttributes::new(false, false, true));
let ctor_ptr = Box::into_raw(ctor);
// 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
world.track_fn_wrapper(ctor_ptr, reuse_key);
ctor_ptr
}
};
let ctor_val = JsValue::from_js_object(ctor_ptr);
// 原型上的 constructor 既有槽原位更新，无槽时开新槽（重建原型无既有槽）；
// 非枚举数据属性（与 Error.prototype.constructor 一致）。
let proto = unsafe { &mut *proto_ptr };
let proto_ctor_shape = sh.make_shape(proto.shape_id(), sf.intern("constructor").0);
proto.set_shape_id(proto_ctor_shape);
proto.ensure_hash_props().push(JsValue::from_js_object(ctor_ptr));
// 原型上的 constructor 按规范为非枚举数据属性（与 Error.prototype.constructor 一致）。
let ctor_pos = proto.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
proto.set_data_meta(ctor_pos, PropAttributes::new(true, false, true));
let si_constructor = sf.intern("constructor").0;
if let Some(pos) = sh.lookup_position(proto.shape_id(), si_constructor) {
proto.set_prop_at(pos, ctor_val);
} else {
let proto_ctor_shape = sh.make_shape(proto.shape_id(), si_constructor);
proto.set_shape_id(proto_ctor_shape);
proto.ensure_hash_props().push(ctor_val);
let ctor_pos = proto.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
proto.set_data_meta(ctor_pos, PropAttributes::new(true, false, true));
}
let global_shape = sh.make_shape(global.shape_id(), name_si);
global.set_shape_id(global_shape);
global.ensure_hash_props().push(JsValue::from_js_object(ctor_ptr));
// 全局子类型构造器槽位非枚举（规范全局构造器描述符约定）。
let global_pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(global_pos, PropAttributes::new(true, false, true));
global.bump_generation();
// 全局子类型构造器槽位既有槽原位更新（旧家族构造器指针不得滞留在属性 vec），
// 无槽时开新槽；描述符非枚举（规范全局构造器描述符约定）。
if let Some(pos) = sh.lookup_position(global.shape_id(), name_si) {
global.set_prop_at(pos, ctor_val);
} else {
let global_shape = sh.make_shape(global.shape_id(), name_si);
global.set_shape_id(global_shape);
global.ensure_hash_props().push(ctor_val);
let global_pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(global_pos, PropAttributes::new(true, false, true));
global.bump_generation();
}
}
/// 把 Error 及各子类型（TypeError/ReferenceError/...）构造器与原型方法绑定到 global。
@@ -83,15 +114,20 @@ pub fn bind_error(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
core.shape_forge().as_ref(),
);
// 全局 Error 槽位既有槽原位更新（旧家族构造器指针不得滞留在属性 vec），
// 无槽时开新槽；描述符非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
let si_err = core.perm_interner().intern("Error").0;
let err_shape = core.shape_forge().make_shape(global.shape_id(), si_err);
let err_val = JsValue::from_js_object(session.builtin_world().error_constructor.as_ptr() as *mut JsObject);
global.set_shape_id(err_shape);
global.ensure_hash_props().push(err_val);
// 全局 Error 构造器槽位非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
let err_pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(err_pos, PropAttributes::new(true, false, true));
global.bump_generation();
if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si_err) {
global.set_prop_at(pos, err_val);
} else {
let err_shape = core.shape_forge().make_shape(global.shape_id(), si_err);
global.set_shape_id(err_shape);
global.ensure_hash_props().push(err_val);
let err_pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(err_pos, PropAttributes::new(true, false, true));
global.bump_generation();
}
bind_error_subtype_constructor(
core,
crates/oxide_vm/src/bindings/bind_math.rs
+12 -7
View File
@@ -77,13 +77,18 @@ pub fn bind_math(core: &Arc<KernelCore>, session: &KernelSession, global: &mut J
math.set_data_meta(pos, PropAttributes::new(false, false, false));
}
// 全局 Math 槽位既有槽原位更新（旧对象指针不得滞留在属性 vec），无槽时
// 开新槽；描述符非枚举（规范全局命名空间对象属性均 enumerable:false）。
let si_m = core.perm_interner().intern("Math").0;
let m_shape = core.shape_forge().make_shape(global.shape_id(), si_m);
let m_val = JsValue::from_js_object(session.builtin_world().math_object.as_ptr() as *mut JsObject);
global.set_shape_id(m_shape);
global.ensure_hash_props().push(m_val);
// 全局 Math 槽位非枚举（规范全局命名空间对象属性均 enumerable:false）。
let pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(pos, PropAttributes::new(true, false, true));
global.bump_generation();
if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si_m) {
global.set_prop_at(pos, m_val);
} else {
let m_shape = core.shape_forge().make_shape(global.shape_id(), si_m);
global.set_shape_id(m_shape);
global.ensure_hash_props().push(m_val);
let pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(pos, PropAttributes::new(true, false, true));
global.bump_generation();
}
}
crates/oxide_vm/src/bindings/bind_string.rs
+12 -7
View File
@@ -73,13 +73,18 @@ pub fn bind_string(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
0,
);
// 全局 String 槽位既有槽原位更新（旧家族构造器指针不得滞留在属性 vec），
// 无槽时开新槽；描述符非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
let si_str = core.perm_interner().intern("String").0;
let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str);
let str_val = JsValue::from_js_object(session.builtin_world().string_constructor.as_ptr() as *mut JsObject);
global.set_shape_id(str_shape);
global.ensure_hash_props().push(str_val);
// 全局构造器槽位非枚举（规范 { writable:true, enumerable:false, configurable:true }）。
let pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(pos, PropAttributes::new(true, false, true));
global.bump_generation();
if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si_str) {
global.set_prop_at(pos, str_val);
} else {
let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str);
global.set_shape_id(str_shape);
global.ensure_hash_props().push(str_val);
let pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(pos, PropAttributes::new(true, false, true));
global.bump_generation();
}
}
crates/oxide_vm/src/bindings/mod.rs
+143 -100
View File
@@ -71,19 +71,26 @@ macro_rules! bind_constructor {
}};
($core:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal, hash: $hash:literal) => {{
let si = $core.perm_interner().intern($name).0;
let shape = $core.shape_forge().make_shape($global.shape_id(), si);
let val = $crate::JsValue::from_js_object($ctor_ptr);
$global.set_shape_id(shape);
if $hash {
$global.ensure_hash_props().push(val);
$global.bump_generation();
if let Some(pos) = $core.shape_forge().lookup_position($global.shape_id(), si) {
// 既有槽（重建后保留的 global）：原位更新槽值，不追加新槽——旧家族
// 构造器指针不得滞留属性 vec，shape 链不得继续增长。
$global.set_prop_at(pos, val);
} else {
$global.push_prop(val);
let shape = $core.shape_forge().make_shape($global.shape_id(), si);
$global.set_shape_id(shape);
if $hash {
$global.ensure_hash_props().push(val);
} else {
$global.push_prop(val);
}
// 全局构造器槽位：规范描述符 { writable:true, enumerable:false,
// configurable:true }，不设 meta 时默认全枚举会泄漏进
// Object.keys(globalThis) / for-in。
let global_pos = $global.prop_vec_len().saturating_sub(1) as u32;
$global.set_data_meta(global_pos, oxide_types::object::PropAttributes::new(true, false, true));
$global.bump_generation();
}
// 全局构造器槽位：规范描述符 { writable:true, enumerable:false, configurable:true }，
// 不设 meta 时默认全枚举会泄漏进 Object.keys(globalThis) / for-in。
let global_pos = $global.prop_vec_len().saturating_sub(1) as u32;
$global.set_data_meta(global_pos, oxide_types::object::PropAttributes::new(true, false, true));
let ctor = unsafe { &mut *$ctor_ptr };
let ptr: *const () = ($ctor_fn as fn(&mut $crate::vm::Vm, &[u8]) -> oxide_runtime_api::NativeResult) as *const ();
ctor.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(ptr) }));
@@ -137,36 +144,48 @@ pub(crate) fn bind_accessor_getter(
let shape_forge = core.shape_forge().as_ref();
let string_forge = core.perm_interner().as_ref();
let world = session.builtin_world();
let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
let getter_name = format!("get {name}");
let mut getter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
getter.set_function(true);
// SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。
getter.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) }));
getter.set_native_arg_count(0);
let si_name = string_forge.intern("name").0;
let name_shape = shape_forge.make_shape(getter.shape_id(), si_name);
getter.set_shape_id(name_shape);
getter
.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(&getter_name).0)));
let name_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
getter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
let si_length = string_forge.intern("length").0;
let length_shape = shape_forge.make_shape(getter.shape_id(), si_length);
getter.set_shape_id(length_shape);
getter.ensure_hash_props().push(JsValue::int(0));
let length_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
getter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
let getter_ptr = Box::into_raw(getter);
world.track_leaked_object(getter_ptr);
let getter_val = JsValue::from_js_object(getter_ptr);
let si = string_forge.intern(name).0;
let getter_name = format!("get {name}");
let si_label = string_forge.intern(&getter_name).0;
// SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。
let getter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) };
// 选择性重建复用：同家族同槽旧 getter 迁移到新 proto 的访问器槽（proto
// 槽已由重建收尾重指），不再新建对象。
let reuse_key =
oxide_kernel::builtin::FnWrapperKey::new(world.wrapper_family_of(proto as *const JsObject), 0, si, si_label);
let getter_ptr = match world.find_fn_wrapper(reuse_key, getter_fn_ptr, 0) {
Some(ptr) => ptr,
None => {
let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
let mut getter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
getter.set_function(true);
getter.set_native_fn(Some(getter_fn_ptr));
getter.set_native_arg_count(0);
let si_name = string_forge.intern("name").0;
let name_shape = shape_forge.make_shape(getter.shape_id(), si_name);
getter.set_shape_id(name_shape);
getter
.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(si_label)));
let name_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
getter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
let si_length = string_forge.intern("length").0;
let length_shape = shape_forge.make_shape(getter.shape_id(), si_length);
getter.set_shape_id(length_shape);
getter.ensure_hash_props().push(JsValue::int(0));
let length_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
getter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
let getter_ptr = Box::into_raw(getter);
world.track_fn_wrapper(getter_ptr, reuse_key);
getter_ptr
}
};
let getter_val = JsValue::from_js_object(getter_ptr);
let new_shape = shape_forge.make_shape(proto.shape_id(), si);
proto.set_shape_id(new_shape);
let pos = proto.push_prop(JsValue::undefined());
@@ -193,51 +212,50 @@ pub(crate) fn bind_accessor_getset(
let shape_forge = core.shape_forge().as_ref();
let string_forge = core.perm_interner().as_ref();
let world = session.builtin_world();
let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
let mut getter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
getter.set_function(true);
// SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。
getter.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) }));
getter.set_native_arg_count(0);
// 给函数对象开 name/length 槽位（描述符均 { writable:false, enumerable:false, configurable:true }）。
let si_name = string_forge.intern("name").0;
let name_shape = shape_forge.make_shape(getter.shape_id(), si_name);
getter.set_shape_id(name_shape);
getter
.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(getter_name).0)));
let name_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
getter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
let family = world.wrapper_family_of(proto as *const JsObject);
let si_length = string_forge.intern("length").0;
let length_shape = shape_forge.make_shape(getter.shape_id(), si_length);
getter.set_shape_id(length_shape);
getter.ensure_hash_props().push(JsValue::int(0));
let length_pos = getter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
getter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
let getter_ptr = Box::into_raw(getter);
world.track_leaked_object(getter_ptr);
let getter_val = JsValue::from_js_object(getter_ptr);
let si_name = string_forge.intern("name").0;
let mut setter = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
setter.set_function(true);
// SAFETY: setter_fn 是转成 *const () 的 NativeFn 函数项指针。
setter.set_native_fn(Some(unsafe { oxide_types::object::NativeFnPtr::from_raw(setter_fn) }));
setter.set_native_arg_count(1);
let name_shape = shape_forge.make_shape(setter.shape_id(), si_name);
setter.set_shape_id(name_shape);
setter
.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(string_forge.intern(setter_name).0)));
let name_pos = setter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
setter.set_data_meta(name_pos, PropAttributes::new(false, false, true));
let length_shape = shape_forge.make_shape(setter.shape_id(), si_length);
setter.set_shape_id(length_shape);
setter.ensure_hash_props().push(JsValue::int(1));
let length_pos = setter.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
setter.set_data_meta(length_pos, PropAttributes::new(false, false, true));
let setter_ptr = Box::into_raw(setter);
world.track_leaked_object(setter_ptr);
// 选择性重建复用：同家族同槽旧 getter/setter 迁移到新 proto 的访问器槽
// （proto 槽已由重建收尾重指），不再新建对象。
let build = |si_label: u32,
fn_ptr_native: oxide_types::object::NativeFnPtr,
arg_count: u8,
length_val: i32|
-> *mut JsObject {
let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(family, 0, key, si_label);
if let Some(ptr) = world.find_fn_wrapper(reuse_key, fn_ptr_native, arg_count) {
return ptr;
}
let fn_proto_val = JsValue::from_js_object(world.function_proto.as_ptr() as *mut JsObject);
let mut func = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
func.set_function(true);
func.set_native_fn(Some(fn_ptr_native));
func.set_native_arg_count(arg_count);
// 给函数对象开 name/length 槽位（描述符均 { writable:false, enumerable:false, configurable:true }）。
let name_shape = shape_forge.make_shape(func.shape_id(), si_name);
func.set_shape_id(name_shape);
func.ensure_hash_props()
.push(JsValue::perm_string(string_forge.string_ptr(si_label)));
let name_pos = func.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
func.set_data_meta(name_pos, PropAttributes::new(false, false, true));
let length_shape = shape_forge.make_shape(func.shape_id(), si_length);
func.set_shape_id(length_shape);
func.ensure_hash_props().push(JsValue::int(length_val));
let length_pos = func.hash_props_vec().map_or(0, |v| v.len() as u32).saturating_sub(1);
func.set_data_meta(length_pos, PropAttributes::new(false, false, true));
let func_ptr = Box::into_raw(func);
world.track_fn_wrapper(func_ptr, reuse_key);
func_ptr
};
// SAFETY: getter_fn / setter_fn 是转成 *const () 的 NativeFn 函数项指针。
let getter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) };
let setter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(setter_fn) };
let si_getter = string_forge.intern(getter_name).0;
let si_setter = string_forge.intern(setter_name).0;
let getter_ptr = build(si_getter, getter_fn_ptr, 0, 0);
let setter_ptr = build(si_setter, setter_fn_ptr, 1, 1);
let getter_val = JsValue::from_js_object(getter_ptr);
let setter_val = JsValue::from_js_object(setter_ptr);
// 访问器属性槽：enumerable=false、configurable=true（get/set 函数对象已持有）。
@@ -573,13 +591,20 @@ fn sync_iterator_function_prototype(core: &Arc<KernelCore>, session: &KernelSess
iterator.set_prop_at(proto_pos, new_proto);
}
/// 在目标对象（global 或命名空间对象）上绑定一个具名槽：既有槽（选择性
/// 重建后保留的目标）原位更新槽值，无槽时开新槽。内置全局值统一非枚举：
/// 描述符 { writable:true, enumerable:false, configurable:true }，与构造器/
/// 命名空间对象（Math/JSON/Reflect/Temporal 等）规范一致。
pub(crate) fn bind_global_value(core: &Arc<KernelCore>, global: &mut JsObject, name: &str, value: JsValue) {
let si = core.perm_interner().intern(name).0;
if let Some(pos) = core.shape_forge().lookup_position(global.shape_id(), si) {
// 原位更新：旧对象指针不得滞留在属性 vec，shape 链不得继续增长。
global.set_prop_at(pos, value);
return;
}
let shape = core.shape_forge().make_shape(global.shape_id(), si);
global.set_shape_id(shape);
global.ensure_hash_props().push(value);
// 内置全局值统一非枚举：描述符 { writable:true, enumerable:false, configurable:true }，
// 与构造器/命名空间对象（Math/JSON/Reflect/Temporal 等）规范一致。
let pos = global.prop_vec_len().saturating_sub(1) as u32;
global.set_data_meta(pos, PropAttributes::new(true, false, true));
global.bump_generation();
@@ -604,28 +629,46 @@ fn bind_error_subtype_global(
// fallback 自建路径与 bind_error 的 Box 自建路径保持同一形态：[[Prototype]] 指向
// Error 构造器（NativeError 构造器继承 Error 构造器），prototype/name 描述符按规范。
let error_ctor_ptr = session.builtin_world().error_constructor.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
ctor.set_function(true);
configure_native_constructor(&mut ctor, ctor_fn, arg_count);
// 家族重建后新原型无既有槽：按复用键查找前轮旧构造器迁移，避免每轮新建。
let world = session.builtin_world();
let sf = core.perm_interner().as_ref();
let sh = core.shape_forge().as_ref();
let si_prototype = sf.intern("prototype").0;
let si_name = sf.intern("name").0;
let name_si = sf.intern(name).0;
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
ctor.set_shape_id(ctor_shape2);
ctor.ensure_hash_props()
.push(JsValue::from_js_object(proto.as_ptr() as *mut JsObject));
ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
// prototype/name 描述符与 Box 自建路径一致：{f,f,f} / {f,f,t}。
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
// SAFETY: ctor_fn 是转成 *const () 的 NativeFn 函数项指针。
let ctor_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(ctor_fn) };
let reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, 0, name_si, name_si);
let ctor_ptr = match world.find_fn_wrapper(reuse_key, ctor_fn_ptr, arg_count) {
Some(ptr) => {
// 迁移内引用：prototype 槽改指新子类型原型（旧原型已被重建替换）。
let ctor = unsafe { &mut *ptr };
if let Some(pos) = sh.lookup_position(ctor.shape_id(), si_prototype) {
ctor.set_prop_at(pos, JsValue::from_js_object(proto.as_ptr() as *mut JsObject));
}
ptr
}
None => {
let error_ctor_ptr = world.error_constructor.as_ptr() as *mut JsObject;
let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_ctor_ptr)));
ctor.set_function(true);
configure_native_constructor(&mut ctor, ctor_fn, arg_count);
let ctor_ptr = Box::into_raw(ctor);
session.builtin_world().track_leaked_object(ctor_ptr);
let si_name = sf.intern("name").0;
let ctor_shape1 = sh.make_shape(EMPTY_SHAPE_ID, si_prototype);
let ctor_shape2 = sh.make_shape(ctor_shape1, si_name);
ctor.set_shape_id(ctor_shape2);
ctor.ensure_hash_props()
.push(JsValue::from_js_object(proto.as_ptr() as *mut JsObject));
ctor.ensure_hash_props().push(JsValue::perm_string(sf.string_ptr(name_si)));
// prototype/name 描述符与 Box 自建路径一致：{f,f,f} / {f,f,t}。
ctor.set_data_meta(0u32, PropAttributes::new(false, false, false));
ctor.set_data_meta(1u32, PropAttributes::new(false, false, true));
let ctor_ptr = Box::into_raw(ctor);
world.track_fn_wrapper(ctor_ptr, reuse_key);
ctor_ptr
}
};
bind_existing_global(core, global, name, JsValue::from_js_object(ctor_ptr));
}
crates/oxide_vm/src/generator.rs
+52 -22
View File
@@ -733,11 +733,14 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
let iterator_proto_val =
JsValue::from_js_object(vm.session.builtin_world().iterator_proto.as_ptr() as *mut JsObject);
let mut gen_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, iterator_proto_val));
// 站点标签：与 AsyncGenerator 原型的同名方法槽（next/return/throw）区分复用键。
let gen_label = sf.intern("GeneratorPrototype").0;
oxide_kernel::bind_methods_static!(
&mut gen_proto,
sf,
sh,
world,
gen_label,
("next", generator_next as *const (), 1),
("return", generator_return as *const (), 1),
("throw", generator_throw as *const (), 1),
@@ -750,7 +753,7 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
gen_proto.set_data_meta(tag_pos, oxide_types::object::PropAttributes::new(false, false, true));
// @@iterator：返回自身（生成器是可迭代对象）。
let iter_key = oxide_types::private_key::make_well_known_symbol_key(0);
let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_static(
let _ = oxide_kernel::builtin::BuiltinWorld::bind_method_key_labeled_static(
&mut gen_proto,
sh,
sf,
@@ -759,30 +762,43 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
unsafe { oxide_types::object::NativeFnPtr::from_raw(generator_symbol_iterator as *const ()) },
0,
world,
gen_label,
);
Vm::swap_intrinsic_proto(&mut vm.generator_proto, *gen_proto);
// %GeneratorFunction.prototype%：proto = Function.prototype，constructor = %GeneratorFunction%。
let mut gf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
gf_ctor.set_function(true);
gf_ctor.set_native_arg_count(1);
let mut gf_proto = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
// %GeneratorFunction% 构造器：动态生成器函数创建未实现，调用抛 TypeError。
gf_ctor.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(generator_function_stub as *const ()) }));
// prototype/name 属性（构造器形状 [prototype, name]）。
let proto_si = sf.intern("prototype").0;
let ctor_shape = sh.make_shape(gf_ctor.shape_id(), proto_si);
gf_ctor.set_shape_id(ctor_shape);
let name_si = sf.intern("name").0;
let name_shape = sh.make_shape(gf_ctor.shape_id(), name_si);
gf_ctor.set_shape_id(name_shape);
// %GeneratorFunction% 占位构造器：动态生成器函数创建未实现，调用抛
// TypeError。选择性重建复用：前轮占位构造器按键迁移（prototype 槽在
// 下方 P 槽换入后重指新原型），不再每轮新建对象。
let gf_ctor_label = sf.intern("GeneratorFunctionCtor").0;
let gf_reuse_key = oxide_kernel::builtin::FnWrapperKey::new(0, gf_ctor_label, 0, 0);
// SAFETY: generator_function_stub 是 NativeFn 函数项。
let gf_stub_ptr = unsafe { NativeFnPtr::from_raw(generator_function_stub as *const ()) };
let (gf_ctor_ptr, gf_ctor_is_new) = match world.find_fn_wrapper(gf_reuse_key, gf_stub_ptr, 1) {
Some(ptr) => (ptr, false),
None => {
let mut gf_ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, fn_proto_val));
gf_ctor.set_function(true);
gf_ctor.set_native_arg_count(1);
gf_ctor.set_native_fn(Some(gf_stub_ptr));
// prototype/name 属性（构造器形状 [prototype, name]）。
let proto_si = sf.intern("prototype").0;
let ctor_shape = sh.make_shape(EMPTY_SHAPE_ID, proto_si);
gf_ctor.set_shape_id(ctor_shape);
let name_si = sf.intern("name").0;
let name_shape = sh.make_shape(gf_ctor.shape_id(), name_si);
gf_ctor.set_shape_id(name_shape);
let gf_ctor_ptr = Box::into_raw(gf_ctor);
// 登记进 world 释放表（带复用键）：session 收尾统一释放构造器本体与属性区。
world.track_fn_wrapper(gf_ctor_ptr, gf_reuse_key);
(gf_ctor_ptr, true)
}
};
// gf_proto.constructor = gf_ctor（构造器登记进 world 释放表，与 builtin 方法 wrapper 同生命周期）。
let ctor_si = sf.intern("constructor").0;
let ctor2_shape = sh.make_shape(gf_proto.shape_id(), ctor_si);
gf_proto.set_shape_id(ctor2_shape);
// 登记进释放表：session 收尾统一释放构造器本体与属性区。
let gf_ctor_ptr = Box::into_raw(gf_ctor);
world.track_leaked_object(gf_ctor_ptr);
let cpos = gf_proto.push_prop(JsValue::from_js_object(gf_ctor_ptr));
gf_proto.set_data_meta(cpos, oxide_types::object::PropAttributes::new(false, false, true));
// gf_proto.prototype = %GeneratorPrototype%（默认原型，default-proto 测试读取）。
@@ -800,15 +816,29 @@ pub(crate) fn init_generator_intrinsics(vm: &mut Vm) {
// proto 本体只存在于 P 槽（Arc 副本，原 Box 随函数结束释放）：装入 P 槽后再写
// 构造器 prototype/name 属性（按模板序 prototype 在前），prototype 指向 P 槽实例，
// 使其与动态生成器函数使用的 [[Prototype]] 同一对象。
// 使其与动态生成器函数使用的 [[Prototype]] 同一对象。复用构造器槽位已填充，
// prototype 原位改指新 P 原型（旧原型已随 P 换出释放）。
Vm::swap_intrinsic_proto(&mut vm.generator_function_proto, *gf_proto);
// SAFETY: gf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），对象已建满、本 Vm 独占。
// SAFETY: gf_ctor_ptr 为 Box 原分配（已登记释放表、生命周期覆盖 session），本 Vm 独占。
unsafe {
let ctor_mut = &mut *gf_ctor_ptr;
let ppos = ctor_mut.push_prop(JsValue::from_js_object(vm.generator_function_proto.as_mut_ptr()));
ctor_mut.set_data_meta(ppos, oxide_types::object::PropAttributes::new(false, false, false));
let npos = ctor_mut.push_prop(JsValue::perm_string(sf.string_ptr(sf.intern("GeneratorFunction").0)));
ctor_mut.set_data_meta(npos, oxide_types::object::PropAttributes::new(false, false, true));
let proto_val = JsValue::from_js_object(vm.generator_function_proto.as_ptr() as *mut JsObject);
let name_val = JsValue::perm_string(sf.string_ptr(sf.intern("GeneratorFunction").0));
if gf_ctor_is_new {
let ppos = ctor_mut.push_prop(proto_val);
ctor_mut.set_data_meta(ppos, oxide_types::object::PropAttributes::new(false, false, false));
let npos = ctor_mut.push_prop(name_val);
ctor_mut.set_data_meta(npos, oxide_types::object::PropAttributes::new(false, false, true));
} else {
let si_prototype = sf.intern("prototype").0;
if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_prototype) {
ctor_mut.set_prop_at(pos, proto_val);
}
let si_name = sf.intern("name").0;
if let Some(pos) = sh.lookup_position(ctor_mut.shape_id(), si_name) {
ctor_mut.set_prop_at(pos, name_val);
}
}
}
}
crates/oxide_vm/src/vm_support.rs
+87
View File
@@ -827,6 +827,93 @@ mod tests {
assert!(!vm.session.is_dirty_since_snapshot());
}
/// P 原型上方法槽的 wrapper 对象原始指针（rebuild 跨轮复用验证用）。
fn method_wrapper_ptr(vm: &Vm, proto_ptr: *const JsObject, name: &str) -> *const JsObject {
let si = vm.kernel_core.perm_interner().intern(name).0;
// SAFETY: proto_ptr 是本 session 的 P 原型，安全点内无并发读者。
let proto = unsafe { &*proto_ptr };
let pos = vm
.kernel_core
.shape_forge()
.lookup_position(proto.shape_id(), si)
.unwrap_or_else(|| panic!("{name} 槽位应存在"));
let val = proto.get_prop_at(pos);
assert!(val.is_object(), "{name} 槽位应为 wrapper 对象: {val:?}");
val.as_js_object_ptr()
}
/// global 属性槽数（槽位原位更新跨轮不追加验证用）。
fn global_slot_count(vm: &Vm) -> usize {
let g = vm.session.global_object.as_ptr() as *mut JsObject;
// SAFETY: global 是本 session 对象，安全点内无并发读者。
unsafe { (*g).prop_vec_len() }
}
/// 选择性重建 wrapper 复用与 global 槽原位更新：每轮「原型脏写 + full_reset」
/// 后存活方法 wrapper 应为同一对象（同 raw 指针、同 shape），释放表计数与
/// global 属性槽数跨轮不增长，重建后方法行为正确。
#[test]
fn full_reset_rebuild_reuses_method_wrappers_across_rounds() {
let mut vm = Vm::new();
let _ = run_source(&mut vm, "0");
let push_before = method_wrapper_ptr(&vm, vm.session.builtin_world().array_proto.as_ptr(), "push");
let push_shape_before = unsafe { &*push_before }.shape_id();
let registry_before = vm.session.builtin_world().leaked_object_count();
let slots_before = global_slot_count(&vm);
for i in 0..3u32 {
// 新键写才 bump 原型世代；四家族逐轮全脏，function 家族重建同时
// 覆盖 wrapper proto 槽重指路径。
let source = format!(
"Object.prototype['w{i}'] = 1; Array.prototype['w{i}'] = 2; String.prototype['w{i}'] = 3; \
Function.prototype['w{i}'] = 4; 0"
);
let _ = run_source(&mut vm, &source);
vm.full_reset();
}
let push_after = method_wrapper_ptr(&vm, vm.session.builtin_world().array_proto.as_ptr(), "push");
assert!(std::ptr::eq(push_before, push_after), "存活方法 wrapper 应复用（同 raw 指针）");
assert_eq!(push_shape_before, unsafe { &*push_after }.shape_id(), "wrapper shape 应稳定");
let registry_after = vm.session.builtin_world().leaked_object_count();
assert!(
registry_after <= registry_before,
"释放表计数跨轮不应增长: {registry_before} -> {registry_after}"
);
let slots_after = global_slot_count(&vm);
assert!(slots_after <= slots_before, "global 槽数跨轮不应增长: {slots_before} -> {slots_after}");
assert_eq!(run_source(&mut vm, "[1, 2].push(3)"), JsValue::int(3));
assert_eq!(run_source(&mut vm, "String.prototype.charCodeAt.call('A', 0)"), JsValue::int(65));
}
/// global 槽位原位更新锚点：错误/资源栈家族脏重建（子类型构造器经 Box 自建
/// 路径）多轮后 global 属性槽数不增长、Error 槽指向新构造器。
#[test]
fn full_reset_rebuild_keeps_global_slot_count_flat() {
let mut vm = Vm::new();
let _ = run_source(&mut vm, "0");
let slots_before = global_slot_count(&vm);
for i in 0..3u32 {
// 新键写脏错误家族（子类型原型重建触发构造器 Box 路径）与对象家族。
let source = format!(
"Error.prototype['e{i}'] = 1; TypeError.prototype['e{i}'] = 2; Object.prototype['e{i}'] = 3; 0"
);
let _ = run_source(&mut vm, &source);
vm.full_reset();
}
let slots_after = global_slot_count(&vm);
assert!(slots_after <= slots_before, "global 槽数跨轮不应增长: {slots_before} -> {slots_after}");
// Error 槽应指向本轮重建的构造器（非滞留旧指针）。
assert!(std::ptr::eq(
global_prop(&vm, "Error").as_js_object_ptr(),
vm.session.builtin_world().error_constructor.as_ptr() as *mut JsObject
));
assert!(global_prop(&vm, "TypeError").is_object());
assert_eq!(run_source(&mut vm, "new TypeError('x') instanceof TypeError"), JsValue::bool(true));
}
fn vm_with_low_threshold() -> Vm {
let mut cfg = KernelConfig::minimal();
cfg.set_session_gc_threshold(1);