ReborrowSystemParam

fix all impls

Author: ecoskey

crates/bevy_ecs/macros/Cargo.toml

@@ -11,7 +11,7 @@ proc-macro = true
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.18.0-dev" }
 
-syn = { version = "2.0.108", features = ["full", "extra-traits"] }
+syn = { version = "2.0.108", features = ["full", "extra-traits", "visit-mut"] }
 quote = "1.0"
 proc-macro2 = "1.0"
 [lints]

crates/bevy_ecs/macros/src/lib.rs

@@ -20,8 +20,8 @@ use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::{format_ident, quote, ToTokens};
 use syn::{
-    parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, ConstParam, Data,
-    DeriveInput, GenericParam, TypeParam,
+    parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, visit_mut::VisitMut,
+    ConstParam, Data, DeriveInput, GenericParam, TypeParam,
 };
 
 enum BundleFieldKind {
@@ -229,6 +229,16 @@ pub fn derive_map_entities(input: TokenStream) -> TokenStream {
     })
 }
 
+struct LifetimeEraser {
+    erased_ident: Ident,
+}
+
+impl VisitMut for LifetimeEraser {
+    fn visit_lifetime_mut(&mut self, i: &mut syn::Lifetime) {
+        i.ident = self.erased_ident.clone();
+    }
+}
+
 /// Implement `SystemParam` to use a struct as a parameter in a system
 #[proc_macro_derive(SystemParam, attributes(system_param))]
 pub fn derive_system_param(input: TokenStream) -> TokenStream {
@@ -240,6 +250,7 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
         Err(e) => e.into_compile_error().into(),
     }
 }
+
 fn derive_system_param_impl(
     token_stream: TokenStream,
     ast: DeriveInput,
@@ -253,6 +264,17 @@ fn derive_system_param_impl(
         .collect::<Vec<_>>();
     let field_members = fields.members().collect::<Vec<_>>();
     let field_types = fields.iter().map(|f| &f.ty).collect::<Vec<_>>();
+    let shadowed_lifetime_field_types = fields
+        .iter()
+        .map(|f| {
+            let mut ty = f.ty.clone();
+            let mut eraser = LifetimeEraser {
+                erased_ident: format_ident!("static"),
+            };
+            syn::visit_mut::visit_type_mut(&mut eraser, &mut ty);
+            ty
+        })
+        .collect::<Vec<_>>();
 
     let field_validation_names = fields.members().map(|m| format!("::{}", quote! { #m }));
     let mut field_validation_messages = Vec::with_capacity(fields.len());
@@ -356,6 +378,18 @@ fn derive_system_param_impl(
             .push(syn::parse_quote!(#field_type: #path::system::ReadOnlySystemParam));
     }
 
+    // Create a where clause for the `ReborrowSystemParam` impl.
+    // Ensure that each field implements `ReborrowSystemParam`.
+    let mut reborrow_generics = generics.clone();
+    let reborrow_where_clause = reborrow_generics.make_where_clause();
+    for (shadowed_lifetime_field_type, field_type) in
+        shadowed_lifetime_field_types.iter().zip(&field_types)
+    {
+        reborrow_where_clause
+            .predicates
+            .push(syn::parse_quote!(for<'w, 's> #shadowed_lifetime_field_type: #path::system::ReborrowSystemParam<Item<'w, 's> = #field_type>));
+    }
+
     let fields_alias =
         ensure_no_collision(format_ident!("__StructFieldsAlias"), token_stream.clone());
 
@@ -482,6 +516,19 @@ fn derive_system_param_impl(
             // Safety: Each field is `ReadOnlySystemParam`, so this can only read from the `World`
             unsafe impl<'w, 's, #punctuated_generics> #path::system::ReadOnlySystemParam for #struct_name #ty_generics #read_only_where_clause {}
 
+            impl<#punctuated_generics> #path::system::ReborrowSystemParam for #struct_name <#(#shadowed_lifetimes,)* #punctuated_generic_idents> #reborrow_where_clause {
+                fn reborrow<'wlong: 'short, 'slong: 'short, 'short>(
+                    item: &'short mut Self::Item<'wlong, 'slong>,
+                ) -> Self::Item<'short, 'short> {
+                    #(
+                        let #field_locals = <#shadowed_lifetime_field_types as #path::system::ReborrowSystemParam>::reborrow(&mut item.#field_members);
+                    )*
+                    #struct_name {
+                        #(#field_members: #field_locals,)*
+                    }
+                }
+            }
+
             #builder_impl
         };
 

crates/bevy_ecs/src/change_detection/params.rs

@@ -123,6 +123,21 @@ impl<'w, T: Resource> Res<'w, T> {
     pub fn into_inner(self) -> &'w T {
         self.value
     }
+
+    /// Returns a `Res<>` with a smaller lifetime.
+    /// This is useful if you have `&Res`, but you need a `Res`.
+    pub fn reborrow(&self) -> Res<'_, T> {
+        Res {
+            value: self.value,
+            ticks: ComponentTicksRef {
+                added: self.ticks.added,
+                changed: self.ticks.changed,
+                changed_by: self.ticks.changed_by,
+                last_run: self.ticks.last_run,
+                this_run: self.ticks.this_run,
+            },
+        }
+    }
 }
 
 impl<'w, T: Resource> From<ResMut<'w, T>> for Res<'w, T> {
@@ -243,6 +258,23 @@ impl<'w, T> From<NonSendMut<'w, T>> for NonSend<'w, T> {
     }
 }
 
+impl<'w, T> NonSend<'w, T> {
+    /// Returns a `NonSend<>` with a smaller lifetime.
+    /// This is useful if you have `&NonSend<T>`, but you need a `NonSend<T>`.
+    pub fn reborrow(&mut self) -> NonSend<'_, T> {
+        NonSend {
+            value: self.value,
+            ticks: ComponentTicksRef {
+                added: self.ticks.added,
+                changed: self.ticks.changed,
+                changed_by: self.ticks.changed_by,
+                last_run: self.ticks.last_run,
+                this_run: self.ticks.this_run,
+            },
+        }
+    }
+}
+
 /// Unique borrow of a non-[`Send`] resource.
 ///
 /// Only [`Send`] resources may be accessed with the [`ResMut`] [`SystemParam`](crate::system::SystemParam). In case that the

crates/bevy_ecs/src/change_detection/traits.rs

@@ -449,12 +449,16 @@ macro_rules! impl_methods {
                 self.value
             }
 
-            /// Returns a `Mut<>` with a smaller lifetime.
+            /// Returns a `
+            #[doc = stringify!($name)]
+            /// <>` with a smaller lifetime.
             /// This is useful if you have `&mut
             #[doc = stringify!($name)]
-            /// <T>`, but you need a `Mut<T>`.
-            pub fn reborrow(&mut self) -> Mut<'_, $target> {
-                Mut {
+            /// <T>`, but you need a `
+            #[doc = stringify!($name)]
+            /// <T>`.
+            pub fn reborrow(&mut self) -> $name<'_, $target> {
+                $name {
                     value: self.value,
                     ticks: ComponentTicksMut {
                         added: self.ticks.added,

crates/bevy_ecs/src/lifecycle.rs

@@ -60,7 +60,7 @@ use crate::{
     query::FilteredAccessSet,
     relationship::RelationshipHookMode,
     storage::SparseSet,
-    system::{Local, ReadOnlySystemParam, SystemMeta, SystemParam},
+    system::{Local, ReadOnlySystemParam, ReborrowSystemParam, SystemMeta, SystemParam},
     world::{unsafe_world_cell::UnsafeWorldCell, DeferredWorld, World},
 };
 
@@ -641,3 +641,11 @@ unsafe impl<'a> SystemParam for &'a RemovedComponentMessages {
         world.removed_components()
     }
 }
+
+impl<'a> ReborrowSystemParam for &'a RemovedComponentMessages {
+    fn reborrow<'wlong: 'short, 'slong: 'short, 'short>(
+        item: &'short mut Self::Item<'wlong, 'slong>,
+    ) -> Self::Item<'short, 'short> {
+        *item
+    }
+}

crates/bevy_ecs/src/system/commands/mod.rs

@@ -30,8 +30,8 @@ use crate::{
     resource::Resource,
     schedule::ScheduleLabel,
     system::{
-        Deferred, IntoObserverSystem, IntoSystem, RegisteredSystem, SystemId, SystemInput,
-        SystemParamValidationError,
+        Deferred, IntoObserverSystem, IntoSystem, ReborrowSystemParam, RegisteredSystem, SystemId,
+        SystemInput, SystemParamValidationError,
     },
     world::{
         command_queue::RawCommandQueue, unsafe_world_cell::UnsafeWorldCell, CommandQueue,
@@ -216,6 +216,14 @@ const _: () = {
         &'w Entities: bevy_ecs::system::ReadOnlySystemParam,
     {
     }
+
+    impl<'w, 's> ReborrowSystemParam for Commands<'w, 's> {
+        fn reborrow<'wlong: 'short, 'slong: 'short, 'short>(
+            item: &'short mut Self::Item<'wlong, 'slong>,
+        ) -> Self::Item<'short, 'short> {
+            item.reborrow()
+        }
+    }
 };
 
 enum InternalQueue<'s> {

crates/bevy_ecs/src/system/query.rs

@@ -8,6 +8,7 @@ use crate::{
         DebugCheckedUnwrap, NopWorldQuery, QueryCombinationIter, QueryData, QueryEntityError,
         QueryFilter, QueryIter, QueryManyIter, QueryManyUniqueIter, QueryParIter, QueryParManyIter,
         QueryParManyUniqueIter, QuerySingleError, QueryState, ROQueryItem, ReadOnlyQueryData,
+        ReborrowQueryData,
     },
     world::unsafe_world_cell::UnsafeWorldCell,
 };
@@ -2674,6 +2675,18 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Single<'w, 's, D, F> {
     pub fn into_inner(self) -> D::Item<'w, 's> {
         self.item
     }
+
+    /// Returns a `Single<>` with a smaller lifetime.
+    /// This is useful if you have `&Single`, but you need an `Single`.
+    pub fn reborrow(&mut self) -> Single<'_, '_, D, F>
+    where
+        D: ReborrowQueryData,
+    {
+        Single {
+            item: D::reborrow(&mut self.item),
+            _filter: PhantomData,
+        }
+    }
 }
 
 /// [System parameter] that works very much like [`Query`] except it always contains at least one matching entity.
@@ -2710,6 +2723,12 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Populated<'w, 's, D, F> {
     pub fn into_inner(self) -> Query<'w, 's, D, F> {
         self.0
     }
+
+    /// Returns a `Populated<>` with a smaller lifetime.
+    /// This is useful if you have `&Populated`, but you need a `Populated`.
+    pub fn reborrow(&mut self) -> Populated<'_, '_, D, F> {
+        Populated(self.0.reborrow())
+    }
 }
 
 impl<'w, 's, D: QueryData, F: QueryFilter> IntoIterator for Populated<'w, 's, D, F> {

crates/bevy_ecs/src/system/system_name.rs

@@ -2,7 +2,9 @@ use crate::{
     change_detection::Tick,
     prelude::World,
     query::FilteredAccessSet,
-    system::{ExclusiveSystemParam, ReadOnlySystemParam, SystemMeta, SystemParam},
+    system::{
+        ExclusiveSystemParam, ReadOnlySystemParam, ReborrowSystemParam, SystemMeta, SystemParam,
+    },
     world::unsafe_world_cell::UnsafeWorldCell,
 };
 use bevy_utils::prelude::DebugName;
@@ -34,7 +36,7 @@ use derive_more::derive::{Display, Into};
 ///     logger.log("Hello");
 /// }
 /// ```
-#[derive(Debug, Into, Display)]
+#[derive(Debug, Into, Display, Clone)]
 pub struct SystemName(DebugName);
 
 impl SystemName {
@@ -70,6 +72,14 @@ unsafe impl SystemParam for SystemName {
     }
 }
 
+impl ReborrowSystemParam for SystemName {
+    fn reborrow<'wlong: 'short, 'slong: 'short, 'short>(
+        item: &'short mut Self::Item<'wlong, 'slong>,
+    ) -> Self::Item<'short, 'short> {
+        item.clone()
+    }
+}
+
 // SAFETY: Only reads internal system state
 unsafe impl ReadOnlySystemParam for SystemName {}