feat: add TypedThrough abstraction to function meta, and refactor (#272)

* feat: add `TypeKind` to function meta, and refactor

* add `TypedThrough` abstraction

* add some more tests

Author: makspll

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

@@ -2,7 +2,10 @@
 
 use std::{ffi::OsString, path::PathBuf};
 
-use crate::bindings::{script_value::ScriptValue, ReflectReference};
+use crate::{
+    bindings::{script_value::ScriptValue, ReflectReference},
+    docgen::typed_through::TypedThrough,
+};
 
 use super::{
     from::{FromScript, Mut, Ref, Val},
@@ -15,10 +18,18 @@ use super::{
 pub trait ScriptArgument: ArgMeta + FromScript + GetTypeDependencies {}
 impl<T: ArgMeta + FromScript + GetTypeDependencies> ScriptArgument for T {}
 
+/// Marker trait for types that can be used as arguments to a script function. And contain type information.
+pub trait TypedScriptArgument: TypedThrough + ScriptArgument {}
+impl<T: TypedThrough + ScriptArgument> TypedScriptArgument for T {}
+
 /// Marker trait for types that can be used as return values from a script function.
 pub trait ScriptReturn: IntoScript + GetTypeDependencies {}
 impl<T: IntoScript + GetTypeDependencies> ScriptReturn for T {}
 
+/// Marker trait for types that can be used as return values from a script function. And contain type information.
+pub trait TypedScriptReturn: TypedThrough + ScriptReturn {}
+impl<T: TypedThrough + ScriptReturn> TypedScriptReturn for T {}
+
 /// Describes an argument to a script function. Provides necessary information for the function to handle dispatch.
 pub trait ArgMeta {
     /// The default value for the argument. Used when the argument is not provided.
@@ -37,13 +48,29 @@ macro_rules! impl_arg_info {
     };
 }
 
-impl_arg_info!(bool, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, f64, usize, isize);
-
-impl_arg_info!(String, PathBuf, OsString);
-
-impl_arg_info!(char);
-
-impl_arg_info!(ReflectReference);
+impl_arg_info!(
+    bool,
+    i8,
+    i16,
+    i32,
+    i64,
+    i128,
+    u8,
+    u16,
+    u32,
+    u64,
+    u128,
+    f32,
+    f64,
+    usize,
+    isize,
+    String,
+    PathBuf,
+    OsString,
+    char,
+    ReflectReference,
+    &'static str
+);
 
 impl<T> ArgMeta for Val<T> {}
 impl<T> ArgMeta for Ref<'_, T> {}

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

@@ -16,15 +16,18 @@ mod test {
     use bevy_mod_scripting_derive::script_bindings;
 
     use crate::{
-        bindings::function::{
-            from::{Ref, Val},
-            namespace::IntoNamespace,
-            script_function::AppScriptFunctionRegistry,
+        bindings::{
+            function::{
+                from::{Ref, Val},
+                namespace::IntoNamespace,
+                script_function::AppScriptFunctionRegistry,
+            },
+            script_value::ScriptValue,
         },
-        error::InteropError,
+        docgen::typed_through::TypedThrough,
     };
 
-    use super::arg_meta::{ScriptArgument, ScriptReturn};
+    use super::arg_meta::{ScriptArgument, ScriptReturn, TypedScriptArgument, TypedScriptReturn};
 
     #[test]
     fn test_macro_generates_correct_registrator_function() {
@@ -66,14 +69,14 @@ mod test {
         assert_eq!(test_fn.info.arg_info[1].name, Some("_arg1".into()));
 
         assert_eq!(
-            test_fn.info.return_info.type_id,
+            test_fn.info.return_info.as_ref().unwrap().type_id,
             std::any::TypeId::of::<()>()
         );
     }
 
-    fn test_is_valid_return<T: ScriptReturn>() {}
-    fn test_is_valid_arg<T: ScriptArgument>() {}
-    fn test_is_valid_arg_and_return<T: ScriptArgument + ScriptReturn>() {}
+    fn test_is_valid_return<T: TypedScriptReturn>() {}
+    fn test_is_valid_arg<T: TypedScriptArgument>() {}
+    fn test_is_valid_arg_and_return<T: TypedScriptReturn + TypedScriptArgument>() {}
 
     #[test]
     fn primitives_are_valid_args() {
@@ -92,6 +95,7 @@ mod test {
         test_is_valid_arg_and_return::<f64>();
         test_is_valid_arg_and_return::<usize>();
         test_is_valid_arg_and_return::<isize>();
+        test_is_valid_arg_and_return::<ScriptValue>();
     }
 
     #[test]
@@ -100,14 +104,15 @@ mod test {
         test_is_valid_arg_and_return::<std::path::PathBuf>();
         test_is_valid_arg_and_return::<std::ffi::OsString>();
         test_is_valid_arg_and_return::<char>();
+        test_is_valid_return::<&'static str>();
     }
 
     #[test]
     fn composites_are_valid_args() {
         fn test_val<T>()
         where
             T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect,
+            T: GetTypeRegistration + FromReflect + Typed,
         {
             test_is_valid_arg_and_return::<Val<T>>();
         }
@@ -128,12 +133,10 @@ mod test {
             test_is_valid_arg::<Ref<'_, T>>();
         }
 
-        test_is_valid_return::<InteropError>();
-
         fn test_array<T, const N: usize>()
         where
             T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + Typed,
+            T: GetTypeRegistration + FromReflect + TypedThrough + Typed,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<[T; N]>();
@@ -142,7 +145,7 @@ mod test {
         fn test_tuple<T>()
         where
             T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + Typed,
+            T: GetTypeRegistration + FromReflect + TypedThrough + Typed,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<()>();
@@ -154,7 +157,7 @@ mod test {
         fn test_option<T>()
         where
             T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + Typed,
+            T: GetTypeRegistration + FromReflect + Typed + TypedThrough,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<Option<T>>();
@@ -163,7 +166,7 @@ mod test {
         fn test_vec<T>()
         where
             T: ScriptArgument + ScriptReturn,
-            T: GetTypeRegistration + FromReflect + Typed,
+            T: GetTypeRegistration + FromReflect + Typed + TypedThrough,
             for<'a> T::This<'a>: Into<T>,
         {
             test_is_valid_arg_and_return::<Vec<T>>();
@@ -172,7 +175,7 @@ mod test {
         fn test_hashmap<V>()
         where
             V: ScriptArgument + ScriptReturn,
-            V: GetTypeRegistration + FromReflect + Typed,
+            V: GetTypeRegistration + FromReflect + Typed + TypedThrough,
             for<'a> V::This<'a>: Into<V>,
         {
             test_is_valid_arg_and_return::<std::collections::HashMap<String, V>>();

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

@@ -73,12 +73,6 @@ pub struct DynamicScriptFunction {
     >,
 }
 
-impl PartialEq for DynamicScriptFunction {
-    fn eq(&self, other: &Self) -> bool {
-        self.info == other.info
-    }
-}
-
 #[derive(Clone, Reflect)]
 #[reflect(opaque)]
 /// A dynamic mutable script function.
@@ -96,12 +90,6 @@ pub struct DynamicScriptFunctionMut {
     >,
 }
 
-impl PartialEq for DynamicScriptFunctionMut {
-    fn eq(&self, other: &Self) -> bool {
-        self.info == other.info
-    }
-}
-
 impl DynamicScriptFunction {
     /// Call the function with the given arguments and caller context.
     ///
@@ -215,6 +203,18 @@ impl DynamicScriptFunctionMut {
     }
 }
 
+impl PartialEq for DynamicScriptFunction {
+    fn eq(&self, other: &Self) -> bool {
+        std::ptr::addr_eq(self as *const Self, other as *const Self)
+    }
+}
+
+impl PartialEq for DynamicScriptFunctionMut {
+    fn eq(&self, other: &Self) -> bool {
+        std::ptr::addr_eq(self as *const Self, other as *const Self)
+    }
+}
+
 impl std::fmt::Debug for DynamicScriptFunction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DynamicScriptFunction")