From 2d4c0745309dc4973b5f741672284b97d17785e5 Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Mon, 17 Aug 2026 00:14:47 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20eval=20=E8=84=9A=E6=9C=AC=E6=A8=A1?= =?UTF-8?q?=E5=BC=8F=E4=BF=9D=E7=95=99=E5=AE=8C=E6=88=90=E5=80=BC=E4=B8=8E?= =?UTF-8?q?=E5=85=A8=E5=B1=80=20var=EF=BC=88create=5Fdynamic=5Fscript?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_builtins/src/eval.rs | 13 ++--- crates/oxide_runtime_api/src/lib.rs | 3 + crates/oxide_vm/src/vm.rs | 34 ++++++++++++ crates/oxide_vm/tests/eval_tests.rs | 86 ++++++++++++++++++++++++++--- 4 files changed, 122 insertions(+), 14 deletions(-) diff --git a/crates/oxide_builtins/src/eval.rs b/crates/oxide_builtins/src/eval.rs index fc5e1299..62e3c46a 100644 --- a/crates/oxide_builtins/src/eval.rs +++ b/crates/oxide_builtins/src/eval.rs @@ -1,10 +1,10 @@ -//! eval 全局函数：非字符串原样返回；字符串按脚本/表达式动态编译执行。 +//! eval 全局函数：非字符串原样返回；字符串按脚本模式动态编译执行。 //! //! # 契约 //! - 非字符串实参**不** ToString（`eval(new String("1+1"))` 返回对象本身）。 //! - 字符串经动态编译以 global 为 this 同步调用；编译失败 → SyntaxError； //! 运行异常 → 优先重抛原始异常值（`take_uncaught_value`，`eval("throw 1")` 捕获到 `1`）。 -//! - 档 1 函数模式：eval 内 var 不落全局；档 2 切 `create_dynamic_script` 后 var 落全局。 +//! - 脚本模式：完成值保留（`eval("1+2")` → 3）；var/函数声明落全局对象；let/const 词法隔离。 use oxide_runtime_api::{NativeResult, VmHost}; use oxide_types::object::JsObject; @@ -12,15 +12,15 @@ use oxide_types::value::JsValue; use crate::error; -/// `eval(x)`：非字符串实参原样返回；字符串按脚本编译执行（档 1 走函数模式）。 +/// `eval(x)`：非字符串实参原样返回；字符串按脚本模式编译执行。 /// /// # 步骤 /// 1. 实参非字符串 → 原样返回（规范不 ToString）。 -/// 2. 字符串 → 动态编译为匿名函数（`create_dynamic_function`），以 global 为 this 同步调用。 +/// 2. 字符串 → 动态编译为脚本模块（`create_dynamic_script`），以 global 为 this 同步调用。 /// 3. 编译失败 → SyntaxError；运行异常 → 优先重抛原始异常值（`take_uncaught_value`）。 /// /// # 边界与前提 -/// - 档 1 函数模式：eval 内 var 不落全局；档 2 切 `create_dynamic_script` 后 var 落全局。 +/// - 脚本模式：var/函数声明落全局对象，完成值保留，let/const 词法隔离。 /// - 无实参等价于 `eval(undefined)` → undefined。 pub fn eval(vm: &mut H, args: &[u8]) -> NativeResult { let arg = if args.len() >= 2 { vm.reg(args[1]) } else { JsValue::undefined() }; @@ -28,8 +28,7 @@ pub fn eval(vm: &mut H, args: &[u8]) -> NativeResult { return NativeResult::Ok(arg); } let code = vm.string_ref(arg).to_string(); - // 档 2 起把此分支换成 `vm.create_dynamic_script(&code)`。 - match vm.create_dynamic_function(&[], &code) { + match vm.create_dynamic_script(&code) { Ok(func) => { let global = JsValue::from_js_object(vm.session().global_object().as_ptr() as *mut JsObject); match vm.call_function_sync(func, global, &[]) { diff --git a/crates/oxide_runtime_api/src/lib.rs b/crates/oxide_runtime_api/src/lib.rs index e3ba3b0c..b8ee296a 100644 --- a/crates/oxide_runtime_api/src/lib.rs +++ b/crates/oxide_runtime_api/src/lib.rs @@ -189,6 +189,9 @@ pub trait VmHost { /// 动态编译一个函数体（`Function` 构造器用）：把参数列表与函数体编译为可调用 /// 函数对象。编译或解析失败返回 `Err`，由调用方转为 `SyntaxError`。 fn create_dynamic_function(&mut self, params: &[String], body: &str) -> Result; + /// 动态编译脚本（`eval` 字符串模式）：按脚本模式编译，var/函数声明落全局对象。 + /// 编译或解析失败返回 `Err`，由调用方转为 `SyntaxError`。 + fn create_dynamic_script(&mut self, code: &str) -> Result; /// `None` 表示无描述（`Symbol()`/`Symbol(undefined)`），`Some(desc)` 为字符串描述。 fn symbol_intern(&mut self, desc: Option) -> u32; fn symbol_description(&self, idx: u32) -> Option<&str>; diff --git a/crates/oxide_vm/src/vm.rs b/crates/oxide_vm/src/vm.rs index 78f9e15b..8b3c7357 100644 --- a/crates/oxide_vm/src/vm.rs +++ b/crates/oxide_vm/src/vm.rs @@ -2228,6 +2228,9 @@ impl oxide_runtime_api::VmHost for Vm { fn create_dynamic_function(&mut self, params: &[String], body: &str) -> Result { self.create_dynamic_function(params, body) } + fn create_dynamic_script(&mut self, code: &str) -> Result { + self.create_dynamic_script(code) + } fn symbol_intern(&mut self, desc: Option) -> u32 { self.symbols.intern(desc) } @@ -2298,6 +2301,37 @@ impl Vm { self.define_data_property(func_obj, name_si, name_val, attrs)?; Ok(func_val) } + + /// 动态编译脚本（eval 脚本模式）：把源码按脚本模式编译，var/函数声明落全局对象。 + /// + /// # 步骤 + /// 1. parse（脚本模式）→ compile（emit_program 置 is_global_scope=true）。 + /// 2. 整棵模块树（根 flat_id=0 + 嵌套函数）追加进平表：`rehome_subtree(&module, base+1)`， + /// 使根落 base、子函数 old→base+old，CREATE_CLOSURE imm16 同步重写。 + /// 3. 扩容 immutables_cache，建函数对象（sub_module_index = base）返回。 + /// + /// # 边界与前提 + /// - 顶层 return 不报 SyntaxError（emit 无此检查，与 CLI 脚本路径一致）——已知偏差。 + /// - 动态模块只在本次 run() 内有效（同 create_dynamic_function）。 + /// - 返回函数对象仅供内部同步调用，不设 name/length（用户不可见）。 + /// + /// # 副作用 + /// - 修改 `self.sub_modules` 与 `self.immutables_cache`。 + pub fn create_dynamic_script(&mut self, code: &str) -> Result { + let allocator = oxide_parser::Allocator::default(); + let program = oxide_parser::parse(&allocator, code) + .map_err(|errs| errs.into_iter().map(|e| e.message).collect::>().join("\n"))?; + let module = oxide_compiler::compiler::Compiler::new().compile(&program)?; + let base = self.sub_modules.len() as u32; + let mut added = Vec::new(); + // 根模块 flat_id=0 传 base+1，重编号后落 base（避开 sub_module_index()==0 守卫）。 + rehome_subtree(&module, base + 1, &mut added); + Arc::make_mut(&mut self.sub_modules).extend(added); + // 平表变长后同步扩容常量缓存，否则激活新模块常量时越界 panic。 + self.immutables_cache + .extend((0..self.sub_modules.len().saturating_sub(self.immutables_cache.len())).map(|_| OnceLock::new())); + Ok(self.create_function_object(base, false, false, false, false)) + } } /// 把 flatten 后的子模块子树重编号到平表偏移 `base`：DFS 前序拷贝进 `out`， diff --git a/crates/oxide_vm/tests/eval_tests.rs b/crates/oxide_vm/tests/eval_tests.rs index f779bc6a..97cd2ba7 100644 --- a/crates/oxide_vm/tests/eval_tests.rs +++ b/crates/oxide_vm/tests/eval_tests.rs @@ -19,26 +19,27 @@ fn assert_num(result: JsValue, expected: f64) { #[test] fn eval_string_expression_completion_value() { let mut vm = Vm::new(); - // 档 1 函数模式：body 包装为语句体匿名函数，隐式返回 undefined，完成值不保留。 - // 档 2 脚本模式（create_dynamic_script）后 `eval('1+2')` 返回 3。 + // 脚本模式完成值保留：`eval('1+2')` 返回 3（档 2 起，不再被函数模式 body wrap 吞掉）。 let result = eval(&mut vm, "eval('1+2')").unwrap(); - assert_eq!(result, JsValue::undefined()); + assert_num(result, 3.0); } #[test] fn eval_string_number_completion_value() { let mut vm = Vm::new(); - // 同档 1 函数模式上限：完成值不保留。 + // 脚本模式完成值保留：`eval('42')` 返回 42。 let result = eval(&mut vm, "eval('42')").unwrap(); - assert_eq!(result, JsValue::undefined()); + assert_num(result, 42.0); } #[test] fn eval_string_var_declaration_inside() { let mut vm = Vm::new(); - // 档 1：eval 内 var 声明只存在于匿名函数作用域，完成值不保留、不泄漏外层。 + // 档 2：eval 内 var 声明落全局对象，完成值保留为末表达式值。 let result = eval(&mut vm, "eval('var y = 1; y')").unwrap(); - assert_eq!(result, JsValue::undefined()); + assert_num(result, 1.0); + let result = eval(&mut vm, "eval('var y = 1; y') && this.y === 1").unwrap(); + assert_eq!(result, JsValue::bool(true)); } #[test] @@ -150,3 +151,74 @@ fn eval_survives_full_reset_rebuild() { assert_num(result, 123.0); assert!(!vm.session().is_dirty_since_snapshot()); } + +#[test] +fn eval_script_var_lands_on_global() { + let mut vm = Vm::new(); + // 间接 eval 脚本模式：var 声明落全局对象，外层 this 可见。 + let result = eval(&mut vm, "(0,eval)('var q = 9'); this.q === 9").unwrap(); + assert_eq!(result, JsValue::bool(true)); +} + +#[test] +fn eval_script_function_decl_lands_on_global() { + let mut vm = Vm::new(); + // 脚本模式：顶层函数声明落全局对象。 + let result = eval(&mut vm, "(0,eval)('function f(){}'); typeof f === 'function'").unwrap(); + assert_eq!(result, JsValue::bool(true)); +} + +#[test] +fn eval_script_let_is_isolated() { + let mut vm = Vm::new(); + // let/const 词法隔离：不落全局，不泄漏到外层。 + let result = eval(&mut vm, "(0,eval)('let z = 1'); typeof z === 'undefined'").unwrap(); + assert_eq!(result, JsValue::bool(true)); + // 词法声明自身仍参与脚本完成值。 + let result = eval(&mut vm, "(0,eval)('let z2 = 2; z2')").unwrap(); + assert_num(result, 2.0); +} + +#[test] +fn eval_script_this_is_global() { + let mut vm = Vm::new(); + // 脚本模式：this 与 globalThis 恒等（inline 调用 receiver 传 global）。 + let result = eval(&mut vm, "(0,eval)('this === globalThis')").unwrap(); + assert_eq!(result, JsValue::bool(true)); +} + +#[test] +fn eval_nested_eval() { + let mut vm = Vm::new(); + // 嵌套 eval：内层完成值透传为外层脚本值。 + let result = eval(&mut vm, "eval(\"eval('1+1')\")").unwrap(); + assert_num(result, 2.0); +} + +#[test] +fn eval_script_completion_value() { + let mut vm = Vm::new(); + // 间接 eval 脚本模式完成值：var 初始化 + 表达式。 + let result = eval(&mut vm, "(0,eval)('var a = 1; a')").unwrap(); + assert_num(result, 1.0); + let result = eval(&mut vm, "(0,eval)('1 + 2')").unwrap(); + assert_num(result, 3.0); +} + +#[test] +fn eval_script_empty_and_decl_only() { + let mut vm = Vm::new(); + // 空脚本 / 纯声明脚本：完成值为 undefined。 + let result = eval(&mut vm, "eval('') === undefined").unwrap(); + assert_eq!(result, JsValue::bool(true)); + let result = eval(&mut vm, "eval('var x;') === undefined").unwrap(); + assert_eq!(result, JsValue::bool(true)); +} + +#[test] +fn eval_script_throw_still_rethrows() { + let mut vm = Vm::new(); + // 脚本模式异常路径回归：eval 内 throw 原始值，外层 catch 捕获同一值。 + let result = eval(&mut vm, "try { (0,eval)('throw 5') } catch(e) { e }").unwrap(); + assert_num(result, 5.0); +}