Allow #[mlua::userdata_impl] in a different module than the type

`#[derive(UserData)]` used to emit a private `__MluaUserDataRegistration_<Type>`
struct next to the type and `#[mlua::userdata_impl]` referred to it by bare
identifier, so the impl block had to sit in the same module as the derive.
Splitting a type from its Lua bindings failed with:

    error[E0422]: cannot find struct, variant or union type
    `__MluaUserDataRegistration_A` in this scope

Collect the registrations through the type instead: the derive implements the
hidden `UserDataRegistrar` trait, which owns the type's inventory registry, and
both macros submit `UserDataRegistration::<Type>` entries. The type is always in
scope where the impl block is written, so registrations now resolve from any
module, including through `use` aliases and fully qualified paths.

Closes #726

Author: teddytennant

docs/UserData.md

@@ -57,6 +57,9 @@ Use `#[mlua::userdata_impl]` on an `impl` block to register methods,
 metamethods, and constants. All items in the block are registered automatically,
 regardless of visibility.
 
+Multiple `impl` blocks are supported and they do not need to live in the same
+module as the type definition.
+
 ## Method detection
 
 The receiver type determines how a method is registered:

mlua_derive/src/userdata/mod.rs

@@ -131,31 +131,31 @@ pub fn userdata_type(item: TokenStream) -> TokenStream {
         }
     }
 
-    let registration_type_name = format_ident!("__MluaUserDataRegistration_{type_name}");
     let register_fields_fn_name = format_ident!("__mlua_register_{type_name}_fields");
 
     let output = quote! {
-        #[doc(hidden)]
-        #[allow(non_camel_case_types)]
-        struct #registration_type_name {
-            register: fn(&mut ::mlua::userdata::UserDataRegistry<#type_name>),
+        // Registrations are collected through the type itself, so that `#[mlua::userdata_impl]`
+        // can submit them from any module.
+        impl ::mlua::userdata::UserDataRegistrar for #type_name {
+            fn inventory_registry() -> &'static ::mlua::__inventory::Registry {
+                static REGISTRY: ::mlua::__inventory::Registry = ::mlua::__inventory::Registry::new();
+                &REGISTRY
+            }
         }
 
-        ::mlua::__inventory::collect!(#registration_type_name);
-
         #[allow(non_snake_case)]
         fn #register_fields_fn_name(registry: &mut ::mlua::userdata::UserDataRegistry<#type_name>) {
             use ::mlua::userdata::UserDataFields as _;
             #(#field_registrations)*
         }
 
         ::mlua::__inventory::submit! {
-            #registration_type_name { register: #register_fields_fn_name }
+            ::mlua::userdata::UserDataRegistration::<#type_name> { register: #register_fields_fn_name }
         }
 
         impl ::mlua::userdata::UserData for #type_name {
             fn register(registry: &mut ::mlua::userdata::UserDataRegistry<Self>) {
-                for item in ::mlua::__inventory::iter::<#registration_type_name> {
+                for item in ::mlua::__inventory::iter::<::mlua::userdata::UserDataRegistration<#type_name>> {
                     (item.register)(registry);
                 }
             }

mlua_derive/src/userdata/userdata_impl.rs

@@ -323,7 +323,6 @@ pub fn userdata_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
     static COUNTER: AtomicUsize = AtomicUsize::new(0);
     let unique_suffix = COUNTER.fetch_add(1, Ordering::Relaxed);
     let register_fn_name = format_ident!("__mlua_register_{type_name}_{unique_suffix}");
-    let registration_type_name = format_ident!("__MluaUserDataRegistration_{type_name}");
 
     let mut registration_calls = Vec::new();
     for item in &input.items {
@@ -522,7 +521,7 @@ pub fn userdata_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
         }
 
         ::mlua::__inventory::submit! {
-            #registration_type_name { register: #register_fn_name }
+            ::mlua::userdata::UserDataRegistration::<#type_path> { register: #register_fn_name }
         }
 
         #input

src/userdata.rs

@@ -33,6 +33,9 @@ pub(crate) use cell::UserDataStorage;
 pub use r#ref::{UserDataOwned, UserDataRef, UserDataRefMut};
 pub use registry::UserDataRegistry;
 pub(crate) use registry::{RawUserDataRegistry, UserDataProxy};
+#[cfg(feature = "macros")]
+#[doc(hidden)]
+pub use registry::{UserDataRegistrar, UserDataRegistration};
 pub(crate) use util::{
     TypeIdHints, borrow_userdata_scoped, borrow_userdata_scoped_mut, collect_userdata,
     init_userdata_metatable,

src/userdata/registry.rs

@@ -677,6 +677,40 @@ lua_userdata_impl!(std::sync::Arc<parking_lot::Mutex<T>>);
 #[cfg(feature = "userdata-wrappers")]
 lua_userdata_impl!(std::sync::Arc<parking_lot::RwLock<T>>);
 
+/// A single registration function collected by the `mlua` derive macros.
+///
+/// This is not part of the public API.
+#[cfg(feature = "macros")]
+#[doc(hidden)]
+pub struct UserDataRegistration<T> {
+    pub register: fn(&mut UserDataRegistry<T>),
+}
+
+/// Links a userdata type to the inventory registry holding its registrations.
+///
+/// Implemented by `#[derive(UserData)]`, which is what allows `#[mlua::userdata_impl]` to submit
+/// registrations through the type itself rather than through a name that is only reachable from the
+/// module where the type is defined.
+///
+/// This is not part of the public API.
+#[cfg(feature = "macros")]
+#[doc(hidden)]
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is missing `#[derive(UserData)]`",
+    note = "`#[mlua::userdata_impl]` requires the type to derive `UserData`"
+)]
+pub trait UserDataRegistrar: Sized + 'static {
+    fn inventory_registry() -> &'static inventory::Registry;
+}
+
+#[cfg(feature = "macros")]
+impl<T: UserDataRegistrar> inventory::Collect for UserDataRegistration<T> {
+    #[inline]
+    fn registry() -> &'static inventory::Registry {
+        T::inventory_registry()
+    }
+}
+
 #[cfg(test)]
 mod assertions {
     #[cfg(feature = "send")]

tests/userdata_macro.rs

@@ -569,6 +569,53 @@ fn test_wildcard_params() {
     .unwrap();
 }
 
+// The type definition and its Lua bindings can live in different modules.
+mod counter_type {
+    use mlua::UserData;
+
+    #[derive(Clone, Debug, UserData)]
+    pub struct Counter {
+        pub count: u32,
+    }
+}
+
+mod counter_bindings {
+    use mlua::Result;
+
+    use super::counter_type::Counter;
+
+    #[mlua::userdata_impl]
+    impl Counter {
+        #[lua(infallible)]
+        fn new() -> Counter {
+            Counter { count: 0 }
+        }
+
+        fn increment(&mut self) -> Result<u32> {
+            self.count += 1;
+            Ok(self.count)
+        }
+    }
+}
+
+#[test]
+fn test_impl_in_other_module() {
+    let lua = Lua::new();
+    lua.globals()
+        .set("Counter", lua.create_proxy::<counter_type::Counter>().unwrap())
+        .unwrap();
+    lua.load(
+        r#"
+        local c = Counter.new()
+        assert(c:increment() == 1, "increment should return 1")
+        assert(c:increment() == 2, "increment should return 2")
+        assert(c.count == 2, "field registered by the derive should be visible too")
+    "#,
+    )
+    .exec()
+    .unwrap();
+}
+
 #[cfg(feature = "async")]
 mod async_tests {
     use mlua::{Lua, Result, UserData};