remove label declaration macros

Author: joseph-gio

benches/benches/bevy_ecs/scheduling/run_criteria.rs

@@ -1,8 +1,7 @@
 use bevy_ecs::{
     component::Component,
     prelude::{ParallelSystemDescriptorCoercion, Res, Resource, RunCriteriaDescriptorCoercion},
-    run_criteria_label,
-    schedule::{ShouldRun, Stage, SystemStage},
+    schedule::{RunCriteriaLabel, ShouldRun, Stage, SystemStage},
     system::Query,
     world::World,
 };
@@ -12,6 +11,13 @@ fn run_stage(stage: &mut SystemStage, world: &mut World) {
     stage.run(world);
 }
 
+/// Labels for run criteria which either always return yes, or always return no.
+#[derive(RunCriteriaLabel)]
+enum Always {
+    Yes,
+    No,
+}
+
 pub fn run_criteria_yes(criterion: &mut Criterion) {
     let mut world = World::new();
     let mut group = criterion.benchmark_group("run_criteria/yes");
@@ -87,15 +93,14 @@ pub fn run_criteria_yes_with_labels(criterion: &mut Criterion) {
     for amount in 0..21 {
         let mut stage = SystemStage::parallel();
 
-        run_criteria_label!(always_yes_label);
-        stage.add_system(empty.with_run_criteria(always_yes.label(always_yes_label)));
+        stage.add_system(empty.with_run_criteria(always_yes.label(Always::Yes)));
         for _ in 0..amount {
             stage
-                .add_system(empty.with_run_criteria(always_yes_label))
-                .add_system(empty.with_run_criteria(always_yes_label))
-                .add_system(empty.with_run_criteria(always_yes_label))
-                .add_system(empty.with_run_criteria(always_yes_label))
-                .add_system(empty.with_run_criteria(always_yes_label));
+                .add_system(empty.with_run_criteria(Always::Yes))
+                .add_system(empty.with_run_criteria(Always::Yes))
+                .add_system(empty.with_run_criteria(Always::Yes))
+                .add_system(empty.with_run_criteria(Always::Yes))
+                .add_system(empty.with_run_criteria(Always::Yes));
         }
         // run once to initialize systems
         run_stage(&mut stage, &mut world);
@@ -120,15 +125,14 @@ pub fn run_criteria_no_with_labels(criterion: &mut Criterion) {
     for amount in 0..21 {
         let mut stage = SystemStage::parallel();
 
-        run_criteria_label!(always_no_label);
-        stage.add_system(empty.with_run_criteria(always_no.label(always_no_label)));
+        stage.add_system(empty.with_run_criteria(always_no.label(Always::No)));
         for _ in 0..amount {
             stage
-                .add_system(empty.with_run_criteria(always_no_label))
-                .add_system(empty.with_run_criteria(always_no_label))
-                .add_system(empty.with_run_criteria(always_no_label))
-                .add_system(empty.with_run_criteria(always_no_label))
-                .add_system(empty.with_run_criteria(always_no_label));
+                .add_system(empty.with_run_criteria(Always::No))
+                .add_system(empty.with_run_criteria(Always::No))
+                .add_system(empty.with_run_criteria(Always::No))
+                .add_system(empty.with_run_criteria(Always::No))
+                .add_system(empty.with_run_criteria(Always::No));
         }
         // run once to initialize systems
         run_stage(&mut stage, &mut world);

crates/bevy_app/src/app.rs

@@ -151,9 +151,9 @@ impl App {
     /// # use bevy_ecs::prelude::*;
     /// # let mut app = App::new();
     /// #
-    /// // Define a new, private `StageLabel`.
-    /// stage_label!(my_stage);
-    /// app.add_stage(my_stage, SystemStage::parallel());
+    /// #[derive(StageLabel)]
+    /// struct MyStage;
+    /// app.add_stage(MyStage, SystemStage::parallel());
     /// ```
     pub fn add_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
         self.schedule.add_stage(label, stage);
@@ -170,9 +170,9 @@ impl App {
     /// # use bevy_ecs::prelude::*;
     /// # let mut app = App::new();
     /// #
-    /// // Define a new, private `StageLabel`.
-    /// stage_label!(my_stage);
-    /// app.add_stage_after(CoreStage::Update, my_stage, SystemStage::parallel());
+    /// #[derive(StageLabel)]
+    /// struct MyStage;
+    /// app.add_stage_after(CoreStage::Update, MyStage, SystemStage::parallel());
     /// ```
     pub fn add_stage_after<S: Stage>(
         &mut self,
@@ -194,9 +194,9 @@ impl App {
     /// # use bevy_ecs::prelude::*;
     /// # let mut app = App::new();
     /// #
-    /// // Define a new, private `StageLabel`.
-    /// stage_label!(my_stage);
-    /// app.add_stage_before(CoreStage::Update, my_stage, SystemStage::parallel());
+    /// #[derive(StageLabel)]
+    /// struct MyStage;
+    /// app.add_stage_before(CoreStage::Update, MyStage, SystemStage::parallel());
     /// ```
     pub fn add_stage_before<S: Stage>(
         &mut self,
@@ -218,9 +218,9 @@ impl App {
     /// # use bevy_ecs::prelude::*;
     /// # let mut app = App::new();
     /// #
-    /// // Define a new, private `StageLabel`.
-    /// stage_label!(my_startup_stage);
-    /// app.add_startup_stage(my_startup_stage, SystemStage::parallel());
+    /// #[derive(StageLabel)]
+    /// struct MyStartupStage;
+    /// app.add_startup_stage(MyStartupStage, SystemStage::parallel());
     /// ```
     pub fn add_startup_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
         self.schedule
@@ -242,11 +242,11 @@ impl App {
     /// # use bevy_ecs::prelude::*;
     /// # let mut app = App::new();
     /// #
-    /// // Define a new, private `StageLabel`.
-    /// stage_label!(my_startup_stage);
+    /// #[derive(StageLabel)]
+    /// struct MyStartupStage;
     /// app.add_startup_stage_after(
     ///     StartupStage::Startup,
-    ///     my_startup_stage,
+    ///     MyStartupStage,
     ///     SystemStage::parallel()
     /// );
     /// ```
@@ -275,11 +275,11 @@ impl App {
     /// # use bevy_ecs::prelude::*;
     /// # let mut app = App::new();
     /// #
-    /// // Define a new, private `StageLabel`.
-    /// stage_label!(my_startup_stage);
+    /// #[derive(StageLabel)]
+    /// struct MyStartupStage;
     /// app.add_startup_stage_before(
     ///     StartupStage::Startup,
-    ///     my_startup_stage,
+    ///     MyStartupStage,
     ///     SystemStage::parallel()
     /// );
     /// ```

crates/bevy_ecs/examples/change_detection.rs

@@ -1,4 +1,4 @@
-use bevy_ecs::{prelude::*, stage_label};
+use bevy_ecs::prelude::*;
 use rand::Rng;
 use std::ops::Deref;
 
@@ -30,7 +30,8 @@ fn main() {
     update.add_system(remove_old_entities.after(SimulationSystem::Age));
     update.add_system(print_changed_entities.after(SimulationSystem::Age));
     // Add the Stage with our systems to the Schedule
-    stage_label!(Update);
+    #[derive(StageLabel)]
+    struct Update;
     schedule.add_stage(Update, update);
 
     // Simulate 10 frames in our world

crates/bevy_ecs/examples/events.rs

@@ -1,4 +1,4 @@
-use bevy_ecs::{event::Events, prelude::*, stage_label};
+use bevy_ecs::{event::Events, prelude::*};
 
 // In this example a system sends a custom event with a 50/50 chance during any frame.
 // If an event was send, it will be printed by the console in a receiving system.
@@ -10,7 +10,11 @@ fn main() {
     // Create a schedule and a stage
     let mut schedule = Schedule::default();
 
-    stage_label!(_1st, _2nd);
+    #[derive(StageLabel)]
+    enum Stages {
+        First,
+        Second,
+    }
 
     // Events need to be updated in every frame. This update should happen before we use
     // the events. To guarantee this, we can let the update run in an earlier stage than our logic.
@@ -19,15 +23,15 @@ fn main() {
     // sending and receiving events.
     let mut first = SystemStage::parallel();
     first.add_system(Events::<MyEvent>::update_system);
-    schedule.add_stage(_1st, first);
+    schedule.add_stage(Stages::First, first);
 
     // Add systems sending and receiving events to a "second" Stage
     let mut second = SystemStage::parallel();
     second.add_system(sending_system);
     second.add_system(receiving_system.after(sending_system));
 
     // Run the "second" Stage after the "first" Stage, so our Events always get updated before we use them
-    schedule.add_stage_after(_1st, _2nd, second);
+    schedule.add_stage_after(Stages::First, Stages::Second, second);
 
     // Simulate 10 frames of our world
     for iteration in 1..=10 {

crates/bevy_ecs/examples/resources.rs

@@ -1,4 +1,4 @@
-use bevy_ecs::{prelude::*, stage_label};
+use bevy_ecs::prelude::*;
 use rand::Rng;
 use std::ops::Deref;
 
@@ -15,14 +15,15 @@ fn main() {
     let mut schedule = Schedule::default();
     let mut update = SystemStage::parallel();
 
-    // Declare a private stage label
-
     // Add systems to increase the counter and to print out the current value
     update.add_system(increase_counter);
     update.add_system(print_counter.after(increase_counter));
 
+    // Declare a unique label for the stage.
+    #[derive(StageLabel)]
+    struct Update;
+
     // Add the stage to the schedule.
-    stage_label!(Update);
     schedule.add_stage(Update, update);
 
     for iteration in 1..=10 {

crates/bevy_ecs/src/lib.rs

@@ -27,26 +27,22 @@ pub mod prelude {
     pub use crate::reflect::{ReflectComponent, ReflectResource};
     #[doc(hidden)]
     pub use crate::{
-        ambiguity_set_label,
         bundle::Bundle,
         change_detection::DetectChanges,
         component::Component,
         entity::Entity,
         event::{EventReader, EventWriter, Events},
         query::{Added, AnyOf, ChangeTrackers, Changed, Or, QueryState, With, Without},
-        run_criteria_label,
         schedule::{
             AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
             RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, Schedule, Stage,
             StageLabel, State, SystemLabel, SystemSet, SystemStage,
         },
-        stage_label,
         system::{
             Commands, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend,
             NonSendMut, ParallelCommands, ParamSet, Query, RemovedComponents, Res, ResMut,
             Resource, System, SystemParamFunction,
         },
-        system_label,
         world::{FromWorld, Mut, World},
     };
 }

crates/bevy_ecs/src/schedule/label.rs

@@ -25,75 +25,3 @@ define_label!(
     /// Strongly-typed identifier for a [`RunCriteriaLabel`].
     RunCriteriaLabelId,
 );
-
-/// Defines one or more local, unique types implementing [`StageLabel`].
-#[macro_export]
-macro_rules! stage_label {
-    ($($name:ident),* $(,)*) => {
-        $(
-            /// A macro-generated local `StageLabel`.
-            #[allow(non_camel_case_types)]
-            struct $name;
-
-            impl $crate::schedule::StageLabel for $name {
-                fn as_str(&self) -> &'static str {
-                    std::stringify!($name)
-                }
-            }
-        )*
-    }
-}
-
-/// Defines one or more local, unique types implementing [`SystemLabel`].
-#[macro_export]
-macro_rules! system_label {
-    ($($name:ident),* $(,)*) => {
-        $(
-            /// A macro-generated local `SystemLabel`.
-            #[allow(non_camel_case_types)]
-            struct $name;
-
-            impl $crate::schedule::SystemLabel for $name {
-                fn as_str(&self) -> &'static str {
-                    std::stringify!($name)
-                }
-            }
-        )*
-    }
-}
-
-/// Defines one or more local, unique types implementing [`AmbiguitySetLabel`].
-#[macro_export]
-macro_rules! ambiguity_set_label {
-    ($($name:ident),* $(,)*) => {
-        $(
-            /// A macro-generated local `AmbiguitySetLabel`.
-            #[allow(non_camel_case_types)]
-            struct $name;
-
-            impl $crate::schedule::AmbiguitySetLabel for $name {
-                fn as_str(&self) -> &'static str {
-                    std::stringify!($name)
-                }
-            }
-        )*
-    }
-}
-
-/// Defines one or more local, unique types implementing [`RunCriteriaLabel`].
-#[macro_export]
-macro_rules! run_criteria_label {
-    ($($name:ident),* $(,)*) => {
-        $(
-            /// A macro-generated local `RunCriteria`.
-            #[allow(non_camel_case_types)]
-            struct $name;
-
-            impl $crate::schedule::RunCriteriaLabel for $name {
-                fn as_str(&self) -> &'static str {
-                    std::stringify!($name)
-                }
-            }
-        )*
-    }
-}