From 430231236d85539b02b46f99c80dc6eac4dca333 Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Fri, 11 Sep 2026 10:14:56 +0000 Subject: [PATCH] =?UTF-8?q?fix:=20=E6=9C=AA=E5=A3=B0=E6=98=8E=E6=A0=87?= =?UTF-8?q?=E8=AF=86=E7=AC=A6=E8=AF=BB=E5=86=99=E6=B7=B7=E5=90=88=E8=A7=A3?= =?UTF-8?q?=E6=9E=90=E2=80=94=E2=80=94=E8=AF=BB=E4=BE=A7=E7=99=BB=E8=AE=B0?= =?UTF-8?q?=E7=9A=84=E5=85=A8=E5=B1=80=E6=A7=BD=E5=86=99=E4=B8=8D=E7=A9=BF?= =?UTF-8?q?=E9=80=8F=E5=85=A8=E5=B1=80=E5=AF=B9=E8=B1=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 未声明名由首次引用侧登记全局槽：读侧（LOAD_GLOBAL 槽）登记后， 后的写点只查写侧集合，补全局对象属性写被跳过——条件读走全局 属性、写落脚本内寄存器，脱节成死循环；更新式/复合式/逻辑赋值的 旧值又取自入口快照槽（读从不刷新槽），先读后写算出陈旧值。 写点隐式全局判定改读写登记集合取并（7 处），RMW 旧值读前经 LOAD_GLOBAL_TYPEOF 从全局对象取当前值（缺失按 undefined，sloppy 未解析引用 GetBaseValue 语义），读侧登记集合随继承绑定传入子 函数 ctx。 --- crates/oxide_emit/src/emit.rs | 19 ++++++++--- crates/oxide_emit/src/expr/assignment.rs | 27 +++++++++++++-- crates/oxide_emit/src/expr/identifier.rs | 2 +- crates/oxide_emit/src/expr/operator/mod.rs | 14 +++++++- crates/oxide_emit/src/shared/binding.rs | 6 ++-- .../tests/implicit_global_write_tests.rs | 33 +++++++++++++++++++ 6 files changed, 89 insertions(+), 12 deletions(-) diff --git a/crates/oxide_emit/src/emit.rs b/crates/oxide_emit/src/emit.rs index 57340880..8d1476ea 100644 --- a/crates/oxide_emit/src/emit.rs +++ b/crates/oxide_emit/src/emit.rs @@ -216,9 +216,9 @@ pub struct CompileCtx { /// 按寄存器而非名字记录：块作用域同名新绑定持不同槽位，不会被误判为隐式全局。 pub(crate) implicit_global_reads: HashSet, /// 未声明标识符写所登记的全局槽寄存器集合：`lookup_or_global` 未命中任何作用域 - /// 时登记全局作用域绑定并记录其寄存器，写调用点据此补全局对象属性写（sloppy） - /// 或抛 ReferenceError（strict）。子函数 ctx 从父继承——继承绑定命中同一寄存器， - /// 补写/抛错判定跨嵌套函数一致。 + /// 时登记全局作用域绑定并记录其寄存器，写调用点据此（经 `is_implicit_global_reg` + /// 与读集合取并）补全局对象属性写（sloppy）或抛 ReferenceError（strict）。 + /// 子函数 ctx 从父继承——继承绑定命中同一寄存器，补写/抛错判定跨嵌套函数一致。 pub(crate) implicit_global_writes: HashSet, /// 函数 `length` 属性值：首个带默认值形参之前的形参数（rest 不计）。 /// emit_params_prologue 前由编译入口从 param_specs 计算。 @@ -482,6 +482,13 @@ impl CompileCtx { self.scopes.symbols.lookup_or_global(name, reg) } + /// 寄存器是否承载未声明标识符的全局槽（写调用点据此补全局对象属性写或抛 + /// ReferenceError）。读写两个登记集合取并：未声明名谁先引用谁登记，读侧登记 + /// （LOAD_GLOBAL 槽）与写侧登记同属一个全局槽，写都必须穿透到全局对象。 + pub(crate) fn is_implicit_global_reg(&self, reg: u32) -> bool { + self.implicit_global_writes.contains(®) || self.implicit_global_reads.contains(®) + } + pub(crate) fn lookup_const_flag(&self, name: &str) -> bool { // upvalue 捕获的 const：子 ctx 符号表不含父函数作用域绑定，查快照标志。 self.scopes.symbols.lookup_is_const(name) || self.upvalue_const_flags.contains(name) @@ -1128,9 +1135,11 @@ impl Emitter { ); inherited_reg_start = inherited_reg_start.max(binding.reg.saturating_add(1)); } - // 隐式全局写集合随继承绑定传入：父层未声明写已登记全局作用域，子层解析命中 - // 继承绑定时须同样补全局对象属性写（或严格模式抛错）。 + // 隐式全局登记集合随继承绑定传入：父层未声明名已登记全局作用域，子层解析 + // 命中继承绑定时须同样补全局对象属性写（或严格模式抛错）。读写两侧登记 + // 一并继承——读侧登记的全局槽与写侧同属一个槽，写判定跨嵌套函数一致。 ctx.implicit_global_writes = parent_ctx.implicit_global_writes.clone(); + ctx.implicit_global_reads = parent_ctx.implicit_global_reads.clone(); for (name, reg) in extra_bindings { ctx.scopes.symbols.scopes[0].bindings.insert( (*name).to_string(), diff --git a/crates/oxide_emit/src/expr/assignment.rs b/crates/oxide_emit/src/expr/assignment.rs index 5c2b2948..69befe1a 100644 --- a/crates/oxide_emit/src/expr/assignment.rs +++ b/crates/oxide_emit/src/expr/assignment.rs @@ -95,11 +95,23 @@ impl Emitter { ctx.inst(Inst::new(op, Operand::Reg(val_reg), Operand::Reg(rhs), Operand::None)); return Ok(val_reg); } - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明复合写：未解析引用不可 put，值无关抛 ReferenceError。 return self.emit_strict_undeclared_write(name, ctx); } + // 未声明名槽是入口快照（读侧登记的槽从不被读刷新，同脚本后续写 + // 可使其脱节）：RMW 前从全局对象属性取旧值，属性缺失按 undefined + // （sloppy 未解析引用 GetBaseValue 语义，不抛）。 + if is_implicit { + let key_idx = ctx.add_constant(Constant::String(name.to_string())); + ctx.inst(Inst::new( + OpCode::LOAD_GLOBAL_TYPEOF, + Operand::Reg(var_reg), + Operand::Const(key_idx), + Operand::None, + )); + } ctx.inst(Inst::new(op, Operand::Reg(var_reg), Operand::Reg(rhs), Operand::None)); if is_implicit { self.emit_implicit_global_write(name, var_reg, ctx); @@ -368,6 +380,17 @@ impl Emitter { )); } else { let var_reg = ctx.lookup_or_global(name); + // 未声明名槽是入口快照（读侧登记的槽从不被读刷新）： + // 旧值读前从全局对象属性取当前值，缺失按 undefined（不抛）。 + if ctx.is_implicit_global_reg(var_reg) { + let key_idx = ctx.add_constant(Constant::String(name.to_string())); + ctx.inst(Inst::new( + OpCode::LOAD_GLOBAL_TYPEOF, + Operand::Reg(var_reg), + Operand::Const(key_idx), + Operand::None, + )); + } ctx.inst(Inst::new( OpCode::LOAD_VAR, Operand::Reg(result_reg), @@ -408,7 +431,7 @@ impl Emitter { } else if !readonly_builtin { // 隐式全局判定以寄存器集合为准：读侧（旧值解析）已登记绑定， // 写侧二次解析命中集合而非"新登记"。 - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明写：抛 ReferenceError，后续 LOAD_VAR 不可达。 let _ = self.emit_strict_undeclared_write(name, ctx)?; diff --git a/crates/oxide_emit/src/expr/identifier.rs b/crates/oxide_emit/src/expr/identifier.rs index a7559398..83a8c2c7 100644 --- a/crates/oxide_emit/src/expr/identifier.rs +++ b/crates/oxide_emit/src/expr/identifier.rs @@ -181,7 +181,7 @@ impl Emitter { } return; } - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明写：发射 ReferenceError 抛错，跳过寄存器写（值无关）。 let _ = self.emit_strict_undeclared_write(name, ctx); diff --git a/crates/oxide_emit/src/expr/operator/mod.rs b/crates/oxide_emit/src/expr/operator/mod.rs index abae1d3a..ce1f23cc 100644 --- a/crates/oxide_emit/src/expr/operator/mod.rs +++ b/crates/oxide_emit/src/expr/operator/mod.rs @@ -632,11 +632,23 @@ impl Emitter { ctx.inst(Inst::new(op, Operand::Reg(tmp_reg), Operand::Reg(result_reg), Operand::Reg(result_reg))); return Ok(result_reg); } - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明更新写：值无关抛 ReferenceError。 return self.emit_strict_undeclared_write(name, ctx); } + // 未声明名槽是入口快照（读侧登记的槽从不被读刷新，同脚本后续写 + // 可使其脱节）：RMW 前从全局对象属性取旧值，属性缺失按 undefined + // （sloppy 未解析引用 GetBaseValue 语义，不抛）。 + if is_implicit { + let key_idx = ctx.add_constant(Constant::String(name.to_string())); + ctx.inst(Inst::new( + OpCode::LOAD_GLOBAL_TYPEOF, + Operand::Reg(var_reg), + Operand::Const(key_idx), + Operand::None, + )); + } let result_reg = ctx.alloc_reg(); let op = match (update.operator, update.prefix) { (UpdateOperator::Increment, true) => OpCode::INC_PRE, diff --git a/crates/oxide_emit/src/shared/binding.rs b/crates/oxide_emit/src/shared/binding.rs index e1218dc5..9d05bf44 100644 --- a/crates/oxide_emit/src/shared/binding.rs +++ b/crates/oxide_emit/src/shared/binding.rs @@ -135,7 +135,7 @@ impl Emitter { } return Ok(()); } - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。 self.emit_strict_undeclared_write(name, ctx)?; @@ -337,7 +337,7 @@ impl Emitter { } return Ok(()); } - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。 self.emit_strict_undeclared_write(name, ctx)?; @@ -421,7 +421,7 @@ impl Emitter { } continue; } - let is_implicit = ctx.implicit_global_writes.contains(&var_reg); + let is_implicit = ctx.is_implicit_global_reg(var_reg); if is_implicit && ctx.is_strict { // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。 self.emit_strict_undeclared_write(name, ctx)?; diff --git a/crates/oxide_vm/tests/implicit_global_write_tests.rs b/crates/oxide_vm/tests/implicit_global_write_tests.rs index eb6317c9..d3dc524b 100644 --- a/crates/oxide_vm/tests/implicit_global_write_tests.rs +++ b/crates/oxide_vm/tests/implicit_global_write_tests.rs @@ -161,3 +161,36 @@ fn sloppy_undeclared_write_to_readonly_global_property_silent() { .unwrap(); assert!(r.is_bool() && r.as_bool(), "sloppy 对既有不可写全局属性写应静默 no-op，实际 {:?}", r); } + +// ── 读写混合解析：未声明名由首次引用侧登记全局槽（读侧 LOAD_GLOBAL 登记， +// 写侧新建登记），后的写须同样穿透全局对象——先读后写各形态回归钉 ── +#[test] +fn undeclared_read_then_assignment_write_reaches_global() { + let r = eval_many(&["globalThis.n = 0", "var seen = n", "n = 7", "globalThis.n === 7"]).unwrap(); + assert!(r.is_bool() && r.as_bool(), "先读后写的未声明名应穿透全局对象，实际 {:?}", r); +} + +#[test] +fn undeclared_read_then_update_write_reaches_global() { + let r = eval_many(&["globalThis.c = 0", "var seen = c", "c++", "globalThis.c === 1"]).unwrap(); + assert!(r.is_bool() && r.as_bool(), "先读后更新式写应穿透全局对象，实际 {:?}", r); +} + +#[test] +fn undeclared_read_then_compound_write_reaches_global() { + let r = eval_many(&["globalThis.m = 0", "var seen = m", "m += 2", "globalThis.m === 2"]).unwrap(); + assert!(r.is_bool() && r.as_bool(), "先读后复合赋值应穿透全局对象，实际 {:?}", r); +} + +#[test] +fn undeclared_read_then_destructuring_write_reaches_global() { + let r = eval_many(&["globalThis.d = 0", "var seen = d", "[d] = [9]", "globalThis.d === 9"]).unwrap(); + assert!(r.is_bool() && r.as_bool(), "先读后解构写应穿透全局对象，实际 {:?}", r); +} + +// ── 严格模式：读侧已登记的全局槽同属未解析引用，后写抛 ReferenceError ── +#[test] +fn strict_undeclared_read_then_write_throws_reference() { + let result = eval("'use strict'; globalThis.s = 0; var seen = s; s = 5"); + assert_err_contains(result, "s is not defined"); +}