[Merged by Bors] - Use lifetimed, type erased pointers in bevy_ecs

crates/bevy_ecs/macros/src/lib.rs

@@ -126,18 +126,17 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
                 self.#field.get_components(&mut func);
             });
             field_from_components.push(quote! {
-                #field: <#field_type as #ecs_path::bundle::Bundle>::from_components(&mut func),
+                #field: <#field_type as #ecs_path::bundle::Bundle>::from_components(ctx, &mut func),
             });
         } else {
             field_component_ids.push(quote! {
                 component_ids.push(components.init_component::<#field_type>(storages));
             });
             field_get_components.push(quote! {
-                func((&mut self.#field as *mut #field_type).cast::<u8>());
-                std::mem::forget(self.#field);
+                #ecs_path::ptr::OwningPtr::make(self.#field, &mut func);
             });
             field_from_components.push(quote! {
-                #field: func().cast::<#field_type>().read(),
+                #field: func(ctx).inner().cast::<#field_type>().read(),
             });
         }
     }
@@ -159,14 +158,17 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             }
 
             #[allow(unused_variables, unused_mut, non_snake_case)]
-            unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
+            unsafe fn from_components<T, F>(ctx: &mut T, mut func: F) -> Self
+            where
+                F: FnMut(&mut T) -> #ecs_path::ptr::OwningPtr<'_>
+            {
                 Self {
                     #(#field_from_components)*
                 }
             }
 
             #[allow(unused_variables, unused_mut, forget_copy, forget_ref)]
-            fn get_components(mut self, mut func: impl FnMut(*mut u8)) {
+            fn get_components(self, mut func: impl FnMut(#ecs_path::ptr::OwningPtr<'_>)) {
                 #(#field_get_components)*
             }
         }
@@ -209,20 +211,20 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
         let query_fn_mut = &query_fn_muts[0..query_count];
         tokens.extend(TokenStream::from(quote! {
             impl<'w, 's, #(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> SystemParam for QuerySet<'w, 's, (#(QueryState<#query, #filter>,)*)>
-                where #(#filter::Fetch: FilterFetch,)*
+                where #(for<'x, 'y> QueryFetch<'x, 'y, #filter>: FilterFetch<'x, 'y>,)*
             {
                 type Fetch = QuerySetState<(#(QueryState<#query, #filter>,)*)>;
             }
 
-            // SAFE: All Queries are constrained to ReadOnlyFetch, so World is only read
+            // SAFE: All Queries are constrained to ReadOnlyQuery, so World is only read
             unsafe impl<#(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> ReadOnlySystemParamFetch for QuerySetState<(#(QueryState<#query, #filter>,)*)>
-            where #(#query::Fetch: ReadOnlyFetch,)* #(#filter::Fetch: FilterFetch,)*
+            where #(#query: ReadOnlyQuery,)* #(for<'x, 'y> QueryFetch<'x, 'y, #filter>: FilterFetch<'x, 'y>,)*
             { }
 
             // SAFE: Relevant query ComponentId and ArchetypeComponentId access is applied to SystemMeta. If any QueryState conflicts
             // with any prior access, a panic will occur.
             unsafe impl<#(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> SystemParamState for QuerySetState<(#(QueryState<#query, #filter>,)*)>
-                where #(#filter::Fetch: FilterFetch,)*
+                where #(for<'x, 'y> QueryFetch<'x, 'y, #filter>: FilterFetch<'x, 'y>,)*
             {
                 type Config = ();
                 fn init(world: &mut World, system_meta: &mut SystemMeta, config: Self::Config) -> Self {
@@ -262,7 +264,7 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
             }
 
             impl<'w, 's, #(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> SystemParamFetch<'w, 's> for QuerySetState<(#(QueryState<#query, #filter>,)*)>
-                where #(#filter::Fetch: FilterFetch,)*
+                where #(for<'x, 'y> QueryFetch<'x, 'y, #filter>: FilterFetch<'x, 'y>,)*
             {
                 type Item = QuerySet<'w, 's, (#(QueryState<#query, #filter>,)*)>;
 
@@ -283,7 +285,7 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
             }
 
             impl<'w, 's, #(#query: WorldQuery,)* #(#filter: WorldQuery,)*> QuerySet<'w, 's, (#(QueryState<#query, #filter>,)*)>
-                where #(#filter::Fetch: FilterFetch,)*
+                where #(for<'x, 'y> QueryFetch<'x, 'y, #filter>: FilterFetch<'x, 'y>,)*
             {
                 #(#query_fn_mut)*
             }

crates/bevy_ecs/src/bundle.rs

@@ -8,6 +8,7 @@ use crate::{
     archetype::{AddBundle, Archetype, ArchetypeId, Archetypes, ComponentStatus},
     component::{Component, ComponentId, ComponentTicks, Components, StorageType},
     entity::{Entities, Entity, EntityLocation},
+    ptr::OwningPtr,
     storage::{SparseSetIndex, SparseSets, Storages, Table},
 };
 use bevy_ecs_macros::all_tuples;
@@ -85,14 +86,15 @@ pub unsafe trait Bundle: Send + Sync + 'static {
     /// # Safety
     /// Caller must return data for each component in the bundle, in the order of this bundle's
     /// Components
-    unsafe fn from_components(func: impl FnMut() -> *mut u8) -> Self
+    unsafe fn from_components<T, F>(ctx: &mut T, func: F) -> Self
     where
+        F: FnMut(&mut T) -> OwningPtr<'_>,
         Self: Sized;
 
     /// Calls `func` on each value, in the order of this bundle's Components. This will
     /// "mem::forget" the bundle fields, so callers are responsible for dropping the fields if
     /// that is desirable.
-    fn get_components(self, func: impl FnMut(*mut u8));
+    fn get_components(self, func: impl FnMut(OwningPtr<'_>));
 }
 
 macro_rules! tuple_impl {
@@ -106,21 +108,23 @@ macro_rules! tuple_impl {
 
             #[allow(unused_variables, unused_mut)]
             #[allow(clippy::unused_unit)]
-            unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
+            unsafe fn from_components<T, F>(ctx: &mut T, mut func: F) -> Self
+            where
+                F: FnMut(&mut T) -> OwningPtr<'_>
+            {
                 #[allow(non_snake_case)]
                 let ($(mut $name,)*) = (
-                    $(func().cast::<$name>(),)*
+                    $(func(ctx).inner().cast::<$name>(),)*
                 );
                 ($($name.read(),)*)
             }
 
             #[allow(unused_variables, unused_mut)]
-            fn get_components(self, mut func: impl FnMut(*mut u8)) {
+            fn get_components(self, mut func: impl FnMut(OwningPtr<'_>)) {
                 #[allow(non_snake_case)]
                 let ($(mut $name,)*) = self;
                 $(
-                    func((&mut $name as *mut $name).cast::<u8>());
-                    std::mem::forget($name);
+                    OwningPtr::make($name, &mut func);
                 )*
             }
         }

crates/bevy_ecs/src/component.rs

@@ -1,6 +1,7 @@
 //! Types for declaring and storing [`Component`]s.
 
 use crate::{
+    ptr::OwningPtr,
     storage::{SparseSetIndex, Storages},
     system::Resource,
 };
@@ -118,7 +119,7 @@ impl ComponentInfo {
     }
 
     #[inline]
-    pub fn drop(&self) -> unsafe fn(*mut u8) {
+    pub fn drop(&self) -> unsafe fn(OwningPtr<'_>) {
         self.descriptor.drop
     }
 
@@ -163,7 +164,6 @@ impl SparseSetIndex for ComponentId {
     }
 }
 
-#[derive(Debug)]
 pub struct ComponentDescriptor {
     name: String,
     // SAFETY: This must remain private. It must match the statically known StorageType of the
@@ -174,13 +174,25 @@ pub struct ComponentDescriptor {
     is_send_and_sync: bool,
     type_id: Option<TypeId>,
     layout: Layout,
-    drop: unsafe fn(*mut u8),
+    drop: for<'a> unsafe fn(OwningPtr<'a>),
+}
+
+impl std::fmt::Debug for ComponentDescriptor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ComponentDescriptor")
+            .field("name", &self.name)
+            .field("storage_type", &self.storage_type)
+            .field("is_send_and_sync", &self.is_send_and_sync)
+            .field("type_id", &self.type_id)
+            .field("layout", &self.layout)
+            .finish()
+    }
 }
 
 impl ComponentDescriptor {
     // SAFETY: The pointer points to a valid value of type `T` and it is safe to drop this value.
-    unsafe fn drop_ptr<T>(x: *mut u8) {
-        x.cast::<T>().drop_in_place()
+    unsafe fn drop_ptr<T>(x: OwningPtr<'_>) {
+        x.inner().cast::<T>().drop_in_place()
     }
 
     pub fn new<T: Component>() -> Self {

crates/bevy_ecs/src/lib.rs

@@ -4,6 +4,7 @@ pub mod change_detection;
 pub mod component;
 pub mod entity;
 pub mod event;
+pub mod ptr;
 pub mod query;
 #[cfg(feature = "bevy_reflect")]
 pub mod reflect;
@@ -41,6 +42,7 @@ pub mod prelude {
 #[cfg(test)]
 mod tests {
     use crate as bevy_ecs;
+    use crate::query::QueryFetch;
     use crate::{
         bundle::Bundle,
         component::{Component, ComponentId},
@@ -886,7 +888,7 @@ mod tests {
 
         fn get_filtered<F: WorldQuery>(world: &mut World) -> Vec<Entity>
         where
-            F::Fetch: FilterFetch,
+            for<'x, 'y> QueryFetch<'x, 'y, F>: FilterFetch<'x, 'y>,
         {
             world
                 .query_filtered::<Entity, F>()

crates/bevy_ecs/src/ptr.rs

@@ -0,0 +1,149 @@
+use std::{marker::PhantomData, mem::MaybeUninit, ptr::NonNull};
+
+/// Type-erased pointer into memory. Guaranteed to be correctly aligned, non-null and safe to read for a particular type.
+#[derive(Copy, Clone)]
+pub struct Ptr<'a>(NonNull<u8>, PhantomData<&'a u8>);
+
+/// Type-erased pointer into memory. Guaranteed to be correctly aligned, non-null and safe to modify for a particular type.
+pub struct PtrMut<'a>(NonNull<u8>, PhantomData<&'a mut u8>);
+
+/// Type-erased pointer into memory. Guaranteed to be correctly aligned, non-null and safe to move out of for a particular type.
+pub struct OwningPtr<'a>(NonNull<u8>, PhantomData<&'a mut u8>);
+
+pub struct ThinSlicePtr<'a, T> {
+    ptr: NonNull<T>,
+    #[cfg(debug_assertions)]
+    len: usize,
+    _marker: PhantomData<&'a [T]>,
+}
+
+impl<T> Clone for ThinSlicePtr<'_, T> {
+    fn clone(&self) -> Self {
+        Self {
+            ptr: self.ptr,
+            #[cfg(debug_assertions)]
+            len: self.len,
+            _marker: PhantomData,
+        }
+    }
+}
+impl<T> Copy for ThinSlicePtr<'_, T> {}
+
+impl<'a, T> ThinSlicePtr<'a, T> {
+    pub fn new(slice: &'a [T]) -> Self {
+        unsafe {
+            Self {
+                ptr: NonNull::new_unchecked(slice.as_ptr() as *mut _),
+                #[cfg(debug_assertions)]
+                len: slice.len(),
+                _marker: PhantomData,
+            }
+        }
+    }
+
+    /// # Safety
+    /// ptr must be valid for the returned lifetime.
+    pub unsafe fn new_raw(ptr: NonNull<T>, #[cfg(debug_assertions)] len: usize) -> Self {
+        Self {
+            ptr,
+            #[cfg(debug_assertions)]
+            len,
+            _marker: PhantomData,
+        }
+    }
+
+    /// # Safety
+    /// index must not be out of bounds
+    pub unsafe fn index(self, index: usize) -> &'a T {
+        debug_assert!(index < self.len);
+        &*self.ptr.as_ptr().add(index)
+    }
+
+    /// # Safety
+    /// index must not be out of bounds, and the same element must not be mutably accessed twice.
+    pub unsafe fn index_mut(self, index: usize) -> &'a mut T {
+        debug_assert!(index < self.len);
+        &mut *self.ptr.as_ptr().add(index)
+    }
+}
+
+macro_rules! impl_ptr {
+    ($ptr:ident) => {
+        impl $ptr<'_> {
+            /// # Safety
+            /// the offset cannot make the existing ptr null, or take it out of bounds for it's allocation.
+            pub unsafe fn offset(self, count: isize) -> Self {
+                Self(
+                    NonNull::new_unchecked(self.0.as_ptr().offset(count)),
+                    PhantomData,
+                )
+            }
+
+            /// # Safety
+            /// the offset cannot make the existing ptr null, or take it out of bounds for it's allocation.
+            pub unsafe fn add(self, count: usize) -> Self {
+                Self(
+                    NonNull::new_unchecked(self.0.as_ptr().add(count)),
+                    PhantomData,
+                )
+            }
+
+            /// # Safety
+            /// the lifetime for the returned item must not exceed the lifetime `inner` is valid for
+            pub unsafe fn new(inner: NonNull<u8>) -> Self {
+                Self(inner, PhantomData)
+            }
+        }
+    };
+}
+
+impl_ptr!(Ptr);
+impl<'a> Ptr<'a> {
+    /// # Safety
+    /// another PtrMut for the same Ptr shouldn't be created until the first is dropped.
+    pub unsafe fn assert_unique(self) -> PtrMut<'a> {
+        PtrMut(self.0, PhantomData)
+    }
+
+    /// # Safety
+    /// Must point to a valid T
+    pub unsafe fn deref<T>(self) -> &'a T {
+        &*self.0.as_ptr().cast()
+    }
+}
+impl_ptr!(PtrMut);
+impl<'a> PtrMut<'a> {
+    pub fn inner(self) -> NonNull<u8> {
+        self.0
+    }
+
+    /// # Safety
+    /// must have right to drop or move out of PtrMut, and current PtrMut should not be accessed again unless it's written to again.
+    pub unsafe fn promote(self) -> OwningPtr<'a> {
+        OwningPtr(self.0, PhantomData)
+    }
+
+    /// # Safety
+    /// Must point to a valid T
+    pub unsafe fn deref_mut<T>(self) -> &'a mut T {
+        &mut *self.inner().as_ptr().cast()
+    }
+}
+impl_ptr!(OwningPtr);
+impl<'a> OwningPtr<'a> {
+    pub fn inner(self) -> *mut u8 {
+        self.0.as_ptr()
+    }
+
+    pub fn make<T, F: FnOnce(OwningPtr<'_>) -> R, R>(val: T, f: F) -> R {
+        let mut temp = MaybeUninit::new(val);
+        let ptr = unsafe { NonNull::new_unchecked(temp.as_mut_ptr().cast::<u8>()) };
+        f(Self(ptr, PhantomData))
+    }
+
+    /// # Safety
+    /// must point to a valid T.
+    pub unsafe fn read<T>(self) -> T {
+        self.inner().cast::<T>().read()
+    }
+}