Use non-poisoning locks engine-wide

crates/bevy_anti_alias/src/contrast_adaptive_sharpening/node.rs

@@ -1,7 +1,6 @@
-use std::sync::Mutex;
-
 use crate::contrast_adaptive_sharpening::ViewCasPipeline;
 use bevy_ecs::prelude::*;
+use bevy_platform::sync::Mutex;
 use bevy_render::{
     diagnostic::RecordDiagnostics,
     extract_component::{ComponentUniforms, DynamicUniformIndex},
@@ -73,7 +72,7 @@ impl Node for CasNode {
         let source = view_target.source;
         let destination = view_target.destination;
 
-        let mut cached_bind_group = self.cached_bind_group.lock().unwrap();
+        let mut cached_bind_group = self.cached_bind_group.lock();
         let bind_group = match &mut *cached_bind_group {
             Some((buffer_id, texture_id, bind_group))
                 if source.id() == *texture_id && uniforms_id == *buffer_id =>

crates/bevy_anti_alias/src/dlss/node.rs

@@ -72,7 +72,7 @@ impl ViewNode for DlssNode<DlssSuperResolutionFeature> {
 
         let diagnostics = render_context.diagnostic_recorder();
         let command_encoder = render_context.command_encoder();
-        let mut dlss_context = dlss_context.context.lock().unwrap();
+        let mut dlss_context = dlss_context.context.lock();
 
         command_encoder.push_debug_group("dlss_super_resolution");
         let time_span = diagnostics.time_span(command_encoder, "dlss_super_resolution");
@@ -148,7 +148,7 @@ impl ViewNode for DlssNode<DlssRayReconstructionFeature> {
 
         let diagnostics = render_context.diagnostic_recorder();
         let command_encoder = render_context.command_encoder();
-        let mut dlss_context = dlss_context.context.lock().unwrap();
+        let mut dlss_context = dlss_context.context.lock();
 
         command_encoder.push_debug_group("dlss_ray_reconstruction");
         let time_span = diagnostics.time_span(command_encoder, "dlss_ray_reconstruction");

crates/bevy_anti_alias/src/dlss/prepare.rs

@@ -9,14 +9,14 @@ use bevy_ecs::{
     system::{Commands, Query, Res},
 };
 use bevy_math::Vec4Swizzles;
+use bevy_platform::sync::{Arc, Mutex};
 use bevy_render::{
     camera::{MipBias, TemporalJitter},
     render_resource::TextureUsages,
     renderer::{RenderDevice, RenderQueue},
     view::ExtractedView,
 };
 use dlss_wgpu::{DlssFeatureFlags, DlssPerfQualityMode};
-use std::sync::{Arc, Mutex};
 
 #[derive(Component)]
 pub struct DlssRenderContext<F: DlssFeature> {
@@ -76,12 +76,11 @@ pub fn prepare_dlss<F: DlssFeature>(
 
         match dlss_context.as_deref_mut() {
             Some(dlss_context)
-                if upscaled_resolution
-                    == F::upscaled_resolution(&dlss_context.context.lock().unwrap())
+                if upscaled_resolution == F::upscaled_resolution(&dlss_context.context.lock())
                     && dlss.perf_quality_mode == dlss_context.perf_quality_mode
                     && dlss_feature_flags == dlss_context.feature_flags =>
             {
-                let dlss_context = dlss_context.context.lock().unwrap();
+                let dlss_context = dlss_context.context.lock();
                 let render_resolution = F::render_resolution(&dlss_context);
                 temporal_jitter.offset =
                     F::suggested_jitter(&dlss_context, frame_count.0, render_resolution);

crates/bevy_anti_alias/src/fxaa/node.rs

@@ -1,7 +1,6 @@
-use std::sync::Mutex;
-
 use crate::fxaa::{CameraFxaaPipeline, Fxaa, FxaaPipeline};
 use bevy_ecs::{prelude::*, query::QueryItem};
+use bevy_platform::sync::Mutex;
 use bevy_render::{
     diagnostic::RecordDiagnostics,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
@@ -48,7 +47,7 @@ impl ViewNode for FxaaNode {
         let post_process = target.post_process_write();
         let source = post_process.source;
         let destination = post_process.destination;
-        let mut cached_bind_group = self.cached_texture_bind_group.lock().unwrap();
+        let mut cached_bind_group = self.cached_texture_bind_group.lock();
         let bind_group = match &mut *cached_bind_group {
             Some((id, bind_group)) if source.id() == *id => bind_group,
             cached_bind_group => {

crates/bevy_asset/src/lib.rs

@@ -727,7 +727,10 @@ mod tests {
         prelude::*,
         schedule::{LogLevel, ScheduleBuildSettings},
     };
-    use bevy_platform::collections::{HashMap, HashSet};
+    use bevy_platform::{
+        collections::{HashMap, HashSet},
+        sync::Mutex,
+    };
     use bevy_reflect::TypePath;
     use core::time::Duration;
     use serde::{Deserialize, Serialize};
@@ -823,7 +826,7 @@ mod tests {
     /// A dummy [`CoolText`] asset reader that only succeeds after `failure_count` times it's read from for each asset.
     #[derive(Default, Clone)]
     pub struct UnstableMemoryAssetReader {
-        pub attempt_counters: Arc<std::sync::Mutex<HashMap<Box<Path>, usize>>>,
+        pub attempt_counters: Arc<Mutex<HashMap<Box<Path>, usize>>>,
         pub load_delay: Duration,
         memory_reader: MemoryAssetReader,
         failure_count: usize,
@@ -858,7 +861,7 @@ mod tests {
         }
         async fn read<'a>(&'a self, path: &'a Path) -> Result<impl Reader + 'a, AssetReaderError> {
             let attempt_number = {
-                let mut attempt_counters = self.attempt_counters.lock().unwrap();
+                let mut attempt_counters = self.attempt_counters.lock();
                 if let Some(existing) = attempt_counters.get_mut(path) {
                     *existing += 1;
                     *existing

crates/bevy_core_pipeline/src/tonemapping/node.rs

@@ -1,8 +1,7 @@
-use std::sync::Mutex;
-
 use crate::tonemapping::{TonemappingLuts, TonemappingPipeline, ViewTonemappingPipeline};
 
 use bevy_ecs::{prelude::*, query::QueryItem};
+use bevy_platform::sync::Mutex;
 use bevy_render::{
     diagnostic::RecordDiagnostics,
     render_asset::RenderAssets,
@@ -67,7 +66,7 @@ impl ViewNode for TonemappingNode {
         let source = post_process.source;
         let destination = post_process.destination;
 
-        let mut last_tonemapping = self.last_tonemapping.lock().unwrap();
+        let mut last_tonemapping = self.last_tonemapping.lock();
 
         let tonemapping_changed = if let Some(last_tonemapping) = &*last_tonemapping {
             tonemapping != last_tonemapping
@@ -78,7 +77,7 @@ impl ViewNode for TonemappingNode {
             *last_tonemapping = Some(*tonemapping);
         }
 
-        let mut cached_bind_group = self.cached_bind_group.lock().unwrap();
+        let mut cached_bind_group = self.cached_bind_group.lock();
         let bind_group = match &mut *cached_bind_group {
             Some((buffer_id, texture_id, lut_id, bind_group))
                 if view_uniforms_id == *buffer_id

crates/bevy_core_pipeline/src/upscaling/node.rs

@@ -1,6 +1,7 @@
 use crate::{blit::BlitPipeline, upscaling::ViewUpscalingPipeline};
 use bevy_camera::{CameraOutputMode, ClearColor, ClearColorConfig};
 use bevy_ecs::{prelude::*, query::QueryItem};
+use bevy_platform::sync::Mutex;
 use bevy_render::{
     camera::ExtractedCamera,
     diagnostic::RecordDiagnostics,
@@ -9,7 +10,6 @@ use bevy_render::{
     renderer::RenderContext,
     view::ViewTarget,
 };
-use std::sync::Mutex;
 
 #[derive(Default)]
 pub struct UpscalingNode {
@@ -53,7 +53,7 @@ impl ViewNode for UpscalingNode {
         // texture to be upscaled to the output texture
         let main_texture_view = target.main_texture_view();
 
-        let mut cached_bind_group = self.cached_texture_bind_group.lock().unwrap();
+        let mut cached_bind_group = self.cached_texture_bind_group.lock();
         let bind_group = match &mut *cached_bind_group {
             Some((id, bind_group)) if main_texture_view.id() == *id => bind_group,
             cached_bind_group => {

crates/bevy_ecs/src/component/info.rs

@@ -1,5 +1,5 @@
 use alloc::{borrow::Cow, vec::Vec};
-use bevy_platform::{hash::FixedHasher, sync::PoisonError};
+use bevy_platform::hash::FixedHasher;
 use bevy_ptr::OwningPtr;
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
@@ -392,7 +392,7 @@ impl Components {
     /// Returns the number of components registered with this instance.
     #[inline]
     pub fn num_queued(&self) -> usize {
-        let queued = self.queued.read().unwrap_or_else(PoisonError::into_inner);
+        let queued = self.queued.read();
         queued.components.len() + queued.dynamic_registrations.len() + queued.resources.len()
     }
 
@@ -405,10 +405,7 @@ impl Components {
     /// A faster version of [`Self::num_queued`].
     #[inline]
     pub fn num_queued_mut(&mut self) -> usize {
-        let queued = self
-            .queued
-            .get_mut()
-            .unwrap_or_else(PoisonError::into_inner);
+        let queued = self.queued.get_mut();
         queued.components.len() + queued.dynamic_registrations.len() + queued.resources.len()
     }
 
@@ -451,7 +448,7 @@ impl Components {
             .get(id.0)
             .and_then(|info| info.as_ref().map(|info| Cow::Borrowed(&info.descriptor)))
             .or_else(|| {
-                let queued = self.queued.read().unwrap_or_else(PoisonError::into_inner);
+                let queued = self.queued.read();
                 // first check components, then resources, then dynamic
                 queued
                     .components
@@ -473,7 +470,7 @@ impl Components {
             .get(id.0)
             .and_then(|info| info.as_ref().map(|info| info.descriptor.name()))
             .or_else(|| {
-                let queued = self.queued.read().unwrap_or_else(PoisonError::into_inner);
+                let queued = self.queued.read();
                 // first check components, then resources, then dynamic
                 queued
                     .components
@@ -622,7 +619,6 @@ impl Components {
         self.indices.get(&type_id).copied().or_else(|| {
             self.queued
                 .read()
-                .unwrap_or_else(PoisonError::into_inner)
                 .components
                 .get(&type_id)
                 .map(|queued| queued.id)
@@ -669,7 +665,6 @@ impl Components {
         self.resource_indices.get(&type_id).copied().or_else(|| {
             self.queued
                 .read()
-                .unwrap_or_else(PoisonError::into_inner)
                 .resources
                 .get(&type_id)
                 .map(|queued| queued.id)

crates/bevy_ecs/src/component/register.rs

@@ -1,5 +1,4 @@
 use alloc::{boxed::Box, vec::Vec};
-use bevy_platform::sync::PoisonError;
 use bevy_utils::TypeIdMap;
 use core::any::Any;
 use core::{any::TypeId, fmt::Debug, ops::Deref};
@@ -125,11 +124,7 @@ impl<'w> ComponentsRegistrator<'w> {
 
         // components
         while let Some(registrator) = {
-            let queued = self
-                .components
-                .queued
-                .get_mut()
-                .unwrap_or_else(PoisonError::into_inner);
+            let queued = self.components.queued.get_mut();
             queued.components.keys().next().copied().map(|type_id| {
                 // SAFETY: the id just came from a valid iterator.
                 unsafe { queued.components.remove(&type_id).debug_checked_unwrap() }
@@ -140,11 +135,7 @@ impl<'w> ComponentsRegistrator<'w> {
 
         // resources
         while let Some(registrator) = {
-            let queued = self
-                .components
-                .queued
-                .get_mut()
-                .unwrap_or_else(PoisonError::into_inner);
+            let queued = self.components.queued.get_mut();
             queued.resources.keys().next().copied().map(|type_id| {
                 // SAFETY: the id just came from a valid iterator.
                 unsafe { queued.resources.remove(&type_id).debug_checked_unwrap() }
@@ -154,11 +145,7 @@ impl<'w> ComponentsRegistrator<'w> {
         }
 
         // dynamic
-        let queued = &mut self
-            .components
-            .queued
-            .get_mut()
-            .unwrap_or_else(PoisonError::into_inner);
+        let queued = &mut self.components.queued.get_mut();
         if !queued.dynamic_registrations.is_empty() {
             for registrator in core::mem::take(&mut queued.dynamic_registrations) {
                 registrator.register(self);
@@ -188,14 +175,7 @@ impl<'w> ComponentsRegistrator<'w> {
             return id;
         }
 
-        if let Some(registrator) = self
-            .components
-            .queued
-            .get_mut()
-            .unwrap_or_else(PoisonError::into_inner)
-            .components
-            .remove(&type_id)
-        {
+        if let Some(registrator) = self.components.queued.get_mut().components.remove(&type_id) {
             // If we are trying to register something that has already been queued, we respect the queue.
             // Just like if we are trying to register something that already is, we respect the first registration.
             return registrator.register(self);
@@ -325,14 +305,7 @@ impl<'w> ComponentsRegistrator<'w> {
             return *id;
         }
 
-        if let Some(registrator) = self
-            .components
-            .queued
-            .get_mut()
-            .unwrap_or_else(PoisonError::into_inner)
-            .resources
-            .remove(&type_id)
-        {
+        if let Some(registrator) = self.components.queued.get_mut().resources.remove(&type_id) {
             // If we are trying to register something that has already been queued, we respect the queue.
             // Just like if we are trying to register something that already is, we respect the first registration.
             return registrator.register(self);
@@ -500,7 +473,6 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
         self.components
             .queued
             .write()
-            .unwrap_or_else(PoisonError::into_inner)
             .components
             .entry(type_id)
             .or_insert_with(|| {
@@ -525,7 +497,6 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
         self.components
             .queued
             .write()
-            .unwrap_or_else(PoisonError::into_inner)
             .resources
             .entry(type_id)
             .or_insert_with(|| {
@@ -542,15 +513,10 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
         func: impl FnOnce(&mut ComponentsRegistrator, ComponentId, ComponentDescriptor) + 'static,
     ) -> ComponentId {
         let id = self.ids.next();
-        self.components
-            .queued
-            .write()
-            .unwrap_or_else(PoisonError::into_inner)
-            .dynamic_registrations
-            .push(
-                // SAFETY: The id was just generated.
-                unsafe { QueuedRegistration::new(id, descriptor, func) },
-            );
+        self.components.queued.write().dynamic_registrations.push(
+            // SAFETY: The id was just generated.
+            unsafe { QueuedRegistration::new(id, descriptor, func) },
+        );
         id
     }
 

crates/bevy_ecs/src/intern.rs

@@ -5,11 +5,7 @@
 //! and make comparisons for any type as fast as integers.
 
 use alloc::{borrow::ToOwned, boxed::Box};
-use bevy_platform::{
-    collections::HashSet,
-    hash::FixedHasher,
-    sync::{PoisonError, RwLock},
-};
+use bevy_platform::{collections::HashSet, hash::FixedHasher, sync::RwLock};
 use core::{fmt::Debug, hash::Hash, ops::Deref};
 
 /// An interned value. Will stay valid until the end of the program and will not drop.
@@ -140,15 +136,15 @@ impl<T: Internable + ?Sized> Interner<T> {
     /// will return [`Interned<T>`] using the same static reference.
     pub fn intern(&self, value: &T) -> Interned<T> {
         {
-            let set = self.0.read().unwrap_or_else(PoisonError::into_inner);
+            let set = self.0.read();
 
             if let Some(value) = set.get(value) {
                 return Interned(*value);
             }
         }
 
         {
-            let mut set = self.0.write().unwrap_or_else(PoisonError::into_inner);
+            let mut set = self.0.write();
 
             if let Some(value) = set.get(value) {
                 Interned(*value)