get bindings compiling, add more impls

Author: makspll

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

@@ -360,3 +360,28 @@ where
         }
     }
 }
+
+impl<T: FromScript + 'static, const N: usize> FromScript for [T; N]
+where
+    for<'w> T::This<'w>: Into<T>,
+{
+    type This<'w> = Self;
+
+    fn from_script(value: ScriptValue, world: WorldGuard) -> Result<Self, InteropError> {
+        match value {
+            ScriptValue::List(list) if list.len() == N => {
+                let converted_list = list
+                    .into_iter()
+                    .map(|item| T::from_script(item, world.clone()).map(Into::into))
+                    .collect::<Result<Vec<T>, _>>()?
+                    .try_into()
+                    .map_err(|list: Vec<T>| InteropError::length_mismatch(N, list.len()))?;
+                Ok(converted_list)
+            }
+            _ => Err(InteropError::value_mismatch(
+                std::any::TypeId::of::<[T; N]>(),
+                value,
+            )),
+        }
+    }
+}

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

@@ -132,8 +132,32 @@ impl<T: IntoScript> IntoScript for Vec<T> {
     }
 }
 
+impl<T: IntoScript, const N: usize> IntoScript for [T; N] {
+    fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
+        let mut values = Vec::with_capacity(N);
+        for val in self {
+            values.push(val.into_script(world.clone())?);
+        }
+        Ok(ScriptValue::List(values))
+    }
+}
+
 impl IntoScript for InteropError {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Error(self))
     }
 }
+
+macro_rules! impl_into_script_tuple {
+    ($( $ty:ident ),* ) => {
+        #[allow(non_snake_case)]
+        impl<$($ty: IntoScript),*> IntoScript for ($($ty,)*) {
+        fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
+            let ($($ty,)*) = self;
+            Ok(ScriptValue::List(vec![$($ty.into_script(world.clone())?),*]))
+        }
+    }
+}
+}
+
+bevy::utils::all_tuples!(impl_into_script_tuple, 1, 14, T);

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

@@ -15,6 +15,7 @@ use bevy::{
     },
 };
 use std::collections::HashMap;
+use std::hash::Hash;
 use std::sync::Arc;
 
 #[diagnostic::on_unimplemented(
@@ -25,6 +26,7 @@ pub trait ScriptFunction<'env, Marker> {
     fn into_dynamic_function(self) -> DynamicFunction<'static>;
 }
 
+/// Functionally identical to [`GetTypeRegistration`] but without the 'static bound
 pub trait GetInnerTypeDependencies {
     fn register_type_dependencies(registry: &mut TypeRegistry);
 }
@@ -54,9 +56,9 @@ macro_rules! self_type_dependency_only {
 }
 
 macro_rules! recursive_type_dependencies {
-    ($( ($path:path where $($bound:ident : $($bound_val:path);*),* $(=> with $self_:ident)?) ),* )  => {
+    ($( ($path:ty where $($bound:ident : $($bound_val:path);*),* $(,,const $const:ident : $const_ty:ty)? $(=> with $self_:ident)?) ),* )  => {
         $(
-            impl<$($bound : $($bound_val +)*),*> GetInnerTypeDependencies for $path {
+            impl<$($bound : $($bound_val +)*),* , $(const $const : $const_ty )?> GetInnerTypeDependencies for $path {
                 fn register_type_dependencies(registry: &mut TypeRegistry) {
                     $(
                         registry.register::<$bound>();
@@ -70,6 +72,18 @@ macro_rules! recursive_type_dependencies {
     };
 }
 
+macro_rules! register_tuple_dependencies {
+    ($($ty:ident),*) => {
+        impl<$($ty: GetTypeRegistration + Typed),*> GetInnerTypeDependencies for ($($ty,)*) {
+            fn register_type_dependencies(registry: &mut TypeRegistry) {
+                $(
+                    registry.register::<$ty>();
+                )*
+            }
+        }
+    };
+}
+
 no_type_dependencies!(ReflectReference, InteropError);
 self_type_dependency_only!(WorldCallbackAccess);
 
@@ -78,14 +92,13 @@ recursive_type_dependencies!(
     (Ref<'_, T>  where T: GetTypeRegistration),
     (Mut<'_, T>  where T: GetTypeRegistration),
     (Result<T, InteropError>  where T: GetTypeRegistration),
+    ([T; N]  where T: GetTypeRegistration;Typed,, const N: usize => with Self),
     (Option<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self),
-    (Vec<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self)
-);
-
-recursive_type_dependencies!(
-    (HashMap<K,V> where K: GetTypeRegistration, V: GetTypeRegistration)
+    (Vec<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self),
+    (HashMap<K,V> where K: GetTypeRegistration;FromReflect;Typed;Hash;Eq, V: GetTypeRegistration;FromReflect;Typed => with Self)
 );
 
+bevy::utils::all_tuples!(register_tuple_dependencies, 1, 14, T);
 pub trait GetFunctionTypeDependencies<Marker> {
     fn register_type_dependencies(registry: &mut TypeRegistry);
 }

crates/bevy_mod_scripting_core/src/error.rs

@@ -369,7 +369,10 @@ impl InteropError {
             error
         }))
     }
-
+    pub fn length_mismatch(expected: usize, got: usize) -> Self {
+        Self(Arc::new(InteropErrorInner::LengthMismatch { expected, got }))
+    }
+    
     pub fn external_error(error: Box<dyn std::error::Error + Send + Sync>) -> Self {
         Self(Arc::new(InteropErrorInner::OtherError { error }))
     }
@@ -429,6 +432,10 @@ pub enum InteropErrorInner {
         expected: TypeId,
         got: ScriptValue,
     },
+    LengthMismatch {
+        expected: usize,
+        got: usize,
+    },
     CouldNotDowncast {
         from: ReflectReference,
         to: TypeId,
@@ -610,6 +617,9 @@ impl DisplayWithWorld for InteropErrorInner {
                 format!("Unfinished conversion in context of: {}. A better conversion exists but caller didn't handle the case.", context)
             },
             InteropErrorInner::OtherError { error } => error.to_string(),
+            InteropErrorInner::LengthMismatch { expected, got } => {
+                format!("Array/List Length mismatch, expected: {}, got: {}", expected, got)
+            },
         }
     }
 }

crates/bevy_mod_scripting_functions/Cargo.toml

@@ -21,4 +21,5 @@ bevy = { workspace = true, features = [
     "reflect_functions",
 ] }
 uuid = "*"
+smol_str = "*"
 bevy_mod_scripting_core = { workspace = true, optional = true }