Added ReflectFromReflect

Author: MrGVSV

crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -272,13 +272,7 @@ impl<'a> ReflectMeta<'a> {
 
     /// Returns the `GetTypeRegistration` impl as a `TokenStream`.
     pub fn get_type_registration(&self) -> proc_macro2::TokenStream {
-        crate::registration::impl_get_type_registration(
-            self.type_name,
-            &self.bevy_reflect_path,
-            self.traits.idents(),
-            self.generics,
-            None,
-        )
+        crate::registration::impl_get_type_registration(self, None)
     }
 }
 
@@ -300,13 +294,8 @@ impl<'a> ReflectStruct<'a> {
     ///
     /// Returns a specific implementation for structs and this method should be preffered over the generic [`get_type_registration`](crate::ReflectMeta) method
     pub fn get_type_registration(&self) -> proc_macro2::TokenStream {
-        let reflect_path = self.meta.bevy_reflect_path();
-
         crate::registration::impl_get_type_registration(
-            self.meta.type_name(),
-            reflect_path,
-            self.meta.traits().idents(),
-            self.meta.generics(),
+            self.meta(),
             Some(&self.serialization_denylist),
         )
     }

crates/bevy_reflect/bevy_reflect_derive/src/registration.rs

@@ -1,19 +1,27 @@
 //! Contains code related specifically to Bevy's type registration.
 
+use crate::ReflectMeta;
 use bit_set::BitSet;
-use proc_macro2::Ident;
 use quote::quote;
-use syn::{Generics, Path};
 
 /// Creates the `GetTypeRegistration` impl for the given type data.
 pub(crate) fn impl_get_type_registration(
-    type_name: &Ident,
-    bevy_reflect_path: &Path,
-    registration_data: &[Ident],
-    generics: &Generics,
+    meta: &ReflectMeta,
     serialization_denylist: Option<&BitSet<u32>>,
 ) -> proc_macro2::TokenStream {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+    let type_name = meta.type_name();
+    let bevy_reflect_path = meta.bevy_reflect_path();
+    let registration_data = meta.traits().idents();
+    let (impl_generics, ty_generics, where_clause) = meta.generics().split_for_impl();
+
+    let from_reflect_data = if meta.from_reflect().should_auto_derive() {
+        Some(quote! {
+        registration.insert::<#bevy_reflect_path::ReflectFromReflect>(#bevy_reflect_path::FromType::<#type_name #ty_generics>::from_type());
+        })
+    } else {
+        None
+    };
+
     let serialization_data = serialization_denylist.map(|denylist| {
         let denylist = denylist.into_iter().map(|v| v as usize);
         quote! {
@@ -28,6 +36,7 @@ pub(crate) fn impl_get_type_registration(
             fn get_type_registration() -> #bevy_reflect_path::TypeRegistration {
                 let mut registration = #bevy_reflect_path::TypeRegistration::of::<#type_name #ty_generics>();
                 registration.insert::<#bevy_reflect_path::ReflectFromPtr>(#bevy_reflect_path::FromType::<#type_name #ty_generics>::from_type());
+                #from_reflect_data
                 #serialization_data
                 #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<#type_name #ty_generics>::from_type());)*
                 registration

crates/bevy_reflect/src/from_reflect.rs

@@ -0,0 +1,91 @@
+use crate::{FromType, Reflect};
+
+/// A trait for types which can be constructed from a reflected type.
+///
+/// This trait can be derived on types which implement [`Reflect`]. Some complex
+/// types (such as `Vec<T>`) may only be reflected if their element types
+/// implement this trait.
+///
+/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]`
+/// attribute will be constructed using the `Default` implementation of the
+/// field type, rather than the corresponding field value (if any) of the
+/// reflected value.
+pub trait FromReflect: Reflect + Sized {
+    /// Constructs a concrete instance of `Self` from a reflected value.
+    fn from_reflect(reflect: &dyn Reflect) -> Option<Self>;
+}
+
+/// Type data that represents the [`FromReflect`] trait and allows it to be used dynamically.
+///
+/// `FromReflect` allows dynamic types (e.g. [`DynamicStruct`], [`DynamicEnum`], etc.) to be converted
+/// to their full, concrete types. This is most important when it comes to deserialization where it isn't
+/// guaranteed that every field exists when trying to construct the final output.
+///
+/// However, to do this, you normally need to specify the exact concrete type:
+///
+/// ```
+/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect};
+/// #[derive(Reflect, PartialEq, Eq, Debug)]
+/// struct Foo(#[reflect(default = "default_value")] usize);
+///
+/// fn default_value() -> usize { 123 }
+///
+/// let reflected = DynamicTupleStruct::default();
+///
+/// let concrete: Foo = <Foo as FromReflect>::from_reflect(&reflected).unwrap();
+///
+/// assert_eq!(Foo(123), concrete);
+/// ```
+///
+/// In a dynamic context where the type might not be known at compile-time, this is nearly impossible to do.
+/// That is why this type data struct exists— it allows us to construct the full type without knowing
+/// what the actual type is.
+///
+/// # Example
+///
+/// ```
+/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect, ReflectFromReflect, TypeRegistry};
+/// # #[derive(Reflect, PartialEq, Eq, Debug)]
+/// # struct Foo(#[reflect(default = "default_value")] usize);
+/// # fn default_value() -> usize { 123 }
+/// # let mut registry = TypeRegistry::new();
+/// # registry.register::<Foo>();
+///
+/// let mut reflected = DynamicTupleStruct::default();
+/// reflected.set_name(std::any::type_name::<Foo>().to_string());
+///
+/// let registration = registry.get_with_name(reflected.type_name()).unwrap();
+/// let rfr = registration.data::<ReflectFromReflect>().unwrap();
+///
+/// let concrete: Box<dyn Reflect> = rfr.from_reflect(&reflected).unwrap();
+///
+/// assert_eq!(Foo(123), concrete.take::<Foo>().unwrap());
+/// ```
+///
+/// [`DynamicStruct`]: crate::DynamicStruct
+/// [`DynamicEnum`]: crate::DynamicEnum
+#[derive(Clone)]
+pub struct ReflectFromReflect {
+    from_reflect: fn(&dyn Reflect) -> Option<Box<dyn Reflect>>,
+}
+
+impl ReflectFromReflect {
+    /// Perform a [`FromReflect::from_reflect`] conversion on the given reflection object.
+    ///
+    /// This will convert the object to a concrete type if it wasn't already, and return
+    /// the value as `Box<dyn Reflect>`.
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_reflect(&self, reflect_value: &dyn Reflect) -> Option<Box<dyn Reflect>> {
+        (self.from_reflect)(reflect_value)
+    }
+}
+
+impl<T: FromReflect + Reflect> FromType<T> for ReflectFromReflect {
+    fn from_type() -> Self {
+        Self {
+            from_reflect: |reflect_value| {
+                T::from_reflect(reflect_value).map(|value| Box::new(value) as Box<dyn Reflect>)
+            },
+        }
+    }
+}

crates/bevy_reflect/src/lib.rs

@@ -2,6 +2,7 @@
 
 mod array;
 mod fields;
+mod from_reflect;
 mod list;
 mod map;
 mod path;
@@ -47,6 +48,7 @@ pub mod prelude {
 pub use array::*;
 pub use enums::*;
 pub use fields::*;
+pub use from_reflect::*;
 pub use impls::*;
 pub use list::*;
 pub use map::*;
@@ -103,6 +105,7 @@ mod tests {
         ser::{to_string_pretty, PrettyConfig},
         Deserializer,
     };
+    use std::any::TypeId;
     use std::fmt::{Debug, Formatter};
 
     use super::prelude::*;
@@ -244,6 +247,41 @@ mod tests {
         assert_eq!(values, vec![1]);
     }
 
+    #[test]
+    fn should_reflect_from_type_id() {
+        #[derive(Reflect)]
+        struct MyStruct {
+            foo: usize,
+        }
+
+        // Register
+        let mut registry = TypeRegistry::default();
+        registry.register::<MyStruct>();
+
+        // Get type data
+        let type_id = TypeId::of::<MyStruct>();
+        let rfr = registry
+            .get_type_data::<ReflectFromReflect>(type_id)
+            .expect("the FromReflect trait should be registered");
+
+        // Call from_reflect
+        let mut dynamic_struct = DynamicStruct::default();
+        dynamic_struct.insert("foo", 123usize);
+        let reflected = rfr
+            .from_reflect(&dynamic_struct)
+            .expect("the type should be properly reflected");
+
+        // Assert
+        let expected = MyStruct { foo: 123 };
+        assert!(expected
+            .reflect_partial_eq(reflected.as_ref())
+            .unwrap_or_default());
+        let not_expected = MyStruct { foo: 321 };
+        assert!(!not_expected
+            .reflect_partial_eq(reflected.as_ref())
+            .unwrap_or_default());
+    }
+
     #[test]
     fn from_reflect_should_use_default_field_attributes() {
         #[derive(Reflect, Eq, PartialEq, Debug)]
@@ -661,7 +699,7 @@ mod tests {
 
         // Struct (generic)
         #[derive(Reflect)]
-        struct MyGenericStruct<T: Reflect> {
+        struct MyGenericStruct<T: FromReflect> {
             foo: T,
             bar: usize,
         }

crates/bevy_reflect/src/reflect.rs

@@ -190,21 +190,6 @@ pub trait Reflect: Any + Send + Sync {
     }
 }
 
-/// A trait for types which can be constructed from a reflected type.
-///
-/// This trait can be derived on types which implement [`Reflect`]. Some complex
-/// types (such as `Vec<T>`) may only be reflected if their element types
-/// implement this trait.
-///
-/// For structs and tuple structs, fields marked with the `#[reflect(ignore)]`
-/// attribute will be constructed using the `Default` implementation of the
-/// field type, rather than the corresponding field value (if any) of the
-/// reflected value.
-pub trait FromReflect: Reflect + Sized {
-    /// Constructs a concrete instance of `Self` from a reflected value.
-    fn from_reflect(reflect: &dyn Reflect) -> Option<Self>;
-}
-
 impl Debug for dyn Reflect {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.debug(f)

examples/reflection/generic_reflection.rs

@@ -13,7 +13,7 @@ fn main() {
 }
 
 #[derive(Reflect)]
-struct MyType<T: Reflect> {
+struct MyType<T: FromReflect> {
     value: T,
 }