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: 未声明标识符读写混合解析——读侧登记的全局槽写不穿透全局对象

Browse Source 
未声明名由首次引用侧登记全局槽：读侧（LOAD_GLOBAL 槽）登记后，
后的写点只查写侧集合，补全局对象属性写被跳过——条件读走全局
属性、写落脚本内寄存器，脱节成死循环；更新式/复合式/逻辑赋值的
旧值又取自入口快照槽（读从不刷新槽），先读后写算出陈旧值。

写点隐式全局判定改读写登记集合取并（7 处），RMW 旧值读前经
LOAD_GLOBAL_TYPEOF 从全局对象取当前值（缺失按 undefined，sloppy
未解析引用 GetBaseValue 语义），读侧登记集合随继承绑定传入子
函数 ctx。
This commit is contained in:
彭俊皓
2026-09-11 10:14:56 +00:00
parent c0451a484a
commit 430231236d
6 changed files with 89 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oxide_emit/src/emit.rs
+14 -5
View File
@@ -216,9 +216,9 @@ pub struct CompileCtx {
/// 按寄存器而非名字记录：块作用域同名新绑定持不同槽位，不会被误判为隐式全局。
pub(crate) implicit_global_reads: HashSet<u32>,
/// 未声明标识符写所登记的全局槽寄存器集合：`lookup_or_global` 未命中任何作用域
/// 时登记全局作用域绑定并记录其寄存器，写调用点据此补全局对象属性写（sloppy）
/// 或抛 ReferenceError（strict）。子函数 ctx 从父继承——继承绑定命中同一寄存器，
/// 补写/抛错判定跨嵌套函数一致。
/// 时登记全局作用域绑定并记录其寄存器，写调用点据此（经 `is_implicit_global_reg`
/// 与读集合取并）补全局对象属性写（sloppy）或抛 ReferenceError（strict）。
/// 子函数 ctx 从父继承——继承绑定命中同一寄存器，补写/抛错判定跨嵌套函数一致。
pub(crate) implicit_global_writes: HashSet<u32>,
/// 函数 `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(&reg) || self.implicit_global_reads.contains(&reg)
}
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(),
crates/oxide_emit/src/expr/assignment.rs
+25 -2
View File
@@ -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)?;
crates/oxide_emit/src/expr/identifier.rs
+1 -1
View File
@@ -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);
crates/oxide_emit/src/expr/operator/mod.rs
+13 -1
View File
@@ -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,
crates/oxide_emit/src/shared/binding.rs
+3 -3
View File
@@ -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)?;
crates/oxide_vm/tests/implicit_global_write_tests.rs
+33
View File
@@ -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");
}