Make the pointers in Fetch impls unions

crates/bevy_ecs/macros/src/fetch.rs

@@ -225,34 +225,19 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                     #(self.#field_idents.set_table(&_state.#field_idents, _table);)*
                 }
 
-                /// SAFETY: we call `table_fetch` for each member that implements `Fetch`.
-                #[inline]
-                unsafe fn table_fetch(&mut self, _table_row: usize) -> Self::Item {
-                    Self::Item {
-                        #(#field_idents: self.#field_idents.table_fetch(_table_row),)*
-                        #(#ignored_field_idents: Default::default(),)*
-                    }
-                }
-
-                /// SAFETY: we call `archetype_fetch` for each member that implements `Fetch`.
-                #[inline]
-                unsafe fn archetype_fetch(&mut self, _archetype_index: usize) -> Self::Item {
+                /// SAFETY: we call `fetch` for each member that implements `Fetch`.
+                #[inline(always)]
+                unsafe fn fetch(&mut self, _entity: Entity, _table_row: usize) -> Self::Item {
                     Self::Item {
-                        #(#field_idents: self.#field_idents.archetype_fetch(_archetype_index),)*
+                        #(#field_idents: self.#field_idents.fetch(_entity, _table_row),)*
                         #(#ignored_field_idents: Default::default(),)*
                     }
                 }
 
                 #[allow(unused_variables)]
-                #[inline]
-                unsafe fn table_filter_fetch(&mut self, _table_row: usize) -> bool {
-                    true #(&& self.#field_idents.table_filter_fetch(_table_row))*
-                }
-
-                #[allow(unused_variables)]
-                #[inline]
-                unsafe fn archetype_filter_fetch(&mut self, _archetype_index: usize) -> bool {
-                    true #(&& self.#field_idents.archetype_filter_fetch(_archetype_index))*
+                #[inline(always)]
+                unsafe fn filter_fetch(&mut self, _entity: Entity, _table_row: usize) -> bool {
+                    true #(&& self.#field_idents.filter_fetch(_entity, _table_row))*
                 }
 
                 fn update_component_access(state: &Self::State, _access: &mut #path::query::FilteredAccess<#path::component::ComponentId>) {

crates/bevy_ecs/src/archetype.rs

@@ -118,9 +118,19 @@ impl Edges {
     }
 }
 
-struct TableInfo {
-    id: TableId,
-    entity_rows: Vec<usize>,
+pub struct ArchetypeEntity {
+    pub(crate) entity: Entity,
+    pub(crate) table_row: usize,
+}
+
+impl ArchetypeEntity {
+    pub fn entity(&self) -> Entity {
+        self.entity
+    }
+
+    pub fn table_row(&self) -> usize {
+        self.table_row
+    }
 }
 
 pub(crate) struct ArchetypeSwapRemoveResult {
@@ -135,9 +145,9 @@ pub(crate) struct ArchetypeComponentInfo {
 
 pub struct Archetype {
     id: ArchetypeId,
-    entities: Vec<Entity>,
+    table_id: TableId,
     edges: Edges,
-    table_info: TableInfo,
+    entities: Vec<ArchetypeEntity>,
     table_components: Box<[ComponentId]>,
     sparse_set_components: Box<[ComponentId]>,
     pub(crate) unique_components: SparseSet<ComponentId, Column>,
@@ -181,15 +191,12 @@ impl Archetype {
         }
         Self {
             id,
-            table_info: TableInfo {
-                id: table_id,
-                entity_rows: Default::default(),
-            },
+            table_id,
+            entities: Vec::new(),
             components,
             table_components,
             sparse_set_components,
             unique_components: SparseSet::new(),
-            entities: Default::default(),
             edges: Default::default(),
         }
     }
@@ -201,19 +208,14 @@ impl Archetype {
 
     #[inline]
     pub fn table_id(&self) -> TableId {
-        self.table_info.id
+        self.table_id
     }
 
     #[inline]
-    pub fn entities(&self) -> &[Entity] {
+    pub fn entities(&self) -> &[ArchetypeEntity] {
         &self.entities
     }
 
-    #[inline]
-    pub fn entity_table_rows(&self) -> &[usize] {
-        &self.table_info.entity_rows
-    }
-
     #[inline]
     pub fn table_components(&self) -> &[ComponentId] {
         &self.table_components
@@ -251,20 +253,19 @@ impl Archetype {
 
     #[inline]
     pub fn entity_table_row(&self, index: usize) -> usize {
-        self.table_info.entity_rows[index]
+        self.entities[index].table_row
     }
 
     #[inline]
     pub(crate) fn set_entity_table_row(&mut self, index: usize, table_row: usize) {
-        self.table_info.entity_rows[index] = table_row;
+        self.entities[index].table_row = table_row;
     }
 
     /// # Safety
     /// valid component values must be immediately written to the relevant storages
     /// `table_row` must be valid
     pub(crate) unsafe fn allocate(&mut self, entity: Entity, table_row: usize) -> EntityLocation {
-        self.entities.push(entity);
-        self.table_info.entity_rows.push(table_row);
+        self.entities.push(ArchetypeEntity { entity, table_row });
 
         EntityLocation {
             archetype_id: self.id,
@@ -274,21 +275,20 @@ impl Archetype {
 
     pub(crate) fn reserve(&mut self, additional: usize) {
         self.entities.reserve(additional);
-        self.table_info.entity_rows.reserve(additional);
     }
 
     /// Removes the entity at `index` by swapping it out. Returns the table row the entity is stored
     /// in.
     pub(crate) fn swap_remove(&mut self, index: usize) -> ArchetypeSwapRemoveResult {
         let is_last = index == self.entities.len() - 1;
-        self.entities.swap_remove(index);
+        let entity = self.entities.swap_remove(index);
         ArchetypeSwapRemoveResult {
             swapped_entity: if is_last {
                 None
             } else {
-                Some(self.entities[index])
+                Some(self.entities[index].entity)
             },
-            table_row: self.table_info.entity_rows.swap_remove(index),
+            table_row: entity.table_row,
         }
     }
 
@@ -326,7 +326,6 @@ impl Archetype {
 
     pub(crate) fn clear_entities(&mut self) {
         self.entities.clear();
-        self.table_info.entity_rows.clear();
     }
 }
 

crates/bevy_ecs/src/lib.rs

@@ -540,7 +540,7 @@ mod tests {
             .spawn()
             .insert_bundle((TableStored("def"), A(456), SparseStored(1)))
             .id();
-        // // this should be skipped
+        // this should be skipped
         // SparseStored(1).spawn().insert("abc");
         let ents = world
             .query::<(Entity, Option<&SparseStored>, &A)>()