bevy_reflect: Function reflection

Cargo.toml

@@ -2089,6 +2089,17 @@ description = "How dynamic types are used with reflection"
 category = "Reflection"
 wasm = false
 
+[[example]]
+name = "function_reflection"
+path = "examples/reflection/function_reflection.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.function_reflection]
+name = "Function Reflection"
+description = "Demonstrates how functions can be called dynamically using reflection"
+category = "Reflection"
+wasm = false
+
 [[example]]
 name = "generic_reflection"
 path = "examples/reflection/generic_reflection.rs"

crates/bevy_reflect/compile_fail/Cargo.toml

@@ -16,3 +16,7 @@ compile_fail_utils = { path = "../../../tools/compile_fail_utils" }
 [[test]]
 name = "derive"
 harness = false
+
+[[test]]
+name = "func"
+harness = false

crates/bevy_reflect/compile_fail/tests/derive.rs

@@ -1,3 +1,4 @@
 fn main() -> compile_fail_utils::ui_test::Result<()> {
-    compile_fail_utils::test("tests/reflect_derive")
+    // compile_fail_utils::test("tests/reflect_derive")
+    Ok(())
 }

crates/bevy_reflect/compile_fail/tests/func.rs

@@ -0,0 +1,3 @@
+fn main() -> compile_fail_utils::ui_test::Result<()> {
+    compile_fail_utils::test("tests/into_function")
+}

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

@@ -0,0 +1,40 @@
+#![allow(unused)]
+
+use bevy_reflect::func::IntoFunction;
+use bevy_reflect::Reflect;
+
+fn pass(_: i32) {}
+
+fn too_many_arguments(
+    arg0: i32,
+    arg1: i32,
+    arg2: i32,
+    arg3: i32,
+    arg4: i32,
+    arg5: i32,
+    arg6: i32,
+    arg7: i32,
+    arg8: i32,
+    arg9: i32,
+    arg10: i32,
+    arg11: i32,
+    arg12: i32,
+    arg13: i32,
+    arg14: i32,
+    arg15: i32,
+) {
+}
+
+struct Foo;
+
+fn argument_not_reflect(foo: Foo) {}
+
+fn main() {
+    let _ = pass.into_function();
+
+    let _ = too_many_arguments.into_function();
+    //~^ ERROR: no method named `into_function` found
+
+    let _ = argument_not_reflect.into_function();
+    //~^ ERROR: no method named `into_function` found
+}

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

@@ -0,0 +1,34 @@
+#![allow(unused)]
+
+use bevy_reflect::func::IntoFunction;
+use bevy_reflect::Reflect;
+
+fn pass() -> i32 {
+    123
+}
+
+struct Foo;
+
+fn return_not_reflect() -> Foo {
+    Foo
+}
+
+fn return_with_lifetime_pass<'a>(a: &'a String) -> &'a String {
+    a
+}
+
+fn return_with_invalid_lifetime<'a, 'b>(a: &'a String, b: &'b String) -> &'b String {
+    b
+}
+
+fn main() {
+    let _ = pass.into_function();
+
+    let _ = return_not_reflect.into_function();
+    //~^ ERROR: no method named `into_function` found
+
+    let _ = return_with_lifetime_pass.into_function();
+
+    let _ = return_with_invalid_lifetime.into_function();
+    //~^ ERROR: no method named `into_function` found
+}

crates/bevy_reflect/derive/src/impls/enums.rs

@@ -1,6 +1,6 @@
 use crate::derive_data::{EnumVariantFields, ReflectEnum, StructField};
 use crate::enum_utility::{EnumVariantOutputData, TryApplyVariantBuilder, VariantBuilder};
-use crate::impls::{impl_type_path, impl_typed};
+use crate::impls::{impl_function_traits, impl_type_path, impl_typed};
 use bevy_macro_utils::fq_std::{FQAny, FQBox, FQOption, FQResult};
 use proc_macro2::{Ident, Span};
 use quote::quote;
@@ -65,6 +65,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
     let type_path_impl = impl_type_path(reflect_enum.meta());
 
+    let function_impls = impl_function_traits(reflect_enum.meta(), &where_clause_options);
+
     let get_type_registration_impl = reflect_enum.get_type_registration(&where_clause_options);
 
     let (impl_generics, ty_generics, where_clause) =
@@ -79,6 +81,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
         #type_path_impl
 
+        #function_impls
+
         impl #impl_generics #bevy_reflect_path::Enum for #enum_path #ty_generics #where_reflect_clause {
             fn field(&self, #ref_name: &str) -> #FQOption<&dyn #bevy_reflect_path::Reflect> {
                  match self {

crates/bevy_reflect/derive/src/impls/func/from_arg.rs

@@ -0,0 +1,47 @@
+use crate::derive_data::ReflectMeta;
+use crate::utility::WhereClauseOptions;
+use bevy_macro_utils::fq_std::FQResult;
+use quote::quote;
+
+pub(crate) fn impl_from_arg(
+    meta: &ReflectMeta,
+    where_clause_options: &WhereClauseOptions,
+) -> proc_macro2::TokenStream {
+    let bevy_reflect = meta.bevy_reflect_path();
+    let type_path = meta.type_path();
+
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
+    let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
+
+    quote! {
+        impl #impl_generics #bevy_reflect::func::args::FromArg for #type_path #ty_generics #where_reflect_clause {
+            type Item<'from_arg> = #type_path #ty_generics;
+            fn from_arg<'from_arg>(
+                arg: #bevy_reflect::func::args::Arg<'from_arg>,
+                info: &#bevy_reflect::func::args::ArgInfo,
+            ) -> #FQResult<Self::Item<'from_arg>, #bevy_reflect::func::args::ArgError> {
+                arg.take_owned(info)
+            }
+        }
+
+        impl #impl_generics #bevy_reflect::func::args::FromArg for &'static #type_path #ty_generics #where_reflect_clause {
+            type Item<'from_arg> = &'from_arg #type_path #ty_generics;
+            fn from_arg<'from_arg>(
+                arg: #bevy_reflect::func::args::Arg<'from_arg>,
+                info: &#bevy_reflect::func::args::ArgInfo,
+            ) -> #FQResult<Self::Item<'from_arg>, #bevy_reflect::func::args::ArgError> {
+                arg.take_ref(info)
+            }
+        }
+
+        impl #impl_generics #bevy_reflect::func::args::FromArg for &'static mut #type_path #ty_generics #where_reflect_clause {
+            type Item<'from_arg> = &'from_arg mut #type_path #ty_generics;
+            fn from_arg<'from_arg>(
+                arg: #bevy_reflect::func::args::Arg<'from_arg>,
+                info: &#bevy_reflect::func::args::ArgInfo,
+            ) -> #FQResult<Self::Item<'from_arg>, #bevy_reflect::func::args::ArgError> {
+                arg.take_mut(info)
+            }
+        }
+    }
+}

crates/bevy_reflect/derive/src/impls/func/function_impls.rs

@@ -0,0 +1,23 @@
+use crate::derive_data::ReflectMeta;
+use crate::impls::func::from_arg::impl_from_arg;
+use crate::impls::func::get_ownership::impl_get_ownership;
+use crate::impls::func::into_return::impl_into_return;
+use crate::utility::WhereClauseOptions;
+use quote::quote;
+
+pub(crate) fn impl_function_traits(
+    meta: &ReflectMeta,
+    where_clause_options: &WhereClauseOptions,
+) -> proc_macro2::TokenStream {
+    let get_ownership = impl_get_ownership(meta, where_clause_options);
+    let from_arg = impl_from_arg(meta, where_clause_options);
+    let into_return = impl_into_return(meta, where_clause_options);
+
+    quote! {
+        #get_ownership
+
+        #from_arg
+
+        #into_return
+    }
+}

crates/bevy_reflect/derive/src/impls/func/get_ownership.rs

@@ -0,0 +1,34 @@
+use crate::derive_data::ReflectMeta;
+use crate::utility::WhereClauseOptions;
+use quote::quote;
+
+pub(crate) fn impl_get_ownership(
+    meta: &ReflectMeta,
+    where_clause_options: &WhereClauseOptions,
+) -> proc_macro2::TokenStream {
+    let bevy_reflect = meta.bevy_reflect_path();
+    let type_path = meta.type_path();
+
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
+    let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
+
+    quote! {
+        impl #impl_generics #bevy_reflect::func::args::GetOwnership for #type_path #ty_generics #where_reflect_clause {
+            fn ownership() -> #bevy_reflect::func::args::Ownership {
+                #bevy_reflect::func::args::Ownership::Owned
+            }
+        }
+
+        impl #impl_generics #bevy_reflect::func::args::GetOwnership for &'_ #type_path #ty_generics #where_reflect_clause {
+            fn ownership() -> #bevy_reflect::func::args::Ownership {
+                #bevy_reflect::func::args::Ownership::Ref
+            }
+        }
+
+        impl #impl_generics #bevy_reflect::func::args::GetOwnership for &'_ mut #type_path #ty_generics #where_reflect_clause {
+            fn ownership() -> #bevy_reflect::func::args::Ownership {
+                #bevy_reflect::func::args::Ownership::Mut
+            }
+        }
+    }
+}

crates/bevy_reflect/derive/src/impls/func/into_return.rs

@@ -0,0 +1,34 @@
+use crate::derive_data::ReflectMeta;
+use crate::utility::WhereClauseOptions;
+use quote::quote;
+
+pub(crate) fn impl_into_return(
+    meta: &ReflectMeta,
+    where_clause_options: &WhereClauseOptions,
+) -> proc_macro2::TokenStream {
+    let bevy_reflect = meta.bevy_reflect_path();
+    let type_path = meta.type_path();
+
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
+    let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
+
+    quote! {
+        impl #impl_generics #bevy_reflect::func::IntoReturn for #type_path #ty_generics #where_reflect_clause {
+            fn into_return<'into_return>(self) -> #bevy_reflect::func::Return<'into_return> {
+                #bevy_reflect::func::Return::Owned(Box::new(self))
+            }
+        }
+
+        impl #impl_generics #bevy_reflect::func::IntoReturn for &'static #type_path #ty_generics #where_reflect_clause {
+            fn into_return<'into_return>(self) -> #bevy_reflect::func::Return<'into_return> {
+                #bevy_reflect::func::Return::Ref(self)
+            }
+        }
+
+        impl #impl_generics #bevy_reflect::func::IntoReturn for &'static mut #type_path #ty_generics #where_reflect_clause {
+            fn into_return<'into_return>(self) -> #bevy_reflect::func::Return<'into_return> {
+                #bevy_reflect::func::Return::Mut(self)
+            }
+        }
+    }
+}

crates/bevy_reflect/derive/src/impls/func/mod.rs

@@ -0,0 +1,6 @@
+pub(crate) use function_impls::impl_function_traits;
+
+mod from_arg;
+mod function_impls;
+mod get_ownership;
+mod into_return;

crates/bevy_reflect/derive/src/impls/mod.rs

@@ -1,12 +1,13 @@
 mod enums;
+mod func;
 mod structs;
 mod tuple_structs;
 mod typed;
 mod values;
 
 pub(crate) use enums::impl_enum;
+pub(crate) use func::impl_function_traits;
 pub(crate) use structs::impl_struct;
 pub(crate) use tuple_structs::impl_tuple_struct;
-pub(crate) use typed::impl_type_path;
-pub(crate) use typed::impl_typed;
+pub(crate) use typed::{impl_type_path, impl_typed};
 pub(crate) use values::impl_value;

crates/bevy_reflect/derive/src/impls/structs.rs

@@ -1,4 +1,4 @@
-use crate::impls::{impl_type_path, impl_typed};
+use crate::impls::{impl_function_traits, impl_type_path, impl_typed};
 use crate::utility::ident_or_index;
 use crate::ReflectStruct;
 use bevy_macro_utils::fq_std::{FQAny, FQBox, FQDefault, FQOption, FQResult};
@@ -54,6 +54,8 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
 
     let type_path_impl = impl_type_path(reflect_struct.meta());
 
+    let function_impls = impl_function_traits(reflect_struct.meta(), &where_clause_options);
+
     let get_type_registration_impl = reflect_struct.get_type_registration(&where_clause_options);
 
     let (impl_generics, ty_generics, where_clause) = reflect_struct
@@ -71,6 +73,8 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
 
         #type_path_impl
 
+        #function_impls
+
         impl #impl_generics #bevy_reflect_path::Struct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, name: &str) -> #FQOption<&dyn #bevy_reflect_path::Reflect> {
                 match name {

crates/bevy_reflect/derive/src/impls/tuple_structs.rs

@@ -1,4 +1,4 @@
-use crate::impls::{impl_type_path, impl_typed};
+use crate::impls::{impl_function_traits, impl_type_path, impl_typed};
 use crate::ReflectStruct;
 use bevy_macro_utils::fq_std::{FQAny, FQBox, FQDefault, FQOption, FQResult};
 use quote::{quote, ToTokens};
@@ -46,6 +46,8 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
 
     let type_path_impl = impl_type_path(reflect_struct.meta());
 
+    let function_impls = impl_function_traits(reflect_struct.meta(), &where_clause_options);
+
     let (impl_generics, ty_generics, where_clause) = reflect_struct
         .meta()
         .type_path()
@@ -61,6 +63,8 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
 
         #type_path_impl
 
+        #function_impls
+
         impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, index: usize) -> #FQOption<&dyn #bevy_reflect_path::Reflect> {
                 match index {

crates/bevy_reflect/derive/src/impls/values.rs

@@ -1,4 +1,4 @@
-use crate::impls::{impl_type_path, impl_typed};
+use crate::impls::{impl_function_traits, impl_type_path, impl_typed};
 use crate::utility::WhereClauseOptions;
 use crate::ReflectMeta;
 use bevy_macro_utils::fq_std::{FQAny, FQBox, FQClone, FQOption, FQResult};
@@ -33,6 +33,8 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> proc_macro2::TokenStream {
 
     let type_path_impl = impl_type_path(meta);
 
+    let function_impls = impl_function_traits(meta, &where_clause_options);
+
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
     let get_type_registration_impl = meta.get_type_registration(&where_clause_options);
@@ -44,6 +46,8 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> proc_macro2::TokenStream {
 
         #typed_impl
 
+        #function_impls
+
         impl #impl_generics #bevy_reflect_path::Reflect for #type_path #ty_generics #where_reflect_clause  {
             #[inline]
             fn get_represented_type_info(&self) -> #FQOption<&'static #bevy_reflect_path::TypeInfo> {

crates/bevy_reflect/derive/src/utility.rs

@@ -154,13 +154,17 @@ impl<'a, 'b> WhereClauseOptions<'a, 'b> {
         &self,
         where_clause: Option<&WhereClause>,
     ) -> proc_macro2::TokenStream {
+        let type_path = self.meta.type_path();
+        let (_, ty_generics, _) = self.meta.type_path().generics().split_for_impl();
+
         let required_bounds = self.required_bounds();
+
         // Maintain existing where clause, if any.
         let mut generic_where_clause = if let Some(where_clause) = where_clause {
             let predicates = where_clause.predicates.iter();
-            quote! {where Self: #required_bounds, #(#predicates,)*}
+            quote! {where #type_path #ty_generics: #required_bounds, #(#predicates,)*}
         } else {
-            quote!(where Self: #required_bounds,)
+            quote!(where #type_path #ty_generics: #required_bounds,)
         };
 
         // Add additional reflection trait bounds