fix: 不可写全局内置（undefined/NaN/Infinity）寄存器镜像写编译期拦截——sloppy 静默 no-op、strict 抛 TypeError

crates/oxide_emit/src/emit.rs

@@ -134,6 +134,11 @@ const BUILTIN_GLOBALS: &[&str] = &[
     "$262",
 ];
 
+/// 不可写全局内置名：全局对象上的数据属性为 {writable:false, configurable:false}，
+/// 对它们的 put 永不成功。写路径命中这些名字的全局绑定（非局部遮蔽）时编译期
+/// 拦截：sloppy 静默丢弃、strict 抛 TypeError；其余内置名属性可写，写路径放行。
+const NON_WRITABLE_GLOBAL_BUILTINS: &[&str] = &["undefined", "NaN", "Infinity"];
+
 pub(crate) struct FieldBuffer {
     pub(crate) insts: Vec<Inst>,
     pub(crate) labels: Vec<(LabelId, usize)>,
@@ -657,6 +662,20 @@ impl CompileCtx {
         false
     }
 
+    /// 写目标是否为不可写全局内置（undefined/NaN/Infinity 的全局绑定）。
+    /// 名字在名单内且解析寄存器是全局内置槽（builtin_reg_map 登记），或名字落到
+    /// 全局作用域绑定（顶层 var 预声明/隐式全局，含继承的全局槽）——局部
+    /// var/let/参数遮蔽同名时解析到局部寄存器/局部作用域，两条件均不命中。
+    pub(crate) fn targets_readonly_builtin(&self, name: &str, reg: u32) -> bool {
+        if !NON_WRITABLE_GLOBAL_BUILTINS.contains(&name) {
+            return false;
+        }
+        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)))
+    }
+
     pub(crate) fn is_known_builtin(name: &str) -> bool {
         BUILTIN_GLOBALS.contains(&name)
     }

crates/oxide_emit/src/expr/assignment.rs

@@ -15,6 +15,8 @@ impl Emitter {
     /// # 边界与前提
     /// - `op` 必须是 COMPOUND_* 族（rd 兼作 lhs 源，a 为 rhs）。
     /// - upvalue / cell 场景忽略 const 语义（共享单元由闭包机制保证）。
+    /// - 不可写全局内置槽：值照算（表达式值 = 运算结果）但跳过槽写；strict 抛
+    ///   TypeError。局部遮蔽绑定不受影响。
     fn emit_compound_identifier_static(
         &self, name: &str, op: OpCode, rhs: u32, ctx: &mut CompileCtx,
     ) -> Result<u32, String> {
@@ -27,6 +29,16 @@ impl Emitter {
         // update 写寄存器供下一迭代 fresh 拷贝，不污染本迭代闭包捕获的 cell）。
         if ctx.register_update_names.iter().any(|n| n == name) {
             if let Some(reg) = ctx.scopes.symbols.lookup_any(name) {
+                if ctx.targets_readonly_builtin(name, reg) {
+                    if ctx.is_strict {
+                        return self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx);
+                    }
+                    // 全局不可写内置：值照算（表达式值 = 运算结果），跳过槽写。
+                    let val_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(val_reg), Operand::Reg(reg), Operand::None));
+                    ctx.inst(Inst::new(op, Operand::Reg(val_reg), Operand::Reg(rhs), Operand::None));
+                    return Ok(val_reg);
+                }
                 ctx.inst(Inst::new(op, Operand::Reg(reg), Operand::Reg(rhs), Operand::None));
                 return Ok(reg);
             }
@@ -72,6 +84,17 @@ impl Emitter {
             Ok(val_reg)
         } else {
             let var_reg = ctx.lookup_or_global(name);
+            if ctx.targets_readonly_builtin(name, var_reg) {
+                // 全局不可写内置槽：strict 抛 TypeError（put 失败）；sloppy 值照算
+                // （表达式值 = 运算结果），跳过槽写。
+                if ctx.is_strict {
+                    return self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx);
+                }
+                let val_reg = ctx.alloc_reg();
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(val_reg), Operand::Reg(var_reg), Operand::None));
+                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);
             if is_implicit && ctx.is_strict {
                 // 严格模式未声明复合写：未解析引用不可 put，值无关抛 ReferenceError。

crates/oxide_emit/src/expr/identifier.rs

@@ -126,6 +126,8 @@ impl Emitter {
     /// - `const_flag` 为 1 时编译期直接抛 TypeError（值无关），覆盖普通/upvalue/cell 全写路径；
     ///   不发射写指令（THROW 后不可达）。
     /// - cell 写穿共享单元，无运行时 guard；const 拦截由本入口编译期完成。
+    /// - 不可写全局内置（undefined/NaN/Infinity）的全局绑定写在此拦截：sloppy 跳过
+    ///   寄存器写（槽保留入口预载原值），strict 抛 TypeError；局部遮蔽绑定不受影响。
     pub(crate) fn emit_identifier_store(&self, name: &str, val_reg: u32, const_flag: u16, ctx: &mut CompileCtx) {
         // 循环 update 段的 let/const 循环变量是 per-iteration 可变绑定（CreateMutableBinding），
         // 写寄存器而非 cell，且豁免 const 检查（register_update_names 覆盖全部循环头声明名）。
@@ -139,6 +141,13 @@ impl Emitter {
         // update 写寄存器供下一迭代 fresh 拷贝，不污染本迭代闭包捕获的 cell）。
         if in_loop_update {
             if let Some(reg) = ctx.scopes.symbols.lookup_any(name) {
+                if ctx.targets_readonly_builtin(name, reg) {
+                    // 全局不可写内置：put 永不成功——sloppy 静默跳过，strict 抛错。
+                    if ctx.is_strict {
+                        let _ = self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx);
+                    }
+                    return;
+                }
                 ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(reg), Operand::Reg(val_reg), Operand::Imm(0)));
                 return;
             }
@@ -164,6 +173,14 @@ impl Emitter {
             return;
         }
         let var_reg = ctx.lookup_or_global(name);
+        if ctx.targets_readonly_builtin(name, var_reg) {
+            // 全局不可写内置槽：sloppy 跳过寄存器写（槽保留运行入口预载原值，
+            // 静默 no-op）；strict 在 RHS 已求值后抛 TypeError（put 失败）。
+            if ctx.is_strict {
+                let _ = self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx);
+            }
+            return;
+        }
         let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
         if is_implicit && ctx.is_strict {
             // 严格模式未声明写：发射 ReferenceError 抛错，跳过寄存器写（值无关）。

crates/oxide_emit/src/expr/operator/mod.rs

@@ -506,6 +506,10 @@ impl Emitter {
 
     /// 标识符自增/自减的静态路径：upvalue / 被捕获 cell 走显式读-增减-写回，
     /// 普通槽用 INC_PRE/POST 或 DEC_PRE/POST。返回结果寄存器。
+    ///
+    /// # 边界与前提
+    /// - 不可写全局内置槽：值照算（前缀返回新值、后缀返回旧值）但跳过槽写；
+    ///   strict 抛 TypeError。局部遮蔽绑定不受影响。
     fn emit_identifier_update_static(
         &self, name: &str, update: &oxide_parser::UpdateExpression, ctx: &mut CompileCtx,
     ) -> Result<u32, String> {
@@ -522,13 +526,24 @@ impl Emitter {
         // update 写寄存器供下一迭代 fresh 拷贝，不污染本迭代闭包捕获的 cell）。
         if ctx.register_update_names.iter().any(|n| n == name) {
             if let Some(reg) = ctx.scopes.symbols.lookup_any(name) {
-                let result_reg = ctx.alloc_reg();
                 let op = match (update.operator, update.prefix) {
                     (UpdateOperator::Increment, true) => OpCode::INC_PRE,
                     (UpdateOperator::Increment, false) => OpCode::INC_POST,
                     (UpdateOperator::Decrement, true) => OpCode::DEC_PRE,
                     (UpdateOperator::Decrement, false) => OpCode::DEC_POST,
                 };
+                if ctx.targets_readonly_builtin(name, reg) {
+                    if ctx.is_strict {
+                        return self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx);
+                    }
+                    // 全局不可写内置：值照算（前缀返回新值、后缀返回旧值），跳过槽写。
+                    let tmp_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(tmp_reg), Operand::Reg(reg), Operand::None));
+                    let result_reg = ctx.alloc_reg();
+                    ctx.inst(Inst::new(op, Operand::Reg(tmp_reg), Operand::Reg(result_reg), Operand::Reg(result_reg)));
+                    return Ok(result_reg);
+                }
+                let result_reg = ctx.alloc_reg();
                 ctx.inst(Inst::new(op, Operand::Reg(reg), Operand::Reg(result_reg), Operand::Reg(result_reg)));
                 return Ok(result_reg);
             }
@@ -599,6 +614,24 @@ impl Emitter {
             Ok(if update.prefix { new_reg } else { old_reg })
         } else {
             let var_reg = ctx.lookup_or_global(name);
+            if ctx.targets_readonly_builtin(name, var_reg) {
+                // 全局不可写内置槽：strict 抛 TypeError（put 失败）；sloppy 值照算
+                // （前缀返回新值、后缀返回旧值），跳过槽写。
+                if ctx.is_strict {
+                    return self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx);
+                }
+                let tmp_reg = ctx.alloc_reg();
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(tmp_reg), Operand::Reg(var_reg), Operand::None));
+                let result_reg = ctx.alloc_reg();
+                let op = match (update.operator, update.prefix) {
+                    (UpdateOperator::Increment, true) => OpCode::INC_PRE,
+                    (UpdateOperator::Increment, false) => OpCode::INC_POST,
+                    (UpdateOperator::Decrement, true) => OpCode::DEC_PRE,
+                    (UpdateOperator::Decrement, false) => OpCode::DEC_POST,
+                };
+                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);
             if is_implicit && ctx.is_strict {
                 // 严格模式未声明更新写：值无关抛 ReferenceError。

crates/oxide_emit/src/shared/binding.rs

@@ -50,6 +50,10 @@ impl Emitter {
 
     /// 绑定单个标识符到槽位。`fresh_cell` 为 true 时对被捕获绑定用 MAKE_CELL_FRESH
     /// （循环每迭代绑定：无条件新建 cell，本迭代闭包捕获新 cell）。
+    ///
+    /// # 边界与前提
+    /// - 声明撞全局不可写内置（undefined/NaN/Infinity）：sloppy 静默跳过写（槽保留
+    ///   入口预载原值），strict 抛 TypeError；局部遮蔽绑定不受影响。
     pub(crate) fn emit_bind_target(
         &self, name: &str, src_reg: u32, kind: VariableDeclarationKind, is_const: bool, fresh_cell: bool,
         ctx: &mut CompileCtx,
@@ -74,6 +78,14 @@ impl Emitter {
                 var_reg
             }
         };
+        if ctx.targets_readonly_builtin(name, target_reg) {
+            // 声明撞全局不可写内置：声明不更新既有全局绑定——sloppy 静默跳过
+            // （槽保留入口预载原值），strict 在初始化求值后抛 TypeError。
+            if ctx.is_strict {
+                self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx)?;
+            }
+            return Ok(());
+        }
         if let Some(&cell_idx) = ctx.captured_bindings.get(name) {
             let op = if fresh_cell { OpCode::MAKE_CELL_FRESH } else { OpCode::MAKE_CELL };
             ctx.inst(Inst::new(op, Operand::Reg(src_reg), Operand::Imm(cell_idx as u16), Operand::None));
@@ -115,6 +127,14 @@ impl Emitter {
                 self.emit_identifier_tdz_guard(name, ctx)?;
                 self.emit_const_write_guard(name, ctx)?;
                 let var_reg = ctx.lookup_or_global(name);
+                if ctx.targets_readonly_builtin(name, var_reg) {
+                    // 全局不可写内置：sloppy 静默跳过写（槽保留入口预载原值）；
+                    // strict 抛 TypeError（put 失败）。
+                    if ctx.is_strict {
+                        self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx)?;
+                    }
+                    return Ok(());
+                }
                 let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
                 if is_implicit && ctx.is_strict {
                     // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。
@@ -309,6 +329,14 @@ impl Emitter {
                 self.emit_identifier_tdz_guard(name, ctx)?;
                 self.emit_const_write_guard(name, ctx)?;
                 let var_reg = ctx.lookup_or_global(name);
+                if ctx.targets_readonly_builtin(name, var_reg) {
+                    // 全局不可写内置：sloppy 静默跳过写（槽保留入口预载原值）；
+                    // strict 抛 TypeError（put 失败）。
+                    if ctx.is_strict {
+                        self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx)?;
+                    }
+                    return Ok(());
+                }
                 let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
                 if is_implicit && ctx.is_strict {
                     // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。
@@ -385,6 +413,14 @@ impl Emitter {
                     self.emit_identifier_tdz_guard(name, ctx)?;
                     self.emit_const_write_guard(name, ctx)?;
                     let var_reg = ctx.lookup_or_global(name);
+                    if ctx.targets_readonly_builtin(name, var_reg) {
+                        // 全局不可写内置：sloppy 静默跳过该属性写（其余属性继续赋值）；
+                        // strict 抛 TypeError（put 失败）。
+                        if ctx.is_strict {
+                            self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx)?;
+                        }
+                        continue;
+                    }
                     let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
                     if is_implicit && ctx.is_strict {
                         // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。

crates/oxide_emit/src/stmt/iteration/for_.rs

@@ -64,12 +64,15 @@ impl Emitter {
                         for name in &names {
                             if ctx.captured_bindings.contains_key(name) {
                                 if let Some(reg) = ctx.scopes.symbols.lookup_any(name) {
-                                    ctx.inst(Inst::new(
-                                        OpCode::STORE_VAR,
-                                        Operand::Reg(reg),
-                                        Operand::Reg(val_reg),
-                                        Operand::None,
-                                    ));
+                                    // 全局不可写内置的捕获写被声明路径拦截，同步写一并跳过。
+                                    if !ctx.targets_readonly_builtin(name, reg) {
+                                        ctx.inst(Inst::new(
+                                            OpCode::STORE_VAR,
+                                            Operand::Reg(reg),
+                                            Operand::Reg(val_reg),
+                                            Operand::None,
+                                        ));
+                                    }
                                 }
                             }
                         }
@@ -78,21 +81,25 @@ impl Emitter {
                         let tmp = ctx.alloc_reg();
                         ctx.inst(Inst::load_const(Operand::Reg(tmp), idx));
                         let var_reg = ctx.alloc_reg();
-                        let target_reg = if matches!(decl.kind, VariableDeclarationKind::Var) {
+                        // 无初始化 var 是纯声明而非赋值：绑定已预先存在（提升引用或
+                        // 先前写入）时保留槽值，仅首次声明把 undefined 物化进槽。
+                        let (target_reg, already_bound) = if matches!(decl.kind, VariableDeclarationKind::Var) {
                             match ctx.declare(bi.name.as_str(), var_reg, decl.kind, is_const) {
-                                Ok(()) => var_reg,
-                                Err(_) => ctx.lookup(bi.name.as_str()).unwrap_or(var_reg),
+                                Ok(()) => (var_reg, false),
+                                Err(_) => (ctx.lookup(bi.name.as_str()).unwrap_or(var_reg), true),
                             }
                         } else {
                             ctx.declare(bi.name.as_str(), var_reg, decl.kind, is_const)?;
-                            var_reg
+                            (var_reg, false)
                         };
-                        ctx.inst(Inst::new(
-                            OpCode::STORE_VAR,
-                            Operand::Reg(target_reg),
-                            Operand::Reg(tmp),
-                            Operand::None,
-                        ));
+                        if !already_bound {
+                            ctx.inst(Inst::new(
+                                OpCode::STORE_VAR,
+                                Operand::Reg(target_reg),
+                                Operand::Reg(tmp),
+                                Operand::None,
+                            ));
+                        }
                         ctx.init_var(bi.name.as_str());
                     }
                     // 记录 let/const 循环头声明名（update 段写豁免所需）与被捕获的绑定

crates/oxide_emit/src/stmt/iteration/for_in.rs

@@ -64,15 +64,28 @@ impl Emitter {
             ForStatementLeft::AssignmentTargetIdentifier(id_ref) => {
                 let name = id_ref.name.as_str();
                 let var_reg = ctx.lookup_or_global(name);
-                let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
-                // 未声明写仅在本迭代实际产生键后才发生（for-in NEXT 之后），空集合不抛。
-                if is_implicit && ctx.is_strict {
-                    // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。
-                    self.emit_strict_undeclared_write(name, ctx)?;
+                // 写仅在本迭代实际产生键后发生（for-in NEXT 之后），空集合不抛。
+                if ctx.targets_readonly_builtin(name, var_reg) {
+                    // 全局不可写内置：sloppy 静默跳过写（槽保留入口预载原值）；
+                    // strict 在本迭代抛 TypeError（put 失败）。
+                    if ctx.is_strict {
+                        self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx)?;
+                    }
                 } else {
-                    ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg), Operand::Reg(key_reg), Operand::None));
-                    if is_implicit {
-                        self.emit_implicit_global_write(name, var_reg, ctx);
+                    let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
+                    if is_implicit && ctx.is_strict {
+                        // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。
+                        self.emit_strict_undeclared_write(name, ctx)?;
+                    } else {
+                        ctx.inst(Inst::new(
+                            OpCode::STORE_VAR,
+                            Operand::Reg(var_reg),
+                            Operand::Reg(key_reg),
+                            Operand::None,
+                        ));
+                        if is_implicit {
+                            self.emit_implicit_global_write(name, var_reg, ctx);
+                        }
                     }
                 }
             }

crates/oxide_emit/src/stmt/iteration/for_of.rs

@@ -108,15 +108,28 @@ impl Emitter {
             ForStatementLeft::AssignmentTargetIdentifier(id_ref) => {
                 let name = id_ref.name.as_str();
                 let var_reg = ctx.lookup_or_global(name);
-                let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
-                // 未声明写仅在本迭代实际产生值后才发生（for-of NEXT 之后），空集合不抛。
-                if is_implicit && ctx.is_strict {
-                    // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。
-                    self.emit_strict_undeclared_write(name, ctx)?;
+                // 写仅在本迭代实际产生值后发生（for-of NEXT 之后），空集合不抛。
+                if ctx.targets_readonly_builtin(name, var_reg) {
+                    // 全局不可写内置：sloppy 静默跳过写（槽保留入口预载原值）；
+                    // strict 在本迭代抛 TypeError（put 失败）。
+                    if ctx.is_strict {
+                        self.emit_throw_error("TypeError", "cannot assign to read-only property", ctx)?;
+                    }
                 } else {
-                    ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg), Operand::Reg(val_reg), Operand::None));
-                    if is_implicit {
-                        self.emit_implicit_global_write(name, var_reg, ctx);
+                    let is_implicit = ctx.implicit_global_writes.contains(&var_reg);
+                    if is_implicit && ctx.is_strict {
+                        // 严格模式未声明写：抛 ReferenceError，跳过寄存器写（值无关）。
+                        self.emit_strict_undeclared_write(name, ctx)?;
+                    } else {
+                        ctx.inst(Inst::new(
+                            OpCode::STORE_VAR,
+                            Operand::Reg(var_reg),
+                            Operand::Reg(val_reg),
+                            Operand::None,
+                        ));
+                        if is_implicit {
+                            self.emit_implicit_global_write(name, var_reg, ctx);
+                        }
                     }
                 }
             }