make overloading work for subtraction

Author: makspll

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

@@ -139,6 +139,13 @@ impl DynamicScriptFunction {
     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 {
@@ -201,7 +208,7 @@ impl ScriptFunctionRegistry {
         let name = name.into().clone();
 
         if !self.contains(&name) {
-            let func = func.into_dynamic_script_function();
+            let func = func.into_dynamic_script_function().with_name(name.clone());
             self.functions.insert(name, func);
             return;
         }

crates/bevy_mod_scripting_functions/src/namespaced_register.rs

@@ -1,11 +1,12 @@
 use std::{any::TypeId, borrow::Cow, marker::PhantomData};
 
 use bevy::{
-    prelude::{AppFunctionRegistry, IntoFunction, World},
+    prelude::{AppFunctionRegistry, AppTypeRegistry, IntoFunction, World},
     reflect::func::{DynamicFunction, FunctionRegistrationError, FunctionRegistry},
 };
 use bevy_mod_scripting_core::bindings::function::script_function::{
-    AppScriptFunctionRegistry, DynamicScriptFunction, ScriptFunction, ScriptFunctionRegistry,
+    AppScriptFunctionRegistry, DynamicScriptFunction, GetFunctionTypeDependencies, ScriptFunction,
+    ScriptFunctionRegistry,
 };
 
 pub trait RegisterNamespacedFunction {
@@ -17,6 +18,13 @@ pub trait RegisterNamespacedFunction {
 }
 
 pub trait GetNamespacedFunction {
+    fn iter_overloads_namespaced<N>(
+        &self,
+        name: N,
+        namespace: Namespace,
+    ) -> impl Iterator<Item = &DynamicScriptFunction>
+    where
+        N: Into<Cow<'static, str>>;
     fn get_namespaced_function<N>(
         &self,
         name: N,
@@ -78,6 +86,19 @@ impl RegisterNamespacedFunction for ScriptFunctionRegistry {
 }
 
 impl GetNamespacedFunction for ScriptFunctionRegistry {
+    fn iter_overloads_namespaced<N>(
+        &self,
+        name: N,
+        namespace: Namespace,
+    ) -> impl Iterator<Item = &DynamicScriptFunction>
+    where
+        N: Into<Cow<'static, str>>,
+    {
+        let cow: Cow<'static, str> = name.into();
+        let function_name = namespace.function_name(cow);
+        self.iter_overloads(function_name)
+    }
+
     fn get_namespaced_function<N>(
         &self,
         name: N,
@@ -117,14 +138,21 @@ impl<'a, S: IntoNamespace> NamespaceBuilder<'a, S> {
     pub fn register<N, F, M>(&mut self, name: N, function: F) -> &mut Self
     where
         N: Into<Cow<'static, str>>,
-        F: ScriptFunction<'static, M>,
+        F: ScriptFunction<'static, M> + GetFunctionTypeDependencies<M>,
     {
         {
-            let mut registry = self
-                .world
-                .get_resource_or_init::<AppScriptFunctionRegistry>();
-            let mut registry = registry.write();
-            registry.register_namespaced_function::<S, _, F, M>(name, function);
+            {
+                let mut registry = self
+                    .world
+                    .get_resource_or_init::<AppScriptFunctionRegistry>();
+                let mut registry = registry.write();
+                registry.register_namespaced_function::<S, _, F, M>(name, function);
+            }
+            {
+                let mut type_registry = self.world.get_resource_or_init::<AppTypeRegistry>();
+                let mut type_registry = type_registry.write();
+                F::register_type_dependencies(&mut type_registry);
+            }
         }
         self
     }

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

@@ -113,6 +113,23 @@ fn lookup_dynamic_function_typed<T: 'static + ?Sized>(
     lookup_dynamic_function(lua, key, type_id)
 }
 
+fn iter_dynamic_function_overloads(
+    lua: &Lua,
+    key: &str,
+    type_id: TypeId,
+) -> impl Iterator<Item = DynamicScriptFunction> {
+    let registry = lua
+        .get_world()
+        .with_resource(|registry: &AppScriptFunctionRegistry| registry.clone());
+    let registry = registry.read();
+
+    registry
+        .iter_overloads_namespaced(key.to_string(), Namespace::OnType(type_id))
+        .cloned()
+        .collect::<Vec<_>>()
+        .into_iter()
+}
+
 impl UserData for LuaReflectReference {
     fn add_methods<T: UserDataMethods<Self>>(m: &mut T) {
         m.add_meta_function(
@@ -167,6 +184,37 @@ impl UserData for LuaReflectReference {
             },
         );
 
+        m.add_meta_function(
+            MetaMethod::Sub,
+            |lua, (self_, other): (LuaReflectReference, LuaScriptValue)| {
+                let world = lua.get_world();
+                let self_: ReflectReference = self_.into();
+                let other: ScriptValue = other.into();
+
+                let target_type_id = self_.tail_type_id(world.clone())?.or_fake_id();
+
+                let overloads = iter_dynamic_function_overloads(lua, "sub", target_type_id);
+                let mut last_error = None;
+                let call_args = vec![ScriptValue::Reference(self_), other];
+                for overload in overloads {
+                    match overload.call_script_function(
+                        call_args.clone(),
+                        world.clone(),
+                        lua_caller_context(),
+                    ) {
+                        Ok(out) => return LuaScriptValue::from(out).into_lua(lua),
+                        Err(e) => last_error = Some(e),
+                    }
+                }
+
+                Err(last_error
+                    .unwrap_or_else(|| {
+                        InteropError::missing_function(target_type_id, "sub".to_string()).into()
+                    })
+                    .into())
+            },
+        );
+
         // #[cfg(any(
         //     feature = "lua54",
         //     feature = "lua53",

crates/languages/bevy_mod_scripting_lua/tests/data/sub/vec3.lua

@@ -0,0 +1,13 @@
+
+
+local a = Vec3.new(1.0, 2.0, 3.0)
+local b = Vec3.new(4.0, 5.0, 6.0)
+
+
+assert((a - 1).x == 0.0, "Subtraction did not work")
+assert((a - 1).y == 1.0, "Subtraction did not work")
+assert((a - 1).z == 2.0, "Subtraction did not work")
+
+assert((a - b).x == -3.0, "Subtraction did not work")
+assert((a - b).y == -3.0, "Subtraction did not work")
+assert((a - b).z == -3.0, "Subtraction did not work")