implement iterators, and add function passing

Author: makspll

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

@@ -13,7 +13,10 @@ use crate::{
     self_type_dependency_only,
 };
 
-use super::from::Val;
+use super::{
+    from::Val,
+    script_function::{DynamicScriptFunction, DynamicScriptFunctionMut},
+};
 
 pub trait IntoScript {
     fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError>;
@@ -32,9 +35,16 @@ impl IntoScript for () {
         Ok(ScriptValue::Unit)
     }
 }
-
 self_type_dependency_only!(());
 
+impl IntoScript for DynamicScriptFunctionMut {
+    fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
+        Ok(ScriptValue::Function(self))
+    }
+}
+
+self_type_dependency_only!(DynamicScriptFunctionMut, DynamicScriptFunction);
+
 impl IntoScript for bool {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Bool(self))

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

@@ -13,7 +13,7 @@ use bevy::reflect::{
     },
     PartialReflect,
 };
-use script_function::{CallerContext, DynamicScriptFunction};
+use script_function::{CallerContext, DynamicScriptFunction, DynamicScriptFunctionMut};
 
 use crate::{
     error::{FlattenError, InteropError, InteropErrorInner, ScriptError, ScriptResult},
@@ -30,7 +30,7 @@ use super::{
 /// The claim and release functions must be used to scope the access to the world such that function output .
 pub trait CallScriptFunction {
     fn call_script_function<I: IntoIterator<Item = ScriptValue>>(
-        &self,
+        &mut self,
         args: I,
         world: WorldGuard,
         context: CallerContext,
@@ -39,7 +39,25 @@ pub trait CallScriptFunction {
 
 impl CallScriptFunction for DynamicScriptFunction {
     fn call_script_function<I: IntoIterator<Item = ScriptValue>>(
-        &self,
+        &mut self,
+        args: I,
+        world: WorldGuard,
+        context: CallerContext,
+    ) -> Result<ScriptValue, InteropError> {
+        let args = args.into_iter().collect::<Vec<_>>();
+        let world_callback_access = WorldCallbackAccess::from_guard(world.clone());
+        // should we be inlining call errors into the return value?
+        let return_val = self.call(context, world_callback_access, args);
+        match return_val {
+            ScriptValue::Error(e) => Err(InteropError::function_interop_error(self.name(), e)),
+            v => Ok(v),
+        }
+    }
+}
+
+impl CallScriptFunction for DynamicScriptFunctionMut {
+    fn call_script_function<I: IntoIterator<Item = ScriptValue>>(
+        &mut self,
         args: I,
         world: WorldGuard,
         context: CallerContext,

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

@@ -30,6 +30,14 @@ pub trait ScriptFunction<'env, Marker> {
     fn into_dynamic_script_function(self) -> DynamicScriptFunction;
 }
 
+#[diagnostic::on_unimplemented(
+    message = "Only functions with all arguments impplementing FromScript and return values supporting IntoScript are supported. Registering functions also requires they implement GetInnerTypeDependencies",
+    note = "If you're trying to return a non-primitive type, you might need to use Val<T> Ref<T> or Mut<T> wrappers"
+)]
+pub trait ScriptFunctionMut<'env, Marker> {
+    fn into_dynamic_script_function_mut(self) -> DynamicScriptFunctionMut;
+}
+
 /// Functionally identical to [`GetTypeRegistration`] but without the 'static bound
 pub trait GetInnerTypeDependencies {
     fn register_type_dependencies(registry: &mut TypeRegistry);
@@ -39,8 +47,8 @@ pub trait GetInnerTypeDependencies {
 macro_rules! no_type_dependencies {
     ($($path:path),*) => {
         $(
-            impl GetInnerTypeDependencies for $path {
-                fn register_type_dependencies(_registry: &mut TypeRegistry) {}
+            impl $crate::bindings::function::script_function::GetInnerTypeDependencies for $path {
+                fn register_type_dependencies(_registry: &mut bevy::reflect::TypeRegistry) {}
             }
         )*
     };
@@ -115,7 +123,8 @@ pub struct CallerContext {
 }
 
 /// The Script Function equivalent for dynamic functions. Currently unused
-#[derive(Clone)]
+#[derive(Clone, Reflect)]
+#[reflect(opaque)]
 pub struct DynamicScriptFunction {
     name: Cow<'static, str>,
     // TODO: info about the function, this is hard right now because of non 'static lifetimes in wrappers, we can't use TypePath etc
@@ -126,6 +135,34 @@ pub struct DynamicScriptFunction {
             + 'static,
     >,
 }
+
+impl PartialEq for DynamicScriptFunction {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
+#[derive(Clone, Reflect)]
+#[reflect(opaque)]
+pub struct DynamicScriptFunctionMut {
+    name: Cow<'static, str>,
+    func: Arc<
+        RwLock<
+            // I'd rather consume an option or something instead of having the RWLock but I just wanna get this release out
+            dyn FnMut(CallerContext, WorldCallbackAccess, Vec<ScriptValue>) -> ScriptValue
+                + Send
+                + Sync
+                + 'static,
+        >,
+    >,
+}
+
+impl PartialEq for DynamicScriptFunctionMut {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
 impl DynamicScriptFunction {
     pub fn call(
         &self,
@@ -148,9 +185,72 @@ impl DynamicScriptFunction {
     }
 }
 
+impl DynamicScriptFunctionMut {
+    pub fn call(
+        &mut self,
+        context: CallerContext,
+        world: WorldCallbackAccess,
+        args: Vec<ScriptValue>,
+    ) -> ScriptValue {
+        let mut write = self.func.write();
+        write(context, world, args)
+    }
+
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
+
+    pub fn with_name<N: Into<Cow<'static, str>>>(self, name: N) -> Self {
+        Self {
+            name: name.into(),
+            func: self.func,
+        }
+    }
+}
+
 impl std::fmt::Debug for DynamicScriptFunction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DynamicScriptFunction").finish()
+        f.debug_struct("DynamicScriptFunction")
+            .field("name", self.name())
+            .finish()
+    }
+}
+
+impl std::fmt::Debug for DynamicScriptFunctionMut {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DynamicScriptFunctionMut")
+            .field("name", self.name())
+            .finish()
+    }
+}
+
+impl<F> From<F> for DynamicScriptFunction
+where
+    F: Fn(CallerContext, WorldCallbackAccess, Vec<ScriptValue>) -> ScriptValue
+        + Send
+        + Sync
+        + 'static,
+{
+    fn from(fn_: F) -> Self {
+        DynamicScriptFunction {
+            name: std::any::type_name::<F>().into(),
+            func: Arc::new(fn_),
+        }
+    }
+}
+
+impl<F> From<F> for DynamicScriptFunctionMut
+where
+    F: FnMut(CallerContext, WorldCallbackAccess, Vec<ScriptValue>) -> ScriptValue
+        + Send
+        + Sync
+        + 'static,
+{
+    fn from(fn_: F) -> Self {
+        DynamicScriptFunctionMut {
+            name: std::any::type_name::<F>().into(),
+            func: Arc::new(RwLock::new(fn_)),
+        }
     }
 }
 
@@ -261,39 +361,59 @@ macro_rules! count {
 macro_rules! impl_script_function {
 
     ($( $param:ident ),* ) => {
-        // fn(T1...Tn) -> O
-        impl_script_function!(@ $( $param ),* : -> O => O );
-        // fn(WorldCallbackAccess, T1...Tn) -> O
-        impl_script_function!(@ $( $param ),* : ,(callback: WorldCallbackAccess) -> O => O);
-        // fn(CallerContext, WorldCallbackAccess, T1...Tn) -> O
-        impl_script_function!(@ $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => O);
-
-        // fn(T1...Tn) -> Result<O, InteropError>
-        impl_script_function!(@ $( $param ),* : -> O => Result<O, InteropError> where s);
-        // fn(WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
-        impl_script_function!(@ $( $param ),* : ,(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
-        // fn(CallerContext, WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
-        impl_script_function!(@ $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+        // all of this is pretty heavy on the compile time.
+        // ideally we'd do less, but for now this will suffice
+
+        // Fn(T1...Tn) -> O
+        impl_script_function!(@ ScriptFunction Fn DynamicScriptFunction into_dynamic_script_function $( $param ),* : -> O => O );
+        // FnMut(T1...Tn) -> O
+        impl_script_function!(@ ScriptFunctionMut FnMut DynamicScriptFunctionMut into_dynamic_script_function_mut $( $param ),* : -> O => O );
+
+        // Fn(WorldCallbackAccess, T1...Tn) -> O
+        impl_script_function!(@ ScriptFunction Fn DynamicScriptFunction into_dynamic_script_function $( $param ),* : ,(callback: WorldCallbackAccess) -> O => O);
+        // FnMut(WorldCallbackAccess, T1...Tn) -> O
+        impl_script_function!(@ ScriptFunctionMut FnMut DynamicScriptFunctionMut into_dynamic_script_function_mut $( $param ),* : ,(callback: WorldCallbackAccess) -> O => O);
+
+        // Fn(CallerContext, WorldCallbackAccess, T1...Tn) -> O
+        impl_script_function!(@ ScriptFunction Fn DynamicScriptFunction into_dynamic_script_function $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => O);
+        // FnMut(CallerContext, WorldCallbackAccess, T1...Tn) -> O
+        impl_script_function!(@ ScriptFunctionMut FnMut DynamicScriptFunctionMut into_dynamic_script_function_mut $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => O);
+
+        // Fn(T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ ScriptFunction Fn DynamicScriptFunction into_dynamic_script_function $( $param ),* : -> O => Result<O, InteropError> where s);
+        // FnMut(T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ ScriptFunctionMut FnMut DynamicScriptFunctionMut into_dynamic_script_function_mut $( $param ),* : -> O => Result<O, InteropError> where s);
+
+        // Fn(WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ ScriptFunction Fn DynamicScriptFunction into_dynamic_script_function $( $param ),* : ,(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+        // FnMut(WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ ScriptFunctionMut FnMut DynamicScriptFunctionMut into_dynamic_script_function_mut $( $param ),* : ,(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+
+        // Fn(CallerContext, WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ ScriptFunction Fn DynamicScriptFunction into_dynamic_script_function $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+        // FnMut(CallerContext, WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ ScriptFunctionMut FnMut DynamicScriptFunctionMut into_dynamic_script_function_mut $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+
 
     };
 
-    (@ $( $param:ident ),* :  $(($context:ident: $contextty:ty))? $(,($callback:ident: $callbackty:ty))? -> O => $res:ty $(where $out:ident)?) => {
+    (@ $trait_type:ident $fn_type:ident $dynamic_type:ident $trait_fn_name:ident $( $param:ident ),* :  $(($context:ident: $contextty:ty))? $(,($callback:ident: $callbackty:ty))? -> O => $res:ty $(where $out:ident)?) => {
         #[allow(non_snake_case)]
         impl<
             'env,
             $( $param: FromScript, )*
             O,
             F
-        > ScriptFunction<'env,
+        > $trait_type<'env,
             fn( $($contextty,)? $( $callbackty, )? $($param ),* ) -> $res
         > for F
         where
             O: IntoScript + TypePath + GetOwnership,
-            F: Fn(  $($contextty,)? $( $callbackty, )? $($param ),* ) -> $res + Send + Sync + 'static,
+            F: $fn_type(  $($contextty,)? $( $callbackty, )? $($param ),* ) -> $res + Send + Sync + 'static,
             $( $param::This<'env>: Into<$param>,)*
         {
             #[allow(unused_mut,unused_variables)]
-            fn into_dynamic_script_function(self) -> DynamicScriptFunction {
+            fn $trait_fn_name(mut self) -> $dynamic_type {
                 let func = (move |caller_context: CallerContext, world: WorldCallbackAccess, args: Vec<ScriptValue> | {
                     let res: Result<ScriptValue, InteropError> = (|| {
                         let expected_arg_count = count!($($param )*);
@@ -330,7 +450,7 @@ macro_rules! impl_script_function {
                     script_value
                 });
 
-                DynamicScriptFunction { func: Arc::new(func), name: core::any::type_name::<Self>().into() }
+                func.into()
             }
         }
     };

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -397,6 +397,7 @@ impl DisplayWithWorld for ScriptValue {
     fn display_value_with_world(&self, world: WorldGuard) -> String {
         match self {
             ScriptValue::Reference(r) => r.display_value_with_world(world),
+            ScriptValue::Function(f) => format!("Function({})", f.name()),
             ScriptValue::Unit => "()".to_owned(),
             ScriptValue::Bool(b) => b.to_string(),
             ScriptValue::Integer(i) => i.to_string(),

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

@@ -15,7 +15,11 @@ use crate::{
     reflection_extensions::{PartialReflectExt, TypeIdExtensions, TypeInfoExtensions},
 };
 
-use super::{pretty_print::DisplayWithWorld, ReflectReference, WorldGuard};
+use super::{
+    function::script_function::{DynamicScriptFunction, DynamicScriptFunctionMut},
+    pretty_print::DisplayWithWorld,
+    ReflectReference, WorldGuard,
+};
 
 /// An abstraction of values that can be passed to and from scripts.
 /// This allows us to re-use logic between scripting languages.
@@ -36,6 +40,8 @@ pub enum ScriptValue {
     List(Vec<ScriptValue>),
     /// Represents a reference to a value.
     Reference(ReflectReference),
+    /// A dynamic script function
+    Function(DynamicScriptFunctionMut),
     /// Represents any error, will be thrown when returned to a script
     Error(InteropError),
 }
@@ -50,6 +56,7 @@ impl ScriptValue {
             ScriptValue::String(_) => "String".to_owned(),
             ScriptValue::List(_) => "List".to_owned(),
             ScriptValue::Reference(_) => "Reference".to_owned(),
+            ScriptValue::Function(_) => "Function".to_owned(),
             ScriptValue::Error(_) => "Error".to_owned(),
         }
     }
@@ -109,12 +116,6 @@ impl From<ReflectReference> for ScriptValue {
     }
 }
 
-// impl From<ScriptError> for ScriptValue {
-//     fn from(value: ScriptError) -> Self {
-//         ScriptValue::Error(value)
-//     }
-// }
-
 impl From<InteropError> for ScriptValue {
     fn from(value: InteropError) -> Self {
         ScriptValue::Error(value)