fix yieldable continuation on non-luau

Author: Your Name

src/state/extra.rs

@@ -98,9 +98,6 @@ pub(crate) struct ExtraData {
 
     // Values currently being yielded from Lua.yield()
     pub(super) yielded_values: Option<MultiValue>,
-
-    #[cfg(all(not(feature = "luau"), not(feature = "lua51"), not(feature = "luajit")))]
-    pub(super) yield_continuation: bool,
 }
 
 impl Drop for ExtraData {
@@ -203,8 +200,6 @@ impl ExtraData {
             #[cfg(feature = "luau")]
             running_gc: false,
             yielded_values: None,
-            #[cfg(all(not(feature = "luau"), not(feature = "lua51"), not(feature = "luajit")))]
-            yield_continuation: false,
         }));
 
         // Store it in the registry

src/state/raw.rs

@@ -1164,15 +1164,21 @@ impl RawLua {
     pub(crate) fn create_callback(&self, func: Callback) -> Result<Function> {
         unsafe extern "C-unwind" fn call_callback(state: *mut ffi::lua_State) -> c_int {
             let upvalue = get_userdata::<CallbackUpvalue>(state, ffi::lua_upvalueindex(1));
-            callback_error_ext_yieldable(state, (*upvalue).extra.get(), true, |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();
-                match (*upvalue).data {
-                    Some(ref func) => func(rawlua, nargs),
-                    None => Err(Error::CallbackDestructed),
-                }
-            })
+            callback_error_ext_yieldable(
+                state,
+                (*upvalue).extra.get(),
+                true,
+                |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();
+                    match (*upvalue).data {
+                        Some(ref func) => func(rawlua, nargs),
+                        None => Err(Error::CallbackDestructed),
+                    }
+                },
+                false,
+            )
         }
 
         let state = self.state();
@@ -1260,21 +1266,22 @@ impl RawLua {
         {
             unsafe extern "C-unwind" fn call_callback(state: *mut ffi::lua_State) -> c_int {
                 let upvalue = get_userdata::<ContinuationUpvalue>(state, ffi::lua_upvalueindex(1));
-                callback_error_ext_yieldable(state, (*upvalue).extra.get(), true, |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();
-                    match (*upvalue).data {
-                        Some((ref func, _)) => match func(rawlua, nargs) {
-                            Ok(r) => {
-                                (*extra).yield_continuation = true;
-                                Ok(r)
-                            }
-                            Err(e) => Err(e),
-                        },
-                        None => Err(Error::CallbackDestructed),
-                    }
-                })
+                callback_error_ext_yieldable(
+                    state,
+                    (*upvalue).extra.get(),
+                    true,
+                    |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();
+                        match (*upvalue).data {
+                            Some((ref func, _)) => func(rawlua, nargs),
+                            None => Err(Error::CallbackDestructed),
+                        }
+                    },
+                    true,
+                )
             }
 
             let state = self.state();

src/state/util.rs

@@ -115,8 +115,6 @@ where
         Ok(Ok(r)) => {
             // Ensure yielded values are cleared
             take(&mut extra.as_mut().unwrap_unchecked().yielded_values);
-            #[cfg(all(not(feature = "luau"), not(feature = "lua51"), not(feature = "luajit")))]
-            take(&mut extra.as_mut().unwrap_unchecked().yield_continuation);
 
             // Return unused `WrappedFailure` to the pool
             prealloc_failure.release(state, extra);
@@ -170,6 +168,7 @@ pub(crate) unsafe fn callback_error_ext_yieldable<F>(
     mut extra: *mut ExtraData,
     wrap_error: bool,
     f: F,
+    in_callback_with_continuation: bool,
 ) -> c_int
 where
     F: FnOnce(*mut ExtraData, c_int) -> Result<c_int>,
@@ -193,9 +192,6 @@ where
             let raw = extra.as_ref().unwrap_unchecked().raw_lua();
             let values = take(&mut extra.as_mut().unwrap_unchecked().yielded_values);
 
-            #[cfg(all(not(feature = "luau"), not(feature = "lua51"), not(feature = "luajit")))]
-            let yield_cont = take(&mut extra.as_mut().unwrap_unchecked().yield_continuation);
-
             if let Some(values) = values {
                 if raw.state() == state {
                     // Edge case: main thread is being yielded
@@ -230,7 +226,7 @@ where
                         {
                             // Yield to a continuation. Unlike luau, we need to do this manually and on the
                             // fly using a yieldk call
-                            if yield_cont {
+                            if in_callback_with_continuation {
                                 // On Lua 5.2, status and ctx are not present, so use 0 as status for
                                 // compatibility
                                 #[cfg(feature = "lua52")]
@@ -253,6 +249,7 @@ where
                                                 None => Err(Error::CallbackDestructed),
                                             }
                                         },
+                                        true,
                                     )
                                 }
 
@@ -279,6 +276,7 @@ where
                                                 None => Err(Error::CallbackDestructed),
                                             }
                                         },
+                                        true,
                                     )
                                 }