Rename ReportExecutionOrderAmbiguities to ExecutionOrderAmbiguities

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

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ use fixedbitset::FixedBitSet;`
`31`	`31`	`/// App::new()`
`32`	`32`	`/// .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));`
`33`	`33`	/// ```
`34`		`-pub enum ReportExecutionOrderAmbiguities {`
	`34`	`+pub enum ExecutionOrderAmbiguities {`
`35`	`35`	`/// Disables all checks for execution order ambiguities`
`36`	`36`	`Allow,`
`37`	`37`	`/// Displays only the number of unresolved ambiguities detected by the ambiguity checker`
`@@ -164,16 +164,16 @@ pub fn find_ambiguities(`
`164`	`164`	`systems: &[impl SystemContainer],`
`165`	`165`	`crates_filter: &[String],`
`166`	`166`	`// Should explicit attempts to ignore ambiguities be obeyed?`
`167`		`- report_level: ReportExecutionOrderAmbiguities,`
	`167`	`+ report_level: ExecutionOrderAmbiguities,`
`168`	`168`	`) -> Vec<(usize, usize, Vec<ComponentId>)> {`
`169`	`169`	`fn should_ignore_ambiguity(`
`170`	`170`	`systems: &[impl SystemContainer],`
`171`	`171`	`index_a: usize,`
`172`	`172`	`index_b: usize,`
`173`	`173`	`crates_filter: &[String],`
`174`		`- report_level: ReportExecutionOrderAmbiguities,`
	`174`	`+ report_level: ExecutionOrderAmbiguities,`
`175`	`175`	`) -> bool {`
`176`		`- if report_level == ReportExecutionOrderAmbiguities::Forbid {`
	`176`	`+ if report_level == ExecutionOrderAmbiguities::Forbid {`
`177`	`177`	`return false;`
`178`	`178`	`}`
`179`	`179`
`@@ -259,9 +259,9 @@ pub fn find_ambiguities(`
`259`	`259`	`ambiguities`
`260`	`260`	`}`
`261`	`261`
`262`		`-impl Default for ReportExecutionOrderAmbiguities {`
	`262`	`+impl Default for ExecutionOrderAmbiguities {`
`263`	`263`	`fn default() -> Self {`
`264`		`- ReportExecutionOrderAmbiguities::Warn`
	`264`	`+ ExecutionOrderAmbiguities::Warn`
`265`	`265`	`}`
`266`	`266`	`}`
`267`	`267`
`@@ -278,19 +278,19 @@ impl SystemStage {`
`278`	`278`	`// FIXME: these methods should not have tor rely on &mut World, or any specific World`
`279`	`279`	`// see https://github.com/bevyengine/bevy/issues/4364`
`280`	`280`	`world: &mut World,`
`281`		`- report_level: ReportExecutionOrderAmbiguities,`
	`281`	`+ report_level: ExecutionOrderAmbiguities,`
`282`	`282`	`) -> Vec<SystemOrderAmbiguity> {`
`283`	`283`	`self.initialize(world);`
`284`	`284`
`285`		`- if report_level == ReportExecutionOrderAmbiguities::Allow {`
	`285`	`+ if report_level == ExecutionOrderAmbiguities::Allow {`
`286`	`286`	`return Vec::default();`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`// System order must be fresh`
`290`	`290`	`debug_assert!(!self.systems_modified);`
`291`	`291`
`292`	`292`	`// TODO: remove all internal ambiguities and remove this logic`
`293`		`- let ignored_crates = if report_level != ReportExecutionOrderAmbiguities::WarnInternal {`
	`293`	`+ let ignored_crates = if report_level != ExecutionOrderAmbiguities::WarnInternal {`
`294`	`294`	`vec![`
`295`	`295`	`// Rendering`
`296`	`296`	`"bevy_render".to_string(),`
`@@ -385,7 +385,7 @@ impl SystemStage {`
`385`	`385`	`pub fn n_ambiguities(`
`386`	`386`	`&mut self,`
`387`	`387`	`world: &mut World,`
`388`		`- report_level: ReportExecutionOrderAmbiguities,`
	`388`	`+ report_level: ExecutionOrderAmbiguities,`
`389`	`389`	`) -> usize {`
`390`	`390`	`self.ambiguities(world, report_level).len()`
`391`	`391`	`}`
`@@ -394,7 +394,7 @@ impl SystemStage {`
`394`	`394`	`pub fn report_ambiguities(`
`395`	`395`	`&mut self,`
`396`	`396`	`world: &mut World,`
`397`		`- report_level: ReportExecutionOrderAmbiguities,`
	`397`	`+ report_level: ExecutionOrderAmbiguities,`
`398`	`398`	`) {`
`399`	`399`	`let ambiguities = self.ambiguities(world, report_level);`
`400`	`400`	`let unresolved_count = ambiguities.len();`
`@@ -409,7 +409,7 @@ impl SystemStage {`
`409`	`409`	You may want to add `.before()` or `.after()` ordering constraints between some of these systems to prevent bugs.\n");
`410`	`410`	`}`
`411`	`411`
`412`		`- if report_level == ReportExecutionOrderAmbiguities::Warn {`
	`412`	`+ if report_level == ExecutionOrderAmbiguities::Warn {`
`413`	`413`	println!("Set the level of the `ReportExecutionOrderAmbiguities` resource to `AmbiguityReportLevel::Verbose` for more details.");
`414`	`414`	`} else {`
`415`	`415`	`for (i, ambiguity) in ambiguities.iter().enumerate() {`
`@@ -434,8 +434,8 @@ impl SystemStage {`
`434`	`434`	`println!("");`
`435`	`435`	`}`
`436`	`436`
`437`		`- if report_level == ReportExecutionOrderAmbiguities::Deny`
`438`		`- \|\| report_level == ReportExecutionOrderAmbiguities::Forbid`
	`437`	`+ if report_level == ExecutionOrderAmbiguities::Deny`
	`438`	`+ \|\| report_level == ExecutionOrderAmbiguities::Forbid`
`439`	`439`	`{`
`440`	`440`	`panic!("The ReportExecutionOrderAmbiguities resource is set to a level that forbids the app from running with unresolved system execution order ambiguities.")`
`441`	`441`	`}`
`@@ -594,7 +594,7 @@ mod tests {`
`594`	`594`	`.add_system(event_writer_system);`
`595`	`595`
`596`	`596`	`assert_eq!(`
`597`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`597`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`598`	`598`	`0`
`599`	`599`	`);`
`600`	`600`	`}`
`@@ -619,7 +619,7 @@ mod tests {`
`619`	`619`	`.add_system(read_world_system);`
`620`	`620`
`621`	`621`	`assert_eq!(`
`622`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`622`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`623`	`623`	`0`
`624`	`624`	`);`
`625`	`625`	`}`
`@@ -637,7 +637,7 @@ mod tests {`
`637`	`637`	`.add_system(read_world_system);`
`638`	`638`
`639`	`639`	`assert_eq!(`
`640`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`640`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`641`	`641`	`3`
`642`	`642`	`);`
`643`	`643`	`}`
`@@ -650,7 +650,7 @@ mod tests {`
`650`	`650`	`test_stage.add_system(resmut_system).add_system(res_system);`
`651`	`651`
`652`	`652`	`assert_eq!(`
`653`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`653`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`654`	`654`	`1`
`655`	`655`	`);`
`656`	`656`	`}`
`@@ -665,7 +665,7 @@ mod tests {`
`665`	`665`	`.add_system(nonsend_system);`
`666`	`666`
`667`	`667`	`assert_eq!(`
`668`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`668`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`669`	`669`	`1`
`670`	`670`	`);`
`671`	`671`	`}`
`@@ -680,7 +680,7 @@ mod tests {`
`680`	`680`	`.add_system(write_component_system);`
`681`	`681`
`682`	`682`	`assert_eq!(`
`683`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`683`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`684`	`684`	`1`
`685`	`685`	`);`
`686`	`686`	`}`
`@@ -695,7 +695,7 @@ mod tests {`
`695`	`695`	`.add_system(without_filtered_component_system);`
`696`	`696`
`697`	`697`	`assert_eq!(`
`698`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`698`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`699`	`699`	`0`
`700`	`700`	`);`
`701`	`701`	`}`
`@@ -712,7 +712,7 @@ mod tests {`
`712`	`712`	`.add_system(event_resource_system);`
`713`	`713`
`714`	`714`	`assert_eq!(`
`715`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`715`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`716`	`716`	`3`
`717`	`717`	`);`
`718`	`718`	`}`
`@@ -732,7 +732,7 @@ mod tests {`
`732`	`732`	`.add_system(write_world_system.exclusive_system().before_commands());`
`733`	`733`
`734`	`734`	`assert_eq!(`
`735`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`735`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`736`	`736`	`3`
`737`	`737`	`);`
`738`	`738`	`}`
`@@ -749,7 +749,7 @@ mod tests {`
`749`	`749`	`.add_system(event_resource_system.after(event_writer_system));`
`750`	`750`
`751`	`751`	`assert_eq!(`
`752`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`752`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`753`	`753`	`// All of these systems clash`
`754`	`754`	`0`
`755`	`755`	`);`
`@@ -764,7 +764,7 @@ mod tests {`
`764`	`764`	`.add_system(res_system);`
`765`	`765`
`766`	`766`	`assert_eq!(`
`767`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`767`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`768`	`768`	`0`
`769`	`769`	`);`
`770`	`770`	`}`
`@@ -778,7 +778,7 @@ mod tests {`
`778`	`778`	`.add_system(res_system.label("IGNORE_ME"));`
`779`	`779`
`780`	`780`	`assert_eq!(`
`781`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`781`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`782`	`782`	`0`
`783`	`783`	`);`
`784`	`784`	`}`
`@@ -815,7 +815,7 @@ mod tests {`
`815`	`815`	`.add_system(system_b);`
`816`	`816`
`817`	`817`	`assert_eq!(`
`818`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`818`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`819`	`819`	`0`
`820`	`820`	`);`
`821`	`821`	`}`
`@@ -825,7 +825,7 @@ mod tests {`
`825`	`825`	`let mut world = World::new();`
`826`	`826`	`let mut test_stage = make_test_stage(&mut world);`
`827`	`827`	`assert_eq!(`
`828`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`828`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`829`	`829`	`0`
`830`	`830`	`);`
`831`	`831`	`}`
`@@ -835,7 +835,7 @@ mod tests {`
`835`	`835`	`let mut world = World::new();`
`836`	`836`	`let mut test_stage = make_test_stage(&mut world);`
`837`	`837`	`assert_eq!(`
`838`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`838`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`839`	`839`	`2`
`840`	`840`	`);`
`841`	`841`	`}`
`@@ -845,7 +845,7 @@ mod tests {`
`845`	`845`	`let mut world = World::new();`
`846`	`846`	`let mut test_stage = make_test_stage(&mut world);`
`847`	`847`	`assert_eq!(`
`848`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`848`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`849`	`849`	`2`
`850`	`850`	`);`
`851`	`851`	`}`
`@@ -855,7 +855,7 @@ mod tests {`
`855`	`855`	`let mut world = World::new();`
`856`	`856`	`let mut test_stage = make_test_stage(&mut world);`
`857`	`857`	`assert_eq!(`
`858`		`- test_stage.n_ambiguities(&mut world, ReportExecutionOrderAmbiguities::Forbid),`
	`858`	`+ test_stage.n_ambiguities(&mut world, ExecutionOrderAmbiguities::Forbid),`
`859`	`859`	`6`
`860`	`860`	`);`
`861`	`861`	`}`
`@@ -869,7 +869,7 @@ mod tests {`
`869`	`869`	`let mut world = World::new();`
`870`	`870`	`let mut test_stage = make_test_stage(&mut world);`
`871`	`871`	`let ambiguities =`
`872`		`- test_stage.ambiguities(&mut world, ReportExecutionOrderAmbiguities::WarnVerbose);`
	`872`	`+ test_stage.ambiguities(&mut world, ExecutionOrderAmbiguities::WarnVerbose);`
`873`	`873`	`assert_eq!(`
`874`	`874`	`// We don't care if the reported order varies`
`875`	`875`	`HashSet::from_iter(ambiguities),`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,6 @@ use bevy::prelude::*;`
`6`	`6`	`fn main() {`
`7`	`7`	`App::new()`
`8`	`8`	`.add_plugins(DefaultPlugins)`
`9`		`- .insert_resource(ReportExecutionOrderAmbiguities::WarnInternal)`
	`9`	`+ .insert_resource(ExecutionOrderAmbiguities::WarnInternal)`
`10`	`10`	`.run()`
`11`	`11`	`}`