Reorganize some of bevy_reflect's exports into their respective modules

benches/benches/bevy_reflect/list.rs

@@ -1,7 +1,7 @@
 use core::{hint::black_box, iter, time::Duration};
 
 use benches::bench;
-use bevy_reflect::{DynamicList, List};
+use bevy_reflect::list::{DynamicList, List};
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,

benches/benches/bevy_reflect/map.rs

@@ -2,7 +2,7 @@ use core::{fmt::Write, hint::black_box, iter, time::Duration};
 
 use benches::bench;
 use bevy_platform::collections::HashMap;
-use bevy_reflect::{DynamicMap, Map};
+use bevy_reflect::map::{DynamicMap, Map};
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,

benches/benches/bevy_reflect/struct.rs

@@ -1,7 +1,10 @@
 use core::{hint::black_box, time::Duration};
 
 use benches::bench;
-use bevy_reflect::{DynamicStruct, GetField, PartialReflect, Reflect, Struct};
+use bevy_reflect::{
+    structs::{DynamicStruct, GetField, Struct},
+    PartialReflect, Reflect,
+};
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,

crates/bevy_animation/src/lib.rs

@@ -1522,7 +1522,7 @@ impl<'a> Iterator for TriggeredEventsIter<'a> {
 #[cfg(test)]
 mod tests {
     use crate as bevy_animation;
-    use bevy_reflect::{DynamicMap, Map};
+    use bevy_reflect::map::{DynamicMap, Map};
 
     use super::*;
 

crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.rs

@@ -1,4 +1,7 @@
-use bevy_reflect::{GetField, Reflect, Struct, TypePath};
+use bevy_reflect::{
+    structs::{GetField, Struct},
+    Reflect, TypePath,
+};
 
 #[derive(Reflect)]
 #[reflect(from_reflect = false)]

crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.stderr

@@ -1,7 +1,7 @@
 error[E0277]: `NoReflect` can not be reflected
    --> tests/reflect_derive/generics_fail.rs:18:21
     |
-18  |     foo.get_field::<NoReflect>("a").unwrap();
+22  |     foo.get_field::<NoReflect>("a").unwrap();
     |         ---------   ^^^^^^^^^ the trait `Reflect` is not implemented for `NoReflect`
     |         |
     |         required by a bound introduced by this call
@@ -26,7 +26,7 @@ note: required by a bound in `bevy_reflect::GetField::get_field`
 error[E0277]: `NoReflect` does not provide type registration information
   --> tests/reflect_derive/generics_fail.rs:14:36
    |
-14 |     let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
+17 |     let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Invalid Type
    |
    = help: the trait `GetTypeRegistration` is not implemented for `NoReflect`, which is required by `Foo<NoReflect>: bevy_reflect::Struct`
@@ -45,10 +45,10 @@ error[E0277]: `NoReflect` does not provide type registration information
 note: required for `Foo<NoReflect>` to implement `bevy_reflect::Struct`
   --> tests/reflect_derive/generics_fail.rs:3:10
    |
-3  | #[derive(Reflect)]
+6  | #[derive(Reflect)]
    |          ^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
-4  | #[reflect(from_reflect = false)]
-5  | struct Foo<T> {
+7  | #[reflect(from_reflect = false)]
+8  | struct Foo<T> {
    |        ^^^^^^
    = note: required for the cast from `Box<Foo<NoReflect>>` to `Box<(dyn bevy_reflect::Struct + 'static)>`
    = note: this error originates in the derive macro `Reflect` (in Nightly builds, run with -Z macro-backtrace for more info)

crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_structs_pass.rs

@@ -1,5 +1,5 @@
 //@check-pass
-use bevy_reflect::{GetField, Reflect};
+use bevy_reflect::{structs::GetField, Reflect};
 
 #[derive(Reflect)]
 #[reflect(from_reflect = false)]

crates/bevy_reflect/derive/src/derive_data.rs

@@ -648,15 +648,15 @@ impl<'a> ReflectStruct<'a> {
     pub fn to_info_tokens(&self, is_tuple: bool) -> proc_macro2::TokenStream {
         let bevy_reflect_path = self.meta().bevy_reflect_path();
 
-        let (info_variant, info_struct) = if is_tuple {
+        let (info_variant, info_struct): (_, Path) = if is_tuple {
             (
                 Ident::new("TupleStruct", Span::call_site()),
-                Ident::new("TupleStructInfo", Span::call_site()),
+                parse_str("tuple_struct::TupleStructInfo").expect("should be a valid path"),
             )
         } else {
             (
                 Ident::new("Struct", Span::call_site()),
-                Ident::new("StructInfo", Span::call_site()),
+                parse_str("structs::StructInfo").expect("should be a valid path"),
             )
         };
 
@@ -888,7 +888,7 @@ impl<'a> ReflectEnum<'a> {
             .map(|variant| variant.to_info_tokens(bevy_reflect_path));
 
         let mut info = quote! {
-            #bevy_reflect_path::EnumInfo::new::<Self>(&[
+            #bevy_reflect_path::enums::EnumInfo::new::<Self>(&[
                 #(#variants),*
             ])
         };
@@ -1015,7 +1015,7 @@ impl<'a> EnumVariant<'a> {
         };
 
         let mut info = quote! {
-            #bevy_reflect_path::#info_struct::new(#args)
+            #bevy_reflect_path::enums::#info_struct::new(#args)
         };
 
         let custom_attributes = &self.attrs.custom_attributes;
@@ -1037,7 +1037,7 @@ impl<'a> EnumVariant<'a> {
         }
 
         quote! {
-            #bevy_reflect_path::VariantInfo::#info_variant(#info)
+            #bevy_reflect_path::enums::VariantInfo::#info_variant(#info)
         }
     }
 }

crates/bevy_reflect/derive/src/from_reflect.rs

@@ -10,7 +10,7 @@ use bevy_macro_utils::as_member;
 use bevy_macro_utils::fq_std::{FQClone, FQDefault, FQOption};
 use proc_macro2::Span;
 use quote::{quote, ToTokens};
-use syn::{Field, Ident, Lit, LitInt, LitStr, Member};
+use syn::{parse_str, Field, Ident, Lit, LitInt, LitStr, Member, Path};
 
 /// Implements `FromReflect` for the given struct
 pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenStream {
@@ -93,7 +93,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) =
                     #bevy_reflect_path::PartialReflect::reflect_ref(#ref_value)
                 {
-                    match #bevy_reflect_path::Enum::variant_name(#ref_value) {
+                    match #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {
                         #match_branches
                         name => panic!("variant with name `{}` does not exist on enum `{}`", name, <Self as #bevy_reflect_path::TypePath>::type_path()),
                     }
@@ -126,14 +126,20 @@ fn impl_struct_internal(
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
 
     let ref_struct = Ident::new("__ref_struct", Span::call_site());
-    let ref_struct_type = if is_tuple {
-        Ident::new("TupleStruct", Span::call_site())
+    let (ref_struct_type, ref_struct_path) = if is_tuple {
+        (
+            Ident::new("TupleStruct", Span::call_site()),
+            parse_str("tuple_struct::TupleStruct").expect("should be a valid path"),
+        )
     } else {
-        Ident::new("Struct", Span::call_site())
+        (
+            Ident::new("Struct", Span::call_site()),
+            parse_str("structs::Struct").expect("should be a valid path"),
+        )
     };
 
     let MemberValuePair(active_members, active_values) =
-        get_active_fields(reflect_struct, &ref_struct, &ref_struct_type, is_tuple);
+        get_active_fields(reflect_struct, &ref_struct, &ref_struct_path, is_tuple);
 
     let is_defaultable = reflect_struct.meta().attrs().contains(REFLECT_DEFAULT);
 
@@ -236,7 +242,7 @@ fn get_ignored_fields(reflect_struct: &ReflectStruct) -> MemberValuePair {
 fn get_active_fields(
     reflect_struct: &ReflectStruct,
     dyn_struct_name: &Ident,
-    struct_type: &Ident,
+    struct_type: &Path,
     is_tuple: bool,
 ) -> MemberValuePair {
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();

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

@@ -62,8 +62,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_enum.meta(),
-        || Some(quote!(#bevy_reflect_path::enum_partial_eq)),
-        || Some(quote!(#bevy_reflect_path::enum_hash)),
+        || Some(quote!(#bevy_reflect_path::enums::enum_partial_eq)),
+        || Some(quote!(#bevy_reflect_path::enums::enum_hash)),
     );
     let clone_fn = reflect_enum.get_clone_impl();
 
@@ -97,7 +97,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
         #auto_register
 
-        impl #impl_generics #bevy_reflect_path::Enum for #enum_path #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::enums::Enum for #enum_path #ty_generics #where_reflect_clause {
             fn field(&self, #ref_name: &str) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                  match #match_this {
                     #(#enum_field,)*
@@ -140,8 +140,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
                 }
             }
 
-            fn iter_fields(&self) -> #bevy_reflect_path::VariantFieldIter {
-                #bevy_reflect_path::VariantFieldIter::new(self)
+            fn iter_fields(&self) -> #bevy_reflect_path::enums::VariantFieldIter {
+                #bevy_reflect_path::enums::VariantFieldIter::new(self)
             }
 
             #[inline]
@@ -169,15 +169,15 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
             }
 
             #[inline]
-            fn variant_type(&self) -> #bevy_reflect_path::VariantType {
+            fn variant_type(&self) -> #bevy_reflect_path::enums::VariantType {
                  match #match_this {
                     #(#enum_variant_type,)*
                     _ => unreachable!(),
                 }
             }
 
-            fn to_dynamic_enum(&self) -> #bevy_reflect_path::DynamicEnum {
-                #bevy_reflect_path::DynamicEnum::from_ref::<Self>(self)
+            fn to_dynamic_enum(&self) -> #bevy_reflect_path::enums::DynamicEnum {
+                #bevy_reflect_path::enums::DynamicEnum::from_ref::<Self>(self)
             }
         }
 
@@ -194,20 +194,20 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError>  {
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) =
                     #bevy_reflect_path::PartialReflect::reflect_ref(#ref_value) {
-                    if #bevy_reflect_path::Enum::variant_name(self) == #bevy_reflect_path::Enum::variant_name(#ref_value) {
+                    if #bevy_reflect_path::enums::Enum::variant_name(self) == #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {
                         // Same variant -> just update fields
-                        match #bevy_reflect_path::Enum::variant_type(#ref_value) {
-                            #bevy_reflect_path::VariantType::Struct => {
-                                for field in #bevy_reflect_path::Enum::iter_fields(#ref_value) {
+                        match #bevy_reflect_path::enums::Enum::variant_type(#ref_value) {
+                            #bevy_reflect_path::enums::VariantType::Struct => {
+                                for field in #bevy_reflect_path::enums::Enum::iter_fields(#ref_value) {
                                     let name = field.name().unwrap();
-                                    if let #FQOption::Some(v) = #bevy_reflect_path::Enum::field_mut(self, name) {
+                                    if let #FQOption::Some(v) = #bevy_reflect_path::enums::Enum::field_mut(self, name) {
                                        #bevy_reflect_path::PartialReflect::try_apply(v, field.value())?;
                                     }
                                 }
                             }
-                            #bevy_reflect_path::VariantType::Tuple => {
-                                for (index, field) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::Enum::iter_fields(#ref_value)) {
-                                    if let #FQOption::Some(v) = #bevy_reflect_path::Enum::field_at_mut(self, index) {
+                            #bevy_reflect_path::enums::VariantType::Tuple => {
+                                for (index, field) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::enums::Enum::iter_fields(#ref_value)) {
+                                    if let #FQOption::Some(v) = #bevy_reflect_path::enums::Enum::field_at_mut(self, index) {
                                         #bevy_reflect_path::PartialReflect::try_apply(v, field.value())?;
                                     }
                                 }
@@ -216,7 +216,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
                         }
                     } else {
                         // New variant -> perform a switch
-                        match #bevy_reflect_path::Enum::variant_name(#ref_value) {
+                        match #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {
                             #(#variant_names => {
                                 #deref_this = #variant_constructors
                             })*
@@ -309,7 +309,7 @@ fn generate_impls(reflect_enum: &ReflectEnum, ref_index: &Ident, ref_name: &Iden
             #unit{..} => #variant_index
         });
         enum_variant_type.push(quote! {
-            #unit{..} => #bevy_reflect_path::VariantType::#variant_type_ident
+            #unit{..} => #bevy_reflect_path::enums::VariantType::#variant_type_ident
         });
 
         fn process_fields(

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

@@ -40,7 +40,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_struct.meta(),
-        || Some(quote!(#bevy_reflect_path::struct_partial_eq)),
+        || Some(quote!(#bevy_reflect_path::structs::struct_partial_eq)),
         || None,
     );
     let clone_fn = reflect_struct.get_clone_impl();
@@ -78,7 +78,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
 
         #auto_register
 
-        impl #impl_generics #bevy_reflect_path::Struct for #struct_path #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::structs::Struct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, name: &str) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                 match name {
                     #(#field_names => #fqoption::Some(#fields_ref),)*
@@ -118,12 +118,12 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
                 #field_count
             }
 
-            fn iter_fields(&self) -> #bevy_reflect_path::FieldIter {
-                #bevy_reflect_path::FieldIter::new(self)
+            fn iter_fields(&self) -> #bevy_reflect_path::structs::FieldIter {
+                #bevy_reflect_path::structs::FieldIter::new(self)
             }
 
-            fn to_dynamic_struct(&self) -> #bevy_reflect_path::DynamicStruct {
-                let mut dynamic: #bevy_reflect_path::DynamicStruct = #FQDefault::default();
+            fn to_dynamic_struct(&self) -> #bevy_reflect_path::structs::DynamicStruct {
+                let mut dynamic: #bevy_reflect_path::structs::DynamicStruct = #FQDefault::default();
                 dynamic.set_represented_type(#bevy_reflect_path::PartialReflect::get_represented_type_info(self));
                 #(dynamic.insert_boxed(#field_names, #bevy_reflect_path::PartialReflect::to_dynamic(#fields_ref));)*
                 dynamic
@@ -143,9 +143,9 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError> {
                 if let #bevy_reflect_path::ReflectRef::Struct(struct_value)
                     = #bevy_reflect_path::PartialReflect::reflect_ref(value) {
-                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::Struct::iter_fields(struct_value)) {
-                        let name = #bevy_reflect_path::Struct::name_at(struct_value, i).unwrap();
-                        if let #FQOption::Some(v) = #bevy_reflect_path::Struct::field_mut(self, name) {
+                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::structs::Struct::iter_fields(struct_value)) {
+                        let name = #bevy_reflect_path::structs::Struct::name_at(struct_value, i).unwrap();
+                        if let #FQOption::Some(v) = #bevy_reflect_path::structs::Struct::field_mut(self, name) {
                            #bevy_reflect_path::PartialReflect::try_apply(v, value)?;
                         }
                     }

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

@@ -30,7 +30,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_struct.meta(),
-        || Some(quote!(#bevy_reflect_path::tuple_struct_partial_eq)),
+        || Some(quote!(#bevy_reflect_path::tuple_struct::tuple_struct_partial_eq)),
         || None,
     );
     let clone_fn = reflect_struct.get_clone_impl();
@@ -66,7 +66,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
 
         #auto_register
 
-        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::tuple_struct::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, index: usize) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                 match index {
                     #(#field_indices => #fqoption::Some(#fields_ref),)*
@@ -85,12 +85,12 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
                 #field_count
             }
             #[inline]
-            fn iter_fields(&self) -> #bevy_reflect_path::TupleStructFieldIter {
-                #bevy_reflect_path::TupleStructFieldIter::new(self)
+            fn iter_fields(&self) -> #bevy_reflect_path::tuple_struct::TupleStructFieldIter {
+                #bevy_reflect_path::tuple_struct::TupleStructFieldIter::new(self)
             }
 
-            fn to_dynamic_tuple_struct(&self) -> #bevy_reflect_path::DynamicTupleStruct {
-                let mut dynamic: #bevy_reflect_path::DynamicTupleStruct = #FQDefault::default();
+            fn to_dynamic_tuple_struct(&self) -> #bevy_reflect_path::tuple_struct::DynamicTupleStruct {
+                let mut dynamic: #bevy_reflect_path::tuple_struct::DynamicTupleStruct = #FQDefault::default();
                 dynamic.set_represented_type(#bevy_reflect_path::PartialReflect::get_represented_type_info(self));
                 #(dynamic.insert_boxed(#bevy_reflect_path::PartialReflect::to_dynamic(#fields_ref));)*
                 dynamic
@@ -110,8 +110,8 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError> {
                 if let #bevy_reflect_path::ReflectRef::TupleStruct(struct_value) =
                     #bevy_reflect_path::PartialReflect::reflect_ref(value) {
-                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::TupleStruct::iter_fields(struct_value)) {
-                        if let #FQOption::Some(v) = #bevy_reflect_path::TupleStruct::field_mut(self, i) {
+                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::tuple_struct::TupleStruct::iter_fields(struct_value)) {
+                        if let #FQOption::Some(v) = #bevy_reflect_path::tuple_struct::TupleStruct::field_mut(self, i) {
                             #bevy_reflect_path::PartialReflect::try_apply(v, value)?;
                         }
                     }