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/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 {

crates/bevy_reflect/src/kind.rs

@@ -4,8 +4,8 @@ use thiserror::Error;
 #[cfg(feature = "functions")]
 use crate::func::Function;
 use crate::{
-    array::Array, enums::Enum, list::List, map::Map, set::Set, PartialReflect, Struct, Tuple,
-    TupleStruct,
+    array::Array, enums::Enum, list::List, map::Map, set::Set, structs::Struct, PartialReflect,
+    Tuple, TupleStruct,
 };
 
 /// An enumeration of the "kinds" of a reflected type.

crates/bevy_reflect/src/lib.rs

@@ -135,7 +135,7 @@
 //! For example, we can access our struct's fields by name using the [`Struct::field`] method.
 //!
 //! ```
-//! # use bevy_reflect::{PartialReflect, Reflect, Struct};
+//! # use bevy_reflect::{PartialReflect, Reflect, structs::Struct};
 //! # #[derive(Reflect)]
 //! # struct MyStruct {
 //! #   foo: i32
@@ -195,7 +195,7 @@
 //! These dynamic types may contain any arbitrary reflected data.
 //!
 //! ```
-//! # use bevy_reflect::{DynamicStruct, Struct};
+//! # use bevy_reflect::structs::{DynamicStruct, Struct};
 //! let mut data = DynamicStruct::default();
 //! data.insert("foo", 123_i32);
 //! assert_eq!(Some(&123), data.field("foo").unwrap().try_downcast_ref::<i32>())
@@ -209,7 +209,7 @@
 //! we may pass them around just like most other reflected types.
 //!
 //! ```
-//! # use bevy_reflect::{DynamicStruct, PartialReflect, Reflect};
+//! # use bevy_reflect::{structs::DynamicStruct, PartialReflect, Reflect};
 //! # #[derive(Reflect)]
 //! # struct MyStruct {
 //! #   foo: i32
@@ -243,7 +243,7 @@
 //! or when trying to make use of a reflected trait which expects the actual type.
 //!
 //! ```should_panic
-//! # use bevy_reflect::{DynamicStruct, PartialReflect, Reflect};
+//! # use bevy_reflect::{structs::DynamicStruct, PartialReflect, Reflect};
 //! # #[derive(Reflect)]
 //! # struct MyStruct {
 //! #   foo: i32
@@ -545,11 +545,14 @@
 //! [`List`]: crate::list::List
 //! [`Set`]: crate::set::Set
 //! [`Map`]: crate::map::Map
+//! [`Struct`]: crate::structs::Struct
 //! [`Enum`]: crate::enums::Enum
 //! [`Function`]: crate::func::Function
+//! [`Struct::field`]: crate::structs::Struct::field
 //! [`DynamicArray`]: crate::array::DynamicArray
 //! [`DynamicList`]: crate::list::DynamicList
 //! [`DynamicMap`]: crate::map::DynamicMap
+//! [`DynamicStruct`]: crate::structs::DynamicStruct
 //! [`DynamicEnum`]: crate::enums::DynamicEnum
 //! [derive macro documentation]: derive@crate::Reflect
 //! [deriving `Reflect`]: derive@crate::Reflect
@@ -602,7 +605,7 @@ mod reflect;
 mod reflectable;
 mod remote;
 pub mod set;
-mod struct_trait;
+pub mod structs;
 mod tuple;
 mod tuple_struct;
 mod type_info;
@@ -653,9 +656,10 @@ pub mod prelude {
 
     #[doc(hidden)]
     pub use crate::{
-        reflect_trait, FromReflect, GetField, GetPath, GetTupleStructField, PartialReflect,
-        Reflect, ReflectDeserialize, ReflectFromReflect, ReflectPath, ReflectSerialize, Struct,
-        TupleStruct, TypePath,
+        reflect_trait,
+        structs::{GetField, Struct},
+        FromReflect, GetPath, GetTupleStructField, PartialReflect, Reflect, ReflectDeserialize,
+        ReflectFromReflect, ReflectPath, ReflectSerialize, TupleStruct, TypePath,
     };
 
     #[cfg(feature = "functions")]
@@ -672,7 +676,6 @@ pub use path::*;
 pub use reflect::*;
 pub use reflectable::*;
 pub use remote::*;
-pub use struct_trait::*;
 pub use tuple::*;
 pub use tuple_struct::*;
 pub use type_info::*;
@@ -688,8 +691,9 @@ pub use erased_serde;
 #[doc(hidden)]
 pub mod __macro_exports {
     use crate::{
-        array::DynamicArray, enums::DynamicEnum, list::DynamicList, map::DynamicMap, DynamicStruct,
-        DynamicTuple, DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
+        array::DynamicArray, enums::DynamicEnum, list::DynamicList, map::DynamicMap,
+        structs::DynamicStruct, DynamicTuple, DynamicTupleStruct, GetTypeRegistration,
+        TypeRegistry,
     };
 
     /// Re-exports of items from the [`alloc`] crate.
@@ -868,7 +872,7 @@ mod tests {
     };
     use static_assertions::{assert_impl_all, assert_not_impl_all};
 
-    use super::{array::*, enums::*, list::*, map::*, prelude::*, *};
+    use super::{array::*, enums::*, list::*, map::*, prelude::*, structs::*, *};
     use crate::{
         serde::{ReflectDeserializer, ReflectSerializer},
         utility::GenericTypePathCell,

crates/bevy_reflect/src/path/mod.rs

@@ -238,7 +238,7 @@ impl<'a> ReflectPath<'a> for &'a str {
 /// );
 /// ```
 ///
-/// [`Struct`]: crate::Struct
+/// [`Struct`]: crate::structs::Struct
 /// [`Tuple`]: crate::Tuple
 /// [`TupleStruct`]: crate::TupleStruct
 /// [`List`]: crate::list::List
@@ -274,7 +274,7 @@ pub trait GetPath: PartialReflect {
     /// The downcast will fail if this value is not of type `T`
     /// (which may be the case when using dynamic types like [`DynamicStruct`]).
     ///
-    /// [`DynamicStruct`]: crate::DynamicStruct
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
     fn path<'p, T: Reflect>(&self, path: impl ReflectPath<'p>) -> PathResult<'p, &T> {
         path.element(self.as_partial_reflect())
     }
@@ -285,7 +285,7 @@ pub trait GetPath: PartialReflect {
     /// The downcast will fail if this value is not of type `T`
     /// (which may be the case when using dynamic types like [`DynamicStruct`]).
     ///
-    /// [`DynamicStruct`]: crate::DynamicStruct
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
     fn path_mut<'p, T: Reflect>(&mut self, path: impl ReflectPath<'p>) -> PathResult<'p, &mut T> {
         path.element_mut(self.as_partial_reflect_mut())
     }