Auto insert sync points

crates/bevy_ecs/src/schedule/config.rs

@@ -5,6 +5,7 @@ use crate::{
         condition::{BoxedCondition, Condition},
         graph_utils::{Ambiguity, Dependency, DependencyKind, GraphInfo},
         set::{InternedSystemSet, IntoSystemSet, SystemSet},
+        Chain,
     },
     system::{BoxedSystem, IntoSystem, System},
 };
@@ -67,8 +68,8 @@ pub enum NodeConfigs<T> {
         configs: Vec<NodeConfigs<T>>,
         /// Run conditions applied to everything in the tuple.
         collective_conditions: Vec<BoxedCondition>,
-        /// If `true`, adds `before -> after` ordering constraints between the successive elements.
-        chained: bool,
+        /// See [`Chain`] for usage.
+        chained: Chain,
     },
 }
 
@@ -137,6 +138,38 @@ impl<T> NodeConfigs<T> {
         }
     }
 
+    fn before_ignore_deferred_inner(&mut self, set: InternedSystemSet) {
+        match self {
+            Self::NodeConfig(config) => {
+                config
+                    .graph_info
+                    .dependencies
+                    .push(Dependency::new(DependencyKind::BeforeNoSync, set));
+            }
+            Self::Configs { configs, .. } => {
+                for config in configs {
+                    config.before_ignore_deferred_inner(set.intern());
+                }
+            }
+        }
+    }
+
+    fn after_ignore_deferred_inner(&mut self, set: InternedSystemSet) {
+        match self {
+            Self::NodeConfig(config) => {
+                config
+                    .graph_info
+                    .dependencies
+                    .push(Dependency::new(DependencyKind::AfterNoSync, set));
+            }
+            Self::Configs { configs, .. } => {
+                for config in configs {
+                    config.after_ignore_deferred_inner(set.intern());
+                }
+            }
+        }
+    }
+
     fn distributive_run_if_inner<M>(&mut self, condition: impl Condition<M> + Clone) {
         match self {
             Self::NodeConfig(config) => {
@@ -198,7 +231,17 @@ impl<T> NodeConfigs<T> {
         match &mut self {
             Self::NodeConfig(_) => { /* no op */ }
             Self::Configs { chained, .. } => {
-                *chained = true;
+                *chained = Chain::Yes;
+            }
+        }
+        self
+    }
+
+    fn chain_ignore_deferred_inner(mut self) -> Self {
+        match &mut self {
+            Self::NodeConfig(_) => { /* no op */ }
+            Self::Configs { chained, .. } => {
+                *chained = Chain::YesIgnoreDeferred;
             }
         }
         self
@@ -252,22 +295,46 @@ where
         self.into_configs().in_set(set)
     }
 
-    /// Run before all systems in `set`.
+    /// Runs before all systems in `set`. If `self` has any systems that produce [`Commands`](crate::system::Commands)
+    /// or other [`Deferred`](crate::system::Deferred) operations, all systems in `set` will see their effect.
+    ///
+    /// If automatically inserting [`apply_deferred`](crate::schedule::apply_deferred) like
+    /// this isn't desired, use [`before_ignore_deferred`](Self::before_ignore_deferred) instead.
     ///
     /// Note: The given set is not implicitly added to the schedule when this system set is added.
     /// It is safe, but no dependencies will be created.
     fn before<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
         self.into_configs().before(set)
     }
 
-    /// Run after all systems in `set`.
+    /// Run after all systems in `set`. If `set` has any systems that produce [`Commands`](crate::system::Commands)
+    /// or other [`Deferred`](crate::system::Deferred) operations, all systems in `self` will see their effect.
+    ///
+    /// If automatically inserting [`apply_deferred`](crate::schedule::apply_deferred) like
+    /// this isn't desired, use [`after_ignore_deferred`](Self::after_ignore_deferred) instead.
     ///
     /// Note: The given set is not implicitly added to the schedule when this system set is added.
     /// It is safe, but no dependencies will be created.
     fn after<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
         self.into_configs().after(set)
     }
 
+    /// Run before all systems in `set`.
+    ///
+    /// Unlike [`before`](Self::before), this will not cause the systems in
+    /// `set` to wait for the deferred effects of `self` to be applied.
+    fn before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
+        self.into_configs().before_ignore_deferred(set)
+    }
+
+    /// Run after all systems in `set`.
+    ///
+    /// Unlike [`after`](Self::after), this will not wait for the deferred
+    /// effects of systems in `set` to be applied.
+    fn after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
+        self.into_configs().after_ignore_deferred(set)
+    }
+
     /// Add a run condition to each contained system.
     ///
     /// Each system will receive its own clone of the [`Condition`] and will only run
@@ -351,9 +418,22 @@ where
     /// Treat this collection as a sequence of systems.
     ///
     /// Ordering constraints will be applied between the successive elements.
+    ///
+    /// If the preceeding node on a edge has deferred parameters, a [`apply_deferred`](crate::schedule::apply_deferred)
+    /// will be inserted on the edge. If this behavior is not desired consider using
+    /// [`chain_ignore_deferred`](Self::chain_ignore_deferred) instead.
     fn chain(self) -> SystemConfigs {
         self.into_configs().chain()
     }
+
+    /// Treat this collection as a sequence of systems.
+    ///
+    /// Ordering constraints will be applied between the successive elements.
+    ///
+    /// Unlike [`chain`](Self::chain) this will **not** add [`apply_deferred`](crate::schedule::apply_deferred) on the edges.
+    fn chain_ignore_deferred(self) -> SystemConfigs {
+        self.into_configs().chain_ignore_deferred()
+    }
 }
 
 impl IntoSystemConfigs<()> for SystemConfigs {
@@ -385,6 +465,18 @@ impl IntoSystemConfigs<()> for SystemConfigs {
         self
     }
 
+    fn before_ignore_deferred<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
+        let set = set.into_system_set();
+        self.before_ignore_deferred_inner(set.intern());
+        self
+    }
+
+    fn after_ignore_deferred<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
+        let set = set.into_system_set();
+        self.after_ignore_deferred_inner(set.intern());
+        self
+    }
+
     fn distributive_run_if<M>(mut self, condition: impl Condition<M> + Clone) -> SystemConfigs {
         self.distributive_run_if_inner(condition);
         self
@@ -409,6 +501,10 @@ impl IntoSystemConfigs<()> for SystemConfigs {
     fn chain(self) -> Self {
         self.chain_inner()
     }
+
+    fn chain_ignore_deferred(self) -> Self {
+        self.chain_ignore_deferred_inner()
+    }
 }
 
 #[doc(hidden)]
@@ -426,7 +522,7 @@ macro_rules! impl_system_collection {
                 SystemConfigs::Configs {
                     configs: vec![$($sys.into_configs(),)*],
                     collective_conditions: Vec::new(),
-                    chained: false,
+                    chained: Chain::No,
                 }
             }
         }
@@ -474,16 +570,40 @@ where
         self.into_configs().in_set(set)
     }
 
-    /// Run before all systems in `set`.
+    /// Runs before all systems in `set`. If `self` has any systems that produce [`Commands`](crate::system::Commands)
+    /// or other [`Deferred`](crate::system::Deferred) operations, all systems in `set` will see their effect.
+    ///
+    /// If automatically inserting [`apply_deferred`](crate::schedule::apply_deferred) like
+    /// this isn't desired, use [`before_ignore_deferred`](Self::before_ignore_deferred) instead.
     fn before<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
         self.into_configs().before(set)
     }
 
-    /// Run after all systems in `set`.
+    /// Runs before all systems in `set`. If `set` has any systems that produce [`Commands`](crate::system::Commands)
+    /// or other [`Deferred`](crate::system::Deferred) operations, all systems in `self` will see their effect.
+    ///
+    /// If automatically inserting [`apply_deferred`](crate::schedule::apply_deferred) like
+    /// this isn't desired, use [`after_ignore_deferred`](Self::after_ignore_deferred) instead.
     fn after<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
         self.into_configs().after(set)
     }
 
+    /// Run before all systems in `set`.
+    ///
+    /// Unlike [`before`](Self::before), this will not cause the systems in `set` to wait for the
+    /// deferred effects of `self` to be applied.
+    fn before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
+        self.into_configs().before_ignore_deferred(set)
+    }
+
+    /// Run after all systems in `set`.
+    ///
+    /// Unlike [`after`](Self::after), this may not see the deferred
+    /// effects of systems in `set` to be applied.
+    fn after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
+        self.into_configs().after_ignore_deferred(set)
+    }
+
     /// Run the systems in this set(s) only if the [`Condition`] is `true`.
     ///
     /// The `Condition` will be evaluated at most once (per schedule run),
@@ -510,6 +630,15 @@ where
     fn chain(self) -> SystemSetConfigs {
         self.into_configs().chain()
     }
+
+    /// Treat this collection as a sequence of systems.
+    ///
+    /// Ordering constraints will be applied between the successive elements.
+    ///
+    /// Unlike [`chain`](Self::chain) this will **not** add [`apply_deferred`](crate::schedule::apply_deferred) on the edges.
+    fn chain_ignore_deferred(self) -> SystemConfigs {
+        self.into_configs().chain_ignore_deferred()
+    }
 }
 
 impl IntoSystemSetConfigs for SystemSetConfigs {
@@ -542,6 +671,20 @@ impl IntoSystemSetConfigs for SystemSetConfigs {
         self
     }
 
+    fn before_ignore_deferred<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
+        let set = set.into_system_set();
+        self.before_ignore_deferred_inner(set.intern());
+
+        self
+    }
+
+    fn after_ignore_deferred<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
+        let set = set.into_system_set();
+        self.after_ignore_deferred_inner(set.intern());
+
+        self
+    }
+
     fn run_if<M>(mut self, condition: impl Condition<M>) -> SystemSetConfigs {
         self.run_if_dyn(new_condition(condition));
 
@@ -588,7 +731,7 @@ macro_rules! impl_system_set_collection {
                 SystemSetConfigs::Configs {
                     configs: vec![$($set.into_configs(),)*],
                     collective_conditions: Vec::new(),
-                    chained: false,
+                    chained: Chain::No,
                 }
             }
         }

crates/bevy_ecs/src/schedule/graph_utils.rs

@@ -45,6 +45,10 @@ pub(crate) enum DependencyKind {
     Before,
     /// A node that should be succeeded.
     After,
+    /// A node that should be preceded and will **not** automatically insert an instance of `apply_deferred` on the edge.
+    BeforeNoSync,
+    /// A node that should be succeeded and will **not** automatically insert an instance of `apply_deferred` on the edge.
+    AfterNoSync,
 }
 
 /// An edge to be added to the dependency graph.