Infer function name using std::any::type_name

Author: MrGVSV

crates/bevy_reflect/src/func/function.rs

@@ -115,6 +115,12 @@ impl<'env> DynamicFunction<'env> {
     }
 
     /// Set the name of the function.
+    ///
+    /// For [`DynamicFunctions`] created using [`IntoFunction`],
+    /// the default name will always be the full path to the function as returned by [`std::any::type_name`].
+    ///
+    /// [`DynamicFunctions`]: DynamicFunction
+    /// [`IntoFunction`]: crate::func::IntoFunction
     pub fn with_name(mut self, name: impl Into<Cow<'static, str>>) -> Self {
         self.info = self.info.with_name(name);
         self

crates/bevy_reflect/src/func/info.rs

@@ -26,7 +26,7 @@ impl FunctionInfo {
 
     /// Set the name of the function.
     ///
-    /// Reflected functions are not required to have a name and by default are not given one,
+    /// Reflected functions are not required to have a name,
     /// so this method must be called manually to set the name.
     pub fn with_name(mut self, name: impl Into<Cow<'static, str>>) -> Self {
         self.name = Some(name.into());
@@ -52,11 +52,8 @@ impl FunctionInfo {
 
     /// The name of the function, if it was given one.
     ///
-    /// Note that this may return `None` even if the function has a name.
-    /// This is because the name needs to be manually set using [`Self::with_name`]
-    /// since the name can't be inferred from the function type alone.
-    ///
-    /// For [`DynamicFunctions`] created using [`IntoFunction`], the name will always be `None`.
+    /// For [`DynamicFunctions`] created using [`IntoFunction`],
+    /// the name will always be the full path to the function as returned by [`std::any::type_name`].
     ///
     /// [`DynamicFunctions`]: crate::func::DynamicFunction
     pub fn name(&self) -> Option<&str> {

crates/bevy_reflect/src/func/into_function.rs

@@ -123,6 +123,7 @@ macro_rules! impl_into_function {
                 const COUNT: usize = count_tts!($($Arg)*);
 
                 let info = $crate::func::FunctionInfo::new()
+                    .with_name(std::any::type_name::<F>())
                     .with_args({
                         #[allow(unused_mut)]
                         let mut _index = 0;
@@ -171,6 +172,7 @@ macro_rules! impl_into_function {
                 const COUNT: usize = count_tts!(Receiver $($Arg)*);
 
                 let info = $crate::func::FunctionInfo::new()
+                    .with_name(std::any::type_name::<F>())
                     .with_args({
                         #[allow(unused_mut)]
                         let mut _index = 1;
@@ -222,6 +224,7 @@ macro_rules! impl_into_function {
                 const COUNT: usize = count_tts!(Receiver $($Arg)*);
 
                 let info = $crate::func::FunctionInfo::new()
+                    .with_name(std::any::type_name::<F>())
                     .with_args({
                         #[allow(unused_mut)]
                         let mut _index = 1;
@@ -273,6 +276,7 @@ macro_rules! impl_into_function {
                 const COUNT: usize = count_tts!(Receiver $($Arg)*);
 
                 let info = $crate::func::FunctionInfo::new()
+                    .with_name(std::any::type_name::<F>())
                     .with_args({
                         #[allow(unused_mut)]
                         let mut _index = 1;

crates/bevy_reflect/src/func/mod.rs

@@ -157,6 +157,36 @@ mod tests {
         assert_eq!(result.downcast_mut::<i32>(), Some(&mut 123));
     }
 
+    #[test]
+    fn should_default_with_function_type_name() {
+        fn foo() {}
+
+        let func = foo.into_function();
+        assert_eq!(
+            func.info().name(),
+            Some("bevy_reflect::func::tests::should_default_with_function_type_name::foo")
+        );
+    }
+
+    #[test]
+    fn should_default_with_closure_type_name() {
+        let bar = |_: i32| {};
+
+        let func = bar.into_function();
+        assert_eq!(
+            func.info().name(),
+            Some("bevy_reflect::func::tests::should_default_with_closure_type_name::{{closure}}")
+        );
+    }
+
+    #[test]
+    fn should_overwrite_function_name() {
+        fn foo() {}
+
+        let func = foo.into_function().with_name("my_function");
+        assert_eq!(func.info().name(), Some("my_function"));
+    }
+
     #[test]
     fn should_error_on_missing_args() {
         fn foo(_: i32) {}