rename ThinColumn to Column (bevyengine#21427)

# Objective

- Now that we've removed Column, there's not really a reason for
ThinColumn to have a special name

## Solution

- Rename ThinColumn to Column
- fix docs

## Testing

- compiles

Author: ecoskey

crates/bevy_ecs/src/archetype.rs

@@ -425,7 +425,7 @@ impl Archetype {
                 },
             );
             // NOTE: the `table_components` are sorted AND they were inserted in the `Table` in the same
-            // sorted order, so the index of the `ThinColumn` in the `Table` is the same as the index of the
+            // sorted order, so the index of the `Column` in the `Table` is the same as the index of the
             // component in the `table_components` vector
             component_index
                 .entry(component_id)

crates/bevy_ecs/src/storage/sparse_set.rs

@@ -3,7 +3,7 @@ use crate::{
     component::{CheckChangeTicks, ComponentId, ComponentInfo, ComponentTicks, Tick, TickCells},
     entity::{Entity, EntityRow},
     query::DebugCheckedUnwrap,
-    storage::{AbortOnPanic, TableRow, ThinColumn, VecExtensions},
+    storage::{AbortOnPanic, Column, TableRow, VecExtensions},
 };
 use alloc::{boxed::Box, vec::Vec};
 use bevy_ptr::{OwningPtr, Ptr};
@@ -120,7 +120,7 @@ impl<I: SparseSetIndex, V> SparseArray<I, V> {
 #[derive(Debug)]
 pub struct ComponentSparseSet {
     /// Capacity and length match those of `entities`.
-    dense: ThinColumn,
+    dense: Column,
     // Internally this only relies on the Entity index to keep track of where the component data is
     // stored for entities that are alive. The generation is not required, but is stored
     // in debug builds to validate that access is correct.
@@ -137,7 +137,7 @@ impl ComponentSparseSet {
     pub(crate) fn new(component_info: &ComponentInfo, capacity: usize) -> Self {
         let entities = Vec::with_capacity(capacity);
         Self {
-            dense: ThinColumn::with_capacity(component_info, entities.capacity()),
+            dense: Column::with_capacity(component_info, entities.capacity()),
             entities,
             sparse: Default::default(),
         }

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

@@ -7,30 +7,30 @@ use core::{mem::needs_drop, panic::Location};
 
 /// A type-erased contiguous container for data of a homogeneous type.
 ///
-/// Conceptually, a `ThinColumn` is very similar to a type-erased `Box<[T]>`.
+/// Conceptually, a `Column` is very similar to a type-erased `Box<[T]>`.
 /// It also stores the change detection ticks for its components, kept in two separate
 /// contiguous buffers internally. An element shares its data across these buffers by using the
 /// same index (i.e. the entity at row 3 has it's data at index 3 and its change detection ticks at index 3).
 ///
-/// Like many other low-level storage types, `ThinColumn` has a limited and highly unsafe
+/// Like many other low-level storage types, `Column` has a limited and highly unsafe
 /// interface. It's highly advised to use higher level types and their safe abstractions
-/// instead of working directly with `ThinColumn`.
+/// instead of working directly with `Column`.
 ///
-/// For performance reasons, `ThinColumn` does not does not store it's capacity and length.
+/// For performance reasons, `Column` does not does not store it's capacity and length.
 /// This type is used by [`Table`] and [`ComponentSparseSet`], where the corresponding capacity
 /// and length can be found.
 ///
 /// [`ComponentSparseSet`]: crate::storage::ComponentSparseSet
 #[derive(Debug)]
-pub struct ThinColumn {
+pub struct Column {
     pub(super) data: BlobArray,
     pub(super) added_ticks: ThinArrayPtr<UnsafeCell<Tick>>,
     pub(super) changed_ticks: ThinArrayPtr<UnsafeCell<Tick>>,
     pub(super) changed_by: MaybeLocation<ThinArrayPtr<UnsafeCell<&'static Location<'static>>>>,
 }
 
-impl ThinColumn {
-    /// Create a new [`ThinColumn`] with the given `capacity`.
+impl Column {
+    /// Create a new [`Column`] with the given `capacity`.
     pub fn with_capacity(component_info: &ComponentInfo, capacity: usize) -> Self {
         Self {
             // SAFETY: The components stored in this columns will match the information in `component_info`
@@ -137,7 +137,7 @@ impl ThinColumn {
         data
     }
 
-    /// Call [`realloc`](std::alloc::realloc) to expand / shrink the memory allocation for this [`ThinColumn`]
+    /// Call [`realloc`](std::alloc::realloc) to expand / shrink the memory allocation for this [`Column`]
     ///
     /// # Panics
     /// - Panics if the any of the new capacity overflows `isize::MAX` bytes.
@@ -159,7 +159,7 @@ impl ThinColumn {
             .map(|changed_by| changed_by.realloc(current_capacity, new_capacity));
     }
 
-    /// Call [`alloc`](std::alloc::alloc) to allocate memory for this [`ThinColumn`]
+    /// Call [`alloc`](std::alloc::alloc) to allocate memory for this [`Column`]
     /// The caller should make sure their saved `capacity` value is updated to `new_capacity` after this operation.
     ///
     /// # Panics
@@ -233,7 +233,7 @@ impl ThinColumn {
     #[inline]
     pub(crate) unsafe fn initialize_from_unchecked(
         &mut self,
-        other: &mut ThinColumn,
+        other: &mut Column,
         other_last_element_index: usize,
         src_row: TableRow,
         dst_row: TableRow,
@@ -302,7 +302,7 @@ impl ThinColumn {
     }
 
     /// Because this method needs parameters, it can't be the implementation of the `Drop` trait.
-    /// The owner of this [`ThinColumn`] must call this method with the correct information.
+    /// The owner of this [`Column`] must call this method with the correct information.
     ///
     /// # Safety
     /// - `len` is indeed the length of the column
@@ -330,32 +330,32 @@ impl ThinColumn {
         self.data.drop_last_element(last_element_index);
     }
 
-    /// Get a slice to the data stored in this [`ThinColumn`].
+    /// Get a slice to the data stored in this [`Column`].
     ///
     /// # Safety
-    /// - `T` must match the type of data that's stored in this [`ThinColumn`]
+    /// - `T` must match the type of data that's stored in this [`Column`]
     /// - `len` must match the actual length of this column (number of elements stored)
     pub unsafe fn get_data_slice<T>(&self, len: usize) -> &[UnsafeCell<T>] {
         self.data.get_sub_slice(len)
     }
 
-    /// Get a slice to the added [`ticks`](Tick) in this [`ThinColumn`].
+    /// Get a slice to the added [`ticks`](Tick) in this [`Column`].
     ///
     /// # Safety
     /// - `len` must match the actual length of this column (number of elements stored)
     pub unsafe fn get_added_ticks_slice(&self, len: usize) -> &[UnsafeCell<Tick>] {
         self.added_ticks.as_slice(len)
     }
 
-    /// Get a slice to the changed [`ticks`](Tick) in this [`ThinColumn`].
+    /// Get a slice to the changed [`ticks`](Tick) in this [`Column`].
     ///
     /// # Safety
     /// - `len` must match the actual length of this column (number of elements stored)
     pub unsafe fn get_changed_ticks_slice(&self, len: usize) -> &[UnsafeCell<Tick>] {
         self.changed_ticks.as_slice(len)
     }
 
-    /// Get a slice to the calling locations that last changed each value in this [`ThinColumn`]
+    /// Get a slice to the calling locations that last changed each value in this [`Column`]
     ///
     /// # Safety
     /// - `len` must match the actual length of this column (number of elements stored)

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

@@ -137,7 +137,7 @@ impl TableRow {
 // it must be the correct capacity to allocate, reallocate, and deallocate all columns. This
 // means the safety invariant must be enforced even in `TableBuilder`.
 pub(crate) struct TableBuilder {
-    columns: SparseSet<ComponentId, ThinColumn>,
+    columns: SparseSet<ComponentId, Column>,
     entities: Vec<Entity>,
 }
 
@@ -150,12 +150,12 @@ impl TableBuilder {
         }
     }
 
-    /// Add a new column to the [`Table`]. Specify the component which will be stored in the [`column`](ThinColumn) using its [`ComponentId`]
+    /// Add a new column to the [`Table`]. Specify the component which will be stored in the [`column`](Column) using its [`ComponentId`]
     #[must_use]
     pub fn add_column(mut self, component_info: &ComponentInfo) -> Self {
         self.columns.insert(
             component_info.id(),
-            ThinColumn::with_capacity(component_info, self.entities.capacity()),
+            Column::with_capacity(component_info, self.entities.capacity()),
         );
         self
     }
@@ -174,7 +174,7 @@ impl TableBuilder {
 /// in a [`World`].
 ///
 /// Conceptually, a `Table` can be thought of as a `HashMap<ComponentId, Column>`, where
-/// each [`ThinColumn`] is a type-erased `Vec<T: Component>`. Each row corresponds to a single entity
+/// each [`Column`] is a type-erased `Vec<T: Component>`. Each row corresponds to a single entity
 /// (i.e. index 3 in Column A and index 3 in Column B point to different components on the same
 /// entity). Fetching components from a table involves fetching the associated column for a
 /// component type (via its [`ComponentId`]), then fetching the entity's row within that column.
@@ -188,7 +188,7 @@ impl TableBuilder {
 // it must be the correct capacity to allocate, reallocate, and deallocate all columns. This
 // means the safety invariant must be enforced even in `TableBuilder`.
 pub struct Table {
-    columns: ImmutableSparseSet<ComponentId, ThinColumn>,
+    columns: ImmutableSparseSet<ComponentId, Column>,
     entities: Vec<Entity>,
 }
 
@@ -482,28 +482,28 @@ impl Table {
         })
     }
 
-    /// Fetches a read-only reference to the [`ThinColumn`] for a given [`Component`] within the table.
+    /// Fetches a read-only reference to the [`Column`] for a given [`Component`] within the table.
     ///
     /// Returns `None` if the corresponding component does not belong to the table.
     ///
     /// [`Component`]: crate::component::Component
     #[inline]
-    pub fn get_column(&self, component_id: ComponentId) -> Option<&ThinColumn> {
+    pub fn get_column(&self, component_id: ComponentId) -> Option<&Column> {
         self.columns.get(component_id)
     }
 
-    /// Fetches a mutable reference to the [`ThinColumn`] for a given [`Component`] within the
+    /// Fetches a mutable reference to the [`Column`] for a given [`Component`] within the
     /// table.
     ///
     /// Returns `None` if the corresponding component does not belong to the table.
     ///
     /// [`Component`]: crate::component::Component
     #[inline]
-    pub(crate) fn get_column_mut(&mut self, component_id: ComponentId) -> Option<&mut ThinColumn> {
+    pub(crate) fn get_column_mut(&mut self, component_id: ComponentId) -> Option<&mut Column> {
         self.columns.get_mut(component_id)
     }
 
-    /// Checks if the table contains a [`ThinColumn`] for a given [`Component`].
+    /// Checks if the table contains a [`Column`] for a given [`Component`].
     ///
     /// Returns `true` if the column is present, `false` otherwise.
     ///
@@ -670,8 +670,8 @@ impl Table {
         }
     }
 
-    /// Iterates over the [`ThinColumn`]s of the [`Table`].
-    pub fn iter_columns(&self) -> impl Iterator<Item = &ThinColumn> {
+    /// Iterates over the [`Column`]s of the [`Table`].
+    pub fn iter_columns(&self) -> impl Iterator<Item = &Column> {
         self.columns.values()
     }
 

release-content/migration-guides/rename_thin_column.md

@@ -0,0 +1,9 @@
+---
+title: Replaced `Column` with `ThinColumn`
+pull_requests: [21427]
+---
+
+The low-level `Column` and `ThinColumn` types in `bevy_ecs` have been
+merged into a single type, now called `Column` but with the api
+of `ThinColumn`. This type does not keep track of its own allocated
+length, and only provides unsafe methods.