Look over some old FIXMEs

Author: BoxyUwU

crates/bevy_ecs/src/query/fetch.rs

@@ -705,9 +705,6 @@ impl<'w, 's, T: Component> Iterator for RelationAccess<'w, 's, T> {
                 },
                 Either::U(target_iter) => {
                     let target = target_iter.next()?;
-                    // FIXME(Relationships) do we want `T None` to be yielded from a `Relation<T>` query
-                    // honestly there are a lot of places we need to think about this, for example the
-                    // add_relation_filter method takes `Entity` not `Option<Entity>` lol
                     match columns.1.get(target) {
                         Some(col) => unsafe {
                             let ptr = col.get_unchecked(*current_idx) as *mut T;
@@ -723,9 +720,6 @@ impl<'w, 's, T: Component> Iterator for RelationAccess<'w, 's, T> {
                 iter,
                 ..
             } => {
-                // FIXME(Relationships) do we want `T None` to be yielded from a `Relation<T>` query
-                // honestly there are a lot of places we need to think about this, for example the
-                // add_relation_filter method takes `Entity` not `Option<Entity>` lol
                 let target = match iter {
                     Either::T(target_iter) => target_iter.next()?,
                     Either::U(target_iter) => Some(*target_iter.next()?),
@@ -993,9 +987,6 @@ impl<'w, 's, T: Component> Iterator for RelationAccessMut<'w, 's, T> {
                 },
                 Either::U(target_iter) => {
                     let target = target_iter.next()?;
-                    // FIXME(Relationships) do we want `T None` to be yielded from a `Relation<T>` query
-                    // honestly there are a lot of places we need to think about this, for example the
-                    // add_relation_filter method takes `Entity` not `Option<Entity>` lol
                     match columns.1.get(target) {
                         Some(col) => unsafe {
                             let ptr = col.get_unchecked(*current_idx) as *mut T;
@@ -1023,9 +1014,6 @@ impl<'w, 's, T: Component> Iterator for RelationAccessMut<'w, 's, T> {
                 change_tick,
                 ..
             } => {
-                // FIXME(Relationships) do we want `T None` to be yielded from a `Relation<T>` query
-                // honestly there are a lot of places we need to think about this, for example the
-                // add_relation_filter method takes `Entity` not `Option<Entity>` lol
                 let target = match iter {
                     Either::T(target_iter) => target_iter.next()?,
                     Either::U(target_iter) => Some(*target_iter.next()?),

crates/bevy_ecs/src/query/relation_filter.rs

@@ -59,8 +59,12 @@ impl<Q: WorldQuery, F: WorldQuery> QueryRelationFilter<Q, F> {
         Self::default()
     }
 
-    // FIXME(Relationships) should the behaviour for this be target AND other_target AND other_other_target
-    // or should it be target OR other_target OR other_other_target
+    // FIXME(Relationships) currently we cant set a target filter of `None`- rather than allowing this
+    // we should stop storing `target` as an `Option<Entity>` and instead have a statically knowable
+    // ID represent the `None` case
+    // FIXME(Relationships) implement ability to say `target1` OR `target2`, currently it works like
+    // `target1` AND `target2`. This mirrors how queries normally work `Query<(&T, &U)>`- `T` AND `U`
+    // but we need to also be able to mirror `Or<(T, U)>`
     pub fn add_target_filter<T: Component, Path>(mut self, target: Entity) -> Self
     where
         Self: SpecifiesRelation<T, Path, RelationFilter = Self>,

crates/bevy_ecs/src/system/mod.rs

@@ -393,7 +393,6 @@ mod tests {
                     .get_id(std::any::TypeId::of::<(i32, bool)>())
                     .expect("Bundle used to spawn entity should exist");
                 let bundle_info = bundles.get(bundle_id).unwrap();
-                // FIXME(Relationships) make sure this is using `(RelationKindId, Option<Entity>)`
                 let mut bundle_components = bundle_info.components().to_vec();
                 bundle_components.sort();
                 assert_eq!(

crates/bevy_ecs/src/system/query.rs

@@ -228,7 +228,7 @@ where
             .get_unchecked_manual(self.world, entity, self.last_change_tick, self.change_tick)
     }
 
-    // FIXME(Relationships) we likely want get_relation methods for both `T *` and `T some_entity`
+    // FIXME(Relationships) implement get_relation methods for both `T *` and `T some_entity`
 
     /// Gets a reference to the [`Entity`]'s [`Component`] of the given type. This will fail if the
     /// entity does not have the given component type or if the given component type does not match

crates/bevy_ecs/src/system/system_param.rs

@@ -110,7 +110,6 @@ where
     }
 
     fn new_archetype(&mut self, archetype: &Archetype, system_state: &mut SystemState) {
-        // FIXME(Relationships) investigate this function
         for (relation_filter, cache) in self.relation_filter_accesses.iter_mut() {
             Self::new_archetype(
                 &self.fetch_state,

crates/bevy_ecs/src/world/mod.rs

@@ -481,7 +481,6 @@ impl World {
         QueryState::new(self)
     }
 
-    // FIXME(Relationships) add a method for doing this for `T *`
     /// Returns an iterator of entities that had components of type `T` removed
     /// since the last call to [World::clear_trackers].
     pub fn removed<T: Component>(&self) -> std::iter::Cloned<std::slice::Iter<'_, Entity>> {
@@ -492,6 +491,7 @@ impl World {
         }
     }
 
+    // FIXME(Relationships) implement a way to set `*` for the target
     /// Returns an iterator of entities that had components with the given `component_id` removed
     /// since the last call to [World::clear_trackers].
     ///
@@ -831,9 +831,6 @@ impl World {
                 resource_archetype_components.insert(
                     component_id,
                     (
-                        // FIXME(Relationships) I'm not sure if we should really be overwriting the entry in
-                        // resource_archetype_components, this *is* for resources so we should never really
-                        // be inserting anything into the hashmap so this is probably fine /shrug
                         Some(ArchetypeComponentInfo {
                             archetype_component_id: ArchetypeComponentId::new(
                                 *archetype_component_count,

crates/bevy_ecs/src/world/tests.rs

@@ -144,8 +144,6 @@ fn relation_access_raw(storage_type: StorageType) {
     assert_eq!(
         accessor.next().unwrap(),
         (
-            // FIXME(Relationships) honestly having Option<Entity> is really annoying
-            // i should just make a statically knowable entity to represent None...
             Some(parent1),
             &ChildOf {
                 despawn_recursive: true
@@ -165,8 +163,6 @@ fn relation_access_raw(storage_type: StorageType) {
     assert_eq!(
         accessor.next().unwrap(),
         (
-            // FIXME(Relationships) honestly having Option<Entity> is really annoying
-            // i should just make a statically knowable entity to represent None...
             Some(parent2),
             &ChildOf {
                 despawn_recursive: false