feat: add construct global for constructing arbitrary types & Union type

crates/bevy_mod_scripting_core/Cargo.toml

@@ -48,6 +48,7 @@ bevy_mod_scripting_derive = { workspace = true }
 [dev-dependencies]
 test_utils = { workspace = true }
 tokio = { version = "1", features = ["rt", "macros"] }
+pretty_assertions = "1.4"
 
 [lints]
 workspace = true

crates/bevy_mod_scripting_core/src/bindings/function/arg_meta.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 
 use super::{
-    from::{FromScript, Mut, Ref, Val},
+    from::{FromScript, Mut, Ref, Union, Val},
     into::IntoScript,
     script_function::{DynamicScriptFunction, DynamicScriptFunctionMut, FunctionCallContext},
     type_dependencies::GetTypeDependencies,
@@ -72,6 +72,7 @@ impl_arg_info!(
     &'static str
 );
 
+impl<T1, T2> ArgMeta for Union<T1, T2> {}
 impl<T> ArgMeta for Val<T> {}
 impl<T> ArgMeta for Ref<'_, T> {}
 impl<T> ArgMeta for Mut<'_, T> {}

crates/bevy_mod_scripting_core/src/bindings/function/from.rs

@@ -456,3 +456,46 @@ where
         }
     }
 }
+
+/// A union of two or more (by nesting unions) types.
+pub struct Union<T1, T2>(Result<T1, T2>);
+
+impl<T1, T2> Union<T1, T2> {
+    /// Try interpret the union as the left type
+    pub fn into_left(self) -> Result<T1, T2> {
+        match self.0 {
+            Ok(r) => Ok(r),
+            Err(l) => Err(l),
+        }
+    }
+
+    /// Try interpret the union as the right type
+    pub fn into_right(self) -> Result<T2, T1> {
+        match self.0 {
+            Err(r) => Ok(r),
+            Ok(l) => Err(l),
+        }
+    }
+}
+
+impl<T1: FromScript, T2: FromScript> FromScript for Union<T1, T2>
+where
+    for<'a> T1::This<'a>: Into<T1>,
+    for<'a> T2::This<'a>: Into<T2>,
+{
+    type This<'w> = Self;
+    fn from_script(
+        value: ScriptValue,
+        world: WorldGuard<'_>,
+    ) -> Result<Self::This<'_>, InteropError> {
+        let _ = match T1::from_script(value.clone(), world.clone()) {
+            Ok(v) => return Ok(Union(Ok(v.into()))),
+            Err(e) => e,
+        };
+
+        match T2::from_script(value, world) {
+            Ok(v) => Ok(Union(Err(v.into()))),
+            Err(e) => Err(e),
+        }
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/function/mod.rs

@@ -18,7 +18,7 @@ mod test {
     use crate::{
         bindings::{
             function::{
-                from::{Ref, Val},
+                from::{Ref, Union, Val},
                 namespace::IntoNamespace,
                 script_function::AppScriptFunctionRegistry,
             },
@@ -109,6 +109,8 @@ mod test {
 
     #[test]
     fn composites_are_valid_args() {
+        test_is_valid_arg::<Union<usize, usize>>();
+
         fn test_val<T>()
         where
             T: ScriptArgument + ScriptReturn,

crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs

@@ -1,7 +1,7 @@
 //! This module contains the [`GetTypeDependencies`] trait and its implementations for various types.
 
 use super::{
-    from::{Mut, Ref, Val},
+    from::{Mut, Ref, Union, Val},
     script_function::FunctionCallContext,
 };
 use crate::{
@@ -88,6 +88,13 @@ recursive_type_dependencies!(
     (HashMap<K,V> where K: GetTypeRegistration;FromReflect;Typed;Hash;Eq, V: GetTypeRegistration;FromReflect;Typed => with Self)
 );
 
+impl<T1: GetTypeDependencies, T2: GetTypeDependencies> GetTypeDependencies for Union<T1, T2> {
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        T1::register_type_dependencies(registry);
+        T2::register_type_dependencies(registry);
+    }
+}
+
 bevy::utils::all_tuples!(register_tuple_dependencies, 1, 14, T);
 
 /// A trait collecting type dependency information for a whole function. Used to register everything used by a function with the type registry

crates/bevy_mod_scripting_core/src/bindings/query.rs

@@ -80,6 +80,11 @@ impl ScriptResourceRegistration {
     pub fn type_registration(&self) -> &ScriptTypeRegistration {
         &self.registration
     }
+
+    /// Convert to a generic [`ScriptTypeRegistration`] ditching the resource information.
+    pub fn into_type_registration(self) -> ScriptTypeRegistration {
+        self.registration
+    }
 }
 
 impl ScriptComponentRegistration {
@@ -101,6 +106,11 @@ impl ScriptComponentRegistration {
     pub fn type_registration(&self) -> &ScriptTypeRegistration {
         &self.registration
     }
+
+    /// Convert to a generic [`ScriptTypeRegistration`] ditching the component information.
+    pub fn into_type_registration(self) -> ScriptTypeRegistration {
+        self.registration
+    }
 }
 
 impl std::fmt::Debug for ScriptTypeRegistration {

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -61,6 +61,16 @@ pub enum TypeIdSource {
 }
 #[profiling::all_functions]
 impl ReflectReference {
+    /// If this points to a variant of an enum, returns the name of the variant.
+    pub fn variant_name(&self, world: WorldGuard) -> Result<Option<String>, InteropError> {
+        self.with_reflect(world, |s| {
+            s.reflect_ref()
+                .as_enum()
+                .ok()
+                .map(|enum_ref| enum_ref.variant_name().to_owned())
+        })
+    }
+
     /// Creates a new infinite iterator. This iterator will keep returning the next element reference forever.
     pub fn into_iter_infinite(self) -> ReflectRefIter {
         ReflectRefIter::new_indexed(self)