[Merged by Bors] - Panic on dropping NonSend in non-origin thread.

crates/bevy_ecs/src/storage/resource.rs

@@ -2,17 +2,40 @@ use crate::archetype::ArchetypeComponentId;
 use crate::component::{ComponentId, ComponentTicks, Components};
 use crate::storage::{Column, SparseSet};
 use bevy_ptr::{OwningPtr, Ptr, UnsafeCellDeref};
+use bevy_utils::tracing::error;
 use std::cell::UnsafeCell;
+use std::thread::ThreadId;
 
 /// The type-erased backing storage and metadata for a single resource within a [`World`].
 ///
 /// [`World`]: crate::world::World
 pub struct ResourceData {
     column: Column,
     id: ArchetypeComponentId,
+    origin_thread_id: Option<ThreadId>,
+}
+
+impl Drop for ResourceData {
+    fn drop(&mut self) {
+        self.validate_drop();
+    }
 }
 
 impl ResourceData {
+    #[inline]
+    fn validate_drop(&self) {
+        if let Some(origin_thread_id) = self.origin_thread_id {
+            if origin_thread_id != std::thread::current().id() {
+                error!(
+                    "Attempted to drop non-send resource from thread {:?} on a thread {:?}. This is not allowed. Aborting.",
+                    origin_thread_id,
+                    std::thread::current().id()
+                );
+                std::process::abort();
+            }
+        }
+    }
+
     /// Returns true if the resource is populated.
     #[inline]
     pub fn is_present(&self) -> bool {
@@ -60,6 +83,9 @@ impl ResourceData {
     /// [`World::validate_non_send_access_untyped`]: crate::world::World::validate_non_send_access_untyped
     #[inline]
     pub(crate) unsafe fn insert(&mut self, value: OwningPtr<'_>, change_tick: u32) {
+        if self.origin_thread_id.is_some() {
+            self.origin_thread_id = Some(std::thread::current().id());
+        }
         if self.is_present() {
             self.column.replace(0, value, change_tick);
         } else {
@@ -115,6 +141,7 @@ impl ResourceData {
     /// [`World::validate_non_send_access_untyped`]: crate::world::World::validate_non_send_access_untyped
     #[inline]
     pub(crate) unsafe fn remove_and_drop(&mut self) {
+        self.validate_drop();
         self.column.clear();
     }
 }
@@ -162,17 +189,22 @@ impl Resources {
     ///
     /// # Panics
     /// Will panic if `component_id` is not valid for the provided `components`
-    pub(crate) fn initialize_with(
+    ///
+    /// # Safety
+    /// `is_send` must be accurate for the Resource that is being initialized.
+    pub(crate) unsafe fn initialize_with(
         &mut self,
         component_id: ComponentId,
         components: &Components,
+        is_send: bool,
         f: impl FnOnce() -> ArchetypeComponentId,
     ) -> &mut ResourceData {
         self.resources.get_or_insert_with(component_id, || {
             let component_info = components.get_info(component_id).unwrap();
             ResourceData {
                 column: Column::with_capacity(component_info, 1),
                 id: f(),
+                origin_thread_id: (!is_send).then(|| std::thread::current().id()),
             }
         })
     }

crates/bevy_ecs/src/world/mod.rs

@@ -739,7 +739,7 @@ impl World {
         OwningPtr::make(value, |ptr| {
             // SAFETY: component_id was just initialized and corresponds to resource of type R
             unsafe {
-                self.insert_resource_by_id(component_id, ptr);
+                self.insert_resource_by_id(component_id, true, ptr);
             }
         });
     }
@@ -779,7 +779,7 @@ impl World {
         OwningPtr::make(value, |ptr| {
             // SAFETY: component_id was just initialized and corresponds to resource of type R
             unsafe {
-                self.insert_resource_by_id(component_id, ptr);
+                self.insert_resource_by_id(component_id, false, ptr);
             }
         });
     }
@@ -1311,31 +1311,36 @@ impl World {
     ///
     /// # Safety
     /// The value referenced by `value` must be valid for the given [`ComponentId`] of this world
-    /// `component_id` must exist in this [`World`]
+    /// `component_id` must exist in this [`World`]. `is_send` must correspond to whether the resource
+    /// adheres to invariants of `Send`.
     #[inline]
     pub unsafe fn insert_resource_by_id(
         &mut self,
         component_id: ComponentId,
+        is_send: bool,
         value: OwningPtr<'_>,
     ) {
         let change_tick = self.change_tick();
 
-        // SAFETY: component_id is valid, ensured by caller
-        self.initialize_resource_internal(component_id)
+        // SAFETY: component_id and is_send are valid, ensured by caller
+        self.initialize_resource_internal(component_id, is_send)
             .insert(value, change_tick);
     }
 
     /// # Safety
     /// `component_id` must be valid for this world
+    /// `is_send` should correspond for the resource being initialized.
     #[inline]
     unsafe fn initialize_resource_internal(
         &mut self,
         component_id: ComponentId,
+        is_send: bool,
     ) -> &mut ResourceData {
         let archetype_component_count = &mut self.archetypes.archetype_component_count;
+        // SAFETY: Caller guarentees that `is_send` matches the underlying type.
         self.storages
             .resources
-            .initialize_with(component_id, &self.components, || {
+            .initialize_with(component_id, &self.components, is_send, || {
                 let id = ArchetypeComponentId::new(*archetype_component_count);
                 *archetype_component_count += 1;
                 id
@@ -1344,15 +1349,15 @@ impl World {
 
     pub(crate) fn initialize_resource<R: Resource>(&mut self) -> ComponentId {
         let component_id = self.components.init_resource::<R>();
-        // SAFETY: resource initialized above
-        unsafe { self.initialize_resource_internal(component_id) };
+        // SAFETY: resource initialized above, resource type must be Send
+        unsafe { self.initialize_resource_internal(component_id, true) };
         component_id
     }
 
     pub(crate) fn initialize_non_send_resource<R: 'static>(&mut self) -> ComponentId {
         let component_id = self.components.init_non_send::<R>();
-        // SAFETY: resource initialized above
-        unsafe { self.initialize_resource_internal(component_id) };
+        // SAFETY: resource initialized above, resource type might not be send
+        unsafe { self.initialize_resource_internal(component_id, false) };
         component_id
     }
 
@@ -1794,7 +1799,7 @@ mod tests {
         OwningPtr::make(value, |ptr| {
             // SAFETY: value is valid for the component layout
             unsafe {
-                world.insert_resource_by_id(component_id, ptr);
+                world.insert_resource_by_id(component_id, true, ptr);
             }
         });