state_entity

Author: re0312

crates/bevy_audio/src/audio_output.rs

@@ -54,10 +54,10 @@ pub struct PlaybackDespawnMarker;
 pub struct PlaybackRemoveMarker;
 
 #[derive(SystemParam)]
-pub(crate) struct EarPositions<'w, 's> {
-    pub(crate) query: Query<'w, 's, (Entity, &'static GlobalTransform, &'static SpatialListener)>,
+pub(crate) struct EarPositions<'w> {
+    pub(crate) query: Query<'w, 'w, (Entity, &'static GlobalTransform, &'static SpatialListener)>,
 }
-impl<'w, 's> EarPositions<'w, 's> {
+impl<'w> EarPositions<'w> {
     /// Gets a set of transformed ear positions.
     ///
     /// If there are no listeners, use the default values. If a user has added multiple

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

@@ -5,12 +5,11 @@ use bevy_ecs::system::{ReadOnlySystemParam, SystemParam, SystemState};
 struct Foo;
 
 #[derive(SystemParam)]
-struct Mutable<'w, 's> {
-    a: Query<'w, 's, &'static mut Foo>,
+struct Mutable<'w> {
+    a: Query<'w, &'static mut Foo>,
 }
 
 fn main() {
-
     let mut world = World::default();
     let state = SystemState::<Mutable>::new(&mut world);
     state.get(&world);

crates/bevy_ecs/src/query/state.rs

@@ -3,7 +3,7 @@ use crate::{
     component::{ComponentId, Tick},
     entity::{Entity, EntityEquivalent, EntitySet, UniqueEntityArray},
     entity_disabling::DefaultQueryFilters,
-    prelude::FromWorld,
+    prelude::{Component, FromWorld},
     query::{FilteredAccess, QueryCombinationIter, QueryIter, QueryParIter, WorldQuery},
     storage::{SparseSetIndex, TableId},
     system::Query,
@@ -60,6 +60,8 @@ pub(super) union StorageId {
 /// [`Fetch`]: crate::query::world_query::WorldQuery::Fetch
 /// [`Table`]: crate::storage::Table
 #[repr(C)]
+#[derive(Component)]
+#[component(storage = "SparseSet")]
 // SAFETY NOTE:
 // Do not add any new fields that use the `D` or `F` generic parameters as this may
 // make `QueryState::as_transmuted_state` unsound if not done with care.

crates/bevy_ecs/src/system/builder.rs

@@ -3,6 +3,8 @@ use bevy_platform::cell::SyncCell;
 use variadics_please::all_tuples;
 
 use crate::{
+    component::ComponentId,
+    entity::Entity,
     prelude::QueryBuilder,
     query::{QueryData, QueryFilter, QueryState},
     resource::Resource,
@@ -212,10 +214,12 @@ impl ParamBuilder {
 unsafe impl<'w, 's, D: QueryData + 'static, F: QueryFilter + 'static>
     SystemParamBuilder<Query<'w, 's, D, F>> for QueryState<D, F>
 {
-    fn build(self, world: &mut World, system_meta: &mut SystemMeta) -> QueryState<D, F> {
+    fn build(self, world: &mut World, system_meta: &mut SystemMeta) -> (Entity, ComponentId) {
         self.validate_world(world.id());
         init_query_param(world, system_meta, &self);
-        self
+        let id = world.register_component::<QueryState<D, F>>();
+        let e = world.spawn(self).id();
+        (e, id)
     }
 }
 
@@ -291,12 +295,14 @@ unsafe impl<
         T: FnOnce(&mut QueryBuilder<D, F>),
     > SystemParamBuilder<Query<'w, 's, D, F>> for QueryParamBuilder<T>
 {
-    fn build(self, world: &mut World, system_meta: &mut SystemMeta) -> QueryState<D, F> {
+    fn build(self, world: &mut World, system_meta: &mut SystemMeta) -> (Entity, ComponentId) {
         let mut builder = QueryBuilder::new(world);
         (self.0)(&mut builder);
         let state = builder.build();
         init_query_param(world, system_meta, &state);
-        state
+        let id = world.register_component::<QueryState<D, F>>();
+        let e = world.spawn(state).id();
+        (e, id)
     }
 }
 
@@ -965,9 +971,9 @@ mod tests {
 
     #[derive(SystemParam)]
     #[system_param(builder)]
-    struct CustomParam<'w, 's> {
-        query: Query<'w, 's, ()>,
-        local: Local<'s, usize>,
+    struct CustomParam<'w> {
+        query: Query<'w, 'w, ()>,
+        local: Local<usize>,
     }
 
     #[test]

crates/bevy_ecs/src/system/system_param.rs

@@ -4,10 +4,10 @@ use crate::{
     bundle::Bundles,
     change_detection::{MaybeLocation, Ticks, TicksMut},
     component::{ComponentId, ComponentTicks, Components, Tick},
-    entity::Entities,
+    entity::{Entities, Entity},
     query::{
-        Access, FilteredAccess, FilteredAccessSet, QueryData, QueryFilter, QuerySingleError,
-        QueryState, ReadOnlyQueryData,
+        Access, DebugCheckedUnwrap, FilteredAccess, FilteredAccessSet, QueryData, QueryFilter,
+        QuerySingleError, QueryState, ReadOnlyQueryData,
     },
     resource::Resource,
     storage::ResourceData,
@@ -65,7 +65,7 @@ use variadics_please::{all_tuples, all_tuples_enumerated};
 /// # #[derive(SystemParam)]
 /// # struct ParamsExample<'w, 's> {
 /// #    query:
-/// Query<'w, 's, Entity>,
+/// Query<'w, 'w, Entity>,
 /// #    res:
 /// Res<'w, SomeResource>,
 /// #    res_mut:
@@ -171,7 +171,7 @@ use variadics_please::{all_tuples, all_tuples_enumerated};
 ///     #[derive(SystemParam)]
 ///     #[system_param(builder)]
 ///     pub struct CustomParam<'w, 's> {
-///         query: Query<'w, 's, ()>,
+///         query: Query<'w, 'w, ()>,
 ///         local: Local<'s, usize>,
 ///     }
 ///
@@ -321,13 +321,15 @@ unsafe impl<'w, 's, D: ReadOnlyQueryData + 'static, F: QueryFilter + 'static> Re
 // SAFETY: Relevant query ComponentId access is applied to SystemMeta. If
 // this Query conflicts with any prior access, a panic will occur.
 unsafe impl<D: QueryData + 'static, F: QueryFilter + 'static> SystemParam for Query<'_, '_, D, F> {
-    type State = QueryState<D, F>;
-    type Item<'w, 's> = Query<'w, 's, D, F>;
+    type State = (Entity, ComponentId);
+    type Item<'w, 's> = Query<'w, 'w, D, F>;
 
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
-        let state = QueryState::new(world);
+        let state: QueryState<D, F> = QueryState::new(world);
         init_query_param(world, system_meta, &state);
-        state
+        let e = world.spawn(state).id();
+        let id = world.register_component::<QueryState<D, F>>();
+        (e, id)
     }
 
     #[inline]
@@ -336,11 +338,21 @@ unsafe impl<D: QueryData + 'static, F: QueryFilter + 'static> SystemParam for Qu
         system_meta: &SystemMeta,
         world: UnsafeWorldCell<'w>,
         change_tick: Tick,
-    ) -> Self::Item<'w, 's> {
+    ) -> Self::Item<'w, 'w> {
+        let state = world
+            .storages()
+            .sparse_sets
+            .get(state.1)
+            .debug_checked_unwrap()
+            .get(state.0)
+            .debug_checked_unwrap()
+            .assert_unique()
+            .deref_mut::<QueryState<D, F>>();
         // SAFETY: We have registered all of the query's world accesses,
         // so the caller ensures that `world` has permission to access any
         // world data that the query needs.
         // The caller ensures the world matches the one used in init_state.
+
         unsafe { state.query_unchecked_with_ticks(world, system_meta.last_run, change_tick) }
     }
 }
@@ -386,11 +398,11 @@ fn assert_component_access_compatibility(
 // SAFETY: Relevant query ComponentId access is applied to SystemMeta. If
 // this Query conflicts with any prior access, a panic will occur.
 unsafe impl<'a, D: QueryData + 'static, F: QueryFilter + 'static> SystemParam for Single<'a, D, F> {
-    type State = QueryState<D, F>;
+    type State = (Entity, ComponentId);
     type Item<'w, 's> = Single<'w, D, F>;
 
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
-        Query::init_state(world, system_meta)
+        Query::<D, F>::init_state(world, system_meta)
     }
 
     #[inline]
@@ -400,10 +412,8 @@ unsafe impl<'a, D: QueryData + 'static, F: QueryFilter + 'static> SystemParam fo
         world: UnsafeWorldCell<'w>,
         change_tick: Tick,
     ) -> Self::Item<'w, 's> {
-        // SAFETY: State ensures that the components it accesses are not accessible somewhere elsewhere.
-        // The caller ensures the world matches the one used in init_state.
-        let query =
-            unsafe { state.query_unchecked_with_ticks(world, system_meta.last_run, change_tick) };
+        let query: Query<'_, '_, D, F> = Query::get_param(state, system_meta, world, change_tick);
+
         let single = query
             .single_inner()
             .expect("The query was expected to contain exactly one matching entity.");
@@ -419,12 +429,9 @@ unsafe impl<'a, D: QueryData + 'static, F: QueryFilter + 'static> SystemParam fo
         system_meta: &SystemMeta,
         world: UnsafeWorldCell,
     ) -> Result<(), SystemParamValidationError> {
-        // SAFETY: State ensures that the components it accesses are not mutably accessible elsewhere
-        // and the query is read only.
-        // The caller ensures the world matches the one used in init_state.
-        let query = unsafe {
-            state.query_unchecked_with_ticks(world, system_meta.last_run, world.change_tick())
-        };
+        let query: Query<'_, '_, D, F> =
+            Query::get_param(state, system_meta, world, world.change_tick());
+
         match query.single_inner() {
             Ok(_) => Ok(()),
             Err(QuerySingleError::NoEntities(_)) => Err(
@@ -448,11 +455,11 @@ unsafe impl<'a, D: ReadOnlyQueryData + 'static, F: QueryFilter + 'static> ReadOn
 unsafe impl<D: QueryData + 'static, F: QueryFilter + 'static> SystemParam
     for Populated<'_, '_, D, F>
 {
-    type State = QueryState<D, F>;
-    type Item<'w, 's> = Populated<'w, 's, D, F>;
+    type State = (Entity, ComponentId);
+    type Item<'w, 's> = Populated<'w, 'w, D, F>;
 
     fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
-        Query::init_state(world, system_meta)
+        Query::<D, F>::init_state(world, system_meta)
     }
 
     #[inline]
@@ -461,7 +468,7 @@ unsafe impl<D: QueryData + 'static, F: QueryFilter + 'static> SystemParam
         system_meta: &SystemMeta,
         world: UnsafeWorldCell<'w>,
         change_tick: Tick,
-    ) -> Self::Item<'w, 's> {
+    ) -> Self::Item<'w, 'w> {
         // SAFETY: Delegate to existing `SystemParam` implementations.
         let query = unsafe { Query::get_param(state, system_meta, world, change_tick) };
         Populated(query)
@@ -473,12 +480,9 @@ unsafe impl<D: QueryData + 'static, F: QueryFilter + 'static> SystemParam
         system_meta: &SystemMeta,
         world: UnsafeWorldCell,
     ) -> Result<(), SystemParamValidationError> {
-        // SAFETY:
-        // - We have read-only access to the components accessed by query.
-        // - The caller ensures the world matches the one used in init_state.
-        let query = unsafe {
-            state.query_unchecked_with_ticks(world, system_meta.last_run, world.change_tick())
-        };
+        // SAFETY: Delegate to existing `SystemParam` implementations.
+        let query: Query<'_, '_, D, F> =
+            unsafe { Query::get_param(state, system_meta, world, world.change_tick()) };
         if query.is_empty() {
             Err(SystemParamValidationError::skipped::<Self>(
                 "No matching entities",
@@ -2573,11 +2577,10 @@ mod tests {
         #[derive(SystemParam)]
         pub struct SpecialQuery<
             'w,
-            's,
             D: QueryData + Send + Sync + 'static,
             F: QueryFilter + Send + Sync + 'static = (),
         > {
-            _query: Query<'w, 's, D, F>,
+            _query: Query<'w, 'w, D, F>,
         }
 
         fn my_system(_: SpecialQuery<(), ()>) {}
@@ -2706,11 +2709,11 @@ mod tests {
     #[test]
     fn system_param_where_clause() {
         #[derive(SystemParam)]
-        pub struct WhereParam<'w, 's, D>
+        pub struct WhereParam<'w, D>
         where
             D: 'static + QueryData,
         {
-            _q: Query<'w, 's, D, ()>,
+            _q: Query<'w, 'w, D, ()>,
         }
 
         fn my_system(_: WhereParam<()>) {}

crates/bevy_input_focus/src/lib.rs

@@ -293,13 +293,13 @@ pub trait IsFocused {
 ///
 /// When working with the entire [`World`], consider using the [`IsFocused`] instead.
 #[derive(SystemParam)]
-pub struct IsFocusedHelper<'w, 's> {
-    parent_query: Query<'w, 's, &'static ChildOf>,
+pub struct IsFocusedHelper<'w> {
+    parent_query: Query<'w, 'w, &'static ChildOf>,
     input_focus: Option<Res<'w, InputFocus>>,
     input_focus_visible: Option<Res<'w, InputFocusVisible>>,
 }
 
-impl IsFocused for IsFocusedHelper<'_, '_> {
+impl IsFocused for IsFocusedHelper<'_> {
     fn is_focused(&self, entity: Entity) -> bool {
         self.input_focus
             .as_deref()

crates/bevy_input_focus/src/tab_navigation.rs

@@ -150,21 +150,21 @@ pub enum TabNavigationError {
 /// An injectable helper object that provides tab navigation functionality.
 #[doc(hidden)]
 #[derive(SystemParam)]
-pub struct TabNavigation<'w, 's> {
+pub struct TabNavigation<'w> {
     // Query for tab groups.
-    tabgroup_query: Query<'w, 's, (Entity, &'static TabGroup, &'static Children)>,
+    tabgroup_query: Query<'w, 'w, (Entity, &'static TabGroup, &'static Children)>,
     // Query for tab indices.
     tabindex_query: Query<
         'w,
-        's,
+        'w,
         (Entity, Option<&'static TabIndex>, Option<&'static Children>),
         Without<TabGroup>,
     >,
     // Query for parents.
-    parent_query: Query<'w, 's, &'static ChildOf>,
+    parent_query: Query<'w, 'w, &'static ChildOf>,
 }
 
-impl TabNavigation<'_, '_> {
+impl TabNavigation<'_> {
     /// Navigate to the desired focusable entity.
     ///
     /// Change the [`NavAction`] to navigate in a different direction.

crates/bevy_picking/src/mesh_picking/ray_cast/mod.rs

@@ -179,7 +179,7 @@ pub struct MeshRayCast<'w, 's> {
     #[doc(hidden)]
     pub culling_query: Query<
         'w,
-        's,
+        'w,
         (
             Read<InheritedVisibility>,
             Read<ViewVisibility>,
@@ -192,7 +192,7 @@ pub struct MeshRayCast<'w, 's> {
     #[doc(hidden)]
     pub mesh_query: Query<
         'w,
-        's,
+        'w,
         (
             Option<Read<Mesh2d>>,
             Option<Read<Mesh3d>>,

crates/bevy_text/src/text2d.rs

@@ -131,7 +131,7 @@ impl From<String> for Text2d {
 pub type Text2dReader<'w, 's> = TextReader<'w, 's, Text2d>;
 
 /// 2d alias for [`TextWriter`].
-pub type Text2dWriter<'w, 's> = TextWriter<'w, 's, Text2d>;
+pub type Text2dWriter<'w> = TextWriter<'w, Text2d>;
 
 /// This system extracts the sprites from the 2D text components and adds them to the
 /// "render world".