Fix logic to terminate futures on drop.

The underlying Lua thread must stay in yielded state rather than finished.

Author: khvzak

src/state/raw.rs

@@ -1262,7 +1262,7 @@ impl RawLua {
                 if nargs == 1 && ffi::lua_tolightuserdata(state, -1) == Lua::poll_terminate().0 {
                     // Destroy the future and terminate the Lua thread
                     (*upvalue).data.take();
-                    ffi::lua_pushinteger(state, 0);
+                    ffi::lua_pushinteger(state, -1);
                     return Ok(1);
                 }
 
@@ -1347,6 +1347,10 @@ impl RawLua {
                         return res
                     elseif nres == 2 then
                         return res, res2
+                    elseif nres < 0 then
+                        -- Negative `nres` means that the future is terminated
+                        -- It must stay yielded and never be resumed again
+                        yield()
                     else
                         return unpack(res, nres)
                     end

src/thread.rs

@@ -529,6 +529,7 @@ impl<R> Drop for AsyncThread<R> {
                         // The thread is dropped while yielded, resume it with the "terminate" signal
                         ffi::lua_pushlightuserdata(self.thread.1, crate::Lua::poll_terminate().0);
                         if let Ok((new_status, _)) = self.thread.resume_inner(&lua, 1) {
+                            // `new_status` should always be `ThreadStatusInner::Yielded(0)`
                             status = new_status;
                         }
                     }

tests/async.rs

@@ -610,6 +610,36 @@ async fn test_async_task() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_async_task_abort() -> Result<()> {
+    let lua = Lua::new();
+
+    let sleep = lua.create_async_function(move |_lua, n: u64| async move {
+        sleep_ms(n).await;
+        Ok(())
+    })?;
+    lua.globals().set("sleep", sleep)?;
+
+    let local = tokio::task::LocalSet::new();
+    local
+        .run_until(async {
+            let lua2 = lua.clone();
+            let jh = tokio::task::spawn_local(async move {
+                lua2.load("sleep(200) result = 'done'")
+                    .exec_async()
+                    .await
+                    .unwrap();
+            });
+            sleep_ms(100).await; // Wait for the task to start
+            jh.abort();
+        })
+        .await;
+    local.await;
+    assert_eq!(lua.globals().get::<Value>("result")?, Value::Nil);
+
+    Ok(())
+}
+
 #[tokio::test]
 #[cfg(not(feature = "luau"))]
 async fn test_async_hook() -> Result<()> {