mlua_derive: Support wildcard params and reject invalid impls in userdata_impl

Author: khvzak

mlua_derive/src/userdata/userdata_impl.rs

@@ -168,51 +168,64 @@ fn analyze_self_and_args(sig: &Signature) -> syn::Result<MethodInfo> {
                     }
                 }
 
-                if let syn::Pat::Ident(pat_ident) = &*typed.pat {
-                    let arg_type = &*typed.ty;
-                    let mut option_inner = None;
-                    let ref_kind = match arg_type {
-                        Type::Reference(r) if r.mutability.is_some() => Some(RefKind::Mut),
-                        Type::Reference(_) => Some(RefKind::Ref),
-                        _ => {
-                            // Check if it's `Option<&T>` or `Option<&mut T>`
-                            option_inner = try_unwrap_option(arg_type);
-                            option_inner.and_then(|inner| match inner {
-                                Type::Reference(r) if r.mutability.is_some() => Some(RefKind::OptionMut),
-                                Type::Reference(_) => Some(RefKind::OptionRef),
-                                _ => None,
-                            })
-                        }
-                    };
-                    let callback_type = match &ref_kind {
-                        Some(RefKind::OptionRef | RefKind::OptionMut) => {
-                            match classify_ref_type(option_inner.unwrap()) {
-                                Some(ty) => parse_quote! { Option<#ty> },
-                                None => {
-                                    return Err(syn::Error::new_spanned(
-                                        arg_type,
-                                        "this reference type is not supported as a callback parameter",
-                                    ));
-                                }
-                            }
-                        }
-                        Some(_) => match classify_ref_type(arg_type) {
-                            Some(ty) => ty,
+                let ident = match &*typed.pat {
+                    syn::Pat::Ident(pat_ident) => pat_ident.ident.clone(),
+                    syn::Pat::Wild(_) => {
+                        // For wildcards we generate a unique identifier to avoid collisions with other
+                        // parameters.
+                        Ident::new(&format!("__mlua_arg_{}", args.len()), Span2::mixed_site())
+                    }
+                    _ => {
+                        return Err(syn::Error::new_spanned(
+                            &typed.pat,
+                            "`#[mlua::userdata_impl]` requires a named parameter or `_`; destructuring patterns are not supported",
+                        ));
+                    }
+                };
+
+                let arg_type = &*typed.ty;
+                let mut option_inner = None;
+                let ref_kind = match arg_type {
+                    Type::Reference(r) if r.mutability.is_some() => Some(RefKind::Mut),
+                    Type::Reference(_) => Some(RefKind::Ref),
+                    _ => {
+                        // Check if it's `Option<&T>` or `Option<&mut T>`
+                        option_inner = try_unwrap_option(arg_type);
+                        option_inner.and_then(|inner| match inner {
+                            Type::Reference(r) if r.mutability.is_some() => Some(RefKind::OptionMut),
+                            Type::Reference(_) => Some(RefKind::OptionRef),
+                            _ => None,
+                        })
+                    }
+                };
+                let callback_type = match &ref_kind {
+                    Some(RefKind::OptionRef | RefKind::OptionMut) => {
+                        match classify_ref_type(option_inner.unwrap()) {
+                            Some(ty) => parse_quote! { Option<#ty> },
                             None => {
                                 return Err(syn::Error::new_spanned(
                                     arg_type,
                                     "this reference type is not supported as a callback parameter",
                                 ));
                             }
-                        },
-                        None => arg_type.clone(),
-                    };
-                    args.push(ArgInfo {
-                        ident: pat_ident.ident.clone(),
-                        userdata_ref: ref_kind,
-                        callback_type,
-                    });
-                }
+                        }
+                    }
+                    Some(_) => match classify_ref_type(arg_type) {
+                        Some(ty) => ty,
+                        None => {
+                            return Err(syn::Error::new_spanned(
+                                arg_type,
+                                "this reference type is not supported as a callback parameter",
+                            ));
+                        }
+                    },
+                    None => arg_type.clone(),
+                };
+                args.push(ArgInfo {
+                    ident,
+                    userdata_ref: ref_kind,
+                    callback_type,
+                });
             }
         }
     }
@@ -275,6 +288,24 @@ pub fn userdata_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
 
     let mut input = parse_macro_input!(item as ItemImpl);
 
+    // Generic impl blocks are not supported
+    if !input.generics.params.is_empty() {
+        return syn::Error::new_spanned(
+            &input.generics,
+            "`#[mlua::userdata_impl]` does not support generic impl blocks.",
+        )
+        .to_compile_error()
+        .into();
+    }
+    if let Some(where_clause) = &input.generics.where_clause {
+        return syn::Error::new_spanned(
+            where_clause,
+            "`#[mlua::userdata_impl]` does not support `where` clauses on the impl block.",
+        )
+        .to_compile_error()
+        .into();
+    }
+
     let type_path = match &*input.self_ty {
         Type::Path(type_path) => &type_path.path,
         _ => {

tests/compile.rs

@@ -34,6 +34,8 @@ fn test_compilation() {
         t.compile_fail("tests/compile/userdata_setter_no_value.rs");
         t.compile_fail("tests/compile/userdata_static_with_self.rs");
         t.compile_fail("tests/compile/userdata_meta_owned_self.rs");
+        t.compile_fail("tests/compile/userdata_destructuring_arg.rs");
+        t.compile_fail("tests/compile/userdata_generic_impl.rs");
         t.compile_fail("tests/compile/userdata_const_getter.rs");
         t.compile_fail("tests/compile/userdata_field_with_args.rs");
     }

tests/compile/userdata_destructuring_arg.rs

@@ -0,0 +1,14 @@
+#[derive(mlua::UserData)]
+struct Foo {
+    x: u32,
+}
+
+#[mlua::userdata_impl]
+impl Foo {
+    #[lua(infallible)]
+    fn takes_pattern(&self, (a, b): (u32, u32)) -> u32 {
+        self.x + a + b
+    }
+}
+
+fn main() {}

tests/compile/userdata_destructuring_arg.stderr

@@ -0,0 +1,5 @@
+error: `#[mlua::userdata_impl]` requires a named parameter or `_`; destructuring patterns are not supported
+ --> tests/compile/userdata_destructuring_arg.rs:9:29
+  |
+9 |     fn takes_pattern(&self, (a, b): (u32, u32)) -> u32 {
+  |                             ^^^^^^

tests/compile/userdata_generic_impl.rs

@@ -0,0 +1,14 @@
+#[derive(mlua::UserData)]
+struct Foo {
+    x: u32,
+}
+
+#[mlua::userdata_impl]
+impl<T> Foo<T> {
+    #[lua(infallible)]
+    fn get(&self) -> u32 {
+        self.x
+    }
+}
+
+fn main() {}

tests/compile/userdata_generic_impl.stderr

@@ -0,0 +1,5 @@
+error: `#[mlua::userdata_impl]` does not support generic impl blocks.
+ --> tests/compile/userdata_generic_impl.rs:7:5
+  |
+7 | impl<T> Foo<T> {
+  |     ^^^

tests/userdata_macro.rs

@@ -528,6 +528,47 @@ fn test_param_name_hygiene() {
     .unwrap();
 }
 
+#[derive(Clone, Debug, UserData)]
+struct Wild {
+    n: i32,
+}
+
+#[mlua::userdata_impl]
+impl Wild {
+    #[lua(infallible)]
+    fn new(n: i32) -> Self {
+        Wild { n }
+    }
+
+    #[lua(infallible)]
+    fn ignore_one(&self, _: i32) -> i32 {
+        self.n
+    }
+
+    #[lua(infallible)]
+    fn add_second(&self, _: i32, other: &Wild) -> i32 {
+        self.n + other.n
+    }
+}
+
+#[test]
+fn test_wildcard_params() {
+    let lua = Lua::new();
+    lua.globals()
+        .set("Wild", lua.create_proxy::<Wild>().unwrap())
+        .unwrap();
+    lua.load(
+        r#"
+        local w = Wild.new(7)
+        assert(w:ignore_one(99) == 7, "single wildcard arg should be ignored")
+        assert(w:add_second(1, Wild.new(5)) == 12, "named arg after a wildcard should work")
+        assert(not pcall(function() return w:ignore_one({}) end), "wildcard arg is still type-checked")
+    "#,
+    )
+    .exec()
+    .unwrap();
+}
+
 #[cfg(feature = "async")]
 mod async_tests {
     use mlua::{Lua, Result, UserData};