Move struct-like exports to crate::structs

Author: LikeLakers2

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_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("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"),
             )
         };
 

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 {
@@ -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("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/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/src/enums/dynamic_enum.rs

@@ -2,8 +2,9 @@ use bevy_reflect_derive::impl_type_path;
 
 use crate::{
     enums::{enum_debug, enum_hash, enum_partial_eq, Enum, VariantFieldIter, VariantType},
-    ApplyError, DynamicStruct, DynamicTuple, PartialReflect, Reflect, ReflectKind, ReflectMut,
-    ReflectOwned, ReflectRef, Struct, Tuple, TypeInfo,
+    structs::{DynamicStruct, Struct},
+    ApplyError, DynamicTuple, PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned,
+    ReflectRef, Tuple, TypeInfo,
 };
 
 use alloc::{boxed::Box, string::String};

crates/bevy_reflect/src/enums/mod.rs

@@ -13,7 +13,7 @@ pub use variants::*;
 
 #[cfg(test)]
 mod tests {
-    use crate::{enums::*, *};
+    use crate::{enums::*, structs::*, *};
     use alloc::boxed::Box;
 
     #[derive(Reflect, Debug, PartialEq)]

crates/bevy_reflect/src/from_reflect.rs

@@ -20,7 +20,7 @@ use alloc::boxed::Box;
 /// See the [crate-level documentation] to see how this trait can be used.
 ///
 /// [derive macro]: bevy_reflect_derive::FromReflect
-/// [`DynamicStruct`]: crate::DynamicStruct
+/// [`DynamicStruct`]: crate::structs::DynamicStruct
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `FromReflect` so cannot be created through reflection",
@@ -38,7 +38,7 @@ pub trait FromReflect: Reflect + Sized {
     /// rather than a boxed dynamic type (e.g. [`DynamicStruct`], [`DynamicList`], etc.).
     ///
     /// [`from_reflect`]: Self::from_reflect
-    /// [`DynamicStruct`]: crate::DynamicStruct
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
     /// [`DynamicList`]: crate::list::DynamicList
     fn take_from_reflect(
         reflect: Box<dyn PartialReflect>,
@@ -100,7 +100,7 @@ pub trait FromReflect: Reflect + Sized {
 /// assert_eq!(Foo(123), concrete.take::<Foo>().unwrap());
 /// ```
 ///
-/// [`DynamicStruct`]: crate::DynamicStruct
+/// [`DynamicStruct`]: crate::structs::DynamicStruct
 /// [`DynamicEnum`]: crate::enums::DynamicEnum
 #[derive(Clone)]
 pub struct ReflectFromReflect {