Tests & migration guide

Author: SpecificProtagonist

crates/bevy_app/src/app.rs

@@ -1350,7 +1350,8 @@ impl App {
         self.default_error_handler
     }
 
-    /// Override the error handler for the all subapps (including the main one).
+    /// Set the [default error handler] for the all subapps (including the main one and future ones)
+    /// that do not have one.
     ///
     /// May only be called once and should be set by the application, not by libraries.
     ///
@@ -1363,12 +1364,14 @@ impl App {
     /// ```
     /// # use bevy_app::*;
     /// # use bevy_ecs::error::warn;
-    /// # fn MyPlugins() {}
+    /// # fn MyPlugins(_: &mut App) {}
     /// App::new()
     ///     .set_error_handler(warn)
     ///     .add_plugins(MyPlugins)
     ///     .run();
     /// ```
+    ///
+    /// [default error handler]: bevy_ecs::error::DefaultErrorHandler
     pub fn set_error_handler(&mut self, handler: ErrorHandler) -> &mut Self {
         assert!(
             self.default_error_handler.is_none(),

crates/bevy_ecs/src/error/command_handling.rs

@@ -59,6 +59,13 @@ where
             self.apply(world);
         }
     }
+
+    #[inline]
+    fn handle_error(self) -> impl Command {
+        move |world: &mut World| {
+            self.apply(world);
+        }
+    }
 }
 
 impl<C> HandleError for C

crates/bevy_ecs/src/error/mod.rs

@@ -8,7 +8,7 @@
 //! [`panic`] error handler function is used, resulting in a panic with the error message attached.
 //!
 //! You can change the default behavior by registering a custom error handler:
-//! Use [`World::set_default_error_handler`] to set a custom error handler function for a world,
+//! Use [`DefaultErrorHandler`] to set a custom error handler function for a world,
 //! or `App::set_error_handler` for a whole app.
 //! In practice, this is generally feature-flagged: panicking or loudly logging errors in development,
 //! and quietly logging or ignoring them in production to avoid crashing the app.
@@ -35,7 +35,7 @@
 //! context surrounding the error – such as the system's [`name`] – in your error messages.
 //!
 //! ```rust, ignore
-//! use bevy_ecs::error::{BevyError, ErrorContext};
+//! use bevy_ecs::error::{BevyError, ErrorContext, DefaultErrorHandler};
 //! use log::trace;
 //!
 //! fn my_error_handler(error: BevyError, ctx: ErrorContext) {
@@ -48,8 +48,8 @@
 //!
 //! fn main() {
 //!     let mut world = World::new();
-//!     world.set_default_error_handler(my_error_handler);
-//!     …
+//!     world.insert_resource(DefaultErrorHandler(my_error_handler));
+//!     // Use your world here
 //! }
 //! ```
 //!

crates/bevy_ecs/src/observer/runner.rs

@@ -3,7 +3,7 @@ use core::any::Any;
 
 use crate::{
     component::{ComponentHook, ComponentId, HookContext, Mutable, StorageType},
-    error::ErrorContext,
+    error::{ErrorContext, ErrorHandler},
     observer::{ObserverDescriptor, ObserverTrigger},
     prelude::*,
     query::DebugCheckedUnwrap,
@@ -190,7 +190,7 @@ pub type ObserverRunner = fn(DeferredWorld, ObserverTrigger, PtrMut, propagate:
 /// [`SystemParam`]: crate::system::SystemParam
 pub struct Observer {
     hook_on_add: ComponentHook,
-    error_handler: Option<fn(BevyError, ErrorContext)>,
+    error_handler: Option<ErrorHandler>,
     system: Box<dyn Any + Send + Sync + 'static>,
     pub(crate) descriptor: ObserverDescriptor,
     pub(crate) last_trigger_id: u32,
@@ -349,8 +349,6 @@ fn observer_system_runner<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
         return;
     }
     state.last_trigger_id = last_trigger;
-    // SAFETY: Observer was triggered so must have an `Observer` component.
-    let error_handler = unsafe { state.error_handler.debug_checked_unwrap() };
 
     let trigger: Trigger<E, B> = Trigger::new(
         // SAFETY: Caller ensures `ptr` is castable to `&mut T`
@@ -378,7 +376,10 @@ fn observer_system_runner<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
         match (*system).validate_param_unsafe(world) {
             Ok(()) => {
                 if let Err(err) = (*system).run_unsafe(trigger, world) {
-                    error_handler(
+                    let handler = state
+                        .error_handler
+                        .unwrap_or_else(|| world.default_error_handler());
+                    handler(
                         err,
                         ErrorContext::Observer {
                             name: (*system).name(),
@@ -390,7 +391,10 @@ fn observer_system_runner<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
             }
             Err(e) => {
                 if !e.skipped {
-                    error_handler(
+                    let handler = state
+                        .error_handler
+                        .unwrap_or_else(|| world.default_error_handler());
+                    handler(
                         e.into(),
                         ErrorContext::Observer {
                             name: (*system).name(),
@@ -421,14 +425,10 @@ fn hook_on_add<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
         B::component_ids(&mut world.components_registrator(), &mut |id| {
             components.push(id);
         });
-        let default_error_handler = world.default_error_handler();
         if let Some(mut observe) = world.get_mut::<Observer>(entity) {
             observe.descriptor.events.push(event_id);
             observe.descriptor.components.extend(components);
 
-            if observe.error_handler.is_none() {
-                observe.error_handler = Some(default_error_handler);
-            }
             let system: *mut dyn ObserverSystem<E, B> = observe.system.downcast_mut::<S>().unwrap();
             // SAFETY: World reference is exclusive and initialize does not touch system, so references do not alias
             unsafe {
@@ -441,7 +441,11 @@ fn hook_on_add<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{event::Event, observer::Trigger};
+    use crate::{
+        error::{ignore, DefaultErrorHandler},
+        event::Event,
+        observer::Trigger,
+    };
 
     #[derive(Event)]
     struct TriggerEvent;
@@ -469,11 +473,20 @@ mod tests {
             Err("I failed!".into())
         }
 
+        // Using observer error handler
         let mut world = World::default();
         world.init_resource::<Ran>();
-        let observer = Observer::new(system).with_error_handler(crate::error::ignore);
-        world.spawn(observer);
-        Schedule::default().run(&mut world);
+        world.spawn(Observer::new(system).with_error_handler(ignore));
+        world.trigger(TriggerEvent);
+        assert!(world.resource::<Ran>().0);
+
+        // Using world error handler
+        let mut world = World::default();
+        world.init_resource::<Ran>();
+        world.spawn(Observer::new(system));
+        // Test that the correct handler is used when the observer was added
+        // before the default handler
+        world.insert_resource(DefaultErrorHandler(ignore));
         world.trigger(TriggerEvent);
         assert!(world.resource::<Ran>().0);
     }

crates/bevy_ecs/src/schedule/schedule.rs

@@ -2060,6 +2060,7 @@ mod tests {
     use bevy_ecs_macros::ScheduleLabel;
 
     use crate::{
+        error::{ignore, panic, DefaultErrorHandler, Result},
         prelude::{ApplyDeferred, Res, Resource},
         schedule::{
             tests::ResMut, IntoScheduleConfigs, Schedule, ScheduleBuildSettings, SystemSet,
@@ -2809,4 +2810,32 @@ mod tests {
             .expect("CheckSystemRan Resource Should Exist");
         assert_eq!(value.0, 2);
     }
+
+    #[test]
+    fn test_default_error_handler() {
+        #[derive(Resource, Default)]
+        struct Ran(bool);
+
+        fn system(mut ran: ResMut<Ran>) -> Result {
+            ran.0 = true;
+            Err("I failed!".into())
+        }
+
+        // Test that the default error handler is used
+        let mut world = World::default();
+        world.init_resource::<Ran>();
+        world.insert_resource(DefaultErrorHandler(ignore));
+        let mut schedule = Schedule::default();
+        schedule.add_systems(system).run(&mut world);
+        assert!(world.resource::<Ran>().0);
+
+        // Test that the handler doesn't change within the schedule
+        schedule.add_systems(
+            (|world: &mut World| {
+                world.insert_resource(DefaultErrorHandler(panic));
+            })
+            .before(system),
+        );
+        schedule.run(&mut world);
+    }
 }

crates/bevy_ecs/src/system/commands/mod.rs

@@ -88,8 +88,8 @@ use crate::{
 /// A [`Command`] can return a [`Result`](crate::error::Result),
 /// which will be passed to an [error handler](crate::error) if the `Result` is an error.
 ///
-/// The [default error handler](crate::error::default_error_handler) panics.
-/// It can be configured via [`set_global_default_error_handler`](crate::error::set_global_default_error_handler).
+/// The default error handler panics. It can be configured via
+/// the [`DefaultErrorHandler`](crate::error::DefaultErrorHandler) resource.
 ///
 /// Alternatively, you can customize the error handler for a specific command
 /// by calling [`Commands::queue_handled`].
@@ -508,7 +508,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// Pushes a generic [`Command`] to the command queue.
     ///
     /// If the [`Command`] returns a [`Result`],
-    /// it will be handled using the [default error handler](crate::error::default_error_handler).
+    /// it will be handled using the [default error handler](crate::error::DefaultErrorHandler).
     ///
     /// To use a custom error handler, see [`Commands::queue_handled`].
     ///
@@ -643,7 +643,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// This command will fail if any of the given entities do not exist.
     ///
     /// It will internally return a [`TryInsertBatchError`](crate::world::error::TryInsertBatchError),
-    /// which will be handled by the [default error handler](crate::error::default_error_handler).
+    /// which will be handled by the [default error handler](crate::error::DefaultErrorHandler).
     #[track_caller]
     pub fn insert_batch<I, B>(&mut self, batch: I)
     where
@@ -674,7 +674,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// This command will fail if any of the given entities do not exist.
     ///
     /// It will internally return a [`TryInsertBatchError`](crate::world::error::TryInsertBatchError),
-    /// which will be handled by the [default error handler](crate::error::default_error_handler).
+    /// which will be handled by the [default error handler](crate::error::DefaultErrorHandler).
     #[track_caller]
     pub fn insert_batch_if_new<I, B>(&mut self, batch: I)
     where
@@ -1175,8 +1175,8 @@ impl<'w, 's> Commands<'w, 's> {
 /// An [`EntityCommand`] can return a [`Result`](crate::error::Result),
 /// which will be passed to an [error handler](crate::error) if the `Result` is an error.
 ///
-/// The [default error handler](crate::error::default_error_handler) panics.
-/// It can be configured via [`set_global_default_error_handler`](crate::error::set_global_default_error_handler).
+/// The default error handler panics. It can be configured via
+/// the [`DefaultErrorHandler`](crate::error::DefaultErrorHandler) resource.
 ///
 /// Alternatively, you can customize the error handler for a specific command
 /// by calling [`EntityCommands::queue_handled`].
@@ -1768,7 +1768,7 @@ impl<'a> EntityCommands<'a> {
     /// Pushes an [`EntityCommand`] to the queue,
     /// which will get executed for the current [`Entity`].
     ///
-    /// The [default error handler](crate::error::default_error_handler)
+    /// The [default error handler](crate::error::DefaultErrorHandler)
     /// will be used to handle error cases.
     /// Every [`EntityCommand`] checks whether the entity exists at the time of execution
     /// and returns an error if it does not.

release-content/migration-guides/18810_Per_world_error_handler.md

@@ -0,0 +1,10 @@
+---
+title: Global default error handler
+pull_requests: [18810]
+---
+
+Worlds can now have different default error handlers, so there no longer is a global handler.
+
+Replace uses of `GLOBAL_ERROR_HANDLER` with `App`'s `.set_error_handler(handler)`.
+For worlds that do not directly belong to an `App`/`SubApp`,
+insert the `DefaultErrorHandler(handler)` resource.