Auto-register ReflectFromReflect

Author: MrGVSV

crates/bevy_asset/src/handle.rs

@@ -103,7 +103,9 @@ where
     marker: PhantomData<fn() -> T>,
 }
 
+#[derive(Default)]
 enum HandleType {
+    #[default]
     Weak,
     Strong(Sender<RefChange>),
 }

crates/bevy_input/src/touchpad.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::event::Event;
-use bevy_reflect::{Reflect, ReflectFromReflect};
+use bevy_reflect::Reflect;
 
 #[cfg(feature = "serialize")]
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
@@ -13,7 +13,7 @@ use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
 ///
 /// - Only available on **`macOS`**.
 #[derive(Event, Debug, Clone, Copy, PartialEq, Reflect)]
-#[reflect(Debug, PartialEq, FromReflect)]
+#[reflect(Debug, PartialEq)]
 #[cfg_attr(
     feature = "serialize",
     derive(serde::Serialize, serde::Deserialize),
@@ -30,7 +30,7 @@ pub struct TouchpadMagnify(pub f32);
 ///
 /// - Only available on **`macOS`**.
 #[derive(Event, Debug, Clone, Copy, PartialEq, Reflect)]
-#[reflect(Debug, PartialEq, FromReflect)]
+#[reflect(Debug, PartialEq)]
 #[cfg_attr(
     feature = "serialize",
     derive(serde::Serialize, serde::Deserialize),

crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -1,6 +1,5 @@
 use crate::container_attributes::{FromReflectAttrs, ReflectTraits};
 use crate::field_attributes::{parse_field_attrs, ReflectFieldAttr};
-use crate::fq_std::{FQAny, FQDefault, FQSend, FQSync};
 use crate::type_path::parse_path_no_leading_colon;
 use crate::utility::{members_to_serialization_denylist, StringExpr, WhereClauseOptions};
 use bit_set::BitSet;
@@ -89,6 +88,7 @@ pub(crate) struct ReflectEnum<'a> {
 }
 
 /// Represents a field on a struct or tuple struct.
+#[derive(Clone)]
 pub(crate) struct StructField<'a> {
     /// The raw field.
     pub data: &'a Field,
@@ -450,6 +450,7 @@ impl<'a> ReflectStruct<'a> {
     }
 
     /// Get a collection of types which are ignored by the reflection API
+    #[allow(dead_code)]
     pub fn ignored_types(&self) -> Vec<syn::Type> {
         self.ignored_fields()
             .map(|field| field.data.ty.clone())
@@ -470,14 +471,7 @@ impl<'a> ReflectStruct<'a> {
     }
 
     pub fn where_clause_options(&self) -> WhereClauseOptions {
-        let bevy_reflect_path = &self.meta().bevy_reflect_path;
-        WhereClauseOptions {
-            active_types: self.active_types().into(),
-            active_trait_bounds: quote! { #bevy_reflect_path::Reflect },
-            ignored_types: self.ignored_types().into(),
-            ignored_trait_bounds: quote! { #FQAny + #FQSend + #FQSync },
-            ..WhereClauseOptions::type_path_bounds(self.meta())
-        }
+        WhereClauseOptions::new(self.meta(), self.active_fields(), self.ignored_fields())
     }
 }
 
@@ -508,6 +502,7 @@ impl<'a> ReflectEnum<'a> {
     }
 
     /// Get a collection of types which are exposed to the reflection API
+    #[allow(dead_code)]
     pub fn active_types(&self) -> Vec<syn::Type> {
         self.active_fields()
             .map(|field| field.data.ty.clone())
@@ -522,21 +517,15 @@ impl<'a> ReflectEnum<'a> {
     }
 
     /// Get a collection of types which are ignored to the reflection API
+    #[allow(dead_code)]
     pub fn ignored_types(&self) -> Vec<syn::Type> {
         self.ignored_fields()
             .map(|field| field.data.ty.clone())
             .collect()
     }
 
     pub fn where_clause_options(&self) -> WhereClauseOptions {
-        let bevy_reflect_path = &self.meta().bevy_reflect_path;
-        WhereClauseOptions {
-            active_types: self.active_types().into(),
-            active_trait_bounds: quote! { #bevy_reflect_path::FromReflect },
-            ignored_types: self.ignored_types().into(),
-            ignored_trait_bounds: quote! { #FQAny + #FQSend + #FQSync + #FQDefault },
-            ..WhereClauseOptions::type_path_bounds(self.meta())
-        }
+        WhereClauseOptions::new(self.meta(), self.active_fields(), self.ignored_fields())
     }
 }
 

crates/bevy_reflect/bevy_reflect_derive/src/documentation.rs

@@ -9,7 +9,7 @@ use syn::{Attribute, Expr, ExprLit, Lit, Meta};
 ///
 /// When converted to a [`TokenStream`], this will output an `Option<String>`
 /// containing the collection of doc comments.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub(crate) struct Documentation {
     docs: Vec<String>,
 }

crates/bevy_reflect/bevy_reflect_derive/src/field_attributes.rs

@@ -46,7 +46,7 @@ impl ReflectIgnoreBehavior {
 }
 
 /// A container for attributes defined on a reflected type's field.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub(crate) struct ReflectFieldAttr {
     /// Determines how this field should be ignored if at all.
     pub ignore: ReflectIgnoreBehavior,
@@ -55,7 +55,7 @@ pub(crate) struct ReflectFieldAttr {
 }
 
 /// Controls how the default value is determined for a field.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub(crate) enum DefaultBehavior {
     /// Field is required.
     #[default]

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -2,7 +2,7 @@ use crate::container_attributes::REFLECT_DEFAULT;
 use crate::derive_data::ReflectEnum;
 use crate::enum_utility::{get_variant_constructors, EnumVariantConstructors};
 use crate::field_attributes::DefaultBehavior;
-use crate::fq_std::{FQAny, FQClone, FQDefault, FQOption, FQSend, FQSync};
+use crate::fq_std::{FQAny, FQClone, FQDefault, FQOption};
 use crate::utility::{extend_where_clause, ident_or_index, WhereClauseOptions};
 use crate::{ReflectMeta, ReflectStruct};
 use proc_macro2::Span;
@@ -24,7 +24,7 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> proc_macro2::TokenStream {
     let bevy_reflect_path = meta.bevy_reflect_path();
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     let where_from_reflect_clause =
-        extend_where_clause(where_clause, &WhereClauseOptions::type_path_bounds(meta));
+        extend_where_clause(where_clause, &WhereClauseOptions::new_value(meta));
     quote! {
         impl #impl_generics #bevy_reflect_path::FromReflect for #type_path #ty_generics #where_from_reflect_clause  {
             fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> #FQOption<Self> {
@@ -52,13 +52,19 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
     // Add FromReflect bound for each active field
     let where_from_reflect_clause = extend_where_clause(
         where_clause,
-        &WhereClauseOptions {
-            active_types: reflect_enum.active_types().into_boxed_slice(),
-            ignored_types: reflect_enum.ignored_types().into_boxed_slice(),
-            active_trait_bounds: quote!(#bevy_reflect_path::FromReflect),
-            ignored_trait_bounds: quote!(#FQDefault + #FQAny + #FQSend + #FQSync),
-            ..WhereClauseOptions::type_path_bounds(reflect_enum.meta())
-        },
+        &WhereClauseOptions::new_with_bounds(
+            reflect_enum.meta(),
+            reflect_enum.active_fields(),
+            reflect_enum.ignored_fields(),
+            |field| match &field.attrs.default {
+                DefaultBehavior::Default => Some(quote!(#FQDefault)),
+                _ => None,
+            },
+            |field| match &field.attrs.default {
+                DefaultBehavior::Func(_) => None,
+                _ => Some(quote!(#FQDefault)),
+            },
+        ),
     );
 
     quote! {
@@ -140,17 +146,25 @@ fn impl_struct_internal(
     // Add FromReflect bound for each active field
     let where_from_reflect_clause = extend_where_clause(
         where_clause,
-        &WhereClauseOptions {
-            active_types: reflect_struct.active_types().into_boxed_slice(),
-            ignored_types: reflect_struct.ignored_types().into_boxed_slice(),
-            active_trait_bounds: quote!(#bevy_reflect_path::FromReflect),
-            ignored_trait_bounds: if is_defaultable {
-                quote!(#FQAny + #FQSend + #FQSync)
-            } else {
-                quote!(#FQDefault + #FQAny + #FQSend + #FQSync)
+        &WhereClauseOptions::new_with_bounds(
+            reflect_struct.meta(),
+            reflect_struct.active_fields(),
+            reflect_struct.ignored_fields(),
+            |field| match &field.attrs.default {
+                DefaultBehavior::Default => Some(quote!(#FQDefault)),
+                _ => None,
+            },
+            |field| {
+                if is_defaultable {
+                    None
+                } else {
+                    match &field.attrs.default {
+                        DefaultBehavior::Func(_) => None,
+                        _ => Some(quote!(#FQDefault)),
+                    }
+                }
             },
-            ..WhereClauseOptions::type_path_bounds(reflect_struct.meta())
-        },
+        ),
     );
 
     quote! {

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

@@ -21,7 +21,7 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> proc_macro2::TokenStream {
     #[cfg(not(feature = "documentation"))]
     let with_docs: Option<proc_macro2::TokenStream> = None;
 
-    let where_clause_options = WhereClauseOptions::type_path_bounds(meta);
+    let where_clause_options = WhereClauseOptions::new_value(meta);
     let typed_impl = impl_typed(
         meta,
         &where_clause_options,

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -75,6 +75,14 @@ pub(crate) static TYPE_NAME_ATTRIBUTE_NAME: &str = "type_name";
 /// This is often used with traits that have been marked by the [`#[reflect_trait]`](macro@reflect_trait)
 /// macro in order to register the type's implementation of that trait.
 ///
+/// ### Default Registrations
+///
+/// The following types are automatically registered when deriving `Reflect`:
+///
+/// * `ReflectFromReflect` (unless opting out of `FromReflect`)
+/// * `SerializationData`
+/// * `ReflectFromPtr`
+///
 /// ### Special Identifiers
 ///
 /// There are a few "special" identifiers that work a bit differently:
@@ -118,6 +126,8 @@ pub(crate) static TYPE_NAME_ATTRIBUTE_NAME: &str = "type_name";
 /// This is useful for when a type can't or shouldn't implement `FromReflect`,
 /// or if a manual implementation is desired.
 ///
+/// Note that in the latter case, `ReflectFromReflect` will no longer be automatically registered.
+///
 /// # Field Attributes
 ///
 /// Along with the container attributes, this macro comes with some attributes that may be applied
@@ -263,7 +273,8 @@ pub fn derive_type_path(input: TokenStream) -> TokenStream {
 
     impls::impl_type_path(
         derive_data.meta(),
-        &WhereClauseOptions::type_path_bounds(derive_data.meta()),
+        // Use `WhereClauseOptions::new_value` here so we don't enforce reflection bounds
+        &WhereClauseOptions::new_value(derive_data.meta()),
     )
     .into()
 }
@@ -565,7 +576,7 @@ pub fn impl_type_path(input: TokenStream) -> TokenStream {
 
     let meta = ReflectMeta::new(type_path, ReflectTraits::default());
 
-    impls::impl_type_path(&meta, &WhereClauseOptions::type_path_bounds(&meta)).into()
+    impls::impl_type_path(&meta, &WhereClauseOptions::new_value(&meta)).into()
 }
 
 /// Derives `TypeUuid` for the given type. This is used internally to implement `TypeUuid` on foreign types, such as those in the std. This macro should be used in the format of `<[Generic Params]> [Type (Path)], [Uuid (String Literal)]`.

crates/bevy_reflect/bevy_reflect_derive/src/registration.rs

@@ -1,11 +1,10 @@
 //! Contains code related specifically to Bevy's type registration.
 
+use crate::derive_data::ReflectMeta;
 use crate::utility::{extend_where_clause, WhereClauseOptions};
 use bit_set::BitSet;
 use quote::quote;
 
-use crate::derive_data::ReflectMeta;
-
 /// Creates the `GetTypeRegistration` impl for the given type data.
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn impl_get_type_registration(
@@ -17,6 +16,16 @@ pub(crate) fn impl_get_type_registration(
     let bevy_reflect_path = meta.bevy_reflect_path();
     let registration_data = meta.traits().idents();
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
+    let where_reflect_clause = extend_where_clause(where_clause, where_clause_options);
+
+    let from_reflect_data = if meta.from_reflect().should_auto_derive() {
+        Some(quote! {
+        registration.insert::<#bevy_reflect_path::ReflectFromReflect>(#bevy_reflect_path::FromType::<Self>::from_type());
+        })
+    } else {
+        None
+    };
+
     let serialization_data = serialization_denylist.map(|denylist| {
         let denylist = denylist.into_iter();
         quote! {
@@ -25,14 +34,13 @@ pub(crate) fn impl_get_type_registration(
         }
     });
 
-    let where_reflect_clause = extend_where_clause(where_clause, where_clause_options);
-
     quote! {
         #[allow(unused_mut)]
         impl #impl_generics #bevy_reflect_path::GetTypeRegistration for #type_path #ty_generics #where_reflect_clause {
             fn get_type_registration() -> #bevy_reflect_path::TypeRegistration {
                 let mut registration = #bevy_reflect_path::TypeRegistration::of::<Self>();
                 registration.insert::<#bevy_reflect_path::ReflectFromPtr>(#bevy_reflect_path::FromType::<Self>::from_type());
+                #from_reflect_data
                 #serialization_data
                 #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<Self>::from_type());)*
                 registration