Replace boxed labels with interned labels

Author: geieredgar

crates/bevy_app/src/app.rs

@@ -4,7 +4,7 @@ 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,
         ScheduleLabel,
     },
 };
@@ -70,7 +70,7 @@ pub struct App {
     /// The schedule that runs the main loop of schedule execution.
     ///
     /// This is initially set to [`Main`].
-    pub main_schedule_label: BoxedScheduleLabel,
+    pub main_schedule_label: InternedScheduleLabel,
     sub_apps: HashMap<AppLabelId, SubApp>,
     plugin_registry: Vec<Box<dyn Plugin>>,
     plugin_name_added: HashSet<String>,
@@ -219,7 +219,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.into(),
             building_plugin_depth: 0,
         }
     }
@@ -379,9 +379,10 @@ impl App {
         schedule: impl ScheduleLabel,
         systems: impl IntoSystemConfigs<M>,
     ) -> &mut Self {
+        let schedule: InternedScheduleLabel = (&schedule as &dyn ScheduleLabel).into();
         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();
@@ -398,8 +399,9 @@ impl App {
         schedule: impl ScheduleLabel,
         set: impl IntoSystemSetConfig,
     ) -> &mut Self {
+        let schedule: InternedScheduleLabel = (&schedule as &dyn ScheduleLabel).into();
         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_set(set);
         } else {
             let mut new_schedule = Schedule::new();
@@ -415,8 +417,9 @@ impl App {
         schedule: impl ScheduleLabel,
         sets: impl IntoSystemSetConfigs,
     ) -> &mut Self {
+        let schedule: InternedScheduleLabel = (&schedule as &dyn ScheduleLabel).into();
         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();
@@ -797,7 +800,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, schedule);
+        schedules.insert(&label as &dyn ScheduleLabel, schedule);
 
         self
     }
@@ -806,8 +809,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: InternedScheduleLabel = (&label as &dyn ScheduleLabel).into();
         let mut schedules = self.world.resource_mut::<Schedules>();
-        if !schedules.contains(&label) {
+        if !schedules.contains(label) {
             schedules.insert(label, Schedule::new());
         }
         self
@@ -816,15 +820,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 as &dyn ScheduleLabel)
     }
 
     /// 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 as &dyn ScheduleLabel)
     }
 
     /// Applies the function to the [`Schedule`] associated with `label`.
@@ -835,13 +839,14 @@ impl App {
         label: impl ScheduleLabel,
         f: impl FnOnce(&mut Schedule),
     ) -> &mut Self {
+        let label: InternedScheduleLabel = (&label as &dyn ScheduleLabel).into();
         let mut schedules = self.world.resource_mut::<Schedules>();
 
-        if schedules.get(&label).is_none() {
-            schedules.insert(label.dyn_clone(), Schedule::new());
+        if schedules.get(label).is_none() {
+            schedules.insert(label, Schedule::new());
         }
 
-        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);
 

crates/bevy_ecs/macros/src/lib.rs

@@ -7,7 +7,7 @@ mod states;
 
 use crate::{fetch::derive_world_query_impl, set::derive_set};
 use bevy_macro_utils::{
-    derive_boxed_label, ensure_no_collision, get_named_struct_fields, BevyManifest,
+    derive_interned_label, ensure_no_collision, get_named_struct_fields, BevyManifest,
 };
 use proc_macro::TokenStream;
 use proc_macro2::Span;
@@ -435,7 +435,7 @@ pub fn derive_schedule_label(input: TokenStream) -> TokenStream {
     trait_path
         .segments
         .push(format_ident!("ScheduleLabel").into());
-    derive_boxed_label(input, &trait_path)
+    derive_interned_label(input, &trait_path)
 }
 
 /// Derive macro generating an impl of the trait `SystemSet`.

crates/bevy_ecs/macros/src/set.rs

@@ -1,5 +1,6 @@
 use proc_macro::TokenStream;
-use quote::quote;
+use quote::{quote, quote_spanned};
+use syn::spanned::Spanned;
 
 /// Derive a set trait
 ///
@@ -21,12 +22,56 @@ pub fn derive_set(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStrea
         })
         .unwrap(),
     );
-
+    let dyn_static_ref_impl = match input.data {
+        syn::Data::Struct(data) => {
+            if data.fields.is_empty() {
+                quote! { std::option::Option::Some(&Self) }
+            } else {
+                quote! { std::option::Option::None }
+            }
+        }
+        syn::Data::Enum(data) => {
+            let mut use_fallback_variant = false;
+            let variants: Vec<_> = data
+                .variants
+                .into_iter()
+                .filter_map(|variant| {
+                    if variant.fields.is_empty() {
+                        let span = variant.span();
+                        let variant_ident = variant.ident;
+                        Some(quote_spanned! { span => Self::#variant_ident => std::option::Option::Some(&Self::#variant_ident), })
+                    } else {
+                        use_fallback_variant = true;
+                        None
+                    }
+                })
+                .collect();
+            if use_fallback_variant {
+                quote! {
+                    match self {
+                        #(#variants)*
+                        _ => None
+                    }
+                }
+            } else {
+                quote! {
+                    match self {
+                        #(#variants)*
+                    }
+                }
+            }
+        }
+        syn::Data::Union(_) => quote! { std::option::Option::None },
+    };
     (quote! {
         impl #impl_generics #trait_path for #ident #ty_generics #where_clause {
             fn dyn_clone(&self) -> std::boxed::Box<dyn #trait_path> {
                 std::boxed::Box::new(std::clone::Clone::clone(self))
             }
+
+            fn dyn_static_ref(&self) -> std::option::Option<&'static dyn #trait_path> {
+                #dyn_static_ref_impl
+            }
         }
     })
     .into()