mlua_derive: Fix static metamethods shifting arguments in userdata_impl

Author: khvzak

docs/UserData.md

@@ -115,7 +115,29 @@ impl MyType {
     fn __add(&self, other: &Self) -> Self { ... }
 
     #[lua(meta, name = "__call", infallible)]
-    fn construct(lua: &Lua, value: u32) -> Self { ... }
+    fn construct(this: mlua::AnyUserData, value: u32) -> Self { ... }
+}
+```
+
+A metamethod with a `self` receiver is registered via `add_meta_method`
+and behaves like a regular method. A metamethod without a receiver is
+registered via `add_meta_function` and receives exactly the values Lua passes.
+Declare every argument Lua provides, in order:
+
+- Binary metamethods (`__add`, `__sub`, `__eq`, `__concat`, ...) receive both
+  operands, so both must be declared. This is also the way to support reversed
+  operands (e.g. `2 + obj`), where the userdata is the second argument.
+- Method-style metamethods (`__call`, `__index`, `__newindex`, ...) receive the
+  object as their first argument. When registered without a `self` receiver
+  (for example a constructor invoked as `MyType(value)`), declare that leading
+  argument explicitly (typically `mlua::AnyUserData`), even if it is ignored.
+
+```rust,ignore
+#[mlua::userdata_impl]
+impl Vec2 {
+    // No receiver: both operands are declared and passed directly by Lua.
+    #[lua(meta, infallible, name = "__add")]
+    fn add(a: &Vec2, b: &Vec2) -> Vec2 { ... }
 }
 ```
 

mlua_derive/src/userdata/userdata_impl.rs

@@ -654,18 +654,7 @@ fn gen_meta(type_path: &syn::Path, fn_name: &Ident, lua_attr: &LuaAttr, info: &M
         Ok(name) => name,
         Err(err) => return err.to_compile_error(),
     };
-    let closure_params = if matches!(info.self_kind, SelfKind::None) {
-        // Lua always passes `self` to the stack arg, just ignore it.
-        if info.args.is_empty() {
-            quote! { |lua, _this: ::mlua::AnyUserData| }
-        } else {
-            let idents: Vec<_> = info.args.iter().map(|a| &a.ident).collect();
-            let types: Vec<_> = info.args.iter().map(|a| &a.callback_type).collect();
-            quote! { |lua, (_this, #(#idents),*): (::mlua::AnyUserData, #(#types),*) | }
-        }
-    } else {
-        gen_closure_params(info)
-    };
+    let closure_params = gen_closure_params(info);
     let call_args = gen_call_args(info);
     let fn_path = quote! { #type_path::#fn_name };
 
@@ -761,17 +750,7 @@ fn gen_async_meta(
         Ok(name) => name,
         Err(err) => return err.to_compile_error(),
     };
-    let closure_params = if matches!(info.self_kind, SelfKind::None) {
-        if info.args.is_empty() {
-            quote! { |lua, _this: ::mlua::AnyUserData| }
-        } else {
-            let idents: Vec<_> = info.args.iter().map(|a| &a.ident).collect();
-            let types: Vec<_> = info.args.iter().map(|a| &a.callback_type).collect();
-            quote! { |lua, (_this, #(#idents),*): (::mlua::AnyUserData, #(#types),*) | }
-        }
-    } else {
-        gen_async_closure_params(info)
-    };
+    let closure_params = gen_async_closure_params(info);
     let call_args = gen_async_call_args(info);
     let fn_path = quote! { #type_path::#fn_name };
 

tests/userdata_macro.rs

@@ -1,6 +1,6 @@
 #![cfg(feature = "macros")]
 
-use mlua::{Lua, Result, UserData};
+use mlua::{AnyUserData, Lua, Result, UserData};
 
 #[derive(Default, Clone, Debug, UserData)]
 struct Rectangle {
@@ -412,6 +412,65 @@ fn test_known_borrow_wrappers() -> Result<()> {
     Ok(())
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, UserData)]
+struct Vec2 {
+    x: i32,
+    y: i32,
+}
+
+#[mlua::userdata_impl]
+impl Vec2 {
+    #[lua(infallible)]
+    fn new(x: i32, y: i32) -> Self {
+        Vec2 { x, y }
+    }
+
+    #[lua(meta, infallible, name = "__add")]
+    fn add(this: &Vec2, other: &Vec2) -> Vec2 {
+        Vec2 {
+            x: this.x + other.x,
+            y: this.y + other.y,
+        }
+    }
+
+    #[lua(meta, infallible, name = "__eq")]
+    fn eq(this: &Vec2, other: &Vec2) -> bool {
+        this == other
+    }
+
+    #[lua(meta, infallible, name = "__call")]
+    fn call(_lua: &Lua, _proxy: AnyUserData, x: i32, y: i32) -> Vec2 {
+        Self::new(x, y)
+    }
+}
+
+#[test]
+fn test_static_metamethods() {
+    let lua = Lua::new();
+    lua.globals()
+        .set("Vec2", lua.create_proxy::<Vec2>().unwrap())
+        .unwrap();
+    lua.load(
+        r#"
+        local a = Vec2.new(1, 2)
+        local b = Vec2.new(3, 4)
+
+        local c = a + b
+        assert(c.x == 4, "__add x should be 1 + 3 = 4, got " .. tostring(c.x))
+        assert(c.y == 6, "__add y should be 2 + 4 = 6, got " .. tostring(c.y))
+
+        assert(a == Vec2.new(1, 2), "__eq should report vectors equal")
+        assert(a ~= b, "__eq should report vectors unequal")
+
+        -- `__call` on the proxy
+        local d = Vec2(7, 14)
+        assert(d.x == 7 and d.y == 14, "__call should build Vec2(7, 14)")
+    "#,
+    )
+    .exec()
+    .unwrap();
+}
+
 #[cfg(feature = "async")]
 mod async_tests {
     use mlua::{Lua, Result, UserData};