Introduce a boxed label wrapper type

Author: vladbat00

crates/bevy_app/src/app.rs

@@ -15,7 +15,7 @@ use std::fmt::Debug;
 
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
-bevy_utils::define_label!(AppLabel);
+bevy_utils::define_label!(AppLabel, BoxedAppLabel);
 
 #[allow(clippy::needless_doctest_main)]
 /// A container of app logic and data.
@@ -56,7 +56,7 @@ pub struct App {
     pub runner: Box<dyn Fn(App)>,
     /// A container of [`Stage`]s set to be run in a linear order.
     pub schedule: Schedule,
-    sub_apps: HashMap<Box<dyn AppLabel>, SubApp>,
+    sub_apps: HashMap<BoxedAppLabel, SubApp>,
 }
 
 /// Each `SubApp` has its own [`Schedule`] and [`World`], enabling a separation of concerns.
@@ -889,7 +889,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((&label) as &dyn AppLabel)
+            .get_mut(&label.dyn_clone())
             .map(|sub_app| &mut sub_app.app)
             .ok_or(label)
     }
@@ -910,7 +910,7 @@ impl App {
     /// 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 &dyn AppLabel)
+            .get(&label.dyn_clone())
             .map(|sub_app| &sub_app.app)
             .ok_or(label)
     }

crates/bevy_derive/src/lib.rs

@@ -85,6 +85,10 @@ pub fn derive_enum_variant_meta(input: TokenStream) -> TokenStream {
 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 boxed_type_path = trait_path.clone();
     trait_path.segments.push(format_ident!("AppLabel").into());
-    derive_label(input, &trait_path)
+    boxed_type_path
+        .segments
+        .push(format_ident!("BoxedAppLabel").into());
+    derive_label(input, &trait_path, &boxed_type_path)
 }

crates/bevy_ecs/macros/src/lib.rs

@@ -424,43 +424,62 @@ pub fn derive_world_query(input: TokenStream) -> TokenStream {
 #[proc_macro_derive(SystemLabel)]
 pub fn derive_system_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    let mut trait_path = bevy_ecs_path();
-    trait_path.segments.push(format_ident!("schedule").into());
-    trait_path
-        .segments
-        .push(format_ident!("SystemLabel").into());
-    derive_label(input, &trait_path)
+    let LabelPaths {
+        trait_path,
+        boxed_type_path,
+    } = label_paths("SystemLabel");
+    derive_label(input, &trait_path, &boxed_type_path)
 }
 
 #[proc_macro_derive(StageLabel)]
 pub fn derive_stage_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    let mut trait_path = bevy_ecs_path();
-    trait_path.segments.push(format_ident!("schedule").into());
-    trait_path.segments.push(format_ident!("StageLabel").into());
-    derive_label(input, &trait_path)
+    let LabelPaths {
+        trait_path,
+        boxed_type_path,
+    } = label_paths("StageLabel");
+    derive_label(input, &trait_path, &boxed_type_path)
 }
 
 #[proc_macro_derive(AmbiguitySetLabel)]
 pub fn derive_ambiguity_set_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    let mut trait_path = bevy_ecs_path();
-    trait_path.segments.push(format_ident!("schedule").into());
-    trait_path
-        .segments
-        .push(format_ident!("AmbiguitySetLabel").into());
-    derive_label(input, &trait_path)
+    let LabelPaths {
+        trait_path,
+        boxed_type_path,
+    } = label_paths("AmbiguitySetLabel");
+    derive_label(input, &trait_path, &boxed_type_path)
 }
 
 #[proc_macro_derive(RunCriteriaLabel)]
 pub fn derive_run_criteria_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
+    let LabelPaths {
+        trait_path,
+        boxed_type_path,
+    } = label_paths("RunCriteriaLabel");
+    derive_label(input, &trait_path, &boxed_type_path)
+}
+
+struct LabelPaths {
+    trait_path: syn::Path,
+    boxed_type_path: syn::Path,
+}
+
+fn label_paths(label_trait_name: &'static str) -> LabelPaths {
     let mut trait_path = bevy_ecs_path();
     trait_path.segments.push(format_ident!("schedule").into());
+    let mut boxed_type_path = trait_path.clone();
     trait_path
         .segments
-        .push(format_ident!("RunCriteriaLabel").into());
-    derive_label(input, &trait_path)
+        .push(format_ident!("{}", label_trait_name).into());
+    boxed_type_path
+        .segments
+        .push(format_ident!("Boxed{}", label_trait_name).into());
+    LabelPaths {
+        trait_path,
+        boxed_type_path,
+    }
 }
 
 pub(crate) fn bevy_ecs_path() -> syn::Path {

crates/bevy_ecs/src/schedule/label.rs

@@ -1,12 +1,7 @@
 pub use bevy_ecs_macros::{AmbiguitySetLabel, RunCriteriaLabel, StageLabel, SystemLabel};
 use bevy_utils::define_label;
 
-define_label!(StageLabel);
-define_label!(SystemLabel);
-define_label!(AmbiguitySetLabel);
-define_label!(RunCriteriaLabel);
-
-pub(crate) type BoxedStageLabel = Box<dyn StageLabel>;
-pub(crate) type BoxedSystemLabel = Box<dyn SystemLabel>;
-pub(crate) type BoxedAmbiguitySetLabel = Box<dyn AmbiguitySetLabel>;
-pub(crate) type BoxedRunCriteriaLabel = Box<dyn RunCriteriaLabel>;
+define_label!(StageLabel, BoxedStageLabel);
+define_label!(SystemLabel, BoxedSystemLabel);
+define_label!(AmbiguitySetLabel, BoxedAmbiguitySetLabel);
+define_label!(RunCriteriaLabel, BoxedRunCriteriaLabel);

crates/bevy_ecs/src/schedule/mod.rs

@@ -111,7 +111,7 @@ impl Schedule {
     /// schedule.add_stage("my_stage", SystemStage::parallel());
     /// ```
     pub fn add_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
-        let label: Box<dyn StageLabel> = label.dyn_clone();
+        let label: BoxedStageLabel = label.dyn_clone();
         self.stage_order.push(label.clone());
         let prev = self.stages.insert(label.clone(), Box::new(stage));
         assert!(prev.is_none(), "Stage already exists: {:?}.", label);
@@ -135,7 +135,7 @@ impl Schedule {
         label: impl StageLabel,
         stage: S,
     ) -> &mut Self {
-        let label: Box<dyn StageLabel> = label.dyn_clone();
+        let label: BoxedStageLabel = label.dyn_clone();
         let target = &target as &dyn StageLabel;
         let target_index = self
             .stage_order
@@ -169,7 +169,7 @@ impl Schedule {
         label: impl StageLabel,
         stage: S,
     ) -> &mut Self {
-        let label: Box<dyn StageLabel> = label.dyn_clone();
+        let label: BoxedStageLabel = label.dyn_clone();
         let target = &target as &dyn StageLabel;
         let target_index = self
             .stage_order
@@ -307,7 +307,7 @@ impl Schedule {
     /// ```
     pub fn get_stage<T: Stage>(&self, label: &dyn StageLabel) -> Option<&T> {
         self.stages
-            .get(label)
+            .get(&label.dyn_clone())
             .and_then(|stage| stage.downcast_ref::<T>())
     }
 
@@ -328,7 +328,7 @@ impl Schedule {
     /// ```
     pub fn get_stage_mut<T: Stage>(&mut self, label: &dyn StageLabel) -> Option<&mut T> {
         self.stages
-            .get_mut(label)
+            .get_mut(&label.dyn_clone())
             .and_then(|stage| stage.downcast_mut::<T>())
     }