Some cosmetic changes

Author: khvzak

src/state.rs

@@ -1127,8 +1127,8 @@ impl Lua {
 
     /// Wraps a Rust async function or closure, creating a callable Lua function handle to it.
     ///
-    /// While executing the function Rust will poll Future and if the result is not ready, call
-    /// `yield()` passing internal representation of a `Poll::Pending` value.
+    /// While executing the function Rust will poll the Future and if the result is not ready,
+    /// call `yield()` passing internal representation of a `Poll::Pending` value.
     ///
     /// The function must be called inside Lua coroutine ([`Thread`]) to be able to suspend its
     /// execution. An executor should be used to poll [`AsyncThread`] and mlua will take a

src/state/raw.rs

@@ -1075,6 +1075,7 @@ impl RawLua {
 
     #[cfg(feature = "async")]
     pub(crate) fn create_async_callback(&self, func: AsyncCallback) -> Result<Function> {
+        // Ensure that the coroutine library is loaded
         #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
         unsafe {
             if !(*self.extra.get()).libs.contains(StdLib::COROUTINE) {
@@ -1130,7 +1131,7 @@ impl RawLua {
                     }
                     Poll::Ready(nresults) => {
                         match nresults? {
-                            nresults @ 0..=2 => {
+                            nresults if nresults < 3 => {
                                 // Fast path for up to 2 results without creating a table
                                 ffi::lua_pushinteger(state, nresults as _);
                                 if nresults > 0 {
@@ -1182,13 +1183,11 @@ impl RawLua {
         let lua = self.lua();
         let coroutine = lua.globals().get::<Table>("coroutine")?;
 
+        // Prepare environment for the async poller
         let env = lua.create_table_with_capacity(0, 3)?;
         env.set("get_poll", get_poll)?;
-        // Cache `yield` function
         env.set("yield", coroutine.get::<Function>("yield")?)?;
-        unsafe {
-            env.set("unpack", lua.create_c_function(unpack)?)?;
-        }
+        env.set("unpack", unsafe { lua.create_c_function(unpack)? })?;
 
         lua.load(
             r#"

tests/async.rs

@@ -75,7 +75,7 @@ async fn test_async_call() -> Result<()> {
 
     match hello.call::<()>("alex") {
         Err(Error::RuntimeError(_)) => {}
-        _ => panic!("non-async executing async function must fail on the yield stage with RuntimeError"),
+        err => panic!("expected `RuntimeError`, got {err:?}"),
     };
 
     assert_eq!(hello.call_async::<String>("alex").await?, "hello, alex!");

tests/function.rs

@@ -168,6 +168,13 @@ fn test_function_environment() -> Result<()> {
     lua.gc_collect()?;
     assert_eq!(lua_func2.call::<String>(())?, "local");
 
+    // Test getting environment set by chunk loader
+    let chunk = lua
+        .load("return hello")
+        .set_environment(lua.create_table_from([("hello", "chunk")])?)
+        .into_function()?;
+    assert_eq!(chunk.environment().unwrap().get::<String>("hello")?, "chunk");
+
     Ok(())
 }