From a6b0da2afb11eebd8ab656cb4aebd49092a6c88f 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 01/42] 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 9d5dda4bdf385..b071374467838 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -478,11 +478,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()
                 )
@@ -509,30 +512,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 735abc5e09fc5747305ad237cecd1a0f00aa8421 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 02/42] 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 b071374467838..7f2f7c7d8d6cf 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -485,7 +485,7 @@ impl SystemStage {
                     string,
                     "{}.{} - {:?} and {:?}",
                     output_prefix,
-                    idx, 
+                    idx,
                     systems[index_a].name(),
                     systems[index_b].name()
                 )
@@ -537,7 +537,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 889dd59957f4b493ba3ee297ae70b703171302ca 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 03/42] 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 7f2f7c7d8d6cf..f9feae630f5b4 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -483,7 +483,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(),
@@ -495,7 +495,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 b1d49ca12813fbf63e97fd3f7eeb5142288b1e3c 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 04/42] 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 f9feae630f5b4..72f19a0855d1e 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -522,7 +522,7 @@ impl SystemStage {
                     &self.exclusive_at_start,
                     at_start,
                     world,
-                    "1",
+                    "2",
                 );
             }
             if !before_commands.is_empty() {
@@ -532,7 +532,7 @@ impl SystemStage {
                     &self.exclusive_before_commands,
                     before_commands,
                     world,
-                    "1",
+                    "3",
                 );
             }
             if !at_end.is_empty() {
@@ -542,7 +542,7 @@ impl SystemStage {
                     &self.exclusive_at_end,
                     at_end,
                     world,
-                    "1",
+                    "4",
                 );
             }
             info!("{}", string);

From 1083583b20a9dd75b5f03ba8a79364194f4e9bce 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 05/42] 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 72f19a0855d1e..c405d24e207c3 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -480,23 +480,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 cd439afbe54efe6a2927e3d2cbdf7cede0a37225 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 06/42] 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 c405d24e207c3..41975aaa6c5fb 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};
 
 pub trait Stage: Downcast + Send + Sync {
     /// Runs the stage; this happens once per update.
@@ -743,6 +743,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])
             {
@@ -1953,6 +1963,32 @@ mod tests {
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_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 68e493da714b5..6ca8c7cf4296e 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, cell::UnsafeCell};
 
+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 {}
@@ -133,6 +143,7 @@ impl ParallelSystemContainer {
             before: descriptor.before,
             after: descriptor.after,
             ambiguity_sets: descriptor.ambiguity_sets,
+            ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
 
@@ -214,4 +225,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 74a3963ca26d7..153282a68a0f3 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -90,6 +90,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<(), ()>,
@@ -98,6 +103,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 {
@@ -108,6 +114,7 @@ fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescrip
         before: Vec::new(),
         after: Vec::new(),
         ambiguity_sets: Vec::new(),
+        ambiguity_detection: AmbiguityDetection::Check,
     }
 }
 
@@ -131,6 +138,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 {
@@ -161,6 +171,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
@@ -189,6 +204,10 @@ where
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
         new_parallel_descriptor(Box::new(self.system())).in_ambiguity_set(set)
     }
+
+    fn ambiguous(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(self.system())).ambiguous()
+    }
 }
 
 impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
@@ -214,6 +233,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)]
@@ -231,6 +254,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,
 }
 
@@ -242,6 +266,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,
     }
 }
@@ -276,6 +301,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 {
@@ -321,6 +349,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
@@ -361,4 +394,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 362b804082d767bdc4499af57bb31a3f5e4276af 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 07/42] 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 41975aaa6c5fb..fefcd37007877 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -691,6 +691,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();
@@ -743,18 +763,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();
@@ -1989,6 +2000,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 153282a68a0f3..efa1cb5427cac 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -93,6 +93,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`.
@@ -141,6 +142,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 {
@@ -176,6 +181,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
@@ -208,6 +226,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<(), ()> {
@@ -237,6 +259,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)]
@@ -304,6 +330,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 {
@@ -354,6 +384,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
@@ -398,4 +441,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 1e7030541e3fe9918f72f837991ed21593eed9d6 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 08/42] 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 fefcd37007877..70caa78d9a8fb 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;
@@ -26,6 +26,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.
@@ -45,7 +52,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.
@@ -470,7 +509,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(
@@ -518,10 +566,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"
@@ -801,9 +860,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 fa8f71e4f05768dbe632c157d41e5fffd3ba8de2 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 09/42] 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 70caa78d9a8fb..5772f164add59 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 77cf9e915099a6b176e05e49048d5c612c641433 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 10/42] 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 ae51cb6b3d49a..b5c552cb3a89b 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -343,7 +343,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 9c8719b501e7daf6103bf3ba16e0d05333b291c2 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 11/42] 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 5772f164add59..1dd396110daa8 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -30,7 +30,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,
@@ -56,7 +56,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 {
@@ -64,6 +65,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn off() -> Self {
         Self {
             level: AmbiguityReportLevel::Off,
+            ignore_crates: vec![],
         }
     }
 
@@ -72,6 +74,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn minimal() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,
+            ignore_crates: vec![],
         }
     }
 
@@ -79,8 +82,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 {
@@ -513,12 +524,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;
         }
 
@@ -565,10 +574,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();
@@ -583,7 +596,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"
@@ -752,25 +765,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();
@@ -827,7 +849,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();
@@ -1666,7 +1688,24 @@ mod tests {
         fn find_ambiguities_first_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)| {
                     (
@@ -1681,6 +1720,10 @@ mod tests {
         fn resource(_: ResMut<usize>) {}
         fn component(_: Query<&mut f32>) {}
 
+        mod inner {
+            pub(super) fn inner_fn(_: super::ResMut<usize>) {}
+        }
+
         let mut world = World::new();
 
         let mut stage = SystemStage::parallel()
@@ -1691,7 +1734,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"))
@@ -1731,7 +1774,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"))
@@ -1957,7 +2000,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"))
@@ -2098,6 +2141,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 7c246897ee16b1e07832836fae383d224db6fc56 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 12/42] 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 1dd396110daa8..5ba08fea7ceee 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -65,7 +65,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn off() -> Self {
         Self {
             level: AmbiguityReportLevel::Off,
-            ignore_crates: vec![],
+            ..Default::default()
         }
     }
 
@@ -74,7 +74,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn minimal() -> Self {
         Self {
             level: AmbiguityReportLevel::Minimal,
-            ignore_crates: vec![],
+            ..Default::default()
         }
     }
 
@@ -82,7 +82,7 @@ impl ReportExecutionOrderAmbiguities {
     pub fn verbose() -> Self {
         Self {
             level: AmbiguityReportLevel::Verbose,
-            ignore_crates: vec![],
+            ..Default::default()
         }
     }
 
@@ -96,7 +96,10 @@ impl ReportExecutionOrderAmbiguities {
 
 impl Default for ReportExecutionOrderAmbiguities {
     fn default() -> Self {
-        Self::minimal()
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+            ignore_crates: vec!["bevy_".into()],
+        }
     }
 }
 

From b013b9e7531b0919154659b94bed342c3b64181f 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 13/42] 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 5ba08fea7ceee..143493746eaf8 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -592,7 +592,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 c20907ed7002a75366eddf70878dcb19b38ceb35 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 14/42] 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 143493746eaf8..13ad15c5c787b 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -36,10 +36,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.
@@ -50,11 +46,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>,
@@ -69,8 +82,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 b08aee65fc8c3d1c8d04b0501805adaca5bec740 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 15/42] 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 0fafd91be7970..4c7c1fbc7dc42 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -258,6 +258,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 e9c787dc308b9cd7f8475a991d4a5d6498f2e01b 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 16/42] 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 13ad15c5c787b..b4cafa65c581f 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -46,7 +46,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 34b2f0e7e52591b4cd477043c7fc6715e74008bc 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 17/42] 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 7796afdb16223..95c9655bb9d86 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -155,6 +155,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
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception

From 9a7f436f44a29ae678a0bfaaa070474027f05c9a 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 18/42] 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 b4cafa65c581f..b9797b70e80ac 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -62,9 +62,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 652b960f0623d51731610a2d9aaeb00806bf0cd7 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 19/42] 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 1967b7b79c3d9f62b23afc439d3089ea8fc17f95 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 20/42] 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 95c9655bb9d86..769c6404c9ae6 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -155,8 +155,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
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception
 `fixed_timestep` | [`ecs/fixed_timestep.rs`](./ecs/fixed_timestep.rs) | Shows how to create systems that run every fixed timestep, rather than every tick

From ab5dd30af37f4f955af3fe0ff0768f507f903272 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 21/42] 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 769c6404c9ae6..e484525f92a59 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -156,7 +156,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
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception
 `fixed_timestep` | [`ecs/fixed_timestep.rs`](./ecs/fixed_timestep.rs) | Shows how to create systems that run every fixed timestep, rather than every tick

From c3d094483b1c1a75224e6deb2a75bd9c2c724540 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 22/42] 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 b9797b70e80ac..69fddd0268be1 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -53,8 +53,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 efa1cb5427cac..e704c5a675179 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -140,11 +140,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;
 }
 
@@ -328,11 +328,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 b9d9d666a0a34cd3d6ec5f62c27fe721d2c36288 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 23/42] 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 69fddd0268be1..b0fb8415f7cee 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -104,6 +104,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 a2449a585bc63ab028015e41c5c3a684fd1aa51a 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 24/42] 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 b0fb8415f7cee..104fb059c8f9d 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -98,6 +98,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 133c73208e601696972c08a4342b4d7d5f3ead6c 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 25/42] 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 104fb059c8f9d..fa64e00517572 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -2102,7 +2102,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"));
@@ -2116,8 +2116,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"));
@@ -2128,11 +2128,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 e704c5a675179..902d5fc0d4ac8 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -141,7 +141,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.
@@ -177,7 +177,7 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self
     }
 
-    fn ambiguous(mut self) -> ParallelSystemDescriptor {
+    fn silence_ambiguity_checks(mut self) -> ParallelSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
@@ -223,8 +223,8 @@ where
         new_parallel_descriptor(Box::new(self.system())).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 {
@@ -256,8 +256,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 {
@@ -329,7 +329,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.
@@ -380,7 +380,7 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self
     }
 
-    fn ambiguous(mut self) -> ExclusiveSystemDescriptor {
+    fn silence_ambiguity_checks(mut self) -> ExclusiveSystemDescriptor {
         self.ambiguity_detection = AmbiguityDetection::Ignore;
         self
     }
@@ -438,8 +438,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 4c9f85730575c4809a4aea3749082ed87ea88287 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 26/42] 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 fa64e00517572..0a6c9c9f2be2c 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -611,7 +611,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 c218faa21008ffc0e9bbf51cb0e7b84ffc6d03b6 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 27/42] 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 0a6c9c9f2be2c..d1d35532c13cc 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -590,7 +590,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 23a1e58f72b9c0844fc6825676f2d5cd9468161d 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 28/42] 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 0a6c9c9f2be2c..d8c93fb706a77 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -617,7 +617,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 70e693347855531a569bc2c5f9d27b49de6d834b 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 29/42] 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 d8c93fb706a77..5d5eb1835660a 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -73,6 +73,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 {
@@ -108,7 +221,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
     }
 }
@@ -117,7 +231,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 b934d93d08547ee69e02f3aa4fed37697a699877 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 30/42] 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 5d5eb1835660a..72fa7c6314c71 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -935,9 +935,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 f6cb41771d59e79c55eb6d10b26ea199de9a0d88 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 31/42] 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 929a990b37bee..f92c1f0338050 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -2310,7 +2310,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 426d448c79c4d774c6307dbb343821168d38f642 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 32/42] 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 929a990b37bee..9b0b243771d95 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -58,8 +58,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 47432fa50395afb191b19b27c41f9af96b4043ca 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 33/42] 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 12714b48ac4d7..27bc51c8419f1 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -58,7 +58,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 1252fc65bcff4a8656e62652f9fa43efc7a6a9e9 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 34/42] 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 27bc51c8419f1..3ad561e2c1204 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -120,7 +120,6 @@ const BEVY_CRATES: [&str; 110] = [
     "bevy_curve",
     "bevy_demo",
     "bevy_editor",
-    "bevy_egui",
     "bevy_event",
     "bevy_executor",
     "bevy_extra",

From b8274bc1d528e0fe1e1d683bc31ad71e4156e3f5 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 35/42] 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 3ad561e2c1204..6b3effb333d64 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -74,7 +74,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 889a263f09835e8faecf75805e0f05256cf133ba 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 36/42] 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 f1f4a66e5bbe3..de31a4d1081b3 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 ee43fd472e141a48d2b5488d5239d3f9d5f21a63 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 37/42] 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 6b3effb333d64..c3f06ec0e4205 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -212,8 +212,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 0dbb9c4e01209cd71ab65e2fef016fd8e29dc4d3 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 38/42] 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 c3f06ec0e4205..ae9bea3e26be4 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -74,118 +74,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 {
@@ -211,18 +99,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
     }
 }
@@ -231,7 +118,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 76b35420ccf7cda530b0a8faf754e445e47ea714 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 39/42] 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    |  7 ++++-
 crates/bevy_sprite/src/lib.rs    | 49 +++++++++++++++++++-------------
 crates/bevy_text/src/lib.rs      |  7 ++++-
 crates/bevy_transform/src/lib.rs |  9 +++++-
 crates/bevy_ui/src/lib.rs        |  9 +++++-
 crates/bevy_winit/src/lib.rs     |  9 +++++-
 7 files changed, 72 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 5f44d68f9f40b..2ddbecafaea59 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -13,7 +13,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::system::IntoExclusiveSystem;
+use bevy_ecs::{schedule::ReportExecutionOrderAmbiguities, system::IntoExclusiveSystem};
 
 /// Adds support for audio playback to an App
 #[derive(Default)]
@@ -31,5 +31,10 @@ impl Plugin for AudioPlugin {
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
         app.init_asset_loader::<Mp3Loader>();
+
+        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 e26be98280c1c..2d23bfcc1d3e4 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -13,7 +13,7 @@ pub mod texture;
 pub mod wireframe;
 
 use bevy_ecs::{
-    schedule::{ParallelSystemDescriptorCoercion, SystemStage},
+    schedule::{ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemStage},
     system::{IntoExclusiveSystem, Res},
 };
 use bevy_transform::TransformSystem;
@@ -218,6 +218,11 @@ impl Plugin for RenderPlugin {
                 active_cameras.add(base::camera::CAMERA_2D);
             }
         }
+
+        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 4dfdb7884979d..04523a844748c 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -28,7 +28,10 @@ pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::component::{ComponentDescriptor, StorageType};
+use bevy_ecs::{
+    component::{ComponentDescriptor, StorageType},
+    schedule::ReportExecutionOrderAmbiguities,
+};
 use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
@@ -96,24 +99,32 @@ impl Plugin for SpritePlugin {
             ))
             .unwrap();
 
-        let world_cell = app.world.cell();
-        let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
-        let mut pipelines = world_cell
-            .get_resource_mut::<Assets<PipelineDescriptor>>()
-            .unwrap();
-        let mut shaders = world_cell.get_resource_mut::<Assets<Shader>>().unwrap();
-        crate::render::add_sprite_graph(&mut render_graph, &mut pipelines, &mut shaders);
+        {
+            let world_cell = app.world.cell();
+            let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
+            let mut pipelines = world_cell
+                .get_resource_mut::<Assets<PipelineDescriptor>>()
+                .unwrap();
+            let mut shaders = world_cell.get_resource_mut::<Assets<Shader>>().unwrap();
+            crate::render::add_sprite_graph(&mut render_graph, &mut pipelines, &mut shaders);
 
-        let mut meshes = world_cell.get_resource_mut::<Assets<Mesh>>().unwrap();
-        let mut color_materials = world_cell
-            .get_resource_mut::<Assets<ColorMaterial>>()
-            .unwrap();
-        color_materials.set_untracked(Handle::<ColorMaterial>::default(), ColorMaterial::default());
-        meshes.set_untracked(
-            QUAD_HANDLE,
-            // Use a flipped quad because the camera is facing "forward" but quads should face
-            // backward
-            Mesh::from(shape::Quad::new(Vec2::new(1.0, 1.0))),
-        )
+            let mut meshes = world_cell.get_resource_mut::<Assets<Mesh>>().unwrap();
+            let mut color_materials = world_cell
+                .get_resource_mut::<Assets<ColorMaterial>>()
+                .unwrap();
+            color_materials
+                .set_untracked(Handle::<ColorMaterial>::default(), ColorMaterial::default());
+            meshes.set_untracked(
+                QUAD_HANDLE,
+                // Use a flipped quad because the camera is facing "forward" but quads should face
+                // backward
+                Mesh::from(shape::Quad::new(Vec2::new(1.0, 1.0))),
+            );
+        }
+
+        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 ce91d4a2e8ba3..759e5cd0633b3 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -29,7 +29,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::entity::Entity;
+use bevy_ecs::{entity::Entity, schedule::ReportExecutionOrderAmbiguities};
 use bevy_render::RenderStage;
 
 pub type DefaultTextPipeline = TextPipeline<Entity>;
@@ -45,5 +45,10 @@ impl Plugin for TextPlugin {
             .insert_resource(DefaultTextPipeline::default())
             .add_system_to_stage(CoreStage::PostUpdate, text2d_system)
             .add_system_to_stage(RenderStage::Draw, text2d::draw_text2d_system);
+
+        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 f255c613db814..b690dbfd16084 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -8,7 +8,9 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::schedule::{
+    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
+};
 use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
@@ -48,5 +50,10 @@ impl Plugin for TransformPlugin {
                     .label(TransformSystem::TransformPropagate)
                     .after(TransformSystem::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 e9ca5b3b328f8..173882303f5a5 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -22,7 +22,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_render::RenderStage;
@@ -85,5 +87,10 @@ impl Plugin for UiPlugin {
             .add_system_to_stage(RenderStage::Draw, widget::draw_text_system);
 
         crate::render::add_ui_graph(&mut app.world);
+
+        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 af072b7a60f9f..a939b95be8b47 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -11,7 +11,9 @@ pub use winit_config::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppExit, CoreStage, Events, ManualEventReader, Plugin};
-use bevy_ecs::{system::IntoExclusiveSystem, world::World};
+use bevy_ecs::{
+    schedule::ReportExecutionOrderAmbiguities, system::IntoExclusiveSystem, world::World,
+};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
@@ -43,6 +45,11 @@ impl Plugin for WinitPlugin {
         app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_winit".to_string());
     }
 }
 

From 09aff2bb1f20b3c60be63db760273f2ea6ca05bc 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 40/42] 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 c9aff48b4150e5456ffb23e3b6fb81024a7ab2e5 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 41/42] 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 ae9bea3e26be4..ad9c46b4d86e5 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -61,6 +61,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 4f58ad0eea57617e17cc482db420a6fa4771d2b3 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 42/42] 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 de31a4d1081b3..f1f4a66e5bbe3 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: