feat!: re-design GetTypeDependencies trait & add GetTypeDependencies derive macro (#369)

# Summary
Currently the `GetTypeDependencies` trait struggles with deeply nested
container types.

For example `HashMap<Result<T,E>,V>` would place bounds of
`GetTypeRegistration` on `Result` which quickly falls apart with
non-`'static` types like `Ref` and `Mut` which don't have
`GetTypeRegistration` implementations.

This overhaul introduces the concept of an `Underlying` type allowing us
to have two type trees, the `Real` types which we want to end up being
registered in the registry, and the `Facade` types which exist purely as
trait carriers:


```mermaid
graph TD;
	subgraph facade
	A1[HashMap<.Val<.T>>] --> A2["`Val<.T>`"]
	A2 --> T
	end

	subgraph underlying
    B1[HashMap<.T>] --> B2["`T`"]
    end
```

Thanks to that we can make the two assertions confidently:
- I want your REAL types in the script function signature, to be `Typed`
and possible to add to the type registry
- I don't care if your FACADE types are

Also previously, `HashMap<T, Val<T>>` would not register `HashMap<T, T>`
correctly at all, meaning we now get better dependency coverage!

# Migration Guide
- Any types which you implemented `GetTypeDependencies` for manually,
will need to specify an underlying type, for non-generic types this will
just be `Self`, for types which have recursive registrations, this will
be `Self<T1::Underlying, T2::Underlying...>` etc
- You can use the derive macro to make this easier instead

Author: makspll

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

@@ -3,8 +3,8 @@
 use std::{ffi::OsString, path::PathBuf};
 
 use crate::{
-    bindings::{ScriptValue, ReflectReference},
-    docgen::TypedThrough,
+    bindings::{ReflectReference, ScriptValue},
+    docgen::TypedThrough, error::InteropError,
 };
 
 use super::{
@@ -77,6 +77,8 @@ impl<T> ArgMeta for Val<T> {}
 impl<T> ArgMeta for Ref<'_, T> {}
 impl<T> ArgMeta for Mut<'_, T> {}
 
+impl<T> ArgMeta for Result<T, InteropError> {}
+
 impl<T> ArgMeta for Option<T> {
     fn default_value() -> Option<ScriptValue> {
         Some(ScriptValue::Unit)

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

@@ -469,6 +469,17 @@ where
 pub struct Union<T1, T2>(Result<T1, T2>);
 
 impl<T1, T2> Union<T1, T2> {
+    /// Create a new union with the left value.
+    pub fn new_left(value: T1) -> Self {
+        Union(Ok(value))
+    }
+
+    /// Create a new union with the right value.
+    pub fn new_right(value: T2) -> Self {
+        Union(Err(value))
+    }
+
+
     /// Try interpret the union as the left type
     pub fn into_left(self) -> Result<T1, T2> {
         match self.0 {
@@ -484,6 +495,14 @@ impl<T1, T2> Union<T1, T2> {
             Ok(l) => Err(l),
         }
     }
+     
+    /// Map the union to another type
+    pub fn map_both<U1, U2, F: Fn(T1) -> U1, G: Fn(T2) -> U2>(self, f: F, g: G) -> Union<U1, U2> {
+        match self.0 {
+            Ok(t) => Union(Ok(f(t))),
+            Err(t) => Union(Err(g(t))),
+        }
+    }
 }
 
 impl<T1: FromScript, T2: FromScript> FromScript for Union<T1, T2>

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

@@ -3,8 +3,8 @@
 use std::{borrow::Cow, collections::HashMap, ffi::OsString, path::PathBuf};
 use bevy::reflect::Reflect;
 
-use crate::{bindings::{ReflectReference, ScriptValue, WorldGuard}, error::InteropError, private::self_type_dependency_only};
-use super::{DynamicScriptFunction, DynamicScriptFunctionMut, Val};
+use crate::{bindings::{ReflectReference, ScriptValue, WorldGuard}, error::InteropError};
+use super::{DynamicScriptFunction, DynamicScriptFunctionMut, Union, Val};
 
 /// Converts a value into a [`ScriptValue`].
 pub trait IntoScript {
@@ -26,14 +26,13 @@ impl IntoScript for ScriptValue {
     }
 }
 
-self_type_dependency_only!(ScriptValue);
 
 impl IntoScript for () {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Unit)
     }
 }
-self_type_dependency_only!(());
+
 
 impl IntoScript for DynamicScriptFunctionMut {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
@@ -47,14 +46,12 @@ impl IntoScript for DynamicScriptFunction {
     }
 }
 
-self_type_dependency_only!(DynamicScriptFunctionMut, DynamicScriptFunction);
 
 impl IntoScript for bool {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Bool(self))
     }
 }
-self_type_dependency_only!(bool);
 
 macro_rules! impl_into_with_downcast {
     ($variant:tt as $cast:ty [$($ty:ty),*]) => {
@@ -71,9 +68,7 @@ macro_rules! impl_into_with_downcast {
 
 impl_into_with_downcast!(Integer as i64 [i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, usize, isize]);
 impl_into_with_downcast!(Float as f64 [f32, f64]);
-self_type_dependency_only!(
-    i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, usize, isize, f32, f64
-);
+
 
 macro_rules! impl_into_stringlike {
     ($id:ident,[ $(($ty:ty => $conversion:expr)),*]) => {
@@ -99,15 +94,14 @@ impl_into_stringlike!(
     ]
 );
 
-self_type_dependency_only!(String, char, PathBuf, OsString);
 
 impl IntoScript for &'static str {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::String(Cow::Borrowed(self)))
     }
 }
 
-self_type_dependency_only!(&'static str);
+
 
 impl IntoScript for ReflectReference {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
@@ -156,6 +150,15 @@ impl<T: IntoScript, const N: usize> IntoScript for [T; N] {
     }
 }
 
+impl <T1: IntoScript, T2: IntoScript> IntoScript for Union<T1,T2> {
+    fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
+        match self.into_left() {
+            Ok(left) => left.into_script(world),
+            Err(right) => right.into_script(world),
+        }
+    }
+} 
+
 impl<V: IntoScript> IntoScript for HashMap<String, V> {
     fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
         let mut map = HashMap::new();

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

@@ -17,17 +17,13 @@ mod test {
     use bevy::reflect::{FromReflect, GetTypeRegistration, Reflect, Typed};
     use bevy_mod_scripting_derive::script_bindings;
 
-    use crate::{
-        bindings::{
+    use crate::bindings::{
             function::{
                 from::{Ref, Union, Val},
                 namespace::IntoNamespace,
                 script_function::AppScriptFunctionRegistry,
-            },
-            script_value::ScriptValue,
-        },
-        docgen::typed_through::TypedThrough,
-    };
+            }, script_value::ScriptValue
+        };
 
     use super::arg_meta::{ScriptArgument, ScriptReturn, TypedScriptArgument, TypedScriptReturn};
 
@@ -137,19 +133,29 @@ mod test {
             test_is_valid_arg::<Ref<'_, T>>();
         }
 
+        fn test_union<T>()
+        where
+            T: TypedScriptArgument + TypedScriptReturn,
+            T::Underlying: FromReflect + Typed + GetTypeRegistration,
+            for<'a> T::This<'a>: Into<T>,
+        {
+            test_is_valid_arg_and_return::<Union<T, T>>();
+            test_is_valid_arg_and_return::<Union<T, Union<T, T>>>();
+        }
+
         fn test_array<T, const N: usize>()
         where
-            T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + TypedThrough + Typed,
+            T: TypedScriptArgument + TypedScriptReturn + 'static,
+            T::Underlying: FromReflect + Typed + GetTypeRegistration,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<[T; N]>();
         }
 
         fn test_tuple<T>()
         where
-            T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + TypedThrough + Typed,
+            T: TypedScriptArgument + TypedScriptReturn + 'static,
+            T::Underlying: FromReflect + Typed + GetTypeRegistration,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<()>();
@@ -160,26 +166,26 @@ mod test {
 
         fn test_option<T>()
         where
-            T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + Typed + TypedThrough,
+            T: TypedScriptArgument + TypedScriptReturn,
+            T::Underlying: FromReflect + Typed + GetTypeRegistration,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<Option<T>>();
         }
 
         fn test_vec<T>()
         where
-            T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + Typed + TypedThrough,
+            T: TypedScriptArgument + TypedScriptReturn + 'static,
+            T::Underlying: FromReflect + Typed + GetTypeRegistration,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<Vec<T>>();
         }
 
         fn test_hashmap<V>()
         where
-            V: ScriptArgument + ScriptReturn,
-            V: GetTypeRegistration + FromReflect + Typed + TypedThrough,
+            V: TypedScriptArgument + TypedScriptReturn + 'static,
+            V::Underlying: FromReflect + Typed + GetTypeRegistration + Eq,
             for<'a> V::This<'a>: Into<V>,
         {
             test_is_valid_arg_and_return::<std::collections::HashMap<String, V>>();