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

crates/bevy_core/src/name.rs

@@ -131,7 +131,7 @@ pub struct NameOrEntity {
     pub entity: Entity,
 }
 
-impl<'a> std::fmt::Display for NameOrEntityItem<'a> {
+impl<'w, 's> std::fmt::Display for NameOrEntityItem<'w, 's> {
     #[inline(always)]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self.name {
@@ -229,9 +229,9 @@ mod tests {
         let e2 = world.spawn(name.clone()).id();
         let mut query = world.query::<NameOrEntity>();
         let d1 = query.get(&world, e1).unwrap();
-        let d2 = query.get(&world, e2).unwrap();
         // NameOrEntity Display for entities without a Name should be {index}v{generation}
         assert_eq!(d1.to_string(), "0v1");
+        let d2 = query.get(&world, e2).unwrap();
         // NameOrEntity Display for entities with a Name should be the Name
         assert_eq!(d2.to_string(), "MyName");
     }

crates/bevy_core_pipeline/src/bloom/settings.rs

@@ -218,7 +218,7 @@ impl ExtractComponent for Bloom {
     type QueryFilter = ();
     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

@@ -30,7 +30,7 @@ impl ViewNode for MainOpaquePass2dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (camera, target, depth): QueryItem<'w, Self::ViewQuery>,
+        (camera, 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

@@ -27,7 +27,7 @@ impl ViewNode for MainTransparentPass2dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (camera, target, depth): bevy_ecs::query::QueryItem<'w, Self::ViewQuery>,
+        (camera, 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

@@ -37,7 +37,11 @@ impl ViewNode for DeferredGBufferPrepassNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (view, camera, view_depth_texture, view_prepass_textures): QueryItem<'w, Self::ViewQuery>,
+        (view, camera, view_depth_texture, view_prepass_textures): QueryItem<
+            'w,
+            '_,
+            Self::ViewQuery,
+        >,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let (Some(opaque_deferred_phases), Some(alpha_mask_deferred_phases)) = (

crates/bevy_core_pipeline/src/dof/mod.rs

@@ -348,7 +348,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

@@ -63,7 +63,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

@@ -360,7 +360,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>();
@@ -493,7 +493,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

@@ -53,7 +53,7 @@ impl ViewNode for PrepassNode {
             skybox_prepass_pipeline,
             skybox_prepass_bind_group,
             view_prev_uniform_offset,
-        ): QueryItem<'w, Self::ViewQuery>,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let (Some(opaque_prepass_phases), Some(alpha_mask_prepass_phases)) = (

crates/bevy_core_pipeline/src/skybox/mod.rs

@@ -114,7 +114,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_core_pipeline/src/smaa/mod.rs

@@ -845,7 +845,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_ecs/macros/src/query_data.rs

@@ -95,6 +95,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) =

crates/bevy_ecs/macros/src/query_filter.rs

@@ -26,6 +26,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) =
@@ -127,8 +128,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 {

crates/bevy_ecs/macros/src/world_query.rs

@@ -38,14 +38,14 @@ pub(crate) fn item_struct(
             #derive_macro_call
             #item_attrs
             #visibility struct #item_struct_name #user_impl_generics_with_world #user_where_clauses_with_world {
-                #(#(#field_attrs)* #field_visibilities #field_idents: <#field_types as #path::query::WorldQuery>::Item<'__w>,)*
+                #(#(#field_attrs)* #field_visibilities #field_idents: <#field_types as #path::query::WorldQuery>::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(
-                #( #field_visibilities <#field_types as #path::query::WorldQuery>::Item<'__w>, )*
+                #( #field_visibilities <#field_types as #path::query::WorldQuery>::Item<'__w, '__s>, )*
             );
         },
         Fields::Unit => quote! {
@@ -88,16 +88,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>,)*
-            #marker_name: &'__w (),
+            #(#named_field_idents: <#field_types as #path::query::WorldQuery>::Fetch<'__w, '__s>,)*
+            #marker_name: (&'__w(), &'__s()),
         }
 
         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: (&(), &()),
                     }
                 }
             }
@@ -106,37 +106,37 @@ pub(crate) fn world_query_impl(
         unsafe impl #user_impl_generics #path::query::WorldQuery
             for #struct_name #user_ty_generics #user_where_clauses {
 
-            type Item<'__w> = #item_struct_name #user_ty_generics_with_world;
-            type Fetch<'__w> = #fetch_struct_name #user_ty_generics_with_world;
+            type Item<'__w, '__s> = #item_struct_name #user_ty_generics_with_world;
+            type Fetch<'__w, '__s> = #fetch_struct_name #user_ty_generics_with_world;
             type State = #state_struct_name #user_ty_generics;
 
-            fn shrink<'__wlong: '__wshort, '__wshort>(
-                item: <#struct_name #user_ty_generics as #path::query::WorldQuery>::Item<'__wlong>
-            ) -> <#struct_name #user_ty_generics as #path::query::WorldQuery>::Item<'__wshort> {
+            fn shrink<'__wlong: '__wshort, '__wshort, '__s>(
+                item: <#struct_name #user_ty_generics as #path::query::WorldQuery>::Item<'__wlong, '__s>
+            ) -> <#struct_name #user_ty_generics as #path::query::WorldQuery>::Item<'__wshort, '__s> {
                 #item_struct_name {
                     #(
                         #field_idents: <#field_types>::shrink(item.#field_idents),
                     )*
                 }
             }
 
-            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> {
+            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> {
                 #fetch_struct_name {
                     #(
                         #named_field_idents: <#field_types>::shrink_fetch(fetch.#named_field_idents),
                     )*
-                    #marker_name: &(),
+                    #marker_name: (&(), &()),
                 }
             }
 
-            unsafe fn init_fetch<'__w>(
+            unsafe fn init_fetch<'__w, '__s>(
                 _world: #path::world::unsafe_world_cell::UnsafeWorldCell<'__w>,
-                state: &Self::State,
+                state: &'__s Self::State,
                 _last_run: #path::component::Tick,
                 _this_run: #path::component::Tick,
-            ) -> <Self as #path::query::WorldQuery>::Fetch<'__w> {
+            ) -> <Self as #path::query::WorldQuery>::Fetch<'__w, '__s> {
                 #fetch_struct_name {
                     #(#named_field_idents:
                         <#field_types>::init_fetch(
@@ -146,17 +146,17 @@ pub(crate) fn world_query_impl(
                             _this_run,
                         ),
                     )*
-                    #marker_name: &(),
+                    #marker_name: (&(), &()),
                 }
             }
 
             const IS_DENSE: bool = true #(&& <#field_types>::IS_DENSE)*;
 
             /// SAFETY: we call `set_archetype` for each member that implements `Fetch`
             #[inline]
-            unsafe fn set_archetype<'__w>(
-                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
-                _state: &Self::State,
+            unsafe fn set_archetype<'__w, '__s>(
+                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+                _state: &'__s Self::State,
                 _archetype: &'__w #path::archetype::Archetype,
                 _table: &'__w #path::storage::Table
             ) {
@@ -165,21 +165,21 @@ pub(crate) fn world_query_impl(
 
             /// SAFETY: we call `set_table` for each member that implements `Fetch`
             #[inline]
-            unsafe fn set_table<'__w>(
-                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
-                _state: &Self::State,
+            unsafe fn set_table<'__w, '__s>(
+                _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w, '__s>,
+                _state: &'__s Self::State,
                 _table: &'__w #path::storage::Table
             ) {
                 #(<#field_types>::set_table(&mut _fetch.#named_field_idents, &_state.#named_field_idents, _table);)*
             }
 
             /// 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 as #path::query::WorldQuery>::Item<'__w> {
+            ) -> <Self as #path::query::WorldQuery>::Item<'__w, '__s> {
                 Self::Item {
                     #(#field_idents: <#field_types>::fetch(&mut _fetch.#named_field_idents, _entity, _table_row),)*
                 }

crates/bevy_ecs/src/observer/mod.rs

@@ -566,7 +566,7 @@ mod tests {
     struct Parent(Entity);
 
     impl Traversal for &'_ Parent {
-        fn traverse(item: Self::Item<'_>) -> Option<Entity> {
+        fn traverse(item: Self::Item<'_, '_>) -> Option<Entity> {
             Some(item.0)
         }
     }