[Rust] Clean up conversions between TVM and Rust functions (#6114)

* Replace ToBoxedFn with From

* Compact and improve Typed and ToFunction impls

- Clone one less time
- Don't panic if number of args is wrong, return an error
- Actually drop functions/closures on the rust side

* Retry

rust/tvm-macros/src/external.rs

@@ -144,7 +144,7 @@ pub fn macro_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         let wrapper = quote! {
             pub fn #name<#(#ty_params),*>(#(#args : #tys),*) -> #result_type<#ret_type> {
                 let func_ref: #tvm_rt_crate::Function = #global_name.clone();
-                let func_ref: Box<dyn Fn(#(#tys),*) -> #result_type<#ret_type>> = func_ref.to_boxed_fn();
+                let func_ref: Box<dyn Fn(#(#tys),*) -> #result_type<#ret_type>> = func_ref.into();
                 let res: #ret_type = func_ref(#(#args),*)?;
                 Ok(res)
             }

rust/tvm-rt/README.md

@@ -53,7 +53,7 @@ fn sum(x: i64, y: i64, z: i64) -> i64 {
 fn main() {
     register(sum, "mysum".to_owned()).unwrap();
     let func = Function::get("mysum").unwrap();
-    let boxed_fn = func.to_boxed_fn::<dyn Fn(i64, i64, i64) -> Result<i64>>();
+    let boxed_fn: Box<dyn Fn(i64, i64, i64) -> Result<i64>> = func.into();
     let ret = boxed_fn(10, 20, 30).unwrap();
     assert_eq!(ret, 60);
 }

rust/tvm-rt/src/function.rs

@@ -25,7 +25,7 @@
 //!
 //! See the tests and examples repository for more examples.
 
-use std::convert::TryFrom;
+use std::convert::{TryFrom, TryInto};
 use std::{
     ffi::CString,
     os::raw::{c_char, c_int},
@@ -34,8 +34,6 @@ use std::{
 
 use crate::errors::Error;
 
-use super::to_boxed_fn::ToBoxedFn;
-
 pub use super::to_function::{ToFunction, Typed};
 pub use tvm_sys::{ffi, ArgValue, RetValue};
 
@@ -94,11 +92,13 @@ impl Function {
         }
     }
 
-    pub fn get_boxed<F: ?Sized, S: AsRef<str>>(name: S) -> Option<Box<F>>
+    pub fn get_boxed<F, S>(name: S) -> Option<Box<F>>
     where
-        F: ToBoxedFn,
+        S: AsRef<str>,
+        F: ?Sized,
+        Self: Into<Box<F>>,
     {
-        Self::get(name).map(|f| f.to_boxed_fn::<F>())
+        Self::get(name).map(|f| f.into())
     }
 
     /// Returns the underlying TVM function handle.
@@ -141,15 +141,31 @@ impl Function {
 
         Ok(rv)
     }
+}
 
-    pub fn to_boxed_fn<F: ?Sized>(self) -> Box<F>
-    where
-        F: ToBoxedFn,
-    {
-        F::to_boxed_fn(self)
-    }
+macro_rules! impl_to_fn {
+    () => { impl_to_fn!(@impl); };
+    ($t:ident, $($ts:ident,)*) => { impl_to_fn!(@impl $t, $($ts,)*); impl_to_fn!($($ts,)*); };
+    (@impl $($t:ident,)*) => {
+        impl<Err, Out, $($t,)*> From<Function> for Box<dyn Fn($($t,)*) -> Result<Out>>
+        where
+            Error: From<Err>,
+            Out: TryFrom<RetValue, Error = Err>,
+            $($t: Into<ArgValue<'static>>),*
+        {
+            fn from(func: Function) -> Self {
+                #[allow(non_snake_case)]
+                Box::new(move |$($t : $t),*| {
+                    let args = vec![ $($t.into()),* ];
+                    Ok(func.invoke(args)?.try_into()?)
+                })
+            }
+        }
+    };
 }
 
+impl_to_fn!(T1, T2, T3, T4, T5, T6,);
+
 impl Clone for Function {
     fn clone(&self) -> Function {
         Self {
@@ -248,7 +264,7 @@ impl<'a> TryFrom<&ArgValue<'a>> for Function {
 ///
 /// register(sum, "mysum".to_owned()).unwrap();
 /// let func = Function::get("mysum").unwrap();
-/// let boxed_fn = func.to_boxed_fn::<dyn Fn(i64, i64, i64) -> Result<i64>>();
+/// let boxed_fn: Box<dyn Fn(i64, i64, i64) -> Result<i64>> = func.into();
 /// let ret = boxed_fn(10, 20, 30).unwrap();
 /// assert_eq!(ret, 60);
 /// ```

rust/tvm-rt/src/lib.rs

@@ -97,7 +97,6 @@ pub mod errors;
 pub mod function;
 pub mod module;
 pub mod ndarray;
-pub mod to_boxed_fn;
 mod to_function;
 pub mod value;