Return InvertibleComponentIdSet from Access for reads_and_writes

Author: Zeophlite

_release-content/migration-guides/access_is_invertible.md

@@ -0,0 +1,16 @@
+---
+title: "Reads and writes from `Access` are exposed"
+pull_requests: []
+---
+
+Removed from [`bevy_ecs::query::Access`] methods that gave `Result<ComponentIdSet, UnboundedAccessError>>`:
+
+- `try_reads_and_writes()`
+- `try_writes()`
+
+Added new functions that return a new enum `InvertibleComponentIdSet`:
+
+- `reads_and_writes()`
+- `writes()`
+
+The `try_` methods would fail for exclusion queries.

crates/bevy_ecs/src/query/access.rs

@@ -419,30 +419,22 @@ impl Access {
         &self.archetypal
     }
 
-    /// Returns the set of components with read or write access,
-    /// or an error if the access is unbounded.
-    pub fn try_reads_and_writes(&self) -> Result<&ComponentIdSet, UnboundedAccessError> {
+    /// Returns the set of components with read or write access
+    pub fn reads_and_writes(&self) -> InvertibleComponentIdSet<'_> {
         // writes_inverted is only ever true when read_and_writes_inverted is
         // also true. Therefore it is sufficient to check just read_and_writes_inverted.
         if self.read_and_writes_inverted {
-            return Err(UnboundedAccessError {
-                writes_inverted: self.writes_inverted,
-                read_and_writes_inverted: self.read_and_writes_inverted,
-            });
+            return InvertibleComponentIdSet::Excluded(&self.read_and_writes);
         }
-        Ok(&self.read_and_writes)
+        InvertibleComponentIdSet::Included(&self.read_and_writes)
     }
 
-    /// Returns the set of components with write access,
-    /// or an error if the access is unbounded.
-    pub fn try_writes(&self) -> Result<&ComponentIdSet, UnboundedAccessError> {
+    /// Returns the set of components with write access
+    pub fn writes(&self) -> InvertibleComponentIdSet<'_> {
         if self.writes_inverted {
-            return Err(UnboundedAccessError {
-                writes_inverted: self.writes_inverted,
-                read_and_writes_inverted: self.read_and_writes_inverted,
-            });
+            return InvertibleComponentIdSet::Excluded(&self.writes);
         }
-        Ok(&self.writes)
+        InvertibleComponentIdSet::Included(&self.writes)
     }
 
     /// Returns an iterator over the component IDs and their [`ComponentAccessKind`].
@@ -478,7 +470,16 @@ impl Access {
     pub fn try_iter_access(
         &self,
     ) -> Result<impl Iterator<Item = ComponentAccessKind> + '_, UnboundedAccessError> {
-        let reads_and_writes = self.try_reads_and_writes()?.iter().map(|index| {
+        let a = self.reads_and_writes();
+
+        let InvertibleComponentIdSet::Included(b) = a else {
+            return Err(UnboundedAccessError {
+                writes_inverted: self.writes_inverted,
+                read_and_writes_inverted: self.read_and_writes_inverted,
+            });
+        };
+
+        let reads_and_writes = b.iter().map(|index| {
             if self.writes.contains(index) {
                 ComponentAccessKind::Exclusive(index)
             } else {
@@ -495,6 +496,15 @@ impl Access {
     }
 }
 
+/// Either all or nothing in a [`ComponentIdSet`]
+#[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
+pub enum InvertibleComponentIdSet<'a> {
+    /// All components in the set
+    Included(&'a ComponentIdSet),
+    /// All components *not* in the set
+    Excluded(&'a ComponentIdSet),
+}
+
 /// Performs an in-place union of `other` into `self`, where either set may be inverted.
 ///
 /// Each set corresponds to a `FixedBitSet` if `inverted` is `false`,