`AnyOf` can violate single mutable alias rule

[Zeenobit]

Bevy version

0.13.2

What you did

I'm noticing some weird behavior with AnyOf.
Given two systems test1 and test2:

    #[derive(Component)]
    struct X(usize);

    // Runs on startup
    fn setup_test(mut commands: Commands) {
        commands.spawn(X(0));
    }

    fn test1(query: Query<(&mut X, &mut X)>) {}

    fn test2(mut query: Query<AnyOf<(&mut X, &mut X)>>) {
        let (a, b) = query.single_mut();
        a.unwrap().0 += 1;
        *b.unwrap() = X(3);
        let (a, _) = query.single();
        dbg!(a.unwrap().0);
    }

Obviously test1 fails to run, since Query<(&mut X, &mut X)> is invalid.
But somehow test2 is perfectly ok. I was expecting at least one of a or b to be None, but nope! Both a and b are valid, implying we can violate the single mutable alias rule with AnyOf.

Running an app with test2 prints "3", always, which seems like an error.

[iiYese]

The clock has to be rewound back to 0.9 for it to crash as it should. But you don't get an access panic you get an error from the stdlib which is only in debug builds.

use bevy::prelude::*;

#[derive(Deref, DerefMut, Component)]
struct Foo(u32);

fn setup(mut cmds: Commands) {
    cmds.spawn(Foo(0));
}

fn update(mut query: Query<AnyOf<(&mut Foo, &mut Foo)>>) {
    let Ok((Some(mut a), Some(mut b))) = query.get_single_mut() else {
        return;
    };
    **a += 1;
    **b += 1;
    println!("did a ub {} {}", **a, **b);
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup)
        .add_system(update)
        .run();
}

did a ub 2 2
thread 'main' panicked at library/core/src/panicking.rs:220:5:
unsafe precondition(s) violated: slice::from_raw_parts requires the pointer to be aligned and non-null, and the total size of the slice not to exceed `isize::MAX`

[Gingeh]

I was able to get it working(?) after some tinkering around with AnyOf's update_component_access impl.

diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index 2ebf95cde..847653ab1 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -1872,10 +1872,12 @@ macro_rules! impl_anytuple_fetch {
                         $name::update_component_access($name, &mut intermediate);
                         _new_access.append_or(&intermediate);
                         _new_access.extend_access(&intermediate);
+                        _access.extend_access(&intermediate); // add accesses for remaining items to check against
                     } else {
                         $name::update_component_access($name, &mut _new_access);
                         _new_access.required = _access.required.clone();
                         _not_first = true;
+                        _access.extend_access(&_new_access); // add accesses for remaining items to check against
                     }
                 )*
 
diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index b41255194..075e04692 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -564,6 +564,14 @@ mod tests {
         run_system(&mut world, sys);
     }
 
+    #[test]
+    #[should_panic = "&mut bevy_ecs::system::tests::A conflicts with a previous access in this query."]
+    fn any_of_with_conflicting() {
+        fn sys(_: Query<AnyOf<(&mut A, &mut A)>>) {}
+        let mut world = World::default();
+        run_system(&mut world, sys);
+    }
+
     #[test]
     fn any_of_has_filter_with_when_both_have_it() {
         fn sys(_: Query<(AnyOf<(&A, &A)>, &mut B)>, _: Query<&mut B, Without<A>>) {}

I have a very limited understanding of how this all works, so take this with a hefty grain of salt.