Create a System Builder Syntax instead of using System Descriptors

crates/bevy_app/src/app.rs

@@ -1,10 +1,9 @@
 use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
 use bevy_ecs::{
     component::{Component, ComponentDescriptor},
-    prelude::{FromWorld, IntoExclusiveSystem},
-    schedule::{
-        IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage,
-    },
+    prelude::{ExclusiveSystem, FromWorld, IntoExclusiveSystem, IntoSystem, StageConfig, System},
+    schedule::{RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage},
+    system::BoxedSystem,
     world::World,
 };
 use bevy_utils::tracing::debug;
@@ -50,7 +49,7 @@ impl Default for App {
 
         app.add_default_stages()
             .add_event::<AppExit>()
-            .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system());
+            .add_exclusive(World::clear_trackers.stage(CoreStage::Last));
 
         #[cfg(feature = "bevy_ci_testing")]
         {
@@ -203,85 +202,108 @@ impl App {
     /// App::new()
     ///     .add_system(my_system);
     /// ```
-    pub fn add_system<Params>(&mut self, system: impl IntoSystemDescriptor<Params>) -> &mut Self {
-        self.add_system_to_stage(CoreStage::Update, system)
-    }
-
-    pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self {
-        self.add_system_set_to_stage(CoreStage::Update, system_set)
-    }
-
-    pub fn add_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.schedule.add_system_to_stage(stage_label, system);
-        self
-    }
-
-    pub fn add_system_set_to_stage(
-        &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.schedule
-            .add_system_set_to_stage(stage_label, system_set);
+    pub fn add_system<Params>(&mut self, system: impl IntoSystem<(), (), Params>) -> &mut Self {
+        let system = system.system();
+        if system.config().startup {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.stage(StartupStage::Startup)
+                }
+            };
+            self.schedule
+                .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                    schedule.add_system(system)
+                });
+        } else {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.stage(CoreStage::Update)
+                }
+            };
+            self.schedule.add_system(system);
+        }
         self
     }
 
-    /// Adds a system that is run once at application startup
-    ///
-    /// Startup systems run exactly once BEFORE all other systems. These are generally used for
-    /// app initialization code (ex: adding entities and resources).
-    ///
-    /// * For adding a system that runs for every frame, see [`App::add_system`].
-    /// * For adding a system to specific stage, see [`App::add_system_to_stage`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// fn my_startup_system(_commands: Commands) {
-    ///     println!("My startup system");
-    /// }
-    ///
-    /// App::new()
-    ///     .add_startup_system(my_startup_system);
-    /// ```
-    pub fn add_startup_system<Params>(
-        &mut self,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.add_startup_system_to_stage(StartupStage::Startup, system)
-    }
-
-    pub fn add_startup_system_set(&mut self, system_set: SystemSet) -> &mut Self {
-        self.add_startup_system_set_to_stage(StartupStage::Startup, system_set)
-    }
+    pub fn add_system_set(&mut self, set: SystemSet) -> &mut Self {
+        fn ensure_no_conflicts(set: &SystemSet) {
+            if let Some(l) = set.systems
+                .iter()
+                .filter(|s| s.config().stage != set.config().stage)
+                .next()
+                .and_then(|s| s.config().stage.as_ref()) {
+                    panic!("System set stage conflicts with internal exclusive system's stage: {:?}", l.as_ref());
+                }
+            if let Some(l) = set.exclusive_systems
+                .iter()
+                .filter(|s| s.config().stage != set.config().stage)
+                .next()
+                .and_then(|s| s.config().stage.as_ref()) {
+                    panic!("System set stage conflicts with internal exclusive system's stage: {:?}", l.as_ref());
+                }
+        }
 
-    pub fn add_startup_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_system_to_stage(stage_label, system)
-            });
+        if set.config().startup {
+            let set = {
+                if set.config().stage.is_some() {
+                    set
+                } else {
+                    set.stage(StartupStage::Startup)
+                }
+            };
+            ensure_no_conflicts(&set);
+            self.schedule
+                .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                    schedule.add_system_set(set)
+                });
+        } else {
+            let set = {
+                if set.config().stage.is_some() {
+                    set
+                } else {
+                    set.stage(CoreStage::Update)
+                }
+            };
+            ensure_no_conflicts(&set);
+            self.schedule.add_system_set(set);
+        }
         self
     }
 
-    pub fn add_startup_system_set_to_stage(
+    pub fn add_exclusive<Params, SystemType>(
         &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_system_set_to_stage(stage_label, system_set)
-            });
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> &mut Self
+    where
+        SystemType: ExclusiveSystem + StageConfig<Params, SystemType>,
+    {
+        let system = system.exclusive_system();
+        if system.config().startup {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.exclusive_system().stage(StartupStage::Startup)
+                }
+            };
+            self.schedule
+                .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                    schedule.add_exclusive(system)
+                });
+        } else {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.exclusive_system().stage(CoreStage::Update)
+                }
+            };
+            self.schedule.add_exclusive(system);
+        }
         self
     }
 
@@ -307,7 +329,7 @@ impl App {
         T: Component + Debug + Clone + Eq + Hash,
     {
         self.insert_resource(State::new(initial))
-            .add_system_set_to_stage(stage, State::<T>::get_driver())
+            .add_system_set(State::<T>::get_driver().stage(stage))
     }
 
     pub fn add_default_stages(&mut self) -> &mut Self {
@@ -335,7 +357,7 @@ impl App {
         T: Component,
     {
         self.insert_resource(Events::<T>::default())
-            .add_system_to_stage(CoreStage::First, Events::<T>::update_system)
+            .add_system(Events::<T>::update_system.stage(CoreStage::First))
     }
 
     /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.

crates/bevy_asset/src/assets.rs

@@ -3,7 +3,7 @@ use crate::{
     RefChange,
 };
 use bevy_app::{App, EventWriter, Events};
-use bevy_ecs::{system::ResMut, world::FromWorld};
+use bevy_ecs::{prelude::StageConfig, system::ResMut, world::FromWorld};
 use bevy_utils::HashMap;
 use crossbeam_channel::Sender;
 use std::fmt::Debug;
@@ -214,8 +214,8 @@ impl AddAsset for App {
         };
 
         self.insert_resource(assets)
-            .add_system_to_stage(AssetStage::AssetEvents, Assets::<T>::asset_event_system)
-            .add_system_to_stage(AssetStage::LoadAssets, update_asset_storage_system::<T>)
+            .add_system(Assets::<T>::asset_event_system.stage(AssetStage::AssetEvents))
+            .add_system(update_asset_storage_system::<T>.stage(AssetStage::LoadAssets))
             .register_type::<Handle<T>>()
             .add_event::<AssetEvent<T>>()
     }

crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs

@@ -1,7 +1,10 @@
 use crate::{Asset, Assets};
 use bevy_app::prelude::*;
 use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics, MAX_DIAGNOSTIC_NAME_WIDTH};
-use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::{
+    prelude::StartupConfig,
+    system::{Res, ResMut},
+};
 
 /// Adds "asset count" diagnostic to an App
 pub struct AssetCountDiagnosticsPlugin<T: Asset> {
@@ -18,7 +21,7 @@ impl<T: Asset> Default for AssetCountDiagnosticsPlugin<T> {
 
 impl<T: Asset> Plugin for AssetCountDiagnosticsPlugin<T> {
     fn build(&self, app: &mut App) {
-        app.add_startup_system(Self::setup_system)
+        app.add_system(Self::setup_system.startup())
             .add_system(Self::diagnostic_system);
     }
 }

crates/bevy_asset/src/lib.rs

@@ -27,7 +27,10 @@ pub use loader::*;
 pub use path::*;
 
 use bevy_app::{prelude::Plugin, App};
-use bevy_ecs::schedule::{StageLabel, SystemStage};
+use bevy_ecs::{
+    prelude::StageConfig,
+    schedule::{StageLabel, SystemStage},
+};
 use bevy_tasks::IoTaskPool;
 
 /// The names of asset stages in an App Schedule
@@ -101,15 +104,12 @@ impl Plugin for AssetPlugin {
             SystemStage::parallel(),
         )
         .register_type::<HandleId>()
-        .add_system_to_stage(
-            bevy_app::CoreStage::PreUpdate,
-            asset_server::free_unused_assets_system,
-        );
+        .add_system(asset_server::free_unused_assets_system.stage(bevy_app::CoreStage::PreUpdate));
 
         #[cfg(all(
             feature = "filesystem_watcher",
             all(not(target_arch = "wasm32"), not(target_os = "android"))
         ))]
-        app.add_system_to_stage(AssetStage::LoadAssets, io::filesystem_watcher_system);
+        app.add_system(io::filesystem_watcher_system.stage(AssetStage::LoadAssets));
     }
 }

crates/bevy_audio/src/lib.rs

@@ -13,7 +13,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::system::IntoExclusiveSystem;
+use bevy_ecs::{prelude::StageConfig, system::IntoExclusiveSystem};
 
 /// Adds support for audio playback to an App
 #[derive(Default)]
@@ -24,9 +24,10 @@ impl Plugin for AudioPlugin {
         app.init_non_send_resource::<AudioOutput<AudioSource>>()
             .add_asset::<AudioSource>()
             .init_resource::<Audio<AudioSource>>()
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                play_queued_audio_system::<AudioSource>.exclusive_system(),
+            .add_exclusive(
+                play_queued_audio_system::<AudioSource>
+                    .exclusive_system()
+                    .stage(CoreStage::PostUpdate),
             );
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]

crates/bevy_core/src/label.rs

@@ -122,6 +122,7 @@ pub(crate) fn entity_labels_system(
 #[cfg(test)]
 mod tests {
     use bevy_ecs::{
+        prelude::StageConfig,
         schedule::{Schedule, Stage, SystemStage},
         world::World,
     };
@@ -133,7 +134,7 @@ mod tests {
         world.insert_resource(EntityLabels::default());
         let mut schedule = Schedule::default();
         schedule.add_stage("test", SystemStage::single_threaded());
-        schedule.add_system_to_stage("test", entity_labels_system);
+        schedule.add_system(entity_labels_system.stage("test"));
         (world, schedule)
     }
 

crates/bevy_core/src/lib.rs

@@ -20,8 +20,8 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
-    schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
-    system::IntoExclusiveSystem,
+    prelude::{ScheduleConfig, StageConfig, StartupConfig},
+    schedule::SystemLabel,
 };
 use bevy_utils::HashSet;
 use std::ops::Range;
@@ -58,12 +58,13 @@ impl Plugin for CorePlugin {
             .register_type::<Timer>()
             // time system is added as an "exclusive system" to ensure it runs before other systems
             // in CoreStage::First
-            .add_system_to_stage(
-                CoreStage::First,
-                time_system.exclusive_system().label(CoreSystem::Time),
+            .add_exclusive(time_system.stage(CoreStage::First).label(CoreSystem::Time))
+            .add_system(
+                entity_labels_system
+                    .startup()
+                    .stage(StartupStage::PostStartup),
             )
-            .add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system)
-            .add_system_to_stage(CoreStage::PostUpdate, entity_labels_system);
+            .add_system(entity_labels_system.stage(CoreStage::PostUpdate));
 
         register_rust_types(app);
         register_math_types(app);

crates/bevy_core/src/time/fixed_timestep.rs

@@ -4,7 +4,7 @@ use bevy_ecs::{
     component::ComponentId,
     query::Access,
     schedule::ShouldRun,
-    system::{ConfigurableSystem, IntoSystem, Local, Res, ResMut, System, SystemId},
+    system::{ConfigurableSystem, IntoSystem, Local, Res, ResMut, System, SystemConfig, SystemId},
     world::World,
 };
 use bevy_utils::HashMap;
@@ -51,13 +51,15 @@ impl FixedTimesteps {
 pub struct FixedTimestep {
     state: State,
     internal_system: Box<dyn System<In = (), Out = ShouldRun>>,
+    config: SystemConfig,
 }
 
 impl Default for FixedTimestep {
     fn default() -> Self {
         Self {
             state: State::default(),
             internal_system: Box::new(Self::prepare_system.system()),
+            config: SystemConfig::default(),
         }
     }
 }
@@ -197,4 +199,12 @@ impl System for FixedTimestep {
     fn check_change_tick(&mut self, change_tick: u32) {
         self.internal_system.check_change_tick(change_tick);
     }
+
+    fn config(&self) -> &SystemConfig {
+        &self.config
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.config
+    }
 }