add retest of continuation/yield across continuation

Author: Your Name

tests/thread.rs

@@ -558,4 +558,188 @@ fn test_large_thread_creation() {
         assert_eq!(th_a, dbg_th1, "Thread {:?} debug format changed for th1", rth);
         assert_eq!(th_b, dbg_th2, "Thread {:?} debug format changed for th2", rth);
     }
+
+    // Repeat yielded continuation test now with a new aux thread
+    // Yielding continuation test (only supported on luau)
+    #[cfg(feature = "luau")]
+    {
+        mlua::Lua::set_fflag("LuauYieldableContinuations", true).unwrap();
+    }
+
+    let cont_func = lua
+        .create_function_with_continuation(
+            |_lua, a: u64| Ok(a + 1),
+            |_lua, _status, a: u64| {
+                println!("Reached cont");
+                Ok(a + 2)
+            },
+        )
+        .expect("Failed to create cont_func");
+
+    // Ensure normal calls work still
+    assert_eq!(
+        lua.load("local cont_func = ...\nreturn cont_func(1)")
+            .call::<u64>(cont_func)
+            .expect("Failed to call cont_func"),
+        2
+    );
+
+    // basic yield test before we go any further
+    let always_yield = lua
+        .create_function(|lua, ()| lua.yield_with((42, "69420".to_string(), 45.6)))
+        .unwrap();
+
+    let thread = lua.create_thread(always_yield).unwrap();
+    assert_eq!(
+        thread.resume::<(i32, String, f32)>(()).unwrap(),
+        (42, String::from("69420"), 45.6)
+    );
+
+    // Trigger the continuation
+    let cont_func = lua
+        .create_function_with_continuation(
+            |lua, a: u64| lua.yield_with(a),
+            |_lua, _status, a: u64| {
+                println!("Reached cont");
+                Ok(a + 39)
+            },
+        )
+        .expect("Failed to create cont_func");
+
+    let luau_func = lua
+        .load(
+            "
+                local cont_func = ...
+                local res = cont_func(1)
+                return res + 1
+            ",
+        )
+        .into_function()
+        .expect("Failed to create function");
+
+    let th = lua
+        .create_thread(luau_func)
+        .expect("Failed to create luau thread");
+
+    let v = th
+        .resume::<mlua::MultiValue>(cont_func)
+        .expect("Failed to resume");
+    let v = th.resume::<i32>(v).expect("Failed to load continuation");
+
+    assert_eq!(v, 41);
+
+    let always_yield = lua
+        .create_function_with_continuation(
+            |lua, ()| lua.yield_with((42, "69420".to_string(), 45.6)),
+            |_lua, _, mv: mlua::MultiValue| {
+                println!("Reached second continuation");
+                if mv.is_empty() {
+                    return Ok(mv);
+                }
+                Err(mlua::Error::external(format!("a{}", mv.len())))
+            },
+        )
+        .unwrap();
+
+    let thread = lua.create_thread(always_yield).unwrap();
+    let mv = thread.resume::<mlua::MultiValue>(()).unwrap();
+    assert!(thread
+        .resume::<String>(mv)
+        .unwrap_err()
+        .to_string()
+        .starts_with("a3"));
+
+    let cont_func = lua
+        .create_function_with_continuation(
+            |lua, a: u64| lua.yield_with((a + 1, 1)),
+            |lua, status, args: mlua::MultiValue| {
+                println!("Reached cont recursive/multiple: {:?}", args);
+
+                if args.len() == 5 {
+                    if cfg!(any(feature = "luau", feature = "lua52")) {
+                        assert_eq!(status, mlua::ContinuationStatus::Ok);
+                    } else {
+                        assert_eq!(status, mlua::ContinuationStatus::Yielded);
+                    }
+                    return Ok(6_i32);
+                }
+
+                lua.yield_with((args.len() + 1, args))?; // thread state becomes LEN, LEN-1... 1
+                Ok(1_i32) // this will be ignored
+            },
+        )
+        .expect("Failed to create cont_func");
+
+    let luau_func = lua
+        .load(
+            "
+                local cont_func = ...
+                local res = cont_func(1)
+                return res + 1
+            ",
+        )
+        .into_function()
+        .expect("Failed to create function");
+    let th = lua
+        .create_thread(luau_func)
+        .expect("Failed to create luau thread");
+
+    let v = th
+        .resume::<mlua::MultiValue>(cont_func)
+        .expect("Failed to resume");
+    println!("v={:?}", v);
+
+    let v = th
+        .resume::<mlua::MultiValue>(v)
+        .expect("Failed to load continuation");
+    println!("v={:?}", v);
+    let v = th
+        .resume::<mlua::MultiValue>(v)
+        .expect("Failed to load continuation");
+    println!("v={:?}", v);
+    let v = th
+        .resume::<mlua::MultiValue>(v)
+        .expect("Failed to load continuation");
+
+    // (2, 1) followed by ()
+    assert_eq!(v.len(), 2 + 3);
+
+    let v = th.resume::<i32>(v).expect("Failed to load continuation");
+
+    assert_eq!(v, 7);
+
+    // test panics
+    let cont_func = lua
+        .create_function_with_continuation(
+            |lua, a: u64| lua.yield_with(a),
+            |_lua, _status, _a: u64| {
+                panic!("Reached continuation which should panic!");
+                #[allow(unreachable_code)]
+                Ok(())
+            },
+        )
+        .expect("Failed to create cont_func");
+
+    let luau_func = lua
+        .load(
+            "
+                local cont_func = ...
+                local ok, res = pcall(cont_func, 1)
+                assert(not ok)
+                return tostring(res)
+            ",
+        )
+        .into_function()
+        .expect("Failed to create function");
+
+    let th = lua
+        .create_thread(luau_func)
+        .expect("Failed to create luau thread");
+
+    let v = th
+        .resume::<mlua::MultiValue>(cont_func)
+        .expect("Failed to resume");
+
+    let v = th.resume::<String>(v).expect("Failed to load continuation");
+    assert!(v.contains("Reached continuation which should panic!"));
 }