v0.9.1

This causes Lua API correctness check assertion in debug mode.
Fixes #311.

CHANGELOG.md

@@ -1,3 +1,9 @@
+## v0.9.1
+
+- impl Default for Lua
+- impl IntoLuaMulti for `std::result::Result<(), E>`
+- Fix using wrong userdata index after processing Variadic args (#311)
+
 ## v0.9.0
 
 Changes since v0.9.0-rc.3

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.9.0" # remember to update mlua_derive
+version = "0.9.1" # remember to update mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
 rust-version = "1.71"
 edition = "2021"

README.md

@@ -117,7 +117,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.9.0", features = ["lua54", "vendored"] }
+mlua = { version = "0.9.1", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -152,7 +152,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.9.0", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.9.1", features = ["lua54", "module"] }
 ```
 
 `lib.rs` :

src/lua.rs

@@ -282,6 +282,13 @@ impl Deref for Lua {
     }
 }
 
+impl Default for Lua {
+    #[inline]
+    fn default() -> Self {
+        Lua::new()
+    }
+}
+
 impl Lua {
     /// Creates a new Lua state and loads the **safe** subset of the standard libraries.
     ///
@@ -292,7 +299,6 @@ impl Lua {
     /// See [`StdLib`] documentation for a list of unsafe modules that cannot be loaded.
     ///
     /// [`StdLib`]: crate::StdLib
-    #[allow(clippy::new_without_default)]
     pub fn new() -> Lua {
         mlua_expect!(
             Self::new_with(StdLib::ALL_SAFE, LuaOptions::default()),

src/multi.rs

@@ -25,6 +25,21 @@ impl<'lua, T: IntoLua<'lua>, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<
     }
 }
 
+impl<'lua, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<(), E> {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        match self {
+            Ok(_) => return Ok(MultiValue::new()),
+            Err(e) => {
+                let mut result = MultiValue::with_lua_and_capacity(lua, 2);
+                result.push_front(e.into_lua(lua)?);
+                result.push_front(Nil);
+                Ok(result)
+            }
+        }
+    }
+}
+
 impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for T {
     #[inline]
     fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {

src/userdata_impl.rs

@@ -79,10 +79,12 @@ impl<'lua, T: 'static> UserDataRegistry<'lua, T> {
                 let err = Error::from_lua_conversion("missing argument", "userdata", None);
                 try_self_arg!(Err(err));
             }
-            // Self was at index 1, so we pass 2 here
+            let state = lua.state();
+            // Find absolute "self" index before processing args
+            let index = ffi::lua_absindex(state, -nargs);
+            // Self was at position 1, so we pass 2 here
             let args = A::from_stack_args(nargs - 1, 2, Some(&name), lua);
 
-            let (state, index) = (lua.state(), -nargs);
             match try_self_arg!(lua.get_userdata_type_id(index)) {
                 Some(id) if id == TypeId::of::<T>() => {
                     let ud = try_self_arg!(get_userdata_ref::<T>(state, index));
@@ -157,10 +159,12 @@ impl<'lua, T: 'static> UserDataRegistry<'lua, T> {
                 let err = Error::from_lua_conversion("missing argument", "userdata", None);
                 try_self_arg!(Err(err));
             }
-            // Self was at index 1, so we pass 2 here
+            let state = lua.state();
+            // Find absolute "self" index before processing args
+            let index = ffi::lua_absindex(state, -nargs);
+            // Self was at position 1, so we pass 2 here
             let args = A::from_stack_args(nargs - 1, 2, Some(&name), lua);
 
-            let (state, index) = (lua.state(), -nargs);
             match try_self_arg!(lua.get_userdata_type_id(index)) {
                 Some(id) if id == TypeId::of::<T>() => {
                     let mut ud = try_self_arg!(get_userdata_mut::<T>(state, index));

tests/tests.rs

@@ -504,25 +504,32 @@ fn test_result_conversions() -> Result<()> {
     let lua = Lua::new();
     let globals = lua.globals();
 
-    let err = lua.create_function(|_, ()| {
-        Ok(Err::<String, _>(
-            "only through failure can we succeed".into_lua_err(),
-        ))
-    })?;
-    let ok = lua.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))?;
+    let ok = lua.create_function(|_, ()| Ok(Ok::<(), Error>(())))?;
+    let err = lua.create_function(|_, ()| Ok(Err::<(), _>("failure1".into_lua_err())))?;
+    let ok2 = lua.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))?;
+    let err2 = lua.create_function(|_, ()| Ok(Err::<String, _>("failure2".into_lua_err())))?;
 
-    globals.set("err", err)?;
     globals.set("ok", ok)?;
+    globals.set("ok2", ok2)?;
+    globals.set("err", err)?;
+    globals.set("err2", err2)?;
 
     lua.load(
         r#"
+        local r, e = ok()
+        assert(r == nil and e == nil)
+
         local r, e = err()
         assert(r == nil)
-        assert(tostring(e):find("only through failure can we succeed") ~= nil)
+        assert(tostring(e):find("failure1") ~= nil)
 
-        local r, e = ok()
+        local r, e = ok2()
         assert(r == "!")
         assert(e == nil)
+
+        local r, e = err2()
+        assert(r == nil)
+        assert(tostring(e):find("failure2") ~= nil)
     "#,
     )
     .exec()?;

tests/userdata.rs

@@ -15,7 +15,7 @@ use std::sync::atomic::{AtomicI64, Ordering};
 
 use mlua::{
     AnyUserData, AnyUserDataExt, Error, ExternalError, Function, Lua, MetaMethod, Nil, Result,
-    String, UserData, UserDataFields, UserDataMethods, UserDataRef, Value,
+    String, UserData, UserDataFields, UserDataMethods, UserDataRef, Value, Variadic,
 };
 
 #[test]
@@ -92,6 +92,30 @@ fn test_methods() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_method_variadic() -> Result<()> {
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_method("get", |_, data, ()| Ok(data.0));
+            methods.add_method_mut("add", |_, data, vals: Variadic<i64>| {
+                data.0 += vals.into_iter().sum::<i64>();
+                Ok(())
+            });
+        }
+    }
+
+    let lua = Lua::new();
+    let globals = lua.globals();
+    globals.set("userdata", MyUserData(0))?;
+    lua.load("userdata:add(1, 5, -10)").exec()?;
+    let ud: UserDataRef<MyUserData> = globals.get("userdata")?;
+    assert_eq!(ud.0, -4);
+
+    Ok(())
+}
+
 #[test]
 fn test_metamethods() -> Result<()> {
     #[derive(Copy, Clone)]