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

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。