rename ComponentIdDictator

Author: ElliottjPierce

crates/bevy_ecs/macros/src/lib.rs

@@ -134,7 +134,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
         // - `Bundle::get_components` is exactly once for each member. Rely's on the Component -> Bundle implementation to properly pass
         //   the correct `StorageType` into the callback.
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name #ty_generics #where_clause {
-            fn component_ids<Components: #ecs_path::component::ComponentIdDictator>(
+            fn component_ids<Components: #ecs_path::component::DetermineComponentIds>(
                 components: &mut Components,
             ) -> impl Iterator<Item = #ecs_path::component::ComponentId> + use<#(#generics_ty_list,)* Components> {
                 core::iter::empty()#(.chain(<#active_field_types as #ecs_path::bundle::Bundle>::component_ids(components)))*

crates/bevy_ecs/src/bundle/impls.rs

@@ -6,15 +6,15 @@ use variadics_please::all_tuples_enumerated;
 
 use crate::{
     bundle::{Bundle, BundleFromComponents, DynamicBundle, NoBundleEffect},
-    component::{Component, ComponentId, ComponentIdDictator, Components, StorageType},
+    component::{Component, ComponentId, Components, DetermineComponentIds, StorageType},
     world::EntityWorldMut,
 };
 
 // SAFETY:
 // - `Bundle::component_ids` calls `ids` for C's component id (and nothing else)
 // - `Bundle::get_components` is called exactly once for C and passes the component's storage type based on its associated constant.
 unsafe impl<C: Component> Bundle for C {
-    fn component_ids<Components: ComponentIdDictator>(
+    fn component_ids<Components: DetermineComponentIds>(
         components: &mut Components,
     ) -> impl Iterator<Item = ComponentId> + use<C, Components> {
         iter::once(components.determine_component_id_of::<C>())
@@ -73,7 +73,7 @@ macro_rules! tuple_impl {
         // - `Bundle::get_components` is called exactly once for each member. Relies on the above implementation to pass the correct
         //   `StorageType` into the callback.
         unsafe impl<$($name: Bundle),*> Bundle for ($($name,)*) {
-            fn component_ids<'a, Components: ComponentIdDictator>(components: &'a mut Components) -> impl Iterator<Item = ComponentId> + use<$($name,)* Components> {
+            fn component_ids<'a, Components: DetermineComponentIds>(components: &'a mut Components) -> impl Iterator<Item = ComponentId> + use<$($name,)* Components> {
                 iter::empty()$(.chain(<$name as Bundle>::component_ids(components)))*
             }
 

crates/bevy_ecs/src/bundle/mod.rs

@@ -77,7 +77,7 @@ pub use info::*;
 pub use bevy_ecs_macros::Bundle;
 
 use crate::{
-    component::{ComponentId, ComponentIdDictator, Components, StorageType},
+    component::{ComponentId, Components, DetermineComponentIds, StorageType},
     world::EntityWorldMut,
 };
 use bevy_ptr::OwningPtr;
@@ -204,9 +204,9 @@ use bevy_ptr::OwningPtr;
 )]
 pub unsafe trait Bundle: DynamicBundle + Send + Sync + 'static {
     /// Gets this [`Bundle`]'s component ids, in the order of this bundle's [`Component`]s
-    /// This may register the component if it doesn't exist, depending on which [`ComponentIdDictator`] is used.
+    /// This may register the component if it doesn't exist, depending on which [`DetermineComponentIds`] is used.
     #[doc(hidden)]
-    fn component_ids<Components: ComponentIdDictator>(
+    fn component_ids<Components: DetermineComponentIds>(
         components: &mut Components,
     ) -> impl Iterator<Item = ComponentId> + use<Self, Components>;
 

crates/bevy_ecs/src/component/register.rs

@@ -703,20 +703,20 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
 ///
 /// This exists to encapsulate shared behavior of [`ComponentsRegistrator`] and [`ComponentsQueuedRegistrator`].
 /// If you know which one you are working with, prefer their direct methods.
-pub trait ComponentIdDictator {
+pub trait DetermineComponentIds {
     /// Determines the [`ComponentId`] of `T`.
     /// This makes no promises of whether or not `T` will be full registered; it just gets its id.
     fn determine_component_id_of<T: Component>(&mut self) -> ComponentId;
 }
 
-impl ComponentIdDictator for ComponentsRegistrator<'_> {
+impl DetermineComponentIds for ComponentsRegistrator<'_> {
     #[inline]
     fn determine_component_id_of<T: Component>(&mut self) -> ComponentId {
         self.register_component::<T>()
     }
 }
 
-impl ComponentIdDictator for ComponentsQueuedRegistrator<'_> {
+impl DetermineComponentIds for ComponentsQueuedRegistrator<'_> {
     #[inline]
     fn determine_component_id_of<T: Component>(&mut self) -> ComponentId {
         self.queue_register_component::<T>()

crates/bevy_ecs/src/spawn.rs

@@ -298,7 +298,7 @@ pub struct SpawnRelatedBundle<R: Relationship, L: SpawnableList<R>> {
 unsafe impl<R: Relationship, L: SpawnableList<R> + Send + Sync + 'static> Bundle
     for SpawnRelatedBundle<R, L>
 {
-    fn component_ids<Components: crate::component::ComponentIdDictator>(
+    fn component_ids<Components: crate::component::DetermineComponentIds>(
         components: &mut Components,
     ) -> impl Iterator<Item = crate::component::ComponentId> + use<R, L, Components> {
         <R::RelationshipTarget as Bundle>::component_ids(components)
@@ -388,7 +388,7 @@ impl<R: Relationship, B: Bundle> DynamicBundle for SpawnOneRelated<R, B> {
 
 // SAFETY: This internally relies on the RelationshipTarget's Bundle implementation, which is sound.
 unsafe impl<R: Relationship, B: Bundle> Bundle for SpawnOneRelated<R, B> {
-    fn component_ids<Components: crate::component::ComponentIdDictator>(
+    fn component_ids<Components: crate::component::DetermineComponentIds>(
         components: &mut Components,
     ) -> impl Iterator<Item = crate::component::ComponentId> + use<R, B, Components> {
         <R::RelationshipTarget as Bundle>::component_ids(components)

crates/bevy_ui_widgets/src/observe.rs

@@ -25,7 +25,7 @@ unsafe impl<
     > Bundle for AddObserver<E, B, M, I>
 {
     #[inline]
-    fn component_ids<Components: bevy_ecs::component::ComponentIdDictator>(
+    fn component_ids<Components: bevy_ecs::component::DetermineComponentIds>(
         _components: &mut Components,
     ) -> impl Iterator<Item = bevy_ecs::component::ComponentId> + use<E, B, M, I, Components> {
         // SAFETY: Empty iterator

release-content/migration-guides/bundle_traits.md

@@ -3,8 +3,8 @@ title: Bundle Traits
 pull_requests: [22670]
 ---
 
-The function `Bundle::component_ids` is now generic over `Components: ComponentIdDictator`.
-The `ComponentIdDictator` is implemented for the old `ComponentsRegistrator` and `ComponentsQueuedRegistrator`.
+The function `Bundle::component_ids` is now generic over `Components: DetermineComponentIds`.
+The `DetermineComponentIds` is implemented for the old `ComponentsRegistrator` and `ComponentsQueuedRegistrator`.
 Additionally, because [this rust rfc](https://github.com/rust-lang/rust/issues/130043) is not yet stable, the `use<Self>` had to be extended to `use<Self, Components>`.
 This may cause some lifetime annoyances but nothing a `SmallVec` can't fix.
 This was done to allow bundles to work with queued component registration.