Automatically add systems to sets based on their world accesses

crates/bevy_ecs/src/component.rs

@@ -324,6 +324,7 @@ pub struct ComponentDescriptor {
     // actually Send + Sync
     is_send_and_sync: bool,
     type_id: Option<TypeId>,
+    is_resource: bool,
     layout: Layout,
     // SAFETY: this function must be safe to call with pointers pointing to items of the type
     // this descriptor describes.
@@ -357,6 +358,7 @@ impl ComponentDescriptor {
             storage_type: T::Storage::STORAGE_TYPE,
             is_send_and_sync: true,
             type_id: Some(TypeId::of::<T>()),
+            is_resource: false,
             layout: Layout::new::<T>(),
             drop: needs_drop::<T>().then_some(Self::drop_ptr::<T> as _),
         }
@@ -378,6 +380,7 @@ impl ComponentDescriptor {
             storage_type,
             is_send_and_sync: true,
             type_id: None,
+            is_resource: false,
             layout,
             drop,
         }
@@ -394,6 +397,7 @@ impl ComponentDescriptor {
             storage_type: StorageType::Table,
             is_send_and_sync: true,
             type_id: Some(TypeId::of::<T>()),
+            is_resource: true,
             layout: Layout::new::<T>(),
             drop: needs_drop::<T>().then_some(Self::drop_ptr::<T> as _),
         }
@@ -405,6 +409,7 @@ impl ComponentDescriptor {
             storage_type,
             is_send_and_sync: false,
             type_id: Some(TypeId::of::<T>()),
+            is_resource: true,
             layout: Layout::new::<T>(),
             drop: needs_drop::<T>().then_some(Self::drop_ptr::<T> as _),
         }
@@ -468,7 +473,18 @@ impl Components {
         storages: &mut Storages,
         descriptor: ComponentDescriptor,
     ) -> ComponentId {
-        let index = Components::init_component_inner(&mut self.components, storages, descriptor);
+        let index = if let Some(type_id) = descriptor.type_id {
+            let indices = if descriptor.is_resource {
+                &mut self.resource_indices
+            } else {
+                &mut self.indices
+            };
+            *indices.entry(type_id).or_insert_with(|| {
+                Components::init_component_inner(&mut self.components, storages, descriptor)
+            })
+        } else {
+            Components::init_component_inner(&mut self.components, storages, descriptor)
+        };
         ComponentId(index)
     }
 

crates/bevy_ecs/src/lib.rs

@@ -65,6 +65,10 @@ type TypeIdMap<V> = rustc_hash::FxHashMap<TypeId, V>;
 mod tests {
     use crate as bevy_ecs;
     use crate::prelude::Or;
+    use crate::schedule::{
+        ComponentAccessSet, IntoSystemConfigs, ResourceAccessSet, Schedule, ScheduleBuildSettings,
+    };
+    use crate::system::{Query, Res, ResMut};
     use crate::{
         bundle::Bundle,
         change_detection::Ref,
@@ -1725,4 +1729,129 @@ mod tests {
             "new entity was spawned and received C component"
         );
     }
+
+    #[test]
+    fn read_component_with_access_set() {
+        #[derive(Component)]
+        struct Conflict;
+
+        fn before_read(_: Query<&mut Conflict>) {}
+        fn does_read(_: Query<&A>, _: Query<&mut Conflict>) {}
+
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+
+        schedule.add_systems((
+            before_read.before(ComponentAccessSet::Reads::<A>),
+            does_read,
+        ));
+
+        // Panic if there are ambiguities.
+        schedule.set_build_settings(ScheduleBuildSettings {
+            ambiguity_detection: bevy_ecs::schedule::LogLevel::Error,
+            ..Default::default()
+        });
+
+        schedule.run(&mut world);
+    }
+
+    #[test]
+    fn write_component_with_access_set() {
+        fn does_write(_q: Query<&mut A>) {}
+        fn after_write(_q: Query<&A>) {}
+
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+
+        schedule.add_systems(does_write);
+        schedule.add_systems(after_write.after(ComponentAccessSet::Writes::<A>));
+
+        // Panic if there are ambiguities.
+        schedule.set_build_settings(ScheduleBuildSettings {
+            ambiguity_detection: bevy_ecs::schedule::LogLevel::Error,
+            ..Default::default()
+        });
+
+        schedule.run(&mut world);
+    }
+
+    #[test]
+    fn resource_with_access_set() {
+        #[derive(Resource, Default)]
+        struct R;
+
+        fn send_system(_: ResMut<R>) {}
+        fn read_system(_: Res<R>) {}
+
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+
+        world.init_resource::<R>();
+        schedule.add_systems((
+            send_system.before(ResourceAccessSet::Reads::<R>),
+            read_system,
+        ));
+
+        // Panic if there are ambiguities.
+        schedule.set_build_settings(ScheduleBuildSettings {
+            ambiguity_detection: bevy_ecs::schedule::LogLevel::Error,
+            ..Default::default()
+        });
+
+        schedule.run(&mut world);
+    }
+
+    #[test]
+    fn access_set_late_init() {
+        #[derive(Component)]
+        struct C;
+
+        fn read_system(_: Query<&C>) {}
+        fn write_system(_: Query<&mut C>) {}
+
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+
+        // Make sure the system with write-access is initialized *before* the access set is mentioned.
+        schedule.add_systems(write_system);
+        schedule.run(&mut world);
+
+        schedule.add_systems(read_system.after(ComponentAccessSet::Writes::<C>));
+
+        // Panic if there are ambiguities.
+        schedule.set_build_settings(ScheduleBuildSettings {
+            ambiguity_detection: bevy_ecs::schedule::LogLevel::Error,
+            ..Default::default()
+        });
+
+        schedule.run(&mut world);
+    }
+
+    #[test]
+    fn access_set_reads_all_not_included() {
+        #[derive(Resource, Default)]
+        struct R;
+
+        fn read_system(_: Res<R>) {}
+        fn read_all_system(_: &World) {}
+
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+
+        world.init_resource::<R>();
+        schedule.add_systems((
+            read_system,
+            // This will cause a dependency cycle if `read_all_system` is included
+            // in the read-access set.
+            read_all_system.after(ResourceAccessSet::Reads::<R>),
+        ));
+
+        // Panic if there are ambiguities.
+        schedule.set_build_settings(ScheduleBuildSettings {
+            ambiguity_detection: bevy_ecs::schedule::LogLevel::Error,
+            ..Default::default()
+        });
+
+        schedule.run(&mut world);
+    }
 }

crates/bevy_ecs/src/query/access.rs

@@ -121,6 +121,13 @@ impl<T: SparseSetIndex> Access<T> {
         self.reads_all || self.reads_and_writes.contains(index.sparse_set_index())
     }
 
+    /// Returns `true` if this has read-only access to the element given by `index`,
+    /// unless the access comes from [`Self::has_read_all`].
+    pub(crate) fn has_granular_read_only(&self, index: T) -> bool {
+        let index = index.sparse_set_index();
+        self.reads_and_writes.contains(index) && !self.writes.contains(index)
+    }
+
     /// Returns `true` if this can access anything.
     pub fn has_any_read(&self) -> bool {
         self.reads_all || !self.reads_and_writes.is_clear()

crates/bevy_ecs/src/schedule/config.rs

@@ -93,6 +93,10 @@ impl SystemConfigs {
 impl<T> NodeConfigs<T> {
     /// Adds a new boxed system set to the systems.
     pub fn in_set_dyn(&mut self, set: BoxedSystemSet) {
+        assert!(
+            set.reads_component().is_none() && set.writes_component().is_none(),
+            "adding arbitrary systems to a world access set is not allowed"
+        );
         match self {
             Self::NodeConfig(config) => {
                 config.graph_info.sets.push(set);
@@ -329,6 +333,10 @@ impl IntoSystemConfigs<()> for SystemConfigs {
             set.system_type().is_none(),
             "adding arbitrary systems to a system type set is not allowed"
         );
+        assert!(
+            set.reads_component().is_none() && set.writes_component().is_none(),
+            "adding arbitrary systems to a world access set is not allowed"
+        );
 
         self.in_set_dyn(set.dyn_clone());
 
@@ -409,6 +417,10 @@ impl SystemSetConfig {
             set.system_type().is_none(),
             "configuring system type sets is not allowed"
         );
+        assert!(
+            set.reads_component().is_none() && set.writes_component().is_none(),
+            "configuring world access sets is not allowed"
+        );
 
         Self {
             node: set,