interning

Author: maniwani

crates/bevy_app/src/app.rs

@@ -4,8 +4,7 @@ use bevy_ecs::{
     prelude::*,
     schedule::{
         apply_state_transition, common_conditions::run_once as run_once_condition,
-        run_enter_schedule, BoxedScheduleLabel, IntoSystemConfigs, IntoSystemSetConfigs,
-        ScheduleLabel,
+        run_enter_schedule, IntoSystemConfigs, IntoSystemSetConfigs, ScheduleId, ScheduleLabel,
     },
 };
 use bevy_utils::{tracing::debug, HashMap, HashSet};
@@ -70,7 +69,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: ScheduleId,
     sub_apps: HashMap<AppLabelId, SubApp>,
     plugin_registry: Vec<Box<dyn Plugin>>,
     plugin_name_added: HashSet<String>,
@@ -156,7 +155,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 +218,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.as_label(),
             building_plugin_depth: 0,
         }
     }
@@ -241,7 +240,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")]
@@ -745,7 +744,7 @@ 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),
         }
     }
 
@@ -767,7 +766,7 @@ 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),
         }
     }
 
@@ -837,11 +836,12 @@ impl App {
     ) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
-        if schedules.get(&label).is_none() {
-            schedules.insert(label.dyn_clone(), Schedule::new());
+        let id = ScheduleId::of(&label);
+        if !schedules.contains(&id) {
+            schedules.insert(id, Schedule::new());
         }
 
-        let schedule = schedules.get_mut(&label).unwrap();
+        let schedule = schedules.get_mut(&id).unwrap();
         // Call the function f, passing in the schedule retrieved
         f(schedule);
 

crates/bevy_app/src/main_schedule.rs

@@ -125,7 +125,7 @@ impl MainScheduleOrder {
         let index = self
             .labels
             .iter()
-            .position(|current| (**current).eq(&after))
+            .position(|current| (current.as_dyn_eq()).dyn_eq(after.as_dyn_eq()))
             .unwrap_or_else(|| panic!("Expected {after:?} to exist"));
         self.labels.insert(index + 1, Box::new(schedule));
     }

crates/bevy_derive/src/lib.rs

@@ -208,5 +208,5 @@ 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");
     trait_path.segments.push(format_ident!("AppLabel").into());
-    derive_label(input, &trait_path, "app_label")
+    derive_label(input, &trait_path)
 }

crates/bevy_ecs/macros/src/lib.rs

@@ -6,9 +6,7 @@ mod set;
 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,
-};
+use bevy_macro_utils::{derive_label, ensure_no_collision, get_named_struct_fields, BevyManifest};
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use quote::{format_ident, quote};
@@ -435,7 +433,7 @@ pub fn derive_schedule_label(input: TokenStream) -> TokenStream {
     trait_path
         .segments
         .push(format_ident!("ScheduleLabel").into());
-    derive_boxed_label(input, &trait_path)
+    derive_label(input, &trait_path)
 }
 
 /// Derive macro generating an impl of the trait `SystemSet`.

crates/bevy_ecs/macros/src/set.rs

@@ -23,11 +23,7 @@ pub fn derive_set(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStrea
     );
 
     (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))
-            }
-        }
+        impl #impl_generics #trait_path for #ident #ty_generics #where_clause {}
     })
     .into()
 }

crates/bevy_ecs/src/schedule/config.rs

@@ -4,7 +4,7 @@ use crate::{
     schedule::{
         condition::{BoxedCondition, Condition},
         graph_utils::{Ambiguity, Dependency, DependencyKind, GraphInfo},
-        set::{BoxedSystemSet, IntoSystemSet, SystemSet},
+        set::{IntoSystemSet, SystemSet, SystemSetUntyped},
     },
     system::{BoxedSystem, IntoSystem, System},
 };
@@ -20,7 +20,7 @@ fn new_condition<M>(condition: impl Condition<M>) -> BoxedCondition {
     Box::new(condition_system)
 }
 
-fn ambiguous_with(graph_info: &mut GraphInfo, set: BoxedSystemSet) {
+fn ambiguous_with(graph_info: &mut GraphInfo, set: SystemSetUntyped) {
     match &mut graph_info.ambiguous_with {
         detection @ Ambiguity::Check => {
             *detection = Ambiguity::IgnoreWithSet(vec![set]);
@@ -83,20 +83,20 @@ impl SystemConfigs {
         })
     }
 
-    pub(crate) fn in_set_inner(&mut self, set: BoxedSystemSet) {
+    pub(crate) fn in_set_inner(&mut self, set: SystemSetUntyped) {
         match self {
             SystemConfigs::SystemConfig(config) => {
                 config.graph_info.sets.push(set);
             }
             SystemConfigs::Configs { configs, .. } => {
                 for config in configs {
-                    config.in_set_inner(set.dyn_clone());
+                    config.in_set_inner(set);
                 }
             }
         }
     }
 
-    fn before_inner(&mut self, set: BoxedSystemSet) {
+    fn before_inner(&mut self, set: SystemSetUntyped) {
         match self {
             SystemConfigs::SystemConfig(config) => {
                 config
@@ -106,13 +106,13 @@ impl SystemConfigs {
             }
             SystemConfigs::Configs { configs, .. } => {
                 for config in configs {
-                    config.before_inner(set.dyn_clone());
+                    config.before_inner(set);
                 }
             }
         }
     }
 
-    fn after_inner(&mut self, set: BoxedSystemSet) {
+    fn after_inner(&mut self, set: SystemSetUntyped) {
         match self {
             SystemConfigs::SystemConfig(config) => {
                 config
@@ -122,7 +122,7 @@ impl SystemConfigs {
             }
             SystemConfigs::Configs { configs, .. } => {
                 for config in configs {
-                    config.after_inner(set.dyn_clone());
+                    config.after_inner(set);
                 }
             }
         }
@@ -141,14 +141,14 @@ impl SystemConfigs {
         }
     }
 
-    fn ambiguous_with_inner(&mut self, set: BoxedSystemSet) {
+    fn ambiguous_with_inner(&mut self, set: SystemSetUntyped) {
         match self {
             SystemConfigs::SystemConfig(config) => {
                 ambiguous_with(&mut config.graph_info, set);
             }
             SystemConfigs::Configs { configs, .. } => {
                 for config in configs {
-                    config.ambiguous_with_inner(set.dyn_clone());
+                    config.ambiguous_with_inner(set);
                 }
             }
         }
@@ -302,25 +302,26 @@ impl IntoSystemConfigs<()> for SystemConfigs {
 
     #[track_caller]
     fn in_set(mut self, set: impl SystemSet) -> Self {
+        let set = SystemSetUntyped::of(&set);
         assert!(
             set.system_type().is_none(),
             "adding arbitrary systems to a system type set is not allowed"
         );
 
-        self.in_set_inner(set.dyn_clone());
+        self.in_set_inner(set);
 
         self
     }
 
     fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = set.into_system_set();
-        self.before_inner(set.dyn_clone());
+        let set = SystemSetUntyped::of(&set.into_system_set());
+        self.before_inner(set);
         self
     }
 
     fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = set.into_system_set();
-        self.after_inner(set.dyn_clone());
+        let set = SystemSetUntyped::of(&set.into_system_set());
+        self.after_inner(set);
         self
     }
 
@@ -330,8 +331,8 @@ 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.dyn_clone());
+        let set = SystemSetUntyped::of(&set.into_system_set());
+        self.ambiguous_with_inner(set);
         self
     }
 
@@ -382,13 +383,13 @@ all_tuples!(impl_system_collection, 1, 20, P, S);
 
 /// A [`SystemSet`] with scheduling metadata.
 pub struct SystemSetConfig {
-    pub(super) set: BoxedSystemSet,
+    pub(super) set: SystemSetUntyped,
     pub(super) graph_info: GraphInfo,
     pub(super) conditions: Vec<BoxedCondition>,
 }
 
 impl SystemSetConfig {
-    fn new(set: BoxedSystemSet) -> Self {
+    fn new(set: SystemSetUntyped) -> Self {
         // system type sets are automatically populated
         // to avoid unintentionally broad changes, they cannot be configured
         assert!(
@@ -445,11 +446,11 @@ pub trait IntoSystemSetConfig: Sized {
 
 impl<S: SystemSet> IntoSystemSetConfig for S {
     fn into_config(self) -> SystemSetConfig {
-        SystemSetConfig::new(Box::new(self))
+        SystemSetConfig::new(SystemSetUntyped::of(&self))
     }
 }
 
-impl IntoSystemSetConfig for BoxedSystemSet {
+impl IntoSystemSetConfig for SystemSetUntyped {
     fn into_config(self) -> SystemSetConfig {
         SystemSetConfig::new(self)
     }
@@ -462,27 +463,28 @@ impl IntoSystemSetConfig for SystemSetConfig {
 
     #[track_caller]
     fn in_set(mut self, set: impl SystemSet) -> Self {
+        let set = SystemSetUntyped::of(&set);
         assert!(
             set.system_type().is_none(),
             "adding arbitrary systems to a system type set is not allowed"
         );
-        self.graph_info.sets.push(Box::new(set));
+        self.graph_info.sets.push(set);
         self
     }
 
     fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        self.graph_info.dependencies.push(Dependency::new(
-            DependencyKind::Before,
-            Box::new(set.into_system_set()),
-        ));
+        let set = SystemSetUntyped::of(&set.into_system_set());
+        self.graph_info
+            .dependencies
+            .push(Dependency::new(DependencyKind::Before, set));
         self
     }
 
     fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        self.graph_info.dependencies.push(Dependency::new(
-            DependencyKind::After,
-            Box::new(set.into_system_set()),
-        ));
+        let set = SystemSetUntyped::of(&set.into_system_set());
+        self.graph_info
+            .dependencies
+            .push(Dependency::new(DependencyKind::After, set));
         self
     }
 
@@ -492,7 +494,8 @@ impl IntoSystemSetConfig for SystemSetConfig {
     }
 
     fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        ambiguous_with(&mut self.graph_info, Box::new(set.into_system_set()));
+        let set = SystemSetUntyped::of(&set.into_system_set());
+        ambiguous_with(&mut self.graph_info, set);
         self
     }
 
@@ -561,45 +564,46 @@ impl IntoSystemSetConfigs for SystemSetConfigs {
 
     #[track_caller]
     fn in_set(mut self, set: impl SystemSet) -> Self {
+        let set = SystemSetUntyped::of(&set);
         assert!(
             set.system_type().is_none(),
             "adding arbitrary systems to a system type set is not allowed"
         );
         for config in &mut self.sets {
-            config.graph_info.sets.push(set.dyn_clone());
+            config.graph_info.sets.push(set);
         }
 
         self
     }
 
     fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = set.into_system_set();
+        let set = SystemSetUntyped::of(&set.into_system_set());
         for config in &mut self.sets {
             config
                 .graph_info
                 .dependencies
-                .push(Dependency::new(DependencyKind::Before, set.dyn_clone()));
+                .push(Dependency::new(DependencyKind::Before, set));
         }
 
         self
     }
 
     fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = set.into_system_set();
+        let set = SystemSetUntyped::of(&set.into_system_set());
         for config in &mut self.sets {
             config
                 .graph_info
                 .dependencies
-                .push(Dependency::new(DependencyKind::After, set.dyn_clone()));
+                .push(Dependency::new(DependencyKind::After, set));
         }
 
         self
     }
 
     fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
-        let set = set.into_system_set();
+        let set = SystemSetUntyped::of(&set.into_system_set());
         for config in &mut self.sets {
-            ambiguous_with(&mut config.graph_info, set.dyn_clone());
+            ambiguous_with(&mut config.graph_info, set);
         }
 
         self