feat! add type cache table global, and refactor GetTypeDependencies to work better with nested types

WIP

feat: shorten import paths (#367)

where we previously did `pub use my_mod` we also use `pub use
my_mod::*`, this should make imports everywhere prettier and should not
be a breaking change

merge

re-design the type dependency trait better

refactor

Author: makspll

assets/tests/globals/type_cache_available.lua

@@ -0,0 +1,6 @@
+
+function on_test()
+    local my_type = types.TestResource;
+    assert(my_type ~= nil, "Type TestResource is not available in type cache");
+    assert(my_type:short_name() == "TestResource", "Type t.TestResource:short_name() is not correct: " .. my_type:short_name());
+end

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

@@ -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,7 +3,7 @@
 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 crate::{bindings::{ReflectReference, ScriptValue, WorldGuard}, error::InteropError};
 use super::{DynamicScriptFunction, DynamicScriptFunctionMut, Val};
 
 /// Converts a value into a [`ScriptValue`].
@@ -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>>();