Move list-like exports to crate::list

LikeLakers2 · LikeLakers2 · commit 59c9ebf980d6 · 2026-01-01T21:14:25.000-05:00
diff --git a/benches/benches/bevy_reflect/list.rs b/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,
diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs
@@ -45,7 +45,7 @@ use core::{
 ///
 /// [array-like]: https://doc.rust-lang.org/book/ch03-02-data-types.html#the-array-type
 /// [reflection]: crate
-/// [`List`]: crate::List
+/// [`List`]: crate::list::List
 /// [type-erasing]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html
 /// [`GetTypeRegistration`]: crate::GetTypeRegistration
 /// [limitation]: https://github.com/serde-rs/serde/issues/1937
@@ -162,7 +162,7 @@ impl ArrayInfo {
 /// This isn't to say that a [`DynamicArray`] is immutable— its items
 /// can be mutated— just that the _number_ of items cannot change.
 ///
-/// [`DynamicList`]: crate::DynamicList
+/// [`DynamicList`]: crate::list::DynamicList
 #[derive(Debug)]
 pub struct DynamicArray {
     pub(crate) represented_type: Option<&'static TypeInfo>,
diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs
@@ -39,7 +39,7 @@ pub trait FromReflect: Reflect + Sized {
     ///
     /// [`from_reflect`]: Self::from_reflect
     /// [`DynamicStruct`]: crate::DynamicStruct
-    /// [`DynamicList`]: crate::DynamicList
+    /// [`DynamicList`]: crate::list::DynamicList
     fn take_from_reflect(
         reflect: Box<dyn PartialReflect>,
     ) -> Result<Self, Box<dyn PartialReflect>> {
diff --git a/crates/bevy_reflect/src/impls/alloc/borrow.rs b/crates/bevy_reflect/src/impls/alloc/borrow.rs
@@ -245,19 +245,19 @@ impl<T: FromReflect + MaybeTyped + Clone + TypePath + GetTypeRegistration> Parti
     }
 
     fn reflect_hash(&self) -> Option<u64> {
-        crate::list_hash(self)
+        crate::list::list_hash(self)
     }
 
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::list_partial_eq(self, value)
+        crate::list::list_partial_eq(self, value)
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::list_apply(self, value);
+        crate::list::list_apply(self, value);
     }
 
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        crate::list_try_apply(self, value)
+        crate::list::list_try_apply(self, value)
     }
 }
 
diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs
@@ -1,8 +1,9 @@
 use crate::{
-    utility::GenericTypeInfoCell, ApplyError, FromReflect, FromType, Generics, GetTypeRegistration,
-    List, ListInfo, ListIter, MaybeTyped, PartialReflect, Reflect, ReflectFromPtr, ReflectKind,
-    ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypeParamInfo, TypePath, TypeRegistration,
-    Typed,
+    list::{List, ListInfo, ListIter},
+    utility::GenericTypeInfoCell,
+    ApplyError, FromReflect, FromType, Generics, GetTypeRegistration, MaybeTyped, PartialReflect,
+    Reflect, ReflectFromPtr, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+    TypeParamInfo, TypePath, TypeRegistration, Typed,
 };
 use alloc::{boxed::Box, vec::Vec};
 use bevy_reflect::ReflectCloneError;
@@ -112,11 +113,11 @@ where
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::list_apply(self, value);
+        crate::list::list_apply(self, value);
     }
 
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        crate::list_try_apply(self, value)
+        crate::list::list_try_apply(self, value)
     }
 
     fn reflect_kind(&self) -> ReflectKind {
@@ -147,7 +148,7 @@ where
     }
 
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::list_partial_eq(self, value)
+        crate::list::list_partial_eq(self, value)
     }
 }
 
diff --git a/crates/bevy_reflect/src/kind.rs b/crates/bevy_reflect/src/kind.rs
@@ -4,7 +4,7 @@ use thiserror::Error;
 #[cfg(feature = "functions")]
 use crate::func::Function;
 use crate::{
-    array::Array, enums::Enum, List, Map, PartialReflect, Set, Struct, Tuple, TupleStruct,
+    array::Array, enums::Enum, list::List, Map, PartialReflect, Set, Struct, Tuple, TupleStruct,
 };
 
 /// An enumeration of the "kinds" of a reflected type.
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
@@ -542,9 +542,11 @@
 //! [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
+//! [`List`]: crate::list::List
 //! [`Enum`]: crate::enums::Enum
 //! [`Function`]: crate::func::Function
 //! [`DynamicArray`]: crate::array::DynamicArray
+//! [`DynamicList`]: crate::list::DynamicList
 //! [`DynamicEnum`]: crate::enums::DynamicEnum
 //! [derive macro documentation]: derive@crate::Reflect
 //! [deriving `Reflect`]: derive@crate::Reflect
@@ -590,7 +592,7 @@ mod from_reflect;
 pub mod func;
 mod is;
 mod kind;
-mod list;
+pub mod list;
 mod map;
 mod path;
 mod reflect;
@@ -663,7 +665,6 @@ pub use from_reflect::*;
 pub use generics::*;
 pub use is::*;
 pub use kind::*;
-pub use list::*;
 pub use map::*;
 pub use path::*;
 pub use reflect::*;
@@ -686,7 +687,7 @@ pub use erased_serde;
 #[doc(hidden)]
 pub mod __macro_exports {
     use crate::{
-        array::DynamicArray, enums::DynamicEnum, DynamicList, DynamicMap, DynamicStruct,
+        array::DynamicArray, enums::DynamicEnum, list::DynamicList, DynamicMap, DynamicStruct,
         DynamicTuple, DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
     };
 
@@ -866,7 +867,7 @@ mod tests {
     };
     use static_assertions::{assert_impl_all, assert_not_impl_all};
 
-    use super::{array::*, enums::*, prelude::*, *};
+    use super::{array::*, enums::*, list::*, prelude::*, *};
     use crate::{
         serde::{ReflectDeserializer, ReflectSerializer},
         utility::GenericTypePathCell,
diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs
@@ -1,3 +1,6 @@
+//! Types and traits used to power [list-like] operations via reflection.
+//!
+//! [list-like]: https://doc.rust-lang.org/book/ch08-01-vectors.html
 use alloc::{boxed::Box, vec::Vec};
 use core::{
     any::Any,
@@ -39,7 +42,7 @@ use crate::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Reflect, List};
+/// use bevy_reflect::{PartialReflect, Reflect, list::List};
 ///
 /// let foo: &mut dyn List = &mut vec![123_u32, 456_u32, 789_u32];
 /// assert_eq!(foo.len(), 3);
diff --git a/crates/bevy_reflect/src/path/mod.rs b/crates/bevy_reflect/src/path/mod.rs
@@ -241,7 +241,7 @@ impl<'a> ReflectPath<'a> for &'a str {
 /// [`Struct`]: crate::Struct
 /// [`Tuple`]: crate::Tuple
 /// [`TupleStruct`]: crate::TupleStruct
-/// [`List`]: crate::List
+/// [`List`]: crate::list::List
 /// [`Array`]: crate::array::Array
 /// [`Enum`]: crate::enums::Enum
 #[diagnostic::on_unimplemented(
diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs
@@ -1,5 +1,5 @@
 use crate::{
-    array::array_debug, enums::enum_debug, list_debug, map_debug, set_debug, struct_debug,
+    array::array_debug, enums::enum_debug, list::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,
@@ -115,7 +115,7 @@ where
     /// performant for such use cases.
     ///
     /// [`DynamicStruct`]: crate::DynamicStruct
-    /// [`DynamicList`]: crate::DynamicList
+    /// [`DynamicList`]: crate::list::DynamicList
     /// [`TypeRegistry::get_type_info`]: crate::TypeRegistry::get_type_info
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo>;
 
@@ -186,11 +186,11 @@ where
     /// [`TupleStruct`]: crate::TupleStruct
     /// [`Tuple`]: crate::Tuple
     /// [`Enum`]: crate::enums::Enum
-    /// [`List`]: crate::List
+    /// [`List`]: crate::list::List
     /// [`Array`]: crate::array::Array
     /// [`Map`]: crate::Map
     /// [`Set`]: crate::Set
-    /// [`list_apply`]: crate::list_apply
+    /// [`list_apply`]: crate::list::list_apply
     /// [`map_apply`]: crate::map_apply
     /// [`set_apply`]: crate::set_apply
     ///
@@ -265,9 +265,9 @@ where
     /// ```
     ///
     /// [kind]: PartialReflect::reflect_kind
-    /// [`List`]: crate::List
-    /// [`List::to_dynamic_list`]: crate::List::to_dynamic_list
-    /// [`DynamicList`]: crate::DynamicList
+    /// [`List`]: crate::list::List
+    /// [`List::to_dynamic_list`]: crate::list::List::to_dynamic_list
+    /// [`DynamicList`]: crate::list::DynamicList
     /// [`Struct`]: crate::Struct
     /// [`Struct::to_dynamic_struct`]: crate::Struct::to_dynamic_struct
     /// [`DynamicStruct`]: crate::DynamicStruct
@@ -352,7 +352,7 @@ where
     /// (e.g. [`List`], [`Map`]), will default to the format: `"Reflect(type_path)"`,
     /// where `type_path` is the [type path] of the underlying type.
     ///
-    /// [`List`]: crate::List
+    /// [`List`]: crate::list::List
     /// [`Map`]: crate::Map
     /// [type path]: TypePath::type_path
     fn debug(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -381,7 +381,7 @@ where
     /// By default, this method will return `false`.
     ///
     /// [`DynamicStruct`]: crate::DynamicStruct
-    /// [`DynamicList`]: crate::DynamicList
+    /// [`DynamicList`]: crate::list::DynamicList
     /// [`DynamicTuple`]: crate::DynamicTuple
     fn is_dynamic(&self) -> bool {
         false
diff --git a/crates/bevy_reflect/src/serde/de/deserializer.rs b/crates/bevy_reflect/src/serde/de/deserializer.rs
@@ -99,7 +99,7 @@ use super::ReflectDeserializerProcessor;
 /// [`ReflectKind::Opaque`]: crate::ReflectKind::Opaque
 /// [`ReflectDeserialize`]: crate::ReflectDeserialize
 /// [`Box<DynamicStruct>`]: crate::DynamicStruct
-/// [`Box<DynamicList>`]: crate::DynamicList
+/// [`Box<DynamicList>`]: crate::list::DynamicList
 /// [`FromReflect`]: crate::FromReflect
 /// [`ReflectFromReflect`]: crate::ReflectFromReflect
 /// [`with_processor`]: Self::with_processor
@@ -266,7 +266,7 @@ impl<'de, P: ReflectDeserializerProcessor> DeserializeSeed<'de> for ReflectDeser
 /// [`ReflectKind::Opaque`]: crate::ReflectKind::Opaque
 /// [`ReflectDeserialize`]: crate::ReflectDeserialize
 /// [`Box<DynamicStruct>`]: crate::DynamicStruct
-/// [`Box<DynamicList>`]: crate::DynamicList
+/// [`Box<DynamicList>`]: crate::list::DynamicList
 /// [`FromReflect`]: crate::FromReflect
 /// [`ReflectFromReflect`]: crate::ReflectFromReflect
 /// [`with_processor`]: Self::with_processor
diff --git a/crates/bevy_reflect/src/serde/de/lists.rs b/crates/bevy_reflect/src/serde/de/lists.rs
@@ -1,6 +1,7 @@
 use crate::{
+    list::{DynamicList, ListInfo},
     serde::{de::registration_utils::try_get_registration, TypedReflectDeserializer},
-    DynamicList, ListInfo, TypeRegistry,
+    TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{SeqAccess, Visitor};
@@ -9,7 +10,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`List`] values.
 ///
-/// [`List`]: crate::List
+/// [`List`]: crate::list::List
 pub(super) struct ListVisitor<'a, P> {
     pub list_info: &'static ListInfo,
     pub registry: &'a TypeRegistry,
diff --git a/crates/bevy_reflect/src/serde/ser/lists.rs b/crates/bevy_reflect/src/serde/ser/lists.rs
@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, List, TypeRegistry};
+use crate::{list::List, serde::TypedReflectSerializer, TypeRegistry};
 use serde::{ser::SerializeSeq, Serialize};
 
 use super::ReflectSerializerProcessor;
diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs
@@ -1,9 +1,9 @@
 use crate::{
     array::{ArrayInfo, DynamicArray},
     enums::{DynamicEnum, EnumInfo},
-    DynamicList, DynamicMap, DynamicStruct, DynamicTuple, DynamicTupleStruct, Generics, ListInfo,
-    MapInfo, PartialReflect, Reflect, ReflectKind, SetInfo, StructInfo, TupleInfo, TupleStructInfo,
-    TypePath, TypePathTable,
+    list::{DynamicList, ListInfo},
+    DynamicMap, DynamicStruct, DynamicTuple, DynamicTupleStruct, Generics, MapInfo, PartialReflect,
+    Reflect, ReflectKind, SetInfo, StructInfo, TupleInfo, TupleStructInfo, TypePath, TypePathTable,
 };
 use core::{
     any::{Any, TypeId},
@@ -217,7 +217,7 @@ pub enum TypeInfo {
     Tuple(TupleInfo),
     /// Type information for a [list-like] type.
     ///
-    /// [list-like]: crate::List
+    /// [list-like]: crate::list::List
     List(ListInfo),
     /// Type information for an [array-like] type.
     ///
diff --git a/examples/reflection/dynamic_types.rs b/examples/reflection/dynamic_types.rs
@@ -3,11 +3,12 @@
 use bevy::reflect::{
     array::DynamicArray,
     enums::{DynamicEnum, DynamicVariant},
+    list::DynamicList,
     reflect_trait,
     serde::TypedReflectDeserializer,
     std_traits::ReflectDefault,
-    DynamicList, DynamicMap, DynamicSet, DynamicStruct, DynamicTuple, DynamicTupleStruct,
-    FromReflect, PartialReflect, Reflect, ReflectFromReflect, Set, TypeRegistry, Typed,
+    DynamicMap, DynamicSet, DynamicStruct, DynamicTuple, DynamicTupleStruct, FromReflect,
+    PartialReflect, Reflect, ReflectFromReflect, Set, TypeRegistry, Typed,
 };
 use serde::de::DeserializeSeed;
 use std::collections::{HashMap, HashSet};
diff --git a/examples/reflection/reflection_types.rs b/examples/reflection/reflection_types.rs
@@ -4,7 +4,7 @@
 use bevy::{
     platform::collections::HashMap,
     prelude::*,
-    reflect::{DynamicList, PartialReflect, ReflectRef},
+    reflect::{list::DynamicList, PartialReflect, ReflectRef},
 };
 use serde::{Deserialize, Serialize};
 

Original file line number	Diff line number	Diff line change
`@@ -245,19 +245,19 @@ impl<T: FromReflect + MaybeTyped + Clone + TypePath + GetTypeRegistration> Parti`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`fn reflect_hash(&self) -> Option<u64> {`
`248`		`- crate::list_hash(self)`
	`248`	`+ crate::list::list_hash(self)`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {`
`252`		`- crate::list_partial_eq(self, value)`
	`252`	`+ crate::list::list_partial_eq(self, value)`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`fn apply(&mut self, value: &dyn PartialReflect) {`
`256`		`- crate::list_apply(self, value);`
	`256`	`+ crate::list::list_apply(self, value);`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {`
`260`		`- crate::list_try_apply(self, value)`
	`260`	`+ crate::list::list_try_apply(self, value)`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`	`1`	`use crate::{`
`2`		`- utility::GenericTypeInfoCell, ApplyError, FromReflect, FromType, Generics, GetTypeRegistration,`
`3`		`- List, ListInfo, ListIter, MaybeTyped, PartialReflect, Reflect, ReflectFromPtr, ReflectKind,`
`4`		`- ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypeParamInfo, TypePath, TypeRegistration,`
`5`		`- Typed,`
	`2`	`+ list::{List, ListInfo, ListIter},`
	`3`	`+ utility::GenericTypeInfoCell,`
	`4`	`+ ApplyError, FromReflect, FromType, Generics, GetTypeRegistration, MaybeTyped, PartialReflect,`
	`5`	`+ Reflect, ReflectFromPtr, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,`
	`6`	`+ TypeParamInfo, TypePath, TypeRegistration, Typed,`
`6`	`7`	`};`
`7`	`8`	`use alloc::{boxed::Box, vec::Vec};`
`8`	`9`	`use bevy_reflect::ReflectCloneError;`
`@@ -112,11 +113,11 @@ where`
`112`	`113`	`}`
`113`	`114`
`114`	`115`	`fn apply(&mut self, value: &dyn PartialReflect) {`
`115`		`- crate::list_apply(self, value);`
	`116`	`+ crate::list::list_apply(self, value);`
`116`	`117`	`}`
`117`	`118`
`118`	`119`	`fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {`
`119`		`- crate::list_try_apply(self, value)`
	`120`	`+ crate::list::list_try_apply(self, value)`
`120`	`121`	`}`
`121`	`122`
`122`	`123`	`fn reflect_kind(&self) -> ReflectKind {`
`@@ -147,7 +148,7 @@ where`
`147`	`148`	`}`
`148`	`149`
`149`	`150`	`fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {`
`150`		`- crate::list_partial_eq(self, value)`
	`151`	`+ crate::list::list_partial_eq(self, value)`
`151`	`152`	`}`
`152`	`153`	`}`
`153`	`154`