bevy_reflect: Recursive registration

crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -470,7 +470,12 @@ impl<'a> ReflectMeta<'a> {
         &self,
         where_clause_options: &WhereClauseOptions,
     ) -> proc_macro2::TokenStream {
-        crate::registration::impl_get_type_registration(self, where_clause_options, None)
+        crate::registration::impl_get_type_registration(
+            self,
+            where_clause_options,
+            None,
+            Option::<std::iter::Empty<&Type>>::None,
+        )
     }
 
     /// The collection of docstrings for this type, if any.
@@ -502,6 +507,7 @@ impl<'a> ReflectStruct<'a> {
             self.meta(),
             where_clause_options,
             self.serialization_data(),
+            Some(self.active_types().iter()),
         )
     }
 
@@ -512,22 +518,21 @@ impl<'a> ReflectStruct<'a> {
             .collect()
     }
 
-    /// Get an iterator of fields which are exposed to the reflection API
+    /// Get an iterator of fields which are exposed to the reflection API.
     pub fn active_fields(&self) -> impl Iterator<Item = &StructField<'a>> {
-        self.fields
+        self.fields()
             .iter()
             .filter(|field| field.attrs.ignore.is_active())
     }
 
     /// Get an iterator of fields which are ignored by the reflection API
     pub fn ignored_fields(&self) -> impl Iterator<Item = &StructField<'a>> {
-        self.fields
+        self.fields()
             .iter()
             .filter(|field| field.attrs.ignore.is_ignored())
     }
 
     /// The complete set of fields in this struct.
-    #[allow(dead_code)]
     pub fn fields(&self) -> &[StructField<'a>] {
         &self.fields
     }
@@ -573,6 +578,21 @@ impl<'a> ReflectEnum<'a> {
     pub fn where_clause_options(&self) -> WhereClauseOptions {
         WhereClauseOptions::new_with_fields(self.meta(), self.active_types().into_boxed_slice())
     }
+
+    /// Returns the `GetTypeRegistration` impl as a `TokenStream`.
+    ///
+    /// Returns a specific implementation for enums and this method should be preferred over the generic [`get_type_registration`](crate::ReflectMeta) method
+    pub fn get_type_registration(
+        &self,
+        where_clause_options: &WhereClauseOptions,
+    ) -> proc_macro2::TokenStream {
+        crate::registration::impl_get_type_registration(
+            self.meta(),
+            where_clause_options,
+            None,
+            Some(self.active_fields().map(|field| &field.data.ty)),
+        )
+    }
 }
 
 impl<'a> EnumVariant<'a> {

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

@@ -84,9 +84,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
     let type_path_impl = impl_type_path(reflect_enum.meta());
 
-    let get_type_registration_impl = reflect_enum
-        .meta()
-        .get_type_registration(&where_clause_options);
+    let get_type_registration_impl = reflect_enum.get_type_registration(&where_clause_options);
 
     let (impl_generics, ty_generics, where_clause) =
         reflect_enum.meta().type_path().generics().split_for_impl();

crates/bevy_reflect/bevy_reflect_derive/src/registration.rs

@@ -4,17 +4,28 @@ use crate::derive_data::ReflectMeta;
 use crate::serialization::SerializationDataDef;
 use crate::utility::WhereClauseOptions;
 use quote::quote;
+use syn::Type;
 
 /// Creates the `GetTypeRegistration` impl for the given type data.
 #[allow(clippy::too_many_arguments)]
-pub(crate) fn impl_get_type_registration(
+pub(crate) fn impl_get_type_registration<'a>(
     meta: &ReflectMeta,
     where_clause_options: &WhereClauseOptions,
     serialization_data: Option<&SerializationDataDef>,
+    type_dependencies: Option<impl Iterator<Item = &'a Type>>,
 ) -> proc_macro2::TokenStream {
     let type_path = meta.type_path();
     let bevy_reflect_path = meta.bevy_reflect_path();
     let registration_data = meta.attrs().idents();
+
+    let type_deps_fn = type_dependencies.map(|deps| {
+        quote! {
+            fn register_type_dependencies(registry: &mut #bevy_reflect_path::TypeRegistry) {
+                #(<#deps as #bevy_reflect_path::__macro_exports::RegisterForReflection>::__register(registry);)*
+            }
+        }
+    });
+
     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);
 
@@ -44,6 +55,8 @@ pub(crate) fn impl_get_type_registration(
                 #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<Self>::from_type());)*
                 registration
             }
+
+            #type_deps_fn
         }
     }
 }

crates/bevy_reflect/bevy_reflect_derive/src/utility.rs

@@ -217,11 +217,15 @@ impl<'a, 'b> WhereClauseOptions<'a, 'b> {
 
             // `TypePath` is always required for active fields since they are used to
             // construct `NamedField` and `UnnamedField` instances for the `Typed` impl.
-            Some(
-                self.active_fields
-                    .iter()
-                    .map(move |ty| quote!(#ty : #reflect_bound + #bevy_reflect_path::TypePath)),
-            )
+            // Likewise, `GetTypeRegistration` is always required for active fields since
+            // they are used to register the type's dependencies.
+            Some(self.active_fields.iter().map(move |ty| {
+                quote!(
+                    #ty : #reflect_bound
+                        + #bevy_reflect_path::TypePath
+                        + #bevy_reflect_path::__macro_exports::RegisterForReflection
+                )
+            }))
         }
     }