Replace boxed labels with interned labels

Author: geieredgar

benches/benches/bevy_ecs/scheduling/schedule.rs

@@ -69,8 +69,8 @@ pub fn build_schedule(criterion: &mut Criterion) {
     struct DummySet;
 
     impl SystemSet for NumSet {
-        fn dyn_clone(&self) -> Box<dyn SystemSet> {
-            Box::new(self.clone())
+        fn dyn_leak(&self) -> &'static dyn SystemSet {
+            Box::leak(Box::new(self.clone()))
         }
     }
 

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, IntoSystemConfig, IntoSystemSetConfigs,
+        run_enter_schedule, InternedScheduleLabel, IntoSystemConfig, IntoSystemSetConfigs,
         ScheduleLabel,
     },
 };
@@ -69,11 +69,11 @@ pub struct App {
     /// The schedule that systems are added to by default.
     ///
     /// This is initially set to [`CoreSchedule::Main`].
-    pub default_schedule_label: BoxedScheduleLabel,
+    pub default_schedule_label: InternedScheduleLabel,
     /// The schedule that controls the outer loop of schedule execution.
     ///
     /// This is initially set to [`CoreSchedule::Outer`].
-    pub outer_schedule_label: BoxedScheduleLabel,
+    pub outer_schedule_label: InternedScheduleLabel,
     sub_apps: HashMap<AppLabelId, SubApp>,
     plugin_registry: Vec<Box<dyn Plugin>>,
     plugin_name_added: HashSet<String>,
@@ -223,8 +223,8 @@ impl App {
             sub_apps: HashMap::default(),
             plugin_registry: Vec::default(),
             plugin_name_added: Default::default(),
-            default_schedule_label: Box::new(CoreSchedule::Main),
-            outer_schedule_label: Box::new(CoreSchedule::Outer),
+            default_schedule_label: CoreSchedule::Main.dyn_intern(),
+            outer_schedule_label: CoreSchedule::Outer.dyn_intern(),
             is_building_plugin: false,
         }
     }
@@ -952,7 +952,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.dyn_intern(), schedule);
 
         self
     }
@@ -963,7 +963,7 @@ impl App {
     pub fn init_schedule(&mut self, label: impl ScheduleLabel) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
         if !schedules.contains(&label) {
-            schedules.insert(label, Schedule::new());
+            schedules.insert(label.dyn_intern(), Schedule::new());
         }
         self
     }
@@ -993,7 +993,7 @@ impl App {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
         if schedules.get(&label).is_none() {
-            schedules.insert(label.dyn_clone(), Schedule::new());
+            schedules.insert(label.dyn_intern(), Schedule::new());
         }
 
         let schedule = schedules.get_mut(&label).unwrap();

crates/bevy_ecs/macros/src/lib.rs

@@ -6,7 +6,7 @@ mod set;
 mod states;
 
 use crate::{fetch::derive_world_query_impl, set::derive_set};
-use bevy_macro_utils::{derive_boxed_label, get_named_struct_fields, BevyManifest};
+use bevy_macro_utils::{derive_interned_label, get_named_struct_fields, BevyManifest};
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use quote::{format_ident, quote};
@@ -465,7 +465,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,6 +1,9 @@
 use proc_macro::TokenStream;
-use quote::{quote, ToTokens};
-use syn::parse::{Parse, ParseStream};
+use quote::{quote, quote_spanned, ToTokens};
+use syn::{
+    parse::{Parse, ParseStream},
+    spanned::Spanned,
+};
 
 pub static SYSTEM_SET_ATTRIBUTE_NAME: &str = "system_set";
 pub static BASE_ATTRIBUTE_NAME: &str = "base";
@@ -64,15 +67,57 @@ pub fn derive_set(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStrea
         })
         .unwrap(),
     );
-
+    let fallback_leak =
+        quote! { std::boxed::Box::leak(std::boxed::Box::new(std::clone::Clone::clone(self))) };
+    let dyn_leak_impl = match input.data {
+        syn::Data::Struct(data) => {
+            if data.fields.is_empty() {
+                quote! { &Self }
+            } else {
+                fallback_leak
+            }
+        }
+        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 => &Self::#variant_ident, })
+                    } else {
+                        use_fallback_variant = true;
+                        None
+                    }
+                })
+                .collect();
+            if use_fallback_variant {
+                quote! {
+                    match self {
+                        #(#variants)*
+                        _ => #fallback_leak
+                    }
+                }
+            } else {
+                quote! {
+                    match self {
+                        #(#variants)*
+                    }
+                }
+            }
+        }
+        syn::Data::Union(_) => fallback_leak,
+    };
     (quote! {
         impl #impl_generics #trait_path for #ident #ty_generics #where_clause {
             fn is_base(&self) -> bool {
                 #is_base
             }
 
-            fn dyn_clone(&self) -> std::boxed::Box<dyn #trait_path> {
-                std::boxed::Box::new(std::clone::Clone::clone(self))
+            fn dyn_leak(&self) -> &'static dyn #trait_path {
+                #dyn_leak_impl
             }
         }
     })