Remove 's lifetime from WorldQuery::Fetch (#19720)

# Objective

Unblock #18162.

#15396 added the `'s` lifetime to `QueryData::Item` to make it possible
for query items to borrow from the state. The state isn't passed
directly to `QueryData::fetch()`, so it also added the `'s` lifetime to
`WorldQuery::Fetch` so that we can pass the borrows through there.

Unfortunately, having `WorldQuery::Fetch` borrow from the state makes it
impossible to have owned state, because we store the state and the
`Fetch` in the same `struct` during iteration.

## Solution

Undo the change to add the `'s` lifetime to `WorldQuery::Fetch`.

Instead, add a `&'s Self::State` parameter to `QueryData::fetch()` and
`QueryFilter::filter_fetch()` so that borrows from the state can be
passed directly to query items.

---------

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
Co-authored-by: Emerson Coskey <emerson@coskey.dev>

Author: 3 people

crates/bevy_asset/src/asset_changed.rs

@@ -150,13 +150,11 @@ pub struct AssetChangedState<A: AsAssetId> {
 #[expect(unsafe_code, reason = "WorldQuery is an unsafe trait.")]
 /// SAFETY: `ROQueryFetch<Self>` is the same as `QueryFetch<Self>`
 unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
-    type Fetch<'w, 's> = AssetChangedFetch<'w, A>;
+    type Fetch<'w> = AssetChangedFetch<'w, A>;
 
     type State = AssetChangedState<A>;
 
-    fn shrink_fetch<'wlong: 'wshort, 'wshort, 's>(
-        fetch: Self::Fetch<'wlong, 's>,
-    ) -> Self::Fetch<'wshort, 's> {
+    fn shrink_fetch<'wlong: 'wshort, 'wshort>(fetch: Self::Fetch<'wlong>) -> Self::Fetch<'wshort> {
         fetch
     }
 
@@ -165,7 +163,7 @@ unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
         state: &'s Self::State,
         last_run: Tick,
         this_run: Tick,
-    ) -> Self::Fetch<'w, 's> {
+    ) -> Self::Fetch<'w> {
         // SAFETY:
         // - `AssetChanges` is private and only accessed mutably in the `AssetEventSystems` system set.
         // - `resource_id` was obtained from the type ID of `AssetChanges<A::Asset>`.
@@ -204,7 +202,7 @@ unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
     const IS_DENSE: bool = <&A>::IS_DENSE;
 
     unsafe fn set_archetype<'w, 's>(
-        fetch: &mut Self::Fetch<'w, 's>,
+        fetch: &mut Self::Fetch<'w>,
         state: &'s Self::State,
         archetype: &'w Archetype,
         table: &'w Table,
@@ -218,7 +216,7 @@ unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
     }
 
     unsafe fn set_table<'w, 's>(
-        fetch: &mut Self::Fetch<'w, 's>,
+        fetch: &mut Self::Fetch<'w>,
         state: &Self::State,
         table: &'w Table,
     ) {
@@ -271,14 +269,15 @@ unsafe impl<A: AsAssetId> QueryFilter for AssetChanged<A> {
 
     #[inline]
     unsafe fn filter_fetch(
-        fetch: &mut Self::Fetch<'_, '_>,
+        state: &Self::State,
+        fetch: &mut Self::Fetch<'_>,
         entity: Entity,
         table_row: TableRow,
     ) -> bool {
         fetch.inner.as_mut().is_some_and(|inner| {
             // SAFETY: We delegate to the inner `fetch` for `A`
             unsafe {
-                let handle = <&A>::fetch(inner, entity, table_row);
+                let handle = <&A>::fetch(&state.asset_id, inner, entity, table_row);
                 fetch.check.has_changed(handle)
             }
         })

crates/bevy_ecs/macros/src/query_data.rs

@@ -74,13 +74,23 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
     let user_generics = ast.generics.clone();
     let (user_impl_generics, user_ty_generics, user_where_clauses) = user_generics.split_for_impl();
     let user_generics_with_world = {
-        let mut generics = ast.generics;
+        let mut generics = ast.generics.clone();
         generics.params.insert(0, parse_quote!('__w));
-        generics.params.insert(0, parse_quote!('__s));
         generics
     };
     let (user_impl_generics_with_world, user_ty_generics_with_world, user_where_clauses_with_world) =
         user_generics_with_world.split_for_impl();
+    let user_generics_with_world_and_state = {
+        let mut generics = ast.generics;
+        generics.params.insert(0, parse_quote!('__w));
+        generics.params.insert(0, parse_quote!('__s));
+        generics
+    };
+    let (
+        user_impl_generics_with_world_and_state,
+        user_ty_generics_with_world_and_state,
+        user_where_clauses_with_world_and_state,
+    ) = user_generics_with_world_and_state.split_for_impl();
 
     let struct_name = ast.ident;
     let read_only_struct_name = if attributes.is_mutable {
@@ -165,13 +175,13 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
         &visibility,
         &item_struct_name,
         &field_types,
-        &user_impl_generics_with_world,
+        &user_impl_generics_with_world_and_state,
         &field_attrs,
         &field_visibilities,
         &field_idents,
         &user_ty_generics,
-        &user_ty_generics_with_world,
-        user_where_clauses_with_world,
+        &user_ty_generics_with_world_and_state,
+        user_where_clauses_with_world_and_state,
     );
     let mutable_world_query_impl = world_query_impl(
         &path,
@@ -200,13 +210,13 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
             &visibility,
             &read_only_item_struct_name,
             &read_only_field_types,
-            &user_impl_generics_with_world,
+            &user_impl_generics_with_world_and_state,
             &field_attrs,
             &field_visibilities,
             &field_idents,
             &user_ty_generics,
-            &user_ty_generics_with_world,
-            user_where_clauses_with_world,
+            &user_ty_generics_with_world_and_state,
+            user_where_clauses_with_world_and_state,
         );
         let readonly_world_query_impl = world_query_impl(
             &path,
@@ -257,7 +267,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                 for #read_only_struct_name #user_ty_generics #user_where_clauses {
                     const IS_READ_ONLY: bool = true;
                     type ReadOnly = #read_only_struct_name #user_ty_generics;
-                    type Item<'__w, '__s> = #read_only_item_struct_name #user_ty_generics_with_world;
+                    type Item<'__w, '__s> = #read_only_item_struct_name #user_ty_generics_with_world_and_state;
 
                     fn shrink<'__wlong: '__wshort, '__wshort, '__s>(
                         item: Self::Item<'__wlong, '__s>
@@ -280,12 +290,13 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                     /// SAFETY: we call `fetch` for each member that implements `Fetch`.
                     #[inline(always)]
                     unsafe fn fetch<'__w, '__s>(
-                        _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+                        _state: &'__s Self::State,
+                        _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                         _entity: #path::entity::Entity,
                         _table_row: #path::storage::TableRow,
                     ) -> Self::Item<'__w, '__s> {
                         Self::Item {
-                            #(#field_idents: <#read_only_field_types>::fetch(&mut _fetch.#named_field_idents, _entity, _table_row),)*
+                            #(#field_idents: <#read_only_field_types>::fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row),)*
                         }
                     }
                 }
@@ -314,7 +325,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
             for #struct_name #user_ty_generics #user_where_clauses {
                 const IS_READ_ONLY: bool = #is_read_only;
                 type ReadOnly = #read_only_struct_name #user_ty_generics;
-                type Item<'__w, '__s> = #item_struct_name #user_ty_generics_with_world;
+                type Item<'__w, '__s> = #item_struct_name #user_ty_generics_with_world_and_state;
 
                 fn shrink<'__wlong: '__wshort, '__wshort, '__s>(
                     item: Self::Item<'__wlong, '__s>
@@ -337,12 +348,13 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                 /// SAFETY: we call `fetch` for each member that implements `Fetch`.
                 #[inline(always)]
                 unsafe fn fetch<'__w, '__s>(
-                    _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+                    _state: &'__s Self::State,
+                    _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                     _entity: #path::entity::Entity,
                     _table_row: #path::storage::TableRow,
                 ) -> Self::Item<'__w, '__s> {
                     Self::Item {
-                        #(#field_idents: <#field_types>::fetch(&mut _fetch.#named_field_idents, _entity, _table_row),)*
+                        #(#field_idents: <#field_types>::fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row),)*
                     }
                 }
             }

crates/bevy_ecs/macros/src/query_filter.rs

@@ -23,7 +23,6 @@ pub fn derive_query_filter_impl(input: TokenStream) -> TokenStream {
     let user_generics_with_world = {
         let mut generics = ast.generics;
         generics.params.insert(0, parse_quote!('__w));
-        generics.params.insert(0, parse_quote!('__s));
         generics
     };
     let (user_impl_generics_with_world, user_ty_generics_with_world, user_where_clauses_with_world) =
@@ -102,12 +101,13 @@ pub fn derive_query_filter_impl(input: TokenStream) -> TokenStream {
 
             #[allow(unused_variables)]
             #[inline(always)]
-            unsafe fn filter_fetch<'__w, '__s>(
-                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+            unsafe fn filter_fetch<'__w>(
+                _state: &Self::State,
+                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                 _entity: #path::entity::Entity,
                 _table_row: #path::storage::TableRow,
             ) -> bool {
-                true #(&& <#field_types>::filter_fetch(&mut _fetch.#named_field_idents, _entity, _table_row))*
+                true #(&& <#field_types>::filter_fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row))*
             }
         }
     };

crates/bevy_ecs/macros/src/world_query.rs

@@ -10,13 +10,13 @@ pub(crate) fn item_struct(
     visibility: &Visibility,
     item_struct_name: &Ident,
     field_types: &Vec<proc_macro2::TokenStream>,
-    user_impl_generics_with_world: &ImplGenerics,
+    user_impl_generics_with_world_and_state: &ImplGenerics,
     field_attrs: &Vec<Vec<Attribute>>,
     field_visibilities: &Vec<Visibility>,
     field_idents: &Vec<proc_macro2::TokenStream>,
     user_ty_generics: &TypeGenerics,
-    user_ty_generics_with_world: &TypeGenerics,
-    user_where_clauses_with_world: Option<&WhereClause>,
+    user_ty_generics_with_world_and_state: &TypeGenerics,
+    user_where_clauses_with_world_and_state: Option<&WhereClause>,
 ) -> proc_macro2::TokenStream {
     let item_attrs = quote! {
         #[doc = concat!(
@@ -33,20 +33,20 @@ pub(crate) fn item_struct(
         Fields::Named(_) => quote! {
             #derive_macro_call
             #item_attrs
-            #visibility struct #item_struct_name #user_impl_generics_with_world #user_where_clauses_with_world {
+            #visibility struct #item_struct_name #user_impl_generics_with_world_and_state #user_where_clauses_with_world_and_state {
                 #(#(#field_attrs)* #field_visibilities #field_idents: <#field_types as #path::query::QueryData>::Item<'__w, '__s>,)*
             }
         },
         Fields::Unnamed(_) => quote! {
             #derive_macro_call
             #item_attrs
-            #visibility struct #item_struct_name #user_impl_generics_with_world #user_where_clauses_with_world(
+            #visibility struct #item_struct_name #user_impl_generics_with_world_and_state #user_where_clauses_with_world_and_state(
                 #( #field_visibilities <#field_types as #path::query::QueryData>::Item<'__w, '__s>, )*
             );
         },
         Fields::Unit => quote! {
             #item_attrs
-            #visibility type #item_struct_name #user_ty_generics_with_world = #struct_name #user_ty_generics;
+            #visibility type #item_struct_name #user_ty_generics_with_world_and_state = #struct_name #user_ty_generics;
         },
     }
 }
@@ -78,16 +78,16 @@ pub(crate) fn world_query_impl(
         )]
         #[automatically_derived]
         #visibility struct #fetch_struct_name #user_impl_generics_with_world #user_where_clauses_with_world {
-            #(#named_field_idents: <#field_types as #path::query::WorldQuery>::Fetch<'__w, '__s>,)*
-            #marker_name: (&'__w(), &'__s()),
+            #(#named_field_idents: <#field_types as #path::query::WorldQuery>::Fetch<'__w>,)*
+            #marker_name: &'__w(),
         }
 
         impl #user_impl_generics_with_world Clone for #fetch_struct_name #user_ty_generics_with_world
             #user_where_clauses_with_world {
                 fn clone(&self) -> Self {
                     Self {
                         #(#named_field_idents: self.#named_field_idents.clone(),)*
-                        #marker_name: (&(), &()),
+                        #marker_name: &(),
                     }
                 }
             }
@@ -96,17 +96,17 @@ pub(crate) fn world_query_impl(
         unsafe impl #user_impl_generics #path::query::WorldQuery
             for #struct_name #user_ty_generics #user_where_clauses {
 
-            type Fetch<'__w, '__s> = #fetch_struct_name #user_ty_generics_with_world;
+            type Fetch<'__w> = #fetch_struct_name #user_ty_generics_with_world;
             type State = #state_struct_name #user_ty_generics;
 
-            fn shrink_fetch<'__wlong: '__wshort, '__wshort, '__s>(
-                fetch: <#struct_name #user_ty_generics as #path::query::WorldQuery>::Fetch<'__wlong, '__s>
-            ) -> <#struct_name #user_ty_generics as #path::query::WorldQuery>::Fetch<'__wshort, '__s> {
+            fn shrink_fetch<'__wlong: '__wshort, '__wshort>(
+                fetch: <#struct_name #user_ty_generics as #path::query::WorldQuery>::Fetch<'__wlong>
+            ) -> <#struct_name #user_ty_generics as #path::query::WorldQuery>::Fetch<'__wshort> {
                 #fetch_struct_name {
                     #(
                         #named_field_idents: <#field_types>::shrink_fetch(fetch.#named_field_idents),
                     )*
-                    #marker_name: (&(), &()),
+                    #marker_name: &(),
                 }
             }
 
@@ -115,7 +115,7 @@ pub(crate) fn world_query_impl(
                 state: &'__s Self::State,
                 _last_run: #path::component::Tick,
                 _this_run: #path::component::Tick,
-            ) -> <Self as #path::query::WorldQuery>::Fetch<'__w, '__s> {
+            ) -> <Self as #path::query::WorldQuery>::Fetch<'__w> {
                 #fetch_struct_name {
                     #(#named_field_idents:
                         <#field_types>::init_fetch(
@@ -125,7 +125,7 @@ pub(crate) fn world_query_impl(
                             _this_run,
                         ),
                     )*
-                    #marker_name: (&(), &()),
+                    #marker_name: &(),
                 }
             }
 
@@ -134,7 +134,7 @@ pub(crate) fn world_query_impl(
             /// SAFETY: we call `set_archetype` for each member that implements `Fetch`
             #[inline]
             unsafe fn set_archetype<'__w, '__s>(
-                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                 _state: &'__s Self::State,
                 _archetype: &'__w #path::archetype::Archetype,
                 _table: &'__w #path::storage::Table
@@ -145,7 +145,7 @@ pub(crate) fn world_query_impl(
             /// SAFETY: we call `set_table` for each member that implements `Fetch`
             #[inline]
             unsafe fn set_table<'__w, '__s>(
-                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                 _state: &'__s Self::State,
                 _table: &'__w #path::storage::Table
             ) {