From 3e6a8c53ca088891ee97f7f5c9db82f0d8d2b150 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 12:39:50 -0500
Subject: [PATCH 01/66] Basic functionality

---
 crates/bevy_ecs/src/system/mod.rs             |   2 +
 crates/bevy_ecs/src/system/system_registry.rs | 111 ++++++++++++++++++
 2 files changed, 113 insertions(+)
 create mode 100644 crates/bevy_ecs/src/system/system_registry.rs

diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 52d8b0a12d6f9..d1cc45b7e940a 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -74,6 +74,7 @@ mod query;
 mod system;
 mod system_chaining;
 mod system_param;
+mod system_registry;
 
 pub use commands::*;
 pub use exclusive_system::*;
@@ -82,6 +83,7 @@ pub use query::*;
 pub use system::*;
 pub use system_chaining::*;
 pub use system_param::*;
+pub use system_registry::*;
 
 pub fn assert_is_system<In, Out, Params, S: IntoSystem<In, Out, Params>>(sys: S) {
     if false {
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
new file mode 100644
index 0000000000000..c616b51a9aea7
--- /dev/null
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -0,0 +1,111 @@
+use bevy_utils::HashMap;
+use std::any::{Any, TypeId};
+
+use crate::system::{IntoSystem, System};
+use crate::world::{Mut, World};
+
+/// A [`System`] that cannot be chained.
+///
+/// [`BoxedSystem`](crate::system::BoxedSystem) is the equivalent type alias for arbitrary `In` and `Out` types.
+pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
+
+/// Stores initialized [`Systems`](crate::system::System), so they can quickly be reused and run
+///
+/// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+#[derive(Default)]
+pub struct SystemRegistry {
+    systems: HashMap<TypeId, UnchainedSystem>,
+}
+
+// User-facing methods
+impl SystemRegistry {
+    /// Runs the supplied system on the [`World`] a single time
+    ///
+    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
+    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        world: &mut World,
+        system: S,
+    ) {
+        // If the system is already registered and initialized, use it
+        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
+            initialized_system.run((), world);
+            initialized_system.apply_buffers(world);
+        // Otherwise, register and initialize it first.
+        } else {
+            let initialized_system = self.register(world, system);
+            initialized_system.run((), world);
+            initialized_system.apply_buffers(world);
+        }
+    }
+
+    /// Runs the supplied system on the [`World`] a single time, without flushing [`Commands`](crate::system::Commands)
+    #[inline]
+    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        world: &mut World,
+        system: S,
+    ) {
+        // If the system is already registered and initialized, use it
+        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
+            initialized_system.run((), world);
+        // Otherwise, register and initialize it first.
+        } else {
+            let initialized_system = self.register(world, system);
+            initialized_system.run((), world);
+        }
+    }
+}
+
+// Internals
+impl SystemRegistry {
+    #[inline]
+    fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        world: &mut World,
+        system: S,
+    ) -> &mut UnchainedSystem {
+        let label = system.type_id();
+
+        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
+        unchained_system.initialize(world);
+
+        self.systems.insert(label, unchained_system);
+        self.systems.get_mut(&label).unwrap()
+    }
+}
+
+impl World {
+    /// Runs the supplied system on the [`World`] a single time
+    ///
+    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
+    ///
+    /// The system's state will be cached: any future calls using the same type will use this state,
+    /// improving performance and ensuring that change detection works properly.
+    ///
+    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
+    /// at once, and want parallel execution of these systems.
+    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run(world, system);
+        });
+    }
+
+    /// Runs the supplied system on the [`World`] a single time, wihthout flushing [`Commands`](crate::system::Commands)
+    ///
+    /// The system's state will be cached: any future calls using the same type will use this state,
+    /// improving performance and ensuring that change detection works properly.
+    ///
+    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
+    /// at once, and want parallel execution of these systems.
+    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+    ) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_without_flushing(world, system);
+        });
+    }
+}

From f9b16c23e1ecd15eac6208f3129ad5fb2c308a3c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 13:11:08 -0500
Subject: [PATCH 02/66] commands.run_system

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 23 ++++++++
 crates/bevy_ecs/src/system/system_registry.rs | 56 ++++++++++++++++---
 2 files changed, 72 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 7d3f541dab930..4ecbf91444db8 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -4,6 +4,7 @@ use crate::{
     bundle::Bundle,
     component::Component,
     entity::{Entities, Entity},
+    system::{IntoSystem, RunSystemCommand},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::{error, warn};
@@ -348,6 +349,28 @@ impl<'w, 's> Commands<'w, 's> {
         });
     }
 
+    /// Calls [`World::run_system`] once [`Commands`] are flushed
+    pub fn run_system<
+        Params: Send + Sync + 'static,
+        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    >(
+        &mut self,
+        system: S,
+    ) {
+        self.queue.push(RunSystemCommand::new(system, true));
+    }
+
+    /// Calls [`World::run_system_without_flushing`] once [`Commands`] are flushed
+    pub fn run_system_without_flushing<
+        Params: Send + Sync + 'static,
+        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    >(
+        &mut self,
+        system: S,
+    ) {
+        self.queue.push(RunSystemCommand::new(system, false));
+    }
+
     /// Adds a command directly to the command list.
     ///
     /// # Example
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c616b51a9aea7..9c7a23c2a8e37 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,7 +1,8 @@
 use bevy_utils::HashMap;
 use std::any::{Any, TypeId};
+use std::marker::PhantomData;
 
-use crate::system::{IntoSystem, System};
+use crate::system::{Command, IntoSystem, System};
 use crate::world::{Mut, World};
 
 /// A [`System`] that cannot be chained.
@@ -22,7 +23,7 @@ impl SystemRegistry {
     /// Runs the supplied system on the [`World`] a single time
     ///
     /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -41,7 +42,7 @@ impl SystemRegistry {
 
     /// Runs the supplied system on the [`World`] a single time, without flushing [`Commands`](crate::system::Commands)
     #[inline]
-    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -86,9 +87,10 @@ impl World {
     /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
-    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+    #[inline]
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run(world, system);
+            registry.run_system(world, system);
         });
     }
 
@@ -100,12 +102,52 @@ impl World {
     /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
-    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+    #[inline]
+    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         system: S,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_without_flushing(world, system);
+            registry.run_system_without_flushing(world, system);
         });
     }
 }
+
+/// The [`Command`] type for [`SystemRegistry`] [`Commands`]
+#[derive(Debug, Clone)]
+pub struct RunSystemCommand<
+    Params: Send + Sync + 'static,
+    S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+> {
+    _phantom_params: PhantomData<Params>,
+    system: S,
+    flush: bool,
+}
+
+impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
+    RunSystemCommand<Params, S>
+{
+    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`]
+    #[inline]
+    #[must_use]
+    pub fn new(system: S, flush: bool) -> Self {
+        Self {
+            _phantom_params: PhantomData::default(),
+            system,
+            flush,
+        }
+    }
+}
+
+impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static> Command
+    for RunSystemCommand<Params, S>
+{
+    #[inline]
+    fn write(self, world: &mut World) {
+        if self.flush {
+            world.run_system(self.system);
+        } else {
+            world.run_system_without_flushing(self.system);
+        }
+    }
+}

From 8e32c74433a69cb3e8d0d345266402704100ce85 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 13:13:04 -0500
Subject: [PATCH 03/66] Add SystemRegistry resource as part of CorePlugin

No plugin exists for bevy_ecs, so this was the best place.
---
 crates/bevy_core/src/lib.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 038abaeb16eb2..c777276f64e07 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -22,7 +22,7 @@ use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
     schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
-    system::IntoExclusiveSystem,
+    system::{IntoExclusiveSystem, SystemRegistry},
 };
 use bevy_utils::HashSet;
 use std::ops::Range;
@@ -50,6 +50,7 @@ impl Plugin for CorePlugin {
 
         app.init_resource::<Time>()
             .init_resource::<FixedTimesteps>()
+            .init_resource::<SystemRegistry>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()

From 961af58ad049690ab2112e777a430aeb38f3d762 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:07:20 -0500
Subject: [PATCH 04/66] Run system by TypeId

---
 crates/bevy_ecs/src/system/system_registry.rs | 82 ++++++++++---------
 1 file changed, 43 insertions(+), 39 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 9c7a23c2a8e37..7d2d720d3ebe1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -12,6 +12,9 @@ pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
 
 /// Stores initialized [`Systems`](crate::system::System), so they can quickly be reused and run
 ///
+/// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
+/// including for change detection.
+///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 #[derive(Default)]
 pub struct SystemRegistry {
@@ -20,59 +23,60 @@ pub struct SystemRegistry {
 
 // User-facing methods
 impl SystemRegistry {
-    /// Runs the supplied system on the [`World`] a single time
+    /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    /// This only needs to be called manually whenn using [`run_system_by_type_id`](SystemRegistry).
+    #[inline]
+    pub fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
     ) {
-        // If the system is already registered and initialized, use it
-        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
-            initialized_system.run((), world);
-            initialized_system.apply_buffers(world);
-        // Otherwise, register and initialize it first.
-        } else {
-            let initialized_system = self.register(world, system);
-            initialized_system.run((), world);
-            initialized_system.apply_buffers(world);
-        }
+        let label = system.type_id();
+
+        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
+        unchained_system.initialize(world);
+
+        self.systems.insert(label, unchained_system);
     }
 
-    /// Runs the supplied system on the [`World`] a single time, without flushing [`Commands`](crate::system::Commands)
-    #[inline]
-    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+    /// Is the provided `type_id` registered?
+    pub fn type_id_registered(&self, type_id: &TypeId) -> bool {
+        self.systems.contains_key(type_id)
+    }
+
+    /// Runs the system corresponding to the provided [`TypeId`] on the [`World`] a single time
+    ///
+    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
+    pub fn run_system_by_type_id(
         &mut self,
         world: &mut World,
-        system: S,
+        type_id: TypeId,
+        flush_commands: bool,
     ) {
-        // If the system is already registered and initialized, use it
-        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
-            initialized_system.run((), world);
-        // Otherwise, register and initialize it first.
-        } else {
-            let initialized_system = self.register(world, system);
-            initialized_system.run((), world);
+        let initialized_system = self.systems.get_mut(&type_id).unwrap_or_else(||{panic!{"No system with the `TypeId` {type_id:?} was found. Did you forget to register it?"}});
+        initialized_system.run((), world);
+        if flush_commands {
+            initialized_system.apply_buffers(world);
         }
     }
-}
 
-// Internals
-impl SystemRegistry {
-    #[inline]
-    fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
+    /// Runs the supplied system on the [`World`] a single time
+    ///
+    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
-    ) -> &mut UnchainedSystem {
-        let label = system.type_id();
-
-        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
-        unchained_system.initialize(world);
-
-        self.systems.insert(label, unchained_system);
-        self.systems.get_mut(&label).unwrap()
+        flush_commands: bool,
+    ) {
+        let type_id = TypeId::of::<S>();
+        if self.type_id_registered(&type_id) {
+            self.run_system_by_type_id(world, type_id, flush_commands);
+        } else {
+            self.register(world, system);
+            self.run_system_by_type_id(world, type_id, flush_commands);
+        }
     }
 }
 
@@ -90,7 +94,7 @@ impl World {
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system);
+            registry.run_system(world, system, true);
         });
     }
 
@@ -108,7 +112,7 @@ impl World {
         system: S,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_without_flushing(world, system);
+            registry.run_system(world, system, false);
         });
     }
 }

From d7ece72a82ad855ff96dae96190cbfbbe6b09f53 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:15:17 -0500
Subject: [PATCH 05/66] Fix doc links

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 7d2d720d3ebe1..07d36e107225b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -117,7 +117,7 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry`] [`Commands`]
+/// The [`Command`] type for [`SystemRegistry`] [`Commands`](crate::system::Commands)
 #[derive(Debug, Clone)]
 pub struct RunSystemCommand<
     Params: Send + Sync + 'static,
@@ -131,7 +131,7 @@ pub struct RunSystemCommand<
 impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
     RunSystemCommand<Params, S>
 {
-    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`]
+    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
     pub fn new(system: S, flush: bool) -> Self {

From f54db1fcb6a9b0abade2299f818d68259ee780d7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:31:20 -0500
Subject: [PATCH 06/66] run_system_by_type_id for World and Commands

---
 crates/bevy_ecs/src/system/system_registry.rs | 48 +++++++++++++++++--
 1 file changed, 45 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 07d36e107225b..f6a62b42abdfd 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -27,7 +27,7 @@ impl SystemRegistry {
     ///
     /// This only needs to be called manually whenn using [`run_system_by_type_id`](SystemRegistry).
     #[inline]
-    pub fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -74,13 +74,23 @@ impl SystemRegistry {
         if self.type_id_registered(&type_id) {
             self.run_system_by_type_id(world, type_id, flush_commands);
         } else {
-            self.register(world, system);
+            self.register_system(world, system);
             self.run_system_by_type_id(world, type_id, flush_commands);
         }
     }
 }
 
 impl World {
+    /// Registers the supplied system in the [`SystemRegistry`] resource
+    ///
+    /// This allows the system to be run by [`TypeId`] using [`World::run_system_by_type_id`]
+    #[inline]
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system(world, system);
+        });
+    }
+
     /// Runs the supplied system on the [`World`] a single time
     ///
     /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
@@ -98,6 +108,25 @@ impl World {
         });
     }
 
+    /// Runs the system corresponding to the supplied `type_id` on the [`World`] a single time
+    ///
+    /// Systems must be registered before they can be run by `type_id`.
+    ///
+    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
+    ///
+    /// The system's state will be cached: any future calls using the same type will use this state,
+    /// improving performance and ensuring that change detection works properly.
+    ///
+    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
+    /// at once, and want parallel execution of these systems.
+    #[inline]
+    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_system_by_type_id(world, type_id, true);
+        });
+    }
+
     /// Runs the supplied system on the [`World`] a single time, wihthout flushing [`Commands`](crate::system::Commands)
     ///
     /// The system's state will be cached: any future calls using the same type will use this state,
@@ -117,7 +146,7 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry`] [`Commands`](crate::system::Commands)
+/// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
 pub struct RunSystemCommand<
     Params: Send + Sync + 'static,
@@ -155,3 +184,16 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
         }
     }
 }
+
+/// The [`Command`] type for [`SystemRegistry::run_system_by_type_id`]
+#[derive(Debug, Clone)]
+pub struct RunSystemByTypeIdCommand {
+    pub type_id: TypeId,
+}
+
+impl Command for RunSystemByTypeIdCommand {
+    #[inline]
+    fn write(self, world: &mut World) {
+        world.run_system_by_type_id(self.type_id)
+    }
+}

From 4fc35e51ced2abc2c571eafd56a3359c33506b2c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:38:48 -0500
Subject: [PATCH 07/66] Always flush commands from systems

Only the commands specific to this system are applied, so we should de-emphasize this choice.
---
 crates/bevy_ecs/src/system/commands/mod.rs    | 20 +++-----
 crates/bevy_ecs/src/system/system_registry.rs | 51 ++++---------------
 2 files changed, 16 insertions(+), 55 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 4ecbf91444db8..7b52511ed1c99 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -4,12 +4,12 @@ use crate::{
     bundle::Bundle,
     component::Component,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemCommand},
+    system::{IntoSystem, RunSystemByTypeIdCommand, RunSystemCommand},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::{error, warn};
 pub use command_queue::CommandQueue;
-use std::marker::PhantomData;
+use std::{any::TypeId, marker::PhantomData};
 
 use super::Resource;
 
@@ -349,7 +349,7 @@ impl<'w, 's> Commands<'w, 's> {
         });
     }
 
-    /// Calls [`World::run_system`] once [`Commands`] are flushed
+    /// Calls [`World::run_system`]
     pub fn run_system<
         Params: Send + Sync + 'static,
         S: IntoSystem<(), (), Params> + Send + Sync + 'static,
@@ -357,18 +357,12 @@ impl<'w, 's> Commands<'w, 's> {
         &mut self,
         system: S,
     ) {
-        self.queue.push(RunSystemCommand::new(system, true));
+        self.queue.push(RunSystemCommand::new(system));
     }
 
-    /// Calls [`World::run_system_without_flushing`] once [`Commands`] are flushed
-    pub fn run_system_without_flushing<
-        Params: Send + Sync + 'static,
-        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
-    >(
-        &mut self,
-        system: S,
-    ) {
-        self.queue.push(RunSystemCommand::new(system, false));
+    /// Calls [`World::run_system_by_type_id`]
+    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
+        self.queue.push(RunSystemByTypeIdCommand { type_id });
     }
 
     /// Adds a command directly to the command list.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index f6a62b42abdfd..1bcf354c7e644 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -14,6 +14,7 @@ pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
 ///
 /// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
 /// including for change detection.
+/// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 #[derive(Default)]
@@ -46,19 +47,10 @@ impl SystemRegistry {
     }
 
     /// Runs the system corresponding to the provided [`TypeId`] on the [`World`] a single time
-    ///
-    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
-    pub fn run_system_by_type_id(
-        &mut self,
-        world: &mut World,
-        type_id: TypeId,
-        flush_commands: bool,
-    ) {
+    pub fn run_system_by_type_id(&mut self, world: &mut World, type_id: TypeId) {
         let initialized_system = self.systems.get_mut(&type_id).unwrap_or_else(||{panic!{"No system with the `TypeId` {type_id:?} was found. Did you forget to register it?"}});
         initialized_system.run((), world);
-        if flush_commands {
-            initialized_system.apply_buffers(world);
-        }
+        initialized_system.apply_buffers(world);
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -68,14 +60,13 @@ impl SystemRegistry {
         &mut self,
         world: &mut World,
         system: S,
-        flush_commands: bool,
     ) {
         let type_id = TypeId::of::<S>();
         if self.type_id_registered(&type_id) {
-            self.run_system_by_type_id(world, type_id, flush_commands);
+            self.run_system_by_type_id(world, type_id);
         } else {
             self.register_system(world, system);
-            self.run_system_by_type_id(world, type_id, flush_commands);
+            self.run_system_by_type_id(world, type_id);
         }
     }
 }
@@ -104,7 +95,7 @@ impl World {
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system, true);
+            registry.run_system(world, system);
         });
     }
 
@@ -123,25 +114,7 @@ impl World {
     #[inline]
     pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_by_type_id(world, type_id, true);
-        });
-    }
-
-    /// Runs the supplied system on the [`World`] a single time, wihthout flushing [`Commands`](crate::system::Commands)
-    ///
-    /// The system's state will be cached: any future calls using the same type will use this state,
-    /// improving performance and ensuring that change detection works properly.
-    ///
-    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
-    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
-    /// at once, and want parallel execution of these systems.
-    #[inline]
-    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system, false);
+            registry.run_system_by_type_id(world, type_id);
         });
     }
 }
@@ -154,7 +127,6 @@ pub struct RunSystemCommand<
 > {
     _phantom_params: PhantomData<Params>,
     system: S,
-    flush: bool,
 }
 
 impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
@@ -163,11 +135,10 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     /// Creates a new [`Command`] struct, which can be addeded to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
-    pub fn new(system: S, flush: bool) -> Self {
+    pub fn new(system: S) -> Self {
         Self {
             _phantom_params: PhantomData::default(),
             system,
-            flush,
         }
     }
 }
@@ -177,11 +148,7 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
 {
     #[inline]
     fn write(self, world: &mut World) {
-        if self.flush {
-            world.run_system(self.system);
-        } else {
-            world.run_system_without_flushing(self.system);
-        }
+        world.run_system(self.system);
     }
 }
 

From a9be93363c65a09b46ec50a17651a955890442ce Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:53:39 -0500
Subject: [PATCH 08/66] Always initialize SystemRegistry on the `World`

---
 crates/bevy_core/src/lib.rs      | 3 +--
 crates/bevy_ecs/src/world/mod.rs | 9 ++++++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index c777276f64e07..038abaeb16eb2 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -22,7 +22,7 @@ use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
     schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
-    system::{IntoExclusiveSystem, SystemRegistry},
+    system::IntoExclusiveSystem,
 };
 use bevy_utils::HashSet;
 use std::ops::Range;
@@ -50,7 +50,6 @@ impl Plugin for CorePlugin {
 
         app.init_resource::<Time>()
             .init_resource::<FixedTimesteps>()
-            .init_resource::<SystemRegistry>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 24c7db76f15a7..414d3a6967bee 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -15,7 +15,7 @@ use crate::{
     entity::{AllocAtWithoutReplacement, Entities, Entity},
     query::{FilterFetch, QueryState, WorldQuery},
     storage::{Column, SparseSet, Storages},
-    system::Resource,
+    system::{Resource, SystemRegistry},
 };
 use bevy_utils::tracing::debug;
 use std::{
@@ -92,7 +92,7 @@ pub struct World {
 
 impl Default for World {
     fn default() -> Self {
-        Self {
+        let mut world = Self {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Default::default(),
             components: Default::default(),
@@ -106,7 +106,10 @@ impl Default for World {
             // are detected on first system runs and for direct world queries.
             change_tick: AtomicU32::new(1),
             last_change_tick: 0,
-        }
+        };
+        // This resource is required by bevy_ecs itself, so cannot be included in a plugin
+        world.init_resource::<SystemRegistry>();
+        world
     }
 }
 

From fed175ce1824918078f7394690a294ebd273515c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 17:46:08 -0500
Subject: [PATCH 09/66] Add test suite

---
 crates/bevy_ecs/src/system/system_registry.rs | 133 ++++++++++++++++++
 1 file changed, 133 insertions(+)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 1bcf354c7e644..ec23b40333dea 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -164,3 +164,136 @@ impl Command for RunSystemByTypeIdCommand {
         world.run_system_by_type_id(self.type_id)
     }
 }
+
+mod tests {
+    use crate::prelude::*;
+
+    #[derive(Default, PartialEq, Debug)]
+    struct Counter(u8);
+
+    #[allow(dead_code)]
+    fn count_up(mut counter: ResMut<Counter>) {
+        counter.0 += 1;
+    }
+
+    #[test]
+    fn run_system() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+    }
+
+    #[test]
+    fn run_system_by_type_id() {
+        use std::any::Any;
+
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.register_system(count_up);
+        world.run_system_by_type_id(count_up.type_id());
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+    }
+
+    #[allow(dead_code)]
+    fn spawn_entity(mut commands: Commands) {
+        commands.spawn();
+    }
+
+    #[test]
+    fn command_processing() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(world.entities.len(), 0);
+        world.run_system(spawn_entity);
+        assert_eq!(world.entities.len(), 1);
+    }
+
+    fn non_send_count_down(mut ns: NonSendMut<Counter>) {
+        ns.0 -= 1;
+    }
+
+    #[allow(dead_code)]
+    fn trigger_non_send_count_down(mut commands: Commands) {
+        commands.run_system(non_send_count_down);
+    }
+
+    #[test]
+    fn non_send_resources() {
+        let mut world = World::new();
+        world.insert_non_send_resource(Counter(10));
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
+        world.run_system(non_send_count_down);
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
+        world.run_system(trigger_non_send_count_down);
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(8));
+    }
+
+    #[derive(Default)]
+    struct ChangeDetector;
+
+    #[allow(dead_code)]
+    fn count_up_iff_changed(mut commands: Commands, change_detector: ResMut<ChangeDetector>) {
+        if change_detector.is_changed() {
+            commands.run_system(count_up);
+        }
+    }
+
+    #[test]
+    fn change_detection() {
+        let mut world = World::new();
+        world.init_resource::<ChangeDetector>();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        // Resources are changed when they are first added.
+        world.run_system(count_up_iff_changed);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        // Nothing changed
+        world.run_system(count_up_iff_changed);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        // Making a change
+        world.resource_mut::<ChangeDetector>().set_changed();
+        world.run_system(count_up_iff_changed);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+    }
+
+    #[allow(dead_code)]
+    // The `Local` begins at the default value of 0
+    fn fibonacci_counting(last_counter: Local<u8>, mut counter: ResMut<Counter>) {
+        counter.0 = *last_counter + counter.0;
+    }
+
+    #[test]
+    fn local_variables() {
+        let mut world = World::new();
+        world.insert_resource(Counter(1));
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(3));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(5));
+    }
+
+    #[allow(dead_code)]
+    fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
+        counter.0 += 1;
+        if counter.0 < 10 {
+            commands.run_system(count_to_ten)
+        }
+    }
+
+    #[test]
+    fn system_recursion() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_to_ten);
+        assert_eq!(*world.resource::<Counter>(), Counter(10));
+    }
+}

From b883bca762fe74e78c9d6c03f660cef216c70f63 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 7 Mar 2022 11:57:51 -0500
Subject: [PATCH 10/66] Doc improvements

---
 crates/bevy_ecs/src/system/system_registry.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index ec23b40333dea..d6254d1764b47 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -10,7 +10,7 @@ use crate::world::{Mut, World};
 /// [`BoxedSystem`](crate::system::BoxedSystem) is the equivalent type alias for arbitrary `In` and `Out` types.
 pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
 
-/// Stores initialized [`Systems`](crate::system::System), so they can quickly be reused and run
+/// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
 ///
 /// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
 /// including for change detection.
@@ -22,7 +22,6 @@ pub struct SystemRegistry {
     systems: HashMap<TypeId, UnchainedSystem>,
 }
 
-// User-facing methods
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
@@ -42,6 +41,7 @@ impl SystemRegistry {
     }
 
     /// Is the provided `type_id` registered?
+    #[inline]
     pub fn type_id_registered(&self, type_id: &TypeId) -> bool {
         self.systems.contains_key(type_id)
     }
@@ -132,7 +132,7 @@ pub struct RunSystemCommand<
 impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
     RunSystemCommand<Params, S>
 {
-    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`](crate::system::Commands)
+    /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
     pub fn new(system: S) -> Self {

From ee336305b793bc3ab1523ba652feb59132c47e4e Mon Sep 17 00:00:00 2001
From: Alice <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 02:17:30 -0400
Subject: [PATCH 11/66] Store registered systems by their system labels

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  11 +-
 crates/bevy_ecs/src/system/function_system.rs |  12 ++
 crates/bevy_ecs/src/system/system_registry.rs | 167 +++++++++++++-----
 3 files changed, 139 insertions(+), 51 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 7b52511ed1c99..86ad3984c84c4 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -4,12 +4,13 @@ use crate::{
     bundle::Bundle,
     component::Component,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemByTypeIdCommand, RunSystemCommand},
+    schedule::SystemLabel,
+    system::{IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::{error, warn};
 pub use command_queue::CommandQueue;
-use std::{any::TypeId, marker::PhantomData};
+use std::marker::PhantomData;
 
 use super::Resource;
 
@@ -361,8 +362,10 @@ impl<'w, 's> Commands<'w, 's> {
     }
 
     /// Calls [`World::run_system_by_type_id`]
-    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
-        self.queue.push(RunSystemByTypeIdCommand { type_id });
+    pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
+        self.queue.push(RunSystemsByLabelCommand {
+            label: Box::new(label),
+        });
     }
 
     /// Adds a command directly to the command list.
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 30f421cabad37..751ca5993d97a 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -445,6 +445,8 @@ where
             self.system_meta.name.as_ref(),
         );
     }
+
+    #[inline]
     fn default_labels(&self) -> Vec<Box<dyn SystemLabel>> {
         vec![Box::new(self.func.as_system_label())]
     }
@@ -453,6 +455,16 @@ where
 /// A [`SystemLabel`] that was automatically generated for a system on the basis of its `TypeId`.
 pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
 
+impl<T: 'static> SystemTypeIdLabel<T> {
+    /// Constructs a new copy of the [`SystemTypeIdLabel`] for the type `T`
+    ///
+    /// You can also construct this by using [`.as_system_label()](crate::system::AsSystemLabel) on a concrete instance
+    /// of your function type.
+    pub fn new() -> Self {
+        Self(PhantomData::default())
+    }
+}
+
 impl<T> Debug for SystemTypeIdLabel<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("SystemTypeIdLabel")
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d6254d1764b47..17dc85674c1c9 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,56 +1,124 @@
 use bevy_utils::HashMap;
-use std::any::{Any, TypeId};
 use std::marker::PhantomData;
 
-use crate::system::{Command, IntoSystem, System};
+use crate::archetype::ArchetypeGeneration;
+use crate::schedule::SystemLabel;
+use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
 
-/// A [`System`] that cannot be chained.
-///
-/// [`BoxedSystem`](crate::system::BoxedSystem) is the equivalent type alias for arbitrary `In` and `Out` types.
-pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
-
 /// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
 ///
-/// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
-/// including for change detection.
+/// Systems are keyed by their [`SystemLabel`]:
+///  - all systems with a given label will be run (in linear registration order) when a given label is run
+///  - repeated calls with the same function type will reuse cached state, including for change detection
+///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 #[derive(Default)]
 pub struct SystemRegistry {
-    systems: HashMap<TypeId, UnchainedSystem>,
+    systems: Vec<StoredSystem>,
+    // Stores the index of all systems that match the key's label
+    labels: HashMap<Box<dyn SystemLabel>, Vec<usize>>,
+}
+
+struct StoredSystem {
+    system: Box<dyn System<In = (), Out = ()>>,
+    generation: ArchetypeGeneration,
+}
+
+impl StoredSystem {
+    /// Updates archetypes to ensure our access pointers are correct
+    ///
+    /// This logic must be run after each system is run, as each system can modify archetypes
+    // TODO: remove this method once https://github.com/bevyengine/bevy/pull/4115 is merged
+    fn update_archetypes(&mut self, world: &mut World) {
+        // This logic is borrowed directly from SingleThreadedExecutor
+        let archetypes = world.archetypes();
+        let new_generation = archetypes.generation();
+        let old_generation = std::mem::replace(&mut self.generation, new_generation);
+        self.generation = new_generation;
+
+        let archetype_index_range = old_generation.value()..new_generation.value();
+
+        for archetype in archetypes.archetypes[archetype_index_range].iter() {
+            self.system.new_archetype(archetype);
+        }
+    }
 }
 
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// This only needs to be called manually whenn using [`run_system_by_type_id`](SystemRegistry).
+    /// This method only needs to be called manually when using [`run_system_by_label`](SystemRegistry).
+    ///
+    /// If `labels` are provided, the system will be registered under those labels.
+    /// Otherwise, it will use the default labels for that system, typically its [`SystemTypeIdLabel`].
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
+        labels: Option<Vec<Box<dyn SystemLabel>>>,
     ) {
-        let label = system.type_id();
+        let mut unchained_system: Box<dyn System<In = (), Out = ()>> =
+            Box::new(IntoSystem::into_system(system));
 
-        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
-        unchained_system.initialize(world);
+        // If no labels are provided, use the default labels
+        let labels = labels.unwrap_or(unchained_system.default_labels());
 
-        self.systems.insert(label, unchained_system);
+        // Intialize the system's state
+        unchained_system.initialize(world);
+        // Record the archetype generation at the time of its creation
+        let archetype_generation = ArchetypeGeneration::initial();
+
+        let stored_system = StoredSystem {
+            system: unchained_system,
+            generation: archetype_generation,
+        };
+
+        // Add the system to the end of the vec
+        self.systems.push(stored_system);
+        let system_index = self.systems.len();
+
+        // For each label that the system has
+        for label in labels {
+            let maybe_label_indexes = self.labels.get_mut(&label);
+
+            // Add the index of the system in the vec to the lookup hashmap
+            // under the corresponding label key
+            if let Some(label_indexes) = maybe_label_indexes {
+                label_indexes.push(system_index);
+            } else {
+                self.labels.insert(label, vec![system_index]);
+            };
+        }
     }
 
-    /// Is the provided `type_id` registered?
-    #[inline]
-    pub fn type_id_registered(&self, type_id: &TypeId) -> bool {
-        self.systems.contains_key(type_id)
+    /// Returns true if at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`].
+    pub fn label_registered<L: SystemLabel>(&self, label: L) -> bool {
+        let boxed_label: Box<dyn SystemLabel> = Box::new(label);
+        self.labels.get(&boxed_label).is_some()
     }
 
-    /// Runs the system corresponding to the provided [`TypeId`] on the [`World`] a single time
-    pub fn run_system_by_type_id(&mut self, world: &mut World, type_id: TypeId) {
-        let initialized_system = self.systems.get_mut(&type_id).unwrap_or_else(||{panic!{"No system with the `TypeId` {type_id:?} was found. Did you forget to register it?"}});
-        initialized_system.run((), world);
-        initialized_system.apply_buffers(world);
+    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
+    ///
+    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
+    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, world: &mut World, label: &L) {
+        let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
+
+        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {label:?} was found. Did you forget to register it?"}});
+
+        // Loop over the system in registration order
+        for &index in matching_system_indexes {
+            let ref mut stored_system = self.systems[index];
+            // Update the archetypes to make sure our data access is correct
+            stored_system.update_archetypes(world);
+            // Run the system
+            stored_system.system.run((), world);
+            // Apply any generated commands
+            stored_system.system.apply_buffers(world);
+        }
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -61,12 +129,13 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
     ) {
-        let type_id = TypeId::of::<S>();
-        if self.type_id_registered(&type_id) {
-            self.run_system_by_type_id(world, type_id);
+        let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
+
+        if self.label_registered(automatic_system_label) {
+            self.run_systems_by_label(world, &automatic_system_label);
         } else {
-            self.register_system(world, system);
-            self.run_system_by_type_id(world, type_id);
+            self.register_system(world, system, None);
+            self.run_systems_by_label(world, &automatic_system_label);
         }
     }
 }
@@ -74,11 +143,15 @@ impl SystemRegistry {
 impl World {
     /// Registers the supplied system in the [`SystemRegistry`] resource
     ///
-    /// This allows the system to be run by [`TypeId`] using [`World::run_system_by_type_id`]
+    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`]
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+        labels: Option<Vec<Box<dyn SystemLabel>>>,
+    ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system);
+            registry.register_system(world, system, labels);
         });
     }
 
@@ -89,7 +162,7 @@ impl World {
     /// The system's state will be cached: any future calls using the same type will use this state,
     /// improving performance and ensuring that change detection works properly.
     ///
-    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// This is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
@@ -99,22 +172,22 @@ impl World {
         });
     }
 
-    /// Runs the system corresponding to the supplied `type_id` on the [`World`] a single time
+    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
     ///
-    /// Systems must be registered before they can be run by `type_id`.
+    /// Systems must be registered before they can be run by their label.
     ///
     /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
     ///
     /// The system's state will be cached: any future calls using the same type will use this state,
     /// improving performance and ensuring that change detection works properly.
     ///
-    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// This is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
-    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
+    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, label: &L) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_by_type_id(world, type_id);
+            registry.run_systems_by_label(world, label);
         });
     }
 }
@@ -152,16 +225,16 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry::run_system_by_type_id`]
+/// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
-pub struct RunSystemByTypeIdCommand {
-    pub type_id: TypeId,
+pub struct RunSystemsByLabelCommand {
+    pub label: Box<dyn SystemLabel>,
 }
 
-impl Command for RunSystemByTypeIdCommand {
+impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
-        world.run_system_by_type_id(self.type_id)
+        world.run_systems_by_label(&*self.label)
     }
 }
 
@@ -186,14 +259,14 @@ mod tests {
     }
 
     #[test]
-    fn run_system_by_type_id() {
-        use std::any::Any;
+    fn run_system_by_label() {
+        use crate::system::AsSystemLabel;
 
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up);
-        world.run_system_by_type_id(count_up.type_id());
+        world.register_system(count_up, None);
+        world.run_systems_by_label(&count_up.as_system_label());
         assert_eq!(*world.resource::<Counter>(), Counter(1));
     }
 

From b520291c36d3dec9fbf1b5d7d652ae8efa103c07 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 15:28:24 -0400
Subject: [PATCH 12/66] Ensure that run_system always runs the system exactly
 once

---
 crates/bevy_ecs/src/system/system_registry.rs | 48 +++++++++++++------
 1 file changed, 34 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 17dc85674c1c9..4435894f6ffbd 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -53,7 +53,7 @@ impl SystemRegistry {
     /// This method only needs to be called manually when using [`run_system_by_label`](SystemRegistry).
     ///
     /// If `labels` are provided, the system will be registered under those labels.
-    /// Otherwise, it will use the default labels for that system, typically its [`SystemTypeIdLabel`].
+    /// Otherwise, it will use the default labels for that system: typically its [`SystemTypeIdLabel`].
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
@@ -95,12 +95,38 @@ impl SystemRegistry {
         }
     }
 
+    /// Runs the system at the supplied `index` a single time
+    #[inline]
+    fn run_system_at_index(&mut self, world: &mut World, index: usize) {
+        let ref mut stored_system = self.systems[index];
+
+        // Update the archetypes to make sure our data access is correct
+        stored_system.update_archetypes(world);
+        // Run the system
+        stored_system.system.run((), world);
+        // Apply any generated commands
+        stored_system.system.apply_buffers(world);
+    }
+
     /// Returns true if at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`].
+    #[inline]
     pub fn label_registered<L: SystemLabel>(&self, label: L) -> bool {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
         self.labels.get(&boxed_label).is_some()
     }
 
+    /// Returns the first matching index for systems with this label
+    ///
+    /// # Panics
+    ///
+    /// Panics if no system with the label is registered.
+    #[inline]
+    fn first_registered_index<L: SystemLabel>(&self, label: L) -> usize {
+        let boxed_label: Box<dyn SystemLabel> = Box::new(label);
+        let vec_of_indexes = self.labels.get(&boxed_label).unwrap();
+        *vec_of_indexes.iter().next().unwrap()
+    }
+
     /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
@@ -110,20 +136,16 @@ impl SystemRegistry {
         let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {label:?} was found. Did you forget to register it?"}});
 
         // Loop over the system in registration order
-        for &index in matching_system_indexes {
-            let ref mut stored_system = self.systems[index];
-            // Update the archetypes to make sure our data access is correct
-            stored_system.update_archetypes(world);
-            // Run the system
-            stored_system.system.run((), world);
-            // Apply any generated commands
-            stored_system.system.apply_buffers(world);
+        for index in matching_system_indexes.clone() {
+            self.run_system_at_index(world, index);
         }
     }
 
     /// Runs the supplied system on the [`World`] a single time
     ///
-    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
+    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
+    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
+    /// only the first will be run.
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
@@ -131,12 +153,10 @@ impl SystemRegistry {
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
-        if self.label_registered(automatic_system_label) {
-            self.run_systems_by_label(world, &automatic_system_label);
-        } else {
+        if !self.label_registered(automatic_system_label) {
             self.register_system(world, system, None);
-            self.run_systems_by_label(world, &automatic_system_label);
         }
+        self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }
 }
 

From 7041713523b5ea8a7a0df0aab311ef5ece709fd2 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 15:54:54 -0400
Subject: [PATCH 13/66] Advertise SystemRegistry in SystemState docs

---
 crates/bevy_ecs/src/system/function_system.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 751ca5993d97a..c2b8537b6be88 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -55,8 +55,10 @@ impl SystemMeta {
 // (to avoid the need for unwrapping to retrieve SystemMeta)
 /// Holds on to persistent state required to drive [`SystemParam`] for a [`System`].
 ///
-/// This is a very powerful and convenient tool for working with exclusive world access,
+/// This is a powerful and convenient tool for working with exclusive world access,
 /// allowing you to fetch data from the [`World`] as if you were running a [`System`].
+/// However, simply calling `world::run_system(my_system)` using a [`SystemRegistry`](crate::system::SystemRegistry)
+/// can be significantly simpler and more reliable.
 ///
 /// Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once,
 /// and arbitrary system parameters (like [`EventWriter`](crate::event::EventWriter)) can be conveniently fetched.
@@ -72,6 +74,8 @@ impl SystemMeta {
 /// - [`Local`](crate::system::Local) variables that hold state
 /// - [`EventReader`](crate::event::EventReader) system parameters, which rely on a [`Local`](crate::system::Local) to track which events have been seen
 ///
+/// Note that this is automatically handled for you when using a [`SystemRegistry`](crate::system::SystemRegistry).
+///
 /// # Example
 ///
 /// Basic usage:

From 1a5e308d79c7f1d50158cd69dffdd4770006fc7b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 17:24:43 -0400
Subject: [PATCH 14/66] Doc tests for SystemRegistry

---
 crates/bevy_ecs/src/system/system_registry.rs | 112 +++++++++++++++++-
 1 file changed, 106 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 4435894f6ffbd..ed42eafb72907 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -15,6 +15,101 @@ use crate::world::{Mut, World};
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+///
+/// # Examples
+///
+/// You can run a single system directly on the World,
+/// applying its effect and caching its state for the next time
+/// you call this method (internally, this is based on [`SystemTypeIdLabel`]).
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+///
+/// let mut world = World::new();  
+///
+/// #[derive(Default, PartialEq, Debug)]
+/// struct Counter(u8);
+///
+/// fn count_up(mut counter: ResMut<Counter>){
+///     counter.0 += 1;
+/// }
+///
+/// world.init_resource::<Counter>();
+/// world.run_system(count_up);
+///
+/// assert_eq!(Counter(1), *world.resource());
+/// ```
+///
+/// These systems immediately apply commands and cache state,
+/// ensuring that change detection and [`Local`](crate::system::Local) variables work correctly.
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+///
+/// let mut world = World::new();
+///
+/// #[derive(Component)]
+/// struct Marker;
+///
+/// fn spawn_7_entities(mut commands: Commands) {
+///     for _ in 0..7 {
+///         commands.spawn().insert(Marker);
+///     }
+///     
+///     // You can even run systems via commands,
+///     // which will take effect the next time commands are applied
+///     commands.run_system(assert_7_spawned)
+/// }
+///
+/// fn assert_7_spawned(query: Query<(), Added<Marker>>){
+///     let n_spawned = query.iter().count();
+///     assert_eq!(n_spawned, 7);
+/// }
+///
+/// world.run_system(spawn_7_entities);
+/// ```
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::SystemRegistry;
+///
+/// let mut world = World::new();
+/// // The `SystemRegistry` type is automatically included as a resource in every World
+/// let mut system_registry: Mut<SystemRegistry> = world.resource_mut();
+///
+/// #[derive(SystemLabel, Debug, PartialEq, Eq, Hash, Clone)]
+/// enum ManualSystems {
+///     Hello,
+///     Goodbye,
+/// }
+///
+/// fn hello(){
+///     println!("Hello!")
+/// }
+///
+/// fn goodbye(){
+///     println!("Goodbye <3")
+/// }
+///
+/// fn have_a_nice_day(){
+///     println!("Have a nice day, and enjoy using Bevy!")
+/// }
+///
+/// // You can register systems by their label
+/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
+///
+/// // And run them by their label as well
+/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+///
+/// // All systems registered under that label will be run, in registration order
+/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
+/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+///
+/// // All methods on this type are also exposed on the `World` for convenience
+/// world.register_system(goodbye, vec![ManualSystems::Goodbye]);
+/// world.register_system(have_a_nice_day, vec![ManualSystems::Goodbye]);
+/// world.run_systems_by_label(&ManualSystems::Goodbye);
+/// ```
 #[derive(Default)]
 pub struct SystemRegistry {
     systems: Vec<StoredSystem>,
@@ -59,13 +154,17 @@ impl SystemRegistry {
         &mut self,
         world: &mut World,
         system: S,
-        labels: Option<Vec<Box<dyn SystemLabel>>>,
+        labels: Vec<Box<dyn SystemLabel>>,
     ) {
         let mut unchained_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
         // If no labels are provided, use the default labels
-        let labels = labels.unwrap_or(unchained_system.default_labels());
+        let labels = if labels.is_empty() {
+            unchained_system.default_labels()
+        } else {
+            labels
+        };
 
         // Intialize the system's state
         unchained_system.initialize(world);
@@ -154,7 +253,7 @@ impl SystemRegistry {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
         if !self.label_registered(automatic_system_label) {
-            self.register_system(world, system, None);
+            self.register_system(world, system, Vec::default());
         }
         self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }
@@ -168,7 +267,7 @@ impl World {
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         system: S,
-        labels: Option<Vec<Box<dyn SystemLabel>>>,
+        labels: Vec<Box<dyn SystemLabel>>,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.register_system(world, system, labels);
@@ -285,9 +384,10 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, None);
+        world.register_system(count_up, Vec::default());
+        world.register_system(count_up, Vec::default());
         world.run_systems_by_label(&count_up.as_system_label());
-        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
     #[allow(dead_code)]

From 6f3a676aa58e420d1c31a0f974c90599a4259e2c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 18:25:33 -0400
Subject: [PATCH 15/66] Improve ergonomics of the register_system API

---
 crates/bevy_ecs/src/system/system_registry.rs | 33 +++++++++++++------
 1 file changed, 23 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index ed42eafb72907..8e5a734f29699 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -154,25 +154,35 @@ impl SystemRegistry {
         &mut self,
         world: &mut World,
         system: S,
-        labels: Vec<Box<dyn SystemLabel>>,
+        labels: impl IntoIterator<Item = Box<dyn SystemLabel>>,
     ) {
-        let mut unchained_system: Box<dyn System<In = (), Out = ()>> =
+        let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
+        let mut labels: Vec<Box<dyn SystemLabel>> = labels.into_iter().collect();
+
         // If no labels are provided, use the default labels
-        let labels = if labels.is_empty() {
-            unchained_system.default_labels()
-        } else {
-            labels
-        };
+        if labels.is_empty() {
+            labels = boxed_system.default_labels()
+        }
+
+        self.register_boxed_system_by_labels(world, boxed_system, labels);
+    }
 
+    /// A more effecient but less ergonomic version of `register_system`
+    pub fn register_boxed_system_by_labels(
+        &mut self,
+        world: &mut World,
+        mut boxed_system: Box<dyn System<In = (), Out = ()>>,
+        labels: Vec<Box<dyn SystemLabel>>,
+    ) {
         // Intialize the system's state
-        unchained_system.initialize(world);
+        boxed_system.initialize(world);
         // Record the archetype generation at the time of its creation
         let archetype_generation = ArchetypeGeneration::initial();
 
         let stored_system = StoredSystem {
-            system: unchained_system,
+            system: boxed_system,
             generation: archetype_generation,
         };
 
@@ -253,7 +263,10 @@ impl SystemRegistry {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
         if !self.label_registered(automatic_system_label) {
-            self.register_system(world, system, Vec::default());
+            let boxed_system: Box<dyn System<In = (), Out = ()>> =
+                Box::new(IntoSystem::into_system(system));
+            let labels = boxed_system.default_labels();
+            self.register_boxed_system_by_labels(world, boxed_system, labels);
         }
         self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }

From ebe2f29f3b36f7d2ac10b1486cc9798c58e8b2d9 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 19:10:27 -0400
Subject: [PATCH 16/66] Improve run_by_label API ergonomics

---
 crates/bevy_ecs/src/system/system_registry.rs | 36 ++++++++++++-------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 8e5a734f29699..59c331b484133 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -96,19 +96,20 @@ use crate::world::{Mut, World};
 /// }
 ///
 /// // You can register systems by their label
-/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
+/// system_registry.register_system(&mut world, hello, ManualSystems::Hello);
 ///
 /// // And run them by their label as well
-/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
+///
+/// // You can register systems under multiple labels
+/// system_registry.register_system(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
 ///
 /// // All systems registered under that label will be run, in registration order
-/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
-/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
 ///
 /// // All methods on this type are also exposed on the `World` for convenience
-/// world.register_system(goodbye, vec![ManualSystems::Goodbye]);
-/// world.register_system(have_a_nice_day, vec![ManualSystems::Goodbye]);
-/// world.run_systems_by_label(&ManualSystems::Goodbye);
+/// world.register_system(goodbye, ManualSystems::Goodbye);
+/// world.run_systems_by_label(ManualSystems::Goodbye);
 /// ```
 #[derive(Default)]
 pub struct SystemRegistry {
@@ -239,10 +240,19 @@ impl SystemRegistry {
     /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
-    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, world: &mut World, label: &L) {
+    pub fn run_systems_by_label<L: SystemLabel>(&mut self, world: &mut World, label: L) {
         let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
+        self.run_systems_by_boxed_label(world, boxed_label);
+    }
 
-        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {label:?} was found. Did you forget to register it?"}});
+    /// A less ergonomic version of `run_systems_by_label` that allows you to pass in a boxed `SystemLabel`
+    #[inline]
+    pub fn run_systems_by_boxed_label(
+        &mut self,
+        world: &mut World,
+        boxed_label: Box<dyn SystemLabel>,
+    ) {
+        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {boxed_label:?} was found. Did you forget to register it?"}});
 
         // Loop over the system in registration order
         for index in matching_system_indexes.clone() {
@@ -317,7 +327,7 @@ impl World {
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
-    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, label: &L) {
+    pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run_systems_by_label(world, label);
         });
@@ -366,7 +376,9 @@ pub struct RunSystemsByLabelCommand {
 impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
-        world.run_systems_by_label(&*self.label)
+        world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_systems_by_boxed_label(world, self.label.dyn_clone())
+        });
     }
 }
 
@@ -399,7 +411,7 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(0));
         world.register_system(count_up, Vec::default());
         world.register_system(count_up, Vec::default());
-        world.run_systems_by_label(&count_up.as_system_label());
+        world.run_systems_by_label(count_up.as_system_label());
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 

From 3e41300f1407b5e2e630c8759c64a3ea51aa46e7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 19:44:43 -0400
Subject: [PATCH 17/66] Improve ergonomics of registering systems

---
 crates/bevy_ecs/src/system/system_registry.rs | 74 ++++++++++++++-----
 1 file changed, 55 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 59c331b484133..1c75a4d507d1a 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -102,7 +102,7 @@ use crate::world::{Mut, World};
 /// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
 ///
 /// // You can register systems under multiple labels
-/// system_registry.register_system(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
+/// system_registry.register_system_with_labels(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
 ///
 /// // All systems registered under that label will be run, in registration order
 /// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
@@ -151,26 +151,47 @@ impl SystemRegistry {
     /// If `labels` are provided, the system will be registered under those labels.
     /// Otherwise, it will use the default labels for that system: typically its [`SystemTypeIdLabel`].
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
         &mut self,
         world: &mut World,
         system: S,
-        labels: impl IntoIterator<Item = Box<dyn SystemLabel>>,
+        label: L,
     ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        let mut labels: Vec<Box<dyn SystemLabel>> = labels.into_iter().collect();
+        self.register_boxed_system_by_labels(world, boxed_system, vec![Box::new(label)]);
+    }
 
-        // If no labels are provided, use the default labels
-        if labels.is_empty() {
-            labels = boxed_system.default_labels()
-        }
+    /// Register system a system with any number of [`SystemLabel`]
+    ///
+    /// This allows the system to be run whenever any of its labels are run using `run_systems_by_label`.
+    pub fn register_system_with_labels<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        world: &mut World,
+        system: S,
+        labels: LI,
+    ) {
+        let boxed_system: Box<dyn System<In = (), Out = ()>> =
+            Box::new(IntoSystem::into_system(system));
+
+        let collected_labels = labels
+            .into_iter()
+            .map(|label| {
+                let boxed_label: Box<dyn SystemLabel> = Box::new(label);
+                boxed_label
+            })
+            .collect();
 
-        self.register_boxed_system_by_labels(world, boxed_system, labels);
+        self.register_boxed_system_by_labels(world, boxed_system, collected_labels);
     }
 
-    /// A more effecient but less ergonomic version of `register_system`
+    /// A more efficient but less ergonomic version of `register_system_with_labels`
     pub fn register_boxed_system_by_labels(
         &mut self,
         world: &mut World,
@@ -285,15 +306,32 @@ impl SystemRegistry {
 impl World {
     /// Registers the supplied system in the [`SystemRegistry`] resource
     ///
-    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`]
+    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`].
+    /// If you are using [`World::run_system`] directly, manual registration is not needed.
+    /// The system will be automatically registered under its [`SystemTypeIdLabel`] the first time it is run.
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
         &mut self,
         system: S,
-        labels: Vec<Box<dyn SystemLabel>>,
+        label: L,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, labels);
+            registry.register_system(world, system, label);
+        });
+    }
+
+    pub fn register_system_with_labels<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        system: S,
+        labels: LI,
+    ) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system_with_labels(world, system, labels);
         });
     }
 
@@ -404,14 +442,12 @@ mod tests {
 
     #[test]
     fn run_system_by_label() {
-        use crate::system::AsSystemLabel;
-
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, Vec::default());
-        world.register_system(count_up, Vec::default());
-        world.run_systems_by_label(count_up.as_system_label());
+        world.register_system(count_up, "count");
+        world.register_system(count_up, "count");
+        world.run_systems_by_label("count");
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 

From 0f0a6dd4ac730cf0a3c4d26bb97cd55ad4b42461 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 20:09:41 -0400
Subject: [PATCH 18/66] Note limitations

---
 crates/bevy_ecs/src/system/system_registry.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 1c75a4d507d1a..6285530b9abfc 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -14,7 +14,15 @@ use crate::world::{Mut, World};
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
-/// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
+/// However, it will likely be easier to use the corresponding methods on [`World`],
+/// to avoid having to worry about split mutable borrows yourself.
+///
+/// # Limitations
+///
+///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`.
+///  - exclusive systems cannot be used.
 ///
 /// # Examples
 ///
@@ -55,10 +63,6 @@ use crate::world::{Mut, World};
 ///     for _ in 0..7 {
 ///         commands.spawn().insert(Marker);
 ///     }
-///     
-///     // You can even run systems via commands,
-///     // which will take effect the next time commands are applied
-///     commands.run_system(assert_7_spawned)
 /// }
 ///
 /// fn assert_7_spawned(query: Query<(), Added<Marker>>){
@@ -67,6 +71,7 @@ use crate::world::{Mut, World};
 /// }
 ///
 /// world.run_system(spawn_7_entities);
+/// world.run_system(assert_7_spawned);
 /// ```
 ///
 /// ```rust

From 870b12dd3d50c66908c267ff273c4bb9e8d8d1af Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 17 Apr 2022 22:48:07 -0400
Subject: [PATCH 19/66] Remove the need to manually update archetypes

---
 crates/bevy_ecs/src/system/system_registry.rs | 27 -------------------
 1 file changed, 27 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 6285530b9abfc..0381f6ef5d69b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,7 +1,6 @@
 use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
-use crate::archetype::ArchetypeGeneration;
 use crate::schedule::SystemLabel;
 use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
@@ -125,27 +124,6 @@ pub struct SystemRegistry {
 
 struct StoredSystem {
     system: Box<dyn System<In = (), Out = ()>>,
-    generation: ArchetypeGeneration,
-}
-
-impl StoredSystem {
-    /// Updates archetypes to ensure our access pointers are correct
-    ///
-    /// This logic must be run after each system is run, as each system can modify archetypes
-    // TODO: remove this method once https://github.com/bevyengine/bevy/pull/4115 is merged
-    fn update_archetypes(&mut self, world: &mut World) {
-        // This logic is borrowed directly from SingleThreadedExecutor
-        let archetypes = world.archetypes();
-        let new_generation = archetypes.generation();
-        let old_generation = std::mem::replace(&mut self.generation, new_generation);
-        self.generation = new_generation;
-
-        let archetype_index_range = old_generation.value()..new_generation.value();
-
-        for archetype in archetypes.archetypes[archetype_index_range].iter() {
-            self.system.new_archetype(archetype);
-        }
-    }
 }
 
 impl SystemRegistry {
@@ -205,12 +183,9 @@ impl SystemRegistry {
     ) {
         // Intialize the system's state
         boxed_system.initialize(world);
-        // Record the archetype generation at the time of its creation
-        let archetype_generation = ArchetypeGeneration::initial();
 
         let stored_system = StoredSystem {
             system: boxed_system,
-            generation: archetype_generation,
         };
 
         // Add the system to the end of the vec
@@ -236,8 +211,6 @@ impl SystemRegistry {
     fn run_system_at_index(&mut self, world: &mut World, index: usize) {
         let ref mut stored_system = self.systems[index];
 
-        // Update the archetypes to make sure our data access is correct
-        stored_system.update_archetypes(world);
         // Run the system
         stored_system.system.run((), world);
         // Apply any generated commands

From ba66966ffaf65557efadbb2e26e353d4b9cd6863 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 17 Apr 2022 23:24:01 -0400
Subject: [PATCH 20/66] Move SystemRegistry to a field on `World`

---
 crates/bevy_ecs/src/system/system_registry.rs | 21 +++++++------------
 crates/bevy_ecs/src/world/mod.rs              | 14 +++++++------
 2 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 0381f6ef5d69b..175a5dc364567 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -13,8 +13,8 @@ use crate::world::{Mut, World};
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
-/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
-/// However, it will likely be easier to use the corresponding methods on [`World`],
+/// This type is stored as a field on each [`World`].
+/// Geneerally speaking, you should use the corresponding methods on [`World`],
 /// to avoid having to worry about split mutable borrows yourself.
 ///
 /// # Limitations
@@ -293,9 +293,7 @@ impl World {
         system: S,
         label: L,
     ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, label);
-        });
+        self.system_registry.register_system(self, system, label);
     }
 
     pub fn register_system_with_labels<
@@ -308,9 +306,8 @@ impl World {
         system: S,
         labels: LI,
     ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_labels(world, system, labels);
-        });
+        self.system_registry
+            .register_system_with_labels(self, system, labels);
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -325,9 +322,7 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system);
-        });
+        self.system_registry.run_system(self, system);
     }
 
     /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
@@ -344,9 +339,7 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_label(world, label);
-        });
+        self.system_registry.run_systems_by_label(self, label);
     }
 }
 
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 414d3a6967bee..3419e24458c12 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -83,16 +83,20 @@ pub struct World {
     pub(crate) storages: Storages,
     pub(crate) bundles: Bundles,
     pub(crate) removed_components: SparseSet<ComponentId, Vec<Entity>>,
-    /// Access cache used by [WorldCell].
+    /// Access cache used by [`WorldCell`].
     pub(crate) archetype_component_access: ArchetypeComponentAccess,
     main_thread_validator: MainThreadValidator,
     pub(crate) change_tick: AtomicU32,
     pub(crate) last_change_tick: u32,
+    /// Stores the systems associated with this [`World`],
+    ///
+    /// These system can be manually run using [`World::run_system`].
+    pub system_registry: SystemRegistry,
 }
 
 impl Default for World {
     fn default() -> Self {
-        let mut world = Self {
+        World {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Default::default(),
             components: Default::default(),
@@ -106,10 +110,8 @@ impl Default for World {
             // are detected on first system runs and for direct world queries.
             change_tick: AtomicU32::new(1),
             last_change_tick: 0,
-        };
-        // This resource is required by bevy_ecs itself, so cannot be included in a plugin
-        world.init_resource::<SystemRegistry>();
-        world
+            system_registry: Default::default(),
+        }
     }
 }
 

From 5baac515ea40249b670f44c8aea3d7993cb45e88 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 17 Apr 2022 23:24:01 -0400
Subject: [PATCH 21/66] Revert "Move SystemRegistry to a field on `World`"

This reverts commit ba66966ffaf65557efadbb2e26e353d4b9cd6863.
---
 crates/bevy_ecs/src/system/system_registry.rs | 21 ++++++++++++-------
 crates/bevy_ecs/src/world/mod.rs              | 14 ++++++-------
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 175a5dc364567..0381f6ef5d69b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -13,8 +13,8 @@ use crate::world::{Mut, World};
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
-/// This type is stored as a field on each [`World`].
-/// Geneerally speaking, you should use the corresponding methods on [`World`],
+/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
+/// However, it will likely be easier to use the corresponding methods on [`World`],
 /// to avoid having to worry about split mutable borrows yourself.
 ///
 /// # Limitations
@@ -293,7 +293,9 @@ impl World {
         system: S,
         label: L,
     ) {
-        self.system_registry.register_system(self, system, label);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system(world, system, label);
+        });
     }
 
     pub fn register_system_with_labels<
@@ -306,8 +308,9 @@ impl World {
         system: S,
         labels: LI,
     ) {
-        self.system_registry
-            .register_system_with_labels(self, system, labels);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system_with_labels(world, system, labels);
+        });
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -322,7 +325,9 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
-        self.system_registry.run_system(self, system);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_system(world, system);
+        });
     }
 
     /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
@@ -339,7 +344,9 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
-        self.system_registry.run_systems_by_label(self, label);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_systems_by_label(world, label);
+        });
     }
 }
 
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 3419e24458c12..414d3a6967bee 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -83,20 +83,16 @@ pub struct World {
     pub(crate) storages: Storages,
     pub(crate) bundles: Bundles,
     pub(crate) removed_components: SparseSet<ComponentId, Vec<Entity>>,
-    /// Access cache used by [`WorldCell`].
+    /// Access cache used by [WorldCell].
     pub(crate) archetype_component_access: ArchetypeComponentAccess,
     main_thread_validator: MainThreadValidator,
     pub(crate) change_tick: AtomicU32,
     pub(crate) last_change_tick: u32,
-    /// Stores the systems associated with this [`World`],
-    ///
-    /// These system can be manually run using [`World::run_system`].
-    pub system_registry: SystemRegistry,
 }
 
 impl Default for World {
     fn default() -> Self {
-        World {
+        let mut world = Self {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Default::default(),
             components: Default::default(),
@@ -110,8 +106,10 @@ impl Default for World {
             // are detected on first system runs and for direct world queries.
             change_tick: AtomicU32::new(1),
             last_change_tick: 0,
-            system_registry: Default::default(),
-        }
+        };
+        // This resource is required by bevy_ecs itself, so cannot be included in a plugin
+        world.init_resource::<SystemRegistry>();
+        world
     }
 }
 

From 3be2a2e7fc059885ff29106fe3ceb196dd316381 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 15:34:39 -0400
Subject: [PATCH 22/66] Clippy fixes

---
 crates/bevy_ecs/src/system/function_system.rs | 3 ++-
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index c2b8537b6be88..a74a7893d3fb1 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -457,12 +457,13 @@ where
 }
 
 /// A [`SystemLabel`] that was automatically generated for a system on the basis of its `TypeId`.
+#[derive(Default)]
 pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
 
 impl<T: 'static> SystemTypeIdLabel<T> {
     /// Constructs a new copy of the [`SystemTypeIdLabel`] for the type `T`
     ///
-    /// You can also construct this by using [`.as_system_label()](crate::system::AsSystemLabel) on a concrete instance
+    /// You can also construct this by using [`.as_system_label()`](crate::system::AsSystemLabel) on a concrete instance
     /// of your function type.
     pub fn new() -> Self {
         Self(PhantomData::default())
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 0381f6ef5d69b..3552db3aeab97 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -209,7 +209,7 @@ impl SystemRegistry {
     /// Runs the system at the supplied `index` a single time
     #[inline]
     fn run_system_at_index(&mut self, world: &mut World, index: usize) {
-        let ref mut stored_system = self.systems[index];
+        let stored_system = &mut self.systems[index];
 
         // Run the system
         stored_system.system.run((), world);
@@ -494,7 +494,7 @@ mod tests {
     #[allow(dead_code)]
     // The `Local` begins at the default value of 0
     fn fibonacci_counting(last_counter: Local<u8>, mut counter: ResMut<Counter>) {
-        counter.0 = *last_counter + counter.0;
+        counter.0 += *last_counter;
     }
 
     #[test]

From 4fe293733e5c27c169a601017ce10a6889bb5962 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 15:48:40 -0400
Subject: [PATCH 23/66] Clippy fix

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 3552db3aeab97..d0c53369157ff 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -393,7 +393,7 @@ impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_boxed_label(world, self.label.dyn_clone())
+            registry.run_systems_by_boxed_label(world, self.label.dyn_clone());
         });
     }
 }
@@ -516,7 +516,7 @@ mod tests {
     fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
         counter.0 += 1;
         if counter.0 < 10 {
-            commands.run_system(count_to_ten)
+            commands.run_system(count_to_ten);
         }
     }
 

From 38fd422b5b75f11bd427b1d4bdd6d145a9843bf9 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 15:53:36 -0400
Subject: [PATCH 24/66] System recursion should fail

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d0c53369157ff..dad7992b085ce 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -521,6 +521,10 @@ mod tests {
     }
 
     #[test]
+    // This is a known limitation;
+    // if this test passes the docs must be updated to reflect this
+    // added functionality
+    #[should_panic]
     fn system_recursion() {
         let mut world = World::new();
         world.init_resource::<Counter>();

From 641f5df487917fab2e9842930d0ab8881b4e0420 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 16:25:32 -0400
Subject: [PATCH 25/66] Documentation improvements

---
 crates/bevy_ecs/src/system/system_registry.rs | 59 +++++++++++--------
 1 file changed, 34 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index dad7992b085ce..2dee1932b3429 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -19,9 +19,9 @@ use crate::world::{Mut, World};
 ///
 /// # Limitations
 ///
-///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
-///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`.
-///  - exclusive systems cannot be used.
+///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values
+///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`
+///  - exclusive systems cannot be used
 ///
 /// # Examples
 ///
@@ -73,13 +73,15 @@ use crate::world::{Mut, World};
 /// world.run_system(assert_7_spawned);
 /// ```
 ///
+/// Systems can also be manually registered using [`SystemLabel`] types
+/// and then run via those labels, enabling more sophisticated control flows.
+///
 /// ```rust
 /// use bevy_ecs::prelude::*;
 /// use bevy_ecs::system::SystemRegistry;
 ///
 /// let mut world = World::new();
-/// // The `SystemRegistry` type is automatically included as a resource in every World
-/// let mut system_registry: Mut<SystemRegistry> = world.resource_mut();
+/// let mut system_registry = SystemRegistry::default();
 ///
 /// #[derive(SystemLabel, Debug, PartialEq, Eq, Hash, Clone)]
 /// enum ManualSystems {
@@ -111,7 +113,7 @@ use crate::world::{Mut, World};
 /// // All systems registered under that label will be run, in registration order
 /// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
 ///
-/// // All methods on this type are also exposed on the `World` for convenience
+/// // The methods on this type are also exposed on the `World` for convenience
 /// world.register_system(goodbye, ManualSystems::Goodbye);
 /// world.run_systems_by_label(ManualSystems::Goodbye);
 /// ```
@@ -129,10 +131,13 @@ struct StoredSystem {
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// This method only needs to be called manually when using [`run_system_by_label`](SystemRegistry).
+    /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
+    /// However, manual registration allows you to provide one or more labels for the system.
+    ///
+    /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
+    /// all registered systems that match that label will be evaluated.
     ///
-    /// If `labels` are provided, the system will be registered under those labels.
-    /// Otherwise, it will use the default labels for that system: typically its [`SystemTypeIdLabel`].
+    /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
         &mut self,
@@ -143,12 +148,12 @@ impl SystemRegistry {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        self.register_boxed_system_by_labels(world, boxed_system, vec![Box::new(label)]);
+        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
     }
 
-    /// Register system a system with any number of [`SystemLabel`]
+    /// Register system a system with any number of [`SystemLabel`]s.
     ///
-    /// This allows the system to be run whenever any of its labels are run using `run_systems_by_label`.
+    /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -171,11 +176,15 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_by_labels(world, boxed_system, collected_labels);
+        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
     }
 
-    /// A more efficient but less ergonomic version of `register_system_with_labels`
-    pub fn register_boxed_system_by_labels(
+    /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
+    ///
+    /// This can be useful when you have a boxed system or boxed labels,
+    /// as the corresponding traits are not implemented for boxed trait objects
+    /// to avoid indefinite nesting.
+    pub fn register_boxed_system_with_labels(
         &mut self,
         world: &mut World,
         mut boxed_system: Box<dyn System<In = (), Out = ()>>,
@@ -217,9 +226,9 @@ impl SystemRegistry {
         stored_system.system.apply_buffers(world);
     }
 
-    /// Returns true if at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`].
+    /// Is at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`]?
     #[inline]
-    pub fn label_registered<L: SystemLabel>(&self, label: L) -> bool {
+    pub fn is_label_registered<L: SystemLabel>(&self, label: L) -> bool {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
         self.labels.get(&boxed_label).is_some()
     }
@@ -244,13 +253,13 @@ impl SystemRegistry {
         self.run_systems_by_boxed_label(world, boxed_label);
     }
 
-    /// A less ergonomic version of `run_systems_by_label` that allows you to pass in a boxed `SystemLabel`
+    /// A more exacting version of [`run_systems_by_label`](Self::run_systems_by_label).
+    ///
+    /// This can be useful when you have boxed labels,
+    /// as [`SystemLabel`] is not implemented for boxed trait objects
+    /// to avoid indefinite nesting.
     #[inline]
-    pub fn run_systems_by_boxed_label(
-        &mut self,
-        world: &mut World,
-        boxed_label: Box<dyn SystemLabel>,
-    ) {
+    fn run_systems_by_boxed_label(&mut self, world: &mut World, boxed_label: Box<dyn SystemLabel>) {
         let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {boxed_label:?} was found. Did you forget to register it?"}});
 
         // Loop over the system in registration order
@@ -271,11 +280,11 @@ impl SystemRegistry {
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
-        if !self.label_registered(automatic_system_label) {
+        if !self.is_label_registered(automatic_system_label) {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
-            self.register_boxed_system_by_labels(world, boxed_system, labels);
+            self.register_boxed_system_with_labels(world, boxed_system, labels);
         }
         self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }

From 854a80541f1e051a59f3fd44e53b04e28121fe23 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:13:38 -0400
Subject: [PATCH 26/66] Nicer error handling

---
 crates/bevy_ecs/src/system/system_registry.rs | 73 +++++++++++++------
 1 file changed, 50 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 2dee1932b3429..d2aeb3c86afb1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -233,24 +233,24 @@ impl SystemRegistry {
         self.labels.get(&boxed_label).is_some()
     }
 
-    /// Returns the first matching index for systems with this label
-    ///
-    /// # Panics
-    ///
-    /// Panics if no system with the label is registered.
+    /// Returns the first matching index for systems with this label if any
     #[inline]
-    fn first_registered_index<L: SystemLabel>(&self, label: L) -> usize {
+    fn first_registered_index<L: SystemLabel>(&self, label: L) -> Option<usize> {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
-        let vec_of_indexes = self.labels.get(&boxed_label).unwrap();
-        *vec_of_indexes.iter().next().unwrap()
+        let vec_of_indexes = self.labels.get(&boxed_label)?;
+        vec_of_indexes.iter().next().copied()
     }
 
     /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
-    pub fn run_systems_by_label<L: SystemLabel>(&mut self, world: &mut World, label: L) {
+    pub fn run_systems_by_label<L: SystemLabel>(
+        &mut self,
+        world: &mut World,
+        label: L,
+    ) -> Result<(), SystemRegistryError> {
         let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
-        self.run_systems_by_boxed_label(world, boxed_label);
+        self.run_systems_by_boxed_label(world, boxed_label)
     }
 
     /// A more exacting version of [`run_systems_by_label`](Self::run_systems_by_label).
@@ -259,12 +259,21 @@ impl SystemRegistry {
     /// as [`SystemLabel`] is not implemented for boxed trait objects
     /// to avoid indefinite nesting.
     #[inline]
-    fn run_systems_by_boxed_label(&mut self, world: &mut World, boxed_label: Box<dyn SystemLabel>) {
-        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {boxed_label:?} was found. Did you forget to register it?"}});
-
-        // Loop over the system in registration order
-        for index in matching_system_indexes.clone() {
-            self.run_system_at_index(world, index);
+    fn run_systems_by_boxed_label(
+        &mut self,
+        world: &mut World,
+        boxed_label: Box<dyn SystemLabel>,
+    ) -> Result<(), SystemRegistryError> {
+        match self.labels.get(&boxed_label) {
+            Some(matching_indexes) => {
+                // Loop over the system in registration order
+                for index in matching_indexes.clone() {
+                    self.run_system_at_index(world, index);
+                }
+
+                Ok(())
+            }
+            None => Err(SystemRegistryError::LabelNotFound(boxed_label)),
         }
     }
 
@@ -279,14 +288,16 @@ impl SystemRegistry {
         system: S,
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
-
         if !self.is_label_registered(automatic_system_label) {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
             self.register_boxed_system_with_labels(world, boxed_system, labels);
         }
-        self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
+        // System was registered above, so we can unwrap safely
+        let index = self.first_registered_index(automatic_system_label).unwrap();
+
+        self.run_system_at_index(world, index);
     }
 }
 
@@ -352,10 +363,13 @@ impl World {
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
-    pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
+    pub fn run_systems_by_label<L: SystemLabel>(
+        &mut self,
+        label: L,
+    ) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_label(world, label);
-        });
+            return registry.run_systems_by_label(world, label);
+        })
     }
 }
 
@@ -402,11 +416,24 @@ impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_boxed_label(world, self.label.dyn_clone());
+            registry
+                .run_systems_by_boxed_label(world, self.label.dyn_clone())
+                // Ideally this error should be handled more gracefully,
+                // but that's blocked on a full error handling solution for commands
+                .unwrap();
         });
     }
 }
 
+/// An operation on a [`SystemRegistry`] failed
+#[derive(Debug)]
+pub enum SystemRegistryError {
+    /// A system was run by label, but no system with that label was found.
+    ///
+    /// Did you forget to register it?
+    LabelNotFound(Box<dyn SystemLabel>),
+}
+
 mod tests {
     use crate::prelude::*;
 
@@ -434,7 +461,7 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(0));
         world.register_system(count_up, "count");
         world.register_system(count_up, "count");
-        world.run_systems_by_label("count");
+        world.run_systems_by_label("count").unwrap();
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 

From 7f41af93870d47c682de388593fb92669dc9b416 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:25:27 -0400
Subject: [PATCH 27/66] Return index from register system methods

---
 crates/bevy_ecs/src/system/system_registry.rs | 35 +++++++++++++------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d2aeb3c86afb1..2318b02de8808 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -132,10 +132,15 @@ impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
     /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
+    /// When this occurs, they will be registered using their [`SystemTypeIdLabel`].
     /// However, manual registration allows you to provide one or more labels for the system.
+    /// This also allows you to register multiple distinct copies of the system under distinct labels.
     ///
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
-    /// all registered systems that match that label will be evaluated.
+    /// all registered systems that match that label will be evaluated (in insertion order).
+    ///
+    /// Returns the index in the vector of systems that this new system is stored at.
+    /// This is only useful for debugging as an external user of this method.
     ///
     /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
@@ -144,15 +149,18 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         label: L,
-    ) {
+    ) -> usize {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
+        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)])
     }
 
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
+    /// Returns the index in the vector of systems that this new system is stored at.
+    /// This is only useful for debugging as an external user of this method.
+    ///
     /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
     pub fn register_system_with_labels<
         Params,
@@ -164,7 +172,7 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         labels: LI,
-    ) {
+    ) -> usize {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
@@ -176,11 +184,14 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
+        self.register_boxed_system_with_labels(world, boxed_system, collected_labels)
     }
 
     /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
     ///
+    /// Returns the index in the vector of systems that this new system is stored at.
+    /// This is only useful for debugging as an external user of this method.
+    ///
     /// This can be useful when you have a boxed system or boxed labels,
     /// as the corresponding traits are not implemented for boxed trait objects
     /// to avoid indefinite nesting.
@@ -189,7 +200,7 @@ impl SystemRegistry {
         world: &mut World,
         mut boxed_system: Box<dyn System<In = (), Out = ()>>,
         labels: Vec<Box<dyn SystemLabel>>,
-    ) {
+    ) -> usize {
         // Intialize the system's state
         boxed_system.initialize(world);
 
@@ -213,6 +224,8 @@ impl SystemRegistry {
                 self.labels.insert(label, vec![system_index]);
             };
         }
+
+        system_index
     }
 
     /// Runs the system at the supplied `index` a single time
@@ -288,14 +301,14 @@ impl SystemRegistry {
         system: S,
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
-        if !self.is_label_registered(automatic_system_label) {
+        let index = if self.is_label_registered(automatic_system_label) {
+            self.first_registered_index(automatic_system_label).unwrap()
+        } else {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
-            self.register_boxed_system_with_labels(world, boxed_system, labels);
-        }
-        // System was registered above, so we can unwrap safely
-        let index = self.first_registered_index(automatic_system_label).unwrap();
+            self.register_boxed_system_with_labels(world, boxed_system, labels)
+        };
 
         self.run_system_at_index(world, index);
     }

From 5c35c515561f1b6ba22de5f127f239e3c7561e25 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:34:03 -0400
Subject: [PATCH 28/66] Fix off by one error

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 2318b02de8808..f209f77e2b000 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -209,8 +209,8 @@ impl SystemRegistry {
         };
 
         // Add the system to the end of the vec
-        self.systems.push(stored_system);
         let system_index = self.systems.len();
+        self.systems.push(stored_system);
 
         // For each label that the system has
         for label in labels {

From 681a6fcffc268d4ba94002ea81f23ccbedf05922 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:43:10 -0400
Subject: [PATCH 29/66] Reduce noisy returns

---
 crates/bevy_ecs/src/system/system_registry.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index f209f77e2b000..b30fcb857a8cd 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -139,9 +139,6 @@ impl SystemRegistry {
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
     /// all registered systems that match that label will be evaluated (in insertion order).
     ///
-    /// Returns the index in the vector of systems that this new system is stored at.
-    /// This is only useful for debugging as an external user of this method.
-    ///
     /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
@@ -149,18 +146,15 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         label: L,
-    ) -> usize {
+    ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)])
+        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
     }
 
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
-    /// Returns the index in the vector of systems that this new system is stored at.
-    /// This is only useful for debugging as an external user of this method.
-    ///
     /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
     pub fn register_system_with_labels<
         Params,
@@ -172,7 +166,7 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         labels: LI,
-    ) -> usize {
+    ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
@@ -184,7 +178,7 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_with_labels(world, boxed_system, collected_labels)
+        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
     }
 
     /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
@@ -381,7 +375,7 @@ impl World {
         label: L,
     ) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            return registry.run_systems_by_label(world, label);
+            registry.run_systems_by_label(world, label)
         })
     }
 }

From 091e50f69ebe39fdc9fbc26827a674bdb7e69ea4 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 23:09:50 -0400
Subject: [PATCH 30/66] Fix broken tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 95 ++++++++++---------
 1 file changed, 52 insertions(+), 43 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b30fcb857a8cd..faacc67f6e25f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -461,6 +461,19 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(1));
     }
 
+    #[test]
+    /// We need to ensure that the system registry is accessible
+    /// even after being used once.
+    fn run_two_systems() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+    }
+
     #[test]
     fn run_system_by_label() {
         let mut world = World::new();
@@ -469,6 +482,7 @@ mod tests {
         world.register_system(count_up, "count");
         world.register_system(count_up, "count");
         world.run_systems_by_label("count").unwrap();
+        // All systems matching the label will be run.
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
@@ -486,38 +500,34 @@ mod tests {
         assert_eq!(world.entities.len(), 1);
     }
 
-    fn non_send_count_down(mut ns: NonSendMut<Counter>) {
-        ns.0 -= 1;
-    }
-
-    #[allow(dead_code)]
-    fn trigger_non_send_count_down(mut commands: Commands) {
-        commands.run_system(non_send_count_down);
-    }
-
     #[test]
     fn non_send_resources() {
+        fn non_send_count_down(mut ns: NonSendMut<Counter>) {
+            ns.0 -= 1;
+        }
+
         let mut world = World::new();
         world.insert_non_send_resource(Counter(10));
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
         world.run_system(non_send_count_down);
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
-        world.run_system(trigger_non_send_count_down);
-        assert_eq!(*world.non_send_resource::<Counter>(), Counter(8));
-    }
-
-    #[derive(Default)]
-    struct ChangeDetector;
-
-    #[allow(dead_code)]
-    fn count_up_iff_changed(mut commands: Commands, change_detector: ResMut<ChangeDetector>) {
-        if change_detector.is_changed() {
-            commands.run_system(count_up);
-        }
     }
 
     #[test]
     fn change_detection() {
+        #[derive(Default)]
+        struct ChangeDetector;
+
+        #[allow(dead_code)]
+        fn count_up_iff_changed(
+            mut counter: ResMut<Counter>,
+            change_detector: ResMut<ChangeDetector>,
+        ) {
+            if change_detector.is_changed() {
+                counter.0 += 1;
+            }
+        }
+
         let mut world = World::new();
         world.init_resource::<ChangeDetector>();
         world.init_resource::<Counter>();
@@ -534,41 +544,40 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
-    #[allow(dead_code)]
-    // The `Local` begins at the default value of 0
-    fn fibonacci_counting(last_counter: Local<u8>, mut counter: ResMut<Counter>) {
-        counter.0 += *last_counter;
-    }
-
     #[test]
     fn local_variables() {
+        // The `Local` begins at the default value of 0
+        fn doubling(mut last_counter: Local<Counter>, mut counter: ResMut<Counter>) {
+            counter.0 += last_counter.0;
+            last_counter.0 = counter.0;
+        }
+
         let mut world = World::new();
         world.insert_resource(Counter(1));
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(fibonacci_counting);
+        world.run_system(doubling);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(fibonacci_counting);
+        world.run_system(doubling);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
-        world.run_system(fibonacci_counting);
-        assert_eq!(*world.resource::<Counter>(), Counter(3));
-        world.run_system(fibonacci_counting);
-        assert_eq!(*world.resource::<Counter>(), Counter(5));
-    }
-
-    #[allow(dead_code)]
-    fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
-        counter.0 += 1;
-        if counter.0 < 10 {
-            commands.run_system(count_to_ten);
-        }
+        world.run_system(doubling);
+        assert_eq!(*world.resource::<Counter>(), Counter(4));
+        world.run_system(doubling);
+        assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
 
     #[test]
     // This is a known limitation;
-    // if this test passes the docs must be updated to reflect this
-    // added functionality
+    // if this test passes the docs must be updated
+    // to reflect the ability to chain run_system commands
     #[should_panic]
     fn system_recursion() {
+        fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
+            counter.0 += 1;
+            if counter.0 < 10 {
+                commands.run_system(count_to_ten);
+            }
+        }
+
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));

From 5f3925e73961b9b4f679e136ae2faab6b72eb5c0 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 23:55:48 -0400
Subject: [PATCH 31/66] Add example

---
 Cargo.toml                       | 10 ++++
 examples/README.md               | 14 +++++
 examples/ecs/one_shot_systems.rs | 98 ++++++++++++++++++++++++++++++++
 3 files changed, 122 insertions(+)
 create mode 100644 examples/ecs/one_shot_systems.rs

diff --git a/Cargo.toml b/Cargo.toml
index 69ec5086a5349..2017b2face91b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -788,6 +788,16 @@ description = "Shows how to iterate over combinations of query results"
 category = "ECS (Entity Component System)"
 wasm = true
 
+[[example]]
+name = "one_shot_systems"
+path = "examples/ecs/one_shot_systems.rs"
+
+[package.metadata.example.one_shot_systems]
+name = "One Shot Systems"
+description = "Shows how to flexibly run systems without scheduling them"
+category = "ECS (Entity Component System)"
+wasm = false
+
 [[example]]
 name = "parallel_query"
 path = "examples/ecs/parallel_query.rs"
diff --git a/examples/README.md b/examples/README.md
index f28805e2e9bd6..1d4c3f86aeb17 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -56,6 +56,19 @@ git checkout v0.4.0
   - [Transforms](#transforms)
   - [UI (User Interface)](#ui-user-interface)
   - [Window](#window)
+- [Tests](#tests)
+- [Platform-Specific Examples](#platform-specific-examples)
+  - [Android](#android)
+    - [Setup](#setup)
+    - [Build & Run](#build--run)
+    - [Old phones](#old-phones)
+  - [iOS](#ios)
+    - [Setup](#setup-1)
+    - [Build & Run](#build--run-1)
+  - [WASM](#wasm)
+    - [Setup](#setup-2)
+    - [Build & Run](#build--run-2)
+    - [Loading Assets](#loading-assets)
 
 - [Tests](#tests)
 - [Platform-Specific Examples](#platform-specific-examples)
@@ -192,6 +205,7 @@ Example | Description
 [Generic System](../examples/ecs/generic_system.rs) | Shows how to create systems that can be reused with different types
 [Hierarchy](../examples/ecs/hierarchy.rs) | Creates a hierarchy of parents and children entities
 [Iter Combinations](../examples/ecs/iter_combinations.rs) | Shows how to iterate over combinations of query results
+[One Shot Systems](../examples/ecs/one_shot_systems.rs) | Shows how to flexibly run systems without scheduling them
 [Parallel Query](../examples/ecs/parallel_query.rs) | Illustrates parallel queries with `ParallelIterator`
 [Removal Detection](../examples/ecs/removal_detection.rs) | Query for entities that had a specific component removed in a previous stage during the current frame
 [Startup System](../examples/ecs/startup_system.rs) | Demonstrates a startup system (one that runs once when the app starts up)
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
new file mode 100644
index 0000000000000..5a815d2c33a66
--- /dev/null
+++ b/examples/ecs/one_shot_systems.rs
@@ -0,0 +1,98 @@
+//! Demonstrates the use of "one-shot systems", which run once when triggered
+//!
+//! These can be useful to help structure your logic in a push-based fashion,
+//! reducing the overhead of running extremely rarely run systems
+//! and improving schedule flexibility.
+//!
+//! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
+
+use bevy::ecs::schedule::IntoSystemDescriptor;
+use bevy::ecs::system::SystemTypeIdLabel;
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_startup_system(setup)
+        // One shot systems are interchangeable with ordinarily scheduled systems.
+        // Change detection, Local and NonSend all work as expected
+        .add_system_to_stage(CoreStage::PostUpdate, count_entities)
+        // Registered systems can be called dynamically by their label
+        // These must be registered in advance, or commands.run_system will panic
+        // as no matching system was found
+        .register_system(button_pressed)
+        .register_system(slider_toggled)
+        // One-shot systems can be used to build complex abstractions
+        // to match the needs of your design.
+        // Here, we model a very simple system-powered callback architecture.
+        .add_system(trigger_callbacks)
+        .add_system(evaluate_callbacks.after(trigger_callbacks))
+        .run();
+}
+
+// Any ordinary system can be run via commands.run_system or world.run_system
+//
+// Chained systems, exclusive systems and systems which themselves run systems cannot be called in this way.
+fn count_entities(all_entities: Query<()>) {
+    dbg!(all_entities.iter().count());
+}
+
+fn setup(mut commands: Commands) {
+    // commands.run_system is evaluated in sequence
+    commands.run_system(count_entities); // Reports 0 entities
+    commands.spawn().insert(Callback::new(button_pressed));
+    commands.spawn().insert(Callback::new(slider_toggled));
+    commands.run_system(count_entities); // Reports 2 entities, as the previous command will be processed by the time this has evaluated
+}
+
+fn button_pressed() {
+    println!("A button was pressed!")
+}
+
+fn slider_toggled() {
+    println!("A slider was toggled!")
+}
+
+// When creating abstractions built on one-shot systems,
+// storing system labels is the way to go.
+// Don't try to store boxed System trait objects!
+#[derive(Component)]
+struct Callback {
+    triggered: bool,
+    label: Box<dyn SystemLabel>,
+}
+
+impl Callback {
+    // We can pass in a system as our function argument to automatically generate the correct label.
+    // Alternatively, you can create an API that takes an explicit `SystemLabel`, and users can control
+    // exactly how the system should be called.
+    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(system: S) -> Self {
+        Callback {
+            triggered: false,
+            label: Box::new(SystemTypeIdLabel::<S>::new()),
+        }
+    }
+}
+
+// These callbacks could easily be triggered via events, button interactions or so on
+// or even stored directly in the event type
+fn trigger_callbacks(query: Query<&mut Callback>) {
+    for mut callback in query.iter_mut() {
+        callback.triggered = true;
+    }
+}
+
+/// Runs the systems associated with each Callback component
+///
+/// This could also be done in an exclusive system,
+/// but the borrow checker is more frustrating
+fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
+    for callback in query.iter() {
+        if callback.triggered {
+            // Because we don't have access to the type information of the callbacks
+            // we have to use the layer of indirection provided by system labels
+            // Note that if we had registered multiple systems with the same label,
+            // they would all be evaluated here.
+            commands.run_systems_by_label(callback.label);
+        }
+    }
+}

From e812bedafb202c46505cb911a1c8515c40db1999 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:12:08 -0400
Subject: [PATCH 32/66] Improve ergonomics of register_system method

---
 crates/bevy_ecs/src/system/system_registry.rs | 66 +++++++++----------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index faacc67f6e25f..c383fd018cf89 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,3 +1,4 @@
+use bevy_utils::tracing::warn;
 use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
@@ -131,6 +132,9 @@ struct StoredSystem {
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
+    /// This allows the system to be run by their [`SystemTypeIdLabel`] using the `run_systems_by_label` method.
+    /// Repeatedly registering a system will have no effect.
+    ///
     /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
     /// When this occurs, they will be registered using their [`SystemTypeIdLabel`].
     /// However, manual registration allows you to provide one or more labels for the system.
@@ -139,23 +143,38 @@ impl SystemRegistry {
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
     /// all registered systems that match that label will be evaluated (in insertion order).
     ///
-    /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
+    /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
-        label: L,
     ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
+        let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
-        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
+        // This avoids nasty surprising behavior in case systems are registered twice
+        if !self.is_label_registered(automatic_system_label) {
+            self.register_boxed_system_with_labels(
+                world,
+                boxed_system,
+                vec![Box::new(automatic_system_label)],
+            );
+        } else {
+            let type_name = std::any::type_name::<S>();
+            warn!("A system of type {type_name} was registered more than once!");
+        };
     }
 
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
     /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
+    ///
+    /// # Warning
+    ///
+    /// Unlike the `register_system` method, duplicate systems may be added;
+    /// each copy will be called seperately if they share a label.
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -311,20 +330,17 @@ impl SystemRegistry {
 impl World {
     /// Registers the supplied system in the [`SystemRegistry`] resource
     ///
-    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`].
-    /// If you are using [`World::run_system`] directly, manual registration is not needed.
-    /// The system will be automatically registered under its [`SystemTypeIdLabel`] the first time it is run.
+    /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
-        &mut self,
-        system: S,
-        label: L,
-    ) {
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, label);
+            registry.register_system(world, system);
         });
     }
 
+    /// Register system a system with any number of [`SystemLabel`]s.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`].
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -342,14 +358,7 @@ impl World {
 
     /// Runs the supplied system on the [`World`] a single time
     ///
-    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    ///
-    /// The system's state will be cached: any future calls using the same type will use this state,
-    /// improving performance and ensuring that change detection works properly.
-    ///
-    /// This is evaluated in a sequential, single-threaded fashion.
-    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
-    /// at once, and want parallel execution of these systems.
+    /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
@@ -359,16 +368,7 @@ impl World {
 
     /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
     ///
-    /// Systems must be registered before they can be run by their label.
-    ///
-    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    ///
-    /// The system's state will be cached: any future calls using the same type will use this state,
-    /// improving performance and ensuring that change detection works properly.
-    ///
-    /// This is evaluated in a sequential, single-threaded fashion.
-    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
-    /// at once, and want parallel execution of these systems.
+    /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
@@ -479,8 +479,8 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, "count");
-        world.register_system(count_up, "count");
+        world.register_system_with_labels(count_up, ["count"]);
+        world.register_system_with_labels(count_up, ["count"]);
         world.run_systems_by_label("count").unwrap();
         // All systems matching the label will be run.
         assert_eq!(*world.resource::<Counter>(), Counter(2));

From 79aba5c97b2ad8a079c4a762cbc594f39b62c24a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:19:29 -0400
Subject: [PATCH 33/66] Formatting

---
 crates/bevy_ecs/src/system/system_registry.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c383fd018cf89..1feea3af66f87 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -241,7 +241,7 @@ impl SystemRegistry {
         system_index
     }
 
-    /// Runs the system at the supplied `index` a single time
+    /// Runs the system at the supplied `index` a single time.
     #[inline]
     fn run_system_at_index(&mut self, world: &mut World, index: usize) {
         let stored_system = &mut self.systems[index];
@@ -259,7 +259,7 @@ impl SystemRegistry {
         self.labels.get(&boxed_label).is_some()
     }
 
-    /// Returns the first matching index for systems with this label if any
+    /// Returns the first matching index for systems with this label if any.
     #[inline]
     fn first_registered_index<L: SystemLabel>(&self, label: L) -> Option<usize> {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
@@ -267,9 +267,9 @@ impl SystemRegistry {
         vec_of_indexes.iter().next().copied()
     }
 
-    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
+    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
+    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
         world: &mut World,
@@ -303,7 +303,7 @@ impl SystemRegistry {
         }
     }
 
-    /// Runs the supplied system on the [`World`] a single time
+    /// Runs the supplied system on the [`World`] a single time.
     ///
     /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
     /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
@@ -328,7 +328,7 @@ impl SystemRegistry {
 }
 
 impl World {
-    /// Registers the supplied system in the [`SystemRegistry`] resource
+    /// Registers the supplied system in the [`SystemRegistry`] resource.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
@@ -356,7 +356,7 @@ impl World {
         });
     }
 
-    /// Runs the supplied system on the [`World`] a single time
+    /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
@@ -366,7 +366,7 @@ impl World {
         });
     }
 
-    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
+    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]

From 7c02da4b7c03d15f7aa8a6b2c1b9d1af54354bc1 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:23:16 -0400
Subject: [PATCH 34/66] Expose run_systems_by_boxed_label method

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 16 ++++++++++++--
 crates/bevy_ecs/src/system/system_registry.rs | 21 +++++++++++++++----
 examples/ecs/one_shot_systems.rs              |  2 +-
 3 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index ae3444e4ecd22..49e786906fd69 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -364,7 +364,9 @@ impl<'w, 's> Commands<'w, 's> {
         });
     }
 
-    /// Calls [`World::run_system`]
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
     pub fn run_system<
         Params: Send + Sync + 'static,
         S: IntoSystem<(), (), Params> + Send + Sync + 'static,
@@ -375,13 +377,23 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RunSystemCommand::new(system));
     }
 
-    /// Calls [`World::run_system_by_type_id`]
+    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
     pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
         self.queue.push(RunSystemsByLabelCommand {
             label: Box::new(label),
         });
     }
 
+    /// A trait-object compatible version of `run_systems_by_label`.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    pub fn run_systems_by_boxed_label(&mut self, boxed_label: Box<dyn SystemLabel>) {
+        self.queue
+            .push(RunSystemsByLabelCommand { label: boxed_label });
+    }
+
     /// Adds a command directly to the command list.
     ///
     /// # Example
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 1feea3af66f87..2eac7e4e3fa24 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -279,13 +279,13 @@ impl SystemRegistry {
         self.run_systems_by_boxed_label(world, boxed_label)
     }
 
-    /// A more exacting version of [`run_systems_by_label`](Self::run_systems_by_label).
+    /// A trait-object compatible version of `run_systems_by_label`.
     ///
-    /// This can be useful when you have boxed labels,
+    /// This can be useful for more abstract designs that rely on boxed labels,
     /// as [`SystemLabel`] is not implemented for boxed trait objects
     /// to avoid indefinite nesting.
     #[inline]
-    fn run_systems_by_boxed_label(
+    pub fn run_systems_by_boxed_label(
         &mut self,
         world: &mut World,
         boxed_label: Box<dyn SystemLabel>,
@@ -366,7 +366,7 @@ impl World {
         });
     }
 
-    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
+    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
@@ -378,6 +378,19 @@ impl World {
             registry.run_systems_by_label(world, label)
         })
     }
+
+    /// A trait-object compatible version of `run_systems_by_label`.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`].
+    #[inline]
+    pub fn run_systems_by_boxed_label(
+        &mut self,
+        boxed_label: Box<dyn SystemLabel>,
+    ) -> Result<(), SystemRegistryError> {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_systems_by_boxed_label(world, boxed_label)
+        })
+    }
 }
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 5a815d2c33a66..52d9735138c4e 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -92,7 +92,7 @@ fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
             // we have to use the layer of indirection provided by system labels
             // Note that if we had registered multiple systems with the same label,
             // they would all be evaluated here.
-            commands.run_systems_by_label(callback.label);
+            commands.run_systems_by_boxed_label(callback.label);
         }
     }
 }

From cdd8cfc79cd183a2b7d096f7d9f597c2a0391bcc Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:31:30 -0400
Subject: [PATCH 35/66] Create matching methods on App

---
 crates/bevy_app/src/lib.rs             |  1 +
 crates/bevy_app/src/system_registry.rs | 68 ++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 crates/bevy_app/src/system_registry.rs

diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index c0a9c68f79c3f..ec40a289ad33c 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -6,6 +6,7 @@ mod app;
 mod plugin;
 mod plugin_group;
 mod schedule_runner;
+mod system_registry;
 
 #[cfg(feature = "bevy_ci_testing")]
 mod ci_testing;
diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
new file mode 100644
index 0000000000000..2941b91d3fa3c
--- /dev/null
+++ b/crates/bevy_app/src/system_registry.rs
@@ -0,0 +1,68 @@
+use crate::App;
+use bevy_ecs::prelude::*;
+use bevy_ecs::system::SystemRegistryError;
+
+impl App {
+    /// Registers the supplied system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry) resource.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+    ) -> &mut Self {
+        self.world.register_system(system);
+        self
+    }
+
+    /// Register system a system with any number of [`SystemLabel`]s.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`].
+    pub fn register_system_with_labels<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        system: S,
+        labels: LI,
+    ) -> &mut Self {
+        self.world.register_system_with_labels(system, labels);
+        self
+    }
+
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+    ) -> &mut Self {
+        self.world.run_system(system);
+        self
+    }
+
+    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn run_systems_by_label<L: SystemLabel>(
+        &mut self,
+        label: L,
+    ) -> Result<(), SystemRegistryError> {
+        self.world.run_systems_by_label(label)
+    }
+
+    /// A trait-object compatible version of `run_systems_by_label`.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn run_systems_by_boxed_label(
+        &mut self,
+        boxed_label: Box<dyn SystemLabel>,
+    ) -> Result<(), SystemRegistryError> {
+        self.world.run_systems_by_boxed_label(boxed_label)
+    }
+}

From e6094c6cbc5b91e20b7f007e0b65c3bfb518b5ea Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:40:28 -0400
Subject: [PATCH 36/66] Polish example

---
 examples/ecs/one_shot_systems.rs | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 52d9735138c4e..09ca8c93fef52 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -12,6 +12,7 @@ use bevy::prelude::*;
 
 fn main() {
     App::new()
+        .add_startup_system(count_entities)
         .add_startup_system(setup)
         // One shot systems are interchangeable with ordinarily scheduled systems.
         // Change detection, Local and NonSend all work as expected
@@ -37,19 +38,17 @@ fn count_entities(all_entities: Query<()>) {
 }
 
 fn setup(mut commands: Commands) {
-    // commands.run_system is evaluated in sequence
-    commands.run_system(count_entities); // Reports 0 entities
     commands.spawn().insert(Callback::new(button_pressed));
     commands.spawn().insert(Callback::new(slider_toggled));
-    commands.run_system(count_entities); // Reports 2 entities, as the previous command will be processed by the time this has evaluated
+    commands.run_system(count_entities);
 }
 
 fn button_pressed() {
-    println!("A button was pressed!")
+    println!("A button was pressed!");
 }
 
 fn slider_toggled() {
-    println!("A slider was toggled!")
+    println!("A slider was toggled!");
 }
 
 // When creating abstractions built on one-shot systems,
@@ -65,7 +64,7 @@ impl Callback {
     // We can pass in a system as our function argument to automatically generate the correct label.
     // Alternatively, you can create an API that takes an explicit `SystemLabel`, and users can control
     // exactly how the system should be called.
-    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(system: S) -> Self {
+    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
         Callback {
             triggered: false,
             label: Box::new(SystemTypeIdLabel::<S>::new()),
@@ -75,7 +74,7 @@ impl Callback {
 
 // These callbacks could easily be triggered via events, button interactions or so on
 // or even stored directly in the event type
-fn trigger_callbacks(query: Query<&mut Callback>) {
+fn trigger_callbacks(mut query: Query<&mut Callback>) {
     for mut callback in query.iter_mut() {
         callback.triggered = true;
     }
@@ -92,7 +91,7 @@ fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
             // we have to use the layer of indirection provided by system labels
             // Note that if we had registered multiple systems with the same label,
             // they would all be evaluated here.
-            commands.run_systems_by_boxed_label(callback.label);
+            commands.run_systems_by_boxed_label(callback.label.clone());
         }
     }
 }

From 61db82475619c5973669ba2c42a068b30dfd4eee Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:51:07 -0400
Subject: [PATCH 37/66] Update examples README per CI

---
 examples/README.md | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index 1d4c3f86aeb17..b8af78039a89d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -56,19 +56,6 @@ git checkout v0.4.0
   - [Transforms](#transforms)
   - [UI (User Interface)](#ui-user-interface)
   - [Window](#window)
-- [Tests](#tests)
-- [Platform-Specific Examples](#platform-specific-examples)
-  - [Android](#android)
-    - [Setup](#setup)
-    - [Build & Run](#build--run)
-    - [Old phones](#old-phones)
-  - [iOS](#ios)
-    - [Setup](#setup-1)
-    - [Build & Run](#build--run-1)
-  - [WASM](#wasm)
-    - [Setup](#setup-2)
-    - [Build & Run](#build--run-2)
-    - [Loading Assets](#loading-assets)
 
 - [Tests](#tests)
 - [Platform-Specific Examples](#platform-specific-examples)

From afec80458c997a83ee15ac0b8961d61f7e95c005 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:53:31 -0400
Subject: [PATCH 38/66] Simplify system_registry doc tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 45 -------------------
 1 file changed, 45 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 2eac7e4e3fa24..b2b51ed030a14 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -73,51 +73,6 @@ use crate::world::{Mut, World};
 /// world.run_system(spawn_7_entities);
 /// world.run_system(assert_7_spawned);
 /// ```
-///
-/// Systems can also be manually registered using [`SystemLabel`] types
-/// and then run via those labels, enabling more sophisticated control flows.
-///
-/// ```rust
-/// use bevy_ecs::prelude::*;
-/// use bevy_ecs::system::SystemRegistry;
-///
-/// let mut world = World::new();
-/// let mut system_registry = SystemRegistry::default();
-///
-/// #[derive(SystemLabel, Debug, PartialEq, Eq, Hash, Clone)]
-/// enum ManualSystems {
-///     Hello,
-///     Goodbye,
-/// }
-///
-/// fn hello(){
-///     println!("Hello!")
-/// }
-///
-/// fn goodbye(){
-///     println!("Goodbye <3")
-/// }
-///
-/// fn have_a_nice_day(){
-///     println!("Have a nice day, and enjoy using Bevy!")
-/// }
-///
-/// // You can register systems by their label
-/// system_registry.register_system(&mut world, hello, ManualSystems::Hello);
-///
-/// // And run them by their label as well
-/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
-///
-/// // You can register systems under multiple labels
-/// system_registry.register_system_with_labels(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
-///
-/// // All systems registered under that label will be run, in registration order
-/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
-///
-/// // The methods on this type are also exposed on the `World` for convenience
-/// world.register_system(goodbye, ManualSystems::Goodbye);
-/// world.run_systems_by_label(ManualSystems::Goodbye);
-/// ```
 #[derive(Default)]
 pub struct SystemRegistry {
     systems: Vec<StoredSystem>,

From 9423b4909cf594de2efbd97ae465e626513ec0ae Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 11:30:15 -0400
Subject: [PATCH 39/66] Fix broken link

Co-authored-by: Federico Rinaldi <gisquerin@gmail.com>
---
 crates/bevy_app/src/system_registry.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 2941b91d3fa3c..dfbaeaa7bb3fc 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -18,6 +18,8 @@ impl App {
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
+    ///
+    /// [`SystemRegistry`]: bevy_ecs::system::SystemRegistry
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,

From ebfca1005ccd5b34c562501fa7b8a0c5f7cb0b15 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:08:04 -0400
Subject: [PATCH 40/66] Add Callback type to bevy_ecs itself

---
 crates/bevy_ecs/src/system/system_registry.rs | 74 ++++++++++++++++++-
 examples/ecs/one_shot_systems.rs              | 68 ++++++-----------
 2 files changed, 95 insertions(+), 47 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b2b51ed030a14..4845a71aacb84 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -2,7 +2,7 @@ use bevy_utils::tracing::warn;
 use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
-use crate::schedule::SystemLabel;
+use crate::schedule::{IntoSystemDescriptor, SystemLabel};
 use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
 
@@ -400,6 +400,78 @@ impl Command for RunSystemsByLabelCommand {
     }
 }
 
+/// A struct that stores a boxed [`SystemLabel`], used to cause a [`SystemRegistry`] to run systems.
+///
+/// This might be stored as a component, used as an event, or arranged in a queue stored in a resource.
+/// Unless you need to inspect the list of events or add additional information,
+/// prefer the simpler `commands.run_system` over storing callbacks as events,
+///
+/// When working with callbacks, consider your architecture carefully.
+/// Callbacks are typically harder to reason about and debug than scheduled systems,
+/// and it's easy to get into a tangled mess if you don't consider the system as a whole before starting.
+///
+/// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
+/// before they can be run by their label using a callback.
+///
+/// # Example
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::callback;
+///
+/// let mut world = World::new();
+/// // When working with `App`, use app.add_event
+/// // to get automatic event cleanup
+/// world.init_resource::<Events<Callback>>();
+///
+/// struct PlayerName(String);
+/// world.add_resource(PlayerName("Cart"));
+///
+/// fn report_player_name(player_name: Res<PlayerName>){
+///     println!("Hello {}", player_name.0);
+/// }
+/// // Remember to register any systems you intend to use as a `Callback`
+/// world.register_system(hello_world);
+///
+/// // Generating some callbacks
+/// fn generate_callback_events(mut callbacks: EventWriter<Callback>){
+///   // This will have no effect if you forgot to register the system in question
+///   callbacks.send(Callback::new(hello_world));
+/// }
+///
+/// world.run_system(generate_callback_events);
+///
+/// // Reading and then applying some callbacks
+/// fn process_callback_events(mut callbacks: EventReader<Callback>) {
+///    for callback in callbacks.iter(){
+///       commands.run_system_by_boxed_label(callback.label);
+///    }
+/// }
+///
+/// // Say hi to Cart!
+/// world.run_system(process_callback_events);
+/// ```
+use crate as bevy_ecs;
+#[derive(Debug, crate::prelude::Component, Clone)]
+pub struct Callback {
+    /// The label of the system(s) to be run.
+    ///
+    /// By default, this is set to the [`SystemTypeIdLabel`]
+    /// of the system passed in via [`Callback::new()`].
+    pub label: Box<dyn SystemLabel>,
+}
+
+impl Callback {
+    /// Creates a new callback from a function that can be used as a system.
+    ///
+    /// Remember that you must register your systems with the `App` / [`World`] before they can be run as callbacks!
+    pub fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
+        Callback {
+            label: Box::new(SystemTypeIdLabel::<S>::new()),
+        }
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 09ca8c93fef52..99e70fd3ea907 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -6,8 +6,7 @@
 //!
 //! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
 
-use bevy::ecs::schedule::IntoSystemDescriptor;
-use bevy::ecs::system::SystemTypeIdLabel;
+use bevy::ecs::system::Callback;
 use bevy::prelude::*;
 
 fn main() {
@@ -24,9 +23,8 @@ fn main() {
         .register_system(slider_toggled)
         // One-shot systems can be used to build complex abstractions
         // to match the needs of your design.
-        // Here, we model a very simple system-powered callback architecture.
-        .add_system(trigger_callbacks)
-        .add_system(evaluate_callbacks.after(trigger_callbacks))
+        // Here, we model a very simple component-linked callback architecture.
+        .add_system(evaluate_callbacks)
         .run();
 }
 
@@ -37,8 +35,18 @@ fn count_entities(all_entities: Query<()>) {
     dbg!(all_entities.iter().count());
 }
 
+#[derive(Component)]
+struct Triggered;
+
 fn setup(mut commands: Commands) {
-    commands.spawn().insert(Callback::new(button_pressed));
+    commands
+        .spawn()
+        // The Callback component is defined in bevy_ecs,
+        // but wrapping this (or making your own customized variant) is easy.
+        // Just stored a boxed SystemLabel!
+        .insert(Callback::new(button_pressed))
+        .insert(Triggered);
+    // This entity does not have a Triggered component, so its callback won't run
     commands.spawn().insert(Callback::new(slider_toggled));
     commands.run_system(count_entities);
 }
@@ -51,47 +59,15 @@ fn slider_toggled() {
     println!("A slider was toggled!");
 }
 
-// When creating abstractions built on one-shot systems,
-// storing system labels is the way to go.
-// Don't try to store boxed System trait objects!
-#[derive(Component)]
-struct Callback {
-    triggered: bool,
-    label: Box<dyn SystemLabel>,
-}
-
-impl Callback {
-    // We can pass in a system as our function argument to automatically generate the correct label.
-    // Alternatively, you can create an API that takes an explicit `SystemLabel`, and users can control
-    // exactly how the system should be called.
-    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
-        Callback {
-            triggered: false,
-            label: Box::new(SystemTypeIdLabel::<S>::new()),
-        }
-    }
-}
-
-// These callbacks could easily be triggered via events, button interactions or so on
-// or even stored directly in the event type
-fn trigger_callbacks(mut query: Query<&mut Callback>) {
-    for mut callback in query.iter_mut() {
-        callback.triggered = true;
-    }
-}
-
-/// Runs the systems associated with each Callback component
+/// Runs the systems associated with each `Callback` component if the entity also has a Triggered component
 ///
-/// This could also be done in an exclusive system,
-/// but the borrow checker is more frustrating
-fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
+/// This could be done in an exclusive system rather than using `Commands` if preferred
+fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Commands) {
     for callback in query.iter() {
-        if callback.triggered {
-            // Because we don't have access to the type information of the callbacks
-            // we have to use the layer of indirection provided by system labels
-            // Note that if we had registered multiple systems with the same label,
-            // they would all be evaluated here.
-            commands.run_systems_by_boxed_label(callback.label.clone());
-        }
+        // Because we don't have access to the type information of the callbacks
+        // we have to use the layer of indirection provided by system labels
+        // Note that if we had registered multiple systems with the same label,
+        // they would all be evaluated here.
+        commands.run_systems_by_boxed_label(callback.label.clone());
     }
 }

From 1088dc626528662b34516c60fa9e9cc8ff578941 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:14:36 -0400
Subject: [PATCH 41/66] Implement PartialEq and Eq for Callback

---
 crates/bevy_ecs/src/system/system_registry.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 4845a71aacb84..a9d714ebf8c13 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -452,7 +452,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(process_callback_events);
 /// ```
 use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone)]
+#[derive(Debug, crate::prelude::Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///
@@ -472,6 +472,12 @@ impl Callback {
     }
 }
 
+impl PartialEq for Callback {
+    fn eq(&self, other: &Self) -> bool {
+        self.label.dyn_eq(other.label.as_dyn_eq())
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {

From 31b2277df8882c49833f5aa8b8191e64c46d15b1 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:21:33 -0400
Subject: [PATCH 42/66] Implement Hash for Callback

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index a9d714ebf8c13..0660c34c0a684 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -452,7 +452,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(process_callback_events);
 /// ```
 use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone, Eq)]
+#[derive(Debug, crate::prelude::Component, Clone, Eq, Hash)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///

From f505e2d383e5adc3af6f68a71e45f66d84323f99 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:33:41 -0400
Subject: [PATCH 43/66] Change run_system_by_boxed_label to run_callback

---
 crates/bevy_app/src/system_registry.rs        | 11 ++----
 crates/bevy_ecs/src/system/commands/mod.rs    | 13 ++++---
 crates/bevy_ecs/src/system/system_registry.rs | 38 ++++++++++---------
 examples/ecs/one_shot_systems.rs              |  2 +-
 4 files changed, 33 insertions(+), 31 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index dfbaeaa7bb3fc..26cb236c7f315 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,6 @@
 use crate::App;
 use bevy_ecs::prelude::*;
-use bevy_ecs::system::SystemRegistryError;
+use bevy_ecs::system::{Callback, SystemRegistryError};
 
 impl App {
     /// Registers the supplied system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry) resource.
@@ -57,14 +57,11 @@ impl App {
         self.world.run_systems_by_label(label)
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
     #[inline]
-    pub fn run_systems_by_boxed_label(
-        &mut self,
-        boxed_label: Box<dyn SystemLabel>,
-    ) -> Result<(), SystemRegistryError> {
-        self.world.run_systems_by_boxed_label(boxed_label)
+    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
+        self.world.run_callback(callback)
     }
 }
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 49e786906fd69..ff64fea3c20b1 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     component::Component,
     entity::{Entities, Entity},
     schedule::SystemLabel,
-    system::{IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
+    system::{Callback, IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::{error, warn};
@@ -382,16 +382,17 @@ impl<'w, 's> Commands<'w, 's> {
     /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
     pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
         self.queue.push(RunSystemsByLabelCommand {
-            label: Box::new(label),
+            callback: Callback {
+                label: Box::new(label),
+            },
         });
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
-    pub fn run_systems_by_boxed_label(&mut self, boxed_label: Box<dyn SystemLabel>) {
-        self.queue
-            .push(RunSystemsByLabelCommand { label: boxed_label });
+    pub fn run_callback(&mut self, callback: Callback) {
+        self.queue.push(RunSystemsByLabelCommand { callback });
     }
 
     /// Adds a command directly to the command list.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 0660c34c0a684..24982996e52ca 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -230,21 +230,28 @@ impl SystemRegistry {
         world: &mut World,
         label: L,
     ) -> Result<(), SystemRegistryError> {
-        let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
-        self.run_systems_by_boxed_label(world, boxed_label)
+        self.run_callback(
+            world,
+            Callback {
+                label: label.dyn_clone(),
+            },
+        )
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// This can be useful for more abstract designs that rely on boxed labels,
-    /// as [`SystemLabel`] is not implemented for boxed trait objects
-    /// to avoid indefinite nesting.
+    /// Systems must be registered before they can be run by their label,
+    /// including via this method.
+    ///
+    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     #[inline]
-    pub fn run_systems_by_boxed_label(
+    pub fn run_callback(
         &mut self,
         world: &mut World,
-        boxed_label: Box<dyn SystemLabel>,
+        callback: Callback,
     ) -> Result<(), SystemRegistryError> {
+        let boxed_label = callback.label;
+
         match self.labels.get(&boxed_label) {
             Some(matching_indexes) => {
                 // Loop over the system in registration order
@@ -334,16 +341,13 @@ impl World {
         })
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
-    pub fn run_systems_by_boxed_label(
-        &mut self,
-        boxed_label: Box<dyn SystemLabel>,
-    ) -> Result<(), SystemRegistryError> {
+    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_boxed_label(world, boxed_label)
+            registry.run_callback(world, callback)
         })
     }
 }
@@ -384,7 +388,7 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
 pub struct RunSystemsByLabelCommand {
-    pub label: Box<dyn SystemLabel>,
+    pub callback: Callback,
 }
 
 impl Command for RunSystemsByLabelCommand {
@@ -392,7 +396,7 @@ impl Command for RunSystemsByLabelCommand {
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
-                .run_systems_by_boxed_label(world, self.label.dyn_clone())
+                .run_callback(world, self.callback)
                 // Ideally this error should be handled more gracefully,
                 // but that's blocked on a full error handling solution for commands
                 .unwrap();
@@ -444,7 +448,7 @@ impl Command for RunSystemsByLabelCommand {
 /// // Reading and then applying some callbacks
 /// fn process_callback_events(mut callbacks: EventReader<Callback>) {
 ///    for callback in callbacks.iter(){
-///       commands.run_system_by_boxed_label(callback.label);
+///       commands.run_callback(callback);
 ///    }
 /// }
 ///
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 99e70fd3ea907..a8c3c0272d27b 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -68,6 +68,6 @@ fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Co
         // we have to use the layer of indirection provided by system labels
         // Note that if we had registered multiple systems with the same label,
         // they would all be evaluated here.
-        commands.run_systems_by_boxed_label(callback.label.clone());
+        commands.run_callback(callback.clone());
     }
 }

From d451282e759e9f109fc77a6d57e55924ad1b290f Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:47:23 -0400
Subject: [PATCH 44/66] Fix doc example

---
 crates/bevy_ecs/src/system/system_registry.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 24982996e52ca..b13ac7073122d 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -435,12 +435,13 @@ impl Command for RunSystemsByLabelCommand {
 ///     println!("Hello {}", player_name.0);
 /// }
 /// // Remember to register any systems you intend to use as a `Callback`
-/// world.register_system(hello_world);
+/// world.register_system(report_player_name);
 ///
 /// // Generating some callbacks
 /// fn generate_callback_events(mut callbacks: EventWriter<Callback>){
-///   // This will have no effect if you forgot to register the system in question
-///   callbacks.send(Callback::new(hello_world));
+///   // The callback will have no effect when evaluated
+///   // if you forgot to register the system in question
+///   callbacks.send(Callback::new(report_player_name));
 /// }
 ///
 /// world.run_system(generate_callback_events);

From 89fa51602932939ce79e05279a50523315de05b7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:53:54 -0400
Subject: [PATCH 45/66] Manually implement Hash

---
 crates/bevy_ecs/src/system/system_registry.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b13ac7073122d..71924df8b1b11 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,5 +1,6 @@
 use bevy_utils::tracing::warn;
 use bevy_utils::HashMap;
+use std::hash::Hash;
 use std::marker::PhantomData;
 
 use crate::schedule::{IntoSystemDescriptor, SystemLabel};
@@ -457,7 +458,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(process_callback_events);
 /// ```
 use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone, Eq, Hash)]
+#[derive(Debug, crate::prelude::Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///
@@ -483,6 +484,12 @@ impl PartialEq for Callback {
     }
 }
 
+impl Hash for Callback {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.label.dyn_hash(state);
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {

From 6cc0cb94b71c8f343872346486c43028254e71d7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 17:14:50 -0400
Subject: [PATCH 46/66] Fix doc example (for real?)

---
 crates/bevy_ecs/src/system/system_registry.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 71924df8b1b11..48ca936967eb4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -422,7 +422,7 @@ impl Command for RunSystemsByLabelCommand {
 ///
 /// ```rust
 /// use bevy_ecs::prelude::*;
-/// use bevy_ecs::system::callback;
+/// use bevy_ecs::system::Callback;
 ///
 /// let mut world = World::new();
 /// // When working with `App`, use app.add_event
@@ -430,7 +430,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.init_resource::<Events<Callback>>();
 ///
 /// struct PlayerName(String);
-/// world.add_resource(PlayerName("Cart"));
+/// world.add_resource(PlayerName("Cart".to_string()));
 ///
 /// fn report_player_name(player_name: Res<PlayerName>){
 ///     println!("Hello {}", player_name.0);
@@ -448,9 +448,9 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(generate_callback_events);
 ///
 /// // Reading and then applying some callbacks
-/// fn process_callback_events(mut callbacks: EventReader<Callback>) {
+/// fn process_callback_events(mut callbacks: EventReader<Callback>, mut commands: Commands) {
 ///    for callback in callbacks.iter(){
-///       commands.run_callback(callback);
+///       commands.run_callback(&callback);
 ///    }
 /// }
 ///

From 5f29c93f8da5d056b23a6ad54680ae289d68019b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 18:43:24 -0400
Subject: [PATCH 47/66] Avoid box allocation

Co-authored-by: MinerSebas <66798382+MinerSebas@users.noreply.github.com>
---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 48ca936967eb4..fb2db298b68ff 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -106,12 +106,12 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
     ) {
-        let boxed_system: Box<dyn System<In = (), Out = ()>> =
-            Box::new(IntoSystem::into_system(system));
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
         // This avoids nasty surprising behavior in case systems are registered twice
         if !self.is_label_registered(automatic_system_label) {
+        	let boxed_system: Box<dyn System<In = (), Out = ()>> =
+            	Box::new(IntoSystem::into_system(system));
             self.register_boxed_system_with_labels(
                 world,
                 boxed_system,

From 707ec5d6cce5c1a33efece9a74e1029f4117588d Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 21:36:29 -0400
Subject: [PATCH 48/66] Mostly fix doc example

---
 crates/bevy_ecs/src/system/system_registry.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index fb2db298b68ff..82eb3136f7ad8 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -6,6 +6,9 @@ use std::marker::PhantomData;
 use crate::schedule::{IntoSystemDescriptor, SystemLabel};
 use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
+// Needed for derive(Component) macro
+use crate as bevy_ecs;
+use bevy_ecs_macros::Component;
 
 /// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
 ///
@@ -110,8 +113,8 @@ impl SystemRegistry {
 
         // This avoids nasty surprising behavior in case systems are registered twice
         if !self.is_label_registered(automatic_system_label) {
-        	let boxed_system: Box<dyn System<In = (), Out = ()>> =
-            	Box::new(IntoSystem::into_system(system));
+            let boxed_system: Box<dyn System<In = (), Out = ()>> =
+                Box::new(IntoSystem::into_system(system));
             self.register_boxed_system_with_labels(
                 world,
                 boxed_system,
@@ -422,6 +425,7 @@ impl Command for RunSystemsByLabelCommand {
 ///
 /// ```rust
 /// use bevy_ecs::prelude::*;
+/// use bevy_ecs::event::Events;
 /// use bevy_ecs::system::Callback;
 ///
 /// let mut world = World::new();
@@ -430,7 +434,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.init_resource::<Events<Callback>>();
 ///
 /// struct PlayerName(String);
-/// world.add_resource(PlayerName("Cart".to_string()));
+/// world.insert_resource(PlayerName("Cart".to_string()));
 ///
 /// fn report_player_name(player_name: Res<PlayerName>){
 ///     println!("Hello {}", player_name.0);
@@ -450,15 +454,14 @@ impl Command for RunSystemsByLabelCommand {
 /// // Reading and then applying some callbacks
 /// fn process_callback_events(mut callbacks: EventReader<Callback>, mut commands: Commands) {
 ///    for callback in callbacks.iter(){
-///       commands.run_callback(&callback);
+///       commands.run_callback(callback.clone());
 ///    }
 /// }
 ///
 /// // Say hi to Cart!
 /// world.run_system(process_callback_events);
 /// ```
-use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone, Eq)]
+#[derive(Debug, Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///

From e7b619028ecc20ba874557870b83fa5caeb72cfc Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 21:45:52 -0400
Subject: [PATCH 49/66] Remove frustrating doc example

---
 crates/bevy_ecs/src/system/system_registry.rs | 41 -------------------
 1 file changed, 41 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 82eb3136f7ad8..fa089ae470014 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -420,47 +420,6 @@ impl Command for RunSystemsByLabelCommand {
 ///
 /// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
 /// before they can be run by their label using a callback.
-///
-/// # Example
-///
-/// ```rust
-/// use bevy_ecs::prelude::*;
-/// use bevy_ecs::event::Events;
-/// use bevy_ecs::system::Callback;
-///
-/// let mut world = World::new();
-/// // When working with `App`, use app.add_event
-/// // to get automatic event cleanup
-/// world.init_resource::<Events<Callback>>();
-///
-/// struct PlayerName(String);
-/// world.insert_resource(PlayerName("Cart".to_string()));
-///
-/// fn report_player_name(player_name: Res<PlayerName>){
-///     println!("Hello {}", player_name.0);
-/// }
-/// // Remember to register any systems you intend to use as a `Callback`
-/// world.register_system(report_player_name);
-///
-/// // Generating some callbacks
-/// fn generate_callback_events(mut callbacks: EventWriter<Callback>){
-///   // The callback will have no effect when evaluated
-///   // if you forgot to register the system in question
-///   callbacks.send(Callback::new(report_player_name));
-/// }
-///
-/// world.run_system(generate_callback_events);
-///
-/// // Reading and then applying some callbacks
-/// fn process_callback_events(mut callbacks: EventReader<Callback>, mut commands: Commands) {
-///    for callback in callbacks.iter(){
-///       commands.run_callback(callback.clone());
-///    }
-/// }
-///
-/// // Say hi to Cart!
-/// world.run_system(process_callback_events);
-/// ```
 #[derive(Debug, Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.

From ddfd7dce2ba7de0b50fd14dbd50494b6e5cda0b3 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:45:15 -0400
Subject: [PATCH 50/66] Typo fix

Co-authored-by: Aevyrie <aevyrie@gmail.com>
---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index fa089ae470014..2e30bfe8f71f2 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -211,7 +211,7 @@ impl SystemRegistry {
         stored_system.system.apply_buffers(world);
     }
 
-    /// Is at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`]?
+    /// Is at least one system in the [`SystemRegistry`] associated with the provided [`SystemLabel`]?
     #[inline]
     pub fn is_label_registered<L: SystemLabel>(&self, label: L) -> bool {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);

From 4d312e7b500efe2cbc9ae5ef31b2aeccadd91379 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:46:03 -0400
Subject: [PATCH 51/66] Clarify drawbacks of SystemState

---
 crates/bevy_ecs/src/system/function_system.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 7608516b8f387..6c079c8838e67 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -59,7 +59,7 @@ impl SystemMeta {
 /// This is a powerful and convenient tool for working with exclusive world access,
 /// allowing you to fetch data from the [`World`] as if you were running a [`System`].
 /// However, simply calling `world::run_system(my_system)` using a [`SystemRegistry`](crate::system::SystemRegistry)
-/// can be significantly simpler and more reliable.
+/// can be significantly simpler and ensures that change detection and command flushing work as expected.
 ///
 /// Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once,
 /// and arbitrary system parameters (like [`EventWriter`](crate::event::EventWriter)) can be conveniently fetched.

From 8cf91a4a2fe4c10ce8e8598e0670726e43097454 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:47:47 -0400
Subject: [PATCH 52/66] Punctuation

Co-authored-by: Federico Rinaldi <gisquerin@gmail.com>
---
 crates/bevy_ecs/src/system/system_registry.rs |  2 +-
 examples/ecs/one_shot_systems.rs              | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 2e30bfe8f71f2..809b318678eb1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -10,7 +10,7 @@ use crate::world::{Mut, World};
 use crate as bevy_ecs;
 use bevy_ecs_macros::Component;
 
-/// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
+/// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
 ///
 /// Systems are keyed by their [`SystemLabel`]:
 ///  - all systems with a given label will be run (in linear registration order) when a given label is run
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index a8c3c0272d27b..abed2a5b88cb8 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -1,4 +1,4 @@
-//! Demonstrates the use of "one-shot systems", which run once when triggered
+//! Demonstrates the use of "one-shot systems", which run once when triggered.
 //!
 //! These can be useful to help structure your logic in a push-based fashion,
 //! reducing the overhead of running extremely rarely run systems
@@ -14,11 +14,11 @@ fn main() {
         .add_startup_system(count_entities)
         .add_startup_system(setup)
         // One shot systems are interchangeable with ordinarily scheduled systems.
-        // Change detection, Local and NonSend all work as expected
+        // Change detection, Local and NonSend all work as expected.
         .add_system_to_stage(CoreStage::PostUpdate, count_entities)
-        // Registered systems can be called dynamically by their label
+        // Registered systems can be called dynamically by their label.
         // These must be registered in advance, or commands.run_system will panic
-        // as no matching system was found
+        // as no matching system was found.
         .register_system(button_pressed)
         .register_system(slider_toggled)
         // One-shot systems can be used to build complex abstractions
@@ -28,7 +28,7 @@ fn main() {
         .run();
 }
 
-// Any ordinary system can be run via commands.run_system or world.run_system
+// Any ordinary system can be run via commands.run_system or world.run_system.
 //
 // Chained systems, exclusive systems and systems which themselves run systems cannot be called in this way.
 fn count_entities(all_entities: Query<()>) {
@@ -46,7 +46,7 @@ fn setup(mut commands: Commands) {
         // Just stored a boxed SystemLabel!
         .insert(Callback::new(button_pressed))
         .insert(Triggered);
-    // This entity does not have a Triggered component, so its callback won't run
+    // This entity does not have a Triggered component, so its callback won't run.
     commands.spawn().insert(Callback::new(slider_toggled));
     commands.run_system(count_entities);
 }
@@ -59,13 +59,13 @@ fn slider_toggled() {
     println!("A slider was toggled!");
 }
 
-/// Runs the systems associated with each `Callback` component if the entity also has a Triggered component
+/// Runs the systems associated with each `Callback` component if the entity also has a Triggered component.
 ///
-/// This could be done in an exclusive system rather than using `Commands` if preferred
+/// This could be done in an exclusive system rather than using `Commands` if preferred.
 fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Commands) {
     for callback in query.iter() {
         // Because we don't have access to the type information of the callbacks
-        // we have to use the layer of indirection provided by system labels
+        // we have to use the layer of indirection provided by system labels.
         // Note that if we had registered multiple systems with the same label,
         // they would all be evaluated here.
         commands.run_callback(callback.clone());

From b2f5bf7696f1c7802fe08d839bd903868fec3fbc Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:48:53 -0400
Subject: [PATCH 53/66] Typo

Co-authored-by: Aevyrie <aevyrie@gmail.com>
---
 crates/bevy_app/src/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 26cb236c7f315..daf56a0258dd2 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -15,7 +15,7 @@ impl App {
         self
     }
 
-    /// Register system a system with any number of [`SystemLabel`]s.
+    /// Register a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     ///

From 2254d4f50c17cde45f477f85d5da83f631f20d15 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:52:01 -0400
Subject: [PATCH 54/66] Fix mistake from merge conflict

---
 crates/bevy_ecs/src/system/function_system.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 6c079c8838e67..8fff658769ef6 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -448,7 +448,7 @@ where
             self.system_meta.name.as_ref(),
         );
     }
-    
+
     fn default_labels(&self) -> Vec<SystemLabelId> {
         vec![self.func.as_system_label().as_label()]
     }
@@ -458,7 +458,7 @@ where
 #[derive(Default)]
 pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
 
-impl<T: 'static> SystemLabel for SystemTypeIdLabel<T> {
+impl<T: 'static> SystemTypeIdLabel<T> {
     /// Constructs a new copy of the [`SystemTypeIdLabel`] for the type `T`
     ///
     /// You can also construct this by using [`.as_system_label()`](crate::system::AsSystemLabel) on a concrete instance
@@ -466,7 +466,9 @@ impl<T: 'static> SystemLabel for SystemTypeIdLabel<T> {
     pub fn new() -> Self {
         Self(PhantomData::default())
     }
+}
 
+impl<T: 'static> SystemLabel for SystemTypeIdLabel<T> {
     #[inline]
     fn as_str(&self) -> &'static str {
         std::any::type_name::<T>()

From 25c66db66ac5266984eef7386a7fbc8c60cc9e0b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:55:25 -0400
Subject: [PATCH 55/66] Remove vague warning about callbacks

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 809b318678eb1..d730a5528fec0 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -414,10 +414,6 @@ impl Command for RunSystemsByLabelCommand {
 /// Unless you need to inspect the list of events or add additional information,
 /// prefer the simpler `commands.run_system` over storing callbacks as events,
 ///
-/// When working with callbacks, consider your architecture carefully.
-/// Callbacks are typically harder to reason about and debug than scheduled systems,
-/// and it's easy to get into a tangled mess if you don't consider the system as a whole before starting.
-///
 /// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
 /// before they can be run by their label using a callback.
 #[derive(Debug, Component, Clone, Eq)]

From 3ad29fdfcb5120b05a4fe36a646df2fde57fb60c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:58:50 -0400
Subject: [PATCH 56/66] Add Send and Sync bounds to label traits

---
 crates/bevy_utils/src/label.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_utils/src/label.rs b/crates/bevy_utils/src/label.rs
index 835656569c1fe..7edbef23f2e87 100644
--- a/crates/bevy_utils/src/label.rs
+++ b/crates/bevy_utils/src/label.rs
@@ -80,7 +80,7 @@ macro_rules! define_label {
         }
 
         $(#[$label_attr])*
-        pub trait $label_name: 'static {
+        pub trait $label_name: Send + Sync + 'static {
             /// Converts this type into an opaque, strongly-typed label.
             fn as_label(&self) -> $id_name {
                 let id = self.type_id();

From ac1c2aae073ee665b7f6bc0d0f214180a05f9ba1 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 17:07:14 -0400
Subject: [PATCH 57/66] Clean up docs and naming around system registration

---
 crates/bevy_ecs/src/system/system_registry.rs | 40 +++++++++----------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d730a5528fec0..5fbfa4a2ea265 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -94,17 +94,12 @@ impl SystemRegistry {
     /// This allows the system to be run by their [`SystemTypeIdLabel`] using the `run_systems_by_label` method.
     /// Repeatedly registering a system will have no effect.
     ///
-    /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
-    /// When this occurs, they will be registered using their [`SystemTypeIdLabel`].
-    /// However, manual registration allows you to provide one or more labels for the system.
-    /// This also allows you to register multiple distinct copies of the system under distinct labels.
-    ///
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
     /// all registered systems that match that label will be evaluated (in insertion order).
     ///
     /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    fn register_system_with_type_label<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -115,26 +110,23 @@ impl SystemRegistry {
         if !self.is_label_registered(automatic_system_label) {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
-            self.register_boxed_system_with_labels(
-                world,
-                boxed_system,
-                vec![Box::new(automatic_system_label)],
-            );
+            self.register_boxed_system(world, boxed_system, vec![Box::new(automatic_system_label)]);
         } else {
             let type_name = std::any::type_name::<S>();
             warn!("A system of type {type_name} was registered more than once!");
         };
     }
 
-    /// Register system a system with any number of [`SystemLabel`]s.
+    /// Register a system so that it may be run by any of their [`SystemLabel`]s.
     ///
-    /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
+    /// This is only needed if you want to run a system by a particular label;
+    /// the `run_system` label will automatically register systems under their [`SystemTypeIdLabel`] when first used.
     ///
     /// # Warning
     ///
-    /// Unlike the `register_system` method, duplicate systems may be added;
-    /// each copy will be called seperately if they share a label.
-    pub fn register_system_with_labels<
+    /// Duplicate systems may be added if this method is called repeatedly.
+    /// Each copy will be called seperately if they share a label.
+    pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
         LI: IntoIterator<Item = L>,
@@ -156,10 +148,10 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
+        self.register_boxed_system(world, boxed_system, collected_labels);
     }
 
-    /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
+    /// A less generic version of [`register_system`](Self::register_system_with_labels).
     ///
     /// Returns the index in the vector of systems that this new system is stored at.
     /// This is only useful for debugging as an external user of this method.
@@ -167,7 +159,7 @@ impl SystemRegistry {
     /// This can be useful when you have a boxed system or boxed labels,
     /// as the corresponding traits are not implemented for boxed trait objects
     /// to avoid indefinite nesting.
-    pub fn register_boxed_system_with_labels(
+    pub fn register_boxed_system(
         &mut self,
         world: &mut World,
         mut boxed_system: Box<dyn System<In = (), Out = ()>>,
@@ -271,7 +263,11 @@ impl SystemRegistry {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
+    /// You do not need to register systems before they are run in this way.
+    /// Instead, systems will be automatically registered according to their [`SystemTypeIdLabel`] the first time this method is called on them.
+    ///
     /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
+    ///
     /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
     /// only the first will be run.
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
@@ -286,7 +282,7 @@ impl SystemRegistry {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
-            self.register_boxed_system_with_labels(world, boxed_system, labels)
+            self.register_boxed_system(world, boxed_system, labels)
         };
 
         self.run_system_at_index(world, index);
@@ -300,7 +296,7 @@ impl World {
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system);
+            registry.register_system_with_type_label(world, system);
         });
     }
 
@@ -318,7 +314,7 @@ impl World {
         labels: LI,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_labels(world, system, labels);
+            registry.register_system(world, system, labels);
         });
     }
 

From e730525e6cfb624549323c1c0d8bfec50efecacf Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 17:16:10 -0400
Subject: [PATCH 58/66] Make App and World APIs consistent

---
 crates/bevy_app/src/system_registry.rs        | 16 ++--------------
 crates/bevy_ecs/src/system/system_registry.rs | 16 +++-------------
 2 files changed, 5 insertions(+), 27 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index daf56a0258dd2..a83b824ca9f45 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -3,24 +3,12 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::{Callback, SystemRegistryError};
 
 impl App {
-    /// Registers the supplied system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry) resource.
-    ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
-    #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
-        self.world.register_system(system);
-        self
-    }
-
     /// Register a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     ///
     /// [`SystemRegistry`]: bevy_ecs::system::SystemRegistry
-    pub fn register_system_with_labels<
+    pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
         LI: IntoIterator<Item = L>,
@@ -30,7 +18,7 @@ impl App {
         system: S,
         labels: LI,
     ) -> &mut Self {
-        self.world.register_system_with_labels(system, labels);
+        self.world.register_system(system, labels);
         self
     }
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5fbfa4a2ea265..7fb51e635b10f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -290,20 +290,10 @@ impl SystemRegistry {
 }
 
 impl World {
-    /// Registers the supplied system in the [`SystemRegistry`] resource.
-    ///
-    /// Calls the method of the same name on [`SystemRegistry`].
-    #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_type_label(world, system);
-        });
-    }
-
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
-    pub fn register_system_with_labels<
+    pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
         LI: IntoIterator<Item = L>,
@@ -491,8 +481,8 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system_with_labels(count_up, ["count"]);
-        world.register_system_with_labels(count_up, ["count"]);
+        world.register_system(count_up, ["count"]);
+        world.register_system(count_up, ["count"]);
         world.run_systems_by_label("count").unwrap();
         // All systems matching the label will be run.
         assert_eq!(*world.resource::<Counter>(), Counter(2));

From 55e61e133a2d4f90b6d01fe82980cc0e69494c96 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 17:20:26 -0400
Subject: [PATCH 59/66] Make doc links on higher level methods more useful

---
 crates/bevy_app/src/system_registry.rs        | 10 ++++------
 crates/bevy_ecs/src/system/commands/mod.rs    |  6 +++---
 crates/bevy_ecs/src/system/system_registry.rs |  8 ++++----
 3 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index a83b824ca9f45..ecccb0a67bbd3 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -5,9 +5,7 @@ use bevy_ecs::system::{Callback, SystemRegistryError};
 impl App {
     /// Register a system with any number of [`SystemLabel`]s.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
-    ///
-    /// [`SystemRegistry`]: bevy_ecs::system::SystemRegistry
+    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
     pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -24,7 +22,7 @@ impl App {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
@@ -36,7 +34,7 @@ impl App {
 
     /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_systems_by_label`](bevy_ecs::system::SystemRegistry::run_systems_by_label).
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
@@ -47,7 +45,7 @@ impl App {
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
     #[inline]
     pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
         self.world.run_callback(callback)
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 0deda5dd5dc59..72eb2e080054c 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -405,7 +405,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
     pub fn run_system<
         Params: Send + Sync + 'static,
         S: IntoSystem<(), (), Params> + Send + Sync + 'static,
@@ -418,7 +418,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_systems_by_label`](crate::SystemRegistry::run_systems_by_label).
     pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
         self.queue.push(RunSystemsByLabelCommand {
             callback: Callback {
@@ -429,7 +429,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
     pub fn run_callback(&mut self, callback: Callback) {
         self.queue.push(RunSystemsByLabelCommand { callback });
     }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 7fb51e635b10f..377275cbcb9c7 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -292,7 +292,7 @@ impl SystemRegistry {
 impl World {
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::register_system`].
     pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -310,7 +310,7 @@ impl World {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::run_system`].
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
@@ -320,7 +320,7 @@ impl World {
 
     /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::run_systems_by_label`].
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
@@ -333,7 +333,7 @@ impl World {
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::run_callback`].
     #[inline]
     pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {

From ba23d056d67a637868c731541da73c24476eb629 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Thu, 9 Mar 2023 15:11:03 +0100
Subject: [PATCH 60/66] remove non-related clippy lint

---
 crates/bevy_reflect/src/type_registry.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/bevy_reflect/src/type_registry.rs b/crates/bevy_reflect/src/type_registry.rs
index 318f06a62ecba..649a43583d903 100644
--- a/crates/bevy_reflect/src/type_registry.rs
+++ b/crates/bevy_reflect/src/type_registry.rs
@@ -466,7 +466,6 @@ impl ReflectSerialize {
 /// [`FromType::from_type`].
 #[derive(Clone)]
 pub struct ReflectDeserialize {
-    #[allow(clippy::type_complexity)]
     pub func: fn(
         deserializer: &mut dyn erased_serde::Deserializer,
     ) -> Result<Box<dyn Reflect>, erased_serde::Error>,

From 9085d50cda4f290e36c39135032b5f19bc0a8b89 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Thu, 9 Mar 2023 18:51:04 +0100
Subject: [PATCH 61/66] fix doc tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 8084bce067cd5..140524caca6b5 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -65,7 +65,7 @@ use bevy_ecs_macros::{Component, Resource};
 ///
 /// fn spawn_7_entities(mut commands: Commands) {
 ///     for _ in 0..7 {
-///         commands.spawn().insert(Marker);
+///         commands.spawn(Marker);
 ///     }
 /// }
 ///

From aca499888679cdcf30163bfabaf122929e52cc26 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 12:37:47 +0100
Subject: [PATCH 62/66] remove run_systems_by_set

---
 crates/bevy_app/src/system_registry.rs        |  34 +--
 crates/bevy_ecs/src/schedule/set.rs           |   1 +
 crates/bevy_ecs/src/system/system_registry.rs | 252 +++---------------
 examples/ecs/one_shot_systems.rs              |   4 +-
 4 files changed, 49 insertions(+), 242 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 40fd840263296..23ec10917d1fb 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -3,31 +3,14 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::{Callback, SystemRegistryError};
 
 impl App {
-    /// Register a system with its [`SystemTypeSet`].
-    ///
-    /// Calls [`SystemRegistry::register_system_with_type_set`](bevy_ecs::system::SystemRegistry::register_system_with_type_set).
-    pub fn register_system_with_type_set<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
-        self.world.register_system_with_type_set(system);
-        self
-    }
-
     /// Register a system with any number of [`SystemLabel`]s.
     ///
     /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
-    pub fn register_system<
-        Params,
-        S: IntoSystem<(), (), Params> + 'static,
-        SSI: IntoIterator<Item = SS>,
-        SS: SystemSet,
-    >(
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
-        sets: SSI,
     ) -> &mut Self {
-        self.world.register_system(system, sets);
+        self.world.register_system(system);
         self
     }
 
@@ -35,22 +18,11 @@ impl App {
     ///
     /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).
     #[inline]
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
+    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> &mut Self {
         self.world.run_system(system);
         self
     }
 
-    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_systems_by_label`](bevy_ecs::system::SystemRegistry::run_systems_by_label).
-    #[inline]
-    pub fn run_systems_by_set<S: SystemSet>(&mut self, set: S) -> Result<(), SystemRegistryError> {
-        self.world.run_systems_by_set(set)
-    }
-
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
diff --git a/crates/bevy_ecs/src/schedule/set.rs b/crates/bevy_ecs/src/schedule/set.rs
index 23058a3de9fbc..784d52f9bac4f 100644
--- a/crates/bevy_ecs/src/schedule/set.rs
+++ b/crates/bevy_ecs/src/schedule/set.rs
@@ -98,6 +98,7 @@ impl<T> Hash for SystemTypeSet<T> {
         // all systems of a given type are the same
     }
 }
+
 impl<T> Clone for SystemTypeSet<T> {
     fn clone(&self) -> Self {
         Self(PhantomData)
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 140524caca6b5..d49677500f875 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,9 +1,9 @@
 use bevy_utils::tracing::warn;
-use bevy_utils::HashMap;
+use bevy_utils::{Entry, HashMap};
 use std::hash::Hash;
 use std::marker::PhantomData;
 
-use crate::schedule::{BoxedSystemSet, IntoSystemConfig, SystemSet, SystemTypeSet};
+use crate::schedule::{BoxedSystemSet, IntoSystemConfig, SystemTypeSet};
 use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::{Mut, World};
 // Needed for derive(Component) macro
@@ -79,13 +79,7 @@ use bevy_ecs_macros::{Component, Resource};
 /// ```
 #[derive(Resource, Default)]
 pub struct SystemRegistry {
-    systems: Vec<StoredSystem>,
-    // Stores the index of all systems that match the key's set
-    sets: HashMap<BoxedSystemSet, Vec<usize>>,
-}
-
-struct StoredSystem {
-    system: BoxedSystem,
+    systems: HashMap<BoxedSystemSet, BoxedSystem>,
 }
 
 impl SystemRegistry {
@@ -99,137 +93,50 @@ impl SystemRegistry {
     ///
     /// To provide explicit set(s), use [`register_system_with_sets`](SystemRegistry::register_system_with_sets).
     #[inline]
-    fn register_system_with_type_set<Params, S: IntoSystem<(), (), Params> + 'static>(
+    fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
     ) {
-        let automatic_system_set: SystemTypeSet<S> = SystemTypeSet::new();
-
+        let boxed_set: BoxedSystemSet = Box::new(SystemTypeSet::<S>::new());
         // This avoids nasty surprising behavior in case systems are registered twice
-        if !self.is_set_registered(automatic_system_set) {
-            let boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-            self.register_boxed_system(world, boxed_system, vec![Box::new(automatic_system_set)]);
+        if !self.systems.contains_key(&boxed_set) {
+            // Initialize the system's state
+            let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
+            boxed_system.initialize(world);
+            // Insert they system keyed by its set
+            self.systems.insert(boxed_set, boxed_system);
         } else {
             let type_name = std::any::type_name::<S>();
             warn!("A system of type {type_name} was registered more than once!");
         };
     }
 
-    /// Register a system so that it may be run by any of their [`SystemSet`]s.
+    /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// This is only needed if you want to run a system by a particular set;
-    /// the `run_system` set will automatically register systems under their [`SystemTypeSet`] when first used.
+    /// You do not need to register systems before they are run in this way.
+    /// Instead, systems will be automatically registered according to their [`SystemTypeSet`] the first time this method is called on them.
     ///
-    /// # Warning
+    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
     ///
-    /// Duplicate systems may be added if this method is called repeatedly.
-    /// Each copy will be called seperately if they share a set.
-    pub fn register_system<
-        Params,
-        S: IntoSystem<(), (), Params> + 'static,
-        SSI: IntoIterator<Item = SS>,
-        SS: SystemSet,
-    >(
+    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeSet`],
+    /// only the first will be run.
+    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
-        sets: SSI,
     ) {
-        let boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-
-        let collected_sets = sets
-            .into_iter()
-            .map(|set| {
-                let boxed_set: BoxedSystemSet = Box::new(set);
-                boxed_set
-            })
-            .collect();
-
-        self.register_boxed_system(world, boxed_system, collected_sets);
-    }
-
-    /// A less generic version of [`register_system`](Self::register_system_with_sets).
-    ///
-    /// Returns the index in the vector of systems that this new system is stored at.
-    /// This is only useful for debugging as an external user of this method.
-    ///
-    /// This can be useful when you have a boxed system or boxed sets,
-    /// as the corresponding traits are not implemented for boxed trait objects
-    /// to avoid indefinite nesting.
-    pub fn register_boxed_system(
-        &mut self,
-        world: &mut World,
-        mut boxed_system: BoxedSystem,
-        sets: Vec<BoxedSystemSet>,
-    ) -> usize {
-        // Intialize the system's state
-        boxed_system.initialize(world);
-
-        let stored_system = StoredSystem {
-            system: boxed_system,
+        let boxed_set = Box::new(SystemTypeSet::<S>::new());
+        let matching_system = match self.systems.entry(boxed_set) {
+            Entry::Occupied(o) => o.into_mut(),
+            Entry::Vacant(v) => {
+                let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
+                boxed_system.initialize(world);
+                v.insert(boxed_system)
+            }
         };
-
-        // Add the system to the end of the vec
-        let system_index = self.systems.len();
-        self.systems.push(stored_system);
-
-        // For each set that the system has
-        for set in sets {
-            let maybe_set_indexes = self.sets.get_mut(&set);
-
-            // Add the index of the system in the vec to the lookup hashmap
-            // under the corresponding set key
-            if let Some(set_indexes) = maybe_set_indexes {
-                set_indexes.push(system_index);
-            } else {
-                self.sets.insert(set, vec![system_index]);
-            };
-        }
-
-        system_index
-    }
-
-    /// Runs the system at the supplied `index` a single time.
-    #[inline]
-    fn run_system_at_index(&mut self, world: &mut World, index: usize) {
-        let stored_system = &mut self.systems[index];
-
-        // Run the system
-        stored_system.system.run((), world);
-        // Apply any generated commands
-        stored_system.system.apply_buffers(world);
-    }
-
-    /// Is at least one system in the [`SystemRegistry`] associated with the provided [`SystemSet`]?
-    #[inline]
-    pub fn is_set_registered<S: SystemSet>(&self, set: S) -> bool {
-        let boxed_set: BoxedSystemSet = Box::new(set);
-        self.sets.get(&boxed_set).is_some()
-    }
-
-    /// Returns the first matching index for systems with this set if any.
-    #[inline]
-    fn first_registered_index<S: SystemSet>(&self, set: S) -> Option<usize> {
-        let boxed_set: BoxedSystemSet = Box::new(set);
-        let vec_of_indexes = self.sets.get(&boxed_set)?;
-        vec_of_indexes.iter().next().copied()
-    }
-
-    /// Runs the set of systems corresponding to the provided [`SystemSet`] on the [`World`] a single time.
-    ///
-    /// Systems will be run sequentially in registration order if more than one registered system matches the provided set.
-    pub fn run_systems_by_set<S: SystemSet>(
-        &mut self,
-        world: &mut World,
-        set: S,
-    ) -> Result<(), SystemRegistryError> {
-        self.run_callback(
-            world,
-            Callback {
-                set: set.dyn_clone(),
-            },
-        )
+        matching_system.run((), world);
+        matching_system.apply_buffers(world);
     }
 
     /// Run the systems corresponding to the set stored in the provided [`Callback`]
@@ -245,75 +152,24 @@ impl SystemRegistry {
         callback: Callback,
     ) -> Result<(), SystemRegistryError> {
         let boxed_set = callback.set;
-
-        match self.sets.get(&boxed_set) {
-            Some(matching_indexes) => {
-                // Loop over the system in registration order
-                for index in matching_indexes.clone() {
-                    self.run_system_at_index(world, index);
-                }
-
+        match self.systems.get_mut(&boxed_set) {
+            Some(matching_system) => {
+                matching_system.run((), world);
+                matching_system.apply_buffers(world);
                 Ok(())
             }
             None => Err(SystemRegistryError::SetNotFound(boxed_set)),
         }
     }
-
-    /// Runs the supplied system on the [`World`] a single time.
-    ///
-    /// You do not need to register systems before they are run in this way.
-    /// Instead, systems will be automatically registered according to their [`SystemTypeSet`] the first time this method is called on them.
-    ///
-    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
-    ///
-    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeSet`],
-    /// only the first will be run.
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        world: &mut World,
-        system: S,
-    ) {
-        let automatic_system_set: SystemTypeSet<S> = SystemTypeSet::new();
-        let index = if self.is_set_registered(automatic_system_set) {
-            self.first_registered_index(automatic_system_set).unwrap()
-        } else {
-            let boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-            let sets = boxed_system.default_system_sets();
-            self.register_boxed_system(world, boxed_system, sets)
-        };
-
-        self.run_system_at_index(world, index);
-    }
 }
 
 impl World {
     /// Register a system with its [`SystemTypeSet`].
     ///
     /// Calls [`SystemRegistry::register_system_with_type_set`].
-    pub fn register_system_with_type_set<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) {
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_type_set(world, system);
-        });
-    }
-
-    /// Register a system with any number of [`SystemSet`]s.
-    ///
-    /// Calls [`SystemRegistry::register_system`].
-    pub fn register_system<
-        Params,
-        S: IntoSystem<(), (), Params> + 'static,
-        SSI: IntoIterator<Item = SS>,
-        SS: SystemSet,
-    >(
-        &mut self,
-        system: S,
-        sets: SSI,
-    ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, sets);
+            registry.register_system(world, system);
         });
     }
 
@@ -321,22 +177,12 @@ impl World {
     ///
     /// Calls [`SystemRegistry::run_system`].
     #[inline]
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run_system(world, system);
         });
     }
 
-    /// Runs the systems corresponding to the supplied [`SystemSet`] on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_systems_by_set`].
-    #[inline]
-    pub fn run_systems_by_set<L: SystemSet>(&mut self, set: L) -> Result<(), SystemRegistryError> {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_set(world, set)
-        })
-    }
-
     /// Run the systems corresponding to the set stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`].
@@ -351,15 +197,15 @@ impl World {
 /// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
 pub struct RunSystemCommand<
-    Params: Send + Sync + 'static,
-    S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    M: Send + Sync + 'static,
+    S: IntoSystem<(), (), M> + Send + Sync + 'static,
 > {
-    _phantom_params: PhantomData<Params>,
+    _phantom_params: PhantomData<M>,
     system: S,
 }
 
-impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
-    RunSystemCommand<Params, S>
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
+    RunSystemCommand<M, S>
 {
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
@@ -372,8 +218,8 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     }
 }
 
-impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static> Command
-    for RunSystemCommand<Params, S>
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
+    for RunSystemCommand<M, S>
 {
     #[inline]
     fn write(self, world: &mut World) {
@@ -421,7 +267,7 @@ impl Callback {
     /// Creates a new callback from a function that can be used as a system.
     ///
     /// Remember that you must register your systems with the `App` / [`World`] before they can be run as callbacks!
-    pub fn new<S: IntoSystemConfig<Params> + 'static, Params>(_system: S) -> Self {
+    pub fn new<S: IntoSystemConfig<M> + 'static, M>(_system: S) -> Self {
         Callback {
             set: Box::new(SystemTypeSet::<S>::new()),
         }
@@ -486,18 +332,6 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
-    #[test]
-    fn run_system_by_set() {
-        let mut world = World::new();
-        world.init_resource::<Counter>();
-        assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, [CountSet]);
-        world.register_system(count_up, [CountSet]);
-        world.run_systems_by_set(CountSet).unwrap();
-        // All systems matching the set will be run.
-        assert_eq!(*world.resource::<Counter>(), Counter(2));
-    }
-
     #[allow(dead_code)]
     fn spawn_entity(mut commands: Commands) {
         commands.spawn_empty();
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 1a62fbf1ac883..8841f778b3475 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -19,8 +19,8 @@ fn main() {
         // Registered systems can be called dynamically by their label.
         // These must be registered in advance, or commands.run_system will panic
         // as no matching system was found.
-        .register_system_with_type_set(button_pressed)
-        .register_system_with_type_set(slider_toggled)
+        .register_system(button_pressed)
+        .register_system(slider_toggled)
         // One-shot systems can be used to build complex abstractions
         // to match the needs of your design.
         // Here, we model a very simple component-linked callback architecture.

From 331966433e86fdcbc066d8b73cf451db848a4fd8 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 12:50:17 +0100
Subject: [PATCH 63/66] remove run_systems_by_label from Commands

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 17 ++++-------------
 crates/bevy_ecs/src/system/system_registry.rs |  4 ++--
 2 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index d1e2dd042c6b3..c6aacc6bf7719 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     bundle::Bundle,
     entity::{Entities, Entity},
     schedule::SystemSet,
-    system::{Callback, IntoSystem, RunSystemCommand, RunSystemsBySetCommand},
+    system::{Callback, IntoSystem, RunCallback, RunSystemCommand},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -511,8 +511,8 @@ impl<'w, 's> Commands<'w, 's> {
     ///
     /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
     pub fn run_system<
-        Params: Send + Sync + 'static,
-        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+        M: Send + Sync + 'static,
+        S: IntoSystem<(), (), M> + Send + Sync + 'static,
     >(
         &mut self,
         system: S,
@@ -520,20 +520,11 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RunSystemCommand::new(system));
     }
 
-    /// Runs the systems corresponding to the supplied [`SystemSet`] on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_systems_by_set`](crate::SystemRegistry::run_systems_by_set).
-    pub fn run_systems_by_label(&mut self, set: impl SystemSet) {
-        self.queue.push(RunSystemsBySetCommand {
-            callback: Callback { set: Box::new(set) },
-        });
-    }
-
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
     pub fn run_callback(&mut self, callback: Callback) {
-        self.queue.push(RunSystemsBySetCommand { callback });
+        self.queue.push(RunCallback { callback });
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d49677500f875..c3674806d96ef 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -229,11 +229,11 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_set`]
 #[derive(Debug, Clone)]
-pub struct RunSystemsBySetCommand {
+pub struct RunCallback {
     pub callback: Callback,
 }
 
-impl Command for RunSystemsBySetCommand {
+impl Command for RunCallback {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {

From 68ba9bd3bdf2e120452c138e7b3b174be59408b7 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 13:08:51 +0100
Subject: [PATCH 64/66] rename params to marker

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c3674806d96ef..e386940d41b08 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -200,7 +200,7 @@ pub struct RunSystemCommand<
     M: Send + Sync + 'static,
     S: IntoSystem<(), (), M> + Send + Sync + 'static,
 > {
-    _phantom_params: PhantomData<M>,
+    _phantom_marker: PhantomData<M>,
     system: S,
 }
 
@@ -212,7 +212,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
     #[must_use]
     pub fn new(system: S) -> Self {
         Self {
-            _phantom_params: PhantomData::default(),
+            _phantom_marker: PhantomData::default(),
             system,
         }
     }

From 98aa1781ec298c87bab7be34e5a15a722c0da109 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Mon, 13 Mar 2023 16:58:35 +0100
Subject: [PATCH 65/66] key systems by SystemId

---
 crates/bevy_app/src/system_registry.rs        |  10 +-
 crates/bevy_ecs/src/system/commands/mod.rs    |   9 +-
 crates/bevy_ecs/src/system/system_registry.rs | 167 +++++++-----------
 examples/ecs/one_shot_systems.rs              |  22 +--
 4 files changed, 88 insertions(+), 120 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 23ec10917d1fb..83514afa7b706 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,8 @@
 use crate::App;
-use bevy_ecs::prelude::*;
-use bevy_ecs::system::{Callback, SystemRegistryError};
+use bevy_ecs::{
+    prelude::*,
+    system::{SystemId, SystemRegistryError},
+};
 
 impl App {
     /// Register a system with any number of [`SystemLabel`]s.
@@ -27,7 +29,7 @@ impl App {
     ///
     /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
     #[inline]
-    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
-        self.world.run_callback(callback)
+    pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
+        self.world.run_system_by_id(system_id)
     }
 }
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index c6aacc6bf7719..968d35e61ced6 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,8 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    schedule::SystemSet,
-    system::{Callback, IntoSystem, RunCallback, RunSystemCommand},
+    system::{IntoSystem, RunSystem, RunSystemById, SystemId},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -517,14 +516,14 @@ impl<'w, 's> Commands<'w, 's> {
         &mut self,
         system: S,
     ) {
-        self.queue.push(RunSystemCommand::new(system));
+        self.queue.push(RunSystem::new(system));
     }
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
-    pub fn run_callback(&mut self, callback: Callback) {
-        self.queue.push(RunCallback { callback });
+    pub fn run_system_by_id(&mut self, system_id: SystemId) {
+        self.queue.push(RunSystemById::new(system_id));
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index e386940d41b08..1ed444528a5e5 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,14 +1,12 @@
-use bevy_utils::tracing::warn;
-use bevy_utils::{Entry, HashMap};
+use std::any::TypeId;
 use std::hash::Hash;
 use std::marker::PhantomData;
 
-use crate::schedule::{BoxedSystemSet, IntoSystemConfig, SystemTypeSet};
 use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::{Mut, World};
 // Needed for derive(Component) macro
-use crate as bevy_ecs;
-use bevy_ecs_macros::{Component, Resource};
+use crate::{self as bevy_ecs, TypeIdMap};
+use bevy_ecs_macros::Resource;
 
 /// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
 ///
@@ -79,7 +77,8 @@ use bevy_ecs_macros::{Component, Resource};
 /// ```
 #[derive(Resource, Default)]
 pub struct SystemRegistry {
-    systems: HashMap<BoxedSystemSet, BoxedSystem>,
+    systems: Vec<(bool, BoxedSystem)>,
+    indices: TypeIdMap<usize>,
 }
 
 impl SystemRegistry {
@@ -93,23 +92,20 @@ impl SystemRegistry {
     ///
     /// To provide explicit set(s), use [`register_system_with_sets`](SystemRegistry::register_system_with_sets).
     #[inline]
-    fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
-        world: &mut World,
         system: S,
-    ) {
-        let boxed_set: BoxedSystemSet = Box::new(SystemTypeSet::<S>::new());
-        // This avoids nasty surprising behavior in case systems are registered twice
-        if !self.systems.contains_key(&boxed_set) {
-            // Initialize the system's state
-            let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-            boxed_system.initialize(world);
-            // Insert they system keyed by its set
-            self.systems.insert(boxed_set, boxed_system);
-        } else {
-            let type_name = std::any::type_name::<S>();
-            warn!("A system of type {type_name} was registered more than once!");
-        };
+    ) -> SystemId {
+        let type_id = TypeId::of::<S>();
+
+        let index = *self.indices.entry(type_id).or_insert_with(|| {
+            let index = self.systems.len();
+            self.systems
+                .push((false, Box::new(IntoSystem::into_system(system))));
+            index
+        });
+
+        SystemId::new(index)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -126,17 +122,9 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
     ) {
-        let boxed_set = Box::new(SystemTypeSet::<S>::new());
-        let matching_system = match self.systems.entry(boxed_set) {
-            Entry::Occupied(o) => o.into_mut(),
-            Entry::Vacant(v) => {
-                let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-                boxed_system.initialize(world);
-                v.insert(boxed_system)
-            }
-        };
-        matching_system.run((), world);
-        matching_system.apply_buffers(world);
+        let id = self.register_system(system);
+        self.run_system_by_id(world, id)
+            .expect("System was registered before running");
     }
 
     /// Run the systems corresponding to the set stored in the provided [`Callback`]
@@ -146,31 +134,49 @@ impl SystemRegistry {
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided set.
     #[inline]
-    pub fn run_callback(
+    pub fn run_system_by_id(
         &mut self,
         world: &mut World,
-        callback: Callback,
+        id: SystemId,
     ) -> Result<(), SystemRegistryError> {
-        let boxed_set = callback.set;
-        match self.systems.get_mut(&boxed_set) {
-            Some(matching_system) => {
+        match self.systems.get_mut(id.index()) {
+            Some((initialized, matching_system)) => {
+                if !*initialized {
+                    matching_system.initialize(world);
+                    *initialized = true;
+                }
                 matching_system.run((), world);
                 matching_system.apply_buffers(world);
                 Ok(())
             }
-            None => Err(SystemRegistryError::SetNotFound(boxed_set)),
+            None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
         }
     }
 }
 
+#[derive(Debug, Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct SystemId(usize);
+
+impl SystemId {
+    #[inline]
+    pub const fn new(index: usize) -> SystemId {
+        SystemId(index)
+    }
+
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+}
+
 impl World {
-    /// Register a system with its [`SystemTypeSet`].
-    ///
-    /// Calls [`SystemRegistry::register_system_with_type_set`].
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system);
-        });
+    #[inline]
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        system: S,
+    ) -> SystemId {
+        self.resource_mut::<SystemRegistry>()
+            .register_system(system)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -187,26 +193,21 @@ impl World {
     ///
     /// Calls [`SystemRegistry::run_callback`].
     #[inline]
-    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
+    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_callback(world, callback)
+            registry.run_system_by_id(world, id)
         })
     }
 }
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
-pub struct RunSystemCommand<
-    M: Send + Sync + 'static,
-    S: IntoSystem<(), (), M> + Send + Sync + 'static,
-> {
+pub struct RunSystem<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
     _phantom_marker: PhantomData<M>,
     system: S,
 }
 
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
-    RunSystemCommand<M, S>
-{
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystem<M, S> {
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
@@ -219,7 +220,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 }
 
 impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
-    for RunSystemCommand<M, S>
+    for RunSystem<M, S>
 {
     #[inline]
     fn write(self, world: &mut World) {
@@ -229,16 +230,22 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_set`]
 #[derive(Debug, Clone)]
-pub struct RunCallback {
-    pub callback: Callback,
+pub struct RunSystemById {
+    pub system_id: SystemId,
 }
 
-impl Command for RunCallback {
+impl RunSystemById {
+    pub fn new(system_id: SystemId) -> Self {
+        Self { system_id }
+    }
+}
+
+impl Command for RunSystemById {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
-                .run_callback(world, self.callback)
+                .run_system_by_id(world, self.system_id)
                 // Ideally this error should be handled more gracefully,
                 // but that's blocked on a full error handling solution for commands
                 .unwrap();
@@ -246,53 +253,13 @@ impl Command for RunCallback {
     }
 }
 
-/// A struct that stores a boxed [`SystemSet`], used to cause a [`SystemRegistry`] to run systems.
-///
-/// This might be stored as a component, used as an event, or arranged in a queue stored in a resource.
-/// Unless you need to inspect the list of events or add additional information,
-/// prefer the simpler `commands.run_system` over storing callbacks as events,
-///
-/// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
-/// before they can be run by their set using a callback.
-#[derive(Debug, Component, Clone, Eq)]
-pub struct Callback {
-    /// The set of the system(s) to be run.
-    ///
-    /// By default, this is set to the [`SystemTypeSet`]
-    /// of the system passed in via [`Callback::new()`].
-    pub set: BoxedSystemSet,
-}
-
-impl Callback {
-    /// Creates a new callback from a function that can be used as a system.
-    ///
-    /// Remember that you must register your systems with the `App` / [`World`] before they can be run as callbacks!
-    pub fn new<S: IntoSystemConfig<M> + 'static, M>(_system: S) -> Self {
-        Callback {
-            set: Box::new(SystemTypeSet::<S>::new()),
-        }
-    }
-}
-
-impl PartialEq for Callback {
-    fn eq(&self, other: &Self) -> bool {
-        self.set.dyn_eq(other.set.as_dyn_eq())
-    }
-}
-
-impl Hash for Callback {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.set.dyn_hash(state);
-    }
-}
-
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {
     /// A system was run by set, but no system with that set was found.
     ///
     /// Did you forget to register it?
-    SetNotFound(BoxedSystemSet),
+    SystemIdNotRegistered(SystemId),
 }
 
 mod tests {
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 8841f778b3475..9244385dfe4a2 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -6,8 +6,10 @@
 //!
 //! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
 
-use bevy::ecs::system::Callback;
-use bevy::prelude::*;
+use bevy::{
+    ecs::system::{SystemId, SystemRegistry},
+    prelude::*,
+};
 
 fn main() {
     App::new()
@@ -16,11 +18,6 @@ fn main() {
         // One shot systems are interchangeable with ordinarily scheduled systems.
         // Change detection, Local and NonSend all work as expected.
         .add_system(count_entities.in_base_set(CoreSet::PostUpdate))
-        // Registered systems can be called dynamically by their label.
-        // These must be registered in advance, or commands.run_system will panic
-        // as no matching system was found.
-        .register_system(button_pressed)
-        .register_system(slider_toggled)
         // One-shot systems can be used to build complex abstractions
         // to match the needs of your design.
         // Here, we model a very simple component-linked callback architecture.
@@ -35,19 +32,22 @@ fn count_entities(all_entities: Query<()>) {
     dbg!(all_entities.iter().count());
 }
 
+#[derive(Component)]
+struct Callback(SystemId);
+
 #[derive(Component)]
 struct Triggered;
 
-fn setup(mut commands: Commands) {
+fn setup(mut system_registry: ResMut<SystemRegistry>, mut commands: Commands) {
     commands.spawn((
         // The Callback component is defined in bevy_ecs,
         // but wrapping this (or making your own customized variant) is easy.
         // Just stored a boxed SystemLabel!
-        Callback::new(button_pressed),
+        Callback(system_registry.register_system(button_pressed)),
         Triggered,
     ));
     // This entity does not have a Triggered component, so its callback won't run.
-    commands.spawn(Callback::new(slider_toggled));
+    commands.spawn(Callback(system_registry.register_system(slider_toggled)));
     commands.run_system(count_entities);
 }
 
@@ -68,6 +68,6 @@ fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Co
         // we have to use the layer of indirection provided by system labels.
         // Note that if we had registered multiple systems with the same label,
         // they would all be evaluated here.
-        commands.run_callback(callback.clone());
+        commands.run_system_by_id(callback.0);
     }
 }

From 0a59b3b31706ad891d3176490dde4334ed60f18d Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Mon, 13 Mar 2023 17:19:21 +0100
Subject: [PATCH 66/66] shorten system registry function names

---
 crates/bevy_ecs/src/system/system_registry.rs | 26 +++++++------------
 examples/ecs/one_shot_systems.rs              |  4 +--
 2 files changed, 11 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 1ed444528a5e5..509f7729610bc 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -92,10 +92,7 @@ impl SystemRegistry {
     ///
     /// To provide explicit set(s), use [`register_system_with_sets`](SystemRegistry::register_system_with_sets).
     #[inline]
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        system: S,
-    ) -> SystemId {
+    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
         let type_id = TypeId::of::<S>();
 
         let index = *self.indices.entry(type_id).or_insert_with(|| {
@@ -117,13 +114,9 @@ impl SystemRegistry {
     ///
     /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeSet`],
     /// only the first will be run.
-    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        world: &mut World,
-        system: S,
-    ) {
-        let id = self.register_system(system);
-        self.run_system_by_id(world, id)
+    pub fn run<M, S: IntoSystem<(), (), M> + 'static>(&mut self, world: &mut World, system: S) {
+        let id = self.register(system);
+        self.run_by_id(world, id)
             .expect("System was registered before running");
     }
 
@@ -134,7 +127,7 @@ impl SystemRegistry {
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided set.
     #[inline]
-    pub fn run_system_by_id(
+    pub fn run_by_id(
         &mut self,
         world: &mut World,
         id: SystemId,
@@ -175,8 +168,7 @@ impl World {
         &mut self,
         system: S,
     ) -> SystemId {
-        self.resource_mut::<SystemRegistry>()
-            .register_system(system)
+        self.resource_mut::<SystemRegistry>().register(system)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -185,7 +177,7 @@ impl World {
     #[inline]
     pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system);
+            registry.run(world, system);
         });
     }
 
@@ -195,7 +187,7 @@ impl World {
     #[inline]
     pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_by_id(world, id)
+            registry.run_by_id(world, id)
         })
     }
 }
@@ -245,7 +237,7 @@ impl Command for RunSystemById {
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
-                .run_system_by_id(world, self.system_id)
+                .run_by_id(world, self.system_id)
                 // Ideally this error should be handled more gracefully,
                 // but that's blocked on a full error handling solution for commands
                 .unwrap();
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 9244385dfe4a2..65297617559a4 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -43,11 +43,11 @@ fn setup(mut system_registry: ResMut<SystemRegistry>, mut commands: Commands) {
         // The Callback component is defined in bevy_ecs,
         // but wrapping this (or making your own customized variant) is easy.
         // Just stored a boxed SystemLabel!
-        Callback(system_registry.register_system(button_pressed)),
+        Callback(system_registry.register(button_pressed)),
         Triggered,
     ));
     // This entity does not have a Triggered component, so its callback won't run.
-    commands.spawn(Callback(system_registry.register_system(slider_toggled)));
+    commands.spawn(Callback(system_registry.register(slider_toggled)));
     commands.run_system(count_entities);
 }