ObserverTrigger: Add wrapper type around ComponentId

crates/bevy_ecs/src/event/base.rs

@@ -94,23 +94,23 @@ use core::{
     note = "consider annotating `{Self}` with `#[derive(Event)]`"
 )]
 pub trait Event: Send + Sync + 'static {
-    /// Generates the [`ComponentId`] for this event type.
+    /// Generates the [`EventKey`] for this event type.
     ///
     /// If this type has already been registered,
-    /// this will return the existing [`ComponentId`].
+    /// this will return the existing [`EventKey`].
     ///
     /// This is used by various dynamically typed observer APIs,
     /// such as [`World::trigger_targets_dynamic`].
     ///
     /// # Warning
     ///
     /// This method should not be overridden by implementers,
-    /// and should always correspond to the implementation of [`component_id`](Event::component_id).
-    fn register_component_id(world: &mut World) -> ComponentId {
-        world.register_component::<EventWrapperComponent<Self>>()
+    /// and should always correspond to the implementation of [`event_type`](Event::event_type).
+    fn register_event_type(world: &mut World) -> EventKey {
+        EventKey(world.register_component::<EventWrapperComponent<Self>>())
     }
 
-    /// Fetches the [`ComponentId`] for this event type,
+    /// Fetches the [`EventKey`] for this event type,
     /// if it has already been generated.
     ///
     /// This is used by various dynamically typed observer APIs,
@@ -119,9 +119,12 @@ pub trait Event: Send + Sync + 'static {
     /// # Warning
     ///
     /// This method should not be overridden by implementers,
-    /// and should always correspond to the implementation of [`register_component_id`](Event::register_component_id).
-    fn component_id(world: &World) -> Option<ComponentId> {
-        world.component_id::<EventWrapperComponent<Self>>()
+    /// and should always correspond to the implementation of
+    /// [`register_event_type`](Event::register_event_type).
+    fn event_type(world: &World) -> Option<EventKey> {
+        world
+            .component_id::<EventWrapperComponent<Self>>()
+            .map(EventKey)
     }
 }
 
@@ -421,3 +424,28 @@ pub(crate) struct EventInstance<E: BufferedEvent> {
     pub event_id: EventId<E>,
     pub event: E,
 }
+
+/// # Warning
+///
+/// This struct should only be instantiated internally to this crate.
+///
+/// [`EventKey`]s are created in:
+/// - `crate::observer::trigger_dynamic_ref_with_caller`
+/// - `crate::observer::trigger_dynamic_ref_with_caller`
+/// - `crate::observer::observer_multiple_events`
+/// - `crate::observer::observer_dynamic_trigger`
+/// - `crate::observer::runner::hook_on_add`
+#[derive(Debug, Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct EventKey(pub(crate) ComponentId);
+
+impl EventKey {
+    /// Returns id of the underlying [`Event`].
+    /// Used internally in:
+    /// - [`crate::event::register_event`]
+    /// - [`crate::event::run_updates`]
+    /// - [`crate::event::deregister_events`]
+    #[inline]
+    pub(crate) fn component_id(&self) -> ComponentId {
+        self.0
+    }
+}

crates/bevy_ecs/src/event/mod.rs

@@ -11,7 +11,7 @@ mod update;
 mod writer;
 
 pub(crate) use base::EventInstance;
-pub use base::{BufferedEvent, EntityEvent, Event, EventId};
+pub use base::{BufferedEvent, EntityEvent, Event, EventId, EventKey};
 pub use bevy_ecs_macros::{BufferedEvent, EntityEvent, Event};
 pub use collections::{Events, SendBatchIds};
 pub use event_cursor::EventCursor;

crates/bevy_ecs/src/event/registry.rs

@@ -1,15 +1,16 @@
 use alloc::vec::Vec;
 use bevy_ecs::{
     change_detection::{DetectChangesMut, MutUntyped},
-    component::{ComponentId, Tick},
-    event::{BufferedEvent, Events},
+    component::Tick,
+    event::{BufferedEvent, EventKey, Events},
     resource::Resource,
     world::World,
 };
 
 #[doc(hidden)]
 struct RegisteredEvent {
-    component_id: ComponentId,
+    event_type: EventKey,
+    // event_type:
     // Required to flush the secondary buffer and drop events even if left unchanged.
     previously_updated: bool,
     // SAFETY: The component ID and the function must be used to fetch the Events<T> resource
@@ -51,7 +52,7 @@ impl EventRegistry {
         let component_id = world.init_resource::<Events<T>>();
         let mut registry = world.get_resource_or_init::<Self>();
         registry.event_updates.push(RegisteredEvent {
-            component_id,
+            event_type: EventKey(component_id),
             previously_updated: false,
             update: |ptr| {
                 // SAFETY: The resource was initialized with the type Events<T>.
@@ -66,7 +67,9 @@ impl EventRegistry {
     pub fn run_updates(&mut self, world: &mut World, last_change_tick: Tick) {
         for registered_event in &mut self.event_updates {
             // Bypass the type ID -> Component ID lookup with the cached component ID.
-            if let Some(events) = world.get_resource_mut_by_id(registered_event.component_id) {
+            if let Some(events) =
+                world.get_resource_mut_by_id(registered_event.event_type.component_id())
+            {
                 let has_changed = events.has_changed_since(last_change_tick);
                 if registered_event.previously_updated || has_changed {
                     // SAFETY: The update function pointer is called with the resource
@@ -87,7 +90,7 @@ impl EventRegistry {
         let mut registry = world.get_resource_or_init::<Self>();
         registry
             .event_updates
-            .retain(|e| e.component_id != component_id);
+            .retain(|e| e.event_type.component_id() != component_id);
         world.remove_resource::<Events<T>>();
     }
 }

crates/bevy_ecs/src/lib.rs

@@ -79,7 +79,8 @@ pub mod prelude {
         entity::{ContainsEntity, Entity, EntityMapper},
         error::{BevyError, Result},
         event::{
-            BufferedEvent, EntityEvent, Event, EventMutator, EventReader, EventWriter, Events,
+            BufferedEvent, EntityEvent, Event, EventKey, EventMutator, EventReader, EventWriter,
+            Events,
         },
         hierarchy::{ChildOf, ChildSpawner, ChildSpawnerCommands, Children},
         lifecycle::{

crates/bevy_ecs/src/lifecycle.rs

@@ -55,7 +55,7 @@ use crate::{
     entity::Entity,
     event::{
         BufferedEvent, EntityEvent, Event, EventCursor, EventId, EventIterator,
-        EventIteratorWithId, Events,
+        EventIteratorWithId, EventKey, Events,
     },
     query::FilteredAccessSet,
     relationship::RelationshipHookMode,
@@ -314,16 +314,16 @@ impl ComponentHooks {
     }
 }
 
-/// [`ComponentId`] for [`Add`]
-pub const ADD: ComponentId = ComponentId::new(0);
-/// [`ComponentId`] for [`Insert`]
-pub const INSERT: ComponentId = ComponentId::new(1);
-/// [`ComponentId`] for [`Replace`]
-pub const REPLACE: ComponentId = ComponentId::new(2);
-/// [`ComponentId`] for [`Remove`]
-pub const REMOVE: ComponentId = ComponentId::new(3);
-/// [`ComponentId`] for [`Despawn`]
-pub const DESPAWN: ComponentId = ComponentId::new(4);
+/// [`EventKey`] for [`Add`]
+pub const ADD: EventKey = EventKey(ComponentId::new(0));
+/// [`EventKey`] for [`Insert`]
+pub const INSERT: EventKey = EventKey(ComponentId::new(1));
+/// [`EventKey`] for [`Replace`]
+pub const REPLACE: EventKey = EventKey(ComponentId::new(2));
+/// [`EventKey`] for [`Remove`]
+pub const REMOVE: EventKey = EventKey(ComponentId::new(3));
+/// [`EventKey`] for [`Despawn`]
+pub const DESPAWN: EventKey = EventKey(ComponentId::new(4));
 
 /// Trigger emitted when a component is inserted onto an entity that does not already have that
 /// component. Runs before `Insert`.