Turn Lua::entrypoint() to constructor (don't require initializing Lua first)

Author: khvzak

mlua_derive/src/lib.rs

@@ -64,9 +64,10 @@ pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
 
         #[no_mangle]
         unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut mlua::lua_State) -> ::std::os::raw::c_int {
-            let lua = mlua::Lua::init_from_ptr(state);
-            #skip_memory_check
-            lua.entrypoint1(state, #func_name)
+            mlua::Lua::entrypoint1(state, move |lua| {
+                #skip_memory_check
+                #func_name(lua)
+            })
         }
     };
 

src/state.rs

@@ -356,36 +356,37 @@ impl Lua {
     // The returned value then pushed onto the stack.
     #[doc(hidden)]
     #[cfg(not(tarpaulin_include))]
-    pub unsafe fn entrypoint<F, A, R>(self, state: *mut ffi::lua_State, func: F) -> c_int
+    pub unsafe fn entrypoint<F, A, R>(state: *mut ffi::lua_State, func: F) -> c_int
     where
-        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        F: FnOnce(&Lua, A) -> Result<R>,
         A: FromLuaMulti,
         R: IntoLua,
     {
-        let extra = self.lock().extra.get();
-        // `self` is no longer needed and must be dropped at this point to avoid possible memory leak
+        // Make sure that Lua is initialized
+        let mut lua = Self::init_from_ptr(state);
+        lua.collect_garbage = false;
+        // `Lua` is no longer needed and must be dropped at this point to avoid possible memory leak
         // in case of possible longjmp (lua_error) below
-        drop(self);
-
-        callback_error_ext(state, extra, move |nargs| {
-            let lua = (*extra).lua();
-            let rawlua = lua.lock();
-            let _guard = StateGuard::new(&rawlua, state);
-            let args = A::from_stack_args(nargs, 1, None, &rawlua)?;
-            func(lua, args)?.push_into_stack(&rawlua)?;
+        drop(lua);
+
+        callback_error_ext(state, ptr::null_mut(), move |extra, nargs| {
+            let rawlua = (*extra).raw_lua();
+            let _guard = StateGuard::new(rawlua, state);
+            let args = A::from_stack_args(nargs, 1, None, rawlua)?;
+            func(rawlua.lua(), args)?.push_into_stack(rawlua)?;
             Ok(1)
         })
     }
 
     // A simple module entrypoint without arguments
     #[doc(hidden)]
     #[cfg(not(tarpaulin_include))]
-    pub unsafe fn entrypoint1<R, F>(self, state: *mut ffi::lua_State, func: F) -> c_int
+    pub unsafe fn entrypoint1<F, R>(state: *mut ffi::lua_State, func: F) -> c_int
     where
+        F: FnOnce(&Lua) -> Result<R>,
         R: IntoLua,
-        F: Fn(&Lua) -> Result<R> + MaybeSend + 'static,
     {
-        self.entrypoint(state, move |lua, _: ()| func(lua))
+        Self::entrypoint(state, move |lua, _: ()| func(lua))
     }
 
     /// Skips memory checks for some operations.
@@ -575,8 +576,7 @@ impl Lua {
                 // We don't support GC interrupts since they cannot survive Lua exceptions
                 return;
             }
-            let extra = ExtraData::get(state);
-            let result = callback_error_ext(state, extra, move |_| {
+            let result = callback_error_ext(state, ptr::null_mut(), move |extra, _| {
                 let interrupt_cb = (*extra).interrupt_callback.clone();
                 let interrupt_cb = mlua_expect!(interrupt_cb, "no interrupt callback set in interrupt_proc");
                 if Rc::strong_count(&interrupt_cb) > 2 {
@@ -629,7 +629,7 @@ impl Lua {
 
         unsafe extern "C-unwind" fn warn_proc(ud: *mut c_void, msg: *const c_char, tocont: c_int) {
             let extra = ud as *mut ExtraData;
-            callback_error_ext((*extra).raw_lua().state(), extra, |_| {
+            callback_error_ext((*extra).raw_lua().state(), extra, |extra, _| {
                 let cb = mlua_expect!(
                     (*extra).warn_callback.as_ref(),
                     "no warning callback set in warn_proc"

src/state/raw.rs

@@ -360,7 +360,7 @@ impl RawLua {
                 ffi::lua_sethook(state, None, 0, 0);
                 return;
             }
-            callback_error_ext(state, extra, move |_| {
+            callback_error_ext(state, extra, move |extra, _| {
                 let hook_cb = (*extra).hook_callback.clone();
                 let hook_cb = mlua_expect!(hook_cb, "no hook callback set in hook_proc");
                 if std::rc::Rc::strong_count(&hook_cb) > 2 {
@@ -1038,7 +1038,7 @@ impl RawLua {
                 }
                 _ => (ptr::null_mut(), ptr::null_mut()),
             };
-            callback_error_ext(state, extra, |nargs| {
+            callback_error_ext(state, extra, |extra, nargs| {
                 // Lua ensures that `LUA_MINSTACK` stack spaces are available (after pushing arguments)
                 if upvalue.is_null() {
                     return Err(Error::CallbackDestructed);
@@ -1089,7 +1089,7 @@ impl RawLua {
             // so the first upvalue is always valid
             let upvalue = get_userdata::<AsyncCallbackUpvalue>(state, ffi::lua_upvalueindex(1));
             let extra = (*upvalue).extra.get();
-            callback_error_ext(state, extra, |nargs| {
+            callback_error_ext(state, extra, |extra, nargs| {
                 // Lua ensures that `LUA_MINSTACK` stack spaces are available (after pushing arguments)
                 // The lock must be already held as the callback is executed
                 let rawlua = (*extra).raw_lua();
@@ -1114,8 +1114,7 @@ impl RawLua {
 
         unsafe extern "C-unwind" fn poll_future(state: *mut ffi::lua_State) -> c_int {
             let upvalue = get_userdata::<AsyncPollUpvalue>(state, ffi::lua_upvalueindex(1));
-            let extra = (*upvalue).extra.get();
-            callback_error_ext(state, extra, |_| {
+            callback_error_ext(state, (*upvalue).extra.get(), |extra, _| {
                 // Lua ensures that `LUA_MINSTACK` stack spaces are available (after pushing arguments)
                 // The lock must be already held as the future is polled
                 let rawlua = (*extra).raw_lua();

src/state/util.rs

@@ -32,7 +32,7 @@ pub(super) unsafe fn callback_error_ext<F, R>(
     f: F,
 ) -> R
 where
-    F: FnOnce(c_int) -> Result<R>,
+    F: FnOnce(*mut ExtraData, c_int) -> Result<R>,
 {
     if extra.is_null() {
         extra = ExtraData::get(state);
@@ -113,7 +113,7 @@ where
     // to store a wrapped failure (error or panic) *before* we proceed.
     let prealloc_failure = PreallocatedFailure::reserve(state, extra);
 
-    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
+    match catch_unwind(AssertUnwindSafe(|| f(extra, nargs))) {
         Ok(Ok(r)) => {
             // Return unused `WrappedFailure` to the pool
             prealloc_failure.release(state, extra);