Make AccessConflicts::is_empty public

[angelthorns]

Objective

When implementing SystemParam for an object which contains a mutable
reference to World, which cannot be derived due to a required lifetime parameter, it's necessary to check that there aren't any conflicts.

As far as I know, the is_empty method is the only way provided to check for no conflicts at all

[github-actions]

Welcome, new contributor!

Please make sure you've read our contributing guide and we look forward to reviewing your pull request shortly ✨

[Bleachfuel]

Could u give a example of how you would implement SystemParam for a type like that? I could try to make it derivable.

[angelthorns]

pub struct NativeOM<'a> {
    pub world: &'a mut World,
}

unsafe impl SystemParam for NativeOM<'_> {
    type State = ();

    type Item<'world, 'state> = NativeOM<'world>;

    fn init_state(
        _world: &mut World,
        system_meta: &mut bevy_ecs::system::SystemMeta,
    ) -> Self::State {
        let mut access = Access::default();
        access.write_all();

        if !system_meta
            .archetype_component_access()
            .is_compatible(&access)
        {
            panic!("NativeOM borrows &mut World and conflicts with other system parameters");
        }

        unsafe {
            system_meta.archetype_component_access_mut().extend(&access);
        }

        let mut filtered_access = FilteredAccess::default();

        filtered_access.write_all();
        
        if !(match system_meta
            .component_access_set()
            .get_conflicts_single(&filtered_access)
        {
            bevy_ecs::query::AccessConflicts::All => false,
            bevy_ecs::query::AccessConflicts::Individual(fixed_bit_set) => fixed_bit_set.is_empty(),
        }) {
            panic!("NativeOM borrows &mut World and conflicts with other system parameters");
        }

        unsafe {
            system_meta.component_access_set_mut().add(filtered_access);
        }

        ()
    }

    unsafe fn get_param<'world, 'state>(
        _state: &'state mut Self::State,
        _system_meta: &bevy_ecs::system::SystemMeta,
        world: bevy_ecs::world::unsafe_world_cell::UnsafeWorldCell<'world>,
        _change_tick: bevy_ecs::component::Tick,
    ) -> Self::Item<'world, 'state> {
        NativeOM::new(world.world_mut())
    }
}

This is how I implemented it after reading the implementation for &'w World (although for now i'm unaware as to how System trait requirements work for &mut World as there is actually not a SystemParam implementation for it, and haven't looked too deeply with it) so I improvised this a bit.

[angelthorns]

if !(match system_meta
            .component_access_set()
            .get_conflicts_single(&filtered_access)
        {
            bevy_ecs::query::AccessConflicts::All => false,
            bevy_ecs::query::AccessConflicts::Individual(fixed_bit_set) => fixed_bit_set.is_empty(),
        })

This part is where i would've used AccessConflicts::is_empty

[chescock]

It's not actually sound to impl SystemParam for something containing &mut World at the moment. We'd need something like #16622 so that we can mark the system as exclusive, and so that we can check for conflicts between &mut World and parameters like &Archetypes and Query<Entity> that have no access but require the structure not change.

If you're able to use DeferredWorld, that does impl SystemParam; otherwise I think you need to use a custom ExclusiveSystemParam.

This PR seems fine, though! It is silly that this method isn't pub when it doesn't do anything you can't already do with the public API.