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_api_gen/src/context.rs

@@ -82,12 +82,12 @@ impl ReflectType<'_> {
 }
 
 pub(crate) const DEF_PATHS_BMS_FROM_SCRIPT: [&str; 2] = [
-    "bevy_mod_scripting_core::bindings::function::from::FromScript",
-    "bindings::function::from::FromScript",
+    "bevy_mod_scripting_core::bindings::FromScript",
+    "bindings::FromScript",
 ];
 pub(crate) const DEF_PATHS_BMS_INTO_SCRIPT: [&str; 2] = [
-    "bevy_mod_scripting_core::bindings::function::into::IntoScript",
-    "bindings::function::into::IntoScript",
+    "bevy_mod_scripting_core::bindings::IntoScript",
+    "bindings::IntoScript",
 ];
 
 pub(crate) const DEF_PATHS_REFLECT: [&str; 2] =

crates/bevy_api_gen/src/passes/cache_traits.rs

@@ -1,12 +1,22 @@
 use log::trace;
 use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_middle::ty::TyCtxt;
 use rustc_span::Symbol;
 
 use crate::{
     Args, BevyCtxt, DEF_PATHS_BMS_FROM_SCRIPT, DEF_PATHS_BMS_INTO_SCRIPT,
     DEF_PATHS_GET_TYPE_REGISTRATION, DEF_PATHS_REFLECT, STD_SOURCE_TRAITS,
 };
 
+fn dump_traits(tcx: &TyCtxt) -> String{
+    let mut buffer = String::new();
+    for t in tcx.all_traits() {
+        buffer.push_str(&tcx.def_path_str(t));
+        buffer.push_str(", ");
+    }
+    buffer
+}
+
 /// Finds and caches relevant traits, if they cannot be found throws an ICE
 pub(crate) fn cache_traits(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
     let tcx = &ctxt.tcx;
@@ -35,15 +45,17 @@ pub(crate) fn cache_traits(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
 
     if !ctxt.cached_traits.has_all_bms_traits() {
         panic!(
-            "Could not find all bms traits in crate: {}",
-            tcx.crate_name(LOCAL_CRATE)
+            "Could not find all bms traits in crate: {}. Available traits: {}",
+            tcx.crate_name(LOCAL_CRATE),
+            dump_traits(tcx)
         )
     }
 
     if !ctxt.cached_traits.has_all_bevy_traits() {
         panic!(
-            "Could not find all reflect traits in crate: {}, did bootstrapping go wrong?",
-            tcx.crate_name(LOCAL_CRATE)
+            "Could not find all reflect traits in crate: {}, did bootstrapping go wrong?. Available traits: {}",
+            tcx.crate_name(LOCAL_CRATE),
+            dump_traits(tcx)
         )
     }
 

crates/bevy_mod_scripting_core/src/bindings/access_map.rs

@@ -713,7 +713,6 @@ impl DisplayCodeLocation for Option<std::panic::Location<'_>> {
     }
 }
 
-#[macro_export]
 /// A macro for claiming access to a value for reading
 macro_rules! with_access_read {
     ($access_map:expr, $id:expr, $msg:expr, $body:block) => {{
@@ -731,7 +730,7 @@ macro_rules! with_access_read {
     }};
 }
 
-#[macro_export]
+pub(crate) use with_access_read;
 /// A macro for claiming access to a value for writing
 macro_rules! with_access_write {
     ($access_map:expr, $id:expr, $msg:expr, $body:block) => {
@@ -748,8 +747,8 @@ macro_rules! with_access_write {
         }
     };
 }
+pub(crate) use with_access_write;
 
-#[macro_export]
 /// A macro for claiming global access
 macro_rules! with_global_access {
     ($access_map:expr, $msg:expr, $body:block) => {
@@ -771,6 +770,8 @@ macro_rules! with_global_access {
     };
 }
 
+pub(crate) use with_global_access;
+
 #[cfg(test)]
 mod test {
     use super::*;

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

@@ -4,7 +4,7 @@ use std::{ffi::OsString, path::PathBuf};
 
 use crate::{
     bindings::{script_value::ScriptValue, ReflectReference},
-    docgen::typed_through::TypedThrough,
+    docgen::typed_through::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/from_ref.rs

@@ -1,15 +1,12 @@
 //! Contains the [`FromScriptRef`] trait and its implementations.
 
 use std::{any::TypeId, ffi::OsString, path::PathBuf};
-
 use bevy::reflect::{
     DynamicEnum, DynamicList, DynamicMap, DynamicTuple, DynamicVariant, Map, PartialReflect,
 };
-
 use crate::{
-    bindings::{function::from::FromScript, WorldGuard},
+    bindings::{match_by_type, WorldGuard, FromScript},
     error::InteropError,
-    match_by_type,
     reflection_extensions::TypeInfoExtensions,
     ScriptValue,
 };

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

@@ -1,17 +1,14 @@
 //! Implementations of the [`IntoScript`] trait for various types.
 
 use std::{borrow::Cow, collections::HashMap, ffi::OsString, path::PathBuf};
-
 use bevy::reflect::Reflect;
 
 use crate::{
     bindings::{script_value::ScriptValue, ReflectReference, WorldGuard},
     error::InteropError,
-    self_type_dependency_only,
 };
-
 use super::{
-    from::Val,
+    from::{Union, Val},
     script_function::{DynamicScriptFunction, DynamicScriptFunctionMut},
 };
 
@@ -35,14 +32,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> {
@@ -56,14 +52,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),*]) => {
@@ -80,9 +74,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)),*]) => {
@@ -108,15 +100,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> {
@@ -165,6 +156,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/into_ref.rs

@@ -26,8 +26,8 @@ pub trait IntoScriptRef {
     ) -> Result<ScriptValue, InteropError>;
 }
 
-#[macro_export]
 /// a utility for matching types by their [`std::any::TypeId`]
+#[macro_export]
 macro_rules! match_by_type {
     (match $on:ident {$($id:ident : $ty:ty => $conv:expr),*}) => {
         match $on {
@@ -39,6 +39,8 @@ macro_rules! match_by_type {
     };
 }
 
+pub use match_by_type;
+
 #[macro_export]
 /// Downcasts a reference into a value of a given type or returns an error if the downcast fails.
 macro_rules! downcast_into_value {

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

@@ -1,31 +1,29 @@
 //! Abstractions to do with dynamic script functions
 
-pub mod arg_meta;
-pub mod from;
-pub mod from_ref;
-pub mod into;
-pub mod into_ref;
-pub mod namespace;
-pub mod script_function;
-pub mod type_dependencies;
+crate::private::export_all_in_modules!{
+    arg_meta,
+    from,
+    from_ref,
+    into,
+    into_ref,
+    namespace,
+    script_function,
+    type_dependencies
+}
 
 #[cfg(test)]
 #[allow(dead_code)]
 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};
 
@@ -135,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::<()>();
@@ -158,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>>();