Move enum exports to crate::enums

LikeLakers2 · LikeLakers2 · commit 91fc3321bc96 · 2026-01-01T19:41:44.000-05:00
diff --git a/crates/bevy_reflect/derive/src/derive_data.rs b/crates/bevy_reflect/derive/src/derive_data.rs
@@ -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)
         }
     }
 }
diff --git a/crates/bevy_reflect/derive/src/from_reflect.rs b/crates/bevy_reflect/derive/src/from_reflect.rs
@@ -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()),
                     }
diff --git a/crates/bevy_reflect/derive/src/impls/enums.rs b/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(
diff --git a/crates/bevy_reflect/src/attributes.rs b/crates/bevy_reflect/src/attributes.rs
@@ -183,7 +183,7 @@ pub(crate) use impl_custom_attribute_methods;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{type_info::Typed, TypeInfo, VariantInfo};
+    use crate::{enums::VariantInfo, type_info::Typed, TypeInfo};
     use alloc::{format, string::String};
     use core::ops::RangeInclusive;
 
diff --git a/crates/bevy_reflect/src/enums/dynamic_enum.rs b/crates/bevy_reflect/src/enums/dynamic_enum.rs
@@ -1,9 +1,9 @@
 use bevy_reflect_derive::impl_type_path;
 
 use crate::{
-    enum_debug, enum_hash, enum_partial_eq, ApplyError, DynamicStruct, DynamicTuple, Enum,
-    PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, Struct, Tuple,
-    TypeInfo, VariantFieldIter, VariantType,
+    enums::{enum_debug, enum_hash, enum_partial_eq, Enum, VariantFieldIter, VariantType},
+    ApplyError, DynamicStruct, DynamicTuple, PartialReflect, Reflect, ReflectKind, ReflectMut,
+    ReflectOwned, ReflectRef, Struct, Tuple, TypeInfo,
 };
 
 use alloc::{boxed::Box, string::String};
diff --git a/crates/bevy_reflect/src/enums/enum_trait.rs b/crates/bevy_reflect/src/enums/enum_trait.rs
@@ -1,8 +1,9 @@
 use crate::generics::impl_generic_info_methods;
 use crate::{
     attributes::{impl_custom_attribute_methods, CustomAttributes},
+    enums::{DynamicEnum, VariantInfo, VariantType},
     type_info::impl_type_methods,
-    DynamicEnum, Generics, PartialReflect, Type, TypePath, VariantInfo, VariantType,
+    Generics, PartialReflect, Type, TypePath,
 };
 use alloc::{boxed::Box, format, string::String};
 use bevy_platform::collections::HashMap;
@@ -325,7 +326,7 @@ impl<'a> VariantField<'a> {
 // Tests that need access to internal fields have to go here rather than in mod.rs
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{enums::*, Reflect};
 
     #[derive(Reflect, Debug, PartialEq)]
     enum MyEnum {
diff --git a/crates/bevy_reflect/src/enums/helpers.rs b/crates/bevy_reflect/src/enums/helpers.rs
@@ -1,4 +1,8 @@
-use crate::{utility::reflect_hasher, Enum, PartialReflect, ReflectRef, VariantType};
+use crate::{
+    enums::{Enum, VariantType},
+    utility::reflect_hasher,
+    PartialReflect, ReflectRef,
+};
 use core::{
     fmt::Debug,
     hash::{Hash, Hasher},
diff --git a/crates/bevy_reflect/src/enums/mod.rs b/crates/bevy_reflect/src/enums/mod.rs
@@ -1,3 +1,6 @@
+//! Types and traits used to power [enum-like] operations via reflection.
+//!
+//! [enum-like]: https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html
 mod dynamic_enum;
 mod enum_trait;
 mod helpers;
@@ -10,7 +13,7 @@ pub use variants::*;
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{enums::*, *};
     use alloc::boxed::Box;
 
     #[derive(Reflect, Debug, PartialEq)]
diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs
@@ -101,7 +101,7 @@ pub trait FromReflect: Reflect + Sized {
 /// ```
 ///
 /// [`DynamicStruct`]: crate::DynamicStruct
-/// [`DynamicEnum`]: crate::DynamicEnum
+/// [`DynamicEnum`]: crate::enums::DynamicEnum
 #[derive(Clone)]
 pub struct ReflectFromReflect {
     from_reflect: fn(&dyn PartialReflect) -> Option<Box<dyn Reflect>>,
diff --git a/crates/bevy_reflect/src/impls/core/option.rs b/crates/bevy_reflect/src/impls/core/option.rs
@@ -15,7 +15,10 @@ impl_reflect! {
 
 #[cfg(test)]
 mod tests {
-    use crate::{Enum, FromReflect, PartialReflect, TypeInfo, Typed, VariantInfo, VariantType};
+    use crate::{
+        enums::{Enum, VariantInfo, VariantType},
+        FromReflect, PartialReflect, TypeInfo, Typed,
+    };
     use bevy_reflect_derive::Reflect;
     use static_assertions::assert_impl_all;
 
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
@@ -517,9 +517,10 @@ mod tests {
     use static_assertions::assert_impl_all;
 
     use crate::{
+        enums::Enum,
         prelude::*,
         serde::{ReflectDeserializer, ReflectSerializer},
-        Enum, GetTypeRegistration, TypeRegistry,
+        GetTypeRegistration, TypeRegistry,
     };
 
     use super::*;
diff --git a/crates/bevy_reflect/src/kind.rs b/crates/bevy_reflect/src/kind.rs
@@ -3,7 +3,9 @@ use thiserror::Error;
 
 #[cfg(feature = "functions")]
 use crate::func::Function;
-use crate::{array::Array, Enum, List, Map, PartialReflect, Set, Struct, Tuple, TupleStruct};
+use crate::{
+    array::Array, enums::Enum, 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,8 +542,10 @@
 //! [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
+//! [`Enum`]: crate::enums::Enum
 //! [`Function`]: crate::func::Function
 //! [`DynamicArray`]: crate::array::DynamicArray
+//! [`DynamicEnum`]: crate::enums::DynamicEnum
 //! [derive macro documentation]: derive@crate::Reflect
 //! [deriving `Reflect`]: derive@crate::Reflect
 //! [type data]: TypeData
@@ -630,7 +632,7 @@ mod impls {
 }
 
 pub mod attributes;
-mod enums;
+pub mod enums;
 mod generics;
 pub mod serde;
 pub mod std_traits;
@@ -655,7 +657,6 @@ pub mod prelude {
     pub use crate::func::{Function, IntoFunction, IntoFunctionMut};
 }
 
-pub use enums::*;
 pub use error::*;
 pub use fields::*;
 pub use from_reflect::*;
@@ -685,8 +686,8 @@ pub use erased_serde;
 #[doc(hidden)]
 pub mod __macro_exports {
     use crate::{
-        array::DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
-        DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
+        array::DynamicArray, enums::DynamicEnum, DynamicList, DynamicMap, DynamicStruct,
+        DynamicTuple, DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
     };
 
     /// Re-exports of items from the [`alloc`] crate.
@@ -865,7 +866,7 @@ mod tests {
     };
     use static_assertions::{assert_impl_all, assert_not_impl_all};
 
-    use super::{array::*, prelude::*, *};
+    use super::{array::*, enums::*, prelude::*, *};
     use crate::{
         serde::{ReflectDeserializer, ReflectSerializer},
         utility::GenericTypePathCell,
diff --git a/crates/bevy_reflect/src/path/access.rs b/crates/bevy_reflect/src/path/access.rs
@@ -4,7 +4,7 @@ use alloc::borrow::Cow;
 use core::fmt;
 
 use super::error::AccessErrorKind;
-use crate::{AccessError, PartialReflect, ReflectKind, ReflectMut, ReflectRef, VariantType};
+use crate::{enums::VariantType, AccessError, PartialReflect, ReflectKind, ReflectMut, ReflectRef};
 
 type InnerResult<T> = Result<T, AccessErrorKind>;
 
diff --git a/crates/bevy_reflect/src/path/error.rs b/crates/bevy_reflect/src/path/error.rs
@@ -1,7 +1,7 @@
 use core::fmt;
 
 use super::Access;
-use crate::{ReflectKind, VariantType};
+use crate::{enums::VariantType, ReflectKind};
 
 /// The kind of [`AccessError`], along with some kind-specific information.
 #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/crates/bevy_reflect/src/path/mod.rs b/crates/bevy_reflect/src/path/mod.rs
@@ -243,7 +243,7 @@ impl<'a> ReflectPath<'a> for &'a str {
 /// [`TupleStruct`]: crate::TupleStruct
 /// [`List`]: crate::List
 /// [`Array`]: crate::array::Array
-/// [`Enum`]: crate::Enum
+/// [`Enum`]: crate::enums::Enum
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `GetPath` so cannot be accessed by reflection path",
     note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
@@ -519,7 +519,7 @@ impl core::ops::IndexMut<usize> for ParsedPath {
 )]
 mod tests {
     use super::*;
-    use crate::*;
+    use crate::{enums::VariantType, *};
     use alloc::vec;
 
     #[derive(Reflect, PartialEq, Debug)]
diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs
@@ -1,7 +1,8 @@
 use crate::{
-    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,
+    array::array_debug, enums::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,
 };
 use alloc::borrow::Cow;
 use alloc::boxed::Box;
@@ -90,7 +91,7 @@ impl From<ReflectKindMismatchError> for ApplyError {
 /// [the derive macro for `Reflect`]: bevy_reflect_derive::Reflect
 /// [`Struct`]: crate::Struct
 /// [`TupleStruct`]: crate::TupleStruct
-/// [`Enum`]: crate::Enum
+/// [`Enum`]: crate::enums::Enum
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `PartialReflect` so cannot be introspected",
@@ -184,7 +185,7 @@ where
     /// [`Struct`]: crate::Struct
     /// [`TupleStruct`]: crate::TupleStruct
     /// [`Tuple`]: crate::Tuple
-    /// [`Enum`]: crate::Enum
+    /// [`Enum`]: crate::enums::Enum
     /// [`List`]: crate::List
     /// [`Array`]: crate::array::Array
     /// [`Map`]: crate::Map
@@ -405,7 +406,7 @@ where
 /// [the derive macro]: bevy_reflect_derive::Reflect
 /// [`Struct`]: crate::Struct
 /// [`TupleStruct`]: crate::TupleStruct
-/// [`Enum`]: crate::Enum
+/// [`Enum`]: crate::enums::Enum
 /// [`Reflectable`]: crate::Reflectable
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
diff --git a/crates/bevy_reflect/src/serde/de/enums.rs b/crates/bevy_reflect/src/serde/de/enums.rs
@@ -1,4 +1,7 @@
 use crate::{
+    enums::{
+        DynamicEnum, DynamicVariant, EnumInfo, StructVariantInfo, TupleVariantInfo, VariantInfo,
+    },
     serde::{
         de::{
             error_utils::make_custom_error,
@@ -9,8 +12,7 @@ use crate::{
         },
         TypedReflectDeserializer,
     },
-    DynamicEnum, DynamicStruct, DynamicTuple, DynamicVariant, EnumInfo, StructVariantInfo,
-    TupleVariantInfo, TypeRegistration, TypeRegistry, VariantInfo,
+    DynamicStruct, DynamicTuple, TypeRegistration, TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{DeserializeSeed, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor};
diff --git a/crates/bevy_reflect/src/serde/de/mod.rs b/crates/bevy_reflect/src/serde/de/mod.rs
diff --git a/crates/bevy_reflect/src/serde/de/options.rs b/crates/bevy_reflect/src/serde/de/options.rs
diff --git a/crates/bevy_reflect/src/serde/de/struct_utils.rs b/crates/bevy_reflect/src/serde/de/struct_utils.rs
diff --git a/crates/bevy_reflect/src/serde/de/tuple_utils.rs b/crates/bevy_reflect/src/serde/de/tuple_utils.rs
diff --git a/crates/bevy_reflect/src/serde/ser/enums.rs b/crates/bevy_reflect/src/serde/ser/enums.rs
diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs
diff --git a/crates/bevy_remote/src/schemas/json_schema.rs b/crates/bevy_remote/src/schemas/json_schema.rs
diff --git a/examples/reflection/dynamic_types.rs b/examples/reflection/dynamic_types.rs

Original file line number	Diff line number	Diff line change
`@@ -888,7 +888,7 @@ impl<'a> ReflectEnum<'a> {`
`888`	`888`	`.map(\|variant\| variant.to_info_tokens(bevy_reflect_path));`
`889`	`889`
`890`	`890`	`let mut info = quote! {`
`891`		`- #bevy_reflect_path::EnumInfo::new::<Self>(&[`
	`891`	`+ #bevy_reflect_path::enums::EnumInfo::new::<Self>(&[`
`892`	`892`	`#(#variants),*`
`893`	`893`	`])`
`894`	`894`	`};`
`@@ -1015,7 +1015,7 @@ impl<'a> EnumVariant<'a> {`
`1015`	`1015`	`};`
`1016`	`1016`
`1017`	`1017`	`let mut info = quote! {`
`1018`		`- #bevy_reflect_path::#info_struct::new(#args)`
	`1018`	`+ #bevy_reflect_path::enums::#info_struct::new(#args)`
`1019`	`1019`	`};`
`1020`	`1020`
`1021`	`1021`	`let custom_attributes = &self.attrs.custom_attributes;`
`@@ -1037,7 +1037,7 @@ impl<'a> EnumVariant<'a> {`
`1037`	`1037`	`}`
`1038`	`1038`
`1039`	`1039`	`quote! {`
`1040`		`- #bevy_reflect_path::VariantInfo::#info_variant(#info)`
	`1040`	`+ #bevy_reflect_path::enums::VariantInfo::#info_variant(#info)`
`1041`	`1041`	`}`
`1042`	`1042`	`}`
`1043`	`1043`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream`
`93`	`93`	`if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) =`
`94`	`94`	`#bevy_reflect_path::PartialReflect::reflect_ref(#ref_value)`
`95`	`95`	`{`
`96`		`- match #bevy_reflect_path::Enum::variant_name(#ref_value) {`
	`96`	`+ match #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {`
`97`	`97`	`#match_branches`
`98`	`98`	name => panic!("variant with name `{}` does not exist on enum `{}`", name, <Self as #bevy_reflect_path::TypePath>::type_path()),
`99`	`99`	`}`