ci fix to run tests, come back to this commit in the future

Author: janis-bhm

crates/bevy_ecs/src/entity/mod.rs

@@ -1321,7 +1321,10 @@ pub type EntityIdLocation = Option<EntityLocation>;
 /// An [`Entity`] that has been disabled. This entity will not be found by queries or accessible via other ECS operations, but it's components are still stored in the ECS.
 /// This is useful for temporarily disabling an entity without fully despawning it or invoking archetype moves. This entity keeps track of its location, so it can be re-enabled later.
 pub struct DisabledEntity {
+    /// The disabled entity.
     pub entity: Entity,
+    /// The location of the entity after it was disabled.
+    /// This may not necessarily be it's location when it is re-enabled.
     pub location: EntityLocation,
 }
 

crates/bevy_ecs/src/storage/blob_array.rs

@@ -5,7 +5,7 @@ use core::{
     alloc::Layout,
     cell::UnsafeCell,
     num::NonZeroUsize,
-    ops::{Bound, Range, RangeBounds},
+    ops::{Bound, RangeBounds},
     ptr::NonNull,
 };
 
@@ -162,38 +162,6 @@ impl BlobArray {
         }
     }
 
-    /// Clears the array, i.e. removing (and dropping) all of the elements.
-    /// Note that this method has no effect on the allocated capacity of the vector.
-    ///
-    /// Note that this method will behave exactly the same as [`Vec::clear`].
-    ///
-    /// # Safety
-    /// - For every element with index `i`, if `i` < `len`: It must be safe to call [`Self::get_unchecked_mut`] with `i`.
-    ///   (If the safety requirements of every method that has been used on `Self` have been fulfilled, the caller just needs to ensure that `len` is correct.)
-    ///
-    /// [`Vec::clear`]: alloc::vec::Vec::clear
-    pub unsafe fn clear(&mut self, len: usize) {
-        #[cfg(debug_assertions)]
-        debug_assert!(self.capacity >= len);
-        if let Some(drop) = self.drop {
-            // We set `self.drop` to `None` before dropping elements for unwind safety. This ensures we don't
-            // accidentally drop elements twice in the event of a drop impl panicking.
-            self.drop = None;
-            let size = self.item_layout.size();
-            for i in 0..len {
-                // SAFETY:
-                // * 0 <= `i` < `len`, so `i * size` must be in bounds for the allocation.
-                // * `size` is a multiple of the erased type's alignment,
-                //   so adding a multiple of `size` will preserve alignment.
-                // * The item is left unreachable so it can be safely promoted to an `OwningPtr`.
-                let item = unsafe { self.get_ptr_mut().byte_add(i * size).promote() };
-                // SAFETY: `item` was obtained from this `BlobArray`, so its underlying type must match `drop`.
-                unsafe { drop(item) };
-            }
-            self.drop = Some(drop);
-        }
-    }
-
     /// Clears the array, i.e. removing (and dropping) all of the elements in the range.
     /// Note that this method has no effect on the allocated capacity of the vector.
     ///
@@ -243,11 +211,11 @@ impl BlobArray {
     /// # Safety
     /// - `cap` and `len` are indeed the capacity and length of this [`BlobArray`]
     /// - This [`BlobArray`] mustn't be used after calling this method.
-    pub unsafe fn drop(&mut self, cap: usize, len: usize) {
+    pub unsafe fn drop(&mut self, cap: usize, range: impl RangeBounds<usize>) {
         #[cfg(debug_assertions)]
         debug_assert_eq!(self.capacity, cap);
         if cap != 0 {
-            self.clear(len);
+            self.clear_range(range);
             if !self.is_zst() {
                 let layout =
                     array_layout(&self.item_layout, cap).expect("array layout should be valid");

crates/bevy_ecs/src/storage/table/column.rs

@@ -3,7 +3,9 @@ use crate::{
     change_detection::MaybeLocation,
     storage::{blob_array::BlobArray, thin_array_ptr::ThinArrayPtr},
 };
-use core::{mem::needs_drop, panic::Location};
+use alloc::vec::Vec;
+use bevy_ptr::PtrMut;
+use core::{mem::needs_drop, ops::RangeBounds, panic::Location};
 
 /// A type-erased contiguous container for data of a homogeneous type.
 ///
@@ -312,7 +314,7 @@ impl Column {
     pub(crate) unsafe fn clear(&mut self, len: usize) {
         self.added_ticks.clear_elements(len);
         self.changed_ticks.clear_elements(len);
-        self.data.clear(len);
+        self.data.clear_range(..len);
         self.changed_by
             .as_mut()
             .map(|changed_by| changed_by.clear_elements(len));
@@ -325,10 +327,10 @@ impl Column {
     /// - `len` is indeed the length of the column
     /// - `cap` is indeed the capacity of the column
     /// - the data stored in `self` will never be used again
-    pub(crate) unsafe fn drop(&mut self, cap: usize, len: usize) {
+    pub(crate) unsafe fn drop(&mut self, cap: usize, len: usize, range: impl RangeBounds<usize>) {
         self.added_ticks.drop(cap, len);
         self.changed_ticks.drop(cap, len);
-        self.data.drop(cap, len);
+        self.data.drop(cap, range);
         self.changed_by
             .as_mut()
             .map(|changed_by| changed_by.drop(cap, len));

crates/bevy_ecs/src/storage/table/mod.rs

@@ -933,7 +933,7 @@ impl Drop for Table {
             // SAFETY: `cap` and `len` are correct. `col` is never accessed again after this call.
             unsafe {
                 // TODO: don't drop disabled entities components
-                col.drop(cap, len);
+                col.drop(cap, len, self.disabled_entities as usize..len);
             }
         }
     }