fix: for-const 循环 update 段豁免 const 写检查（per-iteration 绑定合法）

crates/oxide_emit/src/expr/assignment.rs

@@ -19,7 +19,10 @@ impl Emitter {
         &self, name: &str, op: OpCode, rhs: u32, ctx: &mut CompileCtx,
     ) -> Result<u32, String> {
         // const 复合赋值恒抛 TypeError（编译期拦截，值无关）；检查在读旧值之前。
-        self.emit_const_write_guard(name, ctx)?;
+        // 循环 update 段的 let/const 循环变量是 per-iteration 可变绑定，复合写同样合法，豁免。
+        if !ctx.register_update_names.iter().any(|n| n == name) {
+            self.emit_const_write_guard(name, ctx)?;
+        }
         // 循环 update 段：被捕获绑定走寄存器 RMW（C 风格 for 每迭代 fresh，
         // update 写寄存器供下一迭代 fresh 拷贝，不污染本迭代闭包捕获的 cell）。
         if ctx.register_update_names.iter().any(|n| n == name) {
@@ -176,12 +179,7 @@ impl Emitter {
                     // 复合赋值保规范求值序：先读属性（ic_get）再求值 RHS——RHS 副作用
                     // 可能改写同一属性，后求值才能读到旧值。
                     let val_reg = ctx.alloc_reg();
-                    ctx.inst(Inst::new(
-                        OpCode::LOAD_VAR,
-                        Operand::Reg(val_reg),
-                        Operand::Reg(obj_reg),
-                        Operand::None,
-                    ));
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(val_reg), Operand::Reg(obj_reg), Operand::None));
                     ctx.inst(Inst::ic_get(Operand::Reg(val_reg), Operand::Reg(key_reg)));
                     let rhs = self.emit_expression(&assign.right, ctx)?;
                     let op = match assign.operator {

crates/oxide_emit/src/expr/identifier.rs

@@ -120,21 +120,19 @@ impl Emitter {
     ///   不发射写指令（THROW 后不可达）。
     /// - cell 写穿共享单元，无运行时 guard；const 拦截由本入口编译期完成。
     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 覆盖全部循环头声明名）。
+        let in_loop_update = ctx.register_update_names.iter().any(|n| n == name);
         // const 再赋值编译期抛 TypeError：赋值路径（含闭包捕获 const 写 cell）统一拦截。
-        if const_flag != 0 {
+        if const_flag != 0 && !in_loop_update {
             let _ = self.emit_throw_error("TypeError", "Assignment to constant variable", ctx);
             return;
         }
         // 循环 update 段：被捕获绑定走寄存器而非 cell（C 风格 for 每迭代 fresh，
         // update 写寄存器供下一迭代 fresh 拷贝，不污染本迭代闭包捕获的 cell）。
-        if ctx.register_update_names.iter().any(|n| n == name) {
+        if in_loop_update {
             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::Imm(const_flag),
-                ));
+                ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(reg), Operand::Reg(val_reg), Operand::Imm(0)));
                 return;
             }
         }

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

@@ -467,8 +467,12 @@ impl Emitter {
         &self, name: &str, update: &oxide_parser::UpdateExpression, ctx: &mut CompileCtx,
     ) -> Result<u32, String> {
         // 自增/自减先解析赋值引用：TDZ 绑定抛 ReferenceError；const 抛 TypeError（编译期拦截）。
+        // 循环 update 段的 let/const 循环变量是 per-iteration 可变绑定（CreateMutableBinding），
+        // 规范允许写，故豁免 const 检查（register_update_names 覆盖全部循环头声明名）。
         self.emit_identifier_tdz_guard(name, ctx)?;
-        self.emit_const_write_guard(name, ctx)?;
+        if !ctx.register_update_names.iter().any(|n| n == name) {
+            self.emit_const_write_guard(name, ctx)?;
+        }
         let uv_idx = ctx.current_upvalue_captures.iter().position(|u| u.name == name);
         let captured_cell = ctx.captured_bindings.get(name).copied();
         // 循环 update 段：被捕获绑定走寄存器 INC/DEC（C 风格 for 每迭代 fresh，