fix conversion

Author: makspll

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

@@ -13,7 +13,7 @@ use bevy::reflect::{
     },
     PartialReflect,
 };
-use script_function::CallerContext;
+use script_function::{CallerContext, DynamicScriptFunction};
 
 use crate::{
     error::{FlattenError, InteropError, InteropErrorInner, ScriptError, ScriptResult},
@@ -37,56 +37,20 @@ pub trait CallScriptFunction {
     ) -> Result<ScriptValue, InteropError>;
 }
 
-impl CallScriptFunction for DynamicFunction<'_> {
+impl CallScriptFunction for DynamicScriptFunction {
     fn call_script_function<I: IntoIterator<Item = ScriptValue>>(
         &self,
         args: I,
         world: WorldGuard,
         context: CallerContext,
     ) -> Result<ScriptValue, InteropError> {
-        let args = args.into_iter();
-
-        let add_context = self.is_script_function();
-        let mut args_list = ArgList::new();
-
-        if add_context {
-            args_list = args_list.push_arg(ArgValue::Owned(Box::new(context)));
-            args_list = args_list.push_arg(ArgValue::Owned(Box::new(
-                WorldCallbackAccess::from_guard(world.clone()),
-            )));
-        }
-
-        for arg in args {
-            let arg_val = ArgValue::Owned(Box::new(arg));
-            args_list = args_list.push_arg(arg_val);
+        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),
         }
-
-        let return_val = self
-            .call(args_list)
-            .map_err(InteropError::function_call_error)?;
-
-        match return_val.try_into_or_boxed::<ScriptValue>() {
-            Ok(ScriptValue::Error(e)) => Err(InteropError::function_interop_error(self.info(), e)),
-            Ok(v) => Ok(v),
-            Err(b) => {
-                let allocator = world.allocator();
-                let mut allocator = allocator.write();
-
-                Ok(ReflectReference::new_allocated_boxed(b, &mut allocator).into())
-            }
-        }
-    }
-}
-
-pub trait DynamicFunctionExt {
-    fn is_script_function(&self) -> bool;
-}
-
-impl DynamicFunctionExt for DynamicFunction<'_> {
-    fn is_script_function(&self) -> bool {
-        self.info().args().first().map_or(false, |arg| {
-            arg.type_id() == std::any::TypeId::of::<CallerContext>()
-                || arg.type_id() == std::any::TypeId::of::<WorldCallbackAccess>()
-        })
     }
 }

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

@@ -117,14 +117,29 @@ pub struct CallerContext {
 /// The Script Function equivalent for dynamic functions. Currently unused
 #[derive(Clone)]
 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
-    pub func: Arc<
+    func: Arc<
         dyn Fn(CallerContext, WorldCallbackAccess, Vec<ScriptValue>) -> ScriptValue
             + Send
             + Sync
             + 'static,
     >,
 }
+impl DynamicScriptFunction {
+    pub fn call(
+        &self,
+        context: CallerContext,
+        world: WorldCallbackAccess,
+        args: Vec<ScriptValue>,
+    ) -> ScriptValue {
+        (self.func)(context, world, args)
+    }
+
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
+}
 
 impl std::fmt::Debug for DynamicScriptFunction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -274,7 +289,7 @@ macro_rules! impl_script_function {
             fn into_dynamic_script_function(self) -> DynamicScriptFunction {
                 let func = (move |caller_context: CallerContext, world: WorldCallbackAccess, args: Vec<ScriptValue> | {
                     let res: Result<ScriptValue, InteropError> = (|| {
-                        let expected_arg_count = count!($($param),*);
+                        let expected_arg_count = count!($($param )*);
                         if args.len() != expected_arg_count {
                             return Err(InteropError::function_call_error(FunctionError::ArgCountMismatch{
                                 expected: expected_arg_count,
@@ -308,7 +323,7 @@ macro_rules! impl_script_function {
                     script_value
                 });
 
-                DynamicScriptFunction { func: Arc::new(func) }
+                DynamicScriptFunction { func: Arc::new(func), name: core::any::type_name::<Self>().into() }
             }
         }
     };

crates/bevy_mod_scripting_core/src/error.rs

@@ -351,12 +351,9 @@ impl InteropError {
     }
 
     /// Thrown when an error happens in a function call. The inner error provides details on the error.
-    pub fn function_interop_error(function_info: &FunctionInfo, error: InteropError) -> Self {
+    pub fn function_interop_error(function_name: &str, error: InteropError) -> Self {
         Self(Arc::new(InteropErrorInner::FunctionInteropError {
-            function_name: function_info
-                .name()
-                .map(|s| s.to_string())
-                .unwrap_or("<unnamed function>".to_owned()),
+            function_name: function_name.to_string(),
             error,
         }))
     }

crates/languages/bevy_mod_scripting_lua/src/bindings/reference.rs

@@ -16,7 +16,10 @@ use bevy::{
 };
 use bevy_mod_scripting_core::{
     bindings::{
-        function::{script_function::CallerContext, CallScriptFunction},
+        function::{
+            script_function::{AppScriptFunctionRegistry, CallerContext, DynamicScriptFunction},
+            CallScriptFunction,
+        },
         pretty_print::{DisplayWithWorld, ReflectReferencePrinter},
         script_value::ScriptValue,
         ReflectAllocator, ReflectRefIter, ReflectReference, ReflectionPathExt, TypeIdSource,
@@ -91,25 +94,21 @@ fn lookup_function_typed<T: 'static + ?Sized>(
     lookup_function(lua, key, type_id)
 }
 
-fn lookup_dynamic_function<'lua>(
-    lua: &'lua Lua,
-    key: &str,
-    type_id: TypeId,
-) -> Option<DynamicFunction<'static>> {
+fn lookup_dynamic_function(lua: &Lua, key: &str, type_id: TypeId) -> Option<DynamicScriptFunction> {
     let function_registry = lua
         .get_world()
-        .with_resource(|registry: &AppFunctionRegistry| registry.clone());
+        .with_resource(|registry: &AppScriptFunctionRegistry| registry.clone());
     let registry = function_registry.read();
 
     registry
         .get_namespaced_function(key.to_string(), Namespace::OnType(type_id))
         .cloned()
 }
 
-fn lookup_dynamic_function_typed<'lua, T: 'static + ?Sized>(
-    lua: &'lua Lua,
+fn lookup_dynamic_function_typed<T: 'static + ?Sized>(
+    lua: &Lua,
     key: &str,
-) -> Option<DynamicFunction<'static>> {
+) -> Option<DynamicScriptFunction> {
     let type_id = TypeId::of::<T>();
     lookup_dynamic_function(lua, key, type_id)
 }