support to be close

Author: CppCXY

crates/luars/src/lua_vm/dispatcher/control_instructions.rs

@@ -11,8 +11,8 @@ use crate::lua_vm::{Instruction, LuaCallFrame, LuaError, LuaResult, LuaVM};
 pub fn exec_return(vm: &mut LuaVM, instr: u32) -> LuaResult<()> {
     let a = Instruction::get_a(instr) as usize;
     let b = Instruction::get_b(instr) as usize;
-    let _c = Instruction::get_c(instr) as usize;
-    let _k = Instruction::get_k(instr);
+    // let _c = Instruction::get_c(instr) as usize;
+    let k = Instruction::get_k(instr);
 
     // Close upvalues before popping the frame
     let base_ptr = vm.current_frame().base_ptr;
@@ -117,9 +117,11 @@ pub fn exec_return(vm: &mut LuaVM, instr: u32) -> LuaResult<()> {
     }
 
     // Handle upvalue closing (k bit)
-    if _k {
+    if k {
         let close_from = base_ptr + a;
         vm.close_upvalues_from(close_from);
+        // Also call __close metamethods for to-be-closed variables
+        vm.close_to_be_closed(close_from)?;
     }
 
     Ok(())

crates/luars/src/lua_vm/dispatcher/upvalue_instructions.rs

@@ -310,24 +310,14 @@ pub fn exec_tbc(vm: &mut LuaVM, instr: u32) -> LuaResult<()> {
     let a = Instruction::get_a(instr) as usize;
     let frame = vm.current_frame();
     let base_ptr = frame.base_ptr;
+    let reg_idx = base_ptr + a;
 
-    // In a full implementation, we would:
-    // 1. Mark the variable at R[A] as to-be-closed
-    // 2. When the variable goes out of scope (block end, return, etc.),
-    //    call its __close metamethod if it exists
-    //
-    // For now, we just note the variable exists. The __close metamethod
-    // should be called by:
-    // - RETURN instruction (with k bit set)
-    // - End of block (JMP with upvalue closing)
-    // - Error unwinding
-
-    // Check if the value has a __close metamethod (optional validation)
-    let value = vm.register_stack[base_ptr + a];
-    if !value.is_nil() {
-        // We could check for __close metamethod here, but Lua allows
-        // any value to be marked as to-be-closed
-    }
+    // Get the value to be marked as to-be-closed
+    let value = vm.register_stack[reg_idx];
+
+    // Add to to_be_closed stack (will be processed in LIFO order)
+    // Store absolute register index for later closing
+    vm.to_be_closed.push((reg_idx, value));
 
     Ok(())
 }

crates/luars/src/lua_vm/mod.rs

@@ -41,6 +41,10 @@ pub struct LuaVM {
     // Open upvalues list (for closing when frames exit)
     pub(crate) open_upvalues: Vec<Rc<LuaUpvalue>>,
 
+    // To-be-closed variables stack (for __close metamethod)
+    // Stores (register_index, value) pairs that need __close called when they go out of scope
+    pub(crate) to_be_closed: Vec<(usize, LuaValue)>,
+
     // Next frame ID (for tracking frames)
     pub(crate) next_frame_id: usize,
 
@@ -80,6 +84,7 @@ impl LuaVM {
             gc: GC::new(),
             return_values: Vec::new(),
             open_upvalues: Vec::new(),
+            to_be_closed: Vec::new(),
             next_frame_id: 0,
             error_handler: None,
             #[cfg(feature = "loadlib")]
@@ -1129,6 +1134,42 @@ impl LuaVM {
         self.open_upvalues.retain(|uv| uv.is_open());
     }
 
+    /// Call __close metamethods for to-be-closed variables >= stack_pos
+    pub fn close_to_be_closed(&mut self, stack_pos: usize) -> LuaResult<()> {
+        // Process in reverse order (LIFO - last marked is closed first)
+        while let Some(&(reg_idx, value)) = self.to_be_closed.last() {
+            if reg_idx < stack_pos {
+                break;
+            }
+            
+            self.to_be_closed.pop();
+            
+            // Skip nil values
+            if value.is_nil() {
+                continue;
+            }
+            
+            // Try to get __close metamethod
+            let close_key = self.create_string("__close");
+            let metamethod = if let Some(mt) = self.table_get_metatable(&value) {
+                self.table_get_with_meta(&mt, &close_key)
+            } else {
+                None
+            };
+            
+            if let Some(mm) = metamethod {
+                if !mm.is_nil() {
+                    // Call __close(value, error)
+                    // error is nil in normal close, contains error object during unwinding
+                    let args = vec![value, LuaValue::nil()];
+                    // Ignore errors from __close to prevent infinite loops
+                    let _ = self.call_metamethod(&mm, &args);
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Create a new table and register it with GC
     /// Create a string and register it with GC
     /// For short strings (≤64 bytes), use interning (global deduplication)