From 91a5e3585decd70f1f9c7e2c20261c1304799cdd Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Thu, 2 Sep 2021 18:16:18 -0300
Subject: [PATCH 001/113] Number the reported ambiguities, to make them easier
 to discuss in a team

---
 crates/bevy_ecs/src/schedule/stage.rs | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index c2a040d648517..a48d5c5b0c125 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -501,11 +501,14 @@ impl SystemStage {
             systems: &[impl SystemContainer],
             mut ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
             world: &World,
+            output_prefix: &str,
         ) {
-            for (index_a, index_b, conflicts) in ambiguities.drain(..) {
+            for (idx, (index_a, index_b, conflicts)) in ambiguities.drain(..).enumerate() {
                 writeln!(
                     string,
-                    " -- {:?} and {:?}",
+                    "{}.{} - {:?} and {:?}",
+                    output_prefix,
+                    idx, 
                     systems[index_a].name(),
                     systems[index_b].name()
                 )
@@ -532,30 +535,32 @@ impl SystemStage {
                     add an explicit dependency relation between some of these systems:\n"
                 .to_owned();
             if !parallel.is_empty() {
-                writeln!(string, " * Parallel systems:").unwrap();
-                write_display_names_of_pairs(&mut string, &self.parallel, parallel, world);
+                writeln!(string, "1. Parallel systems:").unwrap();
+                write_display_names_of_pairs(&mut string, &self.parallel, parallel, world, "1");
             }
             if !at_start.is_empty() {
-                writeln!(string, " * Exclusive systems at start of stage:").unwrap();
+                writeln!(string, "2. Exclusive systems at start of stage:").unwrap();
                 write_display_names_of_pairs(
                     &mut string,
                     &self.exclusive_at_start,
                     at_start,
                     world,
+                    "1",
                 );
             }
             if !before_commands.is_empty() {
-                writeln!(string, " * Exclusive systems before commands of stage:").unwrap();
+                writeln!(string, "3. Exclusive systems before commands of stage:").unwrap();
                 write_display_names_of_pairs(
                     &mut string,
                     &self.exclusive_before_commands,
                     before_commands,
                     world,
+                    "1",
                 );
             }
             if !at_end.is_empty() {
-                writeln!(string, " * Exclusive systems at end of stage:").unwrap();
-                write_display_names_of_pairs(&mut string, &self.exclusive_at_end, at_end, world);
+                writeln!(string, "4. Exclusive systems at end of stage:").unwrap();
+                write_display_names_of_pairs(&mut string, &self.exclusive_at_end, at_end, world,"1");
             }
             info!("{}", string);
         }

From 9892cc1447babdd3569802645550688b5f4d28df Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Thu, 2 Sep 2021 18:28:31 -0300
Subject: [PATCH 002/113] Fixed formatting

---
 crates/bevy_ecs/src/schedule/stage.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index a48d5c5b0c125..1fa452f4f3233 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -508,7 +508,7 @@ impl SystemStage {
                     string,
                     "{}.{} - {:?} and {:?}",
                     output_prefix,
-                    idx, 
+                    idx,
                     systems[index_a].name(),
                     systems[index_b].name()
                 )
@@ -560,7 +560,13 @@ impl SystemStage {
             }
             if !at_end.is_empty() {
                 writeln!(string, "4. Exclusive systems at end of stage:").unwrap();
-                write_display_names_of_pairs(&mut string, &self.exclusive_at_end, at_end, world,"1");
+                write_display_names_of_pairs(
+                    &mut string,
+                    &self.exclusive_at_end,
+                    at_end,
+                    world,
+                    "1",
+                );
             }
             info!("{}", string);
         }

From 3383bf07edb5dc013e08cb6cd3da8ef577077658 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Thu, 2 Sep 2021 19:35:11 -0300
Subject: [PATCH 003/113] Explain which components/resources the systems are
 conflicting on.

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 1fa452f4f3233..7de1667af70a5 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -506,7 +506,7 @@ impl SystemStage {
             for (idx, (index_a, index_b, conflicts)) in ambiguities.drain(..).enumerate() {
                 writeln!(
                     string,
-                    "{}.{} - {:?} and {:?}",
+                    "{}.{} - {:?} and {:?} conflicts on the following components/resources:",
                     output_prefix,
                     idx,
                     systems[index_a].name(),
@@ -518,7 +518,7 @@ impl SystemStage {
                         .iter()
                         .map(|id| world.components().get_info(*id).unwrap().name())
                         .collect::<Vec<_>>();
-                    writeln!(string, "    conflicts: {:?}", names).unwrap();
+                    writeln!(string, "{:?}", names).unwrap();
                 }
             }
         }

From 50b86c66a541853680e0999e1424af0a237000d1 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Thu, 2 Sep 2021 20:04:19 -0300
Subject: [PATCH 004/113] Fixed wrong output_prefix

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 7de1667af70a5..0b897778280b0 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -545,7 +545,7 @@ impl SystemStage {
                     &self.exclusive_at_start,
                     at_start,
                     world,
-                    "1",
+                    "2",
                 );
             }
             if !before_commands.is_empty() {
@@ -555,7 +555,7 @@ impl SystemStage {
                     &self.exclusive_before_commands,
                     before_commands,
                     world,
-                    "1",
+                    "3",
                 );
             }
             if !at_end.is_empty() {
@@ -565,7 +565,7 @@ impl SystemStage {
                     &self.exclusive_at_end,
                     at_end,
                     world,
-                    "1",
+                    "4",
                 );
             }
             info!("{}", string);

From 21aad3eb7802dbfb0a546445e9be36581dcd528c Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Thu, 2 Sep 2021 21:25:21 -0300
Subject: [PATCH 005/113] Report ambiguities where all pairwise combinations of
 systems conflict on the same data as a group.

---
 crates/bevy_ecs/src/schedule/stage.rs | 41 ++++++++++++++++++---------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 0b897778280b0..2e3f1be2604b0 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -503,23 +503,38 @@ impl SystemStage {
             world: &World,
             output_prefix: &str,
         ) {
-            for (idx, (index_a, index_b, conflicts)) in ambiguities.drain(..).enumerate() {
+            use std::collections::hash_map;
+
+            let mut ambiguities_map: hash_map::HashMap<Vec<ComponentId>, Vec<usize>> =
+                hash_map::HashMap::new();
+
+            for (index_a, index_b, components) in ambiguities.drain(..) {
+                let systems = ambiguities_map.entry(components).or_default();
+                if !systems.contains(&index_a) {
+                    systems.push(index_a);
+                }
+                if !systems.contains(&index_b) {
+                    systems.push(index_b);
+                }
+            }
+
+            for (idx, (conflicts, systems_indices)) in ambiguities_map.drain().enumerate() {
+                let system_names = systems_indices
+                    .iter()
+                    .map(|index| systems[*index].name())
+                    .collect::<Vec<_>>();
+
+                let system_components = conflicts
+                    .iter()
+                    .map(|id| world.components().get_info(*id).unwrap().name())
+                    .collect::<Vec<_>>();
+
                 writeln!(
                     string,
-                    "{}.{} - {:?} and {:?} conflicts on the following components/resources:",
-                    output_prefix,
-                    idx,
-                    systems[index_a].name(),
-                    systems[index_b].name()
+                    "{}.{} - Systems:\n     {:?}\n   - Conflicts on the following components/resources:\n     {:?}",
+                    output_prefix, idx, system_names, system_components
                 )
                 .unwrap();
-                if !conflicts.is_empty() {
-                    let names = conflicts
-                        .iter()
-                        .map(|id| world.components().get_info(*id).unwrap().name())
-                        .collect::<Vec<_>>();
-                    writeln!(string, "{:?}", names).unwrap();
-                }
             }
         }
         let parallel = find_ambiguities(&self.parallel);

From f0c71341efc6497fcc57dffb7204594685ca2108 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Fri, 3 Sep 2021 11:15:54 -0300
Subject: [PATCH 006/113] Create a simple ambiguous method that causes a system
 to be ignored completely in the ambiguity checker.

---
 crates/bevy_ecs/src/schedule/stage.rs         | 38 ++++++++++++++++++-
 .../bevy_ecs/src/schedule/system_container.rs | 15 ++++++++
 .../src/schedule/system_descriptor.rs         | 37 ++++++++++++++++++
 3 files changed, 89 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 2e3f1be2604b0..d481d167503d8 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -16,7 +16,7 @@ use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::fmt::Debug;
 
-use super::IntoSystemDescriptor;
+use super::{AmbiguityDetection, IntoSystemDescriptor};
 
 /// A type that can run as a step of a [`Schedule`](super::Schedule).
 pub trait Stage: Downcast + Send + Sync {
@@ -766,6 +766,16 @@ fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<
         for index_b in full_bitset.difference(&relations)
         // .take(index_a)
         {
+            match systems[index_a].ambiguity_detection() {
+                AmbiguityDetection::Ignore => continue,
+                AmbiguityDetection::Check => (),
+            }
+
+            match systems[index_b].ambiguity_detection() {
+                AmbiguityDetection::Ignore => continue,
+                AmbiguityDetection::Check => (),
+            }
+
             if !processed.contains(index_b)
                 && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
             {
@@ -1983,6 +1993,32 @@ mod tests {
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
         assert_eq!(ambiguities.len(), 0);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(component.label("0"))
+            .with_system(resource.label("1").after("0").ambiguous())
+            .with_system(empty.label("2"))
+            .with_system(component.label("3").after("2").before("4"))
+            .with_system(resource.label("4"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        assert!(
+            ambiguities.contains(&(Box::new("0"), Box::new("3")))
+                || ambiguities.contains(&(Box::new("3"), Box::new("0")))
+        );
+        assert_eq!(ambiguities.len(), 1);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(component.label("0").ambiguous())
+            .with_system(resource.label("1").after("0").ambiguous())
+            .with_system(empty.label("2"))
+            .with_system(component.label("3").after("2").before("4"))
+            .with_system(resource.label("4"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        assert_eq!(ambiguities.len(), 0);
     }
 
     #[test]
diff --git a/crates/bevy_ecs/src/schedule/system_container.rs b/crates/bevy_ecs/src/schedule/system_container.rs
index 108e391d606f8..89e67f8e184e5 100644
--- a/crates/bevy_ecs/src/schedule/system_container.rs
+++ b/crates/bevy_ecs/src/schedule/system_container.rs
@@ -9,6 +9,8 @@ use crate::{
 };
 use std::borrow::Cow;
 
+use super::AmbiguityDetection;
+
 /// System metadata like its name, labels, order requirements and component access.
 pub trait SystemContainer: GraphNode<Label = BoxedSystemLabel> {
     #[doc(hidden)]
@@ -21,6 +23,7 @@ pub trait SystemContainer: GraphNode<Label = BoxedSystemLabel> {
     fn set_run_criteria(&mut self, index: usize);
     fn run_criteria_label(&self) -> Option<&BoxedRunCriteriaLabel>;
     fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel];
+    fn ambiguity_detection(&self) -> &AmbiguityDetection;
     fn component_access(&self) -> Option<&Access<ComponentId>>;
 }
 
@@ -33,6 +36,7 @@ pub(super) struct ExclusiveSystemContainer {
     before: Vec<BoxedSystemLabel>,
     after: Vec<BoxedSystemLabel>,
     ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    ambiguity_detection: AmbiguityDetection,
 }
 
 impl ExclusiveSystemContainer {
@@ -46,6 +50,7 @@ impl ExclusiveSystemContainer {
             before: descriptor.before,
             after: descriptor.after,
             ambiguity_sets: descriptor.ambiguity_sets,
+            ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
 
@@ -103,6 +108,10 @@ impl SystemContainer for ExclusiveSystemContainer {
     fn component_access(&self) -> Option<&Access<ComponentId>> {
         None
     }
+
+    fn ambiguity_detection(&self) -> &AmbiguityDetection {
+        &self.ambiguity_detection
+    }
 }
 
 pub struct ParallelSystemContainer {
@@ -115,6 +124,7 @@ pub struct ParallelSystemContainer {
     before: Vec<BoxedSystemLabel>,
     after: Vec<BoxedSystemLabel>,
     ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    ambiguity_detection: AmbiguityDetection,
 }
 
 unsafe impl Send for ParallelSystemContainer {}
@@ -132,6 +142,7 @@ impl ParallelSystemContainer {
             before: descriptor.before,
             after: descriptor.after,
             ambiguity_sets: descriptor.ambiguity_sets,
+            ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
 
@@ -205,4 +216,8 @@ impl SystemContainer for ParallelSystemContainer {
     fn component_access(&self) -> Option<&Access<ComponentId>> {
         Some(self.system().component_access())
     }
+
+    fn ambiguity_detection(&self) -> &AmbiguityDetection {
+        &self.ambiguity_detection
+    }
 }
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 405c8760f3a81..269465ab8e74a 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -96,6 +96,11 @@ impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
     }
 }
 
+pub enum AmbiguityDetection {
+    Check,
+    Ignore,
+}
+
 /// Encapsulates a parallel system and information on when it runs in a `SystemStage`.
 pub struct ParallelSystemDescriptor {
     pub(crate) system: BoxedSystem<(), ()>,
@@ -104,6 +109,7 @@ pub struct ParallelSystemDescriptor {
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
     pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    pub(crate) ambiguity_detection: AmbiguityDetection,
 }
 
 fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescriptor {
@@ -114,6 +120,7 @@ fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescrip
         before: Vec::new(),
         after: Vec::new(),
         ambiguity_sets: Vec::new(),
+        ambiguity_detection: AmbiguityDetection::Check,
     }
 }
 
@@ -137,6 +144,9 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems in this set.
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
+
+    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection
+    fn ambiguous(self) -> ParallelSystemDescriptor;
 }
 
 impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
@@ -167,6 +177,11 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self.ambiguity_sets.push(Box::new(set));
         self
     }
+
+    fn ambiguous(mut self) -> ParallelSystemDescriptor {
+        self.ambiguity_detection = AmbiguityDetection::Ignore;
+        self
+    }
 }
 
 impl<S, Params> ParallelSystemDescriptorCoercion<Params> for S
@@ -196,6 +211,10 @@ where
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).in_ambiguity_set(set)
     }
+
+    fn ambiguous(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(self.system())).ambiguous()
+    }
 }
 
 impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
@@ -221,6 +240,10 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
         new_parallel_descriptor(self).in_ambiguity_set(set)
     }
+
+    fn ambiguous(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(self).ambiguous()
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -238,6 +261,7 @@ pub struct ExclusiveSystemDescriptor {
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
     pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    pub(crate) ambiguity_detection: AmbiguityDetection,
     pub(crate) insertion_point: InsertionPoint,
 }
 
@@ -249,6 +273,7 @@ fn new_exclusive_descriptor(system: Box<dyn ExclusiveSystem>) -> ExclusiveSystem
         before: Vec::new(),
         after: Vec::new(),
         ambiguity_sets: Vec::new(),
+        ambiguity_detection: AmbiguityDetection::Check,
         insertion_point: InsertionPoint::AtStart,
     }
 }
@@ -283,6 +308,9 @@ pub trait ExclusiveSystemDescriptorCoercion {
 
     /// Specifies that the system should run with other exclusive systems at the end of stage.
     fn at_end(self) -> ExclusiveSystemDescriptor;
+
+    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection
+    fn ambiguous(self) -> ExclusiveSystemDescriptor;
 }
 
 impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
@@ -328,6 +356,11 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self.insertion_point = InsertionPoint::AtEnd;
         self
     }
+
+    fn ambiguous(mut self) -> ExclusiveSystemDescriptor {
+        self.ambiguity_detection = AmbiguityDetection::Ignore;
+        self
+    }
 }
 
 impl<T> ExclusiveSystemDescriptorCoercion for T
@@ -368,4 +401,8 @@ where
     fn at_end(self) -> ExclusiveSystemDescriptor {
         new_exclusive_descriptor(Box::new(self)).at_end()
     }
+
+    fn ambiguous(self) -> ExclusiveSystemDescriptor {
+        new_exclusive_descriptor(Box::new(self)).ambiguous()
+    }
 }

From 601a26774566a7b0c8bf0bfd2b0670e3bdde68ca Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Fri, 3 Sep 2021 12:49:23 -0300
Subject: [PATCH 007/113] Create a simple ambiguous_with system_label method to
 create two-element ambiguity sets without being forced to invent an ambiguity
 set label.

---
 crates/bevy_ecs/src/schedule/stage.rs         | 69 ++++++++++++++++---
 .../src/schedule/system_descriptor.rs         | 47 +++++++++++++
 2 files changed, 106 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index d481d167503d8..c0c43b21f991d 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -714,6 +714,26 @@ fn process_systems(
 /// along with specific components that have triggered the warning.
 /// Systems must be topologically sorted beforehand.
 fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<ComponentId>)> {
+    fn should_ignore_ambiguity(
+        systems: &[impl SystemContainer],
+        index_a: usize,
+        index_b: usize,
+    ) -> bool {
+        (match systems[index_a].ambiguity_detection() {
+            AmbiguityDetection::Ignore => true,
+            AmbiguityDetection::Check => false,
+            AmbiguityDetection::IgnoreWithLabel(labels) => {
+                labels.iter().any(|l| systems[index_b].labels().contains(l))
+            }
+        }) || (match systems[index_b].ambiguity_detection() {
+            AmbiguityDetection::Ignore => true,
+            AmbiguityDetection::Check => false,
+            AmbiguityDetection::IgnoreWithLabel(labels) => {
+                labels.iter().any(|l| systems[index_a].labels().contains(l))
+            }
+        })
+    }
+
     let mut ambiguity_set_labels = HashMap::default();
     for set in systems.iter().flat_map(|c| c.ambiguity_sets()) {
         let len = ambiguity_set_labels.len();
@@ -766,18 +786,9 @@ fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<
         for index_b in full_bitset.difference(&relations)
         // .take(index_a)
         {
-            match systems[index_a].ambiguity_detection() {
-                AmbiguityDetection::Ignore => continue,
-                AmbiguityDetection::Check => (),
-            }
-
-            match systems[index_b].ambiguity_detection() {
-                AmbiguityDetection::Ignore => continue,
-                AmbiguityDetection::Check => (),
-            }
-
             if !processed.contains(index_b)
                 && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
+                && !should_ignore_ambiguity(systems, index_a, index_b)
             {
                 let a_access = systems[index_a].component_access();
                 let b_access = systems[index_b].component_access();
@@ -2019,6 +2030,44 @@ mod tests {
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
+            .with_system(empty.exclusive_system().label("1").ambiguous())
+            .with_system(empty.exclusive_system().label("2").after("1"))
+            .with_system(empty.exclusive_system().label("3").ambiguous())
+            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
+            .with_system(empty.exclusive_system().label("5").ambiguous())
+            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
+        assert!(
+            ambiguities.contains(&(Box::new("2"), Box::new("4")))
+                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
+        );
+        assert_eq!(ambiguities.len(), 1);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(component.label("0"))
+            .with_system(resource.label("1").after("0"))
+            .with_system(empty.label("2"))
+            .with_system(
+                component
+                    .label("3")
+                    .after("2")
+                    .before("4")
+                    .ambiguous_with("0"),
+            )
+            .with_system(resource.label("4").ambiguous_with("4"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        assert!(
+            ambiguities.contains(&(Box::new("1"), Box::new("4")))
+                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
+        );
+        assert_eq!(ambiguities.len(), 1);
     }
 
     #[test]
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 269465ab8e74a..a12733c662184 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -99,6 +99,7 @@ impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
 pub enum AmbiguityDetection {
     Check,
     Ignore,
+    IgnoreWithLabel(Vec<BoxedSystemLabel>),
 }
 
 /// Encapsulates a parallel system and information on when it runs in a `SystemStage`.
@@ -147,6 +148,10 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
 
     /// Specifies that this system is ambiguous and must be ignored by ambiguity detection
     fn ambiguous(self) -> ParallelSystemDescriptor;
+
+    /// Specifies that the system is exempt from execution order ambiguity detection
+    /// with other systems with the given label
+    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
 }
 
 impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
@@ -182,6 +187,19 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
+
+    fn ambiguous_with(mut self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+        match &mut self.ambiguity_detection {
+            AmbiguityDetection::IgnoreWithLabel(v) => {
+                v.push(Box::new(label));
+            }
+            _ => {
+                self.ambiguity_detection =
+                    AmbiguityDetection::IgnoreWithLabel(vec![Box::new(label)]);
+            }
+        }
+        self
+    }
 }
 
 impl<S, Params> ParallelSystemDescriptorCoercion<Params> for S
@@ -215,6 +233,10 @@ where
     fn ambiguous(self) -> ParallelSystemDescriptor {
         new_parallel_descriptor(Box::new(self.system())).ambiguous()
     }
+
+    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(self.system())).ambiguous_with(label)
+    }
 }
 
 impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
@@ -244,6 +266,10 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
     fn ambiguous(self) -> ParallelSystemDescriptor {
         new_parallel_descriptor(self).ambiguous()
     }
+
+    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(self).ambiguous_with(label)
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -311,6 +337,10 @@ pub trait ExclusiveSystemDescriptorCoercion {
 
     /// Specifies that this system is ambiguous and must be ignored by ambiguity detection
     fn ambiguous(self) -> ExclusiveSystemDescriptor;
+
+    /// Specifies that the system is exempt from execution order ambiguity detection
+    /// with other systems with the given label
+    fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
 }
 
 impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
@@ -361,6 +391,19 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
+
+    fn ambiguous_with(mut self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
+        match &mut self.ambiguity_detection {
+            AmbiguityDetection::IgnoreWithLabel(v) => {
+                v.push(Box::new(label));
+            }
+            _ => {
+                self.ambiguity_detection =
+                    AmbiguityDetection::IgnoreWithLabel(vec![Box::new(label)]);
+            }
+        }
+        self
+    }
 }
 
 impl<T> ExclusiveSystemDescriptorCoercion for T
@@ -405,4 +448,8 @@ where
     fn ambiguous(self) -> ExclusiveSystemDescriptor {
         new_exclusive_descriptor(Box::new(self)).ambiguous()
     }
+
+    fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
+        new_exclusive_descriptor(Box::new(self)).ambiguous_with(label)
+    }
 }

From 66ba0f9eb3231afc6d9daf978995ba8414c43082 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 08:17:03 -0300
Subject: [PATCH 008/113] Provide an 'X unresolved ambiguities detected'
 message that runs by default

---
 crates/bevy_ecs/src/schedule/stage.rs | 69 ++++++++++++++++++++++++---
 1 file changed, 63 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index c0c43b21f991d..922d3f48c33f1 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -11,7 +11,7 @@ use crate::{
     },
     world::{World, WorldId},
 };
-use bevy_utils::{tracing::info, HashMap, HashSet};
+use bevy_utils::{HashMap, HashSet, tracing::{info, warn}};
 use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::fmt::Debug;
@@ -27,6 +27,13 @@ pub trait Stage: Downcast + Send + Sync {
 
 impl_downcast!(Stage);
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+enum AmbiguityReportLevel {
+    Off,
+    Minimal,
+    Verbose,
+}
+
 /// When this resource is present in the `App`'s `Resources`,
 /// each `SystemStage` will log a report containing
 /// pairs of systems with ambiguous execution order.
@@ -46,7 +53,39 @@ impl_downcast!(Stage);
 ///
 /// The checker may report a system more times than the amount of constraints it would actually need
 /// to have unambiguous order with regards to a group of already-constrained systems.
-pub struct ReportExecutionOrderAmbiguities;
+pub struct ReportExecutionOrderAmbiguities {
+    level: AmbiguityReportLevel,
+}
+
+impl ReportExecutionOrderAmbiguities {
+    /// Disables all messages reported by the ambiguity checker.
+    pub fn off() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Off,
+        }
+    }
+
+    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This
+    /// the default behavior.
+    pub fn minimal() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+        }
+    }
+
+    /// Displays a full report of ambiguities detected by the ambiguity checker.
+    pub fn verbose() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Verbose,
+        }
+    }
+}
+
+impl Default for ReportExecutionOrderAmbiguities {
+    fn default() -> Self {
+        Self::minimal()
+    }
+}
 
 /// Stores and executes systems. Execution order is not defined unless explicitly specified;
 /// see `SystemDescriptor` documentation.
@@ -493,7 +532,16 @@ impl SystemStage {
     }
 
     /// Logs execution order ambiguities between systems. System orders must be fresh.
-    fn report_ambiguities(&self, world: &World) {
+    fn report_ambiguities(&self, world: &mut World) {
+        let report_level = match world.get_resource::<ReportExecutionOrderAmbiguities>() {
+            Some(r) => r.level,
+            None => ReportExecutionOrderAmbiguities::default().level,
+        };
+
+        if report_level == AmbiguityReportLevel::Off {
+            return;
+        }
+
         debug_assert!(!self.systems_modified);
         use std::fmt::Write;
         fn write_display_names_of_pairs(
@@ -541,10 +589,21 @@ impl SystemStage {
         let at_start = find_ambiguities(&self.exclusive_at_start);
         let before_commands = find_ambiguities(&self.exclusive_before_commands);
         let at_end = find_ambiguities(&self.exclusive_at_end);
+
+        let mut unresolved_count = parallel.len();
+        unresolved_count += at_start.len();
+        unresolved_count += before_commands.len();
+        unresolved_count += at_end.len();
+
+        if unresolved_count > 0 {
+            warn!("{} unresolved ambiguities detected", unresolved_count);
+        }
+
         if !(parallel.is_empty()
             && at_start.is_empty()
             && before_commands.is_empty()
             && at_end.is_empty())
+            && report_level == AmbiguityReportLevel::Verbose
         {
             let mut string = "Execution order ambiguities detected, you might want to \
                     add an explicit dependency relation between some of these systems:\n"
@@ -824,9 +883,7 @@ impl Stage for SystemStage {
             self.systems_modified = false;
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
-            if world.contains_resource::<ReportExecutionOrderAmbiguities>() {
-                self.report_ambiguities(world);
-            }
+            self.report_ambiguities(world);
         } else if self.executor_modified {
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;

From 5d3ff552fac2f06b278b1987ada024642776d981 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 08:23:39 -0300
Subject: [PATCH 009/113] Fixed format issue

---
 crates/bevy_ecs/src/schedule/stage.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 922d3f48c33f1..448262fde4195 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -11,7 +11,10 @@ use crate::{
     },
     world::{World, WorldId},
 };
-use bevy_utils::{HashMap, HashSet, tracing::{info, warn}};
+use bevy_utils::{
+    tracing::{info, warn},
+    HashMap, HashSet,
+};
 use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::fmt::Debug;

From b9e498877ca076bf8e13934f93efd68a15bff942 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 08:24:41 -0300
Subject: [PATCH 010/113] Fixed ecs_guide example

---
 examples/ecs/ecs_guide.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index c199a0019d5da..8e1a12aa694f4 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -334,7 +334,7 @@ fn main() {
         // Be aware that not everything reported by this checker is a potential problem, you'll have
         // to make that judgement yourself.
         .add_plugin(LogPlugin::default())
-        .insert_resource(ReportExecutionOrderAmbiguities)
+        .insert_resource(ReportExecutionOrderAmbiguities::verbose())
         // This call to run() starts the app we just built!
         .run();
 }

From e997b1d008af7e63a3ca23655fffb4b3a70141c5 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 10:20:44 -0300
Subject: [PATCH 011/113] Provide an way to ignore/filter crates when using
 ambiguity checker.

---
 crates/bevy_ecs/src/schedule/stage.rs | 100 ++++++++++++++++++++------
 1 file changed, 77 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 448262fde4195..c48d92cc5fcee 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -31,7 +31,7 @@ pub trait Stage: Downcast + Send + Sync {
 impl_downcast!(Stage);
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-enum AmbiguityReportLevel {
+pub enum AmbiguityReportLevel {
     Off,
     Minimal,
     Verbose,
@@ -57,7 +57,8 @@ enum AmbiguityReportLevel {
 /// The checker may report a system more times than the amount of constraints it would actually need
 /// to have unambiguous order with regards to a group of already-constrained systems.
 pub struct ReportExecutionOrderAmbiguities {
-    level: AmbiguityReportLevel,
+    pub level: AmbiguityReportLevel,
+    pub ignore_crates: Vec<String>,
 }
 
 impl ReportExecutionOrderAmbiguities {
@@ -65,6 +66,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn off() -> Self {
         Self {
             level: AmbiguityReportLevel::Off,
+            ignore_crates: vec![],
         }
     }
 
@@ -73,6 +75,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn minimal() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,
+            ignore_crates: vec![],
         }
     }
 
@@ -80,8 +83,16 @@ impl ReportExecutionOrderAmbiguities {
     pub fn verbose() -> Self {
         Self {
             level: AmbiguityReportLevel::Verbose,
+            ignore_crates: vec![],
         }
     }
+
+    pub fn ignore(mut self, create_prefix: &[&str]) -> Self {
+        for s in create_prefix {
+            self.ignore_crates.push(s.to_string());
+        }
+        self
+    }
 }
 
 impl Default for ReportExecutionOrderAmbiguities {
@@ -536,12 +547,10 @@ impl SystemStage {
 
     /// Logs execution order ambiguities between systems. System orders must be fresh.
     fn report_ambiguities(&self, world: &mut World) {
-        let report_level = match world.get_resource::<ReportExecutionOrderAmbiguities>() {
-            Some(r) => r.level,
-            None => ReportExecutionOrderAmbiguities::default().level,
-        };
+        let ambiguity_report =
+            world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
 
-        if report_level == AmbiguityReportLevel::Off {
+        if ambiguity_report.level == AmbiguityReportLevel::Off {
             return;
         }
 
@@ -588,10 +597,14 @@ impl SystemStage {
                 .unwrap();
             }
         }
-        let parallel = find_ambiguities(&self.parallel);
-        let at_start = find_ambiguities(&self.exclusive_at_start);
-        let before_commands = find_ambiguities(&self.exclusive_before_commands);
-        let at_end = find_ambiguities(&self.exclusive_at_end);
+
+        let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);
+        let at_start = find_ambiguities(&self.exclusive_at_start, &ambiguity_report.ignore_crates);
+        let before_commands = find_ambiguities(
+            &self.exclusive_before_commands,
+            &ambiguity_report.ignore_crates,
+        );
+        let at_end = find_ambiguities(&self.exclusive_at_end, &ambiguity_report.ignore_crates);
 
         let mut unresolved_count = parallel.len();
         unresolved_count += at_start.len();
@@ -606,7 +619,7 @@ impl SystemStage {
             && at_start.is_empty()
             && before_commands.is_empty()
             && at_end.is_empty())
-            && report_level == AmbiguityReportLevel::Verbose
+            && ambiguity_report.level == AmbiguityReportLevel::Verbose
         {
             let mut string = "Execution order ambiguities detected, you might want to \
                     add an explicit dependency relation between some of these systems:\n"
@@ -775,25 +788,34 @@ fn process_systems(
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
 /// along with specific components that have triggered the warning.
 /// Systems must be topologically sorted beforehand.
-fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<ComponentId>)> {
+fn find_ambiguities(
+    systems: &[impl SystemContainer],
+    crates_filter: &[String],
+) -> Vec<(usize, usize, Vec<ComponentId>)> {
     fn should_ignore_ambiguity(
         systems: &[impl SystemContainer],
         index_a: usize,
         index_b: usize,
+        crates_filter: &[String],
     ) -> bool {
-        (match systems[index_a].ambiguity_detection() {
+        let system_a = &systems[index_a];
+        let system_b = &systems[index_b];
+
+        (match system_a.ambiguity_detection() {
             AmbiguityDetection::Ignore => true,
             AmbiguityDetection::Check => false,
             AmbiguityDetection::IgnoreWithLabel(labels) => {
-                labels.iter().any(|l| systems[index_b].labels().contains(l))
+                labels.iter().any(|l| system_b.labels().contains(l))
             }
-        }) || (match systems[index_b].ambiguity_detection() {
+        }) || (match system_b.ambiguity_detection() {
             AmbiguityDetection::Ignore => true,
             AmbiguityDetection::Check => false,
             AmbiguityDetection::IgnoreWithLabel(labels) => {
-                labels.iter().any(|l| systems[index_a].labels().contains(l))
+                labels.iter().any(|l| system_a.labels().contains(l))
             }
-        })
+        }) || crates_filter
+            .iter()
+            .any(|s| system_a.name().starts_with(s) || system_b.name().starts_with(s))
     }
 
     let mut ambiguity_set_labels = HashMap::default();
@@ -850,7 +872,7 @@ fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<
         {
             if !processed.contains(index_b)
                 && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
-                && !should_ignore_ambiguity(systems, index_a, index_b)
+                && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter)
             {
                 let a_access = systems[index_a].component_access();
                 let b_access = systems[index_b].component_access();
@@ -1686,7 +1708,24 @@ mod tests {
         fn find_ambiguities_first_str_labels(
             systems: &[impl SystemContainer],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            find_ambiguities(systems)
+            find_ambiguities(systems, &[])
+                .drain(..)
+                .map(|(index_a, index_b, _conflicts)| {
+                    (
+                        systems[index_a].labels()[0].clone(),
+                        systems[index_b].labels()[0].clone(),
+                    )
+                })
+                .collect()
+        }
+
+        fn find_ambiguities_first_labels_with_filter(
+            systems: &[impl SystemContainer],
+            filter: &[String],
+        ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
+            let mut find_ambiguities = find_ambiguities(systems, filter);
+
+            find_ambiguities
                 .drain(..)
                 .map(|(index_a, index_b, _conflicts)| {
                     (
@@ -1711,6 +1750,10 @@ mod tests {
         fn resource(_: ResMut<usize>) {}
         fn component(_: Query<&mut W<f32>>) {}
 
+        mod inner {
+            pub(super) fn inner_fn(_: super::ResMut<usize>) {}
+        }
+
         let mut world = World::new();
 
         let mut stage = SystemStage::parallel()
@@ -1721,7 +1764,7 @@ mod tests {
             .with_system(empty.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
+        assert_eq!(find_ambiguities(&stage.parallel, &[]).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.label("0"))
@@ -1761,7 +1804,7 @@ mod tests {
             .with_system(component.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
+        assert_eq!(find_ambiguities(&stage.parallel, &[]).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
@@ -1987,7 +2030,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("7").after("6"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.exclusive_at_start).len(), 0);
+        assert_eq!(find_ambiguities(&stage.exclusive_at_start, &[]).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().label("0").before("1").before("3"))
@@ -2128,6 +2171,17 @@ mod tests {
                 || ambiguities.contains(&(Box::new("4"), Box::new("1")))
         );
         assert_eq!(ambiguities.len(), 1);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(resource.label("1"))
+            .with_system(inner::inner_fn.label("2"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels_with_filter(
+            &stage.parallel,
+            &["bevy_ecs::schedule::stage::tests::ambiguity_detection::inner::".into()],
+        );
+        assert_eq!(ambiguities.len(), 0);
     }
 
     #[test]

From 7972ee117287f254ee1c3a29f6e55bab5a90c367 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 10:25:24 -0300
Subject: [PATCH 012/113] By default, ambiguity checker should ignore internal
 bevy crates.

---
 crates/bevy_ecs/src/schedule/stage.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index c48d92cc5fcee..ae1146ded4546 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -66,7 +66,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn off() -> Self {
         Self {
             level: AmbiguityReportLevel::Off,
-            ignore_crates: vec![],
+            ..Default::default()
         }
     }
 
@@ -75,7 +75,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn minimal() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,
-            ignore_crates: vec![],
+            ..Default::default()
         }
     }
 
@@ -83,7 +83,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn verbose() -> Self {
         Self {
             level: AmbiguityReportLevel::Verbose,
-            ignore_crates: vec![],
+            ..Default::default()
         }
     }
 
@@ -97,7 +97,10 @@ impl ReportExecutionOrderAmbiguities {
 
 impl Default for ReportExecutionOrderAmbiguities {
     fn default() -> Self {
-        Self::minimal()
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+            ignore_crates: vec!["bevy_".into()],
+        }
     }
 }
 

From 389d2ecef0292cb842e130258704a332473a08fc Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 13:17:22 -0300
Subject: [PATCH 013/113] Added better message when warning about unresolved
 ambiguities

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index ae1146ded4546..2c34c43cda72a 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -615,7 +615,7 @@ impl SystemStage {
         unresolved_count += at_end.len();
 
         if unresolved_count > 0 {
-            warn!("{} unresolved ambiguities detected", unresolved_count);
+            warn!("{} unresolved ambiguities detected. Set the level of the ReportExecutionOrderAmbiguities resource to AmbiguityReportLevel::Verbose for more details.", unresolved_count);
         }
 
         if !(parallel.is_empty()

From fe7c4758c5d2eacb49ac61ec4fedefab7ee25e17 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 13:38:03 -0300
Subject: [PATCH 014/113] Updated ReportExecutionOrderAmbiguities docs

---
 crates/bevy_ecs/src/schedule/stage.rs | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 2c34c43cda72a..148b37bebf793 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -37,10 +37,6 @@ pub enum AmbiguityReportLevel {
     Verbose,
 }
 
-/// When this resource is present in the `App`'s `Resources`,
-/// each `SystemStage` will log a report containing
-/// pairs of systems with ambiguous execution order.
-///
 /// Systems that access the same Component or Resource within the same stage
 /// risk an ambiguous order that could result in logic bugs, unless they have an
 /// explicit execution ordering constraint between them.
@@ -51,11 +47,28 @@ pub enum AmbiguityReportLevel {
 /// Some ambiguities reported by the ambiguity checker may be warranted (to allow two systems to run
 /// without blocking each other) or spurious, as the exact combination of archetypes used may
 /// prevent them from ever conflicting during actual gameplay. You can resolve the warnings produced
-/// by the ambiguity checker by adding `.before` or `.after` to one of the conflicting systems
+/// by the ambiguity checker by adding .before or .after to one of the conflicting systems
 /// referencing the other system to force a specific ordering.
 ///
 /// The checker may report a system more times than the amount of constraints it would actually need
 /// to have unambiguous order with regards to a group of already-constrained systems.
+///
+/// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
+/// This behavior can be changed by explicit adding this resource using the following constructors:
+/// * [ReportExecutionOrderAmbiguities::off()] - Disables all messages reported by the ambiguity checker
+/// * [ReportExecutionOrderAmbiguities::minimal()] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
+/// * [ReportExecutionOrderAmbiguities::verbose()] - Displays a full report of ambiguities detected by the ambiguity checker.
+///
+/// The ambiguity checker will ignore all crates starting with "bevy_". To ignore a custom crate, just call [`ReportExecutionOrderAmbiguities::ignore`] function
+/// with an list of crates names as an argument.
+///
+/// ## Example
+/// ```
+/// # use bevy::prelude::*;
+/// #
+/// App::new()
+///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
+/// ```
 pub struct ReportExecutionOrderAmbiguities {
     pub level: AmbiguityReportLevel,
     pub ignore_crates: Vec<String>,
@@ -70,8 +83,7 @@ impl ReportExecutionOrderAmbiguities {
         }
     }
 
-    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This
-    /// the default behavior.
+    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This is the default behavior.
     pub fn minimal() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,

From 2d01a154a165154eb49850815aae797b245156f3 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 13:59:59 -0300
Subject: [PATCH 015/113] Added ambiguity_checker example

---
 Cargo.toml                        |  4 ++
 examples/ecs/ambiguity_checker.rs | 61 +++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 examples/ecs/ambiguity_checker.rs

diff --git a/Cargo.toml b/Cargo.toml
index 3f5c13b5109b7..83cc110256407 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -339,6 +339,10 @@ name = "custom_diagnostic"
 path = "examples/diagnostics/custom_diagnostic.rs"
 
 # ECS (Entity Component System)
+[[example]]
+name = "ambiguity_checker"
+path = "examples/ecs/ambiguity_checker.rs"
+
 [[example]]
 name = "ecs_guide"
 path = "examples/ecs/ecs_guide.rs"
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
new file mode 100644
index 0000000000000..89aa9833d930b
--- /dev/null
+++ b/examples/ecs/ambiguity_checker.rs
@@ -0,0 +1,61 @@
+use bevy::{ecs::schedule::ReportExecutionOrderAmbiguities, log::LogPlugin, prelude::*};
+
+fn main() {
+    App::new()
+        .add_plugin(LogPlugin)
+        .insert_resource(MyStartupResource(0))
+        .insert_resource(1i32)
+        // This resource allows to control how Ambiguity Checker will report unresolved ambiguities
+        // By default only a warning numbering the unresolved ambiguities count is show, but by
+        // explicitly setting it to verbose, a complete report is shown
+        .insert_resource(ReportExecutionOrderAmbiguities::verbose())
+        // startup_system_a and startup_system_b will both compete by the same resource. Since there is no ordering between
+        // both of them (like using .before or .after) there is no guarantee which one will take resource first.
+        // This ambiguity will be reported by Ambiguity Checker.
+        .add_startup_system(startup_system_a)
+        .add_startup_system(startup_system_b)
+        .insert_resource(MyResource(0))
+        // It is possible to mark a system as ambiguous if this is a intended behavior, so the ambiguity checker will ignore this system.
+        .add_system(system_a.ambiguous())
+        .add_system(system_b.label("my_label"))
+        // It is also possible to mark a system as ambiguous with a given label, so whenever ambiguity checker find a ambiguity between
+        // this system and anyone with the given label, it will ignore, since this is an intended behavior.
+        .add_system(system_c.ambiguous_with("my_label"))
+        // If a given set of systems all are ambiguous with each other and this is fine, one may create an ambiguity set, so all systems
+        // inside this ambiguity set will be ignored by ambiguity checker
+        .add_system(system_d.in_ambiguity_set("my_set"))
+        .add_system(system_e.in_ambiguity_set("my_set"))
+        .run();
+}
+
+struct MyStartupResource(i32);
+fn startup_system_a(mut res: ResMut<MyStartupResource>) {
+    res.0 += 1;
+}
+
+fn startup_system_b(mut res: ResMut<MyStartupResource>) {
+    res.0 += 1;
+}
+
+struct MyResource(i32);
+fn system_a(mut res: ResMut<MyResource>) {
+    res.0 += 1;
+}
+
+fn system_b(mut res: ResMut<MyResource>, mut another_res: ResMut<i32>) {
+    res.0 += 1;
+    *another_res += 1;
+}
+
+fn system_c(mut res: ResMut<MyResource>) {
+    res.0 += 1;
+}
+
+fn system_d(mut res: ResMut<MyResource>, mut another_res: ResMut<i32>) {
+    res.0 += 1;
+    *another_res += 1;
+}
+
+fn system_e(mut res: ResMut<MyResource>) {
+    res.0 += 1;
+}

From 3bbb669580ee399dc58c1d724b69b4aa450efcfb Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 14:03:31 -0300
Subject: [PATCH 016/113] Fixed typo on ReportExecutionOrderAmbiguities docs

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 148b37bebf793..495a56b731017 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -47,7 +47,7 @@ pub enum AmbiguityReportLevel {
 /// Some ambiguities reported by the ambiguity checker may be warranted (to allow two systems to run
 /// without blocking each other) or spurious, as the exact combination of archetypes used may
 /// prevent them from ever conflicting during actual gameplay. You can resolve the warnings produced
-/// by the ambiguity checker by adding .before or .after to one of the conflicting systems
+/// by the ambiguity checker by adding `.before` or `.after` to one of the conflicting systems
 /// referencing the other system to force a specific ordering.
 ///
 /// The checker may report a system more times than the amount of constraints it would actually need

From 36007e3db2f48010a60eb2d29be926325eaabf8a Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 14:12:39 -0300
Subject: [PATCH 017/113] Added example on README.md

---
 examples/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/README.md b/examples/README.md
index 000b0ce4ae858..0368d3d503b70 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -177,6 +177,7 @@ Example | File | Description
 
 Example | File | Description
 --- | --- | ---
+`ambiguity_checker` | [`ecs/ambiguity_checker.rs`](./ecs/ambiguity_checker.rs) | Shows how the ambiguity checker works
 `ecs_guide` | [`ecs/ecs_guide.rs`](./ecs/ecs_guide.rs) | Full guide to Bevy's ECS
 `component_change_detection` | [`ecs/component_change_detection.rs`](./ecs/component_change_detection.rs) | Change detection on components
 `custom_query_param` | [`ecs/custom_query_param.rs`](./ecs/custom_query_param.rs) | Groups commonly used compound queries and query filters into a single type

From ae0d6c89a16873585b30c28f46cf9e4a316eb356 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 14:43:46 -0300
Subject: [PATCH 018/113] Ignoring ReportExecutionOrderAmbiguities doc test
 since there is no bevy_app dependancy on bevy_ecs crate

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 495a56b731017..d25389b1331e0 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -63,9 +63,9 @@ pub enum AmbiguityReportLevel {
 /// with an list of crates names as an argument.
 ///
 /// ## Example
-/// ```
-/// # use bevy::prelude::*;
-/// #
+/// ```ignore
+/// # use bevy_app::App;
+/// # use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
 /// App::new()
 ///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
 /// ```

From 9b3cd44fe1e36291164f24320f4750d4a7348d19 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sat, 4 Sep 2021 20:28:38 -0300
Subject: [PATCH 019/113] Changed ambiguity_checker to use custom component
 instead of primitive components, since they will be removed in the future.

---
 examples/ecs/ambiguity_checker.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 89aa9833d930b..8947728127a2e 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -4,7 +4,6 @@ fn main() {
     App::new()
         .add_plugin(LogPlugin)
         .insert_resource(MyStartupResource(0))
-        .insert_resource(1i32)
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities
         // By default only a warning numbering the unresolved ambiguities count is show, but by
         // explicitly setting it to verbose, a complete report is shown
@@ -15,6 +14,7 @@ fn main() {
         .add_startup_system(startup_system_a)
         .add_startup_system(startup_system_b)
         .insert_resource(MyResource(0))
+        .insert_resource(MyAnotherResource(0))
         // It is possible to mark a system as ambiguous if this is a intended behavior, so the ambiguity checker will ignore this system.
         .add_system(system_a.ambiguous())
         .add_system(system_b.label("my_label"))
@@ -38,22 +38,24 @@ fn startup_system_b(mut res: ResMut<MyStartupResource>) {
 }
 
 struct MyResource(i32);
+struct MyAnotherResource(i32);
+
 fn system_a(mut res: ResMut<MyResource>) {
     res.0 += 1;
 }
 
-fn system_b(mut res: ResMut<MyResource>, mut another_res: ResMut<i32>) {
+fn system_b(mut res: ResMut<MyResource>, mut another_res: ResMut<MyAnotherResource>) {
     res.0 += 1;
-    *another_res += 1;
+    another_res.0 += 1;
 }
 
 fn system_c(mut res: ResMut<MyResource>) {
     res.0 += 1;
 }
 
-fn system_d(mut res: ResMut<MyResource>, mut another_res: ResMut<i32>) {
+fn system_d(mut res: ResMut<MyResource>, mut another_res: ResMut<MyAnotherResource>) {
     res.0 += 1;
-    *another_res += 1;
+    another_res.0 += 1;
 }
 
 fn system_e(mut res: ResMut<MyResource>) {

From 5170f46e353738805025d7c91291f15a25eb6273 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 5 Sep 2021 07:27:39 -0300
Subject: [PATCH 020/113] Moved ecs_guide to be the first example on ECS
 section

---
 examples/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/README.md b/examples/README.md
index 0368d3d503b70..458486e73bf52 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -177,8 +177,8 @@ Example | File | Description
 
 Example | File | Description
 --- | --- | ---
-`ambiguity_checker` | [`ecs/ambiguity_checker.rs`](./ecs/ambiguity_checker.rs) | Shows how the ambiguity checker works
 `ecs_guide` | [`ecs/ecs_guide.rs`](./ecs/ecs_guide.rs) | Full guide to Bevy's ECS
+`ambiguity_checker` | [`ecs/ambiguity_checker.rs`](./ecs/ambiguity_checker.rs) | Shows how the ambiguity checker works
 `component_change_detection` | [`ecs/component_change_detection.rs`](./ecs/component_change_detection.rs) | Change detection on components
 `custom_query_param` | [`ecs/custom_query_param.rs`](./ecs/custom_query_param.rs) | Groups commonly used compound queries and query filters into a single type
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception

From ad04d76f26a254f041bddabf20c81f58400456bf Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 5 Sep 2021 15:27:06 -0300
Subject: [PATCH 021/113] Added better example description on README.md

---
 examples/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/README.md b/examples/README.md
index 458486e73bf52..b973ac6088157 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -178,7 +178,7 @@ Example | File | Description
 Example | File | Description
 --- | --- | ---
 `ecs_guide` | [`ecs/ecs_guide.rs`](./ecs/ecs_guide.rs) | Full guide to Bevy's ECS
-`ambiguity_checker` | [`ecs/ambiguity_checker.rs`](./ecs/ambiguity_checker.rs) | Shows how the ambiguity checker works
+`ambiguity_checker` | [`ecs/ambiguity_checker.rs`](./ecs/ambiguity_checker.rs) | Shows how to use system order ambiguity checker
 `component_change_detection` | [`ecs/component_change_detection.rs`](./ecs/component_change_detection.rs) | Change detection on components
 `custom_query_param` | [`ecs/custom_query_param.rs`](./ecs/custom_query_param.rs) | Groups commonly used compound queries and query filters into a single type
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception

From f9a4b1f5add1305a4b724b1f578e443788bdd4df Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Mon, 6 Sep 2021 18:28:41 -0300
Subject: [PATCH 022/113] Apply suggestions from code review

Mostly spelling and phrasing suggestions.

Co-authored-by: Alexander Sepity <ratysz@gmail.com>
---
 crates/bevy_ecs/src/schedule/stage.rs         |  4 ++--
 .../src/schedule/system_descriptor.rs         |  8 +++----
 examples/ecs/ambiguity_checker.rs             | 22 +++++++++----------
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index d25389b1331e0..a8dd0553167bb 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -54,8 +54,8 @@ pub enum AmbiguityReportLevel {
 /// to have unambiguous order with regards to a group of already-constrained systems.
 ///
 /// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
-/// This behavior can be changed by explicit adding this resource using the following constructors:
-/// * [ReportExecutionOrderAmbiguities::off()] - Disables all messages reported by the ambiguity checker
+/// This behavior can be changed by explicitly adding this resource using the following constructors:
+/// * [ReportExecutionOrderAmbiguities::off()] - Disables all messages reported by the ambiguity checker.
 /// * [ReportExecutionOrderAmbiguities::minimal()] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
 /// * [ReportExecutionOrderAmbiguities::verbose()] - Displays a full report of ambiguities detected by the ambiguity checker.
 ///
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index a12733c662184..fcbb2e5ab981e 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -146,11 +146,11 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
     /// with other systems in this set.
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
 
-    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection
+    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
     fn ambiguous(self) -> ParallelSystemDescriptor;
 
     /// Specifies that the system is exempt from execution order ambiguity detection
-    /// with other systems with the given label
+    /// with other systems with the given label.
     fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
 }
 
@@ -335,11 +335,11 @@ pub trait ExclusiveSystemDescriptorCoercion {
     /// Specifies that the system should run with other exclusive systems at the end of stage.
     fn at_end(self) -> ExclusiveSystemDescriptor;
 
-    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection
+    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
     fn ambiguous(self) -> ExclusiveSystemDescriptor;
 
     /// Specifies that the system is exempt from execution order ambiguity detection
-    /// with other systems with the given label
+    /// with other systems with the given label.
     fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
 }
 
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 8947728127a2e..e3e1de079dc06 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -4,25 +4,25 @@ fn main() {
     App::new()
         .add_plugin(LogPlugin)
         .insert_resource(MyStartupResource(0))
-        // This resource allows to control how Ambiguity Checker will report unresolved ambiguities
-        // By default only a warning numbering the unresolved ambiguities count is show, but by
-        // explicitly setting it to verbose, a complete report is shown
+        // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
+        // By default only a warning with the amount of unresolved ambiguities is shown, but
+        // a more complete report will be displayed if we explicitly set this resource to verbose.
         .insert_resource(ReportExecutionOrderAmbiguities::verbose())
-        // startup_system_a and startup_system_b will both compete by the same resource. Since there is no ordering between
-        // both of them (like using .before or .after) there is no guarantee which one will take resource first.
-        // This ambiguity will be reported by Ambiguity Checker.
+        // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
+        // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.
+        // This ambiguity will be reported by ambiguity checker.
         .add_startup_system(startup_system_a)
         .add_startup_system(startup_system_b)
         .insert_resource(MyResource(0))
         .insert_resource(MyAnotherResource(0))
-        // It is possible to mark a system as ambiguous if this is a intended behavior, so the ambiguity checker will ignore this system.
+        // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
         .add_system(system_a.ambiguous())
         .add_system(system_b.label("my_label"))
-        // It is also possible to mark a system as ambiguous with a given label, so whenever ambiguity checker find a ambiguity between
-        // this system and anyone with the given label, it will ignore, since this is an intended behavior.
+        // It is also possible to mark a system as ambiguous with a specific other system,
+        // making the checker ignore any ambiguities between them.
         .add_system(system_c.ambiguous_with("my_label"))
-        // If a given set of systems all are ambiguous with each other and this is fine, one may create an ambiguity set, so all systems
-        // inside this ambiguity set will be ignored by ambiguity checker
+        // If there's an whole group of systems that are supposed to be ambiguous with each other,
+        // an ambiguity set can be used to make the checker ignore anything it detects between them.
         .add_system(system_d.in_ambiguity_set("my_set"))
         .add_system(system_e.in_ambiguity_set("my_set"))
         .run();

From eb1766607cfb81a21169ba8204ba31c821acf648 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Tue, 7 Sep 2021 04:50:08 -0300
Subject: [PATCH 023/113] Added doc hidden method include_bevy witch includes
 bevy internal crates

---
 crates/bevy_ecs/src/schedule/stage.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index a8dd0553167bb..8fe75dbfdb0b1 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -105,6 +105,12 @@ impl ReportExecutionOrderAmbiguities {
         }
         self
     }
+
+    #[doc(hidden)]
+    pub fn include_bevy(mut self) -> Self {
+        self.ignore_crates.retain(|s| !s.starts_with("bevy_"));
+        self
+    }
 }
 
 impl Default for ReportExecutionOrderAmbiguities {

From b19876b03689f2a3704a09cd972c83fe65078d85 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Tue, 7 Sep 2021 04:54:58 -0300
Subject: [PATCH 024/113] Added missing docs on
 ReportExecutionOrderAmbiguities.ignore

---
 crates/bevy_ecs/src/schedule/stage.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 8fe75dbfdb0b1..2adc2e642917d 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -99,6 +99,7 @@ impl ReportExecutionOrderAmbiguities {
         }
     }
 
+    /// Adds the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
     pub fn ignore(mut self, create_prefix: &[&str]) -> Self {
         for s in create_prefix {
             self.ignore_crates.push(s.to_string());

From 5da7a37d04daca908f13da8a1063e0d357b86a54 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Tue, 7 Sep 2021 04:59:22 -0300
Subject: [PATCH 025/113] Renamed ambigous method to silence_ambiguity_checks

---
 crates/bevy_ecs/src/schedule/stage.rs         | 27 ++++++++++++++-----
 .../src/schedule/system_descriptor.rs         | 20 +++++++-------
 examples/ecs/ambiguity_checker.rs             |  2 +-
 3 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 2adc2e642917d..3fb349667afe3 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -2132,7 +2132,7 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
-            .with_system(resource.label("1").after("0").ambiguous())
+            .with_system(resource.label("1").after("0").silence_ambiguity_checks())
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
@@ -2146,8 +2146,8 @@ mod tests {
         assert_eq!(ambiguities.len(), 1);
 
         let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").ambiguous())
-            .with_system(resource.label("1").after("0").ambiguous())
+            .with_system(component.label("0").silence_ambiguity_checks())
+            .with_system(resource.label("1").after("0").silence_ambiguity_checks())
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
@@ -2158,11 +2158,26 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(empty.exclusive_system().label("1").ambiguous())
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("1")
+                    .silence_ambiguity_checks(),
+            )
             .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3").ambiguous())
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("3")
+                    .silence_ambiguity_checks(),
+            )
             .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(empty.exclusive_system().label("5").ambiguous())
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("5")
+                    .silence_ambiguity_checks(),
+            )
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index fcbb2e5ab981e..0712293aa0a34 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -147,7 +147,7 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
 
     /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
-    fn ambiguous(self) -> ParallelSystemDescriptor;
+    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor;
 
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems with the given label.
@@ -183,7 +183,7 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self
     }
 
-    fn ambiguous(mut self) -> ParallelSystemDescriptor {
+    fn silence_ambiguity_checks(mut self) -> ParallelSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
@@ -230,8 +230,8 @@ where
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).in_ambiguity_set(set)
     }
 
-    fn ambiguous(self) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).ambiguous()
+    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(self.system())).silence_ambiguity_checks()
     }
 
     fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
@@ -263,8 +263,8 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
         new_parallel_descriptor(self).in_ambiguity_set(set)
     }
 
-    fn ambiguous(self) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).ambiguous()
+    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(self).silence_ambiguity_checks()
     }
 
     fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
@@ -336,7 +336,7 @@ pub trait ExclusiveSystemDescriptorCoercion {
     fn at_end(self) -> ExclusiveSystemDescriptor;
 
     /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
-    fn ambiguous(self) -> ExclusiveSystemDescriptor;
+    fn silence_ambiguity_checks(self) -> ExclusiveSystemDescriptor;
 
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems with the given label.
@@ -387,7 +387,7 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self
     }
 
-    fn ambiguous(mut self) -> ExclusiveSystemDescriptor {
+    fn silence_ambiguity_checks(mut self) -> ExclusiveSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
@@ -445,8 +445,8 @@ where
         new_exclusive_descriptor(Box::new(self)).at_end()
     }
 
-    fn ambiguous(self) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).ambiguous()
+    fn silence_ambiguity_checks(self) -> ExclusiveSystemDescriptor {
+        new_exclusive_descriptor(Box::new(self)).silence_ambiguity_checks()
     }
 
     fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index e3e1de079dc06..23d52906c9eee 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -16,7 +16,7 @@ fn main() {
         .insert_resource(MyResource(0))
         .insert_resource(MyAnotherResource(0))
         // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
-        .add_system(system_a.ambiguous())
+        .add_system(system_a.silence_ambiguity_checks())
         .add_system(system_b.label("my_label"))
         // It is also possible to mark a system as ambiguous with a specific other system,
         // making the checker ignore any ambiguities between them.

From a00684529aa590fbff7d19c1446169d3e3cb0ba5 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Tue, 7 Sep 2021 05:11:17 -0300
Subject: [PATCH 026/113] Supress the hint message if the
 ReportExecutionOrderAmbiguities is already verbose

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 3fb349667afe3..d01cb5d1c412e 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -634,7 +634,13 @@ impl SystemStage {
         unresolved_count += at_end.len();
 
         if unresolved_count > 0 {
-            warn!("{} unresolved ambiguities detected. Set the level of the ReportExecutionOrderAmbiguities resource to AmbiguityReportLevel::Verbose for more details.", unresolved_count);
+            let mut details = String::from("");
+
+            if ambiguity_report.level != AmbiguityReportLevel::Verbose {
+                write!(details, " Set the level of the ReportExecutionOrderAmbiguities resource to AmbiguityReportLevel::Verbose for more details.").unwrap();
+            }
+
+            warn!("{} unresolved ambiguities detected.{}", unresolved_count, &details);
         }
 
         if !(parallel.is_empty()

From 4aa6cc9d7ae436f1cb75ae3db368cc802da813e8 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Tue, 7 Sep 2021 09:40:46 -0300
Subject: [PATCH 027/113] Typo suggestion fix

Co-authored-by: Alexander Sepity <ratysz@gmail.com>
---
 crates/bevy_ecs/src/schedule/stage.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index d01cb5d1c412e..8c8c696f77b7d 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -613,7 +613,7 @@ impl SystemStage {
 
                 writeln!(
                     string,
-                    "{}.{} - Systems:\n     {:?}\n   - Conflicts on the following components/resources:\n     {:?}",
+                    "{}.{} - Systems:\n     {:?}\n   - Conflict on the following components/resources:\n     {:?}",
                     output_prefix, idx, system_names, system_components
                 )
                 .unwrap();

From 0837a3474a04e641d33daaf0fea98a2642c54f0b Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Wed, 8 Sep 2021 16:04:27 -0300
Subject: [PATCH 028/113] Fixed formating

---
 crates/bevy_ecs/src/schedule/stage.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 8c8c696f77b7d..93046d2f69ba3 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -640,7 +640,10 @@ impl SystemStage {
                 write!(details, " Set the level of the ReportExecutionOrderAmbiguities resource to AmbiguityReportLevel::Verbose for more details.").unwrap();
             }
 
-            warn!("{} unresolved ambiguities detected.{}", unresolved_count, &details);
+            warn!(
+                "{} unresolved ambiguities detected.{}",
+                unresolved_count, &details
+            );
         }
 
         if !(parallel.is_empty()

From 5e53970aa9d21c2be73cffdf9801e86dc21c4a6c Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Wed, 8 Sep 2021 16:24:31 -0300
Subject: [PATCH 029/113] Explicitly added bevy internal crates names, in order
 to avoid conflusion with third party crates with bevy_ prefix names

---
 crates/bevy_ecs/src/schedule/stage.rs | 118 +++++++++++++++++++++++++-
 1 file changed, 116 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 93046d2f69ba3..ba8e0ca7f389e 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -74,6 +74,119 @@ pub struct ReportExecutionOrderAmbiguities {
     pub ignore_crates: Vec<String>,
 }
 
+const BEVY_CRATES: [&str; 110] = [
+    "bevy_app",
+    "bevy_asset",
+    "bevy_audio",
+    "bevy_core",
+    "bevy_derive",
+    "bevy_diagnostic",
+    "bevy_dylib",
+    "bevy_dynamic_plugin",
+    "bevy_ecs",
+    "bevy_gilrs",
+    "bevy_gltf",
+    "bevy_input",
+    "bevy_internal",
+    "bevy_log",
+    "bevy_macro_utils",
+    "bevy_math",
+    "bevy_pbr",
+    "bevy_reflect",
+    "bevy_render",
+    "bevy_scene",
+    "bevy_sprite",
+    "bevy_tasks",
+    "bevy_text",
+    "bevy_transform",
+    "bevy_ui",
+    "bevy_utils",
+    "bevy_wgpu",
+    "bevy_window",
+    "bevy_winit",
+    "bevy_ai",
+    "bevy_android",
+    "bevy_animation",
+    "bevy_async",
+    "bevy_base",
+    "bevy_bounds",
+    "bevy_box2d",
+    "bevy_bullet",
+    "bevy_camera",
+    "bevy_cli",
+    "bevy_collision",
+    "bevy_controller",
+    "bevy_csharp",
+    "bevy_curve",
+    "bevy_demo",
+    "bevy_editor",
+    "bevy_egui",
+    "bevy_event",
+    "bevy_executor",
+    "bevy_extra",
+    "bevy_game",
+    "bevy_geometry",
+    "bevy_gizmo",
+    "bevy_gizmos",
+    "bevy_gpu",
+    "bevy_ik",
+    "bevy_imgui",
+    "bevy_ios",
+    "bevy_jobs",
+    "bevy_joystick",
+    "bevy_js",
+    "bevy_kernel",
+    "bevy_library",
+    "bevy_lighting",
+    "bevy_log",
+    "bevy_lua",
+    "bevy_marketplace",
+    "bevy_navmesh",
+    "bevy_net",
+    "bevy_node_graph",
+    "bevy_nodes",
+    "bevy_nphysics",
+    "bevy_particles",
+    "bevy_pathing",
+    "bevy_physics",
+    "bevy_physx",
+    "bevy_picking",
+    "bevy_playstation",
+    "bevy_prefab",
+    "bevy_project",
+    "bevy_raycast",
+    "bevy_raytracing",
+    "bevy_rustgpu",
+    "bevy_script",
+    "bevy_scripting",
+    "bevy_sdf",
+    "bevy_sdl2",
+    "bevy_shape",
+    "bevy_shapes",
+    "bevy_skeleton",
+    "bevy_spirv",
+    "bevy_store",
+    "bevy_streaming",
+    "bevy_switch",
+    "bevy_system",
+    "bevy_test",
+    "bevy_thread",
+    "bevy_tile",
+    "bevy_tiled",
+    "bevy_tools",
+    "bevy_util",
+    "bevy_vfx",
+    "bevy_visibility",
+    "bevy_voxel",
+    "bevy_vr",
+    "bevy_web",
+    "bevy_websocket",
+    "bevy_widget",
+    "bevy_widgets",
+    "bevy_xbox",
+    "bevy_xr",
+];
+
 impl ReportExecutionOrderAmbiguities {
     /// Disables all messages reported by the ambiguity checker.
     pub fn off() -> Self {
@@ -109,7 +222,8 @@ impl ReportExecutionOrderAmbiguities {
 
     #[doc(hidden)]
     pub fn include_bevy(mut self) -> Self {
-        self.ignore_crates.retain(|s| !s.starts_with("bevy_"));
+        self.ignore_crates
+            .retain(|s| !BEVY_CRATES.iter().any(|&str| s.as_str() == str));
         self
     }
 }
@@ -118,7 +232,7 @@ impl Default for ReportExecutionOrderAmbiguities {
     fn default() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,
-            ignore_crates: vec!["bevy_".into()],
+            ignore_crates: BEVY_CRATES.iter().map(|&s| s.to_string()).collect(),
         }
     }
 }

From 3487c47894682736db1d6cf5770588be01066d34 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Wed, 8 Sep 2021 16:48:09 -0300
Subject: [PATCH 030/113] Ambiguity checker ignores conflicts only between
 crates inside the crate ignored list

---
 crates/bevy_ecs/src/schedule/stage.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index ba8e0ca7f389e..540b1ee4e2f70 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -958,9 +958,8 @@ fn find_ambiguities(
             AmbiguityDetection::IgnoreWithLabel(labels) => {
                 labels.iter().any(|l| system_a.labels().contains(l))
             }
-        }) || crates_filter
-            .iter()
-            .any(|s| system_a.name().starts_with(s) || system_b.name().starts_with(s))
+        }) || (crates_filter.iter().any(|s| system_a.name().starts_with(s))
+            && crates_filter.iter().any(|s| system_b.name().starts_with(s)))
     }
 
     let mut ambiguity_set_labels = HashMap::default();

From fb1dffb4f0b2091cc546297baaabcc3a31837af0 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Wed, 8 Sep 2021 17:34:38 -0300
Subject: [PATCH 031/113] Fixed ambiguity tests error due to new ambiguity
 check behavior

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 540b1ee4e2f70..bfd83ff937963 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -2340,7 +2340,7 @@ mod tests {
             &stage.parallel,
             &["bevy_ecs::schedule::stage::tests::ambiguity_detection::inner::".into()],
         );
-        assert_eq!(ambiguities.len(), 0);
+        assert_eq!(ambiguities.len(), 1);
     }
 
     #[test]

From b746726c0160488dc8f46f3e1a8634eaa8281104 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Wed, 8 Sep 2021 17:37:05 -0300
Subject: [PATCH 032/113] Apply suggestions from code review

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_ecs/src/schedule/stage.rs | 5 +++--
 examples/ecs/ambiguity_checker.rs     | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index bfd83ff937963..5226f9d94c499 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -59,8 +59,9 @@ pub enum AmbiguityReportLevel {
 /// * [ReportExecutionOrderAmbiguities::minimal()] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
 /// * [ReportExecutionOrderAmbiguities::verbose()] - Displays a full report of ambiguities detected by the ambiguity checker.
 ///
-/// The ambiguity checker will ignore all crates starting with "bevy_". To ignore a custom crate, just call [`ReportExecutionOrderAmbiguities::ignore`] function
-/// with an list of crates names as an argument.
+/// The ambiguity checker will ignore ambiguities within official Bevy crates. 
+/// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
+/// with an list of crate names as an argument.
 ///
 /// ## Example
 /// ```ignore
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 23d52906c9eee..dbe3ba1bcf6f2 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -5,7 +5,7 @@ fn main() {
         .add_plugin(LogPlugin)
         .insert_resource(MyStartupResource(0))
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
-        // By default only a warning with the amount of unresolved ambiguities is shown, but
+        // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
         .insert_resource(ReportExecutionOrderAmbiguities::verbose())
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between

From 85a6663e22205b99ab59643b523a82587ace7f65 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Wed, 8 Sep 2021 17:37:41 -0300
Subject: [PATCH 033/113] Fixed formatting

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 5226f9d94c499..973908585477b 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -59,7 +59,7 @@ pub enum AmbiguityReportLevel {
 /// * [ReportExecutionOrderAmbiguities::minimal()] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
 /// * [ReportExecutionOrderAmbiguities::verbose()] - Displays a full report of ambiguities detected by the ambiguity checker.
 ///
-/// The ambiguity checker will ignore ambiguities within official Bevy crates. 
+/// The ambiguity checker will ignore ambiguities within official Bevy crates.
 /// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
 /// with an list of crate names as an argument.
 ///

From cf08855e328212d83c8def3a35a8eae7371b6062 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Fri, 10 Sep 2021 10:16:23 -0300
Subject: [PATCH 034/113] Removed bevy_egui from BEVY_CRATES

---
 crates/bevy_ecs/src/schedule/stage.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 973908585477b..de103aa9658ce 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -121,7 +121,6 @@ const BEVY_CRATES: [&str; 110] = [
     "bevy_curve",
     "bevy_demo",
     "bevy_editor",
-    "bevy_egui",
     "bevy_event",
     "bevy_executor",
     "bevy_extra",

From ea27bd98d3b81a639eb87665274353aa62507aaf Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Fri, 10 Sep 2021 10:23:46 -0300
Subject: [PATCH 035/113] Fixed BEVY_CRATES array size

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index de103aa9658ce..ad9caac87bc8d 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -75,7 +75,7 @@ pub struct ReportExecutionOrderAmbiguities {
     pub ignore_crates: Vec<String>,
 }
 
-const BEVY_CRATES: [&str; 110] = [
+const BEVY_CRATES: [&str; 109] = [
     "bevy_app",
     "bevy_asset",
     "bevy_audio",

From d058e35120a95d58acc5054972220f379c2b420b Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Fri, 10 Sep 2021 10:24:28 -0300
Subject: [PATCH 036/113] Added instructions to add new crates to BEVY_CRATES
 array

---
 CONTRIBUTING.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3cc5ce4031315..5640791ab83d5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -260,6 +260,7 @@ If you end up adding a new official Bevy crate to the `bevy` repo:
 
 1. Add the new crate to the [./tools/publish.sh](./tools/publish.sh) file.
 2. Check if a new cargo feature was added, update [cargo_features.md](https://github.com/bevyengine/bevy/blob/main/docs/cargo_features.md) as needed.
+3. Add the new crate to the [stage::BEVY_CRATES](./crates/bevy_ecs/src/schedule/stage.rs) array.
 
 When contributing, please:
 

From f152eb4ca023000fea0e5a5bd8674a99fdaf22be Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 12 Sep 2021 19:24:33 -0300
Subject: [PATCH 037/113] Fixed typo on ReportExecutionOrderAmbiguities ignore
 function

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

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index ad9caac87bc8d..2b33aa7db83a6 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -213,8 +213,8 @@ impl ReportExecutionOrderAmbiguities {
     }
 
     /// Adds the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
-    pub fn ignore(mut self, create_prefix: &[&str]) -> Self {
-        for s in create_prefix {
+    pub fn ignore(mut self, crate_prefix: &[&str]) -> Self {
+        for s in crate_prefix {
             self.ignore_crates.push(s.to_string());
         }
         self

From f8c0a7b2478ff57c843e6d0711f7e03523383ea2 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 12 Sep 2021 19:27:53 -0300
Subject: [PATCH 038/113] Removed BEVY_CRATES const array

---
 crates/bevy_ecs/src/schedule/stage.rs | 131 ++------------------------
 1 file changed, 9 insertions(+), 122 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 2b33aa7db83a6..0b563d1e26f71 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -75,118 +75,6 @@ pub struct ReportExecutionOrderAmbiguities {
     pub ignore_crates: Vec<String>,
 }
 
-const BEVY_CRATES: [&str; 109] = [
-    "bevy_app",
-    "bevy_asset",
-    "bevy_audio",
-    "bevy_core",
-    "bevy_derive",
-    "bevy_diagnostic",
-    "bevy_dylib",
-    "bevy_dynamic_plugin",
-    "bevy_ecs",
-    "bevy_gilrs",
-    "bevy_gltf",
-    "bevy_input",
-    "bevy_internal",
-    "bevy_log",
-    "bevy_macro_utils",
-    "bevy_math",
-    "bevy_pbr",
-    "bevy_reflect",
-    "bevy_render",
-    "bevy_scene",
-    "bevy_sprite",
-    "bevy_tasks",
-    "bevy_text",
-    "bevy_transform",
-    "bevy_ui",
-    "bevy_utils",
-    "bevy_wgpu",
-    "bevy_window",
-    "bevy_winit",
-    "bevy_ai",
-    "bevy_android",
-    "bevy_animation",
-    "bevy_async",
-    "bevy_base",
-    "bevy_bounds",
-    "bevy_box2d",
-    "bevy_bullet",
-    "bevy_camera",
-    "bevy_cli",
-    "bevy_collision",
-    "bevy_controller",
-    "bevy_csharp",
-    "bevy_curve",
-    "bevy_demo",
-    "bevy_editor",
-    "bevy_event",
-    "bevy_executor",
-    "bevy_extra",
-    "bevy_game",
-    "bevy_geometry",
-    "bevy_gizmo",
-    "bevy_gizmos",
-    "bevy_gpu",
-    "bevy_ik",
-    "bevy_imgui",
-    "bevy_ios",
-    "bevy_jobs",
-    "bevy_joystick",
-    "bevy_js",
-    "bevy_kernel",
-    "bevy_library",
-    "bevy_lighting",
-    "bevy_log",
-    "bevy_lua",
-    "bevy_marketplace",
-    "bevy_navmesh",
-    "bevy_net",
-    "bevy_node_graph",
-    "bevy_nodes",
-    "bevy_nphysics",
-    "bevy_particles",
-    "bevy_pathing",
-    "bevy_physics",
-    "bevy_physx",
-    "bevy_picking",
-    "bevy_playstation",
-    "bevy_prefab",
-    "bevy_project",
-    "bevy_raycast",
-    "bevy_raytracing",
-    "bevy_rustgpu",
-    "bevy_script",
-    "bevy_scripting",
-    "bevy_sdf",
-    "bevy_sdl2",
-    "bevy_shape",
-    "bevy_shapes",
-    "bevy_skeleton",
-    "bevy_spirv",
-    "bevy_store",
-    "bevy_streaming",
-    "bevy_switch",
-    "bevy_system",
-    "bevy_test",
-    "bevy_thread",
-    "bevy_tile",
-    "bevy_tiled",
-    "bevy_tools",
-    "bevy_util",
-    "bevy_vfx",
-    "bevy_visibility",
-    "bevy_voxel",
-    "bevy_vr",
-    "bevy_web",
-    "bevy_websocket",
-    "bevy_widget",
-    "bevy_widgets",
-    "bevy_xbox",
-    "bevy_xr",
-];
-
 impl ReportExecutionOrderAmbiguities {
     /// Disables all messages reported by the ambiguity checker.
     pub fn off() -> Self {
@@ -212,18 +100,17 @@ impl ReportExecutionOrderAmbiguities {
         }
     }
 
-    /// Adds the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
-    pub fn ignore(mut self, crate_prefix: &[&str]) -> Self {
-        for s in crate_prefix {
-            self.ignore_crates.push(s.to_string());
-        }
+    /// Adds the given crate to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
+    pub fn ignore(mut self, crate_prefix: &str) -> Self {
+        self.ignore_crates.push(crate_prefix.to_string());
         self
     }
 
-    #[doc(hidden)]
-    pub fn include_bevy(mut self) -> Self {
-        self.ignore_crates
-            .retain(|s| !BEVY_CRATES.iter().any(|&str| s.as_str() == str));
+    /// Adds all the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
+    pub fn ignore_all(mut self, crate_prefixes: &[&str]) -> Self {
+        for s in crate_prefixes {
+            self.ignore_crates.push(s.to_string());
+        }
         self
     }
 }
@@ -232,7 +119,7 @@ impl Default for ReportExecutionOrderAmbiguities {
     fn default() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,
-            ignore_crates: BEVY_CRATES.iter().map(|&s| s.to_string()).collect(),
+            ignore_crates: vec![],
         }
     }
 }

From 063445fb2ff6674603172645cb01d11f3005ab84 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 12 Sep 2021 19:53:15 -0300
Subject: [PATCH 039/113] Added ignore crate on plugins of bevy_audio,
 bevy_render, bevy_sprites, bevy_text, bevy_ui, bevy_transform, bevy_winit

---
 crates/bevy_audio/src/lib.rs     |  7 ++++++-
 crates/bevy_render/src/lib.rs    |  5 +++++
 crates/bevy_sprite/src/lib.rs    | 14 +++++++++++++-
 crates/bevy_text/src/lib.rs      |  5 +++++
 crates/bevy_transform/src/lib.rs |  5 +++++
 crates/bevy_ui/src/lib.rs        |  9 ++++++++-
 crates/bevy_winit/src/lib.rs     |  6 ++++++
 7 files changed, 48 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 5aa23f7aa5fd6..6085f055193d1 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -44,7 +44,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::system::IntoExclusiveSystem;
+use bevy_ecs::{schedule::ReportExecutionOrderAmbiguities, system::IntoExclusiveSystem};
 
 /// Adds support for audio playback to a Bevy Application
 ///
@@ -65,5 +65,10 @@ impl Plugin for AudioPlugin {
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
         app.init_asset_loader::<AudioLoader>();
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_audio".to_string());
     }
 }
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 5d7127c0ce7b1..190c64038bc46 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -286,6 +286,11 @@ impl Plugin for RenderPlugin {
             // NOTE: Load this after renderer initialization so that it knows about the supported
             // compressed texture formats
             .add_plugin(ImagePlugin);
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_render".to_string());
     }
 }
 
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index b24833d52c0ef..bdf1c6e800832 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -31,7 +31,14 @@ pub use texture_atlas_builder::*;
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, HandleUntyped};
 use bevy_core_pipeline::Transparent2d;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::{
+    schedule::{ParallelSystemDescriptorCoercion, SystemLabel, ReportExecutionOrderAmbiguities},
+use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
+use bevy_ecs::{
+    component::{ComponentDescriptor, StorageType},
+    schedule::ReportExecutionOrderAmbiguities,
+};
+use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     render_phase::AddRenderCommand,
@@ -77,5 +84,10 @@ impl Plugin for SpritePlugin {
                 .add_system_to_stage(RenderStage::Extract, render::extract_sprite_events)
                 .add_system_to_stage(RenderStage::Queue, queue_sprites);
         };
+        
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_sprite".to_string());
     }
 }
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index 6ed6009ad7a44..a2b5b34436d5b 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -54,5 +54,10 @@ impl Plugin for TextPlugin {
                 extract_text2d_sprite.after(SpriteSystem::ExtractSprites),
             );
         }
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_text".to_string());
     }
 }
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index a88017c7d7d60..24b95e84ddf73 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -105,5 +105,10 @@ impl Plugin for TransformPlugin {
                     .label(TransformSystem::TransformPropagate)
                     .after(HierarchySystem::ParentUpdate),
             );
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_transform".to_string());
     }
 }
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 872a2bb9eef85..fc1379c4c7ef6 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -24,7 +24,9 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::schedule::{
+    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
+};
 use bevy_input::InputSystem;
 use bevy_math::{Rect, Size};
 use bevy_transform::TransformSystem;
@@ -105,5 +107,10 @@ impl Plugin for UiPlugin {
             );
 
         crate::render::build_ui_render(app);
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_ui".to_string());
     }
 }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 41b952aa65115..e67efe74d500f 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -43,9 +43,15 @@ impl Plugin for WinitPlugin {
             .init_resource::<WinitSettings>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
+        
         let event_loop = EventLoop::new();
         handle_initial_window_events(&mut app.world, &event_loop);
         app.insert_non_send_resource(event_loop);
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_winit".to_string());
     }
 }
 

From d1fb419c5d9b4d2a851691473d6fc9a0da89e77a Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 12 Sep 2021 19:56:07 -0300
Subject: [PATCH 040/113] Updated ambiguity_checker example

---
 examples/ecs/ambiguity_checker.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index dbe3ba1bcf6f2..6c9b1fa0a76d4 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -2,12 +2,13 @@ use bevy::{ecs::schedule::ReportExecutionOrderAmbiguities, log::LogPlugin, prelu
 
 fn main() {
     App::new()
-        .add_plugin(LogPlugin)
-        .insert_resource(MyStartupResource(0))
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
+        // This resource should be added before any bevy internal plugin.
         .insert_resource(ReportExecutionOrderAmbiguities::verbose())
+        .add_plugin(LogPlugin)
+        .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
         // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.
         // This ambiguity will be reported by ambiguity checker.

From 9b6bb099df0b612f8f06d8b3ce07d99426271fc4 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 12 Sep 2021 19:58:13 -0300
Subject: [PATCH 041/113] Updated ReportExecutionOrderAmbiguities docs

---
 crates/bevy_ecs/src/schedule/stage.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 0b563d1e26f71..9551e1dcdb31a 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -62,6 +62,7 @@ pub enum AmbiguityReportLevel {
 /// The ambiguity checker will ignore ambiguities within official Bevy crates.
 /// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
 /// with an list of crate names as an argument.
+/// This resource should be added before any bevy internal plugin.
 ///
 /// ## Example
 /// ```ignore

From a5371f0b3a8ab74edd25396169e69c39f94a5780 Mon Sep 17 00:00:00 2001
From: Afonso Lage <lage.afonso@gmail.com>
Date: Sun, 12 Sep 2021 20:05:05 -0300
Subject: [PATCH 042/113] Removed the information of BEVY_CRATES from
 CONTRIBUTING.md, since it doesn't exists anymore

---
 CONTRIBUTING.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5640791ab83d5..3cc5ce4031315 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -260,7 +260,6 @@ If you end up adding a new official Bevy crate to the `bevy` repo:
 
 1. Add the new crate to the [./tools/publish.sh](./tools/publish.sh) file.
 2. Check if a new cargo feature was added, update [cargo_features.md](https://github.com/bevyengine/bevy/blob/main/docs/cargo_features.md) as needed.
-3. Add the new crate to the [stage::BEVY_CRATES](./crates/bevy_ecs/src/schedule/stage.rs) array.
 
 When contributing, please:
 

From fcf14d7d3fda9a3e18f8c00b9026a138fa01ab33 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 00:14:50 -0400
Subject: [PATCH 043/113] Fix up rebase

---
 crates/bevy_ecs/src/schedule/system_descriptor.rs |  4 ++--
 crates/bevy_render/src/lib.rs                     |  1 +
 crates/bevy_sprite/src/lib.rs                     | 11 +++--------
 crates/bevy_text/src/lib.rs                       |  5 ++++-
 crates/bevy_transform/src/lib.rs                  |  1 +
 crates/bevy_winit/src/lib.rs                      |  3 ++-
 6 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 0712293aa0a34..36e01b3ce358e 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -231,11 +231,11 @@ where
     }
 
     fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).silence_ambiguity_checks()
+        new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).silence_ambiguity_checks()
     }
 
     fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).ambiguous_with(label)
+        new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).ambiguous_with(label)
     }
 }
 
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 190c64038bc46..d1b62177b0c77 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -46,6 +46,7 @@ use crate::{
 use bevy_app::{App, AppLabel, Plugin};
 use bevy_asset::{AddAsset, AssetServer};
 use bevy_ecs::prelude::*;
+use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
 use std::ops::{Deref, DerefMut};
 
 /// Contains the default Bevy rendering backend based on wgpu.
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index bdf1c6e800832..30367cfb0913c 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -31,14 +31,9 @@ pub use texture_atlas_builder::*;
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, HandleUntyped};
 use bevy_core_pipeline::Transparent2d;
-use bevy_ecs::{
-    schedule::{ParallelSystemDescriptorCoercion, SystemLabel, ReportExecutionOrderAmbiguities},
-use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::{
-    component::{ComponentDescriptor, StorageType},
-    schedule::ReportExecutionOrderAmbiguities,
+use bevy_ecs::schedule::{
+    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
 };
-use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     render_phase::AddRenderCommand,
@@ -84,7 +79,7 @@ impl Plugin for SpritePlugin {
                 .add_system_to_stage(RenderStage::Extract, render::extract_sprite_events)
                 .add_system_to_stage(RenderStage::Queue, queue_sprites);
         };
-        
+
         app.world
             .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
             .ignore_crates
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index a2b5b34436d5b..da8cc233be09f 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -28,7 +28,10 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{entity::Entity, schedule::ParallelSystemDescriptorCoercion};
+use bevy_ecs::{
+    entity::Entity,
+    schedule::{ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities},
+};
 use bevy_render::{RenderApp, RenderStage};
 use bevy_sprite::SpriteSystem;
 
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index 24b95e84ddf73..fba5134b115da 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -14,6 +14,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
+use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
 use bevy_hierarchy::HierarchySystem;
 use prelude::{GlobalTransform, Transform};
 
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index e67efe74d500f..925e90d2a065e 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -13,6 +13,7 @@ pub use winit_windows::*;
 use bevy_app::{App, AppExit, CoreStage, Plugin};
 use bevy_ecs::{
     event::{Events, ManualEventReader},
+    schedule::ReportExecutionOrderAmbiguities,
     system::IntoExclusiveSystem,
     world::World,
 };
@@ -43,7 +44,7 @@ impl Plugin for WinitPlugin {
             .init_resource::<WinitSettings>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
-        
+
         let event_loop = EventLoop::new();
         handle_initial_window_events(&mut app.world, &event_loop);
         app.insert_non_send_resource(event_loop);

From 1b919cdc90473043fff73c42df46131e8938d4a0 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 00:22:53 -0400
Subject: [PATCH 044/113] Add default for AmbiguityDetection enum

---
 crates/bevy_ecs/src/schedule/system_descriptor.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 36e01b3ce358e..6ec0902ded384 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -96,12 +96,24 @@ impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
     }
 }
 
+/// Whether or not system order ambiguities should be reported for this specific system
+///
+/// See the methods on [`ParallelSystemDescriptor`] to set this for a given system.
+///
+/// The overall behavior is configured using the
+/// [`ReportExecutionOrderAmbiguities`](crate::schedule::ReportExecutionOrderAmbiguities) resource.
 pub enum AmbiguityDetection {
     Check,
     Ignore,
     IgnoreWithLabel(Vec<BoxedSystemLabel>),
 }
 
+impl Default for AmbiguityDetection {
+    fn default() -> Self {
+        AmbiguityDetection::Check
+    }
+}
+
 /// Encapsulates a parallel system and information on when it runs in a `SystemStage`.
 pub struct ParallelSystemDescriptor {
     pub(crate) system: BoxedSystem<(), ()>,

From 61251bdc441165bbbcfeb448c90000b655030faf Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 01:10:47 -0400
Subject: [PATCH 045/113] Simplify and clarify execution order reporting

---
 crates/bevy_ecs/src/schedule/stage.rs | 116 ++++++++------------------
 1 file changed, 33 insertions(+), 83 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 9551e1dcdb31a..3c4fbcdb7b1e3 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -11,10 +11,7 @@ use crate::{
     },
     world::{World, WorldId},
 };
-use bevy_utils::{
-    tracing::{info, warn},
-    HashMap, HashSet,
-};
+use bevy_utils::{HashMap, HashSet};
 use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::fmt::Debug;
@@ -579,47 +576,36 @@ impl SystemStage {
         }
 
         debug_assert!(!self.systems_modified);
-        use std::fmt::Write;
+
         fn write_display_names_of_pairs(
-            string: &mut String,
+            offset: usize,
             systems: &[impl SystemContainer],
-            mut ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
+            ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
             world: &World,
-            output_prefix: &str,
-        ) {
-            use std::collections::hash_map;
-
-            let mut ambiguities_map: hash_map::HashMap<Vec<ComponentId>, Vec<usize>> =
-                hash_map::HashMap::new();
-
-            for (index_a, index_b, components) in ambiguities.drain(..) {
-                let systems = ambiguities_map.entry(components).or_default();
-                if !systems.contains(&index_a) {
-                    systems.push(index_a);
-                }
-                if !systems.contains(&index_b) {
-                    systems.push(index_b);
-                }
+        ) -> usize {
+            if ambiguities.is_empty() {
+                return offset;
             }
 
-            for (idx, (conflicts, systems_indices)) in ambiguities_map.drain().enumerate() {
-                let system_names = systems_indices
-                    .iter()
-                    .map(|index| systems[*index].name())
-                    .collect::<Vec<_>>();
+            for (i, (system_a_index, system_b_index, conflicting_indexes)) in
+                ambiguities.iter().enumerate()
+            {
+                let _system_a_name = systems[*system_a_index].name();
+                let _system_b_name = systems[*system_b_index].name();
 
-                let system_components = conflicts
+                let _conflicting_components = conflicting_indexes
                     .iter()
                     .map(|id| world.components().get_info(*id).unwrap().name())
                     .collect::<Vec<_>>();
 
-                writeln!(
-                    string,
-                    "{}.{} - Systems:\n     {:?}\n   - Conflict on the following components/resources:\n     {:?}",
-                    output_prefix, idx, system_names, system_components
-                )
-                .unwrap();
+                let _ambiguity_number = i + offset;
+
+                println!(
+                    "{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicting_components:?}"
+                );
             }
+
+            return ambiguities.len();
         }
 
         let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);
@@ -636,62 +622,26 @@ impl SystemStage {
         unresolved_count += at_end.len();
 
         if unresolved_count > 0 {
-            let mut details = String::from("");
+            println!("{unresolved_count} unresolved system order ambiguities detected in one of your stages: you might want to \
+            add an explicit system ordering between some of these systems to avoid logic errors. \n");
 
             if ambiguity_report.level != AmbiguityReportLevel::Verbose {
-                write!(details, " Set the level of the ReportExecutionOrderAmbiguities resource to AmbiguityReportLevel::Verbose for more details.").unwrap();
-            }
-
-            warn!(
-                "{} unresolved ambiguities detected.{}",
-                unresolved_count, &details
-            );
-        }
-
-        if !(parallel.is_empty()
-            && at_start.is_empty()
-            && before_commands.is_empty()
-            && at_end.is_empty())
-            && ambiguity_report.level == AmbiguityReportLevel::Verbose
-        {
-            let mut string = "Execution order ambiguities detected, you might want to \
-                    add an explicit dependency relation between some of these systems:\n"
-                .to_owned();
-            if !parallel.is_empty() {
-                writeln!(string, "1. Parallel systems:").unwrap();
-                write_display_names_of_pairs(&mut string, &self.parallel, parallel, world, "1");
-            }
-            if !at_start.is_empty() {
-                writeln!(string, "2. Exclusive systems at start of stage:").unwrap();
-                write_display_names_of_pairs(
-                    &mut string,
-                    &self.exclusive_at_start,
-                    at_start,
-                    world,
-                    "2",
-                );
-            }
-            if !before_commands.is_empty() {
-                writeln!(string, "3. Exclusive systems before commands of stage:").unwrap();
-                write_display_names_of_pairs(
-                    &mut string,
+                println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
+            } else {
+                // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
+                // allowing us to merge these collections
+                let mut offset = 1;
+                offset = write_display_names_of_pairs(offset, &self.parallel, parallel, world);
+                offset =
+                    write_display_names_of_pairs(offset, &self.exclusive_at_start, at_start, world);
+                offset = write_display_names_of_pairs(
+                    offset,
                     &self.exclusive_before_commands,
                     before_commands,
                     world,
-                    "3",
-                );
-            }
-            if !at_end.is_empty() {
-                writeln!(string, "4. Exclusive systems at end of stage:").unwrap();
-                write_display_names_of_pairs(
-                    &mut string,
-                    &self.exclusive_at_end,
-                    at_end,
-                    world,
-                    "4",
                 );
+                write_display_names_of_pairs(offset, &self.exclusive_at_end, at_end, world);
             }
-            info!("{}", string);
         }
     }
 

From 530176189f4b01a70b4b46197d76f242c612282a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 01:33:08 -0400
Subject: [PATCH 046/113] CI nits

---
 crates/bevy_ecs/src/schedule/stage.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 3c4fbcdb7b1e3..abbd04d585ef9 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -52,9 +52,9 @@ pub enum AmbiguityReportLevel {
 ///
 /// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
 /// This behavior can be changed by explicitly adding this resource using the following constructors:
-/// * [ReportExecutionOrderAmbiguities::off()] - Disables all messages reported by the ambiguity checker.
-/// * [ReportExecutionOrderAmbiguities::minimal()] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
-/// * [ReportExecutionOrderAmbiguities::verbose()] - Displays a full report of ambiguities detected by the ambiguity checker.
+/// * [`ReportExecutionOrderAmbiguities::off()`] - Disables all messages reported by the ambiguity checker.
+/// * [`ReportExecutionOrderAmbiguities::minimal()`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
+/// * [`ReportExecutionOrderAmbiguities::verbose()`] - Displays a full report of ambiguities detected by the ambiguity checker.
 ///
 /// The ambiguity checker will ignore ambiguities within official Bevy crates.
 /// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
@@ -583,10 +583,6 @@ impl SystemStage {
             ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
             world: &World,
         ) -> usize {
-            if ambiguities.is_empty() {
-                return offset;
-            }
-
             for (i, (system_a_index, system_b_index, conflicting_indexes)) in
                 ambiguities.iter().enumerate()
             {
@@ -605,7 +601,8 @@ impl SystemStage {
                 );
             }
 
-            return ambiguities.len();
+            // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
+            ambiguities.len()
         }
 
         let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);

From 0b734eec5907c02f2e700fc96818e427b82cf1a7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 01:36:33 -0400
Subject: [PATCH 047/113] MyAnotherResource -> MyOtherResource

---
 examples/ecs/ambiguity_checker.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 6c9b1fa0a76d4..c5c93dbba5622 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -15,7 +15,7 @@ fn main() {
         .add_startup_system(startup_system_a)
         .add_startup_system(startup_system_b)
         .insert_resource(MyResource(0))
-        .insert_resource(MyAnotherResource(0))
+        .insert_resource(MyOtherResource(0))
         // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
         .add_system(system_a.silence_ambiguity_checks())
         .add_system(system_b.label("my_label"))
@@ -39,13 +39,13 @@ fn startup_system_b(mut res: ResMut<MyStartupResource>) {
 }
 
 struct MyResource(i32);
-struct MyAnotherResource(i32);
+struct MyOtherResource(i32);
 
 fn system_a(mut res: ResMut<MyResource>) {
     res.0 += 1;
 }
 
-fn system_b(mut res: ResMut<MyResource>, mut another_res: ResMut<MyAnotherResource>) {
+fn system_b(mut res: ResMut<MyResource>, mut another_res: ResMut<MyOtherResource>) {
     res.0 += 1;
     another_res.0 += 1;
 }
@@ -54,7 +54,7 @@ fn system_c(mut res: ResMut<MyResource>) {
     res.0 += 1;
 }
 
-fn system_d(mut res: ResMut<MyResource>, mut another_res: ResMut<MyAnotherResource>) {
+fn system_d(mut res: ResMut<MyResource>, mut another_res: ResMut<MyOtherResource>) {
     res.0 += 1;
     another_res.0 += 1;
 }

From 07a8a2180c9d7f7e025393c4f6bb3c13996a8104 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 02:15:07 -0400
Subject: [PATCH 048/113] Improve wording of warning

Co-authored-by: Joy <51241057+maniwani@users.noreply.github.com>
---
 crates/bevy_ecs/src/schedule/stage.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index abbd04d585ef9..6f840ea845ca5 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -619,8 +619,8 @@ impl SystemStage {
         unresolved_count += at_end.len();
 
         if unresolved_count > 0 {
-            println!("{unresolved_count} unresolved system order ambiguities detected in one of your stages: you might want to \
-            add an explicit system ordering between some of these systems to avoid logic errors. \n");
+            println!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
+            You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
 
             if ambiguity_report.level != AmbiguityReportLevel::Verbose {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");

From 886655d3862b28a61788529b990e5e090781b6f3 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 23 Mar 2022 14:01:17 -0400
Subject: [PATCH 049/113] Split ambiguity detection logic off into its own file

---
 .../src/schedule/ambiguity_detection.rs       | 284 +++++++++++++++++
 crates/bevy_ecs/src/schedule/mod.rs           |   2 +
 crates/bevy_ecs/src/schedule/stage.rs         | 298 +-----------------
 3 files changed, 296 insertions(+), 288 deletions(-)
 create mode 100644 crates/bevy_ecs/src/schedule/ambiguity_detection.rs

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
new file mode 100644
index 0000000000000..87dffd1aeb21e
--- /dev/null
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -0,0 +1,284 @@
+use crate::component::ComponentId;
+use crate::schedule::{AmbiguityDetection, SystemContainer, SystemStage};
+use crate::world::World;
+
+use bevy_utils::HashMap;
+use fixedbitset::FixedBitSet;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AmbiguityReportLevel {
+    Off,
+    Minimal,
+    Verbose,
+}
+
+/// Systems that access the same Component or Resource within the same stage
+/// risk an ambiguous order that could result in logic bugs, unless they have an
+/// explicit execution ordering constraint between them.
+///
+/// This occurs because, in the absence of explicit constraints, systems are executed in
+/// an unstable, arbitrary order within each stage that may vary between runs and frames.
+///
+/// Some ambiguities reported by the ambiguity checker may be warranted (to allow two systems to run
+/// without blocking each other) or spurious, as the exact combination of archetypes used may
+/// prevent them from ever conflicting during actual gameplay. You can resolve the warnings produced
+/// by the ambiguity checker by adding `.before` or `.after` to one of the conflicting systems
+/// referencing the other system to force a specific ordering.
+///
+/// The checker may report a system more times than the amount of constraints it would actually need
+/// to have unambiguous order with regards to a group of already-constrained systems.
+///
+/// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
+/// This behavior can be changed by explicitly adding this resource using the following constructors:
+/// * [`ReportExecutionOrderAmbiguities::off()`] - Disables all messages reported by the ambiguity checker.
+/// * [`ReportExecutionOrderAmbiguities::minimal()`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
+/// * [`ReportExecutionOrderAmbiguities::verbose()`] - Displays a full report of ambiguities detected by the ambiguity checker.
+///
+/// The ambiguity checker will ignore ambiguities within official Bevy crates.
+/// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
+/// with an list of crate names as an argument.
+/// This resource should be added before any bevy internal plugin.
+///
+/// ## Example
+/// ```ignore
+/// # use bevy_app::App;
+/// # use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
+/// App::new()
+///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
+/// ```
+pub struct ReportExecutionOrderAmbiguities {
+    pub level: AmbiguityReportLevel,
+    pub ignore_crates: Vec<String>,
+}
+
+/// Returns vector containing all pairs of indices of systems with ambiguous execution order,
+/// along with specific components that have triggered the warning.
+/// Systems must be topologically sorted beforehand.
+pub(super) fn find_ambiguities(
+    systems: &[impl SystemContainer],
+    crates_filter: &[String],
+) -> Vec<(usize, usize, Vec<ComponentId>)> {
+    fn should_ignore_ambiguity(
+        systems: &[impl SystemContainer],
+        index_a: usize,
+        index_b: usize,
+        crates_filter: &[String],
+    ) -> bool {
+        let system_a = &systems[index_a];
+        let system_b = &systems[index_b];
+
+        (match system_a.ambiguity_detection() {
+            AmbiguityDetection::Ignore => true,
+            AmbiguityDetection::Check => false,
+            AmbiguityDetection::IgnoreWithLabel(labels) => {
+                labels.iter().any(|l| system_b.labels().contains(l))
+            }
+        }) || (match system_b.ambiguity_detection() {
+            AmbiguityDetection::Ignore => true,
+            AmbiguityDetection::Check => false,
+            AmbiguityDetection::IgnoreWithLabel(labels) => {
+                labels.iter().any(|l| system_a.labels().contains(l))
+            }
+        }) || (crates_filter.iter().any(|s| system_a.name().starts_with(s))
+            && crates_filter.iter().any(|s| system_b.name().starts_with(s)))
+    }
+
+    let mut ambiguity_set_labels = HashMap::default();
+    for set in systems.iter().flat_map(|c| c.ambiguity_sets()) {
+        let len = ambiguity_set_labels.len();
+        ambiguity_set_labels.entry(set).or_insert(len);
+    }
+    let mut all_ambiguity_sets = Vec::<FixedBitSet>::with_capacity(systems.len());
+    let mut all_dependencies = Vec::<FixedBitSet>::with_capacity(systems.len());
+    let mut all_dependants = Vec::<FixedBitSet>::with_capacity(systems.len());
+    for (index, container) in systems.iter().enumerate() {
+        let mut ambiguity_sets = FixedBitSet::with_capacity(ambiguity_set_labels.len());
+        for set in container.ambiguity_sets() {
+            ambiguity_sets.insert(ambiguity_set_labels[set]);
+        }
+        all_ambiguity_sets.push(ambiguity_sets);
+        let mut dependencies = FixedBitSet::with_capacity(systems.len());
+        for &dependency in container.dependencies() {
+            dependencies.union_with(&all_dependencies[dependency]);
+            dependencies.insert(dependency);
+            all_dependants[dependency].insert(index);
+        }
+
+        all_dependants.push(FixedBitSet::with_capacity(systems.len()));
+        all_dependencies.push(dependencies);
+    }
+    for index in (0..systems.len()).rev() {
+        let mut dependants = FixedBitSet::with_capacity(systems.len());
+        for dependant in all_dependants[index].ones() {
+            dependants.union_with(&all_dependants[dependant]);
+            dependants.insert(dependant);
+        }
+        all_dependants[index] = dependants;
+    }
+    let mut all_relations = all_dependencies
+        .drain(..)
+        .zip(all_dependants.drain(..))
+        .enumerate()
+        .map(|(index, (dependencies, dependants))| {
+            let mut relations = FixedBitSet::with_capacity(systems.len());
+            relations.union_with(&dependencies);
+            relations.union_with(&dependants);
+            relations.insert(index);
+            relations
+        })
+        .collect::<Vec<FixedBitSet>>();
+    let mut ambiguities = Vec::new();
+    let full_bitset: FixedBitSet = (0..systems.len()).collect();
+    let mut processed = FixedBitSet::with_capacity(systems.len());
+    for (index_a, relations) in all_relations.drain(..).enumerate() {
+        // TODO: prove that `.take(index_a)` would be correct here, and uncomment it if so.
+        for index_b in full_bitset.difference(&relations)
+        // .take(index_a)
+        {
+            if !processed.contains(index_b)
+                && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
+                && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter)
+            {
+                let a_access = systems[index_a].component_access();
+                let b_access = systems[index_b].component_access();
+                if let (Some(a), Some(b)) = (a_access, b_access) {
+                    let conflicts = a.get_conflicts(b);
+                    if !conflicts.is_empty() {
+                        ambiguities.push((index_a, index_b, conflicts));
+                    }
+                } else {
+                    ambiguities.push((index_a, index_b, Vec::new()));
+                }
+            }
+        }
+        processed.insert(index_a);
+    }
+    ambiguities
+}
+
+impl ReportExecutionOrderAmbiguities {
+    /// Disables all messages reported by the ambiguity checker.
+    pub fn off() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Off,
+            ..Default::default()
+        }
+    }
+
+    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This is the default behavior.
+    pub fn minimal() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+            ..Default::default()
+        }
+    }
+
+    /// Displays a full report of ambiguities detected by the ambiguity checker.
+    pub fn verbose() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Verbose,
+            ..Default::default()
+        }
+    }
+
+    /// Adds the given crate to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
+    pub fn ignore(mut self, crate_prefix: &str) -> Self {
+        self.ignore_crates.push(crate_prefix.to_string());
+        self
+    }
+
+    /// Adds all the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
+    pub fn ignore_all(mut self, crate_prefixes: &[&str]) -> Self {
+        for s in crate_prefixes {
+            self.ignore_crates.push(s.to_string());
+        }
+        self
+    }
+}
+
+impl Default for ReportExecutionOrderAmbiguities {
+    fn default() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+            ignore_crates: vec![],
+        }
+    }
+}
+
+impl SystemStage {
+    /// Logs execution order ambiguities between systems. System orders must be fresh.
+    pub fn report_ambiguities(&self, world: &mut World) {
+        let ambiguity_report =
+            world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
+
+        if ambiguity_report.level == AmbiguityReportLevel::Off {
+            return;
+        }
+
+        debug_assert!(!self.systems_modified);
+
+        fn write_display_names_of_pairs(
+            offset: usize,
+            systems: &[impl SystemContainer],
+            ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
+            world: &World,
+        ) -> usize {
+            for (i, (system_a_index, system_b_index, conflicting_indexes)) in
+                ambiguities.iter().enumerate()
+            {
+                let _system_a_name = systems[*system_a_index].name();
+                let _system_b_name = systems[*system_b_index].name();
+
+                let _conflicting_components = conflicting_indexes
+                    .iter()
+                    .map(|id| world.components().get_info(*id).unwrap().name())
+                    .collect::<Vec<_>>();
+
+                let _ambiguity_number = i + offset;
+
+                println!(
+						"{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicting_components:?}"
+					);
+            }
+
+            // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
+            ambiguities.len()
+        }
+
+        let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);
+        let at_start = find_ambiguities(&self.exclusive_at_start, &ambiguity_report.ignore_crates);
+        let before_commands = find_ambiguities(
+            &self.exclusive_before_commands,
+            &ambiguity_report.ignore_crates,
+        );
+        let at_end = find_ambiguities(&self.exclusive_at_end, &ambiguity_report.ignore_crates);
+
+        let mut unresolved_count = parallel.len();
+        unresolved_count += at_start.len();
+        unresolved_count += before_commands.len();
+        unresolved_count += at_end.len();
+
+        if unresolved_count > 0 {
+            println!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
+				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
+
+            if ambiguity_report.level != AmbiguityReportLevel::Verbose {
+                println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
+            } else {
+                // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
+                // allowing us to merge these collections
+                let mut offset = 1;
+                offset = write_display_names_of_pairs(offset, &self.parallel, parallel, world);
+                offset =
+                    write_display_names_of_pairs(offset, &self.exclusive_at_start, at_start, world);
+                offset = write_display_names_of_pairs(
+                    offset,
+                    &self.exclusive_before_commands,
+                    before_commands,
+                    world,
+                );
+                write_display_names_of_pairs(offset, &self.exclusive_at_end, at_end, world);
+            }
+        }
+    }
+}
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
index dc228f4265de3..dc15f631ebd45 100644
--- a/crates/bevy_ecs/src/schedule/mod.rs
+++ b/crates/bevy_ecs/src/schedule/mod.rs
@@ -3,6 +3,7 @@
 //! When using Bevy ECS, systems are usually not run directly, but are inserted into a
 //!  [`Stage`], which then lives within a [`Schedule`].
 
+mod ambiguity_detection;
 mod executor;
 mod executor_parallel;
 pub mod graph_utils;
@@ -14,6 +15,7 @@ mod system_container;
 mod system_descriptor;
 mod system_set;
 
+pub use ambiguity_detection::*;
 pub use executor::*;
 pub use executor_parallel::*;
 pub use graph_utils::GraphNode;
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 6f840ea845ca5..90ab1025a5fad 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1,11 +1,10 @@
 use crate::{
-    component::ComponentId,
     prelude::IntoSystem,
     schedule::{
         graph_utils::{self, DependencyGraphError},
         BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
-        ExclusiveSystemContainer, GraphNode, InsertionPoint, ParallelExecutor,
-        ParallelSystemContainer, ParallelSystemExecutor, RunCriteriaContainer,
+        ExclusiveSystemContainer, GraphNode, InsertionPoint, IntoSystemDescriptor,
+        ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor, RunCriteriaContainer,
         RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun,
         SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
     },
@@ -13,11 +12,8 @@ use crate::{
 };
 use bevy_utils::{HashMap, HashSet};
 use downcast_rs::{impl_downcast, Downcast};
-use fixedbitset::FixedBitSet;
 use std::fmt::Debug;
 
-use super::{AmbiguityDetection, IntoSystemDescriptor};
-
 /// A type that can run as a step of a [`Schedule`](super::Schedule).
 pub trait Stage: Downcast + Send + Sync {
     /// Runs the stage; this happens once per update.
@@ -27,101 +23,6 @@ pub trait Stage: Downcast + Send + Sync {
 
 impl_downcast!(Stage);
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum AmbiguityReportLevel {
-    Off,
-    Minimal,
-    Verbose,
-}
-
-/// Systems that access the same Component or Resource within the same stage
-/// risk an ambiguous order that could result in logic bugs, unless they have an
-/// explicit execution ordering constraint between them.
-///
-/// This occurs because, in the absence of explicit constraints, systems are executed in
-/// an unstable, arbitrary order within each stage that may vary between runs and frames.
-///
-/// Some ambiguities reported by the ambiguity checker may be warranted (to allow two systems to run
-/// without blocking each other) or spurious, as the exact combination of archetypes used may
-/// prevent them from ever conflicting during actual gameplay. You can resolve the warnings produced
-/// by the ambiguity checker by adding `.before` or `.after` to one of the conflicting systems
-/// referencing the other system to force a specific ordering.
-///
-/// The checker may report a system more times than the amount of constraints it would actually need
-/// to have unambiguous order with regards to a group of already-constrained systems.
-///
-/// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
-/// This behavior can be changed by explicitly adding this resource using the following constructors:
-/// * [`ReportExecutionOrderAmbiguities::off()`] - Disables all messages reported by the ambiguity checker.
-/// * [`ReportExecutionOrderAmbiguities::minimal()`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
-/// * [`ReportExecutionOrderAmbiguities::verbose()`] - Displays a full report of ambiguities detected by the ambiguity checker.
-///
-/// The ambiguity checker will ignore ambiguities within official Bevy crates.
-/// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
-/// with an list of crate names as an argument.
-/// This resource should be added before any bevy internal plugin.
-///
-/// ## Example
-/// ```ignore
-/// # use bevy_app::App;
-/// # use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
-/// App::new()
-///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
-/// ```
-pub struct ReportExecutionOrderAmbiguities {
-    pub level: AmbiguityReportLevel,
-    pub ignore_crates: Vec<String>,
-}
-
-impl ReportExecutionOrderAmbiguities {
-    /// Disables all messages reported by the ambiguity checker.
-    pub fn off() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Off,
-            ..Default::default()
-        }
-    }
-
-    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This is the default behavior.
-    pub fn minimal() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Minimal,
-            ..Default::default()
-        }
-    }
-
-    /// Displays a full report of ambiguities detected by the ambiguity checker.
-    pub fn verbose() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Verbose,
-            ..Default::default()
-        }
-    }
-
-    /// Adds the given crate to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
-    pub fn ignore(mut self, crate_prefix: &str) -> Self {
-        self.ignore_crates.push(crate_prefix.to_string());
-        self
-    }
-
-    /// Adds all the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
-    pub fn ignore_all(mut self, crate_prefixes: &[&str]) -> Self {
-        for s in crate_prefixes {
-            self.ignore_crates.push(s.to_string());
-        }
-        self
-    }
-}
-
-impl Default for ReportExecutionOrderAmbiguities {
-    fn default() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Minimal,
-            ignore_crates: vec![],
-        }
-    }
-}
-
 /// Stores and executes systems. Execution order is not defined unless explicitly specified;
 /// see `SystemDescriptor` documentation.
 pub struct SystemStage {
@@ -134,16 +35,16 @@ pub struct SystemStage {
     /// Topologically sorted run criteria of systems.
     run_criteria: Vec<RunCriteriaContainer>,
     /// Topologically sorted exclusive systems that want to be run at the start of the stage.
-    exclusive_at_start: Vec<ExclusiveSystemContainer>,
+    pub(super) exclusive_at_start: Vec<ExclusiveSystemContainer>,
     /// Topologically sorted exclusive systems that want to be run after parallel systems but
     /// before the application of their command buffers.
-    exclusive_before_commands: Vec<ExclusiveSystemContainer>,
+    pub(super) exclusive_before_commands: Vec<ExclusiveSystemContainer>,
     /// Topologically sorted exclusive systems that want to be run at the end of the stage.
-    exclusive_at_end: Vec<ExclusiveSystemContainer>,
+    pub(super) exclusive_at_end: Vec<ExclusiveSystemContainer>,
     /// Topologically sorted parallel systems.
-    parallel: Vec<ParallelSystemContainer>,
+    pub(super) parallel: Vec<ParallelSystemContainer>,
     /// Determines if the stage was modified and needs to rebuild its graphs and orders.
-    systems_modified: bool,
+    pub(super) systems_modified: bool,
     /// Determines if the stage's executor was changed.
     executor_modified: bool,
     /// Newly inserted run criteria that will be initialized at the next opportunity.
@@ -566,82 +467,6 @@ impl SystemStage {
         );
     }
 
-    /// Logs execution order ambiguities between systems. System orders must be fresh.
-    fn report_ambiguities(&self, world: &mut World) {
-        let ambiguity_report =
-            world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
-
-        if ambiguity_report.level == AmbiguityReportLevel::Off {
-            return;
-        }
-
-        debug_assert!(!self.systems_modified);
-
-        fn write_display_names_of_pairs(
-            offset: usize,
-            systems: &[impl SystemContainer],
-            ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
-            world: &World,
-        ) -> usize {
-            for (i, (system_a_index, system_b_index, conflicting_indexes)) in
-                ambiguities.iter().enumerate()
-            {
-                let _system_a_name = systems[*system_a_index].name();
-                let _system_b_name = systems[*system_b_index].name();
-
-                let _conflicting_components = conflicting_indexes
-                    .iter()
-                    .map(|id| world.components().get_info(*id).unwrap().name())
-                    .collect::<Vec<_>>();
-
-                let _ambiguity_number = i + offset;
-
-                println!(
-                    "{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicting_components:?}"
-                );
-            }
-
-            // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
-            ambiguities.len()
-        }
-
-        let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);
-        let at_start = find_ambiguities(&self.exclusive_at_start, &ambiguity_report.ignore_crates);
-        let before_commands = find_ambiguities(
-            &self.exclusive_before_commands,
-            &ambiguity_report.ignore_crates,
-        );
-        let at_end = find_ambiguities(&self.exclusive_at_end, &ambiguity_report.ignore_crates);
-
-        let mut unresolved_count = parallel.len();
-        unresolved_count += at_start.len();
-        unresolved_count += before_commands.len();
-        unresolved_count += at_end.len();
-
-        if unresolved_count > 0 {
-            println!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
-            You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
-
-            if ambiguity_report.level != AmbiguityReportLevel::Verbose {
-                println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
-            } else {
-                // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
-                // allowing us to merge these collections
-                let mut offset = 1;
-                offset = write_display_names_of_pairs(offset, &self.parallel, parallel, world);
-                offset =
-                    write_display_names_of_pairs(offset, &self.exclusive_at_start, at_start, world);
-                offset = write_display_names_of_pairs(
-                    offset,
-                    &self.exclusive_before_commands,
-                    before_commands,
-                    world,
-                );
-                write_display_names_of_pairs(offset, &self.exclusive_at_end, at_end, world);
-            }
-        }
-    }
-
     /// Checks for old component and system change ticks
     fn check_change_ticks(&mut self, world: &mut World) {
         let change_tick = world.change_tick();
@@ -765,111 +590,6 @@ fn process_systems(
     Ok(())
 }
 
-/// Returns vector containing all pairs of indices of systems with ambiguous execution order,
-/// along with specific components that have triggered the warning.
-/// Systems must be topologically sorted beforehand.
-fn find_ambiguities(
-    systems: &[impl SystemContainer],
-    crates_filter: &[String],
-) -> Vec<(usize, usize, Vec<ComponentId>)> {
-    fn should_ignore_ambiguity(
-        systems: &[impl SystemContainer],
-        index_a: usize,
-        index_b: usize,
-        crates_filter: &[String],
-    ) -> bool {
-        let system_a = &systems[index_a];
-        let system_b = &systems[index_b];
-
-        (match system_a.ambiguity_detection() {
-            AmbiguityDetection::Ignore => true,
-            AmbiguityDetection::Check => false,
-            AmbiguityDetection::IgnoreWithLabel(labels) => {
-                labels.iter().any(|l| system_b.labels().contains(l))
-            }
-        }) || (match system_b.ambiguity_detection() {
-            AmbiguityDetection::Ignore => true,
-            AmbiguityDetection::Check => false,
-            AmbiguityDetection::IgnoreWithLabel(labels) => {
-                labels.iter().any(|l| system_a.labels().contains(l))
-            }
-        }) || (crates_filter.iter().any(|s| system_a.name().starts_with(s))
-            && crates_filter.iter().any(|s| system_b.name().starts_with(s)))
-    }
-
-    let mut ambiguity_set_labels = HashMap::default();
-    for set in systems.iter().flat_map(|c| c.ambiguity_sets()) {
-        let len = ambiguity_set_labels.len();
-        ambiguity_set_labels.entry(set).or_insert(len);
-    }
-    let mut all_ambiguity_sets = Vec::<FixedBitSet>::with_capacity(systems.len());
-    let mut all_dependencies = Vec::<FixedBitSet>::with_capacity(systems.len());
-    let mut all_dependants = Vec::<FixedBitSet>::with_capacity(systems.len());
-    for (index, container) in systems.iter().enumerate() {
-        let mut ambiguity_sets = FixedBitSet::with_capacity(ambiguity_set_labels.len());
-        for set in container.ambiguity_sets() {
-            ambiguity_sets.insert(ambiguity_set_labels[set]);
-        }
-        all_ambiguity_sets.push(ambiguity_sets);
-        let mut dependencies = FixedBitSet::with_capacity(systems.len());
-        for &dependency in container.dependencies() {
-            dependencies.union_with(&all_dependencies[dependency]);
-            dependencies.insert(dependency);
-            all_dependants[dependency].insert(index);
-        }
-
-        all_dependants.push(FixedBitSet::with_capacity(systems.len()));
-        all_dependencies.push(dependencies);
-    }
-    for index in (0..systems.len()).rev() {
-        let mut dependants = FixedBitSet::with_capacity(systems.len());
-        for dependant in all_dependants[index].ones() {
-            dependants.union_with(&all_dependants[dependant]);
-            dependants.insert(dependant);
-        }
-        all_dependants[index] = dependants;
-    }
-    let mut all_relations = all_dependencies
-        .drain(..)
-        .zip(all_dependants.drain(..))
-        .enumerate()
-        .map(|(index, (dependencies, dependants))| {
-            let mut relations = FixedBitSet::with_capacity(systems.len());
-            relations.union_with(&dependencies);
-            relations.union_with(&dependants);
-            relations.insert(index);
-            relations
-        })
-        .collect::<Vec<FixedBitSet>>();
-    let mut ambiguities = Vec::new();
-    let full_bitset: FixedBitSet = (0..systems.len()).collect();
-    let mut processed = FixedBitSet::with_capacity(systems.len());
-    for (index_a, relations) in all_relations.drain(..).enumerate() {
-        // TODO: prove that `.take(index_a)` would be correct here, and uncomment it if so.
-        for index_b in full_bitset.difference(&relations)
-        // .take(index_a)
-        {
-            if !processed.contains(index_b)
-                && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
-                && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter)
-            {
-                let a_access = systems[index_a].component_access();
-                let b_access = systems[index_b].component_access();
-                if let (Some(a), Some(b)) = (a_access, b_access) {
-                    let conflicts = a.get_conflicts(b);
-                    if !conflicts.is_empty() {
-                        ambiguities.push((index_a, index_b, conflicts));
-                    }
-                } else {
-                    ambiguities.push((index_a, index_b, Vec::new()));
-                }
-            }
-        }
-        processed.insert(index_a);
-    }
-    ambiguities
-}
-
 impl Stage for SystemStage {
     fn run(&mut self, world: &mut World) {
         if let Some(world_id) = self.world_id {
@@ -1682,7 +1402,9 @@ mod tests {
 
     #[test]
     fn ambiguity_detection() {
-        use super::{find_ambiguities, SystemContainer};
+        use super::SystemContainer;
+        use crate::schedule::find_ambiguities;
+        use crate::schedule::BoxedSystemLabel;
 
         fn find_ambiguities_first_str_labels(
             systems: &[impl SystemContainer],

From 1a9e5745369f9bd8266963cc142fc562511885fa Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 13:35:17 -0400
Subject: [PATCH 050/113] Rename silence_ambiguity_checks to
 ignore_all_ambiguities

---
 crates/bevy_ecs/src/schedule/stage.rs             |  6 +++---
 crates/bevy_ecs/src/schedule/system_descriptor.rs | 14 +++++++-------
 examples/ecs/ambiguity_checker.rs                 |  2 +-
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 90ab1025a5fad..5cfac1292c5ed 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1811,7 +1811,7 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
-            .with_system(resource.label("1").after("0").silence_ambiguity_checks())
+            .with_system(resource.label("1").after("0").ignore_all_ambiguities())
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
@@ -1825,8 +1825,8 @@ mod tests {
         assert_eq!(ambiguities.len(), 1);
 
         let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").silence_ambiguity_checks())
-            .with_system(resource.label("1").after("0").silence_ambiguity_checks())
+            .with_system(component.label("0").ignore_all_ambiguities())
+            .with_system(resource.label("1").after("0").ignore_all_ambiguities())
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 6ec0902ded384..b4eed54994d42 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -158,8 +158,8 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
     /// with other systems in this set.
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
 
-    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
-    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor;
+    /// Ignore all system-order ambiguities between this system and any other system
+    fn ignore_all_ambiguities(self) -> ParallelSystemDescriptor;
 
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems with the given label.
@@ -195,7 +195,7 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self
     }
 
-    fn silence_ambiguity_checks(mut self) -> ParallelSystemDescriptor {
+    fn ignore_all_ambiguities(mut self) -> ParallelSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
@@ -242,8 +242,8 @@ where
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).in_ambiguity_set(set)
     }
 
-    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).silence_ambiguity_checks()
+    fn ignore_all_ambiguities(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).ignore_all_ambiguities()
     }
 
     fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
@@ -275,8 +275,8 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
         new_parallel_descriptor(self).in_ambiguity_set(set)
     }
 
-    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).silence_ambiguity_checks()
+    fn ignore_all_ambiguities(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(self).ignore_all_ambiguities()
     }
 
     fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index c5c93dbba5622..6bf07d43838f5 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -17,7 +17,7 @@ fn main() {
         .insert_resource(MyResource(0))
         .insert_resource(MyOtherResource(0))
         // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
-        .add_system(system_a.silence_ambiguity_checks())
+        .add_system(system_a.ignore_all_ambiguities())
         .add_system(system_b.label("my_label"))
         // It is also possible to mark a system as ambiguous with a specific other system,
         // making the checker ignore any ambiguities between them.

From e241983724127ccb6b8d2f49a5b7782f75bf29bd Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 13:50:44 -0400
Subject: [PATCH 051/113] Yeet ambiguity sets

Now redundant; ambiguous_with can be used instead
---
 .../src/schedule/ambiguity_detection.rs       | 13 ---
 crates/bevy_ecs/src/schedule/label.rs         |  2 -
 crates/bevy_ecs/src/schedule/stage.rs         | 94 ++++++++++++++-----
 .../bevy_ecs/src/schedule/system_container.rs | 17 +---
 .../src/schedule/system_descriptor.rs         | 44 +--------
 crates/bevy_ecs/src/schedule/system_set.rs    | 18 +---
 examples/ecs/ambiguity_checker.rs             |  8 +-
 7 files changed, 82 insertions(+), 114 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 87dffd1aeb21e..9454be003161a 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -2,7 +2,6 @@ use crate::component::ComponentId;
 use crate::schedule::{AmbiguityDetection, SystemContainer, SystemStage};
 use crate::world::World;
 
-use bevy_utils::HashMap;
 use fixedbitset::FixedBitSet;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -83,20 +82,9 @@ pub(super) fn find_ambiguities(
             && crates_filter.iter().any(|s| system_b.name().starts_with(s)))
     }
 
-    let mut ambiguity_set_labels = HashMap::default();
-    for set in systems.iter().flat_map(|c| c.ambiguity_sets()) {
-        let len = ambiguity_set_labels.len();
-        ambiguity_set_labels.entry(set).or_insert(len);
-    }
-    let mut all_ambiguity_sets = Vec::<FixedBitSet>::with_capacity(systems.len());
     let mut all_dependencies = Vec::<FixedBitSet>::with_capacity(systems.len());
     let mut all_dependants = Vec::<FixedBitSet>::with_capacity(systems.len());
     for (index, container) in systems.iter().enumerate() {
-        let mut ambiguity_sets = FixedBitSet::with_capacity(ambiguity_set_labels.len());
-        for set in container.ambiguity_sets() {
-            ambiguity_sets.insert(ambiguity_set_labels[set]);
-        }
-        all_ambiguity_sets.push(ambiguity_sets);
         let mut dependencies = FixedBitSet::with_capacity(systems.len());
         for &dependency in container.dependencies() {
             dependencies.union_with(&all_dependencies[dependency]);
@@ -136,7 +124,6 @@ pub(super) fn find_ambiguities(
         // .take(index_a)
         {
             if !processed.contains(index_b)
-                && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
                 && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter)
             {
                 let a_access = systems[index_a].component_access();
diff --git a/crates/bevy_ecs/src/schedule/label.rs b/crates/bevy_ecs/src/schedule/label.rs
index 5235dc5837692..f539f89c44a85 100644
--- a/crates/bevy_ecs/src/schedule/label.rs
+++ b/crates/bevy_ecs/src/schedule/label.rs
@@ -3,10 +3,8 @@ use bevy_utils::define_label;
 
 define_label!(StageLabel);
 define_label!(SystemLabel);
-define_label!(AmbiguitySetLabel);
 define_label!(RunCriteriaLabel);
 
 pub(crate) type BoxedStageLabel = Box<dyn StageLabel>;
 pub(crate) type BoxedSystemLabel = Box<dyn SystemLabel>;
-pub(crate) type BoxedAmbiguitySetLabel = Box<dyn AmbiguitySetLabel>;
 pub(crate) type BoxedRunCriteriaLabel = Box<dyn RunCriteriaLabel>;
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 5cfac1292c5ed..14239d0230187 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1528,10 +1528,16 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
-            .with_system(resource.label("1").after("0").in_ambiguity_set("a"))
+            .with_system(
+                resource
+                    .label("1")
+                    .after("0")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
-            .with_system(resource.label("4").in_ambiguity_set("a"));
+            .with_system(resource.label("4").ambiguous_with("a").label("a"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
@@ -1583,8 +1589,8 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0").before("1").before("2"))
-            .with_system(component.label("1").in_ambiguity_set("a"))
-            .with_system(component.label("2").in_ambiguity_set("a"))
+            .with_system(component.label("1").ambiguous_with("a").label("a"))
+            .with_system(component.label("2").ambiguous_with("a").label("a"))
             .with_system(component.label("3").after("1").after("2"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
@@ -1593,8 +1599,8 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0").before("1").before("2"))
-            .with_system(component.label("1").in_ambiguity_set("a"))
-            .with_system(component.label("2").in_ambiguity_set("b"))
+            .with_system(component.label("1").ambiguous_with("a").label("a"))
+            .with_system(component.label("2").ambiguous_with("a").label("a"))
             .with_system(component.label("3").after("1").after("2"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
@@ -1664,10 +1670,10 @@ mod tests {
                     .before("3")
                     .before("4"),
             )
-            .with_system(component.label("1").in_ambiguity_set("a"))
-            .with_system(component.label("2").in_ambiguity_set("a"))
-            .with_system(component.label("3").in_ambiguity_set("a"))
-            .with_system(component.label("4").in_ambiguity_set("a"))
+            .with_system(component.label("1").ambiguous_with("a").label("a"))
+            .with_system(component.label("2").ambiguous_with("a").label("a"))
+            .with_system(component.label("3").ambiguous_with("a").label("a"))
+            .with_system(component.label("4").ambiguous_with("a").label("a"))
             .with_system(
                 component
                     .label("5")
@@ -1690,15 +1696,17 @@ mod tests {
                     .before("3")
                     .before("4"),
             )
-            .with_system(component.label("1").in_ambiguity_set("a"))
-            .with_system(component.label("2").in_ambiguity_set("a"))
+            .with_system(component.label("1").ambiguous_with("a").label("a"))
+            .with_system(component.label("2").ambiguous_with("a").label("a"))
             .with_system(
                 component
                     .label("3")
-                    .in_ambiguity_set("a")
-                    .in_ambiguity_set("b"),
+                    .ambiguous_with("a")
+                    .label("a")
+                    .ambiguous_with("b")
+                    .label("b"),
             )
-            .with_system(component.label("4").in_ambiguity_set("b"))
+            .with_system(component.label("4").ambiguous_with("b").label("b"))
             .with_system(
                 component
                     .label("5")
@@ -1772,11 +1780,29 @@ mod tests {
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(empty.exclusive_system().label("1").in_ambiguity_set("a"))
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("1")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
             .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3").in_ambiguity_set("a"))
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("3")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
             .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(empty.exclusive_system().label("5").in_ambiguity_set("a"))
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("5")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
@@ -1800,10 +1826,34 @@ mod tests {
         assert_eq!(ambiguities.len(), 4);
 
         let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("1").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("2").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("3").in_ambiguity_set("a"));
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("0")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("1")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("2")
+                    .ambiguous_with("a")
+                    .label("a"),
+            )
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("3")
+                    .ambiguous_with("a")
+                    .label("a"),
+            );
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
diff --git a/crates/bevy_ecs/src/schedule/system_container.rs b/crates/bevy_ecs/src/schedule/system_container.rs
index 89e67f8e184e5..a63efe1fe70af 100644
--- a/crates/bevy_ecs/src/schedule/system_container.rs
+++ b/crates/bevy_ecs/src/schedule/system_container.rs
@@ -2,8 +2,8 @@ use crate::{
     component::ComponentId,
     query::Access,
     schedule::{
-        BoxedAmbiguitySetLabel, BoxedRunCriteriaLabel, BoxedSystemLabel, ExclusiveSystemDescriptor,
-        GraphNode, ParallelSystemDescriptor,
+        BoxedRunCriteriaLabel, BoxedSystemLabel, ExclusiveSystemDescriptor, GraphNode,
+        ParallelSystemDescriptor,
     },
     system::{ExclusiveSystem, System},
 };
@@ -22,7 +22,6 @@ pub trait SystemContainer: GraphNode<Label = BoxedSystemLabel> {
     #[doc(hidden)]
     fn set_run_criteria(&mut self, index: usize);
     fn run_criteria_label(&self) -> Option<&BoxedRunCriteriaLabel>;
-    fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel];
     fn ambiguity_detection(&self) -> &AmbiguityDetection;
     fn component_access(&self) -> Option<&Access<ComponentId>>;
 }
@@ -35,7 +34,6 @@ pub(super) struct ExclusiveSystemContainer {
     labels: Vec<BoxedSystemLabel>,
     before: Vec<BoxedSystemLabel>,
     after: Vec<BoxedSystemLabel>,
-    ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
     ambiguity_detection: AmbiguityDetection,
 }
 
@@ -49,7 +47,6 @@ impl ExclusiveSystemContainer {
             labels: descriptor.labels,
             before: descriptor.before,
             after: descriptor.after,
-            ambiguity_sets: descriptor.ambiguity_sets,
             ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
@@ -101,10 +98,6 @@ impl SystemContainer for ExclusiveSystemContainer {
         self.run_criteria_label.as_ref()
     }
 
-    fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel] {
-        &self.ambiguity_sets
-    }
-
     fn component_access(&self) -> Option<&Access<ComponentId>> {
         None
     }
@@ -123,7 +116,6 @@ pub struct ParallelSystemContainer {
     labels: Vec<BoxedSystemLabel>,
     before: Vec<BoxedSystemLabel>,
     after: Vec<BoxedSystemLabel>,
-    ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
     ambiguity_detection: AmbiguityDetection,
 }
 
@@ -141,7 +133,6 @@ impl ParallelSystemContainer {
             labels: descriptor.labels,
             before: descriptor.before,
             after: descriptor.after,
-            ambiguity_sets: descriptor.ambiguity_sets,
             ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
@@ -209,10 +200,6 @@ impl SystemContainer for ParallelSystemContainer {
         self.run_criteria_label.as_ref()
     }
 
-    fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel] {
-        &self.ambiguity_sets
-    }
-
     fn component_access(&self) -> Option<&Access<ComponentId>> {
         Some(self.system().component_access())
     }
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index b4eed54994d42..61abad7df9ca4 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -1,12 +1,6 @@
 use crate::{
-    schedule::{
-        AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
-        RunCriteriaDescriptorOrLabel, SystemLabel,
-    },
-    system::{
-        AsSystemLabel, BoxedSystem, ExclusiveSystem, ExclusiveSystemCoerced, ExclusiveSystemFn,
-        IntoSystem,
-    },
+    schedule::{BoxedSystemLabel, IntoRunCriteria, RunCriteriaDescriptorOrLabel, SystemLabel},
+    system::{BoxedSystem, ExclusiveSystem, ExclusiveSystemCoerced, ExclusiveSystemFn, IntoSystem},
 };
 
 /// Encapsulates a system and information on when it run in a `SystemStage`.
@@ -121,7 +115,6 @@ pub struct ParallelSystemDescriptor {
     pub(crate) labels: Vec<BoxedSystemLabel>,
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
-    pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
     pub(crate) ambiguity_detection: AmbiguityDetection,
 }
 
@@ -132,7 +125,6 @@ fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescrip
         run_criteria: None,
         before: Vec::new(),
         after: Vec::new(),
-        ambiguity_sets: Vec::new(),
         ambiguity_detection: AmbiguityDetection::Check,
     }
 }
@@ -154,10 +146,6 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
     /// Specifies that the system should run after systems with the given label.
     fn after<Marker>(self, label: impl AsSystemLabel<Marker>) -> ParallelSystemDescriptor;
 
-    /// Specifies that the system is exempt from execution order ambiguity detection
-    /// with other systems in this set.
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
-
     /// Ignore all system-order ambiguities between this system and any other system
     fn ignore_all_ambiguities(self) -> ParallelSystemDescriptor;
 
@@ -190,11 +178,6 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self
     }
 
-    fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
-        self.ambiguity_sets.push(Box::new(set));
-        self
-    }
-
     fn ignore_all_ambiguities(mut self) -> ParallelSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
@@ -238,10 +221,6 @@ where
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).after(label)
     }
 
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).in_ambiguity_set(set)
-    }
-
     fn ignore_all_ambiguities(self) -> ParallelSystemDescriptor {
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).ignore_all_ambiguities()
     }
@@ -271,10 +250,6 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
         new_parallel_descriptor(self).after(label)
     }
 
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).in_ambiguity_set(set)
-    }
-
     fn ignore_all_ambiguities(self) -> ParallelSystemDescriptor {
         new_parallel_descriptor(self).ignore_all_ambiguities()
     }
@@ -298,7 +273,6 @@ pub struct ExclusiveSystemDescriptor {
     pub(crate) labels: Vec<BoxedSystemLabel>,
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
-    pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
     pub(crate) ambiguity_detection: AmbiguityDetection,
     pub(crate) insertion_point: InsertionPoint,
 }
@@ -310,7 +284,6 @@ fn new_exclusive_descriptor(system: Box<dyn ExclusiveSystem>) -> ExclusiveSystem
         labels: Vec::new(),
         before: Vec::new(),
         after: Vec::new(),
-        ambiguity_sets: Vec::new(),
         ambiguity_detection: AmbiguityDetection::Check,
         insertion_point: InsertionPoint::AtStart,
     }
@@ -333,10 +306,6 @@ pub trait ExclusiveSystemDescriptorCoercion {
     /// Specifies that the system should run after systems with the given label.
     fn after(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
 
-    /// Specifies that the system is exempt from execution order ambiguity detection
-    /// with other systems in this set.
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ExclusiveSystemDescriptor;
-
     /// Specifies that the system should run with other exclusive systems at the start of stage.
     fn at_start(self) -> ExclusiveSystemDescriptor;
 
@@ -379,11 +348,6 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self
     }
 
-    fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> ExclusiveSystemDescriptor {
-        self.ambiguity_sets.push(Box::new(set));
-        self
-    }
-
     fn at_start(mut self) -> ExclusiveSystemDescriptor {
         self.insertion_point = InsertionPoint::AtStart;
         self
@@ -441,10 +405,6 @@ where
         new_exclusive_descriptor(Box::new(self)).after(label)
     }
 
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).in_ambiguity_set(set)
-    }
-
     fn at_start(self) -> ExclusiveSystemDescriptor {
         new_exclusive_descriptor(Box::new(self)).at_start()
     }
diff --git a/crates/bevy_ecs/src/schedule/system_set.rs b/crates/bevy_ecs/src/schedule/system_set.rs
index 5e32c2e48d1bb..527c77609f299 100644
--- a/crates/bevy_ecs/src/schedule/system_set.rs
+++ b/crates/bevy_ecs/src/schedule/system_set.rs
@@ -1,6 +1,6 @@
 use crate::schedule::{
-    AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
-    RunCriteriaDescriptorOrLabel, State, StateData, SystemDescriptor, SystemLabel,
+    BoxedSystemLabel, IntoRunCriteria, RunCriteriaDescriptorOrLabel, State, StateData,
+    SystemDescriptor, SystemLabel,
 };
 
 use super::IntoSystemDescriptor;
@@ -13,7 +13,6 @@ pub struct SystemSet {
     pub(crate) labels: Vec<BoxedSystemLabel>,
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
-    pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
 }
 
 impl SystemSet {
@@ -70,12 +69,6 @@ impl SystemSet {
         Self::new().with_run_criteria(State::<T>::on_resume(s))
     }
 
-    #[must_use]
-    pub fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> Self {
-        self.ambiguity_sets.push(Box::new(set));
-        self
-    }
-
     #[must_use]
     pub fn with_system<Params>(mut self, system: impl IntoSystemDescriptor<Params>) -> Self {
         self.systems.push(system.into_descriptor());
@@ -113,7 +106,6 @@ impl SystemSet {
             labels,
             before,
             after,
-            ambiguity_sets,
         } = self;
         for descriptor in &mut systems {
             match descriptor {
@@ -121,17 +113,11 @@ impl SystemSet {
                     descriptor.labels.extend(labels.iter().cloned());
                     descriptor.before.extend(before.iter().cloned());
                     descriptor.after.extend(after.iter().cloned());
-                    descriptor
-                        .ambiguity_sets
-                        .extend(ambiguity_sets.iter().cloned());
                 }
                 SystemDescriptor::Exclusive(descriptor) => {
                     descriptor.labels.extend(labels.iter().cloned());
                     descriptor.before.extend(before.iter().cloned());
                     descriptor.after.extend(after.iter().cloned());
-                    descriptor
-                        .ambiguity_sets
-                        .extend(ambiguity_sets.iter().cloned());
                 }
             }
         }
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 6bf07d43838f5..74c66fbee2a00 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -19,13 +19,13 @@ fn main() {
         // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
         .add_system(system_a.ignore_all_ambiguities())
         .add_system(system_b.label("my_label"))
-        // It is also possible to mark a system as ambiguous with a specific other system,
+        // It is also possible to mark a system as deliberately ambiguous with a provided lable,
         // making the checker ignore any ambiguities between them.
         .add_system(system_c.ambiguous_with("my_label"))
         // If there's an whole group of systems that are supposed to be ambiguous with each other,
-        // an ambiguity set can be used to make the checker ignore anything it detects between them.
-        .add_system(system_d.in_ambiguity_set("my_set"))
-        .add_system(system_e.in_ambiguity_set("my_set"))
+        // add a common label, and then ignore any conflicts with that label.
+        .add_system(system_d.label("my_set").ambiguous_with("my_set"))
+        .add_system(system_e.label("my_set").ambiguous_with("my_set"))
         .run();
 }
 

From 0b818189ce9c6f5dbb59e6b0ff593aaeb0ba4f02 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 13:53:31 -0400
Subject: [PATCH 052/113] Note value of defaults

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 9454be003161a..53da225d1b7a8 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -33,6 +33,8 @@ pub enum AmbiguityReportLevel {
 /// * [`ReportExecutionOrderAmbiguities::minimal()`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
 /// * [`ReportExecutionOrderAmbiguities::verbose()`] - Displays a full report of ambiguities detected by the ambiguity checker.
 ///
+/// Similarly, [`ReportExectuionOrderAmbiguities::default()`] will set the level to [`AmbiguityReportLevel::Minimal`].
+///
 /// The ambiguity checker will ignore ambiguities within official Bevy crates.
 /// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
 /// with an list of crate names as an argument.

From 17a0fb2eafc4a610ab43cf79a0cf0f8dbfb9bbcc Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 13:57:02 -0400
Subject: [PATCH 053/113] Docs for AmbiguityReportLevel

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 53da225d1b7a8..1763b33e3144a 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -5,6 +5,11 @@ use crate::world::World;
 use fixedbitset::FixedBitSet;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+
+/// Controls the level of reporting for [`ReportExecutionOrderAmbiguities`]:
+/// * [`AmbiguityReportLevel::Off`] - Disables all messages reported by the ambiguity checker.
+/// * [`AmbiguityReportLevel::Minimal`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
+/// * [`AmbiguityReportLevel::Verbose`] - Displays a full report of ambiguities detected by the ambiguity checker.
 pub enum AmbiguityReportLevel {
     Off,
     Minimal,

From 1dbd05d627c31c292621051139a2aafbc3c125f8 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 13:58:23 -0400
Subject: [PATCH 054/113] Fix rebase

---
 crates/bevy_ecs/src/schedule/stage.rs             | 12 ++++++------
 crates/bevy_ecs/src/schedule/system_descriptor.rs |  5 ++++-
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 14239d0230187..1ea7fd4735d55 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1420,7 +1420,7 @@ mod tests {
                 .collect()
         }
 
-        fn find_ambiguities_first_labels_with_filter(
+        fn find_ambiguities_first_str_labels_with_filter(
             systems: &[impl SystemContainer],
             filter: &[String],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
@@ -1867,7 +1867,7 @@ mod tests {
             .with_system(resource.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("0"), Box::new("3")))
                 || ambiguities.contains(&(Box::new("3"), Box::new("0")))
@@ -1882,7 +1882,7 @@ mod tests {
             .with_system(resource.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
 
         let mut stage = SystemStage::parallel()
@@ -1910,7 +1910,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
+        let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
         assert!(
             ambiguities.contains(&(Box::new("2"), Box::new("4")))
                 || ambiguities.contains(&(Box::new("4"), Box::new("2")))
@@ -1931,7 +1931,7 @@ mod tests {
             .with_system(resource.label("4").ambiguous_with("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("4")))
                 || ambiguities.contains(&(Box::new("4"), Box::new("1")))
@@ -1943,7 +1943,7 @@ mod tests {
             .with_system(inner::inner_fn.label("2"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        let ambiguities = find_ambiguities_first_labels_with_filter(
+        let ambiguities = find_ambiguities_first_str_labels_with_filter(
             &stage.parallel,
             &["bevy_ecs::schedule::stage::tests::ambiguity_detection::inner::".into()],
         );
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 61abad7df9ca4..aeafc5d24017c 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -1,6 +1,9 @@
 use crate::{
     schedule::{BoxedSystemLabel, IntoRunCriteria, RunCriteriaDescriptorOrLabel, SystemLabel},
-    system::{BoxedSystem, ExclusiveSystem, ExclusiveSystemCoerced, ExclusiveSystemFn, IntoSystem},
+    system::{
+        AsSystemLabel, BoxedSystem, ExclusiveSystem, ExclusiveSystemCoerced, ExclusiveSystemFn,
+        IntoSystem,
+    },
 };
 
 /// Encapsulates a system and information on when it run in a `SystemStage`.

From 692e27f8fd42a9eb9501f5134c2d6fdba4597de9 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 14:08:48 -0400
Subject: [PATCH 055/113] Allow the use of implicit system labels with
 ambiguous_with

---
 .../src/schedule/system_descriptor.rs         | 38 +++++++++++++------
 examples/ecs/ambiguity_checker.rs             | 15 +++++---
 2 files changed, 36 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index aeafc5d24017c..753e5a3c3c90f 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -154,7 +154,7 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
 
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems with the given label.
-    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
+    fn ambiguous_with<Marker>(self, label: impl AsSystemLabel<Marker>) -> ParallelSystemDescriptor;
 }
 
 impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
@@ -186,14 +186,20 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self
     }
 
-    fn ambiguous_with(mut self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+    fn ambiguous_with<Marker>(
+        mut self,
+        label: impl AsSystemLabel<Marker>,
+    ) -> ParallelSystemDescriptor {
+        let system_label = label.as_system_label();
+        let boxed_system_label: Box<dyn SystemLabel> = Box::new(system_label);
+
         match &mut self.ambiguity_detection {
             AmbiguityDetection::IgnoreWithLabel(v) => {
-                v.push(Box::new(label));
+                v.push(boxed_system_label);
             }
             _ => {
                 self.ambiguity_detection =
-                    AmbiguityDetection::IgnoreWithLabel(vec![Box::new(label)]);
+                    AmbiguityDetection::IgnoreWithLabel(vec![boxed_system_label]);
             }
         }
         self
@@ -228,7 +234,7 @@ where
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).ignore_all_ambiguities()
     }
 
-    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+    fn ambiguous_with<Marker>(self, label: impl AsSystemLabel<Marker>) -> ParallelSystemDescriptor {
         new_parallel_descriptor(Box::new(IntoSystem::into_system(self))).ambiguous_with(label)
     }
 }
@@ -257,7 +263,7 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
         new_parallel_descriptor(self).ignore_all_ambiguities()
     }
 
-    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+    fn ambiguous_with<Marker>(self, label: impl AsSystemLabel<Marker>) -> ParallelSystemDescriptor {
         new_parallel_descriptor(self).ambiguous_with(label)
     }
 }
@@ -324,7 +330,8 @@ pub trait ExclusiveSystemDescriptorCoercion {
 
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems with the given label.
-    fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
+    fn ambiguous_with<Marker>(self, label: impl AsSystemLabel<Marker>)
+        -> ExclusiveSystemDescriptor;
 }
 
 impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
@@ -371,14 +378,20 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self
     }
 
-    fn ambiguous_with(mut self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
+    fn ambiguous_with<Marker>(
+        mut self,
+        label: impl AsSystemLabel<Marker>,
+    ) -> ExclusiveSystemDescriptor {
+        let system_label = label.as_system_label();
+        let boxed_system_label: Box<dyn SystemLabel> = Box::new(system_label);
+
         match &mut self.ambiguity_detection {
             AmbiguityDetection::IgnoreWithLabel(v) => {
-                v.push(Box::new(label));
+                v.push(boxed_system_label);
             }
             _ => {
                 self.ambiguity_detection =
-                    AmbiguityDetection::IgnoreWithLabel(vec![Box::new(label)]);
+                    AmbiguityDetection::IgnoreWithLabel(vec![boxed_system_label]);
             }
         }
         self
@@ -424,7 +437,10 @@ where
         new_exclusive_descriptor(Box::new(self)).silence_ambiguity_checks()
     }
 
-    fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
+    fn ambiguous_with<Marker>(
+        self,
+        label: impl AsSystemLabel<Marker>,
+    ) -> ExclusiveSystemDescriptor {
         new_exclusive_descriptor(Box::new(self)).ambiguous_with(label)
     }
 }
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 74c66fbee2a00..e11b90c1e5fb3 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -18,17 +18,20 @@ fn main() {
         .insert_resource(MyOtherResource(0))
         // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
         .add_system(system_a.ignore_all_ambiguities())
-        .add_system(system_b.label("my_label"))
-        // It is also possible to mark a system as deliberately ambiguous with a provided lable,
+        .add_system(system_b)
+        // It is also possible to mark a system as deliberately ambiguous with a provided system or label,
         // making the checker ignore any ambiguities between them.
-        .add_system(system_c.ambiguous_with("my_label"))
+        .add_system(system_c.ambiguous_with(system_b))
         // If there's an whole group of systems that are supposed to be ambiguous with each other,
-        // add a common label, and then ignore any conflicts with that label.
-        .add_system(system_d.label("my_set").ambiguous_with("my_set"))
-        .add_system(system_e.label("my_set").ambiguous_with("my_set"))
+        // add a shared label, and then ignore any conflicts with that label.
+        .add_system(system_d.label(AmbiguitySet).ambiguous_with(AmbiguitySet))
+        .add_system(system_e.label(AmbiguitySet).ambiguous_with(AmbiguitySet))
         .run();
 }
 
+#[derive(SystemLabel, Debug, Clone, PartialEq, Eq, Hash)]
+struct AmbiguitySet;
+
 struct MyStartupResource(i32);
 fn startup_system_a(mut res: ResMut<MyStartupResource>) {
     res.0 += 1;

From b279192644f108d0933481b0502b458d521d46b7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 28 Mar 2022 16:38:50 -0400
Subject: [PATCH 056/113] Export ReportExecutionOrderAmbiguities in prelude

---
 crates/bevy_ecs/src/lib.rs        | 5 +++--
 examples/ecs/ambiguity_checker.rs | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index e2f62cca07a7c..183a9d676a3b6 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -29,8 +29,9 @@ pub mod prelude {
         query::{Added, AnyOf, ChangeTrackers, Changed, Or, QueryState, With, Without},
         schedule::{
             AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, Schedule, Stage,
-            StageLabel, State, SystemLabel, SystemSet, SystemStage,
+            ReportExecutionOrderAmbiguities, RunCriteria, RunCriteriaDescriptorCoercion,
+            RunCriteriaLabel, RunCriteriaPiping, Schedule, Stage, StageLabel, State, SystemLabel,
+            SystemSet, SystemStage,
         },
         system::{
             Commands, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend,
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index e11b90c1e5fb3..c455b0cb9de52 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -1,4 +1,4 @@
-use bevy::{ecs::schedule::ReportExecutionOrderAmbiguities, log::LogPlugin, prelude::*};
+use bevy::{log::LogPlugin, prelude::*};
 
 fn main() {
     App::new()

From 28afc86922441c4620522cde5fbbc545832e15b4 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 13:31:36 -0400
Subject: [PATCH 057/113] Simplify architecture

---
 crates/bevy_audio/src/lib.rs                  |   7 +-
 crates/bevy_core/src/lib.rs                   |   3 +-
 .../src/schedule/ambiguity_detection.rs       | 110 +++++-------------
 crates/bevy_render/src/lib.rs                 |   6 -
 crates/bevy_sprite/src/lib.rs                 |   9 +-
 crates/bevy_text/src/lib.rs                   |  10 +-
 crates/bevy_transform/src/lib.rs              |   6 -
 crates/bevy_ui/src/lib.rs                     |   9 +-
 crates/bevy_winit/src/lib.rs                  |   6 -
 examples/ecs/ambiguity_checker.rs             |   5 +-
 examples/ecs/ecs_guide.rs                     |  12 +-
 11 files changed, 46 insertions(+), 137 deletions(-)

diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 6085f055193d1..5aa23f7aa5fd6 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -44,7 +44,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{schedule::ReportExecutionOrderAmbiguities, system::IntoExclusiveSystem};
+use bevy_ecs::system::IntoExclusiveSystem;
 
 /// Adds support for audio playback to a Bevy Application
 ///
@@ -65,10 +65,5 @@ impl Plugin for AudioPlugin {
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
         app.init_asset_loader::<AudioLoader>();
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_audio".to_string());
     }
 }
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 038abaeb16eb2..0c94833162d3c 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -21,7 +21,7 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
-    schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
+    schedule::{ExclusiveSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel},
     system::IntoExclusiveSystem,
 };
 use bevy_utils::HashSet;
@@ -50,6 +50,7 @@ impl Plugin for CorePlugin {
 
         app.init_resource::<Time>()
             .init_resource::<FixedTimesteps>()
+            .init_resource::<ReportExecutionOrderAmbiguities>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()
diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 1763b33e3144a..2b168a432938c 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -5,17 +5,6 @@ use crate::world::World;
 use fixedbitset::FixedBitSet;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-
-/// Controls the level of reporting for [`ReportExecutionOrderAmbiguities`]:
-/// * [`AmbiguityReportLevel::Off`] - Disables all messages reported by the ambiguity checker.
-/// * [`AmbiguityReportLevel::Minimal`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
-/// * [`AmbiguityReportLevel::Verbose`] - Displays a full report of ambiguities detected by the ambiguity checker.
-pub enum AmbiguityReportLevel {
-    Off,
-    Minimal,
-    Verbose,
-}
-
 /// Systems that access the same Component or Resource within the same stage
 /// risk an ambiguous order that could result in logic bugs, unless they have an
 /// explicit execution ordering constraint between them.
@@ -32,18 +21,10 @@ pub enum AmbiguityReportLevel {
 /// The checker may report a system more times than the amount of constraints it would actually need
 /// to have unambiguous order with regards to a group of already-constrained systems.
 ///
-/// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
-/// This behavior can be changed by explicitly adding this resource using the following constructors:
-/// * [`ReportExecutionOrderAmbiguities::off()`] - Disables all messages reported by the ambiguity checker.
-/// * [`ReportExecutionOrderAmbiguities::minimal()`] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
-/// * [`ReportExecutionOrderAmbiguities::verbose()`] - Displays a full report of ambiguities detected by the ambiguity checker.
-///
-/// Similarly, [`ReportExectuionOrderAmbiguities::default()`] will set the level to [`AmbiguityReportLevel::Minimal`].
+/// By default, the value of this resource is set to `Minimal`.
 ///
 /// The ambiguity checker will ignore ambiguities within official Bevy crates.
-/// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
-/// with an list of crate names as an argument.
-/// This resource should be added before any bevy internal plugin.
+/// Eventually, these should all be resolved or manually ignored, and this behavior will no longer be needed.
 ///
 /// ## Example
 /// ```ignore
@@ -52,9 +33,13 @@ pub enum AmbiguityReportLevel {
 /// App::new()
 ///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
 /// ```
-pub struct ReportExecutionOrderAmbiguities {
-    pub level: AmbiguityReportLevel,
-    pub ignore_crates: Vec<String>,
+pub enum ReportExecutionOrderAmbiguities {
+    // Disables all messages reported by the ambiguity checker
+    Off,
+    // Displays only the number of unresolved ambiguities detected by the ambiguity checker
+    Minimal,
+    //  Displays a full report of ambiguities detected by the ambiguity checker
+    Verbose,
 }
 
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
@@ -150,52 +135,9 @@ pub(super) fn find_ambiguities(
     ambiguities
 }
 
-impl ReportExecutionOrderAmbiguities {
-    /// Disables all messages reported by the ambiguity checker.
-    pub fn off() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Off,
-            ..Default::default()
-        }
-    }
-
-    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This is the default behavior.
-    pub fn minimal() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Minimal,
-            ..Default::default()
-        }
-    }
-
-    /// Displays a full report of ambiguities detected by the ambiguity checker.
-    pub fn verbose() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Verbose,
-            ..Default::default()
-        }
-    }
-
-    /// Adds the given crate to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
-    pub fn ignore(mut self, crate_prefix: &str) -> Self {
-        self.ignore_crates.push(crate_prefix.to_string());
-        self
-    }
-
-    /// Adds all the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
-    pub fn ignore_all(mut self, crate_prefixes: &[&str]) -> Self {
-        for s in crate_prefixes {
-            self.ignore_crates.push(s.to_string());
-        }
-        self
-    }
-}
-
 impl Default for ReportExecutionOrderAmbiguities {
     fn default() -> Self {
-        Self {
-            level: AmbiguityReportLevel::Minimal,
-            ignore_crates: vec![],
-        }
+        ReportExecutionOrderAmbiguities::Minimal
     }
 }
 
@@ -205,7 +147,7 @@ impl SystemStage {
         let ambiguity_report =
             world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
 
-        if ambiguity_report.level == AmbiguityReportLevel::Off {
+        if *ambiguity_report == ReportExecutionOrderAmbiguities::Off {
             return;
         }
 
@@ -239,13 +181,25 @@ impl SystemStage {
             ambiguities.len()
         }
 
-        let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);
-        let at_start = find_ambiguities(&self.exclusive_at_start, &ambiguity_report.ignore_crates);
-        let before_commands = find_ambiguities(
-            &self.exclusive_before_commands,
-            &ambiguity_report.ignore_crates,
-        );
-        let at_end = find_ambiguities(&self.exclusive_at_end, &ambiguity_report.ignore_crates);
+        // TODO: remove all internal ambiguities and remove this logic
+        let ignored_crates = vec![
+            // Rendering
+            "bevy_render".to_string(),
+            "bevy_sprite".to_string(),
+            "bevy_render".to_string(),
+            "bevy_pbr".to_string(),
+            "bevy_text".to_string(),
+            "bevy_core_pipeline".to_string(),
+            "bevy_ui".to_string(),
+            // Misc
+            "bevy_winit".to_string(),
+            "bevy_audio".to_string(),
+        ];
+
+        let parallel = find_ambiguities(&self.parallel, &ignored_crates);
+        let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates);
+        let before_commands = find_ambiguities(&self.exclusive_before_commands, &ignored_crates);
+        let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates);
 
         let mut unresolved_count = parallel.len();
         unresolved_count += at_start.len();
@@ -253,10 +207,10 @@ impl SystemStage {
         unresolved_count += at_end.len();
 
         if unresolved_count > 0 {
-            println!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
+            println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
 				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
 
-            if ambiguity_report.level != AmbiguityReportLevel::Verbose {
+            if *ambiguity_report == ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index d1b62177b0c77..5d7127c0ce7b1 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -46,7 +46,6 @@ use crate::{
 use bevy_app::{App, AppLabel, Plugin};
 use bevy_asset::{AddAsset, AssetServer};
 use bevy_ecs::prelude::*;
-use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
 use std::ops::{Deref, DerefMut};
 
 /// Contains the default Bevy rendering backend based on wgpu.
@@ -287,11 +286,6 @@ impl Plugin for RenderPlugin {
             // NOTE: Load this after renderer initialization so that it knows about the supported
             // compressed texture formats
             .add_plugin(ImagePlugin);
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_render".to_string());
     }
 }
 
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 30367cfb0913c..b24833d52c0ef 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -31,9 +31,7 @@ pub use texture_atlas_builder::*;
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, HandleUntyped};
 use bevy_core_pipeline::Transparent2d;
-use bevy_ecs::schedule::{
-    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
-};
+use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     render_phase::AddRenderCommand,
@@ -79,10 +77,5 @@ impl Plugin for SpritePlugin {
                 .add_system_to_stage(RenderStage::Extract, render::extract_sprite_events)
                 .add_system_to_stage(RenderStage::Queue, queue_sprites);
         };
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_sprite".to_string());
     }
 }
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index da8cc233be09f..6ed6009ad7a44 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -28,10 +28,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{
-    entity::Entity,
-    schedule::{ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities},
-};
+use bevy_ecs::{entity::Entity, schedule::ParallelSystemDescriptorCoercion};
 use bevy_render::{RenderApp, RenderStage};
 use bevy_sprite::SpriteSystem;
 
@@ -57,10 +54,5 @@ impl Plugin for TextPlugin {
                 extract_text2d_sprite.after(SpriteSystem::ExtractSprites),
             );
         }
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_text".to_string());
     }
 }
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index fba5134b115da..a88017c7d7d60 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -14,7 +14,6 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
 use bevy_hierarchy::HierarchySystem;
 use prelude::{GlobalTransform, Transform};
 
@@ -106,10 +105,5 @@ impl Plugin for TransformPlugin {
                     .label(TransformSystem::TransformPropagate)
                     .after(HierarchySystem::ParentUpdate),
             );
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_transform".to_string());
     }
 }
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index fc1379c4c7ef6..872a2bb9eef85 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -24,9 +24,7 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{
-    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
-};
+use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
 use bevy_input::InputSystem;
 use bevy_math::{Rect, Size};
 use bevy_transform::TransformSystem;
@@ -107,10 +105,5 @@ impl Plugin for UiPlugin {
             );
 
         crate::render::build_ui_render(app);
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_ui".to_string());
     }
 }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 925e90d2a065e..e94b60c8327b2 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -13,7 +13,6 @@ pub use winit_windows::*;
 use bevy_app::{App, AppExit, CoreStage, Plugin};
 use bevy_ecs::{
     event::{Events, ManualEventReader},
-    schedule::ReportExecutionOrderAmbiguities,
     system::IntoExclusiveSystem,
     world::World,
 };
@@ -48,11 +47,6 @@ impl Plugin for WinitPlugin {
         let event_loop = EventLoop::new();
         handle_initial_window_events(&mut app.world, &event_loop);
         app.insert_non_send_resource(event_loop);
-
-        app.world
-            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
-            .ignore_crates
-            .push("bevy_winit".to_string());
     }
 }
 
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index c455b0cb9de52..2c91a5ae0bbd1 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -2,11 +2,12 @@ use bevy::{log::LogPlugin, prelude::*};
 
 fn main() {
     App::new()
+        .add_plugins(MinimalPlugins)
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
-        // This resource should be added before any bevy internal plugin.
-        .insert_resource(ReportExecutionOrderAmbiguities::verbose())
+        // This resource should be added after `CorePlugin` (and hence both `MinimalPlugins` and `DefaultPlugins`).
+        .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
         .add_plugin(LogPlugin)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index 8e1a12aa694f4..e2c7a11b14684 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -1,7 +1,6 @@
 use bevy::{
     app::{AppExit, ScheduleRunnerPlugin, ScheduleRunnerSettings},
     ecs::schedule::ReportExecutionOrderAmbiguities,
-    log::LogPlugin,
     prelude::*,
     utils::Duration,
 };
@@ -329,12 +328,11 @@ fn main() {
             MyStage::AfterRound,
             game_over_system.after(score_check_system),
         )
-        // We can check our systems for execution order ambiguities by examining the output produced
-        // in the console by using the `LogPlugin` and adding the following Resource to our App :)
-        // Be aware that not everything reported by this checker is a potential problem, you'll have
-        // to make that judgement yourself.
-        .add_plugin(LogPlugin::default())
-        .insert_resource(ReportExecutionOrderAmbiguities::verbose())
+        // We can examine execution order ambiguities by examining the output produced
+        // in the console by adding the following resource to our App
+        // Execution order ambiguities can be resolved by adding ordering constraints,
+        // or explicitly ignored (when there's a false positive).
+        .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
         // This call to run() starts the app we just built!
         .run();
 }

From c51432e1a1db2a720c15ad1844327ae0f6f6463a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 13:46:50 -0400
Subject: [PATCH 058/113] No need to add the resource in CorePlugin

---
 crates/bevy_core/src/lib.rs       | 3 +--
 examples/ecs/ambiguity_checker.rs | 1 -
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 0c94833162d3c..038abaeb16eb2 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -21,7 +21,7 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
-    schedule::{ExclusiveSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel},
+    schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
     system::IntoExclusiveSystem,
 };
 use bevy_utils::HashSet;
@@ -50,7 +50,6 @@ impl Plugin for CorePlugin {
 
         app.init_resource::<Time>()
             .init_resource::<FixedTimesteps>()
-            .init_resource::<ReportExecutionOrderAmbiguities>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 2c91a5ae0bbd1..35add2cf46768 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -6,7 +6,6 @@ fn main() {
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
-        // This resource should be added after `CorePlugin` (and hence both `MinimalPlugins` and `DefaultPlugins`).
         .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
         .add_plugin(LogPlugin)
         .insert_resource(MyStartupResource(0))

From d246a1496001f66fad6448b7cf92230d4db07e06 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 13:50:40 -0400
Subject: [PATCH 059/113] No need for LogPlugin

---
 examples/ecs/ambiguity_checker.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 35add2cf46768..1ae83752e7372 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -1,4 +1,4 @@
-use bevy::{log::LogPlugin, prelude::*};
+use bevy::prelude::*;
 
 fn main() {
     App::new()
@@ -7,7 +7,6 @@ fn main() {
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
         .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
-        .add_plugin(LogPlugin)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
         // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.

From 43ef139e1311b214f2ef39b40693b37dec22adfd Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 13:50:56 -0400
Subject: [PATCH 060/113] More reporting levels

---
 .../src/schedule/ambiguity_detection.rs       | 83 +++++++++++++------
 crates/bevy_ecs/src/schedule/stage.rs         | 13 +--
 examples/ecs/ambiguity_checker.rs             |  4 +-
 3 files changed, 67 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 2b168a432938c..f18843cb9d934 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -23,9 +23,6 @@ use fixedbitset::FixedBitSet;
 ///
 /// By default, the value of this resource is set to `Minimal`.
 ///
-/// The ambiguity checker will ignore ambiguities within official Bevy crates.
-/// Eventually, these should all be resolved or manually ignored, and this behavior will no longer be needed.
-///
 /// ## Example
 /// ```ignore
 /// # use bevy_app::App;
@@ -34,12 +31,22 @@ use fixedbitset::FixedBitSet;
 ///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
 /// ```
 pub enum ReportExecutionOrderAmbiguities {
-    // Disables all messages reported by the ambiguity checker
+    /// Disables all messages reported by the ambiguity checker
     Off,
-    // Displays only the number of unresolved ambiguities detected by the ambiguity checker
+    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker
     Minimal,
-    //  Displays a full report of ambiguities detected by the ambiguity checker
+    /// Displays a full report of ambiguities detected by the ambiguity checker
     Verbose,
+    /// Verbosely reports all non-ignored ambiguities, including those between Bevy's systems
+    ///
+    /// These will not be actionable: you should only turn on this functionality when
+    /// investigating to see if there's a Bevy bug or working on the engine itself.
+    ReportInternal,
+    /// Verbosely reports ALL ambiguities, even ignored ones
+    ///
+    /// This will be very noisy, but can be useful when attempting to track down subtle determinism issues,
+    /// as you might need when attempting to implement lockstep networking.
+    Deterministic,
 }
 
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
@@ -48,13 +55,20 @@ pub enum ReportExecutionOrderAmbiguities {
 pub(super) fn find_ambiguities(
     systems: &[impl SystemContainer],
     crates_filter: &[String],
+    // Should explicit attempts to ignore ambiguities be obeyed?
+    respect_ignores: bool,
 ) -> Vec<(usize, usize, Vec<ComponentId>)> {
     fn should_ignore_ambiguity(
         systems: &[impl SystemContainer],
         index_a: usize,
         index_b: usize,
         crates_filter: &[String],
+        respect_ignores: bool,
     ) -> bool {
+        if !respect_ignores {
+            return false;
+        }
+
         let system_a = &systems[index_a];
         let system_b = &systems[index_b];
 
@@ -116,7 +130,13 @@ pub(super) fn find_ambiguities(
         // .take(index_a)
         {
             if !processed.contains(index_b)
-                && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter)
+                && !should_ignore_ambiguity(
+                    systems,
+                    index_a,
+                    index_b,
+                    crates_filter,
+                    respect_ignores,
+                )
             {
                 let a_access = systems[index_a].component_access();
                 let b_access = systems[index_b].component_access();
@@ -182,24 +202,35 @@ impl SystemStage {
         }
 
         // TODO: remove all internal ambiguities and remove this logic
-        let ignored_crates = vec![
-            // Rendering
-            "bevy_render".to_string(),
-            "bevy_sprite".to_string(),
-            "bevy_render".to_string(),
-            "bevy_pbr".to_string(),
-            "bevy_text".to_string(),
-            "bevy_core_pipeline".to_string(),
-            "bevy_ui".to_string(),
-            // Misc
-            "bevy_winit".to_string(),
-            "bevy_audio".to_string(),
-        ];
-
-        let parallel = find_ambiguities(&self.parallel, &ignored_crates);
-        let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates);
-        let before_commands = find_ambiguities(&self.exclusive_before_commands, &ignored_crates);
-        let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates);
+        let ignored_crates = if *ambiguity_report < ReportExecutionOrderAmbiguities::ReportInternal
+        {
+            vec![
+                // Rendering
+                "bevy_render".to_string(),
+                "bevy_sprite".to_string(),
+                "bevy_render".to_string(),
+                "bevy_pbr".to_string(),
+                "bevy_text".to_string(),
+                "bevy_core_pipeline".to_string(),
+                "bevy_ui".to_string(),
+                // Misc
+                "bevy_winit".to_string(),
+                "bevy_audio".to_string(),
+            ]
+        } else {
+            Vec::default()
+        };
+
+        let respect_ignores = *ambiguity_report == ReportExecutionOrderAmbiguities::Deterministic;
+
+        let parallel = find_ambiguities(&self.parallel, &ignored_crates, respect_ignores);
+        let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates, respect_ignores);
+        let before_commands = find_ambiguities(
+            &self.exclusive_before_commands,
+            &ignored_crates,
+            respect_ignores,
+        );
+        let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates, respect_ignores);
 
         let mut unresolved_count = parallel.len();
         unresolved_count += at_start.len();
@@ -210,7 +241,7 @@ impl SystemStage {
             println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
 				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
 
-            if *ambiguity_report == ReportExecutionOrderAmbiguities::Minimal {
+            if *ambiguity_report <= ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 1ea7fd4735d55..11c250c66fe2f 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1409,7 +1409,7 @@ mod tests {
         fn find_ambiguities_first_str_labels(
             systems: &[impl SystemContainer],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            find_ambiguities(systems, &[])
+            find_ambiguities(systems, &[], true)
                 .drain(..)
                 .map(|(index_a, index_b, _conflicts)| {
                     (
@@ -1424,7 +1424,7 @@ mod tests {
             systems: &[impl SystemContainer],
             filter: &[String],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            let mut find_ambiguities = find_ambiguities(systems, filter);
+            let mut find_ambiguities = find_ambiguities(systems, filter, true);
 
             find_ambiguities
                 .drain(..)
@@ -1465,7 +1465,7 @@ mod tests {
             .with_system(empty.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel, &[]).len(), 0);
+        assert_eq!(find_ambiguities(&stage.parallel, &[], false).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.label("0"))
@@ -1505,7 +1505,7 @@ mod tests {
             .with_system(component.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel, &[]).len(), 0);
+        assert_eq!(find_ambiguities(&stage.parallel, &[], false).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
@@ -1739,7 +1739,10 @@ mod tests {
             .with_system(empty.exclusive_system().label("7").after("6"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.exclusive_at_start, &[]).len(), 0);
+        assert_eq!(
+            find_ambiguities(&stage.exclusive_at_start, &[], false).len(),
+            0
+        );
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().label("0").before("1").before("3"))
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 1ae83752e7372..68b3e5107cc07 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -2,11 +2,11 @@ use bevy::prelude::*;
 
 fn main() {
     App::new()
-        .add_plugins(MinimalPlugins)
+        .add_plugins(DefaultPlugins)
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
-        .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
+        .insert_resource(ReportExecutionOrderAmbiguities::Deterministic)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
         // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.

From 16fcfa90c9679dfde526b8e88ce6014c2b2ff2bb Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 14:16:21 -0400
Subject: [PATCH 061/113] Refactor to expose method to get ambiguities on
 SystemStage

---
 .../src/schedule/ambiguity_detection.rs       | 83 ++++++++++++-------
 1 file changed, 51 insertions(+), 32 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index f18843cb9d934..f3d56ed08d513 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -162,45 +162,29 @@ impl Default for ReportExecutionOrderAmbiguities {
 }
 
 impl SystemStage {
-    /// Logs execution order ambiguities between systems. System orders must be fresh.
-    pub fn report_ambiguities(&self, world: &mut World) {
+    /// Returns all execution order ambiguities between systems
+    ///
+    /// Returns 4 vectors of ambiguities for each stage, in the following order:
+    /// - parallel
+    /// - exclusive at start,
+    /// - exclusive before commands
+    /// - exclusive at end
+    pub fn ambiguities(&self, world: &mut World) -> [Vec<(usize, usize, Vec<ComponentId>)>; 4] {
         let ambiguity_report =
             world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
 
         if *ambiguity_report == ReportExecutionOrderAmbiguities::Off {
-            return;
+            return [
+                Vec::default(),
+                Vec::default(),
+                Vec::default(),
+                Vec::default(),
+            ];
         }
 
+        // System order must be fresh
         debug_assert!(!self.systems_modified);
 
-        fn write_display_names_of_pairs(
-            offset: usize,
-            systems: &[impl SystemContainer],
-            ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
-            world: &World,
-        ) -> usize {
-            for (i, (system_a_index, system_b_index, conflicting_indexes)) in
-                ambiguities.iter().enumerate()
-            {
-                let _system_a_name = systems[*system_a_index].name();
-                let _system_b_name = systems[*system_b_index].name();
-
-                let _conflicting_components = conflicting_indexes
-                    .iter()
-                    .map(|id| world.components().get_info(*id).unwrap().name())
-                    .collect::<Vec<_>>();
-
-                let _ambiguity_number = i + offset;
-
-                println!(
-						"{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicting_components:?}"
-					);
-            }
-
-            // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
-            ambiguities.len()
-        }
-
         // TODO: remove all internal ambiguities and remove this logic
         let ignored_crates = if *ambiguity_report < ReportExecutionOrderAmbiguities::ReportInternal
         {
@@ -232,6 +216,14 @@ impl SystemStage {
         );
         let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates, respect_ignores);
 
+        [parallel, at_start, before_commands, at_end]
+    }
+
+    /// Reports all execution order ambiguities between systems
+    pub fn report_ambiguities(&self, world: &mut World) {
+        let [parallel, at_start, before_commands, at_end] = self.ambiguities(world);
+        let &ambiguity_report = world.resource::<ReportExecutionOrderAmbiguities>();
+
         let mut unresolved_count = parallel.len();
         unresolved_count += at_start.len();
         unresolved_count += before_commands.len();
@@ -241,7 +233,7 @@ impl SystemStage {
             println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
 				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
 
-            if *ambiguity_report <= ReportExecutionOrderAmbiguities::Minimal {
+            if ambiguity_report <= ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
@@ -261,3 +253,30 @@ impl SystemStage {
         }
     }
 }
+
+fn write_display_names_of_pairs(
+    offset: usize,
+    systems: &[impl SystemContainer],
+    ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
+    world: &World,
+) -> usize {
+    for (i, (system_a_index, system_b_index, conflicting_indexes)) in ambiguities.iter().enumerate()
+    {
+        let _system_a_name = systems[*system_a_index].name();
+        let _system_b_name = systems[*system_b_index].name();
+
+        let _conflicting_components = conflicting_indexes
+            .iter()
+            .map(|id| world.components().get_info(*id).unwrap().name())
+            .collect::<Vec<_>>();
+
+        let _ambiguity_number = i + offset;
+
+        println!(
+                "{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicting_components:?}"
+            );
+    }
+
+    // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
+    ambiguities.len()
+}

From 6924d0cfe95b05e4b9bedc0e6c57de9793a894f5 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 14:29:03 -0400
Subject: [PATCH 062/113] Refactored (usize, usize, Vec<ComponentId>) into
 SystemOrderAmbiguity

---
 .../src/schedule/ambiguity_detection.rs       | 44 ++++++++++++++-----
 crates/bevy_ecs/src/schedule/stage.rs         | 12 ++---
 examples/ecs/ambiguity_checker.rs             |  2 +-
 3 files changed, 40 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index f3d56ed08d513..9b0121377397e 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -49,15 +49,29 @@ pub enum ReportExecutionOrderAmbiguities {
     Deterministic,
 }
 
+/// A pair of systems that can run in an ambiguous order
+///
+/// Created by applying [`find_ambiguities`] to a [`SystemContainer`].
+/// These can be reported by configuring the [`ReportExecutionOrderAmbiguities`] resource.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SystemOrderAmbiguity {
+    // The index of the first system in the [`SystemContainer`]
+    pub system_a_index: usize,
+    // The index of the second system in the [`SystemContainer`]
+    pub system_b_index: usize,
+    /// The components (and resources) that these systems have incompatible access to
+    pub conflicts: Vec<ComponentId>,
+}
+
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
 /// along with specific components that have triggered the warning.
 /// Systems must be topologically sorted beforehand.
-pub(super) fn find_ambiguities(
+pub fn find_ambiguities(
     systems: &[impl SystemContainer],
     crates_filter: &[String],
     // Should explicit attempts to ignore ambiguities be obeyed?
     respect_ignores: bool,
-) -> Vec<(usize, usize, Vec<ComponentId>)> {
+) -> Vec<SystemOrderAmbiguity> {
     fn should_ignore_ambiguity(
         systems: &[impl SystemContainer],
         index_a: usize,
@@ -143,10 +157,18 @@ pub(super) fn find_ambiguities(
                 if let (Some(a), Some(b)) = (a_access, b_access) {
                     let conflicts = a.get_conflicts(b);
                     if !conflicts.is_empty() {
-                        ambiguities.push((index_a, index_b, conflicts));
+                        ambiguities.push(SystemOrderAmbiguity {
+                            system_a_index: index_a,
+                            system_b_index: index_b,
+                            conflicts,
+                        });
                     }
                 } else {
-                    ambiguities.push((index_a, index_b, Vec::new()));
+                    ambiguities.push(SystemOrderAmbiguity {
+                        system_a_index: index_a,
+                        system_b_index: index_b,
+                        conflicts: Vec::default(),
+                    });
                 }
             }
         }
@@ -169,7 +191,7 @@ impl SystemStage {
     /// - exclusive at start,
     /// - exclusive before commands
     /// - exclusive at end
-    pub fn ambiguities(&self, world: &mut World) -> [Vec<(usize, usize, Vec<ComponentId>)>; 4] {
+    pub fn ambiguities(&self, world: &mut World) -> [Vec<SystemOrderAmbiguity>; 4] {
         let ambiguity_report =
             world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
 
@@ -257,15 +279,15 @@ impl SystemStage {
 fn write_display_names_of_pairs(
     offset: usize,
     systems: &[impl SystemContainer],
-    ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
+    ambiguities: Vec<SystemOrderAmbiguity>,
     world: &World,
 ) -> usize {
-    for (i, (system_a_index, system_b_index, conflicting_indexes)) in ambiguities.iter().enumerate()
-    {
-        let _system_a_name = systems[*system_a_index].name();
-        let _system_b_name = systems[*system_b_index].name();
+    for (i, system_order_ambiguity) in ambiguities.iter().enumerate() {
+        let _system_a_name = systems[system_order_ambiguity.system_a_index].name();
+        let _system_b_name = systems[system_order_ambiguity.system_b_index].name();
 
-        let _conflicting_components = conflicting_indexes
+        let _conflicting_components = system_order_ambiguity
+            .conflicts
             .iter()
             .map(|id| world.components().get_info(*id).unwrap().name())
             .collect::<Vec<_>>();
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 11c250c66fe2f..8424b9eeedf74 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1411,10 +1411,10 @@ mod tests {
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
             find_ambiguities(systems, &[], true)
                 .drain(..)
-                .map(|(index_a, index_b, _conflicts)| {
+                .map(|ambiguity| {
                     (
-                        systems[index_a].labels()[0].clone(),
-                        systems[index_b].labels()[0].clone(),
+                        systems[ambiguity.system_a_index].labels()[0].clone(),
+                        systems[ambiguity.system_a_index].labels()[0].clone(),
                     )
                 })
                 .collect()
@@ -1428,15 +1428,15 @@ mod tests {
 
             find_ambiguities
                 .drain(..)
-                .map(|(index_a, index_b, _conflicts)| {
+                .map(|ambiguity| {
                     (
-                        systems[index_a]
+                        systems[ambiguity.system_a_index]
                             .labels()
                             .iter()
                             .find(|a| (&***a).type_id() == std::any::TypeId::of::<&str>())
                             .unwrap()
                             .clone(),
-                        systems[index_b]
+                        systems[ambiguity.system_a_index]
                             .labels()
                             .iter()
                             .find(|a| (&***a).type_id() == std::any::TypeId::of::<&str>())
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 68b3e5107cc07..7199b941cd467 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -6,7 +6,7 @@ fn main() {
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
-        .insert_resource(ReportExecutionOrderAmbiguities::Deterministic)
+        .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
         // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.

From 402388c0f1d789ce1edffdb593ea5b1483c8a6b6 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 14:55:05 -0400
Subject: [PATCH 063/113] Explicitly pass in a reporting level

---
 .../src/schedule/ambiguity_detection.rs       | 66 +++++++++++++++----
 crates/bevy_ecs/src/schedule/stage.rs         | 13 ++--
 2 files changed, 63 insertions(+), 16 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 9b0121377397e..37572f59ab157 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -191,11 +191,11 @@ impl SystemStage {
     /// - exclusive at start,
     /// - exclusive before commands
     /// - exclusive at end
-    pub fn ambiguities(&self, world: &mut World) -> [Vec<SystemOrderAmbiguity>; 4] {
-        let ambiguity_report =
-            world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
-
-        if *ambiguity_report == ReportExecutionOrderAmbiguities::Off {
+    pub fn ambiguities(
+        &self,
+        report_level: ReportExecutionOrderAmbiguities,
+    ) -> [Vec<SystemOrderAmbiguity>; 4] {
+        if report_level == ReportExecutionOrderAmbiguities::Off {
             return [
                 Vec::default(),
                 Vec::default(),
@@ -208,8 +208,7 @@ impl SystemStage {
         debug_assert!(!self.systems_modified);
 
         // TODO: remove all internal ambiguities and remove this logic
-        let ignored_crates = if *ambiguity_report < ReportExecutionOrderAmbiguities::ReportInternal
-        {
+        let ignored_crates = if report_level < ReportExecutionOrderAmbiguities::ReportInternal {
             vec![
                 // Rendering
                 "bevy_render".to_string(),
@@ -227,7 +226,7 @@ impl SystemStage {
             Vec::default()
         };
 
-        let respect_ignores = *ambiguity_report == ReportExecutionOrderAmbiguities::Deterministic;
+        let respect_ignores = report_level == ReportExecutionOrderAmbiguities::Deterministic;
 
         let parallel = find_ambiguities(&self.parallel, &ignored_crates, respect_ignores);
         let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates, respect_ignores);
@@ -242,9 +241,8 @@ impl SystemStage {
     }
 
     /// Reports all execution order ambiguities between systems
-    pub fn report_ambiguities(&self, world: &mut World) {
-        let [parallel, at_start, before_commands, at_end] = self.ambiguities(world);
-        let &ambiguity_report = world.resource::<ReportExecutionOrderAmbiguities>();
+    pub fn report_ambiguities(&self, world: &World, report_level: ReportExecutionOrderAmbiguities) {
+        let [parallel, at_start, before_commands, at_end] = self.ambiguities(report_level);
 
         let mut unresolved_count = parallel.len();
         unresolved_count += at_start.len();
@@ -255,7 +253,7 @@ impl SystemStage {
             println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
 				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
 
-            if ambiguity_report <= ReportExecutionOrderAmbiguities::Minimal {
+            if report_level <= ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
@@ -302,3 +300,47 @@ fn write_display_names_of_pairs(
     // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
     ambiguities.len()
 }
+
+mod tests {
+    use crate::prelude::*;
+
+    struct TestResource;
+
+    fn system_a(_res: ResMut<TestResource>) {}
+    fn system_b(_res: ResMut<TestResource>) {}
+    fn system_c(_res: ResMut<TestResource>) {}
+    fn system_d(_res: ResMut<TestResource>) {}
+
+    fn make_test_stage() -> SystemStage {
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            // Ambiguous with B and D
+            .add_system(system_a)
+            // Ambiguous with A
+            .add_system(system_b.label("b"))
+            .add_system(system_c.ignore_all_ambiguities())
+            // Ambiguous with A
+            .add_system(system_d.ambiguous_with("b"));
+
+        test_stage
+    }
+
+    #[test]
+    fn off() {
+        let test_stage = make_test_stage();
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Off);
+    }
+
+    #[test]
+    fn minimal() {}
+
+    #[test]
+    fn verbose() {}
+
+    #[test]
+    fn deterministic() {}
+
+    #[test]
+    fn ignore_internal() {}
+}
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 8424b9eeedf74..4aea9a422d68f 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -4,9 +4,10 @@ use crate::{
         graph_utils::{self, DependencyGraphError},
         BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
         ExclusiveSystemContainer, GraphNode, InsertionPoint, IntoSystemDescriptor,
-        ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor, RunCriteriaContainer,
-        RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun,
-        SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
+        ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor,
+        ReportExecutionOrderAmbiguities, RunCriteriaContainer, RunCriteriaDescriptor,
+        RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun, SingleThreadedExecutor,
+        SystemContainer, SystemDescriptor, SystemSet,
     },
     world::{World, WorldId},
 };
@@ -607,7 +608,11 @@ impl Stage for SystemStage {
             self.systems_modified = false;
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
-            self.report_ambiguities(world);
+            // This cannot panic, so we insert the default value if it was not present
+            let report_level = world
+                .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default)
+                .clone();
+            self.report_ambiguities(world, report_level);
         } else if self.executor_modified {
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;

From 746c0c642a59e3ae766322470806ff7e96346f1a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 15:24:56 -0400
Subject: [PATCH 064/113] Basic tests for ambiguity reporting levels

---
 .../src/schedule/ambiguity_detection.rs       | 52 +++++++++++++++++--
 1 file changed, 48 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 37572f59ab157..1c61ad086bb97 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -301,6 +301,9 @@ fn write_display_names_of_pairs(
     ambiguities.len()
 }
 
+// Systems and TestResource are used in tests
+#[allow(dead_code)]
+#[cfg(test)]
 mod tests {
     use crate::prelude::*;
 
@@ -326,21 +329,62 @@ mod tests {
         test_stage
     }
 
+    /// Mocking internal functionality
+    mod bevy_render {
+        use super::*;
+
+        pub(super) fn system_e(_res: ResMut<TestResource>) {}
+
+        pub(super) fn system_f(_res: ResMut<TestResource>) {}
+    }
+
     #[test]
     fn off() {
         let test_stage = make_test_stage();
         let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Off);
+        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+
+        assert_eq!(n_ambiguities, 0);
     }
 
     #[test]
-    fn minimal() {}
+    fn minimal() {
+        let test_stage = make_test_stage();
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Minimal);
+        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+
+        assert_eq!(n_ambiguities, 3);
+    }
 
     #[test]
-    fn verbose() {}
+    fn verbose() {
+        let test_stage = make_test_stage();
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Verbose);
+        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+
+        assert_eq!(n_ambiguities, 3);
+    }
 
     #[test]
-    fn deterministic() {}
+    fn deterministic() {
+        let test_stage = make_test_stage();
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Deterministic);
+        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+
+        assert_eq!(n_ambiguities, 6);
+    }
 
     #[test]
-    fn ignore_internal() {}
+    fn report_internal() {
+        let mut test_stage = make_test_stage();
+        test_stage.add_system(bevy_render::system_e);
+        test_stage.add_system(bevy_render::system_f);
+
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::ReportInternal);
+        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+
+        // Ambiguities between external systems and internal systems should be reported
+        // but not internal ambiguities
+        assert_eq!(n_ambiguities, 5);
+    }
 }

From 7a90186d9f073ff5aaf62a1520f8d95620110c07 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 15:39:25 -0400
Subject: [PATCH 065/113] Initialize schedules for tests

---
 .../src/schedule/ambiguity_detection.rs       | 31 +++++++++++++++----
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 1c61ad086bb97..47dffa16c08c1 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -316,6 +316,8 @@ mod tests {
 
     fn make_test_stage() -> SystemStage {
         let mut test_stage = SystemStage::parallel();
+        let mut world = World::new();
+        world.insert_resource(TestResource);
 
         test_stage
             // Ambiguous with B and D
@@ -326,6 +328,9 @@ mod tests {
             // Ambiguous with A
             .add_system(system_d.ambiguous_with("b"));
 
+        // This is a bit of a hack: we need to ensure that the schedule has been properly initialized
+        // and the best public way to do that is to run it once
+        test_stage.run(&mut world);
         test_stage
     }
 
@@ -376,15 +381,29 @@ mod tests {
 
     #[test]
     fn report_internal() {
-        let mut test_stage = make_test_stage();
-        test_stage.add_system(bevy_render::system_e);
-        test_stage.add_system(bevy_render::system_f);
+        let mut test_stage = SystemStage::parallel();
+        let mut world = World::new();
+        world.insert_resource(TestResource);
+
+        test_stage
+            // Ambiguous with E and F
+            .add_system(system_a)
+            // Internal ambiguities are ignored by default
+            .add_system(bevy_render::system_e)
+            .add_system(bevy_render::system_f);
+
+        // This is a bit of a hack: we need to ensure that the schedule has been properly initialized
+        // and the best public way to do that is to run it once
+        test_stage.run(&mut world);
+
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Verbose);
+        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+
+        assert_eq!(n_ambiguities, 2);
 
         let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::ReportInternal);
         let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
 
-        // Ambiguities between external systems and internal systems should be reported
-        // but not internal ambiguities
-        assert_eq!(n_ambiguities, 5);
+        assert_eq!(n_ambiguities, 3);
     }
 }

From f9075bafb9e6656160a6e642f1232734dbc3a0c0 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 16:01:28 -0400
Subject: [PATCH 066/113] Expose n_ambiguities method on SystemStage

---
 .../src/schedule/ambiguity_detection.rs       | 54 ++++++++++---------
 1 file changed, 30 insertions(+), 24 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 47dffa16c08c1..f634eaac128bc 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -240,6 +240,12 @@ impl SystemStage {
         [parallel, at_start, before_commands, at_end]
     }
 
+    /// Returns the number of system order ambiguities between systems in this stage
+    pub fn n_ambiguities(&self, report_level: ReportExecutionOrderAmbiguities) -> usize {
+        let ambiguities = self.ambiguities(report_level);
+        ambiguities.map(|vec| vec.len()).iter().sum()
+    }
+
     /// Reports all execution order ambiguities between systems
     pub fn report_ambiguities(&self, world: &World, report_level: ReportExecutionOrderAmbiguities) {
         let [parallel, at_start, before_commands, at_end] = self.ambiguities(report_level);
@@ -346,37 +352,37 @@ mod tests {
     #[test]
     fn off() {
         let test_stage = make_test_stage();
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Off);
-        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
-
-        assert_eq!(n_ambiguities, 0);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Off),
+            0
+        );
     }
 
     #[test]
     fn minimal() {
         let test_stage = make_test_stage();
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Minimal);
-        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
-
-        assert_eq!(n_ambiguities, 3);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            3
+        );
     }
 
     #[test]
     fn verbose() {
         let test_stage = make_test_stage();
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Verbose);
-        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
-
-        assert_eq!(n_ambiguities, 3);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Verbose),
+            3
+        );
     }
 
     #[test]
     fn deterministic() {
         let test_stage = make_test_stage();
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Deterministic);
-        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
-
-        assert_eq!(n_ambiguities, 6);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            6
+        );
     }
 
     #[test]
@@ -396,14 +402,14 @@ mod tests {
         // and the best public way to do that is to run it once
         test_stage.run(&mut world);
 
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Verbose);
-        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
-
-        assert_eq!(n_ambiguities, 2);
-
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::ReportInternal);
-        let n_ambiguities: usize = ambiguities.map(|vec| vec.len()).iter().sum();
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Verbose),
+            2
+        );
 
-        assert_eq!(n_ambiguities, 3);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::ReportInternal),
+            3
+        );
     }
 }

From 3452c2b145594064197fe50bfd6ef6c1ac1bf8c7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 16:12:42 -0400
Subject: [PATCH 067/113] Expose SystemStage::initialize

---
 .../src/schedule/ambiguity_detection.rs       | 14 ++++---
 crates/bevy_ecs/src/schedule/stage.rs         | 38 +++++++++++--------
 2 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index f634eaac128bc..51235dd998ba5 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -191,6 +191,10 @@ impl SystemStage {
     /// - exclusive at start,
     /// - exclusive before commands
     /// - exclusive at end
+    ///
+    /// # Panics
+    ///
+    /// You must call [`SystemStage::initialize`] first or this method will panic.
     pub fn ambiguities(
         &self,
         report_level: ReportExecutionOrderAmbiguities,
@@ -334,9 +338,8 @@ mod tests {
             // Ambiguous with A
             .add_system(system_d.ambiguous_with("b"));
 
-        // This is a bit of a hack: we need to ensure that the schedule has been properly initialized
-        // and the best public way to do that is to run it once
-        test_stage.run(&mut world);
+        // We need to ensure that the schedule has been properly initialized
+        test_stage.initialize(&mut world);
         test_stage
     }
 
@@ -398,9 +401,8 @@ mod tests {
             .add_system(bevy_render::system_e)
             .add_system(bevy_render::system_f);
 
-        // This is a bit of a hack: we need to ensure that the schedule has been properly initialized
-        // and the best public way to do that is to run it once
-        test_stage.run(&mut world);
+        // We need to ensure that the schedule has been properly initialized
+        test_stage.initialize(&mut world);
 
         assert_eq!(
             test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Verbose),
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 4aea9a422d68f..94cd295b64214 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -99,6 +99,28 @@ impl SystemStage {
         Self::new(Box::new(ParallelExecutor::default()))
     }
 
+    /// Initializes this [`SystemStage`] on a specific world, ensuring that its internal state is valid
+    ///
+    /// This method is automatically called by [`Stage::run`], but must be manually called
+    /// when using [`SystemStage::ambiguities`].
+    pub fn initialize(&mut self, world: &mut World) {
+        if self.systems_modified {
+            self.initialize_systems(world);
+            self.rebuild_orders_and_dependencies();
+            self.systems_modified = false;
+            self.executor.rebuild_cached_data(&self.parallel);
+            self.executor_modified = false;
+            // This cannot panic, so we insert the default value if it was not present
+            let report_level = world
+                .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default)
+                .clone();
+            self.report_ambiguities(world, report_level);
+        } else if self.executor_modified {
+            self.executor.rebuild_cached_data(&self.parallel);
+            self.executor_modified = false;
+        }
+    }
+
     pub fn get_executor<T: ParallelSystemExecutor>(&self) -> Option<&T> {
         self.executor.downcast_ref()
     }
@@ -602,21 +624,7 @@ impl Stage for SystemStage {
             self.world_id = Some(world.id());
         }
 
-        if self.systems_modified {
-            self.initialize_systems(world);
-            self.rebuild_orders_and_dependencies();
-            self.systems_modified = false;
-            self.executor.rebuild_cached_data(&self.parallel);
-            self.executor_modified = false;
-            // This cannot panic, so we insert the default value if it was not present
-            let report_level = world
-                .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default)
-                .clone();
-            self.report_ambiguities(world, report_level);
-        } else if self.executor_modified {
-            self.executor.rebuild_cached_data(&self.parallel);
-            self.executor_modified = false;
-        }
+        self.initialize(world);
 
         let mut run_stage_loop = true;
         while run_stage_loop {

From e8c2c0a9c936792733d27ba12321fbca2d0f5034 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 16:33:55 -0400
Subject: [PATCH 068/113] More tests

---
 .../src/schedule/ambiguity_detection.rs       | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 51235dd998ba5..6497a7207ad18 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -352,6 +352,64 @@ mod tests {
         pub(super) fn system_f(_res: ResMut<TestResource>) {}
     }
 
+    #[test]
+    fn trivial_ambiguity() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+        test_stage.add_system(system_a).add_system(system_b);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            1
+        );
+    }
+
+    #[test]
+    fn ignore_all_ambiguities() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+        test_stage
+            .add_system(system_a.ignore_all_ambiguities())
+            .add_system(system_b);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            0
+        );
+    }
+
+    #[test]
+    fn ambiguous_with_label() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+        test_stage
+            .add_system(system_a.ambiguous_with("b"))
+            .add_system(system_b.label("b"));
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            0
+        );
+    }
+
+    #[test]
+    fn ambiguous_with_system() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+        test_stage
+            .add_system(system_a.ambiguous_with(system_b))
+            .add_system(system_b);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            0
+        );
+    }
+
     #[test]
     fn off() {
         let test_stage = make_test_stage();

From c3906a2a8f8271f24351ebd097d30847b52d4b0c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 16:51:07 -0400
Subject: [PATCH 069/113] Fix logic for ignoring ambiguities

---
 .../src/schedule/ambiguity_detection.rs       | 28 ++++++---------
 crates/bevy_ecs/src/schedule/stage.rs         | 36 ++++++++++++++++---
 2 files changed, 41 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 6497a7207ad18..3a26eb7c80544 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -70,16 +70,16 @@ pub fn find_ambiguities(
     systems: &[impl SystemContainer],
     crates_filter: &[String],
     // Should explicit attempts to ignore ambiguities be obeyed?
-    respect_ignores: bool,
+    report_level: ReportExecutionOrderAmbiguities,
 ) -> Vec<SystemOrderAmbiguity> {
     fn should_ignore_ambiguity(
         systems: &[impl SystemContainer],
         index_a: usize,
         index_b: usize,
         crates_filter: &[String],
-        respect_ignores: bool,
+        report_level: ReportExecutionOrderAmbiguities,
     ) -> bool {
-        if !respect_ignores {
+        if report_level == ReportExecutionOrderAmbiguities::Deterministic {
             return false;
         }
 
@@ -144,13 +144,7 @@ pub fn find_ambiguities(
         // .take(index_a)
         {
             if !processed.contains(index_b)
-                && !should_ignore_ambiguity(
-                    systems,
-                    index_a,
-                    index_b,
-                    crates_filter,
-                    respect_ignores,
-                )
+                && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter, report_level)
             {
                 let a_access = systems[index_a].component_access();
                 let b_access = systems[index_b].component_access();
@@ -230,16 +224,14 @@ impl SystemStage {
             Vec::default()
         };
 
-        let respect_ignores = report_level == ReportExecutionOrderAmbiguities::Deterministic;
-
-        let parallel = find_ambiguities(&self.parallel, &ignored_crates, respect_ignores);
-        let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates, respect_ignores);
+        let parallel = find_ambiguities(&self.parallel, &ignored_crates, report_level);
+        let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates, report_level);
         let before_commands = find_ambiguities(
             &self.exclusive_before_commands,
             &ignored_crates,
-            respect_ignores,
+            report_level,
         );
-        let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates, respect_ignores);
+        let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates, report_level);
 
         [parallel, at_start, before_commands, at_end]
     }
@@ -424,7 +416,7 @@ mod tests {
         let test_stage = make_test_stage();
         assert_eq!(
             test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
-            3
+            2
         );
     }
 
@@ -433,7 +425,7 @@ mod tests {
         let test_stage = make_test_stage();
         assert_eq!(
             test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Verbose),
-            3
+            2
         );
     }
 
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 94cd295b64214..7eaa6d2c6b659 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1418,11 +1418,12 @@ mod tests {
         use super::SystemContainer;
         use crate::schedule::find_ambiguities;
         use crate::schedule::BoxedSystemLabel;
+        use crate::schedule::ReportExecutionOrderAmbiguities;
 
         fn find_ambiguities_first_str_labels(
             systems: &[impl SystemContainer],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            find_ambiguities(systems, &[], true)
+            find_ambiguities(systems, &[], ReportExecutionOrderAmbiguities::Deterministic)
                 .drain(..)
                 .map(|ambiguity| {
                     (
@@ -1437,7 +1438,11 @@ mod tests {
             systems: &[impl SystemContainer],
             filter: &[String],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            let mut find_ambiguities = find_ambiguities(systems, filter, true);
+            let mut find_ambiguities = find_ambiguities(
+                systems,
+                filter,
+                ReportExecutionOrderAmbiguities::Deterministic,
+            );
 
             find_ambiguities
                 .drain(..)
@@ -1478,7 +1483,15 @@ mod tests {
             .with_system(empty.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel, &[], false).len(), 0);
+        assert_eq!(
+            find_ambiguities(
+                &stage.parallel,
+                &[],
+                ReportExecutionOrderAmbiguities::Deterministic
+            )
+            .len(),
+            0
+        );
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.label("0"))
@@ -1518,7 +1531,15 @@ mod tests {
             .with_system(component.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel, &[], false).len(), 0);
+        assert_eq!(
+            find_ambiguities(
+                &stage.parallel,
+                &[],
+                ReportExecutionOrderAmbiguities::Deterministic
+            )
+            .len(),
+            0
+        );
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
@@ -1753,7 +1774,12 @@ mod tests {
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         assert_eq!(
-            find_ambiguities(&stage.exclusive_at_start, &[], false).len(),
+            find_ambiguities(
+                &stage.exclusive_at_start,
+                &[],
+                ReportExecutionOrderAmbiguities::Deterministic
+            )
+            .len(),
             0
         );
 

From 216bd1aa0247e17d2d2ae648b3e1d5522e6661a9 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 16:57:42 -0400
Subject: [PATCH 070/113] Remove error-prone Ord and PartialOrd traits

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

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 3a26eb7c80544..e8655d5b0586c 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -4,7 +4,7 @@ use crate::world::World;
 
 use fixedbitset::FixedBitSet;
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 /// Systems that access the same Component or Resource within the same stage
 /// risk an ambiguous order that could result in logic bugs, unless they have an
 /// explicit execution ordering constraint between them.
@@ -206,7 +206,7 @@ impl SystemStage {
         debug_assert!(!self.systems_modified);
 
         // TODO: remove all internal ambiguities and remove this logic
-        let ignored_crates = if report_level < ReportExecutionOrderAmbiguities::ReportInternal {
+        let ignored_crates = if report_level != ReportExecutionOrderAmbiguities::ReportInternal {
             vec![
                 // Rendering
                 "bevy_render".to_string(),
@@ -255,7 +255,7 @@ impl SystemStage {
             println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
 				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
 
-            if report_level <= ReportExecutionOrderAmbiguities::Minimal {
+            if report_level == ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 // TODO: clean up this logic once exclusive systems are more compatible with parallel systems

From 84ef1a700ca022dce2cbd7cf8437205661c87b84 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 16:58:39 -0400
Subject: [PATCH 071/113] Remove report_internal test

---
 .../src/schedule/ambiguity_detection.rs       | 27 -------------------
 1 file changed, 27 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index e8655d5b0586c..caffe49fab1dc 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -437,31 +437,4 @@ mod tests {
             6
         );
     }
-
-    #[test]
-    fn report_internal() {
-        let mut test_stage = SystemStage::parallel();
-        let mut world = World::new();
-        world.insert_resource(TestResource);
-
-        test_stage
-            // Ambiguous with E and F
-            .add_system(system_a)
-            // Internal ambiguities are ignored by default
-            .add_system(bevy_render::system_e)
-            .add_system(bevy_render::system_f);
-
-        // We need to ensure that the schedule has been properly initialized
-        test_stage.initialize(&mut world);
-
-        assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Verbose),
-            2
-        );
-
-        assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::ReportInternal),
-            3
-        );
-    }
 }

From 4e11653ecbbcc666abf4579f1a10c2f075df3768 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Tue, 29 Mar 2022 17:00:25 -0400
Subject: [PATCH 072/113] Split error message by singular and plural for
 grammar purposes

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

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index caffe49fab1dc..02c3356572fdd 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -252,8 +252,14 @@ impl SystemStage {
         unresolved_count += at_end.len();
 
         if unresolved_count > 0 {
-            println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
+            // Grammar
+            if unresolved_count == 1 {
+                println!("\n One of your stages contains 1 pair of systems with unknown order and conflicting data access. \
 				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
+            } else {
+                println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
+				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
+            }
 
             if report_level == ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");

From 94c67c53bb6a45d1a9e7437190c490eada1380a0 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 11:46:14 -0400
Subject: [PATCH 073/113] Add internal_ambiguities dev example

---
 Cargo.toml                             |  4 ++++
 examples/tools/internal_ambiguities.rs | 11 +++++++++++
 2 files changed, 15 insertions(+)
 create mode 100644 examples/tools/internal_ambiguities.rs

diff --git a/Cargo.toml b/Cargo.toml
index 83cc110256407..c5193c920d8ac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -548,6 +548,10 @@ path = "examples/stress_tests/transform_hierarchy.rs"
 
 # Tools
 
+[[example]]
+name = "internal_ambiguities"
+path = "examples/tools/internal_ambiguities.rs"
+
 [[example]]
 name = "scene_viewer"
 path = "examples/tools/scene_viewer.rs"
diff --git a/examples/tools/internal_ambiguities.rs b/examples/tools/internal_ambiguities.rs
new file mode 100644
index 0000000000000..675802b934282
--- /dev/null
+++ b/examples/tools/internal_ambiguities.rs
@@ -0,0 +1,11 @@
+//! Reports any Bevy-internal system-order ambiguities
+//! This is primarily useful for engine development
+
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(ReportExecutionOrderAmbiguities::ReportInternal)
+        .run()
+}

From 5bd467ddb44bce47fa0e5e0bbbe0296f12654314 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 11:51:33 -0400
Subject: [PATCH 074/113] Add bevy_hierarchy to the internal blacklist

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 02c3356572fdd..0d1136783caf3 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -216,6 +216,7 @@ impl SystemStage {
                 "bevy_text".to_string(),
                 "bevy_core_pipeline".to_string(),
                 "bevy_ui".to_string(),
+                "bevy_hierarchy".to_string(),
                 // Misc
                 "bevy_winit".to_string(),
                 "bevy_audio".to_string(),

From ee09475d4f01d3a051e646d968c32e50372f3eda Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 12:06:02 -0400
Subject: [PATCH 075/113] Use stage.initialize in tests

---
 crates/bevy_ecs/src/schedule/stage.rs | 69 +++++++++------------------
 1 file changed, 23 insertions(+), 46 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 7eaa6d2c6b659..0f3b028993f07 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1481,8 +1481,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(empty.label("3").after("2").before("4"))
             .with_system(empty.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         assert_eq!(
             find_ambiguities(
                 &stage.parallel,
@@ -1499,8 +1498,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(empty.label("3").after("2").before("4"))
             .with_system(component.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("4")))
@@ -1514,8 +1512,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(empty.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("4")))
@@ -1529,8 +1526,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(empty.label("3").after("2").before("4"))
             .with_system(component.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         assert_eq!(
             find_ambiguities(
                 &stage.parallel,
@@ -1547,8 +1543,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("0"), Box::new("3")))
@@ -1572,8 +1567,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4").ambiguous_with("a").label("a"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("0"), Box::new("3")))
@@ -1585,8 +1579,7 @@ mod tests {
             .with_system(component.label("0").before("2"))
             .with_system(component.label("1").before("2"))
             .with_system(component.label("2"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("0"), Box::new("1")))
@@ -1598,8 +1591,7 @@ mod tests {
             .with_system(component.label("0"))
             .with_system(component.label("1").after("0"))
             .with_system(component.label("2").after("0"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("2")))
@@ -1612,8 +1604,7 @@ mod tests {
             .with_system(component.label("1"))
             .with_system(component.label("2"))
             .with_system(component.label("3").after("1").after("2"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("2")))
@@ -1626,8 +1617,7 @@ mod tests {
             .with_system(component.label("1").ambiguous_with("a").label("a"))
             .with_system(component.label("2").ambiguous_with("a").label("a"))
             .with_system(component.label("3").after("1").after("2"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
 
@@ -1636,8 +1626,7 @@ mod tests {
             .with_system(component.label("1").ambiguous_with("a").label("a"))
             .with_system(component.label("2").ambiguous_with("a").label("a"))
             .with_system(component.label("3").after("1").after("2"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("2")))
@@ -1666,8 +1655,7 @@ mod tests {
                     .after("3")
                     .after("4"),
             );
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("2")))
@@ -1716,8 +1704,7 @@ mod tests {
                     .after("3")
                     .after("4"),
             );
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
 
@@ -1749,8 +1736,7 @@ mod tests {
                     .after("3")
                     .after("4"),
             );
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("4")))
@@ -1771,8 +1757,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("5").after("4"))
             .with_system(empty.exclusive_system().label("6").after("5"))
             .with_system(empty.exclusive_system().label("7").after("6"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         assert_eq!(
             find_ambiguities(
                 &stage.exclusive_at_start,
@@ -1791,8 +1776,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("4").after("3").before("5"))
             .with_system(empty.exclusive_system().label("5"))
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("3")))
@@ -1846,8 +1830,7 @@ mod tests {
                     .label("a"),
             )
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
         assert!(
             ambiguities.contains(&(Box::new("2"), Box::new("3")))
@@ -1896,8 +1879,7 @@ mod tests {
                     .ambiguous_with("a")
                     .label("a"),
             );
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
         assert_eq!(ambiguities.len(), 0);
 
@@ -1907,8 +1889,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("0"), Box::new("3")))
@@ -1922,8 +1903,7 @@ mod tests {
             .with_system(empty.label("2"))
             .with_system(component.label("3").after("2").before("4"))
             .with_system(resource.label("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
 
@@ -1950,8 +1930,7 @@ mod tests {
                     .silence_ambiguity_checks(),
             )
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
         assert!(
             ambiguities.contains(&(Box::new("2"), Box::new("4")))
@@ -1971,8 +1950,7 @@ mod tests {
                     .ambiguous_with("0"),
             )
             .with_system(resource.label("4").ambiguous_with("4"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
         assert!(
             ambiguities.contains(&(Box::new("1"), Box::new("4")))
@@ -1983,8 +1961,7 @@ mod tests {
         let mut stage = SystemStage::parallel()
             .with_system(resource.label("1"))
             .with_system(inner::inner_fn.label("2"));
-        stage.initialize_systems(&mut world);
-        stage.rebuild_orders_and_dependencies();
+        stage.initialize(&mut world);
         let ambiguities = find_ambiguities_first_str_labels_with_filter(
             &stage.parallel,
             &["bevy_ecs::schedule::stage::tests::ambiguity_detection::inner::".into()],

From 20306ceb65af3d894da71972e87ec1f5660a83a3 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 12:22:33 -0400
Subject: [PATCH 076/113] Yeet giant test

---
 crates/bevy_ecs/src/schedule/stage.rs | 556 --------------------------
 1 file changed, 556 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 0f3b028993f07..7487836186c84 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1413,562 +1413,6 @@ mod tests {
         stage.run(&mut world);
     }
 
-    #[test]
-    fn ambiguity_detection() {
-        use super::SystemContainer;
-        use crate::schedule::find_ambiguities;
-        use crate::schedule::BoxedSystemLabel;
-        use crate::schedule::ReportExecutionOrderAmbiguities;
-
-        fn find_ambiguities_first_str_labels(
-            systems: &[impl SystemContainer],
-        ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            find_ambiguities(systems, &[], ReportExecutionOrderAmbiguities::Deterministic)
-                .drain(..)
-                .map(|ambiguity| {
-                    (
-                        systems[ambiguity.system_a_index].labels()[0].clone(),
-                        systems[ambiguity.system_a_index].labels()[0].clone(),
-                    )
-                })
-                .collect()
-        }
-
-        fn find_ambiguities_first_str_labels_with_filter(
-            systems: &[impl SystemContainer],
-            filter: &[String],
-        ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            let mut find_ambiguities = find_ambiguities(
-                systems,
-                filter,
-                ReportExecutionOrderAmbiguities::Deterministic,
-            );
-
-            find_ambiguities
-                .drain(..)
-                .map(|ambiguity| {
-                    (
-                        systems[ambiguity.system_a_index]
-                            .labels()
-                            .iter()
-                            .find(|a| (&***a).type_id() == std::any::TypeId::of::<&str>())
-                            .unwrap()
-                            .clone(),
-                        systems[ambiguity.system_a_index]
-                            .labels()
-                            .iter()
-                            .find(|a| (&***a).type_id() == std::any::TypeId::of::<&str>())
-                            .unwrap()
-                            .clone(),
-                    )
-                })
-                .collect()
-        }
-
-        fn empty() {}
-        fn resource(_: ResMut<usize>) {}
-        fn component(_: Query<&mut W<f32>>) {}
-
-        mod inner {
-            pub(super) fn inner_fn(_: super::ResMut<usize>) {}
-        }
-
-        let mut world = World::new();
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.label("0"))
-            .with_system(empty.label("1").after("0"))
-            .with_system(empty.label("2"))
-            .with_system(empty.label("3").after("2").before("4"))
-            .with_system(empty.label("4"));
-        stage.initialize(&mut world);
-        assert_eq!(
-            find_ambiguities(
-                &stage.parallel,
-                &[],
-                ReportExecutionOrderAmbiguities::Deterministic
-            )
-            .len(),
-            0
-        );
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.label("0"))
-            .with_system(component.label("1").after("0"))
-            .with_system(empty.label("2"))
-            .with_system(empty.label("3").after("2").before("4"))
-            .with_system(component.label("4"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.label("0"))
-            .with_system(resource.label("1").after("0"))
-            .with_system(empty.label("2"))
-            .with_system(empty.label("3").after("2").before("4"))
-            .with_system(resource.label("4"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.label("0"))
-            .with_system(resource.label("1").after("0"))
-            .with_system(empty.label("2"))
-            .with_system(empty.label("3").after("2").before("4"))
-            .with_system(component.label("4"));
-        stage.initialize(&mut world);
-        assert_eq!(
-            find_ambiguities(
-                &stage.parallel,
-                &[],
-                ReportExecutionOrderAmbiguities::Deterministic
-            )
-            .len(),
-            0
-        );
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0"))
-            .with_system(resource.label("1").after("0"))
-            .with_system(empty.label("2"))
-            .with_system(component.label("3").after("2").before("4"))
-            .with_system(resource.label("4"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("0"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("0")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 2);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0"))
-            .with_system(
-                resource
-                    .label("1")
-                    .after("0")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(empty.label("2"))
-            .with_system(component.label("3").after("2").before("4"))
-            .with_system(resource.label("4").ambiguous_with("a").label("a"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("0"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("0")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").before("2"))
-            .with_system(component.label("1").before("2"))
-            .with_system(component.label("2"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("0"), Box::new("1")))
-                || ambiguities.contains(&(Box::new("1"), Box::new("0")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0"))
-            .with_system(component.label("1").after("0"))
-            .with_system(component.label("2").after("0"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("2")))
-                || ambiguities.contains(&(Box::new("2"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").before("1").before("2"))
-            .with_system(component.label("1"))
-            .with_system(component.label("2"))
-            .with_system(component.label("3").after("1").after("2"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("2")))
-                || ambiguities.contains(&(Box::new("2"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").before("1").before("2"))
-            .with_system(component.label("1").ambiguous_with("a").label("a"))
-            .with_system(component.label("2").ambiguous_with("a").label("a"))
-            .with_system(component.label("3").after("1").after("2"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert_eq!(ambiguities.len(), 0);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").before("1").before("2"))
-            .with_system(component.label("1").ambiguous_with("a").label("a"))
-            .with_system(component.label("2").ambiguous_with("a").label("a"))
-            .with_system(component.label("3").after("1").after("2"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("2")))
-                || ambiguities.contains(&(Box::new("2"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(
-                component
-                    .label("0")
-                    .before("1")
-                    .before("2")
-                    .before("3")
-                    .before("4"),
-            )
-            .with_system(component.label("1"))
-            .with_system(component.label("2"))
-            .with_system(component.label("3"))
-            .with_system(component.label("4"))
-            .with_system(
-                component
-                    .label("5")
-                    .after("1")
-                    .after("2")
-                    .after("3")
-                    .after("4"),
-            );
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("2")))
-                || ambiguities.contains(&(Box::new("2"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("2")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("3"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("3")))
-        );
-        assert_eq!(ambiguities.len(), 6);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(
-                component
-                    .label("0")
-                    .before("1")
-                    .before("2")
-                    .before("3")
-                    .before("4"),
-            )
-            .with_system(component.label("1").ambiguous_with("a").label("a"))
-            .with_system(component.label("2").ambiguous_with("a").label("a"))
-            .with_system(component.label("3").ambiguous_with("a").label("a"))
-            .with_system(component.label("4").ambiguous_with("a").label("a"))
-            .with_system(
-                component
-                    .label("5")
-                    .after("1")
-                    .after("2")
-                    .after("3")
-                    .after("4"),
-            );
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert_eq!(ambiguities.len(), 0);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(
-                component
-                    .label("0")
-                    .before("1")
-                    .before("2")
-                    .before("3")
-                    .before("4"),
-            )
-            .with_system(component.label("1").ambiguous_with("a").label("a"))
-            .with_system(component.label("2").ambiguous_with("a").label("a"))
-            .with_system(
-                component
-                    .label("3")
-                    .ambiguous_with("a")
-                    .label("a")
-                    .ambiguous_with("b")
-                    .label("b"),
-            )
-            .with_system(component.label("4").ambiguous_with("b").label("b"))
-            .with_system(
-                component
-                    .label("5")
-                    .after("1")
-                    .after("2")
-                    .after("3")
-                    .after("4"),
-            );
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
-        );
-        assert_eq!(ambiguities.len(), 2);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0"))
-            .with_system(empty.exclusive_system().label("1").after("0"))
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3").after("2"))
-            .with_system(empty.exclusive_system().label("4").after("3"))
-            .with_system(empty.exclusive_system().label("5").after("4"))
-            .with_system(empty.exclusive_system().label("6").after("5"))
-            .with_system(empty.exclusive_system().label("7").after("6"));
-        stage.initialize(&mut world);
-        assert_eq!(
-            find_ambiguities(
-                &stage.exclusive_at_start,
-                &[],
-                ReportExecutionOrderAmbiguities::Deterministic
-            )
-            .len(),
-            0
-        );
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(empty.exclusive_system().label("1"))
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3"))
-            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(empty.exclusive_system().label("5"))
-            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("2")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("5")))
-                || ambiguities.contains(&(Box::new("5"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("5")))
-                || ambiguities.contains(&(Box::new("5"), Box::new("2")))
-        );
-        assert_eq!(ambiguities.len(), 6);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("1")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("3")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("5")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("2")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
-        );
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("5")))
-                || ambiguities.contains(&(Box::new("5"), Box::new("2")))
-        );
-        assert_eq!(ambiguities.len(), 4);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("0")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("1")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("2")
-                    .ambiguous_with("a")
-                    .label("a"),
-            )
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("3")
-                    .ambiguous_with("a")
-                    .label("a"),
-            );
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
-        assert_eq!(ambiguities.len(), 0);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0"))
-            .with_system(resource.label("1").after("0").ignore_all_ambiguities())
-            .with_system(empty.label("2"))
-            .with_system(component.label("3").after("2").before("4"))
-            .with_system(resource.label("4"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("0"), Box::new("3")))
-                || ambiguities.contains(&(Box::new("3"), Box::new("0")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0").ignore_all_ambiguities())
-            .with_system(resource.label("1").after("0").ignore_all_ambiguities())
-            .with_system(empty.label("2"))
-            .with_system(component.label("3").after("2").before("4"))
-            .with_system(resource.label("4"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert_eq!(ambiguities.len(), 0);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("1")
-                    .silence_ambiguity_checks(),
-            )
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("3")
-                    .silence_ambiguity_checks(),
-            )
-            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(
-                empty
-                    .exclusive_system()
-                    .label("5")
-                    .silence_ambiguity_checks(),
-            )
-            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.exclusive_at_start);
-        assert!(
-            ambiguities.contains(&(Box::new("2"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(component.label("0"))
-            .with_system(resource.label("1").after("0"))
-            .with_system(empty.label("2"))
-            .with_system(
-                component
-                    .label("3")
-                    .after("2")
-                    .before("4")
-                    .ambiguous_with("0"),
-            )
-            .with_system(resource.label("4").ambiguous_with("4"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels(&stage.parallel);
-        assert!(
-            ambiguities.contains(&(Box::new("1"), Box::new("4")))
-                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
-        );
-        assert_eq!(ambiguities.len(), 1);
-
-        let mut stage = SystemStage::parallel()
-            .with_system(resource.label("1"))
-            .with_system(inner::inner_fn.label("2"));
-        stage.initialize(&mut world);
-        let ambiguities = find_ambiguities_first_str_labels_with_filter(
-            &stage.parallel,
-            &["bevy_ecs::schedule::stage::tests::ambiguity_detection::inner::".into()],
-        );
-        assert_eq!(ambiguities.len(), 1);
-    }
-
     #[test]
     #[should_panic]
     fn multiple_worlds_same_stage() {

From 606cd984d804ac57cbd96333c9cf78bdce184e96 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 13:03:08 -0400
Subject: [PATCH 077/113] Comprehensive test suite

---
 .../src/schedule/ambiguity_detection.rs       | 241 ++++++++++++++++--
 1 file changed, 213 insertions(+), 28 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 0d1136783caf3..f1049ececc040 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -314,63 +314,185 @@ fn write_display_names_of_pairs(
 #[allow(dead_code)]
 #[cfg(test)]
 mod tests {
+    // Required to make the derive macro behave
+    use crate as bevy_ecs;
+    use crate::event::Events;
     use crate::prelude::*;
 
-    struct TestResource;
+    struct R;
 
-    fn system_a(_res: ResMut<TestResource>) {}
-    fn system_b(_res: ResMut<TestResource>) {}
-    fn system_c(_res: ResMut<TestResource>) {}
-    fn system_d(_res: ResMut<TestResource>) {}
+    #[derive(Component)]
+    struct A;
 
-    fn make_test_stage() -> SystemStage {
-        let mut test_stage = SystemStage::parallel();
+    #[derive(Component)]
+    struct B;
+
+    // An event type
+    struct E;
+
+    fn empty_system() {}
+    fn res_system(_res: Res<R>) {}
+    fn resmut_system(_res: ResMut<R>) {}
+    fn nonsend_system(_ns: NonSend<R>) {}
+    fn nonsendmut_system(_ns: NonSendMut<R>) {}
+    fn read_component_system(_query: Query<&A>) {}
+    fn write_component_system(_query: Query<&mut A>) {}
+    fn with_filtered_component_system(_query: Query<&A, With<B>>) {}
+    fn without_filtered_component_system(_query: Query<&A, Without<B>>) {}
+    fn event_reader_system(_reader: EventReader<E>) {}
+    fn event_writer_system(_writer: EventWriter<E>) {}
+    fn event_resource_system(_events: ResMut<Events<E>>) {}
+
+    // Tests for conflict detection
+    #[test]
+    fn one_of_everything() {
         let mut world = World::new();
-        world.insert_resource(TestResource);
+        let mut test_stage = SystemStage::parallel();
 
         test_stage
-            // Ambiguous with B and D
-            .add_system(system_a)
-            // Ambiguous with A
-            .add_system(system_b.label("b"))
-            .add_system(system_c.ignore_all_ambiguities())
-            // Ambiguous with A
-            .add_system(system_d.ambiguous_with("b"));
+            .add_system(empty_system)
+            // nonsendmut system deliberately conflicts with resmut system
+            .add_system(resmut_system)
+            .add_system(write_component_system)
+            .add_system(event_writer_system);
 
-        // We need to ensure that the schedule has been properly initialized
         test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            0
+        );
+    }
+
+    #[test]
+    fn read_only() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
         test_stage
+            .add_system(empty_system)
+            .add_system(empty_system)
+            .add_system(res_system)
+            .add_system(res_system)
+            .add_system(nonsend_system)
+            .add_system(nonsend_system)
+            .add_system(read_component_system)
+            .add_system(read_component_system)
+            .add_system(event_reader_system)
+            .add_system(event_reader_system);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            0
+        );
     }
 
-    /// Mocking internal functionality
-    mod bevy_render {
-        use super::*;
+    #[test]
+    fn resources() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
 
-        pub(super) fn system_e(_res: ResMut<TestResource>) {}
+        test_stage.add_system(resmut_system).add_system(res_system);
 
-        pub(super) fn system_f(_res: ResMut<TestResource>) {}
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            1
+        );
     }
 
     #[test]
-    fn trivial_ambiguity() {
+    fn nonsend() {
         let mut world = World::new();
         let mut test_stage = SystemStage::parallel();
-        test_stage.add_system(system_a).add_system(system_b);
+
+        test_stage
+            .add_system(nonsendmut_system)
+            .add_system(nonsend_system);
 
         test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
             1
         );
     }
 
+    #[test]
+    fn components() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            .add_system(read_component_system)
+            .add_system(write_component_system);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            1
+        );
+    }
+
+    #[test]
+    fn filtered_components() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            .add_system(with_filtered_component_system)
+            .add_system(without_filtered_component_system);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            0
+        );
+    }
+
+    #[test]
+    fn events() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            .add_system(event_reader_system)
+            .add_system(event_writer_system)
+            .add_system(event_resource_system);
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            // All of these systems clash
+            3
+        );
+    }
+
+    // Tests for silencing and resolving ambiguities
+    #[test]
+    fn before_and_after() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            .add_system(event_reader_system.before(event_writer_system))
+            .add_system(event_writer_system)
+            .add_system(event_resource_system.after(event_writer_system));
+
+        test_stage.initialize(&mut world);
+        assert_eq!(
+            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            // All of these systems clash
+            0
+        );
+    }
+
     #[test]
     fn ignore_all_ambiguities() {
         let mut world = World::new();
         let mut test_stage = SystemStage::parallel();
         test_stage
-            .add_system(system_a.ignore_all_ambiguities())
-            .add_system(system_b);
+            .add_system(resmut_system.ignore_all_ambiguities())
+            .add_system(res_system);
 
         test_stage.initialize(&mut world);
         assert_eq!(
@@ -384,8 +506,8 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = SystemStage::parallel();
         test_stage
-            .add_system(system_a.ambiguous_with("b"))
-            .add_system(system_b.label("b"));
+            .add_system(resmut_system.ambiguous_with("IGNORE_ME"))
+            .add_system(res_system.label("IGNORE_ME"));
 
         test_stage.initialize(&mut world);
         assert_eq!(
@@ -394,6 +516,32 @@ mod tests {
         );
     }
 
+    // Tests for reporting levels
+
+    fn system_a(_res: ResMut<R>) {}
+    fn system_b(_res: ResMut<R>) {}
+    fn system_c(_res: ResMut<R>) {}
+    fn system_d(_res: ResMut<R>) {}
+
+    fn make_test_stage() -> SystemStage {
+        let mut test_stage = SystemStage::parallel();
+        let mut world = World::new();
+        world.insert_resource(R);
+
+        test_stage
+            // Ambiguous with B and D
+            .add_system(system_a)
+            // Ambiguous with A
+            .add_system(system_b.label("b"))
+            .add_system(system_c.ignore_all_ambiguities())
+            // Ambiguous with A
+            .add_system(system_d.ambiguous_with("b"));
+
+        // We need to ensure that the schedule has been properly initialized
+        test_stage.initialize(&mut world);
+        test_stage
+    }
+
     #[test]
     fn ambiguous_with_system() {
         let mut world = World::new();
@@ -444,4 +592,41 @@ mod tests {
             6
         );
     }
+
+    /*
+    // Tests that the correct ambiguities were reported
+    #[test]
+    fn correct_ambiguities() {
+        use crate::component::ComponentId;
+        use crate::schedule::SystemOrderAmbiguity;
+
+        let test_stage = make_test_stage();
+        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Verbose);
+        assert_eq!(
+            ambiguities,
+            [
+                // All ambiguities are in parallel systems
+                // FIXME: this test is flaky due to the fact that the topological order is built nondeterministically
+                vec![
+                    SystemOrderAmbiguity {
+                        system_a_index: 0,
+                        system_b_index: 1,
+                        conflicts: vec![ComponentId(0)]
+                    },
+                    SystemOrderAmbiguity {
+                        system_a_index: 0,
+                        system_b_index: 3,
+                        conflicts: vec![ComponentId(0)]
+                    }
+                ],
+                // Nothing in exclusive-at-start
+                Vec::default(),
+                // Nothing in exclusive-before-commands
+                Vec::default(),
+                // Nothing in exclusive-at-end
+                Vec::default()
+            ]
+        );
+    }
+    */
 }

From adb62166a0fee72239d871c2fb10c4ec4e4d54df Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 13:13:43 -0400
Subject: [PATCH 078/113] Hide rough edges from the public API

---
 .../bevy_ecs/src/schedule/ambiguity_detection.rs   | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index f1049ececc040..808abdd4058c5 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -54,7 +54,7 @@ pub enum ReportExecutionOrderAmbiguities {
 /// Created by applying [`find_ambiguities`] to a [`SystemContainer`].
 /// These can be reported by configuring the [`ReportExecutionOrderAmbiguities`] resource.
 #[derive(Debug, Clone, PartialEq)]
-pub struct SystemOrderAmbiguity {
+struct SystemOrderAmbiguity {
     // The index of the first system in the [`SystemContainer`]
     pub system_a_index: usize,
     // The index of the second system in the [`SystemContainer`]
@@ -66,7 +66,7 @@ pub struct SystemOrderAmbiguity {
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
 /// along with specific components that have triggered the warning.
 /// Systems must be topologically sorted beforehand.
-pub fn find_ambiguities(
+fn find_ambiguities(
     systems: &[impl SystemContainer],
     crates_filter: &[String],
     // Should explicit attempts to ignore ambiguities be obeyed?
@@ -189,7 +189,7 @@ impl SystemStage {
     /// # Panics
     ///
     /// You must call [`SystemStage::initialize`] first or this method will panic.
-    pub fn ambiguities(
+    fn ambiguities(
         &self,
         report_level: ReportExecutionOrderAmbiguities,
     ) -> [Vec<SystemOrderAmbiguity>; 4] {
@@ -238,12 +238,20 @@ impl SystemStage {
     }
 
     /// Returns the number of system order ambiguities between systems in this stage
+    ///
+    /// # Panics
+    ///
+    /// You must call [`SystemStage::initialize`] first or this method will panic.
     pub fn n_ambiguities(&self, report_level: ReportExecutionOrderAmbiguities) -> usize {
         let ambiguities = self.ambiguities(report_level);
         ambiguities.map(|vec| vec.len()).iter().sum()
     }
 
     /// Reports all execution order ambiguities between systems
+    ///
+    /// # Panics
+    ///
+    /// You must call [`SystemStage::initialize`] first or this method will panic.
     pub fn report_ambiguities(&self, world: &World, report_level: ReportExecutionOrderAmbiguities) {
         let [parallel, at_start, before_commands, at_end] = self.ambiguities(report_level);
 

From fc2d59857d69378f596827441b4e1e193a6b5b9b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 13:21:41 -0400
Subject: [PATCH 079/113] Naming consistency

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

diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 753e5a3c3c90f..3b17c5414a1ae 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -326,7 +326,7 @@ pub trait ExclusiveSystemDescriptorCoercion {
     fn at_end(self) -> ExclusiveSystemDescriptor;
 
     /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
-    fn silence_ambiguity_checks(self) -> ExclusiveSystemDescriptor;
+    fn ignore_all_ambiguities(self) -> ExclusiveSystemDescriptor;
 
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems with the given label.
@@ -373,7 +373,7 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self
     }
 
-    fn silence_ambiguity_checks(mut self) -> ExclusiveSystemDescriptor {
+    fn ignore_all_ambiguities(mut self) -> ExclusiveSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
@@ -433,8 +433,8 @@ where
         new_exclusive_descriptor(Box::new(self)).at_end()
     }
 
-    fn silence_ambiguity_checks(self) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).silence_ambiguity_checks()
+    fn ignore_all_ambiguities(self) -> ExclusiveSystemDescriptor {
+        new_exclusive_descriptor(Box::new(self)).ignore_all_ambiguities()
     }
 
     fn ambiguous_with<Marker>(

From f252a70c07c86bfa54be6d0f95b26e3fe8a7de38 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 14:55:09 -0400
Subject: [PATCH 080/113] Refactor to make SystemOrderAmbiguity safe for public
 consumption

---
 .../src/schedule/ambiguity_detection.rs       | 412 +++++++++++-------
 crates/bevy_ecs/src/schedule/stage.rs         |   2 +-
 2 files changed, 252 insertions(+), 162 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 808abdd4058c5..def4b8f0492f5 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -2,6 +2,7 @@ use crate::component::ComponentId;
 use crate::schedule::{AmbiguityDetection, SystemContainer, SystemStage};
 use crate::world::World;
 
+use bevy_utils::HashSet;
 use fixedbitset::FixedBitSet;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -53,25 +54,114 @@ pub enum ReportExecutionOrderAmbiguities {
 ///
 /// Created by applying [`find_ambiguities`] to a [`SystemContainer`].
 /// These can be reported by configuring the [`ReportExecutionOrderAmbiguities`] resource.
-#[derive(Debug, Clone, PartialEq)]
-struct SystemOrderAmbiguity {
-    // The index of the first system in the [`SystemContainer`]
-    pub system_a_index: usize,
-    // The index of the second system in the [`SystemContainer`]
-    pub system_b_index: usize,
+#[derive(Debug, Clone, Eq, Hash)]
+pub struct SystemOrderAmbiguity {
+    // The names of the conflicting systems
+    pub system_names: (String, String),
     /// The components (and resources) that these systems have incompatible access to
-    pub conflicts: Vec<ComponentId>,
+    pub conflicts: Vec<String>,
+    /// The segment of the [`SystemStage`] that the conflicting systems were stored in
+    pub segment: SystemStageSegment,
+}
+
+impl PartialEq for SystemOrderAmbiguity {
+    fn eq(&self, other: &Self) -> bool {
+        // The order of the systems doesn't matter
+        let names_aligned = (self.system_names.0 == other.system_names.0)
+            & (self.system_names.1 == other.system_names.1);
+        let names_inverted = (self.system_names.0 == other.system_names.1)
+            & (self.system_names.0 == other.system_names.1);
+        let names_match = names_aligned | names_inverted;
+
+        // The order of the reported conflicts doesn't matter
+        let conflicts_match =
+            HashSet::from_iter(self.conflicts.iter()) == HashSet::from_iter(other.conflicts.iter());
+
+        let segments_match = self.segment == other.segment;
+
+        names_match & conflicts_match & segments_match
+    }
+}
+
+/// Which part of a [`SystemStage`] was a [`SystemOrderAmbiguity`] detected in?
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
+pub enum SystemStageSegment {
+    Parallel,
+    ExclusiveAtStart,
+    ExclusiveBeforeCommands,
+    ExclusiveAtEnd,
+}
+
+impl SystemOrderAmbiguity {
+    fn from_raw(
+        system_a_index: usize,
+        system_b_index: usize,
+        component_ids: Vec<ComponentId>,
+        segment: SystemStageSegment,
+        stage: &SystemStage,
+        world: &World,
+    ) -> Self {
+        use crate::schedule::graph_utils::GraphNode;
+        use SystemStageSegment::*;
+
+        // TODO: blocked on https://github.com/bevyengine/bevy/pull/4166
+        // We can't grab the system container generically, because .parallel_systems()
+        // and the exclusive equivalent return a different type,
+        // and SystemContainer is not object-safe
+        let (system_a_name, system_b_name) = match segment {
+            Parallel => {
+                let system_container = stage.parallel_systems();
+                (
+                    system_container[system_a_index].name(),
+                    system_container[system_b_index].name(),
+                )
+            }
+            ExclusiveAtStart => {
+                let system_container = stage.parallel_systems();
+                (
+                    system_container[system_a_index].name(),
+                    system_container[system_b_index].name(),
+                )
+            }
+            ExclusiveBeforeCommands => {
+                let system_container = stage.parallel_systems();
+                (
+                    system_container[system_a_index].name(),
+                    system_container[system_b_index].name(),
+                )
+            }
+            ExclusiveAtEnd => {
+                let system_container = stage.parallel_systems();
+                (
+                    system_container[system_a_index].name(),
+                    system_container[system_b_index].name(),
+                )
+            }
+        };
+
+        let conflicts: Vec<String> = component_ids
+            .iter()
+            .map(|id| world.components().get_info(*id).unwrap().name().into())
+            .collect();
+
+        Self {
+            // Don't bother with Cows here
+            system_names: (system_a_name.into(), system_b_name.into()),
+            conflicts,
+            segment,
+        }
+    }
 }
 
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
 /// along with specific components that have triggered the warning.
 /// Systems must be topologically sorted beforehand.
-fn find_ambiguities(
+pub fn find_ambiguities(
     systems: &[impl SystemContainer],
     crates_filter: &[String],
     // Should explicit attempts to ignore ambiguities be obeyed?
     report_level: ReportExecutionOrderAmbiguities,
-) -> Vec<SystemOrderAmbiguity> {
+) -> Vec<(usize, usize, Vec<ComponentId>)> {
     fn should_ignore_ambiguity(
         systems: &[impl SystemContainer],
         index_a: usize,
@@ -149,20 +239,14 @@ fn find_ambiguities(
                 let a_access = systems[index_a].component_access();
                 let b_access = systems[index_b].component_access();
                 if let (Some(a), Some(b)) = (a_access, b_access) {
-                    let conflicts = a.get_conflicts(b);
-                    if !conflicts.is_empty() {
-                        ambiguities.push(SystemOrderAmbiguity {
-                            system_a_index: index_a,
-                            system_b_index: index_b,
-                            conflicts,
-                        });
+                    let component_ids = a.get_conflicts(b);
+                    if !component_ids.is_empty() {
+                        ambiguities.push((index_a, index_b, component_ids));
                     }
                 } else {
-                    ambiguities.push(SystemOrderAmbiguity {
-                        system_a_index: index_a,
-                        system_b_index: index_b,
-                        conflicts: Vec::default(),
-                    });
+                    // The ambiguity is for an exclusive system,
+                    // which conflict on all data
+                    ambiguities.push((index_a, index_b, Vec::default()));
                 }
             }
         }
@@ -185,21 +269,17 @@ impl SystemStage {
     /// - exclusive at start,
     /// - exclusive before commands
     /// - exclusive at end
-    ///
-    /// # Panics
-    ///
-    /// You must call [`SystemStage::initialize`] first or this method will panic.
-    fn ambiguities(
-        &self,
+    pub fn ambiguities(
+        &mut self,
+        // FIXME: these methods should not have tor rely on &mut World, or any specific World
+        // see https://github.com/bevyengine/bevy/issues/4364
+        world: &mut World,
         report_level: ReportExecutionOrderAmbiguities,
-    ) -> [Vec<SystemOrderAmbiguity>; 4] {
+    ) -> Vec<SystemOrderAmbiguity> {
+        self.initialize(world);
+
         if report_level == ReportExecutionOrderAmbiguities::Off {
-            return [
-                Vec::default(),
-                Vec::default(),
-                Vec::default(),
-                Vec::default(),
-            ];
+            return Vec::default();
         }
 
         // System order must be fresh
@@ -225,40 +305,95 @@ impl SystemStage {
             Vec::default()
         };
 
-        let parallel = find_ambiguities(&self.parallel, &ignored_crates, report_level);
-        let at_start = find_ambiguities(&self.exclusive_at_start, &ignored_crates, report_level);
-        let before_commands = find_ambiguities(
+        let parallel: Vec<SystemOrderAmbiguity> =
+            find_ambiguities(&self.parallel, &ignored_crates, report_level)
+                .iter()
+                .map(|(system_a_index, system_b_index, component_ids)| {
+                    SystemOrderAmbiguity::from_raw(
+                        *system_a_index,
+                        *system_b_index,
+                        component_ids.to_vec(),
+                        SystemStageSegment::Parallel,
+                        &self,
+                        &world,
+                    )
+                })
+                .collect();
+
+        let at_start: Vec<SystemOrderAmbiguity> =
+            find_ambiguities(&self.exclusive_at_start, &ignored_crates, report_level)
+                .iter()
+                .map(|(system_a_index, system_b_index, component_ids)| {
+                    SystemOrderAmbiguity::from_raw(
+                        *system_a_index,
+                        *system_b_index,
+                        component_ids.to_vec(),
+                        SystemStageSegment::ExclusiveAtStart,
+                        &self,
+                        &world,
+                    )
+                })
+                .collect();
+
+        let before_commands: Vec<SystemOrderAmbiguity> = find_ambiguities(
             &self.exclusive_before_commands,
             &ignored_crates,
             report_level,
-        );
-        let at_end = find_ambiguities(&self.exclusive_at_end, &ignored_crates, report_level);
-
-        [parallel, at_start, before_commands, at_end]
+        )
+        .iter()
+        .map(|(system_a_index, system_b_index, component_ids)| {
+            SystemOrderAmbiguity::from_raw(
+                *system_a_index,
+                *system_b_index,
+                component_ids.to_vec(),
+                SystemStageSegment::ExclusiveBeforeCommands,
+                &self,
+                &world,
+            )
+        })
+        .collect();
+
+        let at_end: Vec<SystemOrderAmbiguity> =
+            find_ambiguities(&self.exclusive_at_end, &ignored_crates, report_level)
+                .iter()
+                .map(|(system_a_index, system_b_index, component_ids)| {
+                    SystemOrderAmbiguity::from_raw(
+                        *system_a_index,
+                        *system_b_index,
+                        component_ids.to_vec(),
+                        SystemStageSegment::ExclusiveAtEnd,
+                        &self,
+                        &world,
+                    )
+                })
+                .collect();
+
+        let mut ambiguities = Vec::default();
+        ambiguities.extend(at_start);
+        ambiguities.extend(parallel);
+        ambiguities.extend(before_commands);
+        ambiguities.extend(at_end);
+
+        ambiguities
     }
 
     /// Returns the number of system order ambiguities between systems in this stage
-    ///
-    /// # Panics
-    ///
-    /// You must call [`SystemStage::initialize`] first or this method will panic.
-    pub fn n_ambiguities(&self, report_level: ReportExecutionOrderAmbiguities) -> usize {
-        let ambiguities = self.ambiguities(report_level);
-        ambiguities.map(|vec| vec.len()).iter().sum()
+    pub fn n_ambiguities(
+        &mut self,
+        world: &mut World,
+        report_level: ReportExecutionOrderAmbiguities,
+    ) -> usize {
+        self.ambiguities(world, report_level).len()
     }
 
     /// Reports all execution order ambiguities between systems
-    ///
-    /// # Panics
-    ///
-    /// You must call [`SystemStage::initialize`] first or this method will panic.
-    pub fn report_ambiguities(&self, world: &World, report_level: ReportExecutionOrderAmbiguities) {
-        let [parallel, at_start, before_commands, at_end] = self.ambiguities(report_level);
-
-        let mut unresolved_count = parallel.len();
-        unresolved_count += at_start.len();
-        unresolved_count += before_commands.len();
-        unresolved_count += at_end.len();
+    pub fn report_ambiguities(
+        &mut self,
+        world: &mut World,
+        report_level: ReportExecutionOrderAmbiguities,
+    ) {
+        let ambiguities = self.ambiguities(world, report_level);
+        let unresolved_count = ambiguities.len();
 
         if unresolved_count > 0 {
             // Grammar
@@ -273,51 +408,19 @@ impl SystemStage {
             if report_level == ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
-                // TODO: clean up this logic once exclusive systems are more compatible with parallel systems
-                // allowing us to merge these collections
-                let mut offset = 1;
-                offset = write_display_names_of_pairs(offset, &self.parallel, parallel, world);
-                offset =
-                    write_display_names_of_pairs(offset, &self.exclusive_at_start, at_start, world);
-                offset = write_display_names_of_pairs(
-                    offset,
-                    &self.exclusive_before_commands,
-                    before_commands,
-                    world,
-                );
-                write_display_names_of_pairs(offset, &self.exclusive_at_end, at_end, world);
+                for (i, ambiguity) in ambiguities.iter().enumerate() {
+                    let _ambiguity_number = i + 1;
+                    let _system_a_name = &ambiguity.system_names.0;
+                    let _system_b_name = &ambiguity.system_names.1;
+                    let _conflicts = &ambiguity.conflicts;
+
+                    println!("{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicts:?}");
+                }
             }
         }
     }
 }
 
-fn write_display_names_of_pairs(
-    offset: usize,
-    systems: &[impl SystemContainer],
-    ambiguities: Vec<SystemOrderAmbiguity>,
-    world: &World,
-) -> usize {
-    for (i, system_order_ambiguity) in ambiguities.iter().enumerate() {
-        let _system_a_name = systems[system_order_ambiguity.system_a_index].name();
-        let _system_b_name = systems[system_order_ambiguity.system_b_index].name();
-
-        let _conflicting_components = system_order_ambiguity
-            .conflicts
-            .iter()
-            .map(|id| world.components().get_info(*id).unwrap().name())
-            .collect::<Vec<_>>();
-
-        let _ambiguity_number = i + offset;
-
-        println!(
-                "{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicting_components:?}"
-            );
-    }
-
-    // We can't merge the SystemContainer arrays, so instead we manually keep track of how high we've counted :upside_down:
-    ambiguities.len()
-}
-
 // Systems and TestResource are used in tests
 #[allow(dead_code)]
 #[cfg(test)]
@@ -364,9 +467,8 @@ mod tests {
             .add_system(write_component_system)
             .add_system(event_writer_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
@@ -388,9 +490,8 @@ mod tests {
             .add_system(event_reader_system)
             .add_system(event_reader_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
@@ -402,9 +503,8 @@ mod tests {
 
         test_stage.add_system(resmut_system).add_system(res_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             1
         );
     }
@@ -418,9 +518,8 @@ mod tests {
             .add_system(nonsendmut_system)
             .add_system(nonsend_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             1
         );
     }
@@ -434,9 +533,8 @@ mod tests {
             .add_system(read_component_system)
             .add_system(write_component_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             1
         );
     }
@@ -450,9 +548,8 @@ mod tests {
             .add_system(with_filtered_component_system)
             .add_system(without_filtered_component_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
@@ -467,9 +564,8 @@ mod tests {
             .add_system(event_writer_system)
             .add_system(event_resource_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             // All of these systems clash
             3
         );
@@ -486,9 +582,8 @@ mod tests {
             .add_system(event_writer_system)
             .add_system(event_resource_system.after(event_writer_system));
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             // All of these systems clash
             0
         );
@@ -502,9 +597,8 @@ mod tests {
             .add_system(resmut_system.ignore_all_ambiguities())
             .add_system(res_system);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
@@ -517,9 +611,8 @@ mod tests {
             .add_system(resmut_system.ambiguous_with("IGNORE_ME"))
             .add_system(res_system.label("IGNORE_ME"));
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
@@ -531,9 +624,8 @@ mod tests {
     fn system_c(_res: ResMut<R>) {}
     fn system_d(_res: ResMut<R>) {}
 
-    fn make_test_stage() -> SystemStage {
+    fn make_test_stage(world: &mut World) -> SystemStage {
         let mut test_stage = SystemStage::parallel();
-        let mut world = World::new();
         world.insert_resource(R);
 
         test_stage
@@ -545,8 +637,6 @@ mod tests {
             // Ambiguous with A
             .add_system(system_d.ambiguous_with("b"));
 
-        // We need to ensure that the schedule has been properly initialized
-        test_stage.initialize(&mut world);
         test_stage
     }
 
@@ -558,83 +648,83 @@ mod tests {
             .add_system(system_a.ambiguous_with(system_b))
             .add_system(system_b);
 
-        test_stage.initialize(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
 
     #[test]
     fn off() {
-        let test_stage = make_test_stage();
+        let mut world = World::new();
+        let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Off),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             0
         );
     }
 
     #[test]
     fn minimal() {
-        let test_stage = make_test_stage();
+        let mut world = World::new();
+        let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Minimal),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             2
         );
     }
 
     #[test]
     fn verbose() {
-        let test_stage = make_test_stage();
+        let mut world = World::new();
+        let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Verbose),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             2
         );
     }
 
     #[test]
     fn deterministic() {
-        let test_stage = make_test_stage();
+        let mut world = World::new();
+        let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             6
         );
     }
 
-    /*
     // Tests that the correct ambiguities were reported
     #[test]
     fn correct_ambiguities() {
-        use crate::component::ComponentId;
         use crate::schedule::SystemOrderAmbiguity;
+        use bevy_utils::HashSet;
 
-        let test_stage = make_test_stage();
-        let ambiguities = test_stage.ambiguities(ReportExecutionOrderAmbiguities::Verbose);
+        let mut world = World::new();
+        let mut test_stage = make_test_stage(&mut world);
+        let ambiguities =
+            test_stage.ambiguities(&mut world, ReportExecutionOrderAmbiguities::Verbose);
         assert_eq!(
-            ambiguities,
-            [
-                // All ambiguities are in parallel systems
-                // FIXME: this test is flaky due to the fact that the topological order is built nondeterministically
-                vec![
-                    SystemOrderAmbiguity {
-                        system_a_index: 0,
-                        system_b_index: 1,
-                        conflicts: vec![ComponentId(0)]
-                    },
-                    SystemOrderAmbiguity {
-                        system_a_index: 0,
-                        system_b_index: 3,
-                        conflicts: vec![ComponentId(0)]
-                    }
-                ],
-                // Nothing in exclusive-at-start
-                Vec::default(),
-                // Nothing in exclusive-before-commands
-                Vec::default(),
-                // Nothing in exclusive-at-end
-                Vec::default()
-            ]
+            // We don't care if the reported order varies
+            HashSet::from_iter(ambiguities),
+            HashSet::from_iter(vec![
+                SystemOrderAmbiguity {
+                    system_names: (
+                        "bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(),
+                        "bevy_ecs::schedule::ambiguity_detection::tests::system_b".to_string()
+                    ),
+                    conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
+                    segment: bevy_ecs::schedule::SystemStageSegment::Parallel,
+                },
+                SystemOrderAmbiguity {
+                    system_names: (
+                        "bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(),
+                        "bevy_ecs::schedule::ambiguity_detection::tests::system_d".to_string()
+                    ),
+                    conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
+                    segment: bevy_ecs::schedule::SystemStageSegment::Parallel,
+                },
+            ],)
         );
     }
-    */
 }
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 7487836186c84..71cddc236a0ae 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -103,7 +103,7 @@ impl SystemStage {
     ///
     /// This method is automatically called by [`Stage::run`], but must be manually called
     /// when using [`SystemStage::ambiguities`].
-    pub fn initialize(&mut self, world: &mut World) {
+    pub(crate) fn initialize(&mut self, world: &mut World) {
         if self.systems_modified {
             self.initialize_systems(world);
             self.rebuild_orders_and_dependencies();

From c716d19d6b546fe2db01cffa57762f5aa8dd39ea Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 15:05:51 -0400
Subject: [PATCH 081/113] Tests for exclusive systems

---
 .../src/schedule/ambiguity_detection.rs       | 52 +++++++++++++++++--
 1 file changed, 47 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index def4b8f0492f5..a9cb7f194df00 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -117,21 +117,21 @@ impl SystemOrderAmbiguity {
                 )
             }
             ExclusiveAtStart => {
-                let system_container = stage.parallel_systems();
+                let system_container = stage.exclusive_at_start_systems();
                 (
                     system_container[system_a_index].name(),
                     system_container[system_b_index].name(),
                 )
             }
             ExclusiveBeforeCommands => {
-                let system_container = stage.parallel_systems();
+                let system_container = stage.exclusive_before_commands_systems();
                 (
                     system_container[system_a_index].name(),
                     system_container[system_b_index].name(),
                 )
             }
             ExclusiveAtEnd => {
-                let system_container = stage.parallel_systems();
+                let system_container = stage.exclusive_at_end_systems();
                 (
                     system_container[system_a_index].name(),
                     system_container[system_b_index].name(),
@@ -453,6 +453,8 @@ mod tests {
     fn event_reader_system(_reader: EventReader<E>) {}
     fn event_writer_system(_writer: EventWriter<E>) {}
     fn event_resource_system(_events: ResMut<Events<E>>) {}
+    fn read_world_system(_world: &World) {}
+    fn write_world_system(_world: &mut World) {}
 
     // Tests for conflict detection
     #[test]
@@ -488,7 +490,9 @@ mod tests {
             .add_system(read_component_system)
             .add_system(read_component_system)
             .add_system(event_reader_system)
-            .add_system(event_reader_system);
+            .add_system(event_reader_system)
+            .add_system(read_world_system)
+            .add_system(read_world_system);
 
         assert_eq!(
             test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
@@ -496,6 +500,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn read_world() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            .add_system(empty_system)
+            .add_system(resmut_system)
+            .add_system(write_component_system)
+            .add_system(event_writer_system)
+            .add_system(read_world_system);
+
+        assert_eq!(
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            3
+        );
+    }
+
     #[test]
     fn resources() {
         let mut world = World::new();
@@ -560,13 +582,33 @@ mod tests {
         let mut test_stage = SystemStage::parallel();
 
         test_stage
+            // All of these systems clash
             .add_system(event_reader_system)
             .add_system(event_writer_system)
             .add_system(event_resource_system);
 
         assert_eq!(
             test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
-            // All of these systems clash
+            3
+        );
+    }
+
+    #[test]
+    fn exclusive() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+
+        test_stage
+            // All 3 of these conflict with each other
+            .add_system(write_world_system.exclusive_system())
+            .add_system(write_world_system.exclusive_system().at_end())
+            .add_system(res_system.exclusive_system())
+            // These do not, as they're in different segments of the stage
+            .add_system(write_world_system.exclusive_system().at_start())
+            .add_system(write_world_system.exclusive_system().before_commands());
+
+        assert_eq!(
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
             3
         );
     }

From 0edb0ec7ca3642bbd3534e0a0ac68e5f2d343d78 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 18:14:49 -0400
Subject: [PATCH 082/113] Make ambiguity reporting prettier

---
 .../src/schedule/ambiguity_detection.rs       | 129 ++++++++++++++++--
 1 file changed, 119 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index a9cb7f194df00..446bfb0d72c53 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -398,29 +398,138 @@ impl SystemStage {
         if unresolved_count > 0 {
             // Grammar
             if unresolved_count == 1 {
-                println!("\n One of your stages contains 1 pair of systems with unknown order and conflicting data access. \
-				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
+                println!("One of your stages contains 1 pair of systems with unknown order and conflicting data access. \n\
+				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
             } else {
-                println!("\n One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \
-				You may want to add `.before()` or `.after()` constraints between some of these systems to prevent bugs.\n");
+                println!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \n\
+				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
             }
 
             if report_level == ReportExecutionOrderAmbiguities::Minimal {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
-                    let _ambiguity_number = i + 1;
-                    let _system_a_name = &ambiguity.system_names.0;
-                    let _system_b_name = &ambiguity.system_names.1;
-                    let _conflicts = &ambiguity.conflicts;
-
-                    println!("{_ambiguity_number}. {_system_a_name} conflicts with {_system_b_name} on {_conflicts:?}");
+                    let ambiguity_number = i + 1;
+                    // The path name is often just noise, and this gets us consistency with `conflicts`'s formatting
+                    let system_a_name = format_type_name(ambiguity.system_names.0.as_str());
+                    let system_b_name = format_type_name(ambiguity.system_names.1.as_str());
+                    let conflicts: Vec<String> = ambiguity
+                        .conflicts
+                        .iter()
+                        .map(|name| format_type_name(name.as_str()))
+                        .collect();
+
+                    println!("{ambiguity_number:?}. `{system_a_name}` conflicts with `{system_b_name}` on {conflicts:?}");
                 }
+                // Print an empty line to space out multiple stages nicely
+                println!("");
             }
         }
     }
 }
 
+/// Collapses a name returned by std::any::type_name to remove its module path
+fn format_type_name(raw_name: &str) -> String {
+    // Generics result in nested paths within <..> blocks
+    // Consider "bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"
+    // To tackle this, we parse the string from left to right, collapsing as we go
+    let mut index: usize = 0;
+    let end_of_string = raw_name.len();
+    let mut parsed_name = String::new();
+
+    while index < end_of_string {
+        let rest_of_string = raw_name.get(index..end_of_string).unwrap_or_default();
+
+        // Collapse everything up to the next "<", "," or ">",
+        // then skip over it
+        if let Some(special_character_index) =
+            rest_of_string.find(|c: char| (c == '<') || (c == ',') || (c == '>'))
+        {
+            let segment_to_collapse = rest_of_string
+                .get(0..special_character_index)
+                .unwrap_or_default();
+            let collapsed_type_name = collapse_type_name(segment_to_collapse);
+            parsed_name += &collapsed_type_name;
+            // Insert the special character
+            let special_character =
+                &rest_of_string[special_character_index..=special_character_index];
+            parsed_name.push_str(special_character);
+            // Move the index just past the special character
+            index += special_character_index + 1;
+        } else {
+            // If there are no special characters left, we're done!
+            let collapsed_type_name = collapse_type_name(rest_of_string);
+            parsed_name += &collapsed_type_name;
+            index = end_of_string;
+        }
+    }
+
+    parsed_name
+}
+
+#[inline(always)]
+fn collapse_type_name(string: &str) -> String {
+    let type_name = string.split("::").last().unwrap();
+
+    // Account for leading white space
+    if string.get(0..1).unwrap_or_default() == " " {
+        format!(" {type_name}")
+    } else {
+        type_name.to_string()
+    }
+}
+
+#[cfg(test)]
+mod name_formatting_tests {
+    use crate::schedule::ambiguity_detection::collapse_type_name;
+
+    use super::format_type_name;
+
+    #[test]
+    fn trivial() {
+        assert_eq!(format_type_name("test_system"), "test_system")
+    }
+
+    #[test]
+    fn path_seperated() {
+        assert_eq!(
+            format_type_name("bevy_prelude::make_fun_game"),
+            "make_fun_game".to_string()
+        )
+    }
+
+    #[test]
+    fn trivial_generics() {
+        assert_eq!(format_type_name("a<B>"), "a<B>".to_string())
+    }
+
+    #[test]
+    fn multiple_type_parameters() {
+        assert_eq!(format_type_name("a<B, C>"), "a<B, C>".to_string())
+    }
+
+    #[test]
+    fn leading_whitespace() {
+        assert_eq!(collapse_type_name(" foo::A"), " A")
+    }
+
+    #[test]
+    fn generics() {
+        assert_eq!(
+            format_type_name("bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"),
+            "extract_cameras<Camera3d>".to_string()
+        )
+    }
+
+    #[test]
+    fn nested_generics() {
+        assert_eq!(
+            format_type_name("bevy::mad_science::do_mad_science<mad_science::Test<mad_science::Tube>, bavy::TypeSystemAbuse>"),
+            "do_mad_science<Test<Tube>, TypeSystemAbuse>".to_string()
+        )
+    }
+}
+
 // Systems and TestResource are used in tests
 #[allow(dead_code)]
 #[cfg(test)]

From ae0dee1df65ca33f5c723f396a7560f6b7ede6a7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 18:26:04 -0400
Subject: [PATCH 083/113] Make warning for exclusive system conflicts clearer

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 446bfb0d72c53..fc63c709c868c 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -413,12 +413,17 @@ impl SystemStage {
                     // The path name is often just noise, and this gets us consistency with `conflicts`'s formatting
                     let system_a_name = format_type_name(ambiguity.system_names.0.as_str());
                     let system_b_name = format_type_name(ambiguity.system_names.1.as_str());
-                    let conflicts: Vec<String> = ambiguity
+                    let mut conflicts: Vec<String> = ambiguity
                         .conflicts
                         .iter()
                         .map(|name| format_type_name(name.as_str()))
                         .collect();
 
+                    // Exclusive system conflicts are reported as conflicting on the empty set
+                    if conflicts.is_empty() {
+                        conflicts = vec!["World".to_string()];
+                    }
+
                     println!("{ambiguity_number:?}. `{system_a_name}` conflicts with `{system_b_name}` on {conflicts:?}");
                 }
                 // Print an empty line to space out multiple stages nicely

From 583fdee30f7707a7961a77613be4c4896463d78f Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 18:48:30 -0400
Subject: [PATCH 084/113] Make levels of ReportExecutionOrderAmbiguities
 consistent with clippy

---
 .../src/schedule/ambiguity_detection.rs       | 70 +++++++++++--------
 examples/ecs/ambiguity_checker.rs             |  2 +-
 examples/ecs/ecs_guide.rs                     |  2 +-
 examples/tools/internal_ambiguities.rs        |  2 +-
 4 files changed, 43 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index fc63c709c868c..77fbb442712ee 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -22,7 +22,7 @@ use fixedbitset::FixedBitSet;
 /// The checker may report a system more times than the amount of constraints it would actually need
 /// to have unambiguous order with regards to a group of already-constrained systems.
 ///
-/// By default, the value of this resource is set to `Minimal`.
+/// By default, the value of this resource is set to `Warn`.
 ///
 /// ## Example
 /// ```ignore
@@ -32,22 +32,26 @@ use fixedbitset::FixedBitSet;
 ///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
 /// ```
 pub enum ReportExecutionOrderAmbiguities {
-    /// Disables all messages reported by the ambiguity checker
-    Off,
+    /// Disables all checks for execution order ambiguities
+    Allow,
     /// Displays only the number of unresolved ambiguities detected by the ambiguity checker
-    Minimal,
+    Warn,
     /// Displays a full report of ambiguities detected by the ambiguity checker
-    Verbose,
+    WarnVerbose,
     /// Verbosely reports all non-ignored ambiguities, including those between Bevy's systems
     ///
     /// These will not be actionable: you should only turn on this functionality when
     /// investigating to see if there's a Bevy bug or working on the engine itself.
-    ReportInternal,
+    WarnInternal,
+    /// Like `WarnVerbose`, but panics if any non-ignored ambiguities exist
+    Deny,
     /// Verbosely reports ALL ambiguities, even ignored ones
     ///
+    /// Panics if any ambiguities exist.
+    ///
     /// This will be very noisy, but can be useful when attempting to track down subtle determinism issues,
     /// as you might need when attempting to implement lockstep networking.
-    Deterministic,
+    Forbid,
 }
 
 /// A pair of systems that can run in an ambiguous order
@@ -169,7 +173,7 @@ pub fn find_ambiguities(
         crates_filter: &[String],
         report_level: ReportExecutionOrderAmbiguities,
     ) -> bool {
-        if report_level == ReportExecutionOrderAmbiguities::Deterministic {
+        if report_level == ReportExecutionOrderAmbiguities::Forbid {
             return false;
         }
 
@@ -257,7 +261,7 @@ pub fn find_ambiguities(
 
 impl Default for ReportExecutionOrderAmbiguities {
     fn default() -> Self {
-        ReportExecutionOrderAmbiguities::Minimal
+        ReportExecutionOrderAmbiguities::Warn
     }
 }
 
@@ -278,7 +282,7 @@ impl SystemStage {
     ) -> Vec<SystemOrderAmbiguity> {
         self.initialize(world);
 
-        if report_level == ReportExecutionOrderAmbiguities::Off {
+        if report_level == ReportExecutionOrderAmbiguities::Allow {
             return Vec::default();
         }
 
@@ -286,7 +290,7 @@ impl SystemStage {
         debug_assert!(!self.systems_modified);
 
         // TODO: remove all internal ambiguities and remove this logic
-        let ignored_crates = if report_level != ReportExecutionOrderAmbiguities::ReportInternal {
+        let ignored_crates = if report_level != ReportExecutionOrderAmbiguities::WarnInternal {
             vec![
                 // Rendering
                 "bevy_render".to_string(),
@@ -405,7 +409,7 @@ impl SystemStage {
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
             }
 
-            if report_level == ReportExecutionOrderAmbiguities::Minimal {
+            if report_level == ReportExecutionOrderAmbiguities::Warn {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
@@ -429,6 +433,12 @@ impl SystemStage {
                 // Print an empty line to space out multiple stages nicely
                 println!("");
             }
+
+            if report_level == ReportExecutionOrderAmbiguities::Deny
+                || report_level == ReportExecutionOrderAmbiguities::Forbid
+            {
+                panic!("The ReportExecutionOrderAmbiguities resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
+            }
         }
     }
 }
@@ -584,7 +594,7 @@ mod tests {
             .add_system(event_writer_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -609,7 +619,7 @@ mod tests {
             .add_system(read_world_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -627,7 +637,7 @@ mod tests {
             .add_system(read_world_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             3
         );
     }
@@ -640,7 +650,7 @@ mod tests {
         test_stage.add_system(resmut_system).add_system(res_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             1
         );
     }
@@ -655,7 +665,7 @@ mod tests {
             .add_system(nonsend_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             1
         );
     }
@@ -670,7 +680,7 @@ mod tests {
             .add_system(write_component_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             1
         );
     }
@@ -685,7 +695,7 @@ mod tests {
             .add_system(without_filtered_component_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -702,7 +712,7 @@ mod tests {
             .add_system(event_resource_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             3
         );
     }
@@ -722,7 +732,7 @@ mod tests {
             .add_system(write_world_system.exclusive_system().before_commands());
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             3
         );
     }
@@ -739,7 +749,7 @@ mod tests {
             .add_system(event_resource_system.after(event_writer_system));
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             // All of these systems clash
             0
         );
@@ -754,7 +764,7 @@ mod tests {
             .add_system(res_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -768,7 +778,7 @@ mod tests {
             .add_system(res_system.label("IGNORE_ME"));
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -805,7 +815,7 @@ mod tests {
             .add_system(system_b);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -815,7 +825,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -825,7 +835,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             2
         );
     }
@@ -835,7 +845,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             2
         );
     }
@@ -845,7 +855,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Deterministic),
+            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
             6
         );
     }
@@ -859,7 +869,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         let ambiguities =
-            test_stage.ambiguities(&mut world, ReportExecutionOrderAmbiguities::Verbose);
+            test_stage.ambiguities(&mut world, ReportExecutionOrderAmbiguities::WarnVerbose);
         assert_eq!(
             // We don't care if the reported order varies
             HashSet::from_iter(ambiguities),
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 7199b941cd467..d49798f656f25 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -6,7 +6,7 @@ fn main() {
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
-        .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
+        .insert_resource(ReportExecutionOrderAmbiguities::WarnVerbose)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
         // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index e2c7a11b14684..d330aeedd8f07 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -332,7 +332,7 @@ fn main() {
         // in the console by adding the following resource to our App
         // Execution order ambiguities can be resolved by adding ordering constraints,
         // or explicitly ignored (when there's a false positive).
-        .insert_resource(ReportExecutionOrderAmbiguities::Verbose)
+        .insert_resource(ReportExecutionOrderAmbiguities::WarnVerbose)
         // This call to run() starts the app we just built!
         .run();
 }
diff --git a/examples/tools/internal_ambiguities.rs b/examples/tools/internal_ambiguities.rs
index 675802b934282..3a653a4a12cbf 100644
--- a/examples/tools/internal_ambiguities.rs
+++ b/examples/tools/internal_ambiguities.rs
@@ -6,6 +6,6 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .insert_resource(ReportExecutionOrderAmbiguities::ReportInternal)
+        .insert_resource(ReportExecutionOrderAmbiguities::WarnInternal)
         .run()
 }

From 4df39ff0dc06ac4520a4e9bc7b96aafdd04c0221 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 18:49:54 -0400
Subject: [PATCH 085/113] Rename ReportExecutionOrderAmbiguities to
 ExecutionOrderAmbiguities

---
 crates/bevy_ecs/src/lib.rs                    |  4 +-
 .../src/schedule/ambiguity_detection.rs       | 64 +++++++++----------
 crates/bevy_ecs/src/schedule/stage.rs         | 12 ++--
 examples/ecs/ambiguity_checker.rs             |  2 +-
 examples/ecs/ecs_guide.rs                     |  4 +-
 examples/tools/internal_ambiguities.rs        |  2 +-
 6 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 183a9d676a3b6..d182a281afac5 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -28,8 +28,8 @@ pub mod prelude {
         event::{EventReader, EventWriter},
         query::{Added, AnyOf, ChangeTrackers, Changed, Or, QueryState, With, Without},
         schedule::{
-            AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            ReportExecutionOrderAmbiguities, RunCriteria, RunCriteriaDescriptorCoercion,
+            AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ExecutionOrderAmbiguities,
+            ParallelSystemDescriptorCoercion, RunCriteria, RunCriteriaDescriptorCoercion,
             RunCriteriaLabel, RunCriteriaPiping, Schedule, Stage, StageLabel, State, SystemLabel,
             SystemSet, SystemStage,
         },
diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 77fbb442712ee..5a1a964a3cc31 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -31,7 +31,7 @@ use fixedbitset::FixedBitSet;
 /// App::new()
 ///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
 /// ```
-pub enum ReportExecutionOrderAmbiguities {
+pub enum ExecutionOrderAmbiguities {
     /// Disables all checks for execution order ambiguities
     Allow,
     /// Displays only the number of unresolved ambiguities detected by the ambiguity checker
@@ -164,16 +164,16 @@ pub fn find_ambiguities(
     systems: &[impl SystemContainer],
     crates_filter: &[String],
     // Should explicit attempts to ignore ambiguities be obeyed?
-    report_level: ReportExecutionOrderAmbiguities,
+    report_level: ExecutionOrderAmbiguities,
 ) -> Vec<(usize, usize, Vec<ComponentId>)> {
     fn should_ignore_ambiguity(
         systems: &[impl SystemContainer],
         index_a: usize,
         index_b: usize,
         crates_filter: &[String],
-        report_level: ReportExecutionOrderAmbiguities,
+        report_level: ExecutionOrderAmbiguities,
     ) -> bool {
-        if report_level == ReportExecutionOrderAmbiguities::Forbid {
+        if report_level == ExecutionOrderAmbiguities::Forbid {
             return false;
         }
 
@@ -259,9 +259,9 @@ pub fn find_ambiguities(
     ambiguities
 }
 
-impl Default for ReportExecutionOrderAmbiguities {
+impl Default for ExecutionOrderAmbiguities {
     fn default() -> Self {
-        ReportExecutionOrderAmbiguities::Warn
+        ExecutionOrderAmbiguities::Warn
     }
 }
 
@@ -278,11 +278,11 @@ impl SystemStage {
         // FIXME: these methods should not have tor rely on &mut World, or any specific World
         // see https://github.com/bevyengine/bevy/issues/4364
         world: &mut World,
-        report_level: ReportExecutionOrderAmbiguities,
+        report_level: ExecutionOrderAmbiguities,
     ) -> Vec<SystemOrderAmbiguity> {
         self.initialize(world);
 
-        if report_level == ReportExecutionOrderAmbiguities::Allow {
+        if report_level == ExecutionOrderAmbiguities::Allow {
             return Vec::default();
         }
 
@@ -290,7 +290,7 @@ impl SystemStage {
         debug_assert!(!self.systems_modified);
 
         // TODO: remove all internal ambiguities and remove this logic
-        let ignored_crates = if report_level != ReportExecutionOrderAmbiguities::WarnInternal {
+        let ignored_crates = if report_level != ExecutionOrderAmbiguities::WarnInternal {
             vec![
                 // Rendering
                 "bevy_render".to_string(),
@@ -385,7 +385,7 @@ impl SystemStage {
     pub fn n_ambiguities(
         &mut self,
         world: &mut World,
-        report_level: ReportExecutionOrderAmbiguities,
+        report_level: ExecutionOrderAmbiguities,
     ) -> usize {
         self.ambiguities(world, report_level).len()
     }
@@ -394,7 +394,7 @@ impl SystemStage {
     pub fn report_ambiguities(
         &mut self,
         world: &mut World,
-        report_level: ReportExecutionOrderAmbiguities,
+        report_level: ExecutionOrderAmbiguities,
     ) {
         let ambiguities = self.ambiguities(world, report_level);
         let unresolved_count = ambiguities.len();
@@ -409,7 +409,7 @@ impl SystemStage {
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
             }
 
-            if report_level == ReportExecutionOrderAmbiguities::Warn {
+            if report_level == ExecutionOrderAmbiguities::Warn {
                 println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
@@ -434,8 +434,8 @@ impl SystemStage {
                 println!("");
             }
 
-            if report_level == ReportExecutionOrderAmbiguities::Deny
-                || report_level == ReportExecutionOrderAmbiguities::Forbid
+            if report_level == ExecutionOrderAmbiguities::Deny
+                || report_level == ExecutionOrderAmbiguities::Forbid
             {
                 panic!("The ReportExecutionOrderAmbiguities resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
             }
@@ -594,7 +594,7 @@ mod tests {
             .add_system(event_writer_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -619,7 +619,7 @@ mod tests {
             .add_system(read_world_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -637,7 +637,7 @@ mod tests {
             .add_system(read_world_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             3
         );
     }
@@ -650,7 +650,7 @@ mod tests {
         test_stage.add_system(resmut_system).add_system(res_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             1
         );
     }
@@ -665,7 +665,7 @@ mod tests {
             .add_system(nonsend_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             1
         );
     }
@@ -680,7 +680,7 @@ mod tests {
             .add_system(write_component_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             1
         );
     }
@@ -695,7 +695,7 @@ mod tests {
             .add_system(without_filtered_component_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -712,7 +712,7 @@ mod tests {
             .add_system(event_resource_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             3
         );
     }
@@ -732,7 +732,7 @@ mod tests {
             .add_system(write_world_system.exclusive_system().before_commands());
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             3
         );
     }
@@ -749,7 +749,7 @@ mod tests {
             .add_system(event_resource_system.after(event_writer_system));
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             // All of these systems clash
             0
         );
@@ -764,7 +764,7 @@ mod tests {
             .add_system(res_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -778,7 +778,7 @@ mod tests {
             .add_system(res_system.label("IGNORE_ME"));
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -815,7 +815,7 @@ mod tests {
             .add_system(system_b);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -825,7 +825,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             0
         );
     }
@@ -835,7 +835,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             2
         );
     }
@@ -845,7 +845,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             2
         );
     }
@@ -855,7 +855,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
             6
         );
     }
@@ -869,7 +869,7 @@ mod tests {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         let ambiguities =
-            test_stage.ambiguities(&mut world, ReportExecutionOrderAmbiguities::WarnVerbose);
+            test_stage.ambiguities(&mut world, ExecutionOrderAmbiguities::WarnVerbose);
         assert_eq!(
             // We don't care if the reported order varies
             HashSet::from_iter(ambiguities),
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 71cddc236a0ae..50485106b51e5 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -3,11 +3,11 @@ use crate::{
     schedule::{
         graph_utils::{self, DependencyGraphError},
         BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
-        ExclusiveSystemContainer, GraphNode, InsertionPoint, IntoSystemDescriptor,
-        ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor,
-        ReportExecutionOrderAmbiguities, RunCriteriaContainer, RunCriteriaDescriptor,
-        RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun, SingleThreadedExecutor,
-        SystemContainer, SystemDescriptor, SystemSet,
+        ExclusiveSystemContainer, ExecutionOrderAmbiguities, GraphNode, InsertionPoint,
+        IntoSystemDescriptor, ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor,
+        RunCriteriaContainer, RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel,
+        RunCriteriaInner, ShouldRun, SingleThreadedExecutor, SystemContainer, SystemDescriptor,
+        SystemSet,
     },
     world::{World, WorldId},
 };
@@ -112,7 +112,7 @@ impl SystemStage {
             self.executor_modified = false;
             // This cannot panic, so we insert the default value if it was not present
             let report_level = world
-                .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default)
+                .get_resource_or_insert_with(ExecutionOrderAmbiguities::default)
                 .clone();
             self.report_ambiguities(world, report_level);
         } else if self.executor_modified {
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index d49798f656f25..287305612825d 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -6,7 +6,7 @@ fn main() {
         // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
         // By default only a warning with the number of unresolved ambiguities is shown, but
         // a more complete report will be displayed if we explicitly set this resource to verbose.
-        .insert_resource(ReportExecutionOrderAmbiguities::WarnVerbose)
+        .insert_resource(ExecutionOrderAmbiguities::WarnVerbose)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
         // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index d330aeedd8f07..da1d168bceb4a 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -1,6 +1,6 @@
 use bevy::{
     app::{AppExit, ScheduleRunnerPlugin, ScheduleRunnerSettings},
-    ecs::schedule::ReportExecutionOrderAmbiguities,
+    ecs::schedule::ExecutionOrderAmbiguities,
     prelude::*,
     utils::Duration,
 };
@@ -332,7 +332,7 @@ fn main() {
         // in the console by adding the following resource to our App
         // Execution order ambiguities can be resolved by adding ordering constraints,
         // or explicitly ignored (when there's a false positive).
-        .insert_resource(ReportExecutionOrderAmbiguities::WarnVerbose)
+        .insert_resource(ExecutionOrderAmbiguities::WarnVerbose)
         // This call to run() starts the app we just built!
         .run();
 }
diff --git a/examples/tools/internal_ambiguities.rs b/examples/tools/internal_ambiguities.rs
index 3a653a4a12cbf..8144a1b52590f 100644
--- a/examples/tools/internal_ambiguities.rs
+++ b/examples/tools/internal_ambiguities.rs
@@ -6,6 +6,6 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .insert_resource(ReportExecutionOrderAmbiguities::WarnInternal)
+        .insert_resource(ExecutionOrderAmbiguities::WarnInternal)
         .run()
 }

From b38bb1bfc2d5ed3838ac40e71fa3be7691d41af2 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 19:26:58 -0400
Subject: [PATCH 086/113] Thanks clippy

---
 .../src/schedule/ambiguity_detection.rs       | 79 +++++++++++--------
 crates/bevy_ecs/src/schedule/stage.rs         |  5 +-
 2 files changed, 50 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 5a1a964a3cc31..b56d0ba165bb5 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -2,8 +2,8 @@ use crate::component::ComponentId;
 use crate::schedule::{AmbiguityDetection, SystemContainer, SystemStage};
 use crate::world::World;
 
-use bevy_utils::HashSet;
 use fixedbitset::FixedBitSet;
+use std::hash::Hash;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 /// Systems that access the same Component or Resource within the same stage
@@ -58,10 +58,10 @@ pub enum ExecutionOrderAmbiguities {
 ///
 /// Created by applying [`find_ambiguities`] to a [`SystemContainer`].
 /// These can be reported by configuring the [`ReportExecutionOrderAmbiguities`] resource.
-#[derive(Debug, Clone, Eq, Hash)]
+#[derive(Debug, Clone, Eq)]
 pub struct SystemOrderAmbiguity {
     // The names of the conflicting systems
-    pub system_names: (String, String),
+    pub system_names: [String; 2],
     /// The components (and resources) that these systems have incompatible access to
     pub conflicts: Vec<String>,
     /// The segment of the [`SystemStage`] that the conflicting systems were stored in
@@ -70,20 +70,37 @@ pub struct SystemOrderAmbiguity {
 
 impl PartialEq for SystemOrderAmbiguity {
     fn eq(&self, other: &Self) -> bool {
-        // The order of the systems doesn't matter
-        let names_aligned = (self.system_names.0 == other.system_names.0)
-            & (self.system_names.1 == other.system_names.1);
-        let names_inverted = (self.system_names.0 == other.system_names.1)
-            & (self.system_names.0 == other.system_names.1);
-        let names_match = names_aligned | names_inverted;
+        let mut self_names = self.system_names.clone();
+        self_names.sort();
 
-        // The order of the reported conflicts doesn't matter
-        let conflicts_match =
-            HashSet::from_iter(self.conflicts.iter()) == HashSet::from_iter(other.conflicts.iter());
+        let mut other_names = self.system_names.clone();
+        other_names.sort();
+
+        let mut self_conflicts = self.conflicts.clone();
+        self_conflicts.sort();
+
+        let mut other_conflicts = self.conflicts.clone();
+        other_conflicts.sort();
 
-        let segments_match = self.segment == other.segment;
+        (self_names == other_names)
+            && (self_conflicts == other_conflicts)
+            && (self.segment == other.segment)
+    }
+}
 
-        names_match & conflicts_match & segments_match
+// This impl is needed to allow us to test whether a returned set of ambiguities
+// matches the expected value
+impl Hash for SystemOrderAmbiguity {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        // The order of the systems doesn't matter
+        let mut system_names = self.system_names.clone();
+        system_names.sort();
+        system_names.hash(state);
+        // The order of the reported conflicts doesn't matter
+        let mut conflicts = self.conflicts.clone();
+        conflicts.sort();
+        conflicts.hash(state);
+        self.segment.hash(state);
     }
 }
 
@@ -150,7 +167,7 @@ impl SystemOrderAmbiguity {
 
         Self {
             // Don't bother with Cows here
-            system_names: (system_a_name.into(), system_b_name.into()),
+            system_names: [system_a_name.into(), system_b_name.into()],
             conflicts,
             segment,
         }
@@ -318,8 +335,8 @@ impl SystemStage {
                         *system_b_index,
                         component_ids.to_vec(),
                         SystemStageSegment::Parallel,
-                        &self,
-                        &world,
+                        self,
+                        world,
                     )
                 })
                 .collect();
@@ -333,8 +350,8 @@ impl SystemStage {
                         *system_b_index,
                         component_ids.to_vec(),
                         SystemStageSegment::ExclusiveAtStart,
-                        &self,
-                        &world,
+                        self,
+                        world,
                     )
                 })
                 .collect();
@@ -351,8 +368,8 @@ impl SystemStage {
                 *system_b_index,
                 component_ids.to_vec(),
                 SystemStageSegment::ExclusiveBeforeCommands,
-                &self,
-                &world,
+                self,
+                world,
             )
         })
         .collect();
@@ -366,8 +383,8 @@ impl SystemStage {
                         *system_b_index,
                         component_ids.to_vec(),
                         SystemStageSegment::ExclusiveAtEnd,
-                        &self,
-                        &world,
+                        self,
+                        world,
                     )
                 })
                 .collect();
@@ -415,8 +432,8 @@ impl SystemStage {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
                     let ambiguity_number = i + 1;
                     // The path name is often just noise, and this gets us consistency with `conflicts`'s formatting
-                    let system_a_name = format_type_name(ambiguity.system_names.0.as_str());
-                    let system_b_name = format_type_name(ambiguity.system_names.1.as_str());
+                    let system_a_name = format_type_name(ambiguity.system_names[0].as_str());
+                    let system_b_name = format_type_name(ambiguity.system_names[1].as_str());
                     let mut conflicts: Vec<String> = ambiguity
                         .conflicts
                         .iter()
@@ -431,13 +448,13 @@ impl SystemStage {
                     println!("{ambiguity_number:?}. `{system_a_name}` conflicts with `{system_b_name}` on {conflicts:?}");
                 }
                 // Print an empty line to space out multiple stages nicely
-                println!("");
+                println!();
             }
 
             if report_level == ExecutionOrderAmbiguities::Deny
                 || report_level == ExecutionOrderAmbiguities::Forbid
             {
-                panic!("The ReportExecutionOrderAmbiguities resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
+                panic!("The `ReportExecutionOrderAmbiguities` resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
             }
         }
     }
@@ -875,18 +892,18 @@ mod tests {
             HashSet::from_iter(ambiguities),
             HashSet::from_iter(vec![
                 SystemOrderAmbiguity {
-                    system_names: (
+                    system_names: [
                         "bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(),
                         "bevy_ecs::schedule::ambiguity_detection::tests::system_b".to_string()
-                    ),
+                    ],
                     conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
                     segment: bevy_ecs::schedule::SystemStageSegment::Parallel,
                 },
                 SystemOrderAmbiguity {
-                    system_names: (
+                    system_names: [
                         "bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(),
                         "bevy_ecs::schedule::ambiguity_detection::tests::system_d".to_string()
-                    ),
+                    ],
                     conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
                     segment: bevy_ecs::schedule::SystemStageSegment::Parallel,
                 },
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 50485106b51e5..0a9d921c7bb2a 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -111,9 +111,8 @@ impl SystemStage {
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
             // This cannot panic, so we insert the default value if it was not present
-            let report_level = world
-                .get_resource_or_insert_with(ExecutionOrderAmbiguities::default)
-                .clone();
+            let report_level =
+                *world.get_resource_or_insert_with(ExecutionOrderAmbiguities::default);
             self.report_ambiguities(world, report_level);
         } else if self.executor_modified {
             self.executor.rebuild_cached_data(&self.parallel);

From 69cb9b777d284603575fabb8773e0b50f2374b5e Mon Sep 17 00:00:00 2001
From: Alice <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 21:23:30 -0400
Subject: [PATCH 087/113] Fix broken tests

---
 .../src/schedule/ambiguity_detection.rs       | 48 +++++++++----------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index b56d0ba165bb5..56bd0f8850c2a 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -460,7 +460,7 @@ impl SystemStage {
     }
 }
 
-/// Collapses a name returned by std::any::type_name to remove its module path
+/// Collapses a name returned by [`std::any::type_name`] to remove its module path
 fn format_type_name(raw_name: &str) -> String {
     // Generics result in nested paths within <..> blocks
     // Consider "bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"
@@ -781,7 +781,7 @@ mod tests {
             .add_system(res_system);
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Warn),
             0
         );
     }
@@ -795,7 +795,21 @@ mod tests {
             .add_system(res_system.label("IGNORE_ME"));
 
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Warn),
+            0
+        );
+    }
+
+    #[test]
+    fn ambiguous_with_system() {
+        let mut world = World::new();
+        let mut test_stage = SystemStage::parallel();
+        test_stage
+            .add_system(system_a.ambiguous_with(system_b))
+            .add_system(system_b);
+
+        assert_eq!(
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Warn),
             0
         );
     }
@@ -824,51 +838,37 @@ mod tests {
     }
 
     #[test]
-    fn ambiguous_with_system() {
-        let mut world = World::new();
-        let mut test_stage = SystemStage::parallel();
-        test_stage
-            .add_system(system_a.ambiguous_with(system_b))
-            .add_system(system_b);
-
-        assert_eq!(
-            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
-            0
-        );
-    }
-
-    #[test]
-    fn off() {
+    fn allow() {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Allow),
             0
         );
     }
 
     #[test]
-    fn minimal() {
+    fn warn() {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Warn),
             2
         );
     }
 
     #[test]
-    fn verbose() {
+    fn warn_verbose() {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(
-            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),
+            test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::WarnVerbose),
             2
         );
     }
 
     #[test]
-    fn deterministic() {
+    fn forbid() {
         let mut world = World::new();
         let mut test_stage = make_test_stage(&mut world);
         assert_eq!(

From 7b13ca74d9935a0f1a1a6744d82bd159420a8704 Mon Sep 17 00:00:00 2001
From: Alice <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 21:27:01 -0400
Subject: [PATCH 088/113] Fix type name formatting when a local type is used as
 second type param

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 56bd0f8850c2a..b453344b9c86c 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -504,7 +504,7 @@ fn collapse_type_name(string: &str) -> String {
     let type_name = string.split("::").last().unwrap();
 
     // Account for leading white space
-    if string.get(0..1).unwrap_or_default() == " " {
+    if string.get(0..1).unwrap_or_default() == " " && type_name != string {
         format!(" {type_name}")
     } else {
         type_name.to_string()
@@ -513,8 +513,6 @@ fn collapse_type_name(string: &str) -> String {
 
 #[cfg(test)]
 mod name_formatting_tests {
-    use crate::schedule::ambiguity_detection::collapse_type_name;
-
     use super::format_type_name;
 
     #[test]
@@ -540,11 +538,6 @@ mod name_formatting_tests {
         assert_eq!(format_type_name("a<B, C>"), "a<B, C>".to_string())
     }
 
-    #[test]
-    fn leading_whitespace() {
-        assert_eq!(collapse_type_name(" foo::A"), " A")
-    }
-
     #[test]
     fn generics() {
         assert_eq!(

From 65cb329c84d113e2a86425eb86ecf175317c581d Mon Sep 17 00:00:00 2001
From: Alice <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 21:51:15 -0400
Subject: [PATCH 089/113] Fix doc links

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

diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 3b17c5414a1ae..c3dc1b6d51d37 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -98,7 +98,7 @@ impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
 /// See the methods on [`ParallelSystemDescriptor`] to set this for a given system.
 ///
 /// The overall behavior is configured using the
-/// [`ReportExecutionOrderAmbiguities`](crate::schedule::ReportExecutionOrderAmbiguities) resource.
+/// [`ExecutionOrderAmbiguities`](crate::schedule::ExecutionOrderAmbiguities) resource.
 pub enum AmbiguityDetection {
     Check,
     Ignore,

From f9148cf3fca72968b90c28e289294e01e69b7b8b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 30 Mar 2022 23:32:53 -0400
Subject: [PATCH 090/113] Simplify string parsing

---
 .../src/schedule/ambiguity_detection.rs       | 21 ++++++-------------
 1 file changed, 6 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index b453344b9c86c..8c22326104ef7 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -472,16 +472,15 @@ fn format_type_name(raw_name: &str) -> String {
     while index < end_of_string {
         let rest_of_string = raw_name.get(index..end_of_string).unwrap_or_default();
 
-        // Collapse everything up to the next "<", "," or ">",
+        // Collapse everything up to the next special character,
         // then skip over it
         if let Some(special_character_index) =
-            rest_of_string.find(|c: char| (c == '<') || (c == ',') || (c == '>'))
+            rest_of_string.find(|c: char| (c == '<') || (c == ',') || (c == ' ') || (c == '>'))
         {
             let segment_to_collapse = rest_of_string
                 .get(0..special_character_index)
                 .unwrap_or_default();
-            let collapsed_type_name = collapse_type_name(segment_to_collapse);
-            parsed_name += &collapsed_type_name;
+            parsed_name += collapse_type_name(segment_to_collapse);
             // Insert the special character
             let special_character =
                 &rest_of_string[special_character_index..=special_character_index];
@@ -490,8 +489,7 @@ fn format_type_name(raw_name: &str) -> String {
             index += special_character_index + 1;
         } else {
             // If there are no special characters left, we're done!
-            let collapsed_type_name = collapse_type_name(rest_of_string);
-            parsed_name += &collapsed_type_name;
+            parsed_name += collapse_type_name(rest_of_string);
             index = end_of_string;
         }
     }
@@ -500,15 +498,8 @@ fn format_type_name(raw_name: &str) -> String {
 }
 
 #[inline(always)]
-fn collapse_type_name(string: &str) -> String {
-    let type_name = string.split("::").last().unwrap();
-
-    // Account for leading white space
-    if string.get(0..1).unwrap_or_default() == " " && type_name != string {
-        format!(" {type_name}")
-    } else {
-        type_name.to_string()
-    }
+fn collapse_type_name(string: &str) -> &str {
+    string.split("::").last().unwrap()
 }
 
 #[cfg(test)]

From 312168f5d094b09e55a508ed7ec1ae5e1ec24245 Mon Sep 17 00:00:00 2001
From: Alice <alice.i.cecile@gmail.com>
Date: Thu, 31 Mar 2022 00:36:11 -0400
Subject: [PATCH 091/113] Fix overlooked refactoring errors

---
 .../bevy_ecs/src/schedule/ambiguity_detection.rs   | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 8c22326104ef7..5eeee5969c6ab 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -23,14 +23,6 @@ use std::hash::Hash;
 /// to have unambiguous order with regards to a group of already-constrained systems.
 ///
 /// By default, the value of this resource is set to `Warn`.
-///
-/// ## Example
-/// ```ignore
-/// # use bevy_app::App;
-/// # use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
-/// App::new()
-///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
-/// ```
 pub enum ExecutionOrderAmbiguities {
     /// Disables all checks for execution order ambiguities
     Allow,
@@ -57,7 +49,7 @@ pub enum ExecutionOrderAmbiguities {
 /// A pair of systems that can run in an ambiguous order
 ///
 /// Created by applying [`find_ambiguities`] to a [`SystemContainer`].
-/// These can be reported by configuring the [`ReportExecutionOrderAmbiguities`] resource.
+/// These can be reported by configuring the [`ExecutionOrderAmbiguities`] resource.
 #[derive(Debug, Clone, Eq)]
 pub struct SystemOrderAmbiguity {
     // The names of the conflicting systems
@@ -427,7 +419,7 @@ impl SystemStage {
             }
 
             if report_level == ExecutionOrderAmbiguities::Warn {
-                println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
+                println!("Set the level of the `ExecutionOrderAmbiguities` resource to `ExecutionOrderAmbiguities::WarnVerbose` for more details.");
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
                     let ambiguity_number = i + 1;
@@ -454,7 +446,7 @@ impl SystemStage {
             if report_level == ExecutionOrderAmbiguities::Deny
                 || report_level == ExecutionOrderAmbiguities::Forbid
             {
-                panic!("The `ReportExecutionOrderAmbiguities` resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
+                panic!("The `ExecutionOrderAmbiguities` resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
             }
         }
     }

From d90fa27c15dc74fffa355f48773bfc537711fd14 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 31 Mar 2022 13:18:36 -0400
Subject: [PATCH 092/113] Use tracing macros, rather than println!()

---
 .../src/schedule/ambiguity_detection.rs       | 19 +++++++++++++------
 examples/tools/internal_ambiguities.rs        |  2 +-
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 5eeee5969c6ab..a7bab7bcf333f 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -2,6 +2,7 @@ use crate::component::ComponentId;
 use crate::schedule::{AmbiguityDetection, SystemContainer, SystemStage};
 use crate::world::World;
 
+use bevy_utils::tracing::{error, warn};
 use fixedbitset::FixedBitSet;
 use std::hash::Hash;
 
@@ -408,18 +409,20 @@ impl SystemStage {
         let ambiguities = self.ambiguities(world, report_level);
         let unresolved_count = ambiguities.len();
 
+        let mut warning_string = String::new();
+
         if unresolved_count > 0 {
             // Grammar
             if unresolved_count == 1 {
-                println!("One of your stages contains 1 pair of systems with unknown order and conflicting data access. \n\
-				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
+                warning_string += "One of your stages contains 1 pair of systems with unknown order and conflicting data access. \n\
+				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n";
             } else {
-                println!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \n\
+                warning_string += &format!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \n\
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
             }
 
             if report_level == ExecutionOrderAmbiguities::Warn {
-                println!("Set the level of the `ExecutionOrderAmbiguities` resource to `ExecutionOrderAmbiguities::WarnVerbose` for more details.");
+                warning_string += "Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::WarnVerbose` for more details.";
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
                     let ambiguity_number = i + 1;
@@ -437,16 +440,20 @@ impl SystemStage {
                         conflicts = vec!["World".to_string()];
                     }
 
-                    println!("{ambiguity_number:?}. `{system_a_name}` conflicts with `{system_b_name}` on {conflicts:?}");
+                    warning_string += &format!("\n{ambiguity_number:?}. `{system_a_name}` conflicts with `{system_b_name}` on {conflicts:?}");
                 }
                 // Print an empty line to space out multiple stages nicely
+                warning_string.push('\n');
                 println!();
             }
 
             if report_level == ExecutionOrderAmbiguities::Deny
                 || report_level == ExecutionOrderAmbiguities::Forbid
             {
-                panic!("The `ExecutionOrderAmbiguities` resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")
+                error!("{warning_string}");
+                panic!("`ExecutionOrderAmbiguities` is set to `{report_level:?}`, which forbids the `App` from running if any unresolved system order ambiguities exist.")
+            } else {
+                warn!("{warning_string}");
             }
         }
     }
diff --git a/examples/tools/internal_ambiguities.rs b/examples/tools/internal_ambiguities.rs
index 8144a1b52590f..37b7f5190d2be 100644
--- a/examples/tools/internal_ambiguities.rs
+++ b/examples/tools/internal_ambiguities.rs
@@ -6,6 +6,6 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .insert_resource(ExecutionOrderAmbiguities::WarnInternal)
+        .insert_resource(ExecutionOrderAmbiguities::Forbid)
         .run()
 }

From 299263cbb4122660f0db5b79b5d800de62ba5a73 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 31 Mar 2022 14:34:43 -0400
Subject: [PATCH 093/113] Fix with/without query slicing test

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

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index a7bab7bcf333f..4c0f66c03434c 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -572,8 +572,8 @@ mod tests {
     fn nonsendmut_system(_ns: NonSendMut<R>) {}
     fn read_component_system(_query: Query<&A>) {}
     fn write_component_system(_query: Query<&mut A>) {}
-    fn with_filtered_component_system(_query: Query<&A, With<B>>) {}
-    fn without_filtered_component_system(_query: Query<&A, Without<B>>) {}
+    fn with_filtered_component_system(_query: Query<&mut A, With<B>>) {}
+    fn without_filtered_component_system(_query: Query<&mut A, Without<B>>) {}
     fn event_reader_system(_reader: EventReader<E>) {}
     fn event_writer_system(_writer: EventWriter<E>) {}
     fn event_resource_system(_events: ResMut<Events<E>>) {}

From 4d64cfbb4159483ecf6bd8a7b6b564d0d58f60db Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 31 Mar 2022 19:52:29 -0400
Subject: [PATCH 094/113] Ignore known failing test

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 4c0f66c03434c..060e3e5d2ba6e 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -686,6 +686,9 @@ mod tests {
     }
 
     #[test]
+    // Known failing: this should work but doesn't, as we're not looking at filtered access
+    // See https://github.com/bevyengine/bevy/issues/4381
+    #[ignore]
     fn filtered_components() {
         let mut world = World::new();
         let mut test_stage = SystemStage::parallel();

From 0f651942e517cd9a80f778bb521bab0c7cf9b7e2 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:18:09 -0400
Subject: [PATCH 095/113] Remove spurious println()

Co-authored-by: Mike <mike.hsu@gmail.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 060e3e5d2ba6e..61e05be0a3ff3 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -444,7 +444,6 @@ impl SystemStage {
                 }
                 // Print an empty line to space out multiple stages nicely
                 warning_string.push('\n');
-                println!();
             }
 
             if report_level == ExecutionOrderAmbiguities::Deny

From 7cf82daffe51be144b92549c2ef52ead6b5cfdb2 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:19:01 -0400
Subject: [PATCH 096/113] Cleaner handling of plural case.

Co-authored-by: Mike <mike.hsu@gmail.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 61e05be0a3ff3..0e1a30c3cf393 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -412,12 +412,8 @@ impl SystemStage {
         let mut warning_string = String::new();
 
         if unresolved_count > 0 {
-            // Grammar
-            if unresolved_count == 1 {
-                warning_string += "One of your stages contains 1 pair of systems with unknown order and conflicting data access. \n\
-				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n";
-            } else {
-                warning_string += &format!("One of your stages contains {unresolved_count} pairs of systems with unknown order and conflicting data access. \n\
+            let plural = if unresolved_count == 1 { "" } else { "s" };
+            warning_string += &format!("One of your stages contains {unresolved_count} pair{plural} of systems with unknown order and conflicting data access. \n\
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
             }
 

From 5c1000ce4a023be08c4219f67d68b2ebcae61be6 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:19:24 -0400
Subject: [PATCH 097/113] Formatting

Co-authored-by: Mike <mike.hsu@gmail.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 0e1a30c3cf393..83b4b93fc13a4 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -736,6 +736,7 @@ mod tests {
     }
 
     // Tests for silencing and resolving ambiguities
+    
     #[test]
     fn before_and_after() {
         let mut world = World::new();

From ade98dc39c302de671f311f126c95d81530a4505 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:19:58 -0400
Subject: [PATCH 098/113] Fix internal_ambiguities example warning level

Co-authored-by: Mike <mike.hsu@gmail.com>
---
 examples/tools/internal_ambiguities.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/tools/internal_ambiguities.rs b/examples/tools/internal_ambiguities.rs
index 37b7f5190d2be..8144a1b52590f 100644
--- a/examples/tools/internal_ambiguities.rs
+++ b/examples/tools/internal_ambiguities.rs
@@ -6,6 +6,6 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .insert_resource(ExecutionOrderAmbiguities::Forbid)
+        .insert_resource(ExecutionOrderAmbiguities::WarnInternal)
         .run()
 }

From 7a8d1e089590941ef23cf286a49e863668c05e03 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:24:17 -0400
Subject: [PATCH 099/113] Minor fixes

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 83b4b93fc13a4..18c882b9d74f9 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -415,7 +415,6 @@ impl SystemStage {
             let plural = if unresolved_count == 1 { "" } else { "s" };
             warning_string += &format!("One of your stages contains {unresolved_count} pair{plural} of systems with unknown order and conflicting data access. \n\
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
-            }
 
             if report_level == ExecutionOrderAmbiguities::Warn {
                 warning_string += "Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::WarnVerbose` for more details.";
@@ -736,7 +735,7 @@ mod tests {
     }
 
     // Tests for silencing and resolving ambiguities
-    
+
     #[test]
     fn before_and_after() {
         let mut world = World::new();

From 4ce3a211951e700d30919e0bd9f8a1d56f652798 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:38:49 -0400
Subject: [PATCH 100/113] Improve docs

---
 .../bevy_ecs/src/schedule/ambiguity_detection.rs  | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 18c882b9d74f9..1ed859de853cd 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -16,12 +16,17 @@ use std::hash::Hash;
 ///
 /// Some ambiguities reported by the ambiguity checker may be warranted (to allow two systems to run
 /// without blocking each other) or spurious, as the exact combination of archetypes used may
-/// prevent them from ever conflicting during actual gameplay. You can resolve the warnings produced
-/// by the ambiguity checker by adding `.before` or `.after` to one of the conflicting systems
-/// referencing the other system to force a specific ordering.
+/// prevent them from ever conflicting during actual gameplay.
+/// You can resolve the warnings produced by the ambiguity checker by adding `.before` or `.after`
+/// to one of the conflicting systems referencing the other system to force a specific ordering.
+/// Alternatively, if you're confident the error is a false positive (and you don't need true determinism),
+/// you can explicitly ignore it using the `.ambiguous_with` method.
 ///
-/// The checker may report a system more times than the amount of constraints it would actually need
-/// to have unambiguous order with regards to a group of already-constrained systems.
+/// Note that the checker reports each pairwise ambiguity:
+/// typically, these can be resolved with fewer constraints than the number of ambiguities listed
+/// as transitive orderings will resolve ambiguities (e.g. A before B before C will resolve an ambiguity between A and C).
+/// It's generally more productive to pause and reflect on the underlying structure of your logic,
+/// rather than blindly resolving one warning at a time.
 ///
 /// By default, the value of this resource is set to `Warn`.
 pub enum ExecutionOrderAmbiguities {

From 078d69ab9efee144c8a6bd320f973b854262da1a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:52:16 -0400
Subject: [PATCH 101/113] Move type name shortening to bevy_utils

---
 .../src/schedule/ambiguity_detection.rs       | 93 +------------------
 crates/bevy_utils/src/lib.rs                  |  2 +
 crates/bevy_utils/src/short_name.rs           | 85 +++++++++++++++++
 3 files changed, 91 insertions(+), 89 deletions(-)
 create mode 100644 crates/bevy_utils/src/short_name.rs

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 1ed859de853cd..d155fffbe10bd 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -2,6 +2,7 @@ use crate::component::ComponentId;
 use crate::schedule::{AmbiguityDetection, SystemContainer, SystemStage};
 use crate::world::World;
 
+use bevy_utils::get_short_name;
 use bevy_utils::tracing::{error, warn};
 use fixedbitset::FixedBitSet;
 use std::hash::Hash;
@@ -427,12 +428,12 @@ impl SystemStage {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
                     let ambiguity_number = i + 1;
                     // The path name is often just noise, and this gets us consistency with `conflicts`'s formatting
-                    let system_a_name = format_type_name(ambiguity.system_names[0].as_str());
-                    let system_b_name = format_type_name(ambiguity.system_names[1].as_str());
+                    let system_a_name = get_short_name(ambiguity.system_names[0].as_str());
+                    let system_b_name = get_short_name(ambiguity.system_names[1].as_str());
                     let mut conflicts: Vec<String> = ambiguity
                         .conflicts
                         .iter()
-                        .map(|name| format_type_name(name.as_str()))
+                        .map(|name| get_short_name(name.as_str()))
                         .collect();
 
                     // Exclusive system conflicts are reported as conflicting on the empty set
@@ -458,92 +459,6 @@ impl SystemStage {
     }
 }
 
-/// Collapses a name returned by [`std::any::type_name`] to remove its module path
-fn format_type_name(raw_name: &str) -> String {
-    // Generics result in nested paths within <..> blocks
-    // Consider "bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"
-    // To tackle this, we parse the string from left to right, collapsing as we go
-    let mut index: usize = 0;
-    let end_of_string = raw_name.len();
-    let mut parsed_name = String::new();
-
-    while index < end_of_string {
-        let rest_of_string = raw_name.get(index..end_of_string).unwrap_or_default();
-
-        // Collapse everything up to the next special character,
-        // then skip over it
-        if let Some(special_character_index) =
-            rest_of_string.find(|c: char| (c == '<') || (c == ',') || (c == ' ') || (c == '>'))
-        {
-            let segment_to_collapse = rest_of_string
-                .get(0..special_character_index)
-                .unwrap_or_default();
-            parsed_name += collapse_type_name(segment_to_collapse);
-            // Insert the special character
-            let special_character =
-                &rest_of_string[special_character_index..=special_character_index];
-            parsed_name.push_str(special_character);
-            // Move the index just past the special character
-            index += special_character_index + 1;
-        } else {
-            // If there are no special characters left, we're done!
-            parsed_name += collapse_type_name(rest_of_string);
-            index = end_of_string;
-        }
-    }
-
-    parsed_name
-}
-
-#[inline(always)]
-fn collapse_type_name(string: &str) -> &str {
-    string.split("::").last().unwrap()
-}
-
-#[cfg(test)]
-mod name_formatting_tests {
-    use super::format_type_name;
-
-    #[test]
-    fn trivial() {
-        assert_eq!(format_type_name("test_system"), "test_system")
-    }
-
-    #[test]
-    fn path_seperated() {
-        assert_eq!(
-            format_type_name("bevy_prelude::make_fun_game"),
-            "make_fun_game".to_string()
-        )
-    }
-
-    #[test]
-    fn trivial_generics() {
-        assert_eq!(format_type_name("a<B>"), "a<B>".to_string())
-    }
-
-    #[test]
-    fn multiple_type_parameters() {
-        assert_eq!(format_type_name("a<B, C>"), "a<B, C>".to_string())
-    }
-
-    #[test]
-    fn generics() {
-        assert_eq!(
-            format_type_name("bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"),
-            "extract_cameras<Camera3d>".to_string()
-        )
-    }
-
-    #[test]
-    fn nested_generics() {
-        assert_eq!(
-            format_type_name("bevy::mad_science::do_mad_science<mad_science::Test<mad_science::Tube>, bavy::TypeSystemAbuse>"),
-            "do_mad_science<Test<Tube>, TypeSystemAbuse>".to_string()
-        )
-    }
-}
-
 // Systems and TestResource are used in tests
 #[allow(dead_code)]
 #[cfg(test)]
diff --git a/crates/bevy_utils/src/lib.rs b/crates/bevy_utils/src/lib.rs
index f6b3f56ce4996..c336b026d843f 100644
--- a/crates/bevy_utils/src/lib.rs
+++ b/crates/bevy_utils/src/lib.rs
@@ -7,12 +7,14 @@ pub mod label;
 
 mod default;
 mod enum_variant_meta;
+mod short_name;
 
 pub use ahash::AHasher;
 pub use default::default;
 pub use enum_variant_meta::*;
 pub use hashbrown;
 pub use instant::{Duration, Instant};
+pub use short_name::*;
 pub use tracing;
 pub use uuid::Uuid;
 
diff --git a/crates/bevy_utils/src/short_name.rs b/crates/bevy_utils/src/short_name.rs
new file mode 100644
index 0000000000000..7e93c4be25cc3
--- /dev/null
+++ b/crates/bevy_utils/src/short_name.rs
@@ -0,0 +1,85 @@
+/// Collapses a name returned by [`std::any::type_name`] to remove its module path
+pub fn get_short_name(raw_name: &str) -> String {
+    // Generics result in nested paths within <..> blocks
+    // Consider "bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"
+    // To tackle this, we parse the string from left to right, collapsing as we go
+    let mut index: usize = 0;
+    let end_of_string = raw_name.len();
+    let mut parsed_name = String::new();
+
+    while index < end_of_string {
+        let rest_of_string = raw_name.get(index..end_of_string).unwrap_or_default();
+
+        // Collapse everything up to the next special character,
+        // then skip over it
+        if let Some(special_character_index) =
+            rest_of_string.find(|c: char| (c == '<') || (c == ',') || (c == ' ') || (c == '>'))
+        {
+            let segment_to_collapse = rest_of_string
+                .get(0..special_character_index)
+                .unwrap_or_default();
+            parsed_name += collapse_type_name(segment_to_collapse);
+            // Insert the special character
+            let special_character =
+                &rest_of_string[special_character_index..=special_character_index];
+            parsed_name.push_str(special_character);
+            // Move the index just past the special character
+            index += special_character_index + 1;
+        } else {
+            // If there are no special characters left, we're done!
+            parsed_name += collapse_type_name(rest_of_string);
+            index = end_of_string;
+        }
+    }
+
+    parsed_name
+}
+
+#[inline(always)]
+fn collapse_type_name(string: &str) -> &str {
+    string.split("::").last().unwrap()
+}
+
+#[cfg(test)]
+mod name_formatting_tests {
+    use super::get_short_name;
+
+    #[test]
+    fn trivial() {
+        assert_eq!(get_short_name("test_system"), "test_system")
+    }
+
+    #[test]
+    fn path_seperated() {
+        assert_eq!(
+            get_short_name("bevy_prelude::make_fun_game"),
+            "make_fun_game".to_string()
+        )
+    }
+
+    #[test]
+    fn trivial_generics() {
+        assert_eq!(get_short_name("a<B>"), "a<B>".to_string())
+    }
+
+    #[test]
+    fn multiple_type_parameters() {
+        assert_eq!(get_short_name("a<B, C>"), "a<B, C>".to_string())
+    }
+
+    #[test]
+    fn generics() {
+        assert_eq!(
+            get_short_name("bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"),
+            "extract_cameras<Camera3d>".to_string()
+        )
+    }
+
+    #[test]
+    fn nested_generics() {
+        assert_eq!(
+            get_short_name("bevy::mad_science::do_mad_science<mad_science::Test<mad_science::Tube>, bavy::TypeSystemAbuse>"),
+            "do_mad_science<Test<Tube>, TypeSystemAbuse>".to_string()
+        )
+    }
+}

From 77d5c33808b007534ffe01757e6f460b4f514016 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 16:55:42 -0400
Subject: [PATCH 102/113] Reuse get_short_name function

---
 crates/bevy_reflect/src/type_registry.rs | 37 ++----------------------
 crates/bevy_utils/src/short_name.rs      | 10 +++----
 2 files changed, 7 insertions(+), 40 deletions(-)

diff --git a/crates/bevy_reflect/src/type_registry.rs b/crates/bevy_reflect/src/type_registry.rs
index a6aa64f487305..ecdb35411031a 100644
--- a/crates/bevy_reflect/src/type_registry.rs
+++ b/crates/bevy_reflect/src/type_registry.rs
@@ -1,5 +1,5 @@
 use crate::Reflect;
-use bevy_utils::{HashMap, HashSet};
+use bevy_utils::{get_short_name, HashMap, HashSet};
 use downcast_rs::{impl_downcast, Downcast};
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use serde::Deserialize;
@@ -236,40 +236,7 @@ impl TypeRegistration {
     /// example, the short name of `alloc::vec::Vec<core::option::Option<u32>>`
     /// would be `Vec<Option<u32>>`.
     pub fn get_short_name(full_name: &str) -> String {
-        let mut short_name = String::new();
-
-        {
-            // A typename may be a composition of several other type names (e.g. generic parameters)
-            // separated by the characters that we try to find below.
-            // Then, each individual typename is shortened to its last path component.
-            //
-            // Note: Instead of `find`, `split_inclusive` would be nice but it's still unstable...
-            let mut remainder = full_name;
-            while let Some(index) = remainder.find(&['<', '>', '(', ')', '[', ']', ',', ';'][..]) {
-                let (path, new_remainder) = remainder.split_at(index);
-                // Push the shortened path in front of the found character
-                short_name.push_str(path.rsplit(':').next().unwrap());
-                // Push the character that was found
-                let character = new_remainder.chars().next().unwrap();
-                short_name.push(character);
-                // Advance the remainder
-                if character == ',' || character == ';' {
-                    // A comma or semicolon is always followed by a space
-                    short_name.push(' ');
-                    remainder = &new_remainder[2..];
-                } else {
-                    remainder = &new_remainder[1..];
-                }
-            }
-
-            // The remainder will only be non-empty if there were no matches at all
-            if !remainder.is_empty() {
-                // Then, the full typename is a path that has to be shortened
-                short_name.push_str(remainder.rsplit(':').next().unwrap());
-            }
-        }
-
-        short_name
+        get_short_name(full_name)
     }
 }
 
diff --git a/crates/bevy_utils/src/short_name.rs b/crates/bevy_utils/src/short_name.rs
index 7e93c4be25cc3..317589c5fdddf 100644
--- a/crates/bevy_utils/src/short_name.rs
+++ b/crates/bevy_utils/src/short_name.rs
@@ -1,19 +1,19 @@
 /// Collapses a name returned by [`std::any::type_name`] to remove its module path
-pub fn get_short_name(raw_name: &str) -> String {
+pub fn get_short_name(full_name: &str) -> String {
     // Generics result in nested paths within <..> blocks
     // Consider "bevy_render::camera::camera::extract_cameras<bevy_render::camera::bundle::Camera3d>"
     // To tackle this, we parse the string from left to right, collapsing as we go
     let mut index: usize = 0;
-    let end_of_string = raw_name.len();
+    let end_of_string = full_name.len();
     let mut parsed_name = String::new();
 
     while index < end_of_string {
-        let rest_of_string = raw_name.get(index..end_of_string).unwrap_or_default();
+        let rest_of_string = full_name.get(index..end_of_string).unwrap_or_default();
 
         // Collapse everything up to the next special character,
         // then skip over it
-        if let Some(special_character_index) =
-            rest_of_string.find(|c: char| (c == '<') || (c == ',') || (c == ' ') || (c == '>'))
+        if let Some(special_character_index) = rest_of_string
+            .find(|c: char| (c == '<') || (c == ',') || (c == ' ') || (c == '>') || (c == ';'))
         {
             let segment_to_collapse = rest_of_string
                 .get(0..special_character_index)

From 81b3065068673c451ef21841a02464ff36b3b294 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 17:14:09 -0400
Subject: [PATCH 103/113] Handle more edge cases in get_short_name

---
 crates/bevy_utils/src/short_name.rs | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_utils/src/short_name.rs b/crates/bevy_utils/src/short_name.rs
index 317589c5fdddf..7ef7d31a3da3e 100644
--- a/crates/bevy_utils/src/short_name.rs
+++ b/crates/bevy_utils/src/short_name.rs
@@ -12,9 +12,17 @@ pub fn get_short_name(full_name: &str) -> String {
 
         // Collapse everything up to the next special character,
         // then skip over it
-        if let Some(special_character_index) = rest_of_string
-            .find(|c: char| (c == '<') || (c == ',') || (c == ' ') || (c == '>') || (c == ';'))
-        {
+        if let Some(special_character_index) = rest_of_string.find(|c: char| {
+            (c == ' ')
+                || (c == '<')
+                || (c == '>')
+                || (c == '(')
+                || (c == ')')
+                || (c == '[')
+                || (c == ']')
+                || (c == ',')
+                || (c == ';')
+        }) {
             let segment_to_collapse = rest_of_string
                 .get(0..special_character_index)
                 .unwrap_or_default();
@@ -57,6 +65,19 @@ mod name_formatting_tests {
         )
     }
 
+    #[test]
+    fn tuple_type() {
+        assert_eq!(
+            get_short_name("(String, String)"),
+            "(String, String)".to_string()
+        )
+    }
+
+    #[test]
+    fn array_type() {
+        assert_eq!(get_short_name("[i32; 3]"), "[i32; 3]".to_string())
+    }
+
     #[test]
     fn trivial_generics() {
         assert_eq!(get_short_name("a<B>"), "a<B>".to_string())

From d102ffe54d466baa5246978d1f9a3ab8d3049275 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 18:00:43 -0400
Subject: [PATCH 104/113] Re-enable commented out test

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

diff --git a/crates/bevy_reflect/src/type_registry.rs b/crates/bevy_reflect/src/type_registry.rs
index ecdb35411031a..2beea23b52d50 100644
--- a/crates/bevy_reflect/src/type_registry.rs
+++ b/crates/bevy_reflect/src/type_registry.rs
@@ -322,42 +322,6 @@ mod test {
     use crate::TypeRegistration;
     use bevy_utils::HashMap;
 
-    #[test]
-    fn test_get_short_name() {
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<f64>()),
-            "f64"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<String>()),
-            "String"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<(u32, f64)>()),
-            "(u32, f64)"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<(String, String)>()),
-            "(String, String)"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<[f64]>()),
-            "[f64]"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<[String]>()),
-            "[String]"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<[f64; 16]>()),
-            "[f64; 16]"
-        );
-        assert_eq!(
-            TypeRegistration::get_short_name(std::any::type_name::<[String; 16]>()),
-            "[String; 16]"
-        );
-    }
-
     #[test]
     fn test_property_type_registration() {
         assert_eq!(

From 19e8d5fc1e4ab5f77f34baded2e1649f570bdadb Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 18:07:58 -0400
Subject: [PATCH 105/113] Use ignore syntax

---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index d155fffbe10bd..f7715080ea92d 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -600,9 +600,7 @@ mod tests {
     }
 
     #[test]
-    // Known failing: this should work but doesn't, as we're not looking at filtered access
-    // See https://github.com/bevyengine/bevy/issues/4381
-    #[ignore]
+    #[ignore = "Known failing but fix is non-trivial: https://github.com/bevyengine/bevy/issues/4381"]
     fn filtered_components() {
         let mut world = World::new();
         let mut test_stage = SystemStage::parallel();

From d705c3bcd1a907696f989147313d62e69fa945db Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 4 Apr 2022 18:25:02 -0400
Subject: [PATCH 106/113] Move derives below docs

Co-authored-by: MinerSebas <66798382+MinerSebas@users.noreply.github.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index f7715080ea92d..33033f92c7712 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -7,7 +7,6 @@ use bevy_utils::tracing::{error, warn};
 use fixedbitset::FixedBitSet;
 use std::hash::Hash;
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 /// Systems that access the same Component or Resource within the same stage
 /// risk an ambiguous order that could result in logic bugs, unless they have an
 /// explicit execution ordering constraint between them.
@@ -30,6 +29,7 @@ use std::hash::Hash;
 /// rather than blindly resolving one warning at a time.
 ///
 /// By default, the value of this resource is set to `Warn`.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum ExecutionOrderAmbiguities {
     /// Disables all checks for execution order ambiguities
     Allow,

From 2f8c36bc2a36515eed0d48c5dd855b138b5e8211 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 10 Apr 2022 21:13:51 -0400
Subject: [PATCH 107/113] Remove TODO

Co-authored-by: Joy <51241057+maniwani@users.noreply.github.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 33033f92c7712..33b3829ead3de 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -249,9 +249,7 @@ pub fn find_ambiguities(
     let full_bitset: FixedBitSet = (0..systems.len()).collect();
     let mut processed = FixedBitSet::with_capacity(systems.len());
     for (index_a, relations) in all_relations.drain(..).enumerate() {
-        // TODO: prove that `.take(index_a)` would be correct here, and uncomment it if so.
         for index_b in full_bitset.difference(&relations)
-        // .take(index_a)
         {
             if !processed.contains(index_b)
                 && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter, report_level)

From efaad59b3dfaae735c7aec34e92ca55fa6c9298b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 10 Apr 2022 21:15:34 -0400
Subject: [PATCH 108/113] Wording suggestions

Co-authored-by: Joy <51241057+maniwani@users.noreply.github.com>
---
 .../src/schedule/system_descriptor.rs         |  2 +-
 examples/ecs/ambiguity_checker.rs             | 22 +++++++++----------
 examples/tools/internal_ambiguities.rs        |  2 +-
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index c3dc1b6d51d37..60e2ef1475115 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -93,7 +93,7 @@ impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
     }
 }
 
-/// Whether or not system order ambiguities should be reported for this specific system
+/// Determines whether or not execution order ambiguities involving a given system are reported or ignored.
 ///
 /// See the methods on [`ParallelSystemDescriptor`] to set this for a given system.
 ///
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
index 287305612825d..1bdd06dc57ddd 100644
--- a/examples/ecs/ambiguity_checker.rs
+++ b/examples/ecs/ambiguity_checker.rs
@@ -3,9 +3,9 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
-        // By default only a warning with the number of unresolved ambiguities is shown, but
-        // a more complete report will be displayed if we explicitly set this resource to verbose.
+        // This resource controls how an app handles pairs of systems that have incompatible access but ambiguous execution order.
+        // The default behavior logs a warning with just the number of ambiguous pairs. Setting the resource to "verbose" 
+        // will report these pairs in more detail.
         .insert_resource(ExecutionOrderAmbiguities::WarnVerbose)
         .insert_resource(MyStartupResource(0))
         // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
@@ -15,16 +15,14 @@ fn main() {
         .add_startup_system(startup_system_b)
         .insert_resource(MyResource(0))
         .insert_resource(MyOtherResource(0))
-        // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
-        .add_system(system_a.ignore_all_ambiguities())
-        .add_system(system_b)
-        // It is also possible to mark a system as deliberately ambiguous with a provided system or label,
-        // making the checker ignore any ambiguities between them.
-        .add_system(system_c.ambiguous_with(system_b))
-        // If there's an whole group of systems that are supposed to be ambiguous with each other,
-        // add a shared label, and then ignore any conflicts with that label.
+        .add_system(system_a)
+        // It's possible to tell the ambiguity checker to ignore conflicts between a specific pair of systems.
+        .add_system(system_b.ambiguous_with(system_a))
+        // Likewise, between a system and other systems that have a certain label.
+        .add_system(system_c.label(AmbiguitySet).ambiguous_with(AmbiguitySet))
         .add_system(system_d.label(AmbiguitySet).ambiguous_with(AmbiguitySet))
-        .add_system(system_e.label(AmbiguitySet).ambiguous_with(AmbiguitySet))
+        // Lastly, if desired, the checker can be told to ignore any conflicts that involve a particular system.
+        .add_system(system_e.ignore_all_ambiguities())
         .run();
 }
 
diff --git a/examples/tools/internal_ambiguities.rs b/examples/tools/internal_ambiguities.rs
index 8144a1b52590f..15386a236c3a8 100644
--- a/examples/tools/internal_ambiguities.rs
+++ b/examples/tools/internal_ambiguities.rs
@@ -1,4 +1,4 @@
-//! Reports any Bevy-internal system-order ambiguities
+//! Reports execution-order ambiguities involving internal Bevy systems.
 //! This is primarily useful for engine development
 
 use bevy::prelude::*;

From 7d66097510fac5a24f96b92a05f5b8fc6aa1af3b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 10 Apr 2022 21:17:29 -0400
Subject: [PATCH 109/113] More wording suggestions

Co-authored-by: Joy <51241057+maniwani@users.noreply.github.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 33b3829ead3de..fc0bec8f3943e 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -7,12 +7,11 @@ use bevy_utils::tracing::{error, warn};
 use fixedbitset::FixedBitSet;
 use std::hash::Hash;
 
-/// Systems that access the same Component or Resource within the same stage
-/// risk an ambiguous order that could result in logic bugs, unless they have an
-/// explicit execution ordering constraint between them.
+/// Within a stage, writes to a component or resource (and reads relative to writes) should typically have a well-defined order.
 ///
-/// This occurs because, in the absence of explicit constraints, systems are executed in
-/// an unstable, arbitrary order within each stage that may vary between runs and frames.
+/// Ambiguous order between systems that have conflicting access can result in subtle logic bugs since,
+/// in the absence of constraints, systems are executed in an arbitrary order and that can change between runs
+/// and even frames.
 ///
 /// Some ambiguities reported by the ambiguity checker may be warranted (to allow two systems to run
 /// without blocking each other) or spurious, as the exact combination of archetypes used may
@@ -53,7 +52,7 @@ pub enum ExecutionOrderAmbiguities {
     Forbid,
 }
 
-/// A pair of systems that can run in an ambiguous order
+/// A pair of systems that have conflicting access and an ambiguous execution order.
 ///
 /// Created by applying [`find_ambiguities`] to a [`SystemContainer`].
 /// These can be reported by configuring the [`ExecutionOrderAmbiguities`] resource.
@@ -449,7 +448,7 @@ impl SystemStage {
                 || report_level == ExecutionOrderAmbiguities::Forbid
             {
                 error!("{warning_string}");
-                panic!("`ExecutionOrderAmbiguities` is set to `{report_level:?}`, which forbids the `App` from running if any unresolved system order ambiguities exist.")
+                panic!("`ExecutionOrderAmbiguities` is set to `{report_level:?}`, which forbids the `App` from running if any two systems with incompatible data access have ambiguous execution order (unless permitted).")
             } else {
                 warn!("{warning_string}");
             }

From 5671675b5f8a1214503c7453681b2a92fddd0fce Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 10 Apr 2022 21:18:06 -0400
Subject: [PATCH 110/113] Deterministic, not lockstep

Co-authored-by: Joy <51241057+maniwani@users.noreply.github.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index fc0bec8f3943e..9b3033d492ca4 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -48,7 +48,7 @@ pub enum ExecutionOrderAmbiguities {
     /// Panics if any ambiguities exist.
     ///
     /// This will be very noisy, but can be useful when attempting to track down subtle determinism issues,
-    /// as you might need when attempting to implement lockstep networking.
+    /// as you might need when attempting to implement deterministic networking.
     Forbid,
 }
 

From 57fb76d31f1b50143b55939367a1322b8b75e309 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 20 Apr 2022 18:09:33 -0400
Subject: [PATCH 111/113] Fix outdated error message

Co-authored-by: Rob Parrett <robparrett@gmail.com>
---
 crates/bevy_ecs/src/schedule/ambiguity_detection.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 9b3033d492ca4..085c604e6de33 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -420,7 +420,7 @@ impl SystemStage {
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
 
             if report_level == ExecutionOrderAmbiguities::Warn {
-                warning_string += "Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::WarnVerbose` for more details.";
+                warning_string += "Set the level of the `ExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::WarnVerbose` for more details.";
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
                     let ambiguity_number = i + 1;

From bddee995868b11292a91b593de7b77f4be2f4857 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 22 Apr 2022 17:28:03 -0400
Subject: [PATCH 112/113] Fix rebase

---
 crates/bevy_ecs/src/lib.rs            | 4 ++--
 crates/bevy_ecs/src/schedule/stage.rs | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index d182a281afac5..d5f43a9252814 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -30,8 +30,8 @@ pub mod prelude {
         schedule::{
             AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ExecutionOrderAmbiguities,
             ParallelSystemDescriptorCoercion, RunCriteria, RunCriteriaDescriptorCoercion,
-            RunCriteriaLabel, RunCriteriaPiping, Schedule, Stage, StageLabel, State, SystemLabel,
-            SystemSet, SystemStage,
+            RunCriteriaLabel, Schedule, Stage, StageLabel, State, SystemLabel, SystemSet,
+            SystemStage,
         },
         system::{
             Commands, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend,
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 0a9d921c7bb2a..ea98511e95fbf 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -783,9 +783,9 @@ mod tests {
         entity::Entity,
         query::{ChangeTrackers, Changed},
         schedule::{
-            BoxedSystemLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            RunCriteria, RunCriteriaDescriptorCoercion, ShouldRun, SingleThreadedExecutor, Stage,
-            SystemSet, SystemStage,
+            ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion, RunCriteria,
+            RunCriteriaDescriptorCoercion, ShouldRun, SingleThreadedExecutor, Stage, SystemSet,
+            SystemStage,
         },
         system::{In, IntoExclusiveSystem, Local, Query, ResMut},
         world::World,

From 733fbafaf7d6e26d5ac65a353adf75ea06182860 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 22 Apr 2022 17:28:34 -0400
Subject: [PATCH 113/113] Ignore newly introduced internal ambiguities T_T

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

diff --git a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
index 085c604e6de33..cd9f14bac01c7 100644
--- a/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
+++ b/crates/bevy_ecs/src/schedule/ambiguity_detection.rs
@@ -248,8 +248,7 @@ pub fn find_ambiguities(
     let full_bitset: FixedBitSet = (0..systems.len()).collect();
     let mut processed = FixedBitSet::with_capacity(systems.len());
     for (index_a, relations) in all_relations.drain(..).enumerate() {
-        for index_b in full_bitset.difference(&relations)
-        {
+        for index_b in full_bitset.difference(&relations) {
             if !processed.contains(index_b)
                 && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter, report_level)
             {
@@ -314,6 +313,7 @@ impl SystemStage {
                 "bevy_core_pipeline".to_string(),
                 "bevy_ui".to_string(),
                 "bevy_hierarchy".to_string(),
+                "bevy_animation".to_string(),
                 // Misc
                 "bevy_winit".to_string(),
                 "bevy_audio".to_string(),
@@ -420,7 +420,7 @@ impl SystemStage {
 				You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
 
             if report_level == ExecutionOrderAmbiguities::Warn {
-                warning_string += "Set the level of the `ExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::WarnVerbose` for more details.";
+                warning_string += "Set the level of the `ExecutionOrderAmbiguities` resource to `ExecutionOrderAmbiguities::WarnVerbose` for more details.";
             } else {
                 for (i, ambiguity) in ambiguities.iter().enumerate() {
                     let ambiguity_number = i + 1;