simplify interning APIs

Author: joseph-gio

crates/bevy_app/src/app.rs

@@ -158,7 +158,7 @@ impl SubApp {
 
     /// Runs the [`SubApp`]'s default schedule.
     pub fn run(&mut self) {
-        self.app.world.run_schedule(&*self.app.main_schedule_label);
+        self.app.world.run_schedule(self.app.main_schedule_label);
         self.app.world.clear_trackers();
     }
 
@@ -221,7 +221,7 @@ impl App {
             sub_apps: HashMap::default(),
             plugin_registry: Vec::default(),
             plugin_name_added: Default::default(),
-            main_schedule_label: Main.into(),
+            main_schedule_label: Main.intern(),
             building_plugin_depth: 0,
         }
     }
@@ -243,7 +243,7 @@ impl App {
         {
             #[cfg(feature = "trace")]
             let _bevy_main_update_span = info_span!("main app").entered();
-            self.world.run_schedule(&*self.main_schedule_label);
+            self.world.run_schedule(self.main_schedule_label);
         }
         for (_label, sub_app) in self.sub_apps.iter_mut() {
             #[cfg(feature = "trace")]
@@ -381,7 +381,7 @@ impl App {
         schedule: impl ScheduleLabel,
         systems: impl IntoSystemConfigs<M>,
     ) -> &mut Self {
-        let schedule = InternedScheduleLabel::from(&schedule as &dyn ScheduleLabel);
+        let schedule = schedule.intern();
         let mut schedules = self.world.resource_mut::<Schedules>();
 
         if let Some(schedule) = schedules.get_mut(schedule) {
@@ -401,7 +401,7 @@ impl App {
         schedule: impl ScheduleLabel,
         set: impl IntoSystemSetConfig,
     ) -> &mut Self {
-        let schedule = InternedScheduleLabel::from(&schedule as &dyn ScheduleLabel);
+        let schedule = schedule.intern();
         let mut schedules = self.world.resource_mut::<Schedules>();
         if let Some(schedule) = schedules.get_mut(schedule) {
             schedule.configure_set(set);
@@ -419,7 +419,7 @@ impl App {
         schedule: impl ScheduleLabel,
         sets: impl IntoSystemSetConfigs,
     ) -> &mut Self {
-        let schedule = InternedScheduleLabel::from(&schedule as &dyn ScheduleLabel);
+        let schedule = schedule.intern();
         let mut schedules = self.world.resource_mut::<Schedules>();
         if let Some(schedule) = schedules.get_mut(schedule) {
             schedule.configure_sets(sets);
@@ -759,7 +759,7 @@ impl App {
     /// an [`Err`] containing the given label.
     pub fn get_sub_app_mut(&mut self, label: impl AppLabel) -> Result<&mut App, impl AppLabel> {
         self.sub_apps
-            .get_mut(&InternedAppLabel::from(&label as &dyn AppLabel))
+            .get_mut(&label.intern())
             .map(|sub_app| &mut sub_app.app)
             .ok_or(label)
     }
@@ -779,20 +779,20 @@ impl App {
     /// Inserts an existing sub app into the app
     pub fn insert_sub_app(&mut self, label: impl AppLabel, sub_app: SubApp) {
         self.sub_apps
-            .insert((&label as &dyn AppLabel).into(), sub_app);
+            .insert(label.intern(), sub_app);
     }
 
     /// Removes a sub app from the app. Returns [`None`] if the label doesn't exist.
     pub fn remove_sub_app(&mut self, label: impl AppLabel) -> Option<SubApp> {
         self.sub_apps
-            .remove(&InternedAppLabel::from(&label as &dyn AppLabel))
+            .remove(&label.intern())
     }
 
     /// Retrieves a `SubApp` inside this [`App`] with the given label, if it exists. Otherwise returns
     /// an [`Err`] containing the given label.
     pub fn get_sub_app(&self, label: impl AppLabel) -> Result<&App, impl AppLabel> {
         self.sub_apps
-            .get(&InternedAppLabel::from(&label as &dyn AppLabel))
+            .get(&label.intern())
             .map(|sub_app| &sub_app.app)
             .ok_or(label)
     }
@@ -804,7 +804,7 @@ impl App {
     /// To avoid this behavior, use the `init_schedule` method instead.
     pub fn add_schedule(&mut self, label: impl ScheduleLabel, schedule: Schedule) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
-        schedules.insert(&label as &dyn ScheduleLabel, schedule);
+        schedules.insert(label, schedule);
 
         self
     }
@@ -813,7 +813,7 @@ impl App {
     ///
     /// See [`App::add_schedule`] to pass in a pre-constructed schedule.
     pub fn init_schedule(&mut self, label: impl ScheduleLabel) -> &mut Self {
-        let label = InternedScheduleLabel::from(&label as &dyn ScheduleLabel);
+        let label = label.intern();
         let mut schedules = self.world.resource_mut::<Schedules>();
         if !schedules.contains(label) {
             schedules.insert(label, Schedule::new());
@@ -824,15 +824,15 @@ impl App {
     /// Gets read-only access to the [`Schedule`] with the provided `label` if it exists.
     pub fn get_schedule(&self, label: impl ScheduleLabel) -> Option<&Schedule> {
         let schedules = self.world.get_resource::<Schedules>()?;
-        schedules.get(&label as &dyn ScheduleLabel)
+        schedules.get(label)
     }
 
     /// Gets read-write access to a [`Schedule`] with the provided `label` if it exists.
     pub fn get_schedule_mut(&mut self, label: impl ScheduleLabel) -> Option<&mut Schedule> {
         let schedules = self.world.get_resource_mut::<Schedules>()?;
         // We need to call .into_inner here to satisfy the borrow checker:
         // it can reason about reborrows using ordinary references but not the `Mut` smart pointer.
-        schedules.into_inner().get_mut(&label as &dyn ScheduleLabel)
+        schedules.into_inner().get_mut(label)
     }
 
     /// Applies the function to the [`Schedule`] associated with `label`.
@@ -843,7 +843,7 @@ impl App {
         label: impl ScheduleLabel,
         f: impl FnOnce(&mut Schedule),
     ) -> &mut Self {
-        let label = InternedScheduleLabel::from(&label as &dyn ScheduleLabel);
+        let label = label.intern();
         let mut schedules = self.world.resource_mut::<Schedules>();
 
         if schedules.get(label).is_none() {

crates/bevy_app/src/main_schedule.rs

@@ -1,6 +1,6 @@
 use crate::{App, Plugin};
 use bevy_ecs::{
-    schedule::{ExecutorKind, Schedule, ScheduleLabel},
+    schedule::{ExecutorKind, Schedule, ScheduleLabel, InternedScheduleLabel},
     system::{Local, Resource},
     world::{Mut, World},
 };
@@ -100,20 +100,20 @@ pub struct Last;
 #[derive(Resource, Debug)]
 pub struct MainScheduleOrder {
     /// The labels to run for the [`Main`] schedule (in the order they will be run).
-    pub labels: Vec<Box<dyn ScheduleLabel>>,
+    pub labels: Vec<InternedScheduleLabel>,
 }
 
 impl Default for MainScheduleOrder {
     fn default() -> Self {
         Self {
             labels: vec![
-                Box::new(First),
-                Box::new(PreUpdate),
-                Box::new(StateTransition),
-                Box::new(RunFixedUpdateLoop),
-                Box::new(Update),
-                Box::new(PostUpdate),
-                Box::new(Last),
+                First.intern(),
+                PreUpdate.intern(),
+                StateTransition.intern(),
+                RunFixedUpdateLoop.intern(),
+                Update.intern(),
+                PostUpdate.intern(),
+                Last.intern(),
             ],
         }
     }
@@ -127,7 +127,7 @@ impl MainScheduleOrder {
             .iter()
             .position(|current| (**current).eq(&after))
             .unwrap_or_else(|| panic!("Expected {after:?} to exist"));
-        self.labels.insert(index + 1, Box::new(schedule));
+        self.labels.insert(index + 1, schedule.intern());
     }
 }
 
@@ -142,8 +142,8 @@ impl Main {
         }
 
         world.resource_scope(|world, order: Mut<MainScheduleOrder>| {
-            for label in &order.labels {
-                let _ = world.try_run_schedule(&**label);
+            for &label in &order.labels {
+                let _ = world.try_run_schedule(label);
             }
         });
     }

crates/bevy_ecs/src/schedule/config.rs

@@ -307,20 +307,20 @@ impl IntoSystemConfigs<()> for SystemConfigs {
             "adding arbitrary systems to a system type set is not allowed"
         );
 
-        self.in_set_inner((&set as &dyn SystemSet).into());
+        self.in_set_inner(set.intern());
 
         self
     }
 
     fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
         let set = set.into_system_set();
-        self.before_inner((&set as &dyn SystemSet).into());
+        self.before_inner(set.intern());
         self
     }
 
     fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
         let set = set.into_system_set();
-        self.after_inner((&set as &dyn SystemSet).into());
+        self.after_inner(set.intern());
         self
     }
 
@@ -331,7 +331,7 @@ impl IntoSystemConfigs<()> for SystemConfigs {
 
     fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
         let set = set.into_system_set();
-        self.ambiguous_with_inner((&set as &dyn SystemSet).into());
+        self.ambiguous_with_inner(set.intern());
         self
     }
 
@@ -445,7 +445,7 @@ pub trait IntoSystemSetConfig: Sized {
 
 impl<S: SystemSet> IntoSystemSetConfig for S {
     fn into_config(self) -> SystemSetConfig {
-        SystemSetConfig::new((&self as &dyn SystemSet).into())
+        SystemSetConfig::new(self.intern())
     }
 }
 
@@ -460,22 +460,22 @@ impl IntoSystemSetConfig for SystemSetConfig {
             set.system_type().is_none(),
             "adding arbitrary systems to a system type set is not allowed"
         );
-        self.graph_info.sets.push((&set as &dyn SystemSet).into());
+        self.graph_info.sets.push(set.intern());
         self
     }
 
     fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
         self.graph_info.dependencies.push(Dependency::new(
             DependencyKind::Before,
-            (&set.into_system_set() as &dyn SystemSet).into(),
+            set.into_system_set().intern(),
         ));
         self
     }
 
     fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
         self.graph_info.dependencies.push(Dependency::new(
             DependencyKind::After,
-            (&set.into_system_set() as &dyn SystemSet).into(),
+            set.into_system_set().intern(),
         ));
         self
     }
@@ -488,7 +488,7 @@ impl IntoSystemSetConfig for SystemSetConfig {
     fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
         ambiguous_with(
             &mut self.graph_info,
-            (&set.into_system_set() as &dyn SystemSet).into(),
+            set.into_system_set().intern(),
         );
         self
     }
@@ -563,14 +563,14 @@ impl IntoSystemSetConfigs for SystemSetConfigs {
             "adding arbitrary systems to a system type set is not allowed"
         );
         for config in &mut self.sets {
-            config.graph_info.sets.push((&set as &dyn SystemSet).into());
+            config.graph_info.sets.push(set.intern());
         }
 
         self
     }
 
     fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = (&set.into_system_set() as &dyn SystemSet).into();
+        let set = set.into_system_set().intern();
         for config in &mut self.sets {
             config
                 .graph_info
@@ -582,7 +582,7 @@ impl IntoSystemSetConfigs for SystemSetConfigs {
     }
 
     fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = (&set.into_system_set() as &dyn SystemSet).into();
+        let set = set.into_system_set().intern();
         for config in &mut self.sets {
             config
                 .graph_info
@@ -594,7 +594,7 @@ impl IntoSystemSetConfigs for SystemSetConfigs {
     }
 
     fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = (&set.into_system_set() as &dyn SystemSet).into();
+        let set = set.into_system_set().intern();
         for config in &mut self.sets {
             ambiguous_with(&mut config.graph_info, set);
         }

crates/bevy_ecs/src/schedule/schedule.rs

@@ -43,38 +43,38 @@ impl Schedules {
     /// and the old schedule is returned. Otherwise, `None` is returned.
     pub fn insert(
         &mut self,
-        label: impl Into<InternedScheduleLabel>,
+        label: impl ScheduleLabel,
         schedule: Schedule,
     ) -> Option<Schedule> {
-        self.inner.insert(label.into(), schedule)
+        self.inner.insert(label.intern(), schedule)
     }
 
     /// Removes the schedule corresponding to the `label` from the map, returning it if it existed.
-    pub fn remove(&mut self, label: impl Into<InternedScheduleLabel>) -> Option<Schedule> {
-        self.inner.remove(&label.into())
+    pub fn remove(&mut self, label: impl ScheduleLabel) -> Option<Schedule> {
+        self.inner.remove(&label.intern ())
     }
 
     /// Removes the (schedule, label) pair corresponding to the `label` from the map, returning it if it existed.
     pub fn remove_entry(
         &mut self,
-        label: impl Into<InternedScheduleLabel>,
+        label: impl ScheduleLabel,
     ) -> Option<(InternedScheduleLabel, Schedule)> {
-        self.inner.remove_entry(&label.into())
+        self.inner.remove_entry(&label.intern())
     }
 
     /// Does a schedule with the provided label already exist?
-    pub fn contains(&self, label: impl Into<InternedScheduleLabel>) -> bool {
-        self.inner.contains_key(&label.into())
+    pub fn contains(&self, label: impl ScheduleLabel) -> bool {
+        self.inner.contains_key(&label.intern())
     }
 
     /// Returns a reference to the schedule associated with `label`, if it exists.
-    pub fn get(&self, label: impl Into<InternedScheduleLabel>) -> Option<&Schedule> {
-        self.inner.get(&label.into())
+    pub fn get(&self, label: impl ScheduleLabel) -> Option<&Schedule> {
+        self.inner.get(&label.intern())
     }
 
     /// Returns a mutable reference to the schedule associated with `label`, if it exists.
-    pub fn get_mut(&mut self, label: impl Into<InternedScheduleLabel>) -> Option<&mut Schedule> {
-        self.inner.get_mut(&label.into())
+    pub fn get_mut(&mut self, label: impl ScheduleLabel) -> Option<&mut Schedule> {
+        self.inner.get_mut(&label.intern())
     }
 
     /// Returns an iterator over all schedules. Iteration order is undefined.
@@ -537,7 +537,7 @@ impl ScheduleGraph {
                     if more_than_one_entry {
                         let set = self.create_anonymous_set();
                         for config in &mut configs {
-                            config.in_set_inner((&set as &dyn SystemSet).into());
+                            config.in_set_inner(set.intern());
                         }
                         let mut set_config = set.into_config();
                         set_config.conditions.extend(collective_conditions);
@@ -721,8 +721,7 @@ impl ScheduleGraph {
         id
     }
 
-    fn check_set(&mut self, id: &NodeId, set: &dyn SystemSet) -> Result<(), ScheduleBuildError> {
-        let set = set.into();
+    fn check_set(&mut self, id: &NodeId, set: InternedSystemSet) -> Result<(), ScheduleBuildError> {
         match self.system_set_ids.get(&set) {
             Some(set_id) => {
                 if id == set_id {
@@ -748,8 +747,8 @@ impl ScheduleGraph {
         id: &NodeId,
         graph_info: &GraphInfo,
     ) -> Result<(), ScheduleBuildError> {
-        for set in &graph_info.sets {
-            self.check_set(id, &**set)?;
+        for &set in &graph_info.sets {
+            self.check_set(id, set)?;
         }
 
         Ok(())