Suggestion: proc_macro for LuaUserDataMethods::add_method #288

Activity

1. jugglerchris commented on Dec 2, 2023

   

   jugglerchris

   on Dec 2, 2023

   Collaborator

   More actions

   That does look like it'd make lots of bindings much nicer!
2. Caellian commented on Dec 3, 2023

   

   Caellian

   on Dec 3, 2023

   Last edited by Caellian

   Author

   More actions

   For reference, I wrote a macro for registering global constructor functions for my bindings which basically does the alternative proposal:

   macro_rules! decl_func_constructor {
       ($handle: ident: |$ctx: ident| $imp: block) => {
           paste::paste! {
               fn [<register_ $handle:snake _constructor>]<'lua>(lua: LuaContext<'lua>) -> Result<(), LuaError> {
                   let globals = lua.globals();
                   let constructor = lua.create_function(|$ctx: LuaContext, ()| {
                       $imp
                   })?;
                   globals.set(stringify!($handle), constructor)?;
                   Ok(())
               }
           }
       };
       
       ($handle: ident: |$ctx: ident, $($name: ident: $value: ident $( < $($gen: tt),* > )?),*| $imp: block) => {
           paste::paste! {
               fn [<register_ $handle:snake _constructor>]<'lua>(lua: LuaContext<'lua>) -> Result<(), LuaError> {
                   let globals = lua.globals();
                   let constructor = lua.create_function(|$ctx: LuaContext, args: LuaMultiValue| {
                       let mut args = args.into_iter();
                       $(
                           let $name: LuaValue = args.next().ok_or_else(|| LuaError::RuntimeError(
                               format!("missing '{}' argument in {} constructor; expected a value convertible to {}", stringify!($name), stringify!($handle), stringify!($value))
                           ))?;
                           let $name: $value$(<$($gen),*>)? = FromLuaMulti::from_lua_multi(LuaMultiValue::from_vec(vec![$name]), $ctx, &mut 0).map_err(|inner| LuaError::CallbackError {
                               traceback: format!("while converting '{}' argument value", stringify!($name)),
                               cause: std::sync::Arc::new(inner),
                           })?;
                       )*
                       $imp
                   })?;
                   globals.set(stringify!($handle), constructor)?;
                   Ok(())
               }
           }
       };
       ($handle: ident: |$ctx: ident, $multi: ident| $imp: block) => {
           paste::paste! {
               fn [<register_ $handle:snake _constructor>]<'lua>(lua: LuaContext<'lua>) -> Result<(), LuaError> {
                   let globals = lua.globals();
                   let constructor = lua.create_function(|$ctx: LuaContext, $multi: LuaMultiValue| {
                       $imp
                   })?;
                   globals.set(stringify!($handle), constructor)?;
                   Ok(())
               }
           }
       };
   }

   would require some minor tweaking to wrap add_method(_mut) but it's a good example.

   This would probably have to be tuned to allow FromLuaMulti as in #287 for the last argument. But I'll try to mix this macro into that PR to provide much better error messages.

   The issue with that implementation is that it doesn't handle complex types well (e.g. OneOf<String, LuaTable>).
3. jugglerchris commented on Dec 3, 2023

   

   jugglerchris

   on Dec 3, 2023

   Collaborator

   More actions

   FWIW in one of my projects, I use a (declarative) macro which looks like:

   wrap_lua!(RServer impl () {
       "add_redirect" => server_redirect(mut),                                             
       "add_literal" => server_literal(mut),                                               
       "add_part" => server_part(mut),                                                     
       "shutdown" => server_shutdown(mut)                                                  
   });

   where the server_redirect etc. are the rlua-style functions implementing the method.

   I also support traits:

   wrap_trait!(MyTrait {
       "meth" => mytrait_meth(const),
       "othermeth" => mytrait_othermeth(const)
   });
   
   wrap_type1(Type1 impl (MyTrait) {
       "type1_meth" => type1_meth(const)
   });

   From Lua a Type1 userdata then has both its own methods and the trait methods.