feat: refactor handler context into system param

Author: makspll

crates/bevy_mod_scripting_core/Cargo.toml

@@ -40,6 +40,7 @@ itertools = "0.13"
 derivative = "2.2"
 profiling = { workspace = true }
 bevy_mod_scripting_derive = { workspace = true }
+fixedbitset = "0.5"
 
 [dev-dependencies]
 test_utils = { workspace = true }

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -12,7 +12,10 @@ use bevy::{
     reflect::{PartialReflect, ReflectRef},
 };
 use itertools::Itertools;
-use std::{any::TypeId, borrow::Cow};
+use std::{
+    any::{Any, TypeId},
+    borrow::Cow,
+};
 
 /// A utility for printing reflect references in a human readable format.
 pub struct ReflectReferencePrinter {
@@ -325,7 +328,7 @@ impl ReflectReferencePrinter {
 
 /// For types which can't be pretty printed without world access.
 /// Implementors should try to print the best value they can, and never panick.
-pub trait DisplayWithWorld: std::fmt::Debug {
+pub trait DisplayWithWorld: std::fmt::Debug + AsAny {
     /// # Warning
     /// Display this type without world access. It is not recommended to use this method for anything other than debugging or necessary trait impl corners.
     /// For many types this will just print type id's with no further information.
@@ -343,6 +346,27 @@ pub trait DisplayWithWorld: std::fmt::Debug {
         self.display_with_world(world)
     }
 }
+
+#[doc(hidden)]
+pub trait AsAny: 'static {
+    fn as_any(&self) -> &dyn Any;
+}
+
+#[doc(hidden)]
+impl<T: DisplayWithWorld + 'static> AsAny for T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+impl dyn DisplayWithWorld {
+    /// Downcasts the `DisplayWithWorld` trait object to a concrete type.
+    /// Trampoline function to allow downcasting of errors.
+    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
+        self.as_any().downcast_ref::<T>()
+    }
+}
+
 #[profiling::all_functions]
 impl DisplayWithWorld for ReflectReference {
     fn display_with_world(&self, world: WorldGuard) -> String {
@@ -524,7 +548,7 @@ impl DisplayWithWorld for ScriptValue {
     }
 }
 #[profiling::all_functions]
-impl<T: DisplayWithWorld> DisplayWithWorld for Vec<T> {
+impl<T: DisplayWithWorld + 'static> DisplayWithWorld for Vec<T> {
     fn display_with_world(&self, world: WorldGuard) -> String {
         let mut string = String::new();
         BracketType::Square.surrounded(&mut string, |string| {
@@ -579,7 +603,7 @@ impl DisplayWithWorld for String {
     }
 }
 #[profiling::all_functions]
-impl<K: DisplayWithWorld, V: DisplayWithWorld> DisplayWithWorld
+impl<K: DisplayWithWorld + 'static, V: DisplayWithWorld + 'static> DisplayWithWorld
     for std::collections::HashMap<K, V>
 {
     fn display_with_world(&self, world: WorldGuard) -> String {

crates/bevy_mod_scripting_core/src/bindings/world.rs

@@ -92,6 +92,19 @@ impl<'w> WorldAccessGuard<'w> {
         o
     }
 
+    /// Safely allows access to the world for the duration of the closure via a static [`WorldAccessGuard`] using a previously lifetimed world guard.
+    pub fn with_existing_static_guard<O>(
+        guard: WorldAccessGuard<'w>,
+        f: impl FnOnce(WorldGuard<'static>) -> O,
+    ) -> O {
+        // safety: we invalidate the guard after the closure is called, meaning the world cannot be accessed at all after the 'w lifetime ends
+        let static_guard: WorldAccessGuard<'static> = unsafe { std::mem::transmute(guard) };
+        let o = f(static_guard.clone());
+
+        static_guard.invalidate();
+        o
+    }
+
     /// Creates a new [`WorldAccessGuard`] for the given mutable borrow of the world.
     ///
     /// Creating a guard requires that some resources exist in the world, namely: