support cclosure

Author: CppCXY

crates/luars/src/gc/gc_object.rs

@@ -165,11 +165,78 @@ pub struct GcTable {
     pub data: LuaTable,
 }
 
-/// Lua function with embedded GC header
+/// C Function type - Rust function callable from Lua
+pub type CFunction = fn(&mut crate::lua_vm::LuaVM) -> crate::lua_vm::LuaResult<crate::lua_value::MultiValue>;
+
+/// Function body - either Lua bytecode or C function
+pub enum FunctionBody {
+    /// Lua function with bytecode chunk
+    Lua(Rc<Chunk>),
+    /// C function (native Rust function) - no upvalues
+    C(CFunction),
+    /// C closure with single inline upvalue (fast path for common case)
+    /// Used by coroutine.wrap, ipairs iterator, etc.
+    CClosureInline1(CFunction, LuaValue),
+}
+
+/// Unified function with embedded GC header
+/// Supports both Lua closures and C closures (with upvalues)
 pub struct GcFunction {
     pub header: GcHeader,
-    pub chunk: Rc<Chunk>,
-    pub upvalues: Vec<UpvalueId>, // Upvalue IDs, not Rc
+    pub body: FunctionBody,
+    pub upvalues: Vec<UpvalueId>, // Upvalue IDs - used for Lua closures and C closures with >1 upvalue
+}
+
+impl GcFunction {
+    /// Check if this is a C function (any C variant)
+    #[inline(always)]
+    pub fn is_c_function(&self) -> bool {
+        matches!(self.body, FunctionBody::C(_) | FunctionBody::CClosureInline1(_, _))
+    }
+    
+    /// Check if this is a Lua function
+    #[inline(always)]
+    pub fn is_lua_function(&self) -> bool {
+        matches!(self.body, FunctionBody::Lua(_))
+    }
+    
+    /// Get the chunk if this is a Lua function
+    #[inline(always)]
+    pub fn chunk(&self) -> Option<&Rc<Chunk>> {
+        match &self.body {
+            FunctionBody::Lua(chunk) => Some(chunk),
+            _ => None,
+        }
+    }
+    
+    /// Get the chunk reference for Lua functions (panics if C function)
+    /// Use this in contexts where we know it's a Lua function
+    #[inline(always)]
+    pub fn lua_chunk(&self) -> &Rc<Chunk> {
+        match &self.body {
+            FunctionBody::Lua(chunk) => chunk,
+            _ => panic!("Called lua_chunk() on a C function"),
+        }
+    }
+    
+    /// Get the C function pointer if this is any C function variant
+    #[inline(always)]
+    pub fn c_function(&self) -> Option<CFunction> {
+        match &self.body {
+            FunctionBody::C(f) => Some(*f),
+            FunctionBody::CClosureInline1(f, _) => Some(*f),
+            FunctionBody::Lua(_) => None,
+        }
+    }
+    
+    /// Get inline upvalue 1 for CClosureInline1
+    #[inline(always)]
+    pub fn inline_upvalue1(&self) -> Option<LuaValue> {
+        match &self.body {
+            FunctionBody::CClosureInline1(_, uv) => Some(*uv),
+            _ => None,
+        }
+    }
 }
 
 /// Upvalue state - uses absolute stack index like Lua C implementation

crates/luars/src/gc/mod.rs

@@ -532,7 +532,8 @@ impl GC {
             GcObjectType::Function => {
                 if let Some(func) = pool.functions.get(gc_id.index()) {
                     let upvalue_ids = func.upvalues.clone();
-                    let constants = func.chunk.constants.clone();
+                    // C closures don't have constants
+                    let constants = func.chunk().map(|c| c.constants.clone()).unwrap_or_default();
 
                     if let Some(f) = pool.functions.get_mut(gc_id.index()) {
                         if f.header.is_gray() {
@@ -1146,7 +1147,9 @@ impl GC {
                         let (should_mark, upvalue_ids, constants) = {
                             if let Some(func) = pool.functions.get(id.0) {
                                 if func.header.is_white() {
-                                    (true, func.upvalues.clone(), func.chunk.constants.clone())
+                                    // C closures don't have constants
+                                    let consts = func.chunk().map(|c| c.constants.clone()).unwrap_or_default();
+                                    (true, func.upvalues.clone(), consts)
                                 } else {
                                     (false, vec![], vec![])
                                 }

crates/luars/src/gc/object_pool.rs

@@ -13,6 +13,7 @@ use crate::{
     FunctionId, GcFunction, GcHeader, GcString, GcTable, GcThread, GcUpvalue, LuaString, LuaTable,
     LuaValue, StringId, TableId, ThreadId, UpvalueId, UpvalueState, UserdataId,
 };
+use crate::gc::gc_object::{FunctionBody, CFunction};
 use std::rc::Rc;
 
 // ============ Pool Storage ============
@@ -1025,15 +1026,39 @@ impl ObjectPool {
 
     // ==================== Function Operations ====================
 
+    /// Create a Lua function (closure with bytecode chunk)
     #[inline]
     pub fn create_function(&mut self, chunk: Rc<Chunk>, upvalue_ids: Vec<UpvalueId>) -> FunctionId {
         let gc_func = GcFunction {
             header: GcHeader::default(),
-            chunk,
+            body: FunctionBody::Lua(chunk),
             upvalues: upvalue_ids,
         };
         FunctionId(self.functions.alloc(gc_func))
     }
+    
+    /// Create a C closure (native function with upvalues)
+    #[inline]
+    pub fn create_c_closure(&mut self, func: CFunction, upvalue_ids: Vec<UpvalueId>) -> FunctionId {
+        let gc_func = GcFunction {
+            header: GcHeader::default(),
+            body: FunctionBody::C(func),
+            upvalues: upvalue_ids,
+        };
+        FunctionId(self.functions.alloc(gc_func))
+    }
+    
+    /// Create a C closure with single inline upvalue (fast path)
+    /// This avoids UpvalueId allocation for common single-upvalue C closures
+    #[inline]
+    pub fn create_c_closure_inline1(&mut self, func: CFunction, upvalue: LuaValue) -> FunctionId {
+        let gc_func = GcFunction {
+            header: GcHeader::default(),
+            body: FunctionBody::CClosureInline1(func, upvalue),
+            upvalues: Vec::new(),
+        };
+        FunctionId(self.functions.alloc(gc_func))
+    }
 
     #[inline(always)]
     pub fn get_function(&self, id: FunctionId) -> Option<&GcFunction> {