bevy_reflect: Function reflection terminology refactor

benches/benches/bevy_reflect/function.rs

@@ -1,4 +1,4 @@
-use bevy_reflect::func::{ArgList, IntoClosure, TypedFunction};
+use bevy_reflect::func::{ArgList, IntoFunction, TypedFunction};
 use bevy_reflect::prelude::*;
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 
@@ -29,7 +29,7 @@ fn into(c: &mut Criterion) {
         .bench_function("closure", |b| {
             let capture = 25;
             let closure = |a: i32| a + capture;
-            b.iter(|| closure.into_closure());
+            b.iter(|| closure.into_function());
         });
 }
 
@@ -45,7 +45,7 @@ fn call(c: &mut Criterion) {
         })
         .bench_function("closure", |b| {
             let capture = 25;
-            let add = (|a: i32| a + capture).into_closure();
+            let add = (|a: i32| a + capture).into_function();
             b.iter_batched(
                 || ArgList::new().push_owned(75_i32),
                 |args| add.call(args),

crates/bevy_app/src/app.rs

@@ -605,16 +605,16 @@ impl App {
 
     /// Registers the given function into the [`AppFunctionRegistry`] resource.
     ///
-    /// The given function will internally be stored as a [`DynamicClosure`]
+    /// The given function will internally be stored as a [`DynamicFunction`]
     /// and mapped according to its [name].
     ///
     /// Because the function must have a name,
     /// anonymous functions (e.g. `|a: i32, b: i32| { a + b }`) and closures must instead
-    /// be registered using [`register_function_with_name`] or converted to a [`DynamicClosure`]
-    /// and named using [`DynamicClosure::with_name`].
+    /// be registered using [`register_function_with_name`] or converted to a [`DynamicFunction`]
+    /// and named using [`DynamicFunction::with_name`].
     /// Failure to do so will result in a panic.
     ///
-    /// Only types that implement [`IntoClosure`] may be registered via this method.
+    /// Only types that implement [`IntoFunction`] may be registered via this method.
     ///
     /// See [`FunctionRegistry::register`] for more information.
     ///
@@ -650,7 +650,7 @@ impl App {
     ///     .register_function(add);
     /// ```
     ///
-    /// Anonymous functions and closures should be registered using [`register_function_with_name`] or given a name using [`DynamicClosure::with_name`].
+    /// Anonymous functions and closures should be registered using [`register_function_with_name`] or given a name using [`DynamicFunction::with_name`].
     ///
     /// ```should_panic
     /// use bevy_app::App;
@@ -660,15 +660,15 @@ impl App {
     /// ```
     ///
     /// [`register_function_with_name`]: Self::register_function_with_name
-    /// [`DynamicClosure`]: bevy_reflect::func::DynamicClosure
+    /// [`DynamicFunction`]: bevy_reflect::func::DynamicFunction
     /// [name]: bevy_reflect::func::FunctionInfo::name
-    /// [`DynamicClosure::with_name`]: bevy_reflect::func::DynamicClosure::with_name
-    /// [`IntoClosure`]: bevy_reflect::func::IntoClosure
+    /// [`DynamicFunction::with_name`]: bevy_reflect::func::DynamicFunction::with_name
+    /// [`IntoFunction`]: bevy_reflect::func::IntoFunction
     /// [`FunctionRegistry::register`]: bevy_reflect::func::FunctionRegistry::register
     #[cfg(feature = "reflect_functions")]
     pub fn register_function<F, Marker>(&mut self, function: F) -> &mut Self
     where
-        F: bevy_reflect::func::IntoClosure<'static, Marker> + 'static,
+        F: bevy_reflect::func::IntoFunction<'static, Marker> + 'static,
     {
         self.main_mut().register_function(function);
         self
@@ -689,7 +689,7 @@ impl App {
     /// For named functions (e.g. `fn add(a: i32, b: i32) -> i32 { a + b }`) where a custom name is not needed,
     /// it's recommended to use [`register_function`] instead as the generated name is guaranteed to be unique.
     ///
-    /// Only types that implement [`IntoClosure`] may be registered via this method.
+    /// Only types that implement [`IntoFunction`] may be registered via this method.
     ///
     /// See [`FunctionRegistry::register_with_name`] for more information.
     ///
@@ -738,7 +738,7 @@ impl App {
     ///
     /// [type name]: std::any::type_name
     /// [`register_function`]: Self::register_function
-    /// [`IntoClosure`]: bevy_reflect::func::IntoClosure
+    /// [`IntoFunction`]: bevy_reflect::func::IntoFunction
     /// [`FunctionRegistry::register_with_name`]: bevy_reflect::func::FunctionRegistry::register_with_name
     #[cfg(feature = "reflect_functions")]
     pub fn register_function_with_name<F, Marker>(
@@ -747,7 +747,7 @@ impl App {
         function: F,
     ) -> &mut Self
     where
-        F: bevy_reflect::func::IntoClosure<'static, Marker> + 'static,
+        F: bevy_reflect::func::IntoFunction<'static, Marker> + 'static,
     {
         self.main_mut().register_function_with_name(name, function);
         self

crates/bevy_app/src/sub_app.rs

@@ -413,7 +413,7 @@ impl SubApp {
     #[cfg(feature = "reflect_functions")]
     pub fn register_function<F, Marker>(&mut self, function: F) -> &mut Self
     where
-        F: bevy_reflect::func::IntoClosure<'static, Marker> + 'static,
+        F: bevy_reflect::func::IntoFunction<'static, Marker> + 'static,
     {
         let registry = self.world.resource_mut::<AppFunctionRegistry>();
         registry.write().register(function).unwrap();
@@ -428,7 +428,7 @@ impl SubApp {
         function: F,
     ) -> &mut Self
     where
-        F: bevy_reflect::func::IntoClosure<'static, Marker> + 'static,
+        F: bevy_reflect::func::IntoFunction<'static, Marker> + 'static,
     {
         let registry = self.world.resource_mut::<AppFunctionRegistry>();
         registry.write().register_with_name(name, function).unwrap();

crates/bevy_reflect/compile_fail/tests/into_function/closure_fail.rs

@@ -1,19 +1,18 @@
 #![allow(unused)]
 
-use bevy_reflect::func::IntoFunction;
+use bevy_reflect::func::{DynamicFunction, IntoFunction};
 use bevy_reflect::Reflect;
 
 fn main() {
     let value = String::from("Hello, World!");
     let closure_capture_owned = move || println!("{}", value);
 
-    let _ = closure_capture_owned.into_function();
-    //~^ E0277
+    // Pass:
+    let _: DynamicFunction<'static> = closure_capture_owned.into_function();
 
     let value = String::from("Hello, World!");
     let closure_capture_reference = || println!("{}", value);
+    //~^ ERROR: `value` does not live long enough
 
-    let _ = closure_capture_reference.into_function();
-    // ↑ This should be an error (E0277) but `compile_fail_utils` fails to pick it up
-    // when the `closure_capture_owned` test is present
+    let _: DynamicFunction<'static> = closure_capture_reference.into_function();
 }

crates/bevy_reflect/src/func/args/arg.rs

@@ -2,12 +2,10 @@ use crate::func::args::{ArgError, FromArg, Ownership};
 use crate::{PartialReflect, Reflect, TypePath};
 use std::ops::Deref;
 
-/// Represents an argument that can be passed to a [`DynamicFunction`], [`DynamicClosure`],
-/// or [`DynamicClosureMut`].
+/// Represents an argument that can be passed to a [`DynamicFunction`] or [`DynamicFunctionMut`].
 ///
 /// [`DynamicFunction`]: crate::func::DynamicFunction
-/// [`DynamicClosure`]: crate::func::DynamicClosure
-/// [`DynamicClosureMut`]: crate::func::DynamicClosureMut
+/// [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
 #[derive(Debug)]
 pub struct Arg<'a> {
     index: usize,
@@ -181,9 +179,10 @@ impl<'a> Arg<'a> {
     }
 }
 
-/// Represents an argument that can be passed to a [`DynamicFunction`].
+/// Represents an argument that can be passed to a [`DynamicFunction`] or [`DynamicFunctionMut`].
 ///
 /// [`DynamicFunction`]: crate::func::DynamicFunction
+/// [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
 #[derive(Debug)]
 pub enum ArgValue<'a> {
     Owned(Box<dyn PartialReflect>),

crates/bevy_reflect/src/func/args/from_arg.rs

@@ -3,16 +3,16 @@ use crate::func::args::{Arg, ArgError};
 /// A trait for types that can be created from an [`Arg`].
 ///
 /// This trait exists so that types can be automatically converted into an [`Arg`]
-/// by [`IntoFunction`] so they can be passed to a [`DynamicFunction`] in an [`ArgList`].
+/// so they can be put into an [`ArgList`] and passed to a [`DynamicFunction`] or [`DynamicFunctionMut`].
 ///
 /// This trait is used instead of a blanket [`From`] implementation due to coherence issues:
 /// we can't implement `From<T>` for both `T` and `&T`/`&mut T`.
 ///
 /// This trait is automatically implemented when using the `Reflect` [derive macro].
 ///
-/// [`IntoFunction`]: crate::func::IntoFunction
-/// [`DynamicFunction`]: crate::func::DynamicFunction
 /// [`ArgList`]: crate::func::args::ArgList
+/// [`DynamicFunction`]: crate::func::DynamicFunction
+/// [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
 /// [derive macro]: derive@crate::Reflect
 pub trait FromArg {
     /// The type to convert into.

crates/bevy_reflect/src/func/args/info.rs

@@ -3,13 +3,11 @@ use alloc::borrow::Cow;
 use crate::func::args::{GetOwnership, Ownership};
 use crate::TypePath;
 
-/// Type information for an [`Arg`] used in a [`DynamicFunction`], [`DynamicClosure`],
-/// or [`DynamicClosureMut`].
+/// Type information for an [`Arg`] used in a [`DynamicFunction`] or [`DynamicFunctionMut`].
 ///
 /// [`Arg`]: crate::func::args::Arg
-/// [`DynamicFunction`]: crate::func::function::DynamicFunction
-/// [`DynamicClosure`]: crate::func::closures::DynamicClosure
-/// [`DynamicClosureMut`]: crate::func::closures::DynamicClosureMut
+/// [`DynamicFunction`]: crate::func::DynamicFunction
+/// [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
 #[derive(Debug, Clone)]
 pub struct ArgInfo {
     /// The index of the argument within its function.
@@ -58,13 +56,13 @@ impl ArgInfo {
     /// since the name can't be inferred from the function type alone.
     ///
     /// For [`DynamicFunctions`] created using [`IntoFunction`]
-    /// or [`DynamicClosures`] created using [`IntoClosure`],
+    /// and [`DynamicFunctionMuts`] created using [`IntoFunctionMut`],
     /// the name will always be `None`.
     ///
     /// [`DynamicFunctions`]: crate::func::DynamicFunction
     /// [`IntoFunction`]: crate::func::IntoFunction
-    /// [`DynamicClosures`]: crate::func::DynamicClosure
-    /// [`IntoClosure`]: crate::func::IntoClosure
+    /// [`DynamicFunctionMuts`]: crate::func::DynamicFunctionMut
+    /// [`IntoFunctionMut`]: crate::func::IntoFunctionMut
     pub fn name(&self) -> Option<&str> {
         self.name.as_deref()
     }
@@ -74,6 +72,9 @@ impl ArgInfo {
         self.ownership
     }
 
+    /// The [type path] of the argument.
+    ///
+    /// [type path]: TypePath::type_path
     pub fn type_path(&self) -> &'static str {
         self.type_path
     }

crates/bevy_reflect/src/func/args/list.rs

@@ -3,8 +3,7 @@ use crate::func::ArgError;
 use crate::{PartialReflect, Reflect, TypePath};
 use std::collections::VecDeque;
 
-/// A list of arguments that can be passed to a [`DynamicFunction`], [`DynamicClosure`],
-/// or [`DynamicClosureMut`].
+/// A list of arguments that can be passed to a [`DynamicFunction`] or [`DynamicFunctionMut`].
 ///
 /// # Example
 ///
@@ -28,8 +27,7 @@ use std::collections::VecDeque;
 ///
 /// [arguments]: Arg
 /// [`DynamicFunction`]: crate::func::DynamicFunction
-/// [`DynamicClosure`]: crate::func::DynamicClosure
-/// [`DynamicClosureMut`]: crate::func::DynamicClosureMut
+/// [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
 #[derive(Default, Debug)]
 pub struct ArgList<'a> {
     list: VecDeque<Arg<'a>>,

crates/bevy_reflect/src/func/args/mod.rs

@@ -1,7 +1,7 @@
-//! Argument types and utilities for working with [`DynamicFunctions`] and [`DynamicClosures`].
+//! Argument types and utilities for working with [`DynamicFunction`] and [`DynamicFunctionMut`].
 //!
-//! [`DynamicFunctions`]: crate::func::DynamicFunction
-//! [`DynamicClosures`]: crate::func::DynamicClosure
+//! [`DynamicFunction`]: crate::func::DynamicFunction
+//! [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
 
 pub use arg::*;
 pub use error::*;

crates/bevy_reflect/src/func/args/ownership.rs

@@ -2,12 +2,12 @@ use core::fmt::{Display, Formatter};
 
 /// A trait for getting the ownership of a type.
 ///
-/// This trait exists so that [`IntoFunction`] can automatically generate
+/// This trait exists so that [`TypedFunction`] can automatically generate
 /// [`FunctionInfo`] containing the proper [`Ownership`] for its [argument] types.
 ///
 /// This trait is automatically implemented when using the `Reflect` [derive macro].
 ///
-/// [`IntoFunction`]: crate::func::IntoFunction
+/// [`TypedFunction`]: crate::func::TypedFunction
 /// [`FunctionInfo`]: crate::func::FunctionInfo
 /// [argument]: crate::func::args::Arg
 /// [derive macro]: derive@crate::Reflect