Let query items borrow from query state to avoid needing to clone

crates/bevy_anti_aliasing/src/smaa/mod.rs

@@ -847,7 +847,7 @@ impl ViewNode for SmaaNode {
             view_smaa_uniform_offset,
             smaa_textures,
             view_smaa_bind_groups,
-        ): QueryItem<'w, Self::ViewQuery>,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let pipeline_cache = world.resource::<PipelineCache>();

crates/bevy_asset/src/asset_changed.rs

@@ -150,20 +150,22 @@ 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> = AssetChangedFetch<'w, A>;
+    type Fetch<'w, 's> = AssetChangedFetch<'w, A>;
 
     type State = AssetChangedState<A>;
 
-    fn shrink_fetch<'wlong: 'wshort, 'wshort>(fetch: Self::Fetch<'wlong>) -> Self::Fetch<'wshort> {
+    fn shrink_fetch<'wlong: 'wshort, 'wshort, 's>(
+        fetch: Self::Fetch<'wlong, 's>,
+    ) -> Self::Fetch<'wshort, 's> {
         fetch
     }
 
-    unsafe fn init_fetch<'w>(
+    unsafe fn init_fetch<'w, 's>(
         world: UnsafeWorldCell<'w>,
-        state: &Self::State,
+        state: &'s Self::State,
         last_run: Tick,
         this_run: Tick,
-    ) -> Self::Fetch<'w> {
+    ) -> Self::Fetch<'w, 's> {
         // 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>`.
@@ -201,9 +203,9 @@ unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
 
     const IS_DENSE: bool = <&A>::IS_DENSE;
 
-    unsafe fn set_archetype<'w>(
-        fetch: &mut Self::Fetch<'w>,
-        state: &Self::State,
+    unsafe fn set_archetype<'w, 's>(
+        fetch: &mut Self::Fetch<'w, 's>,
+        state: &'s Self::State,
         archetype: &'w Archetype,
         table: &'w Table,
     ) {
@@ -215,7 +217,11 @@ unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
         }
     }
 
-    unsafe fn set_table<'w>(fetch: &mut Self::Fetch<'w>, state: &Self::State, table: &'w Table) {
+    unsafe fn set_table<'w, 's>(
+        fetch: &mut Self::Fetch<'w, 's>,
+        state: &Self::State,
+        table: &'w Table,
+    ) {
         if let Some(inner) = &mut fetch.inner {
             // SAFETY: We delegate to the inner `set_table` for `A`
             unsafe {
@@ -265,7 +271,7 @@ unsafe impl<A: AsAssetId> QueryFilter for AssetChanged<A> {
 
     #[inline]
     unsafe fn filter_fetch(
-        fetch: &mut Self::Fetch<'_>,
+        fetch: &mut Self::Fetch<'_, '_>,
         entity: Entity,
         table_row: TableRow,
     ) -> bool {

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -121,7 +121,7 @@ impl ViewNode for BloomNode {
             bloom_settings,
             upsampling_pipeline_ids,
             downsampling_pipeline_ids,
-        ): QueryItem<'w, Self::ViewQuery>,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         if bloom_settings.intensity == 0.0 {

crates/bevy_core_pipeline/src/bloom/settings.rs

@@ -227,7 +227,7 @@ impl ExtractComponent for Bloom {
     type QueryFilter = With<Hdr>;
     type Out = (Self, BloomUniforms);
 
-    fn extract_component((bloom, camera): QueryItem<'_, Self::QueryData>) -> Option<Self::Out> {
+    fn extract_component((bloom, camera): QueryItem<'_, '_, Self::QueryData>) -> Option<Self::Out> {
         match (
             camera.physical_viewport_rect(),
             camera.physical_viewport_size(),

crates/bevy_core_pipeline/src/core_2d/main_opaque_pass_2d_node.rs

@@ -31,7 +31,7 @@ impl ViewNode for MainOpaquePass2dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (camera, view, target, depth): QueryItem<'w, Self::ViewQuery>,
+        (camera, view, target, depth): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let (Some(opaque_phases), Some(alpha_mask_phases)) = (

crates/bevy_core_pipeline/src/core_2d/main_transparent_pass_2d_node.rs

@@ -28,7 +28,7 @@ impl ViewNode for MainTransparentPass2dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (camera, view, target, depth): bevy_ecs::query::QueryItem<'w, Self::ViewQuery>,
+        (camera, view, target, depth): bevy_ecs::query::QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let Some(transparent_phases) =

crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

@@ -45,7 +45,7 @@ impl ViewNode for MainOpaquePass3dNode {
             skybox_pipeline,
             skybox_bind_group,
             view_uniform_offset,
-        ): QueryItem<'w, Self::ViewQuery>,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let (Some(opaque_phases), Some(alpha_mask_phases)) = (

crates/bevy_core_pipeline/src/deferred/node.rs

@@ -36,7 +36,7 @@ impl ViewNode for EarlyDeferredGBufferPrepassNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        view_query: QueryItem<'w, Self::ViewQuery>,
+        view_query: QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         run_deferred_prepass(
@@ -74,7 +74,7 @@ impl ViewNode for LateDeferredGBufferPrepassNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        view_query: QueryItem<'w, Self::ViewQuery>,
+        view_query: QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let (_, _, _, _, occlusion_culling, no_indirect_drawing) = view_query;
@@ -107,6 +107,7 @@ fn run_deferred_prepass<'w>(
     render_context: &mut RenderContext<'w>,
     (camera, extracted_view, view_depth_texture, view_prepass_textures, _, _): QueryItem<
         'w,
+        '_,
         <LateDeferredGBufferPrepassNode as ViewNode>::ViewQuery,
     >,
     is_late: bool,

crates/bevy_core_pipeline/src/dof/mod.rs

@@ -352,7 +352,7 @@ impl ViewNode for DepthOfFieldNode {
             view_bind_group_layouts,
             depth_of_field_uniform_index,
             auxiliary_dof_texture,
-        ): QueryItem<'w, Self::ViewQuery>,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let pipeline_cache = world.resource::<PipelineCache>();

crates/bevy_core_pipeline/src/msaa_writeback.rs

@@ -61,7 +61,7 @@ impl ViewNode for MsaaWritebackNode {
         &self,
         _graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (target, blit_pipeline_id, msaa): QueryItem<'w, Self::ViewQuery>,
+        (target, blit_pipeline_id, msaa): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         if *msaa == Msaa::Off {

crates/bevy_core_pipeline/src/post_process/mod.rs

@@ -352,7 +352,7 @@ impl ViewNode for PostProcessingNode {
         &self,
         _: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (view_target, pipeline_id, chromatic_aberration, post_processing_uniform_buffer_offsets): QueryItem<'w, Self::ViewQuery>,
+        (view_target, pipeline_id, chromatic_aberration, post_processing_uniform_buffer_offsets): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let pipeline_cache = world.resource::<PipelineCache>();
@@ -485,7 +485,7 @@ impl ExtractComponent for ChromaticAberration {
     type Out = ChromaticAberration;
 
     fn extract_component(
-        chromatic_aberration: QueryItem<'_, Self::QueryData>,
+        chromatic_aberration: QueryItem<'_, '_, Self::QueryData>,
     ) -> Option<Self::Out> {
         // Skip the postprocessing phase entirely if the intensity is zero.
         if chromatic_aberration.intensity > 0.0 {

crates/bevy_core_pipeline/src/prepass/node.rs

@@ -36,7 +36,7 @@ impl ViewNode for EarlyPrepassNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        view_query: QueryItem<'w, Self::ViewQuery>,
+        view_query: QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         run_prepass(graph, render_context, view_query, world, "early prepass")
@@ -73,7 +73,7 @@ impl ViewNode for LatePrepassNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        query: QueryItem<'w, Self::ViewQuery>,
+        query: QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         // We only need a late prepass if we have occlusion culling and indirect
@@ -112,7 +112,7 @@ fn run_prepass<'w>(
         _,
         _,
         has_deferred,
-    ): QueryItem<'w, <LatePrepassNode as ViewNode>::ViewQuery>,
+    ): QueryItem<'w, '_, <LatePrepassNode as ViewNode>::ViewQuery>,
     world: &'w World,
     label: &'static str,
 ) -> Result<(), NodeRunError> {

crates/bevy_core_pipeline/src/skybox/mod.rs

@@ -113,7 +113,9 @@ impl ExtractComponent for Skybox {
     type QueryFilter = ();
     type Out = (Self, SkyboxUniforms);
 
-    fn extract_component((skybox, exposure): QueryItem<'_, Self::QueryData>) -> Option<Self::Out> {
+    fn extract_component(
+        (skybox, exposure): QueryItem<'_, '_, Self::QueryData>,
+    ) -> Option<Self::Out> {
         let exposure = exposure
             .map(Exposure::exposure)
             .unwrap_or_else(|| Exposure::default().exposure());

crates/bevy_ecs/macros/src/query_data.rs

@@ -76,6 +76,7 @@ pub fn derive_query_data_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) =
@@ -256,11 +257,11 @@ 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> = #read_only_item_struct_name #user_ty_generics_with_world;
+                    type Item<'__w, '__s> = #read_only_item_struct_name #user_ty_generics_with_world;
 
-                    fn shrink<'__wlong: '__wshort, '__wshort>(
-                        item: Self::Item<'__wlong>
-                    ) -> Self::Item<'__wshort> {
+                    fn shrink<'__wlong: '__wshort, '__wshort, '__s>(
+                        item: Self::Item<'__wlong, '__s>
+                    ) -> Self::Item<'__wshort, '__s> {
                         #read_only_item_struct_name {
                             #(
                                 #field_idents: <#read_only_field_types>::shrink(item.#field_idents),
@@ -278,16 +279,28 @@ 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>(
-                        _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
+                    unsafe fn fetch<'__w, '__s>(
+                        _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
                         _entity: #path::entity::Entity,
                         _table_row: #path::storage::TableRow,
-                    ) -> Self::Item<'__w> {
+                    ) -> Self::Item<'__w, '__s> {
                         Self::Item {
                             #(#field_idents: <#read_only_field_types>::fetch(&mut _fetch.#named_field_idents, _entity, _table_row),)*
                         }
                     }
                 }
+
+                impl #user_impl_generics #path::query::ReleaseStateQueryData
+                for #read_only_struct_name #user_ty_generics #user_where_clauses
+                // Make these HRTBs with an unused lifetime parameter to allow trivial constraints
+                // See https://github.com/rust-lang/rust/issues/48214
+                where #(for<'__a> #field_types: #path::query::QueryData<ReadOnly: #path::query::ReleaseStateQueryData>,)* {
+                    fn release_state<'__w>(_item: Self::Item<'__w, '_>) -> Self::Item<'__w, 'static> {
+                        Self::Item {
+                            #(#field_idents: <#read_only_field_types>::release_state(_item.#field_idents),)*
+                        }
+                    }
+                }
             }
         } else {
             quote! {}
@@ -301,11 +314,11 @@ 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> = #item_struct_name #user_ty_generics_with_world;
+                type Item<'__w, '__s> = #item_struct_name #user_ty_generics_with_world;
 
-                fn shrink<'__wlong: '__wshort, '__wshort>(
-                    item: Self::Item<'__wlong>
-                ) -> Self::Item<'__wshort> {
+                fn shrink<'__wlong: '__wshort, '__wshort, '__s>(
+                    item: Self::Item<'__wlong, '__s>
+                ) -> Self::Item<'__wshort, '__s> {
                     #item_struct_name {
                         #(
                             #field_idents: <#field_types>::shrink(item.#field_idents),
@@ -323,17 +336,29 @@ 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>(
-                    _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
+                unsafe fn fetch<'__w, '__s>(
+                    _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
                     _entity: #path::entity::Entity,
                     _table_row: #path::storage::TableRow,
-                ) -> Self::Item<'__w> {
+                ) -> Self::Item<'__w, '__s> {
                     Self::Item {
                         #(#field_idents: <#field_types>::fetch(&mut _fetch.#named_field_idents, _entity, _table_row),)*
                     }
                 }
             }
 
+            impl #user_impl_generics #path::query::ReleaseStateQueryData
+            for #struct_name #user_ty_generics #user_where_clauses
+            // Make these HRTBs with an unused lifetime parameter to allow trivial constraints
+            // See https://github.com/rust-lang/rust/issues/48214
+            where #(for<'__a> #field_types: #path::query::ReleaseStateQueryData,)* {
+                fn release_state<'__w>(_item: Self::Item<'__w, '_>) -> Self::Item<'__w, 'static> {
+                    Self::Item {
+                        #(#field_idents: <#field_types>::release_state(_item.#field_idents),)*
+                    }
+                }
+            }
+
             #read_only_data_impl
         }
     };

crates/bevy_ecs/macros/src/query_filter.rs

@@ -23,6 +23,7 @@ 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) =
@@ -101,8 +102,8 @@ pub fn derive_query_filter_impl(input: TokenStream) -> TokenStream {
 
             #[allow(unused_variables)]
             #[inline(always)]
-            unsafe fn filter_fetch<'__w>(
-                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
+            unsafe fn filter_fetch<'__w, '__s>(
+                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
                 _entity: #path::entity::Entity,
                 _table_row: #path::storage::TableRow,
             ) -> bool {