Move array-like exports to bevy_reflect::array

Author: LikeLakers2

crates/bevy_reflect/src/array.rs

@@ -1,3 +1,6 @@
+//! Traits and types used to power [array-like] operations via reflection.
+//!
+//! [array-like]: https://doc.rust-lang.org/book/ch03-02-data-types.html#the-array-type
 use crate::generics::impl_generic_info_methods;
 use crate::{
     type_info::impl_type_methods, utility::reflect_hasher, ApplyError, Generics, MaybeTyped,
@@ -31,7 +34,7 @@ use core::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Array};
+/// use bevy_reflect::{PartialReflect, array::Array};
 ///
 /// let foo: &dyn Array = &[123_u32, 456_u32, 789_u32];
 /// assert_eq!(foo.len(), 3);

crates/bevy_reflect/src/impls/core/primitives.rs

@@ -376,21 +376,21 @@ impl<T: Reflect + MaybeTyped + TypePath + GetTypeRegistration, const N: usize> P
 
     #[inline]
     fn reflect_hash(&self) -> Option<u64> {
-        crate::array_hash(self)
+        crate::array::array_hash(self)
     }
 
     #[inline]
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::array_partial_eq(self, value)
+        crate::array::array_partial_eq(self, value)
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::array_apply(self, value);
+        crate::array::array_apply(self, value);
     }
 
     #[inline]
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        crate::array_try_apply(self, value)
+        crate::array::array_try_apply(self, value)
     }
 }
 

crates/bevy_reflect/src/kind.rs

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

crates/bevy_reflect/src/lib.rs

@@ -541,7 +541,9 @@
 //! [the language feature for dyn upcasting coercion]: https://github.com/rust-lang/rust/issues/65991
 //! [derive macro]: derive@crate::Reflect
 //! [`'static` lifetime]: https://doc.rust-lang.org/rust-by-example/scope/lifetime/static_lifetime.html#trait-bound
+//! [`Array`]: crate::array::Array
 //! [`Function`]: crate::func::Function
+//! [`DynamicArray`]: crate::array::DynamicArray
 //! [derive macro documentation]: derive@crate::Reflect
 //! [deriving `Reflect`]: derive@crate::Reflect
 //! [type data]: TypeData
@@ -578,7 +580,7 @@ extern crate alloc;
 // Required to make proc macros work in bevy itself.
 extern crate self as bevy_reflect;
 
-mod array;
+pub mod array;
 mod error;
 mod fields;
 mod from_reflect;
@@ -653,7 +655,6 @@ pub mod prelude {
     pub use crate::func::{Function, IntoFunction, IntoFunctionMut};
 }
 
-pub use array::*;
 pub use enums::*;
 pub use error::*;
 pub use fields::*;
@@ -684,7 +685,7 @@ pub use erased_serde;
 #[doc(hidden)]
 pub mod __macro_exports {
     use crate::{
-        DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
+        array::DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
         DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
     };
 
@@ -864,7 +865,7 @@ mod tests {
     };
     use static_assertions::{assert_impl_all, assert_not_impl_all};
 
-    use super::{prelude::*, *};
+    use super::{array::*, prelude::*, *};
     use crate::{
         serde::{ReflectDeserializer, ReflectSerializer},
         utility::GenericTypePathCell,

crates/bevy_reflect/src/list.rs

@@ -19,7 +19,7 @@ use crate::{
 /// This corresponds to types, like [`Vec`], which contain an ordered sequence
 /// of elements that implement [`Reflect`].
 ///
-/// Unlike the [`Array`](crate::Array) trait, implementors of this trait are not expected to
+/// Unlike the [`Array`](crate::array::Array) trait, implementors of this trait are not expected to
 /// maintain a constant length.
 /// Methods like [insertion](List::insert) and [removal](List::remove) explicitly allow for their
 /// internal size to change.

crates/bevy_reflect/src/path/mod.rs

@@ -242,7 +242,7 @@ impl<'a> ReflectPath<'a> for &'a str {
 /// [`Tuple`]: crate::Tuple
 /// [`TupleStruct`]: crate::TupleStruct
 /// [`List`]: crate::List
-/// [`Array`]: crate::Array
+/// [`Array`]: crate::array::Array
 /// [`Enum`]: crate::Enum
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `GetPath` so cannot be accessed by reflection path",

crates/bevy_reflect/src/reflect.rs

@@ -1,5 +1,5 @@
 use crate::{
-    array_debug, enum_debug, list_debug, map_debug, set_debug, struct_debug, tuple_debug,
+    array::array_debug, enum_debug, list_debug, map_debug, set_debug, struct_debug, tuple_debug,
     tuple_struct_debug, DynamicTypePath, DynamicTyped, OpaqueInfo, ReflectCloneError, ReflectKind,
     ReflectKindMismatchError, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath, Typed,
 };
@@ -48,7 +48,7 @@ pub enum ApplyError {
     #[error("attempted to apply type with {from_size} size to a type with {to_size} size")]
     /// Attempted to apply an [array-like] type to another of different size, e.g. a [u8; 4] to [u8; 3].
     ///
-    /// [array-like]: crate::Array
+    /// [array-like]: crate::array::Array
     DifferentSize {
         /// Size of the value we attempted to apply, in elements.
         from_size: usize,
@@ -186,7 +186,7 @@ where
     /// [`Tuple`]: crate::Tuple
     /// [`Enum`]: crate::Enum
     /// [`List`]: crate::List
-    /// [`Array`]: crate::Array
+    /// [`Array`]: crate::array::Array
     /// [`Map`]: crate::Map
     /// [`Set`]: crate::Set
     /// [`list_apply`]: crate::list_apply

crates/bevy_reflect/src/serde/de/arrays.rs

@@ -1,6 +1,7 @@
 use crate::{
+    array::{ArrayInfo, DynamicArray},
     serde::{de::registration_utils::try_get_registration, TypedReflectDeserializer},
-    ArrayInfo, DynamicArray, TypeRegistry,
+    TypeRegistry,
 };
 use alloc::{string::ToString, vec::Vec};
 use core::{fmt, fmt::Formatter};

crates/bevy_reflect/src/serde/ser/arrays.rs

@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, Array, TypeRegistry};
+use crate::{array::Array, serde::TypedReflectSerializer, TypeRegistry};
 use serde::{ser::SerializeTuple, Serialize};
 
 use super::ReflectSerializerProcessor;

crates/bevy_reflect/src/type_info.rs

@@ -1,7 +1,8 @@
 use crate::{
-    ArrayInfo, DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
-    DynamicTupleStruct, EnumInfo, Generics, ListInfo, MapInfo, PartialReflect, Reflect,
-    ReflectKind, SetInfo, StructInfo, TupleInfo, TupleStructInfo, TypePath, TypePathTable,
+    array::{ArrayInfo, DynamicArray},
+    DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple, DynamicTupleStruct,
+    EnumInfo, Generics, ListInfo, MapInfo, PartialReflect, Reflect, ReflectKind, SetInfo,
+    StructInfo, TupleInfo, TupleStructInfo, TypePath, TypePathTable,
 };
 use core::{
     any::{Any, TypeId},
@@ -219,7 +220,7 @@ pub enum TypeInfo {
     List(ListInfo),
     /// Type information for an [array-like] type.
     ///
-    /// [array-like]: crate::Array
+    /// [array-like]: crate::array::Array
     Array(ArrayInfo),
     /// Type information for a [map-like] type.
     ///