Optimize param validation through get_param(...) -> Option<Out>

benches/benches/bevy_ecs/fragmentation/mod.rs

@@ -25,7 +25,7 @@ fn iter_frag_empty(c: &mut Criterion) {
         spawn_empty_frag_archetype::<Table>(&mut world);
         let mut q: SystemState<Query<(Entity, &Table)>> =
             SystemState::<Query<(Entity, &Table<0>)>>::new(&mut world);
-        let query = q.get(&world);
+        let query = q.get(&world).unwrap();
         b.iter(move || {
             let mut res = 0;
             query.iter().for_each(|(e, t)| {
@@ -39,7 +39,7 @@ fn iter_frag_empty(c: &mut Criterion) {
         spawn_empty_frag_archetype::<Sparse>(&mut world);
         let mut q: SystemState<Query<(Entity, &Sparse)>> =
             SystemState::<Query<(Entity, &Sparse<0>)>>::new(&mut world);
-        let query = q.get(&world);
+        let query = q.get(&world).unwrap();
         b.iter(move || {
             let mut res = 0;
             query.iter().for_each(|(e, t)| {

benches/benches/bevy_ecs/world/world_get.rs

@@ -269,7 +269,7 @@ pub fn query_get(criterion: &mut Criterion) {
                 .collect();
             entities.shuffle(&mut deterministic_rand());
             let mut query = SystemState::<Query<&Table>>::new(&mut world);
-            let query = query.get(&world);
+            let query = query.get(&world).unwrap();
 
             bencher.iter(|| {
                 let mut count = 0;
@@ -288,7 +288,7 @@ pub fn query_get(criterion: &mut Criterion) {
                 .collect();
             entities.shuffle(&mut deterministic_rand());
             let mut query = SystemState::<Query<&Sparse>>::new(&mut world);
-            let query = query.get(&world);
+            let query = query.get(&world).unwrap();
 
             bencher.iter(|| {
                 let mut count = 0;
@@ -319,7 +319,7 @@ pub fn query_get_many<const N: usize>(criterion: &mut Criterion) {
             entity_groups.shuffle(&mut deterministic_rand());
 
             let mut query = SystemState::<Query<&Table>>::new(&mut world);
-            let query = query.get(&world);
+            let query = query.get(&world).unwrap();
 
             bencher.iter(|| {
                 let mut count = 0;
@@ -342,7 +342,7 @@ pub fn query_get_many<const N: usize>(criterion: &mut Criterion) {
             entity_groups.shuffle(&mut deterministic_rand());
 
             let mut query = SystemState::<Query<&Sparse>>::new(&mut world);
-            let query = query.get(&world);
+            let query = query.get(&world).unwrap();
 
             bencher.iter(|| {
                 let mut count = 0;

crates/bevy_ecs/compile_fail/tests/ui/query_lifetime_safety.rs

@@ -10,7 +10,7 @@ fn main() {
 
     let mut system_state = SystemState::<Query<&mut Foo>>::new(&mut world);
     {
-        let mut query = system_state.get_mut(&mut world);
+        let mut query = system_state.get_mut(&mut world).unwrap();
         dbg!("hi");
         {
             let data: &Foo = query.get(e).unwrap();

crates/bevy_ecs/compile_fail/tests/ui/query_transmute_safety.rs

@@ -12,7 +12,7 @@ fn main() {
     world.spawn(Foo(10));
 
     let mut system_state = SystemState::<Query<(&mut Foo, &Bar)>>::new(&mut world);
-    let mut query = system_state.get_mut(&mut world);
+    let mut query = system_state.get_mut(&mut world).unwrap();
 
     {
         let mut lens_a = query.transmute_lens::<&mut Foo>();

crates/bevy_ecs/compile_fail/tests/ui/system_state_get_lifetime_safety.rs

@@ -14,10 +14,10 @@ struct State {
 
 impl State {
     fn get_component(&mut self, world: &mut World, entity: Entity) {
-        let q1 = self.state_r.get(&world);
+        let q1 = self.state_r.get(&world).unwrap();
         let a1 = q1.get(entity).unwrap();
 
-        let mut q2 = self.state_w.get_mut(world);
+        let mut q2 = self.state_w.get_mut(world).unwrap();
         //~^ E0502
         let _ = q2.get_mut(entity).unwrap();
 

crates/bevy_ecs/compile_fail/tests/ui/system_state_iter_lifetime_safety.rs

@@ -14,10 +14,10 @@ struct State {
 
 impl State {
     fn get_components(&mut self, world: &mut World) {
-        let q1 = self.state_r.get(&world);
+        let q1 = self.state_r.get(&world).unwrap();
         let a1 = q1.iter().next().unwrap();
 
-        let mut q2 = self.state_w.get_mut(world);
+        let mut q2 = self.state_w.get_mut(world).unwrap();
         //~^ E0502
         let _ = q2.iter_mut().next().unwrap();
 

crates/bevy_ecs/compile_fail/tests/ui/system_state_iter_mut_overlap_safety.rs

@@ -11,7 +11,7 @@ fn main() {
 
     let mut system_state = SystemState::<Query<&mut A>>::new(&mut world);
     {
-        let mut query = system_state.get_mut(&mut world);
+        let mut query = system_state.get_mut(&mut world).unwrap();
         let mut_vec = query.iter_mut().collect::<Vec<bevy_ecs::prelude::Mut<A>>>();
         assert_eq!(
             // this should fail to compile due to the later use of mut_vec

crates/bevy_ecs/macros/src/lib.rs

@@ -316,9 +316,11 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
                 // SAFETY: systems run without conflicts with other systems.
                 // Conflicting params in ParamSet are not accessible at the same time
                 // ParamSets are guaranteed to not conflict with other SystemParams
-                unsafe {
+                let maybe_param = unsafe {
                     #param::get_param(&mut self.param_states.#index, &self.system_meta, self.world, self.change_tick)
-                }
+                };
+                // `ParamSet::get_param` ensures all sub-params are accessible.
+                maybe_param.unwrap()
             }
         });
     }
@@ -380,28 +382,30 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
                     <(#(#param,)*) as SystemParam>::queue(state, system_meta, world.reborrow());
                 }
 
-                #[inline]
-                unsafe fn validate_param<'w, 's>(
-                    state: &'s Self::State,
-                    system_meta: &SystemMeta,
-                    world: UnsafeWorldCell<'w>,
-                ) -> bool {
-                    <(#(#param,)*) as SystemParam>::validate_param(state, system_meta, world)
-                }
-
                 #[inline]
                 unsafe fn get_param<'w, 's>(
                     state: &'s mut Self::State,
                     system_meta: &SystemMeta,
                     world: UnsafeWorldCell<'w>,
                     change_tick: Tick,
-                ) -> Self::Item<'w, 's> {
-                    ParamSet {
+                ) -> Option<Self::Item<'w, 's>> {
+                    let param = ParamSet {
                         param_states: state,
                         system_meta: system_meta.clone(),
                         world,
                         change_tick,
-                    }
+                    };
+                    Some(param)
+                }
+
+                #[inline]
+                unsafe fn validate_param<'w, 's>(
+                    state: &'s mut Self::State,
+                    system_meta: &SystemMeta,
+                    world: UnsafeWorldCell<'w>,
+                    change_tick: Tick,
+                ) -> bool {
+                    <(#(#param,)*) as SystemParam>::validate_param(state, system_meta, world, change_tick)
                 }
             }
 
@@ -631,27 +635,25 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                 }
 
                 #[inline]
-                unsafe fn validate_param<'w, 's>(
-                    state: &'s Self::State,
+                unsafe fn get_param<'w, 's>(
+                    state: &'s mut Self::State,
                     system_meta: &#path::system::SystemMeta,
                     world: #path::world::unsafe_world_cell::UnsafeWorldCell<'w>,
-                ) -> bool {
-                    <(#(#tuple_types,)*) as #path::system::SystemParam>::validate_param(&state.state, system_meta, world)
+                    change_tick: #path::component::Tick,
+                ) -> Option<Self::Item<'w, 's>> {
+                    let (#(#tuple_patterns,)*) = <(#(#tuple_types,)*) as #path::system::SystemParam>::get_param(&mut state.state, system_meta, world, change_tick)?;
+                    let param = #struct_name { #(#fields: #field_locals,)* };
+                    Some(param)
                 }
 
                 #[inline]
-                unsafe fn get_param<'w, 's>(
+                unsafe fn validate_param<'w, 's>(
                     state: &'s mut Self::State,
                     system_meta: &#path::system::SystemMeta,
                     world: #path::world::unsafe_world_cell::UnsafeWorldCell<'w>,
                     change_tick: #path::component::Tick,
-                ) -> Self::Item<'w, 's> {
-                    let (#(#tuple_patterns,)*) = <
-                        (#(#tuple_types,)*) as #path::system::SystemParam
-                    >::get_param(&mut state.state, system_meta, world, change_tick);
-                    #struct_name {
-                        #(#fields: #field_locals,)*
-                    }
+                ) -> bool {
+                    <(#(#tuple_types,)*) as #path::system::SystemParam>::validate_param(&mut state.state, system_meta, world, change_tick)
                 }
             }
 

crates/bevy_ecs/src/change_detection.rs

@@ -164,17 +164,17 @@ pub trait DetectChangesMut: DetectChanges {
     /// # world.insert_resource(Score(1));
     /// # let mut score_changed = IntoSystem::into_system(resource_changed::<Score>);
     /// # score_changed.initialize(&mut world);
-    /// # score_changed.run((), &mut world);
+    /// # score_changed.run((), &mut world).unwrap();
     /// #
     /// # let mut schedule = Schedule::default();
     /// # schedule.add_systems(reset_score);
     /// #
     /// # // first time `reset_score` runs, the score is changed.
     /// # schedule.run(&mut world);
-    /// # assert!(score_changed.run((), &mut world));
+    /// # assert!(score_changed.run((), &mut world).unwrap());
     /// # // second time `reset_score` runs, the score is not changed.
     /// # schedule.run(&mut world);
-    /// # assert!(!score_changed.run((), &mut world));
+    /// # assert!(!score_changed.run((), &mut world).unwrap());
     /// ```
     #[inline]
     #[track_caller]
@@ -235,23 +235,23 @@ pub trait DetectChangesMut: DetectChanges {
     /// # world.insert_resource(Score(1));
     /// # let mut score_changed = IntoSystem::into_system(resource_changed::<Score>);
     /// # score_changed.initialize(&mut world);
-    /// # score_changed.run((), &mut world);
+    /// # score_changed.run((), &mut world).unwrap();
     /// #
     /// # let mut score_changed_event = IntoSystem::into_system(on_event::<ScoreChanged>);
     /// # score_changed_event.initialize(&mut world);
-    /// # score_changed_event.run((), &mut world);
+    /// # score_changed_event.run((), &mut world).unwrap();
     /// #
     /// # let mut schedule = Schedule::default();
     /// # schedule.add_systems(reset_score);
     /// #
     /// # // first time `reset_score` runs, the score is changed.
     /// # schedule.run(&mut world);
-    /// # assert!(score_changed.run((), &mut world));
-    /// # assert!(score_changed_event.run((), &mut world));
+    /// # assert!(score_changed.run((), &mut world).unwrap());
+    /// # assert!(score_changed_event.run((), &mut world).unwrap());
     /// # // second time `reset_score` runs, the score is not changed.
     /// # schedule.run(&mut world);
-    /// # assert!(!score_changed.run((), &mut world));
-    /// # assert!(!score_changed_event.run((), &mut world));
+    /// # assert!(!score_changed.run((), &mut world).unwrap());
+    /// # assert!(!score_changed_event.run((), &mut world).unwrap());
     /// ```
     #[inline]
     #[must_use = "If you don't need to handle the previous value, use `set_if_neq` instead."]
@@ -1256,7 +1256,7 @@ mod tests {
 
         // world: 1, system last ran: 0, component changed: 1
         // The spawn will be detected since it happened after the system "last ran".
-        assert!(change_detected_system.run((), &mut world));
+        assert!(change_detected_system.run((), &mut world).unwrap());
 
         // world: 1 + MAX_CHANGE_AGE
         let change_tick = world.change_tick.get_mut();
@@ -1266,7 +1266,7 @@ mod tests {
         // Since we clamp things to `MAX_CHANGE_AGE` for determinism,
         // `ComponentTicks::is_changed` will now see `MAX_CHANGE_AGE > MAX_CHANGE_AGE`
         // and return `false`.
-        assert!(!change_expired_system.run((), &mut world));
+        assert!(!change_expired_system.run((), &mut world).unwrap());
     }
 
     #[test]

crates/bevy_ecs/src/event/mod.rs

@@ -522,20 +522,20 @@ mod tests {
             });
         reader.initialize(&mut world);
 
-        let last = reader.run((), &mut world);
+        let last = reader.run((), &mut world).unwrap();
         assert!(last.is_none(), "EventReader should be empty");
 
         world.send_event(TestEvent { i: 0 });
-        let last = reader.run((), &mut world);
+        let last = reader.run((), &mut world).unwrap();
         assert_eq!(last, Some(TestEvent { i: 0 }));
 
         world.send_event(TestEvent { i: 1 });
         world.send_event(TestEvent { i: 2 });
         world.send_event(TestEvent { i: 3 });
-        let last = reader.run((), &mut world);
+        let last = reader.run((), &mut world).unwrap();
         assert_eq!(last, Some(TestEvent { i: 3 }));
 
-        let last = reader.run((), &mut world);
+        let last = reader.run((), &mut world).unwrap();
         assert!(last.is_none(), "EventReader should be empty");
     }
 
@@ -552,20 +552,20 @@ mod tests {
             });
         mutator.initialize(&mut world);
 
-        let last = mutator.run((), &mut world);
+        let last = mutator.run((), &mut world).unwrap();
         assert!(last.is_none(), "EventMutator should be empty");
 
         world.send_event(TestEvent { i: 0 });
-        let last = mutator.run((), &mut world);
+        let last = mutator.run((), &mut world).unwrap();
         assert_eq!(last, Some(TestEvent { i: 0 }));
 
         world.send_event(TestEvent { i: 1 });
         world.send_event(TestEvent { i: 2 });
         world.send_event(TestEvent { i: 3 });
-        let last = mutator.run((), &mut world);
+        let last = mutator.run((), &mut world).unwrap();
         assert_eq!(last, Some(TestEvent { i: 3 }));
 
-        let last = mutator.run((), &mut world);
+        let last = mutator.run((), &mut world).unwrap();
         assert!(last.is_none(), "EventMutator should be empty");
     }
 

crates/bevy_ecs/src/observer/runner.rs

@@ -374,8 +374,7 @@ fn observer_system_runner<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
     // - system is the same type erased system from above
     unsafe {
         (*system).update_archetype_component_access(world);
-        if (*system).validate_param_unsafe(world) {
-            (*system).run_unsafe(trigger, world);
+        if (*system).run_unsafe(trigger, world).is_some() {
             (*system).queue_deferred(world.into_deferred());
         }
     }

crates/bevy_ecs/src/query/mod.rs

@@ -751,7 +751,7 @@ mod tests {
 
         // system param
         let mut q = SystemState::<Query<&mut Foo>>::new(&mut world);
-        let q = q.get_mut(&mut world);
+        let q = q.get_mut(&mut world).unwrap();
         let _: Option<&Foo> = q.iter().next();
         let _: Option<[&Foo; 2]> = q.iter_combinations::<2>().next();
         let _: Option<&Foo> = q.iter_many([e]).next();