Fix formatting

Author: Alainx277

crates/bevy_ecs/src/schedule/commands.rs

@@ -4,12 +4,12 @@ use super::{IntoSystemDescriptor, Schedule, StageLabel};
 
 #[derive(Default)]
 pub struct ScheduleCommandQueue {
-    items: Vec<Box<dyn ScheduleCommand>>
+    items: Vec<Box<dyn ScheduleCommand>>,
 }
 
 impl ScheduleCommandQueue {
     pub fn push<C>(&mut self, command: C)
-    where 
+    where
         C: ScheduleCommand,
     {
         self.items.push(Box::new(command));
@@ -36,24 +36,22 @@ pub trait ScheduleCommand: Send + Sync + 'static {
 }
 
 pub struct ScheduleCommands<'a> {
-    queue: &'a mut ScheduleCommandQueue
+    queue: &'a mut ScheduleCommandQueue,
 }
 
 impl<'a> ScheduleCommands<'a> {
     pub fn new(queue: &'a mut ScheduleCommandQueue) -> Self {
-        Self {
-            queue
-        }
+        Self { queue }
     }
 
     pub fn insert_system<T: 'static, S, Params: 'static>(&mut self, system: T, stage_label: S)
     where
         T: IntoSystemDescriptor<Params> + Send + Sync,
-        S: StageLabel
+        S: StageLabel,
     {
         self.queue.push(InsertSystem {
-            system: system,
-            stage_label: stage_label,
+            system,
+            stage_label,
             phantom: Default::default(),
         });
     }
@@ -62,7 +60,7 @@ impl<'a> ScheduleCommands<'a> {
 pub struct InsertSystem<T, S, Params>
 where
     T: IntoSystemDescriptor<Params>,
-    S: StageLabel
+    S: StageLabel,
 {
     pub system: T,
     pub stage_label: S,
@@ -72,7 +70,7 @@ where
 impl<T: 'static, S, Params: 'static> ScheduleCommand for InsertSystem<T, S, Params>
 where
     T: IntoSystemDescriptor<Params> + Send + Sync,
-    S: StageLabel
+    S: StageLabel,
 {
     fn write(self: Box<Self>, schedule: &mut Schedule) {
         schedule.add_system_to_stage(self.stage_label, self.system);
@@ -82,16 +80,14 @@ where
 #[cfg(test)]
 mod tests {
     use crate::{
-        schedule::{Schedule, ScheduleCommands, ScheduleCommandQueue, SystemStage},
+        schedule::{Schedule, ScheduleCommandQueue, ScheduleCommands, SystemStage},
         system::Commands,
         world::World,
     };
 
     #[test]
     fn insert_system() {
-        fn sample_system(mut _commands: Commands) {
-
-        }
+        fn sample_system(mut _commands: Commands) {}
         let mut schedule = Schedule::default();
         schedule.add_stage("test", SystemStage::parallel());
         let mut queue = ScheduleCommandQueue::default();

crates/bevy_ecs/src/schedule/mod.rs

@@ -1,3 +1,4 @@
+mod commands;
 mod executor;
 mod executor_parallel;
 pub mod graph_utils;
@@ -8,8 +9,8 @@ mod state;
 mod system_container;
 mod system_descriptor;
 mod system_set;
-mod commands;
 
+pub use commands::*;
 pub use executor::*;
 pub use executor_parallel::*;
 pub use graph_utils::GraphNode;
@@ -20,7 +21,6 @@ pub use state::*;
 pub use system_container::*;
 pub use system_descriptor::*;
 pub use system_set::*;
-pub use commands::*;
 
 use std::fmt::Debug;
 

crates/bevy_ecs/src/schedule/run_criteria.rs

@@ -450,7 +450,9 @@ impl System for RunOnce {
     }
 
     fn apply_buffers(&mut self, _world: &mut World) {}
-    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> { None }
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> {
+        None
+    }
 
     fn initialize(&mut self, _world: &mut World) {}
 

crates/bevy_ecs/src/schedule/stage.rs

@@ -5,10 +5,10 @@ use crate::{
         BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
         ExclusiveSystemContainer, GraphNode, InsertionPoint, ParallelExecutor,
         ParallelSystemContainer, ParallelSystemExecutor, RunCriteriaContainer,
-        RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner,
-        ShouldRun, SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
+        RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun,
+        SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
     },
-    system::{System, ExclusiveSystem},
+    system::{ExclusiveSystem, System},
     world::{World, WorldId},
 };
 use bevy_utils::{tracing::info, HashMap, HashSet};
@@ -809,7 +809,11 @@ impl Stage for SystemStage {
                     )
                 }
 
-                fn run_exclusive(world: &mut World, system: &mut Box<dyn ExclusiveSystem>, commands: &mut ScheduleCommandQueue) {
+                fn run_exclusive(
+                    world: &mut World,
+                    system: &mut Box<dyn ExclusiveSystem>,
+                    commands: &mut ScheduleCommandQueue,
+                ) {
                     system.run(world);
                     if let Some(mut c) = system.schedule_commands() {
                         c.transfer(commands);

crates/bevy_ecs/src/system/function_system.rs

@@ -2,12 +2,12 @@ use crate::{
     archetype::{Archetype, ArchetypeComponentId, ArchetypeGeneration, ArchetypeId},
     component::ComponentId,
     query::{Access, FilteredAccessSet},
+    schedule::ScheduleCommandQueue,
     system::{
         check_system_change_tick, ReadOnlySystemParamFetch, System, SystemId, SystemParam,
         SystemParamFetch, SystemParamState,
     },
     world::{World, WorldId},
-    schedule::ScheduleCommandQueue,
 };
 use bevy_ecs_macros::all_tuples;
 use std::{borrow::Cow, marker::PhantomData};

crates/bevy_ecs/src/system/system.rs

@@ -1,6 +1,12 @@
 use bevy_utils::tracing::warn;
 
-use crate::{archetype::{Archetype, ArchetypeComponentId}, component::ComponentId, query::Access, schedule::ScheduleCommandQueue, world::World};
+use crate::{
+    archetype::{Archetype, ArchetypeComponentId},
+    component::ComponentId,
+    query::Access,
+    schedule::ScheduleCommandQueue,
+    world::World,
+};
 use std::borrow::Cow;
 
 /// A [`System`] identifier.

crates/bevy_ecs/src/system/system_param.rs

@@ -72,7 +72,9 @@ pub unsafe trait SystemParamState: Send + Sync + 'static {
     fn new_archetype(&mut self, _archetype: &Archetype, _system_meta: &mut SystemMeta) {}
     #[inline]
     fn apply(&mut self, _world: &mut World) {}
-    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> { None }
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> {
+        None
+    }
     fn default_config() -> Self::Config;
 }