emit/kernel: 可写 builtin 全局标识符写双写全局属性,三常量描述符对齐规范 c:false,受限词法名集补 eval

- 谓词注册表化:targets_readonly_builtin 解析条件抽公共助手,新增
  targets_writable_builtin / is_writable_builtin_global(BUILTIN_GLOBALS
  减只读三常量派生,不复制名单)+ 只读/可写划分漂移守卫单测
- 12 个赋值族写点(简单/复合/更新/逻辑赋值、解构两臂、for-in/for-of
  标识符目标)补双写臂:STORE_VAR 后 0x98 同步全局对象属性(既有可写
  属性原地更值、保 e/c 位),裸读镜像与 globalThis 反射不失步
- for-in 头 tier 写点移除 builtin 名例外:可写 builtin 名迭代键照规范
  覆写全局属性(三常量仍由拦截臂跳过)
- 三常量(undefined/NaN/Infinity)全局描述符 configurable 翻正为
  false:delete 拒绝、属性保留,描述符读同步
- 脚本顶层受限词法名集 3→4(补 eval,静态受限臂):let/const/class
  eval 顶层声明编译期 SyntaxError
- 配套钉:7 处既有钉随 c 位翻正 + 2 枚 for-in/eval 形态钉反转,新增
  global_builtin_writable_tests(16 钉:双写六形态 + 遮蔽/strict/eval/
  宿主名面)

test262 子集:built-ins/global 29/29、三常量族 20/20、11.13.1-4 7/7、
assignmenttargettype plain 8/8 全绿;language/global-code 17 失败文件
双树单跑一致(pre-existing);annexB assignmenttargettype 7 个 parse
error 为既有解析器缺口
This commit is contained in:
2026-09-13 10:46:10 +00:00
parent c2df6869b8
commit c564ec539b
13 changed files with 267 additions and 57 deletions
+42 -10
View File
@@ -134,9 +134,10 @@ const BUILTIN_GLOBALS: &[&str] = &[
"$262",
];
/// 不可写全局内置名:全局对象上的数据属性为 {writable:false, configurable:false},
/// 只读全局内置名:全局对象上的数据属性为 {writable:false, configurable:false},
/// 对它们的 put 永不成功。写路径命中这些名字的全局绑定(非局部遮蔽)时编译期
/// 拦截:sloppy 静默丢弃、strict 抛 TypeError;其余内置名属性可写,写路径放行。
/// 拦截:sloppy 静默丢弃、strict 抛 TypeError;BUILTIN_GLOBALS 内其余名属性可写
/// (writable:true),标识符写须双写全局属性(见 targets_writable_builtin)。
const NON_WRITABLE_GLOBAL_BUILTINS: &[&str] = &["undefined", "NaN", "Infinity"];
pub(crate) struct FieldBuffer {
@@ -675,20 +676,37 @@ impl CompileCtx {
false
}
/// 写目标是否为不可写全局内置(undefined/NaN/Infinity 的全局绑定)。
/// 名字在名单内且解析寄存器是全局内置槽(builtin_reg_map 登记),或名字落到
/// 全局作用域绑定(顶层 var 预声明/隐式全局,含继承的全局槽)——局部
/// 名字是否解析到全局内置槽:builtin_reg_map 登记(预注册镜像槽),或绑定
/// 落全局作用域(scope 0,顶层 var 预声明/隐式全局,含继承的全局槽)。局部
/// var/let/参数遮蔽同名时解析到局部寄存器/局部作用域,两条件均不命中。
pub(crate) fn targets_readonly_builtin(&self, name: &str, reg: u32) -> bool {
if !NON_WRITABLE_GLOBAL_BUILTINS.contains(&name) {
return false;
}
fn resolves_to_global_builtin_slot(&self, name: &str, reg: u32) -> bool {
if self.scopes.builtin_reg_map.iter().any(|(n, r)| n == name && *r == reg) {
return true;
}
matches!(self.scopes.symbols.lookup_any_binding(name), Some((_, 0)))
}
/// 写目标是否为只读全局内置(undefined/NaN/Infinity 的全局绑定——全局对象上
/// 数据属性 {writable:false, configurable:false},put 永不成功)。名字在只读
/// 名单内且解析到全局内置槽;声明臂与赋值臂共用本谓词。
pub(crate) fn targets_readonly_builtin(&self, name: &str, reg: u32) -> bool {
NON_WRITABLE_GLOBAL_BUILTINS.contains(&name) && self.resolves_to_global_builtin_slot(name, reg)
}
/// 写目标是否为可写全局内置(全局对象上数据属性 {writable:true,
/// configurable:true})。标识符写须双写镜像槽 + 全局对象属性,否则裸读
/// (镜像)与 globalThis 反射(属性)失步。
pub(crate) fn targets_writable_builtin(&self, name: &str, reg: u32) -> bool {
Self::is_writable_builtin_global(name) && self.resolves_to_global_builtin_slot(name, reg)
}
/// 规范可写全局名:BUILTIN_GLOBALS 减只读三常量集——11 个 w:true 函数、
/// 48 个构造器/命名空间、globalThis 与宿主名,描述符皆
/// {writable:true, enumerable:false, configurable:true}。
pub(crate) fn is_writable_builtin_global(name: &str) -> bool {
BUILTIN_GLOBALS.contains(&name) && !NON_WRITABLE_GLOBAL_BUILTINS.contains(&name)
}
pub(crate) fn is_known_builtin(name: &str) -> bool {
BUILTIN_GLOBALS.contains(&name)
}
@@ -1802,7 +1820,7 @@ impl Default for Emitter {
#[cfg(test)]
mod tests {
use super::BUILTIN_GLOBALS;
use super::{BUILTIN_GLOBALS, NON_WRITABLE_GLOBAL_BUILTINS};
use crate::prepass::RESTRICTED_GLOBAL_LEXICAL_NAMES;
/// 漂移守卫:受限全局名集与 put 写拦截名单交叠名恒同步(两名单语义独立、
@@ -1813,4 +1831,18 @@ mod tests {
assert!(BUILTIN_GLOBALS.contains(name), "受限全局名缺失于 builtin 名单:{name}");
}
}
/// 漂移守卫:只读名单是 builtin 母集子集,且只读/可写两谓词对母集构成
/// 划分(不重不漏)——防三常量集或母集改名/删名时拦截面与双写面单边漂移。
#[test]
fn readonly_and_writable_partition_builtin_globals() {
for name in NON_WRITABLE_GLOBAL_BUILTINS {
assert!(BUILTIN_GLOBALS.contains(name), "只读全局名缺失于 builtin 名单:{name}");
}
for name in BUILTIN_GLOBALS {
let readonly = NON_WRITABLE_GLOBAL_BUILTINS.contains(name);
let writable = crate::CompileCtx::is_writable_builtin_global(name);
assert!(readonly ^ writable, "builtin 名只读/可写归属漂移:{name}");
}
}
}
+11 -2
View File
@@ -40,6 +40,10 @@ impl Emitter {
return Ok(val_reg);
}
ctx.inst(Inst::new(op, Operand::Reg(reg), Operand::Reg(rhs), Operand::None));
// 可写内置名:RMW 新值同步落全局对象属性。
if ctx.targets_writable_builtin(name, reg) {
self.emit_global_put_write(name, reg, ctx);
}
return Ok(reg);
}
}
@@ -116,9 +120,11 @@ impl Emitter {
if is_tier {
// 顶层已声明 var 复合赋值:新值落全局对象属性(A 侧单一真值)。
self.emit_tier_global_write(name, var_reg, ctx);
}
if is_implicit {
} else if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:RMW 新值同步落全局对象属性。
self.emit_global_put_write(name, var_reg, ctx);
}
Ok(var_reg)
}
@@ -452,6 +458,9 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:同步落全局对象属性(仅短路通过时到达)。
self.emit_global_put_write(name, var_reg, ctx);
}
}
}
+8
View File
@@ -159,6 +159,10 @@ impl Emitter {
return;
}
ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(reg), Operand::Reg(val_reg), Operand::Imm(0)));
// 可写内置名:值同步落全局对象属性,裸读(镜像)与反射不失步。
if ctx.targets_writable_builtin(name, reg) {
self.emit_global_put_write(name, reg, ctx);
}
return;
}
}
@@ -211,6 +215,10 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:值同步落全局对象属性(0x98 对既有可写属性仅更值、
// 保 e/c 位),否则镜像槽与 globalThis 反射失步。
self.emit_global_put_write(name, var_reg, ctx);
}
}
+8 -2
View File
@@ -548,6 +548,10 @@ impl Emitter {
}
let result_reg = ctx.alloc_reg();
ctx.inst(Inst::new(op, Operand::Reg(reg), Operand::Reg(result_reg), Operand::Reg(result_reg)));
// 可写内置名:RMW 新值同步落全局对象属性。
if ctx.targets_writable_builtin(name, reg) {
self.emit_global_put_write(name, reg, ctx);
}
return Ok(result_reg);
}
}
@@ -663,9 +667,11 @@ impl Emitter {
if is_tier {
// 顶层已声明 var 自增/自减:新值落全局对象属性(A 侧单一真值)。
self.emit_tier_global_write(name, var_reg, ctx);
}
if is_implicit {
} else if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:RMW 新值同步落全局对象属性。
self.emit_global_put_write(name, var_reg, ctx);
}
Ok(result_reg)
}
+7 -6
View File
@@ -9,12 +9,13 @@ use oxide_parser::{
BindingPattern, Declaration, ExportDefaultDeclarationKind, Expression, Statement, VariableDeclarationKind,
};
/// 脚本顶层 lexical 声明禁止使用的受限全局名:规范 HasRestrictedGlobalProperty
/// 判定「全局对象不可配置自有属性名」,现规范全局对象该自有属性恰为三常量。
/// 名基静态集(编译期不可查运行时描述符);eval 与各 builtin 属性均可配置
/// (合法遮蔽),不在此列。与 BUILTIN_GLOBALS 语义不同(后者是 put 写拦截名单),
/// 不互相派生,交叠名由漂移守卫单测断言恒同步。
pub(crate) const RESTRICTED_GLOBAL_LEXICAL_NAMES: &[&str] = &["undefined", "NaN", "Infinity"];
/// 脚本顶层 lexical 声明(let/const/class)禁止使用的受限全局名:4 名静态集。
/// 三常量是全局对象上 {configurable:false} 的自有属性名(声明实例化无法建立
/// 遮蔽绑定);eval 属静态受限臂(顶层 lexical 声明不得遮蔽,var/function
/// 路径不受本集约束)。名基静态集(编译期不可查运行时描述符)。与
/// BUILTIN_GLOBALS 语义不同(后者是 put 写拦截/双写名单),不互相派生,交叠
/// 名由漂移守卫单测断言恒同步。
pub(crate) const RESTRICTED_GLOBAL_LEXICAL_NAMES: &[&str] = &["undefined", "eval", "NaN", "Infinity"];
/// 脚本顶层 lexical 声明撞受限全局名 → SyntaxError(声明实例化期拒绝,整程序
/// 编译失败)。错误消息与既有重复声明错同形;非顶层或名不在受限集 → Ok。
+9
View File
@@ -161,6 +161,9 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:值同步落全局对象属性。
self.emit_global_put_write(name, var_reg, ctx);
}
Ok(())
}
@@ -369,6 +372,9 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:值同步落全局对象属性。
self.emit_global_put_write(name, var_reg, ctx);
}
Ok(())
}
@@ -459,6 +465,9 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:值同步落全局对象属性(其余属性继续赋值)。
self.emit_global_put_write(name, var_reg, ctx);
}
}
AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => {
@@ -72,8 +72,9 @@ impl Emitter {
Operand::None,
));
// 顶层 for-in var 头:迭代值落全局对象属性(A 侧单一真值)。
// builtin 名(writable 如 Math)保留既有全局属性值,不 clobber。
if self.is_global_tier_name(ctx, name) && !CompileCtx::is_known_builtin(name) {
// 只读三常量已在上方拦截臂跳过;其余 builtin 名属性可写,
// 迭代键照规范覆写既有全局属性。
if self.is_global_tier_name(ctx, name) {
self.emit_tier_global_write(name, key_reg, ctx);
}
}
@@ -99,9 +100,10 @@ impl Emitter {
if is_implicit && ctx.is_strict {
// 严格模式未声明写:抛 ReferenceError,跳过寄存器写(值无关)。
self.emit_strict_undeclared_write(name, ctx)?;
} else if is_tier && !CompileCtx::is_known_builtin(name) {
} else if is_tier {
// 顶层 for-in 赋值头:迭代值落全局对象属性(A 侧单一真值)。
// builtin 名保留既有全局属性值,不 clobber。
// 只读三常量已在上方拦截臂跳过;其余 builtin 名属性可写,
// 迭代键照规范覆写既有全局属性。
self.emit_tier_global_write(name, key_reg, ctx);
} else {
ctx.inst(Inst::new(
@@ -112,6 +114,9 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:迭代键同步落全局对象属性。
self.emit_global_put_write(name, var_reg, ctx);
}
}
}
@@ -129,6 +129,9 @@ impl Emitter {
));
if is_implicit {
self.emit_implicit_global_write(name, var_reg, ctx);
} else if ctx.targets_writable_builtin(name, var_reg) {
// 可写内置名:迭代值同步落全局对象属性。
self.emit_global_put_write(name, var_reg, ctx);
}
}
}
+6 -6
View File
@@ -625,16 +625,16 @@ impl KernelSession {
let si_undef = core.perm_interner.intern("undefined").0;
let si_infinity = core.perm_interner.intern("Infinity").0;
// 全局三常量描述符:{ writable:false, enumerable:false, configurable:true }。
// 全局三常量描述符:{ writable:false, enumerable:false, configurable:false }。
// e:false 是枚举面守卫(Object.keys / for-in 由 enumerable 决定);
// c:true 是 delete / defineProperty 可观察的规范值(delete globalThis.undefined
// 属性真删、返回 true)。
// c:false 是 delete / defineProperty 可观察的规范值(delete globalThis.undefined
// 返回 false、属性不可删,后续声明/定义均不得 reconfigure)。
let nan_shape = core.shape_forge.make_shape(EMPTY_SHAPE_ID, si_nan);
global_obj.set_shape_id(nan_shape);
global_obj.ensure_hash_props().push(JsValue::float(f64::NAN));
global_obj.set_data_meta(
global_obj.prop_vec_len().saturating_sub(1) as u32,
oxide_types::object::PropAttributes::new(false, false, true),
oxide_types::object::PropAttributes::new(false, false, false),
);
let undef_shape = core.shape_forge.make_shape(nan_shape, si_undef);
@@ -642,7 +642,7 @@ impl KernelSession {
global_obj.ensure_hash_props().push(JsValue::undefined());
global_obj.set_data_meta(
global_obj.prop_vec_len().saturating_sub(1) as u32,
oxide_types::object::PropAttributes::new(false, false, true),
oxide_types::object::PropAttributes::new(false, false, false),
);
let inf_shape = core.shape_forge.make_shape(undef_shape, si_infinity);
@@ -650,7 +650,7 @@ impl KernelSession {
global_obj.ensure_hash_props().push(JsValue::float(f64::INFINITY));
global_obj.set_data_meta(
global_obj.prop_vec_len().saturating_sub(1) as u32,
oxide_types::object::PropAttributes::new(false, false, true),
oxide_types::object::PropAttributes::new(false, false, false),
);
P::new(global_obj)
@@ -1,7 +1,7 @@
//! 脚本顶层 lexical 声明撞受限全局名的编译期拒绝:let/const/class 声明名撞
//! 全局对象不可配置自有属性(undefined/NaN/Infinity)→ SyntaxError(整程序
//! 编译失败)。局部作用域(函数体/块/try)与 eval 代码为合法遮蔽不拒;三常量
//! 值使用不受影响。
//! 受限集(undefined/eval/NaN/Infinity——三常量不可配置自有属性 + eval 静态
//! 受限臂)→ SyntaxError(整程序编译失败)。局部作用域(函数体/块/try)与
//! eval 代码为合法遮蔽不拒;三常数值使用不受影响。
use std::sync::Arc;
@@ -108,10 +108,22 @@ fn top_level_let_uses_nan_value_allowed() {
}
#[test]
fn top_level_let_eval_name_allowed() {
// eval 是全局对象可配置自有属性:合法遮蔽,不在受限集。
let r = assert_ok("let eval; 1");
assert_eq!(r.as_int(), 1);
fn top_level_let_eval_name_rejected() {
// eval 属静态受限臂:顶层 lexical 声明不得遮蔽(var/function 路径不受
// 本集约束)。
assert_compile_err("let eval;");
}
#[test]
fn top_level_const_eval_name_rejected() {
assert_compile_err("const eval = 1;");
}
#[test]
fn top_level_class_eval_name_rejected() {
// 若解析器更早拒绝(early error 族),亦接受该拒绝相位(整程序拒绝可观察
// 行为同形)。
assert!(eval("class eval {}").is_err(), "class eval 类名应被拒绝");
}
#[test]
@@ -1,7 +1,7 @@
//! 全局三常量(undefined/NaN/Infinity)描述符与 var 声明交互的回归测试。
//!
//! 覆盖规范全局对象属性描述符 { writable:false, enumerable:false, configurable:true }:
//! 描述符读、delete 真删、delete 后镜像裸读、var 无初始化声明的描述符不漂移与值
//! 覆盖规范全局对象属性描述符 { writable:false, enumerable:false, configurable:false }:
//! 描述符读、delete 拒绝且属性保留、delete 后镜像裸读、var 无初始化声明的描述符不漂移与值
//! 保持(writable 不翻位、NaN/Infinity 不被抹成 undefined)、var 初始化声明的值
//! 落槽、枚举面不泄漏、任务只读拦截与 strict TypeError、eval 路径、for-in 枚举面。
@@ -45,31 +45,31 @@ const CONSTANTS: [&str; 3] = ["undefined", "NaN", "Infinity"];
#[test]
fn three_constants_descriptor_matches_spec() {
// #1:描述符 { writable:false, enumerable:false, configurable:true } ×3 常量。
// #1:描述符 { writable:false, enumerable:false, configurable:false } ×3 常量。
for name in CONSTANTS {
let src = format!(
"var d = Object.getOwnPropertyDescriptor(globalThis, '{name}'); \
d.writable === false && d.enumerable === false && d.configurable === true"
d.writable === false && d.enumerable === false && d.configurable === false"
);
run_truthy(&src);
}
}
#[test]
fn delete_three_constants_removes_property() {
// #2:configurable → delete 返 true 且属性真删(描述符读为 undefined)×3 常量。
fn delete_three_constants_refused_property_kept() {
// #2:configurable:false → delete 返 false 且属性保留(描述符仍在、值不变)×3 常量。
for name in CONSTANTS {
let src = format!(
"delete globalThis.{name} === true \
&& Object.getOwnPropertyDescriptor(globalThis, '{name}') === undefined"
"delete globalThis.{name} === false \
&& Object.getOwnPropertyDescriptor(globalThis, '{name}') !== undefined"
);
run_truthy(&src);
}
}
#[test]
fn delete_then_bare_read_via_mirror() {
// #3:删后裸读走镜像预载(入口值),无 ReferenceError。
fn refused_delete_then_bare_read_via_mirror() {
// #3:delete 拒绝后裸读走镜像预载(入口值),无 ReferenceError。
assert_eq!(run_string("delete globalThis.undefined; typeof undefined"), "undefined");
}
@@ -86,7 +86,7 @@ fn var_no_init_descriptor_unchanged() {
let src = format!(
"var {name}; var d = Object.getOwnPropertyDescriptor(globalThis, '{name}'); \
{value_check} && d.writable === false && d.enumerable === false \
&& d.configurable === true",
&& d.configurable === false",
);
run_truthy(&src);
}
@@ -157,7 +157,7 @@ fn eval_var_readonly_builtin() {
run_truthy(
"eval('var undefined = 3'); \
var d = Object.getOwnPropertyDescriptor(globalThis, 'undefined'); \
d.writable === false && d.configurable === true",
d.writable === false && d.configurable === false",
);
}
@@ -199,10 +199,10 @@ fn function_declaration_builtin_name() {
}
#[test]
fn for_in_var_head_builtin_name_compiles_and_keeps_property() {
// 顶层 for-in var 头撞 builtin 名:序言预登记槽复用后可编译,
// 迭代键不触及全局属性(Math 对象保)。
run_truthy("var m = Math; for (var Math in {a:1,b:2}) {} globalThis.Math === m");
fn for_in_var_head_writable_builtin_name_clobbers_property() {
// 顶层 for-in var 头撞可写 builtin 名:序言预登记槽复用后可编译,
// 迭代键照规范覆写既有全局属性(末键 'b' 落 Math 属性)。
run_truthy("var m = Math; for (var Math in {a:1,b:2}) {} globalThis.Math === 'b'");
}
#[test]
@@ -0,0 +1,125 @@
//! 可写 builtin 全局双写(镜像槽 + 全局对象属性)回归测试。
//!
//! 规范可写全局(11 个 w:true 函数 + 48 个构造器/命名空间 + globalThis + 宿主名,
//! 描述符 {writable:true, enumerable:false, configurable:true})的标识符写须同步
//! 全局对象属性,裸读(镜像)与 globalThis 反射(属性)不失步。覆盖:简单/复合/
//! 更新/逻辑赋值、for-in/for-of 标识符目标、解构两臂、局部遮蔽不误伤、strict 可写
//! put 成功、eval 路径与 TypedArray 宿主名抽样。
use std::sync::Arc;
use oxide_compiler::compiler::Compiler;
use oxide_parser::Allocator;
use oxide_vm::vm::Vm;
fn eval_truthy(source: &str) {
let allocator = Allocator::default();
let program = oxide_parser::parse(&allocator, source).expect("parse");
let module = Compiler::new().compile(&program).expect("compile");
let mut vm = Vm::new();
let result = vm.run(&Arc::new(module)).expect("run");
assert!(result.is_bool() && result.as_bool(), "expected true, got: {result:?}\nsource: {source}");
}
// ── 简单赋值:镜像与属性同步落值 ──
#[test]
fn simple_assign_math_dual_writes() {
eval_truthy("var m = Math; Math = 5; Math === 5 && globalThis.Math === 5 && m !== 5");
}
#[test]
fn simple_assign_writable_names_dual_write() {
for name in ["Object", "JSON", "Symbol", "Promise"] {
let src = format!("var m = {name}; {name} = 5; {name} === 5 && globalThis.{name} === 5");
eval_truthy(&src);
}
}
// ── w:true 函数族:strict 下可写 put 成功(无 TypeError) ──
#[test]
fn strict_writable_function_put_succeeds() {
eval_truthy("'use strict'; parseInt = 42; parseInt === 42 && globalThis.parseInt === 42");
}
#[test]
fn sloppy_writable_function_put_succeeds() {
eval_truthy("parseInt = 42; parseInt === 42 && globalThis.parseInt === 42");
}
#[test]
fn uri_family_dual_write() {
eval_truthy("var m = encodeURI; encodeURI = 1; encodeURI === 1 && globalThis.encodeURI === 1");
}
// ── 复合/更新/逻辑赋值:RMW 新值两侧同步 ──
#[test]
fn compound_assign_dual_writes() {
eval_truthy("var m = Math; Math = 5; Math += 1; Math === 6 && globalThis.Math === 6");
}
#[test]
fn update_assign_dual_writes() {
eval_truthy("var m = Math; Math = 5; var r = (Math++); r === 5 && Math === 6 && globalThis.Math === 6");
}
#[test]
fn logical_assign_dual_writes() {
// ||=:LHS falsy 触发 put;??=:LHS nullish 触发 put。
eval_truthy("var m = Math; Math = 0; Math ||= 9; Math === 9 && globalThis.Math === 9");
eval_truthy("var m = Math; Math = null; Math ??= 2; Math === 2 && globalThis.Math === 2");
}
#[test]
fn logical_assign_short_circuit_no_put() {
// 短路未通过不发生 put(&&= 遇 falsy、??= 遇非 nullish):值与属性均保持。
eval_truthy("var m = Math; Math = 0; Math &&= 1; Math === 0 && globalThis.Math === 0");
eval_truthy("var m = Math; Math = 5; Math ??= 2; Math === 5 && globalThis.Math === 5");
}
// ── for-in/for-of 标识符目标:迭代值两侧同步 ──
#[test]
fn for_in_target_dual_writes() {
eval_truthy("var m = Math; Math = 5; for (Math in {a:1,b:2}) {} Math === 'b' && globalThis.Math === 'b'");
}
#[test]
fn for_of_target_dual_writes() {
eval_truthy("var m = Math; for (Math of [1,2]) {} Math === 2 && globalThis.Math === 2");
}
// ── 解构赋值两臂:值两侧同步 ──
#[test]
fn destructure_assign_dual_writes() {
eval_truthy("var m = Math; ({Math} = {Math: 1}); Math === 1 && globalThis.Math === 1");
eval_truthy("var m = Math; ([Math = 1] = [2]); Math === 2 && globalThis.Math === 2");
}
// ── 局部遮蔽不误伤:函数内 var 同名写不触全局 ──
#[test]
fn local_shadow_not_dual_written() {
eval_truthy(
"var m = Math; function g(){ var Math = 7; return Math; } \
g() === 7 && Math === m && globalThis.Math === m",
);
}
// ── globalThis 自身可写:镜像与属性同步 ──
#[test]
fn global_this_self_dual_writes() {
eval_truthy(
"var m = globalThis; globalThis = 1; \
globalThis === 1 && Object.getOwnPropertyDescriptor(m, 'globalThis').value === 1",
);
}
// ── 宿主名(TypedArray 抽象运算对象)同双写面 ──
#[test]
fn typed_array_host_name_dual_writes() {
eval_truthy("var m = TypedArray; TypedArray = 1; TypedArray === 1 && globalThis.TypedArray === 1");
}
// ── eval 路径:同一 emit 管线双写同效(外层镜像预载不重载,只钉属性面) ──
#[test]
fn eval_code_dual_writes_property() {
eval_truthy("eval('Math = 5'); globalThis.Math === 5");
}
@@ -1,6 +1,6 @@
//! 内置全局属性描述符测试:规范要求全局构造器/命名空间对象属性
//! enumerable=false(不泄漏进 Object.keys(globalThis) / for-in),
//! 全局 NaN/undefined/Infinity 三常量不可写不可枚举可配置。
//! enumerable=false(不泄漏进 Object.keys(globalThis) / for-in)且可写可配置,
//! 全局 NaN/undefined/Infinity 三常量不可写不可枚举不可配置。
use std::sync::Arc;
@@ -63,11 +63,11 @@ fn for_in_global_this_excludes_builtins() {
}
#[test]
fn nan_undefined_infinity_are_non_writable_configurable() {
fn nan_undefined_infinity_are_non_writable_non_configurable() {
for name in ["NaN", "undefined", "Infinity"] {
let src = format!(
"var d = Object.getOwnPropertyDescriptor(globalThis, '{name}'); \
d.writable === false && d.enumerable === false && d.configurable === true"
d.writable === false && d.enumerable === false && d.configurable === false"
);
eval_truthy(&src);
}