Replace all labels with interned labels

crates/bevy_app/src/app.rs

@@ -4,11 +4,11 @@ use bevy_ecs::{
  prelude::*,
  schedule::{
  apply_state_transition, common_conditions::run_once as run_once_condition,
- run_enter_schedule, BoxedScheduleLabel, IntoSystemConfigs, IntoSystemSetConfigs,
+ run_enter_schedule, InternedScheduleLabel, IntoSystemConfigs, IntoSystemSetConfigs,
  ScheduleBuildSettings, ScheduleLabel,
  },
 };
-use bevy_utils::{tracing::debug, HashMap, HashSet};
+use bevy_utils::{intern::Interned, tracing::debug, HashMap, HashSet};
 use std::{
  fmt::Debug,
  panic::{catch_unwind, resume_unwind, AssertUnwindSafe},
@@ -20,10 +20,14 @@ use bevy_utils::tracing::info_span;
 bevy_utils::define_label!(
  /// A strongly-typed class of labels used to identify an [`App`].
  AppLabel,
- /// A strongly-typed identifier for an [`AppLabel`].
- AppLabelId,
+ APP_LABEL_INTERNER
 );
 
+pub use bevy_utils::label::DynEq;
+
+/// A shorthand for `Interned<dyn AppLabel>`.
+pub type InternedAppLabel = Interned<dyn AppLabel>;
+
 pub(crate) enum AppError {
  DuplicatePlugin { plugin_name: String },
 }
@@ -70,8 +74,8 @@ pub struct App {
  /// The schedule that runs the main loop of schedule execution.
  ///
  /// This is initially set to [`Main`].
- pub main_schedule_label: BoxedScheduleLabel,
- sub_apps: HashMap<AppLabelId, SubApp>,
+ pub main_schedule_label: InternedScheduleLabel,
+ sub_apps: HashMap<InternedAppLabel, SubApp>,
  plugin_registry: Vec<Box<dyn Plugin>>,
  plugin_name_added: HashSet<String>,
  /// A private counter to prevent incorrect calls to `App::run()` from `Plugin::build()`
@@ -156,7 +160,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();
  }
 
@@ -219,7 +223,7 @@ impl App {
  sub_apps: HashMap::default(),
  plugin_registry: Vec::default(),
  plugin_name_added: Default::default(),
- main_schedule_label: Box::new(Main),
+ main_schedule_label: Main.intern(),
  building_plugin_depth: 0,
  }
  }
@@ -241,7 +245,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 &mut self.sub_apps {
  #[cfg(feature = "trace")]
@@ -379,9 +383,10 @@ impl App {
  schedule: impl ScheduleLabel,
  systems: impl IntoSystemConfigs<M>,
  ) -> &mut Self {
+ let schedule = schedule.intern();
  let mut schedules = self.world.resource_mut::<Schedules>();
 
- if let Some(schedule) = schedules.get_mut(&schedule) {
+ if let Some(schedule) = schedules.get_mut(schedule) {
  schedule.add_systems(systems);
  } else {
  let mut new_schedule = Schedule::new(schedule);
@@ -410,8 +415,9 @@ impl App {
  schedule: impl ScheduleLabel,
  sets: impl IntoSystemSetConfigs,
  ) -> &mut Self {
+ let schedule = schedule.intern();
  let mut schedules = self.world.resource_mut::<Schedules>();
- if let Some(schedule) = schedules.get_mut(&schedule) {
+ if let Some(schedule) = schedules.get_mut(schedule) {
  schedule.configure_sets(sets);
  } else {
  let mut new_schedule = Schedule::new(schedule);
@@ -746,16 +752,15 @@ impl App {
  pub fn sub_app_mut(&mut self, label: impl AppLabel) -> &mut App {
  match self.get_sub_app_mut(label) {
  Ok(app) => app,
- Err(label) => panic!("Sub-App with label '{:?}' does not exist", label.as_str()),
+ Err(label) => panic!("Sub-App with label '{:?}' does not exist", label),
  }
  }
 
  /// 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_mut(&mut self, label: impl AppLabel) -> Result<&mut App, AppLabelId> {
- let label = label.as_label();
+ pub fn get_sub_app_mut(&mut self, label: impl AppLabel) -> Result<&mut App, impl AppLabel> {
  self.sub_apps
- .get_mut(&label)
+ .get_mut(&label.intern())
  .map(|sub_app| &mut sub_app.app)
  .ok_or(label)
  }
@@ -768,25 +773,25 @@ impl App {
  pub fn sub_app(&self, label: impl AppLabel) -> &App {
  match self.get_sub_app(label) {
  Ok(app) => app,
- Err(label) => panic!("Sub-App with label '{:?}' does not exist", label.as_str()),
+ Err(label) => panic!("Sub-App with label '{:?}' does not exist", label),
  }
  }
 
  /// 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_label(), sub_app);
+ self.sub_apps.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(&label.as_label())
+ self.sub_apps.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(&label.as_label())
+ .get(&label.intern())
  .map(|sub_app| &sub_app.app)
  .ok_or(label)
  }
@@ -807,8 +812,9 @@ 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 = label.intern();
  let mut schedules = self.world.resource_mut::<Schedules>();
- if !schedules.contains(&label) {
+ if !schedules.contains(label) {
  schedules.insert(Schedule::new(label));
  }
  self
@@ -817,15 +823,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)
+ 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)
+ schedules.into_inner().get_mut(label)
  }
 
  /// Applies the function to the [`Schedule`] associated with `label`.
@@ -836,13 +842,14 @@ impl App {
  label: impl ScheduleLabel,
  f: impl FnOnce(&mut Schedule),
  ) -> &mut Self {
+ let label = label.intern();
  let mut schedules = self.world.resource_mut::<Schedules>();
 
- if schedules.get(&label).is_none() {
- schedules.insert(Schedule::new(label.dyn_clone()));
+ if schedules.get(label).is_none() {
+ schedules.insert(Schedule::new(label));
  }
 
- let schedule = schedules.get_mut(&label).unwrap();
+ let schedule = schedules.get_mut(label).unwrap();
  // Call the function f, passing in the schedule retrieved
  f(schedule);
 
@@ -964,6 +971,8 @@ pub struct AppExit;
 
 #[cfg(test)]
 mod tests {
+ use std::marker::PhantomData;
+
  use bevy_ecs::{
  schedule::{OnEnter, States},
  system::Commands,
@@ -1060,4 +1069,107 @@ mod tests {
  app.world.run_schedule(OnEnter(AppState::MainMenu));
  assert_eq!(app.world.entities().len(), 2);
  }
+
+ #[test]
+ fn test_derive_app_label() {
+ use super::AppLabel;
+ use crate::{self as bevy_app};
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ struct UnitLabel;
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ struct TupleLabel(u32, u32);
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ struct StructLabel {
+ a: u32,
+ b: u32,
+ }
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ struct EmptyTupleLabel();
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ struct EmptyStructLabel {}
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ enum EnumLabel {
+ #[default]
+ Unit,
+ Tuple(u32, u32),
+ Struct {
+ a: u32,
+ b: u32,
+ },
+ }
+
+ #[derive(AppLabel, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+ struct GenericLabel<T>(PhantomData<T>);
+
+ assert_eq!(UnitLabel.intern(), UnitLabel.intern());
+ assert_eq!(EnumLabel::Unit.intern(), EnumLabel::Unit.intern());
+ assert_ne!(UnitLabel.intern(), EnumLabel::Unit.intern());
+ assert_ne!(UnitLabel.intern(), TupleLabel(0, 0).intern());
+ assert_ne!(EnumLabel::Unit.intern(), EnumLabel::Tuple(0, 0).intern());
+
+ assert_eq!(TupleLabel(0, 0).intern(), TupleLabel(0, 0).intern());
+ assert_eq!(
+ EnumLabel::Tuple(0, 0).intern(),
+ EnumLabel::Tuple(0, 0).intern()
+ );
+ assert_ne!(TupleLabel(0, 0).intern(), TupleLabel(0, 1).intern());
+ assert_ne!(
+ EnumLabel::Tuple(0, 0).intern(),
+ EnumLabel::Tuple(0, 1).intern()
+ );
+ assert_ne!(TupleLabel(0, 0).intern(), EnumLabel::Tuple(0, 0).intern());
+ assert_ne!(
+ TupleLabel(0, 0).intern(),
+ StructLabel { a: 0, b: 0 }.intern()
+ );
+ assert_ne!(
+ EnumLabel::Tuple(0, 0).intern(),
+ EnumLabel::Struct { a: 0, b: 0 }.intern()
+ );
+
+ assert_eq!(
+ StructLabel { a: 0, b: 0 }.intern(),
+ StructLabel { a: 0, b: 0 }.intern()
+ );
+ assert_eq!(
+ EnumLabel::Struct { a: 0, b: 0 }.intern(),
+ EnumLabel::Struct { a: 0, b: 0 }.intern()
+ );
+ assert_ne!(
+ StructLabel { a: 0, b: 0 }.intern(),
+ StructLabel { a: 0, b: 1 }.intern()
+ );
+ assert_ne!(
+ EnumLabel::Struct { a: 0, b: 0 }.intern(),
+ EnumLabel::Struct { a: 0, b: 1 }.intern()
+ );
+ assert_ne!(
+ StructLabel { a: 0, b: 0 }.intern(),
+ EnumLabel::Struct { a: 0, b: 0 }.intern()
+ );
+ assert_ne!(
+ StructLabel { a: 0, b: 0 }.intern(),
+ EnumLabel::Struct { a: 0, b: 0 }.intern()
+ );
+ assert_ne!(StructLabel { a: 0, b: 0 }.intern(), UnitLabel.intern(),);
+ assert_ne!(
+ EnumLabel::Struct { a: 0, b: 0 }.intern(),
+ EnumLabel::Unit.intern()
+ );
+
+ assert_eq!(
+ GenericLabel::<u32>(PhantomData).intern(),
+ GenericLabel::<u32>(PhantomData).intern()
+ );
+ assert_ne!(
+ GenericLabel::<u32>(PhantomData).intern(),
+ GenericLabel::<u64>(PhantomData).intern()
+ );
+ }
 }

crates/bevy_app/src/main_schedule.rs

@@ -1,6 +1,6 @@
 use crate::{App, Plugin};
 use bevy_ecs::{
- schedule::{ExecutorKind, Schedule, ScheduleLabel},
+ schedule::{ExecutorKind, InternedScheduleLabel, Schedule, ScheduleLabel},
  system::{Local, Resource},
  world::{Mut, World},
 };
@@ -105,21 +105,21 @@ 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(SpawnScene),
- Box::new(PostUpdate),
- Box::new(Last),
+ First.intern(),
+ PreUpdate.intern(),
+ StateTransition.intern(),
+ RunFixedUpdateLoop.intern(),
+ Update.intern(),
+ SpawnScene.intern(),
+ PostUpdate.intern(),
+ Last.intern(),
  ],
  }
  }
@@ -133,7 +133,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());
  }
 }
 
@@ -148,8 +148,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_derive/src/lib.rs

@@ -201,12 +201,13 @@ pub fn derive_enum_variant_meta(input: TokenStream) -> TokenStream {
 
 /// Generates an impl of the `AppLabel` trait.
 ///
-/// This works only for unit structs, or enums with only unit variants.
-/// You may force a struct or variant to behave as if it were fieldless with `#[app_label(ignore_fields)]`.
-#[proc_macro_derive(AppLabel, attributes(app_label))]
+/// This does not work for unions.
+#[proc_macro_derive(AppLabel)]
 pub fn derive_app_label(input: TokenStream) -> TokenStream {
  let input = syn::parse_macro_input!(input as syn::DeriveInput);
  let mut trait_path = BevyManifest::default().get_path("bevy_app");
+ let mut dyn_eq_path = trait_path.clone();
  trait_path.segments.push(format_ident!("AppLabel").into());
- derive_label(input, &trait_path, "app_label")
+ dyn_eq_path.segments.push(format_ident!("DynEq").into());
+ derive_label(input, "AppLabel", &trait_path, &dyn_eq_path)
 }