InteriorMutableWorld -> UnsafeWorldCell

Author: jakobhellermann

crates/bevy_asset/src/reflect.rs

@@ -1,6 +1,6 @@
 use std::any::{Any, TypeId};
 
-use bevy_ecs::world::{interior_mutable_world::InteriorMutableWorld, World};
+use bevy_ecs::world::{unsafe_world_cell::UnsafeWorldCell, World};
 use bevy_reflect::{FromReflect, FromType, Reflect, Uuid};
 
 use crate::{Asset, Assets, Handle, HandleId, HandleUntyped};
@@ -21,8 +21,7 @@ pub struct ReflectAsset {
     // SAFETY:
     // - may only be called with a [`IteriorMutableWorld`] which can be used to access the corresponding `Assets<T>` resource mutably
     // - may only be used to access **at most one** access at once
-    get_unchecked_mut:
-        unsafe fn(InteriorMutableWorld<'_>, HandleUntyped) -> Option<&mut dyn Reflect>,
+    get_unchecked_mut: unsafe fn(UnsafeWorldCell<'_>, HandleUntyped) -> Option<&mut dyn Reflect>,
     add: fn(&mut World, &dyn Reflect) -> HandleUntyped,
     set: fn(&mut World, HandleUntyped, &dyn Reflect) -> HandleUntyped,
     len: fn(&World) -> usize,
@@ -58,10 +57,10 @@ impl ReflectAsset {
         handle: HandleUntyped,
     ) -> Option<&'w mut dyn Reflect> {
         // SAFETY: unique world access
-        unsafe { (self.get_unchecked_mut)(world.as_interior_mutable(), handle) }
+        unsafe { (self.get_unchecked_mut)(world.as_unsafe_world_cell(), handle) }
     }
 
-    /// Equivalent of [`Assets::get_mut`], but works with an [`InteriorMutableWorld`].
+    /// Equivalent of [`Assets::get_mut`], but works with an [`UnsafeWorldCell`].
     ///
     /// Only use this method when you have ensured that you are the *only* one with access to the [`Assets`] resource of the asset type.
     /// Furthermore, this does *not* allow you to have look up two distinct handles,
@@ -74,9 +73,9 @@ impl ReflectAsset {
     /// # let mut world: World = unimplemented!();
     /// # let handle_1: HandleUntyped = unimplemented!();
     /// # let handle_2: HandleUntyped = unimplemented!();
-    /// let interior_mutable_world = world.as_interior_mutable();
-    /// let a = unsafe { reflect_asset.get_unchecked_mut(interior_mutable_world, handle_1).unwrap() };
-    /// let b = unsafe { reflect_asset.get_unchecked_mut(interior_mutable_world, handle_2).unwrap() };
+    /// let unsafe_world_cell = world.as_unsafe_world_cell();
+    /// let a = unsafe { reflect_asset.get_unchecked_mut(unsafe_world_cell, handle_1).unwrap() };
+    /// let b = unsafe { reflect_asset.get_unchecked_mut(unsafe_world_cell, handle_2).unwrap() };
     /// // ^ not allowed, two mutable references through the same asset resource, even though the
     /// // handles are distinct
     ///
@@ -86,11 +85,11 @@ impl ReflectAsset {
     /// # Safety
     /// This method does not prevent you from having two mutable pointers to the same data,
     /// violating Rust's aliasing rules. To avoid this:
-    /// * Only call this method if you know that the [`InteriorMutableWorld`] may be used to access the corresponding `Assets<T>`
+    /// * Only call this method if you know that the [`UnsafeWorldCell`] may be used to access the corresponding `Assets<T>`
     /// * Don't call this method more than once in the same scope.
     pub unsafe fn get_unchecked_mut<'w>(
         &self,
-        world: InteriorMutableWorld<'w>,
+        world: UnsafeWorldCell<'w>,
         handle: HandleUntyped,
     ) -> Option<&'w mut dyn Reflect> {
         // SAFETY: requirements are deferred to the caller
@@ -145,7 +144,7 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
                 asset.map(|asset| asset as &dyn Reflect)
             },
             get_unchecked_mut: |world, handle| {
-                // SAFETY: `get_unchecked_mut` must be callied with `InteriorMutableWorld` having access to `Assets<A>`,
+                // SAFETY: `get_unchecked_mut` must be callied with `UnsafeWorldCell` having access to `Assets<A>`,
                 // and must ensure to only have at most one reference to it live at all times.
                 let assets = unsafe { world.get_resource_mut::<Assets<A>>().unwrap().into_inner() };
                 let asset = assets.get_mut(&handle.typed());

crates/bevy_ecs/src/reflect.rs

@@ -5,7 +5,7 @@ use crate::{
     component::Component,
     entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
     system::Resource,
-    world::{interior_mutable_world::InteriorMutableWorld, FromWorld, World},
+    world::{unsafe_world_cell::UnsafeWorldCell, FromWorld, World},
 };
 use bevy_reflect::{
     impl_from_reflect_value, impl_reflect_value, FromType, Reflect, ReflectDeserialize,
@@ -54,8 +54,8 @@ pub struct ReflectComponentFns {
     /// Function pointer implementing [`ReflectComponent::reflect_mut()`].
     ///
     /// # Safety
-    /// The function may only be called with an [`InteriorMutableWorld`] that can be used to mutably access the relevant component on the given entity.
-    pub reflect_mut: unsafe fn(InteriorMutableWorld<'_>, Entity) -> Option<Mut<'_, dyn Reflect>>,
+    /// The function may only be called with an [`UnsafeWorldCell`] that can be used to mutably access the relevant component on the given entity.
+    pub reflect_mut: unsafe fn(UnsafeWorldCell<'_>, Entity) -> Option<Mut<'_, dyn Reflect>>,
     /// Function pointer implementing [`ReflectComponent::copy()`].
     pub copy: fn(&World, &mut World, Entity, Entity),
 }
@@ -120,17 +120,17 @@ impl ReflectComponent {
         entity: Entity,
     ) -> Option<Mut<'a, dyn Reflect>> {
         // SAFETY: unique world access
-        unsafe { (self.0.reflect_mut)(world.as_interior_mutable(), entity) }
+        unsafe { (self.0.reflect_mut)(world.as_unsafe_world_cell(), entity) }
     }
 
     /// # Safety
     /// This method does not prevent you from having two mutable pointers to the same data,
     /// violating Rust's aliasing rules. To avoid this:
-    /// * Only call this method with a [`InteriorMutableWorld`] that may be used to mutably access the component on the entity `entity`
+    /// * Only call this method with a [`UnsafeWorldCell`] that may be used to mutably access the component on the entity `entity`
     /// * Don't call this method more than once in the same scope for a given [`Component`].
     pub unsafe fn reflect_unchecked_mut<'a>(
         &self,
-        world: InteriorMutableWorld<'a>,
+        world: UnsafeWorldCell<'a>,
         entity: Entity,
     ) -> Option<Mut<'a, dyn Reflect>> {
         // SAFETY: safety requirements deferred to caller
@@ -213,7 +213,7 @@ impl<C: Component + Reflect + FromWorld> FromType<C> for ReflectComponent {
             },
             reflect_mut: |world, entity| {
                 // SAFETY: reflect_mut is an unsafe function pointer used by
-                // 1. `reflect_unchecked_mut` which must be called with an InteriorMutableWorld with access to the the component `C` on the `entity`, and
+                // 1. `reflect_unchecked_mut` which must be called with an UnsafeWorldCell with access to the the component `C` on the `entity`, and
                 // 2. `reflect_mut`, which has mutable world access
                 unsafe {
                     world.get_entity(entity)?.get_mut::<C>().map(|c| Mut {
@@ -268,8 +268,8 @@ pub struct ReflectResourceFns {
     /// Function pointer implementing [`ReflectResource::reflect_unchecked_mut()`].
     ///
     /// # Safety
-    /// The function may only be called with an [`InteriorMutableWorld`] that can be used to mutably access the relevant resource.
-    pub reflect_unchecked_mut: unsafe fn(InteriorMutableWorld<'_>) -> Option<Mut<'_, dyn Reflect>>,
+    /// The function may only be called with an [`UnsafeWorldCell`] that can be used to mutably access the relevant resource.
+    pub reflect_unchecked_mut: unsafe fn(UnsafeWorldCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
     /// Function pointer implementing [`ReflectResource::copy()`].
     pub copy: fn(&World, &mut World),
 }
@@ -318,17 +318,17 @@ impl ReflectResource {
     /// Gets the value of this [`Resource`] type from the world as a mutable reflected reference.
     pub fn reflect_mut<'a>(&self, world: &'a mut World) -> Option<Mut<'a, dyn Reflect>> {
         // SAFETY: unique world access
-        unsafe { (self.0.reflect_unchecked_mut)(world.as_interior_mutable()) }
+        unsafe { (self.0.reflect_unchecked_mut)(world.as_unsafe_world_cell()) }
     }
 
     /// # Safety
     /// This method does not prevent you from having two mutable pointers to the same data,
     /// violating Rust's aliasing rules. To avoid this:
-    /// * Only call this method with an [`InteriorMutableWorld`] which can be used to mutably access the resource.
+    /// * Only call this method with an [`UnsafeWorldCell`] which can be used to mutably access the resource.
     /// * Don't call this method more than once in the same scope for a given [`Resource`].
     pub unsafe fn reflect_unchecked_mut<'w>(
         &self,
-        world: InteriorMutableWorld<'w>,
+        world: UnsafeWorldCell<'w>,
     ) -> Option<Mut<'w, dyn Reflect>> {
         // SAFETY: caller promises to uphold uniqueness guarantees
         (self.0.reflect_unchecked_mut)(world)

crates/bevy_ecs/src/system/query.rs

@@ -1134,7 +1134,7 @@ impl<'w, 's, Q: WorldQuery, F: ReadOnlyWorldQuery> Query<'w, 's, Q, F> {
         }
         let world = self.world;
         let entity_ref = world
-            .as_interior_mutable_migration_internal()
+            .as_unsafe_world_cell_migration_internal()
             .get_entity(entity)
             .ok_or(QueryComponentError::NoSuchEntity)?;
         let component_id = world

crates/bevy_ecs/src/system/system_param.rs

@@ -541,7 +541,7 @@ unsafe impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
         change_tick: u32,
     ) -> Self::Item<'w, 's> {
         let value = world
-            .as_interior_mutable_migration_internal()
+            .as_unsafe_world_cell_migration_internal()
             .get_resource_mut_with_id(component_id)
             .unwrap_or_else(|| {
                 panic!(
@@ -579,7 +579,7 @@ unsafe impl<'a, T: Resource> SystemParam for Option<ResMut<'a, T>> {
         change_tick: u32,
     ) -> Self::Item<'w, 's> {
         world
-            .as_interior_mutable_migration_internal()
+            .as_unsafe_world_cell_migration_internal()
             .get_resource_mut_with_id(component_id)
             .map(|value| ResMut {
                 value: value.value,

crates/bevy_ecs/src/world/entity_ref.rs

@@ -13,7 +13,7 @@ use bevy_ptr::{OwningPtr, Ptr};
 use bevy_utils::tracing::debug;
 use std::any::TypeId;
 
-use super::interior_mutable_world::InteriorMutableEntityRef;
+use super::unsafe_world_cell::UnsafeEntityRefCell;
 
 /// A read-only reference to a particular [`Entity`] and all of its components
 #[derive(Copy, Clone)]
@@ -42,9 +42,9 @@ impl<'w> EntityRef<'w> {
         }
     }
 
-    fn as_interior_mutable_readonly(&self) -> InteriorMutableEntityRef<'w> {
-        InteriorMutableEntityRef::new(
-            self.world.as_interior_mutable_readonly(),
+    fn as_unsafe_world_cell_readonly(&self) -> UnsafeEntityRefCell<'w> {
+        UnsafeEntityRefCell::new(
+            self.world.as_unsafe_world_cell_readonly(),
             self.entity,
             self.location,
         )
@@ -89,15 +89,15 @@ impl<'w> EntityRef<'w> {
     #[inline]
     pub fn get<T: Component>(&self) -> Option<&'w T> {
         // SAFETY: &self implies shared access for duration of returned value
-        unsafe { self.as_interior_mutable_readonly().get::<T>() }
+        unsafe { self.as_unsafe_world_cell_readonly().get::<T>() }
     }
 
     /// Retrieves the change ticks for the given component. This can be useful for implementing change
     /// detection in custom runtimes.
     #[inline]
     pub fn get_change_ticks<T: Component>(&self) -> Option<ComponentTicks> {
         // SAFETY: &self implies shared access
-        unsafe { self.as_interior_mutable_readonly().get_change_ticks::<T>() }
+        unsafe { self.as_unsafe_world_cell_readonly().get_change_ticks::<T>() }
     }
 
     /// Retrieves the change ticks for the given [`ComponentId`]. This can be useful for implementing change
@@ -110,7 +110,7 @@ impl<'w> EntityRef<'w> {
     pub fn get_change_ticks_by_id(&self, component_id: ComponentId) -> Option<ComponentTicks> {
         // SAFETY: &self implies shared access
         unsafe {
-            self.as_interior_mutable_readonly()
+            self.as_unsafe_world_cell_readonly()
                 .get_change_ticks_by_id(component_id)
         }
     }
@@ -128,7 +128,7 @@ impl<'w> EntityRef<'w> {
     #[inline]
     pub fn get_by_id(&self, component_id: ComponentId) -> Option<Ptr<'w>> {
         // SAFETY: &self implies shared access for duration of returned value
-        unsafe { self.as_interior_mutable_readonly().get_by_id(component_id) }
+        unsafe { self.as_unsafe_world_cell_readonly().get_by_id(component_id) }
     }
 }
 
@@ -148,15 +148,19 @@ pub struct EntityMut<'w> {
 }
 
 impl<'w> EntityMut<'w> {
-    fn as_interior_mutable_readonly(&self) -> InteriorMutableEntityRef<'_> {
-        InteriorMutableEntityRef::new(
-            self.world.as_interior_mutable_readonly(),
+    fn as_unsafe_world_cell_readonly(&self) -> UnsafeEntityRefCell<'_> {
+        UnsafeEntityRefCell::new(
+            self.world.as_unsafe_world_cell_readonly(),
             self.entity,
             self.location,
         )
     }
-    fn as_interior_mutable(&mut self) -> InteriorMutableEntityRef<'_> {
-        InteriorMutableEntityRef::new(self.world.as_interior_mutable(), self.entity, self.location)
+    fn as_unsafe_world_cell(&mut self) -> UnsafeEntityRefCell<'_> {
+        UnsafeEntityRefCell::new(
+            self.world.as_unsafe_world_cell(),
+            self.entity,
+            self.location,
+        )
     }
 
     /// # Safety
@@ -215,21 +219,21 @@ impl<'w> EntityMut<'w> {
     #[inline]
     pub fn get<T: Component>(&self) -> Option<&'_ T> {
         // SAFETY: &self implies shared access for duration of returned value
-        unsafe { self.as_interior_mutable_readonly().get::<T>() }
+        unsafe { self.as_unsafe_world_cell_readonly().get::<T>() }
     }
 
     #[inline]
     pub fn get_mut<T: Component>(&mut self) -> Option<Mut<'_, T>> {
         // SAFETY: &mut self implies exclusive access for duration of returned value
-        unsafe { self.as_interior_mutable().get_mut() }
+        unsafe { self.as_unsafe_world_cell().get_mut() }
     }
 
     /// Retrieves the change ticks for the given component. This can be useful for implementing change
     /// detection in custom runtimes.
     #[inline]
     pub fn get_change_ticks<T: Component>(&self) -> Option<ComponentTicks> {
         // SAFETY: &self implies shared access
-        unsafe { self.as_interior_mutable_readonly().get_change_ticks::<T>() }
+        unsafe { self.as_unsafe_world_cell_readonly().get_change_ticks::<T>() }
     }
 
     /// Retrieves the change ticks for the given [`ComponentId`]. This can be useful for implementing change
@@ -242,7 +246,7 @@ impl<'w> EntityMut<'w> {
     pub fn get_change_ticks_by_id(&self, component_id: ComponentId) -> Option<ComponentTicks> {
         // SAFETY: &self implies shared access
         unsafe {
-            self.as_interior_mutable_readonly()
+            self.as_unsafe_world_cell_readonly()
                 .get_change_ticks_by_id(component_id)
         }
     }

crates/bevy_ecs/src/world/mod.rs

@@ -1,6 +1,6 @@
 mod entity_ref;
-pub mod interior_mutable_world;
 mod spawn_batch;
+pub mod unsafe_world_cell;
 mod world_cell;
 
 pub use crate::change_detection::{Mut, Ref, CHECK_TICK_THRESHOLD};
@@ -34,7 +34,7 @@ mod identifier;
 
 pub use identifier::WorldId;
 
-use self::interior_mutable_world::InteriorMutableWorld;
+use self::unsafe_world_cell::UnsafeWorldCell;
 
 /// Stores and exposes operations on [entities](Entity), [components](Component), resources,
 /// and their associated metadata.
@@ -108,21 +108,21 @@ impl World {
         self.id
     }
 
-    /// Creates a new [`InteriorMutableWorld`] view with complete read+write access.
-    pub fn as_interior_mutable(&mut self) -> InteriorMutableWorld<'_> {
-        InteriorMutableWorld::new(self)
+    /// Creates a new [`UnsafeWorldCell`] view with complete read+write access.
+    pub fn as_unsafe_world_cell(&mut self) -> UnsafeWorldCell<'_> {
+        UnsafeWorldCell::new(self)
     }
 
-    /// Creates a new [`InteriorMutableWorld`] view with only read access to everything.
-    pub fn as_interior_mutable_readonly(&self) -> InteriorMutableWorld<'_> {
-        InteriorMutableWorld::new(self)
+    /// Creates a new [`UnsafeWorldCell`] view with only read access to everything.
+    pub fn as_unsafe_world_cell_readonly(&self) -> UnsafeWorldCell<'_> {
+        UnsafeWorldCell::new(self)
     }
 
-    /// Creates a new [`InteriorMutableWorld`] with read+write access from a [&World](World).
-    /// This is only a temporary measure until every `&World` that is semantically a [`InteriorMutableWorld`]
+    /// Creates a new [`UnsafeWorldCell`] with read+write access from a [&World](World).
+    /// This is only a temporary measure until every `&World` that is semantically a [`UnsafeWorldCell`]
     /// has been replaced.
-    pub(crate) fn as_interior_mutable_migration_internal(&self) -> InteriorMutableWorld<'_> {
-        InteriorMutableWorld::new(self)
+    pub(crate) fn as_unsafe_world_cell_migration_internal(&self) -> UnsafeWorldCell<'_> {
+        UnsafeWorldCell::new(self)
     }
 
     /// Retrieves this world's [Entities] collection
@@ -1011,7 +1011,7 @@ impl World {
     #[inline]
     pub fn get_resource_mut<R: Resource>(&mut self) -> Option<Mut<'_, R>> {
         // SAFETY: unique world access
-        unsafe { self.as_interior_mutable().get_resource_mut() }
+        unsafe { self.as_unsafe_world_cell().get_resource_mut() }
     }
 
     /// Gets a mutable reference to the resource of type `T` if it exists,
@@ -1108,7 +1108,7 @@ impl World {
     #[inline]
     pub fn get_non_send_resource_mut<R: 'static>(&mut self) -> Option<Mut<'_, R>> {
         // SAFETY: unique world access
-        unsafe { self.as_interior_mutable().get_non_send_resource_mut() }
+        unsafe { self.as_unsafe_world_cell().get_non_send_resource_mut() }
     }
 
     // Shorthand helper function for getting the data and change ticks for a resource.
@@ -1626,7 +1626,7 @@ impl World {
     pub fn get_resource_mut_by_id(&mut self, component_id: ComponentId) -> Option<MutUntyped<'_>> {
         // SAFETY: unique world access
         unsafe {
-            self.as_interior_mutable()
+            self.as_unsafe_world_cell()
                 .get_resource_mut_by_id(component_id)
         }
     }