Add back metamethods for math types

Author: makspll

assets/scripts/bevy_api.lua

@@ -107,18 +107,29 @@ function on_event()
 
     print("============")
 
+    print(Vec3.new(0,1,0) + Vec3.new(1,0,0))
+    print(Vec3.new(0,1,0):any_orthonormal_vector())
+    print(comp.mat3[1])
+    print(Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3[1])
     local complex_vec_op = Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3[1] 
     print("(0,1,0).any_orthonormal_vector() + mat3.x_axis is: ", complex_vec_op) 
 
     local new_mat3 = Mat3.from_cols(Vec3.new(1,0,0),Vec3.new(0,1,0),Vec3.new(0,0,-1))
     print("new_mat3 is:", new_mat3)
 
-    comp.vec2 = comp.vec2 + comp.vec2
+    -- comp.vec2 = comp.vec2 + comp.vec2
+    print("A")
     comp.usize = comp.vec2:min_element()
+    
+    print("B")
     comp.f32 = comp.f32 + comp.f32 + comp.vec2:min_element()
+    print("C")
     comp.vec2 = Vec2.new(2,1)
+    print("D")
     comp.quat = Quat.from_xyzw(3,2,1,4)
+    print("E")
     comp.mat3[1] = Vec3.new(69,69,69)
+    print("F")
 
 
     world:exit()

crates/bevy_api_gen/templates/function.tera

@@ -12,42 +12,27 @@ r#"
     {% endif %}
 as_trait="{{ function.from_trait_path }}",
 {%- endif -%}
-
 {% if is_op %}
 composite="{{ function.ident }}",
 {% endif %}
 
-{#
-{% if function.has_self and not is_op %}
-kind="{% if function.args.0.ty is starting_with("&mut") %}Mutating{% endif %}Method",
-{% elif is_op %}
-kind="MetaFunction",
-{% else %}
-kind="Function",
-{% endif %}
-
-{%- if function.output.reflection_strategy == "Proxy" -%}
-output(proxy),
-{%- endif -%}
-
-
-
-{% if function.from_trait_path == "std::ops::Neg" %}
-metamethod="Unm",
-{% elif function.from_trait_path == "std::ops::Mul" %}
-metamethod="Mul",
-{% elif function.from_trait_path == "std::ops::Add" %}
-metamethod="Add",
-{% elif function.from_trait_path == "std::ops::Sub" %}
-metamethod="Sub",
-{% elif function.from_trait_path == "std::ops::Div" %}
-metamethod="Div",
-{% elif function.from_trait_path == "std::ops::Rem" %}
-metamethod="Mod",
-{% elif function.from_trait_path == "std::cmp::PartialEq" %}
-metamethod="Eq",
+{% if function.from_trait_path %}
+    {% if function.from_trait_path is starting_with("std::ops::Neg") %}
+    metamethod="Unm",
+    {% elif function.from_trait_path is starting_with("std::ops::Mul") %}
+    metamethod="Mul",
+    {% elif function.from_trait_path is starting_with("std::ops::Add") %}
+    metamethod="Add",
+    {% elif function.from_trait_path is starting_with("std::ops::Sub") %}
+    metamethod="Sub",
+    {% elif function.from_trait_path is starting_with("std::ops::Div") %}
+    metamethod="Div",
+    {% elif function.from_trait_path is starting_with("std::ops::Rem") %}
+    metamethod="Mod",
+    {% elif function.from_trait_path is starting_with("std::cmp::PartialEq") %}
+    metamethod="Eq",
+    {% endif %}
 {% endif %}
-#}
 )] 
 {% if function.is_unsafe %}unsafe {% endif -%}fn {{ function.ident }} (
     {%- filter separated(delimeter=", ", split_at="---", ignore_first=true) -%}

crates/bevy_api_gen/templates/macros.tera

@@ -13,21 +13,21 @@ fn index(&mut self, idx: usize, val: {{ num_type }}) -> () {
 {% endmacro vector_newindex %}
 
 {% macro matrix_index(col_type, mat_type, bms_core_path) %}
-#[lua(metamethod="Index")]
-fn index(_self: LuaIdentityProxy<Self>, idx: usize) -> LuaIdentityProxy<{{ col_type | prefix_lua }}> {
-    let mut curr_ref = _self.0.clone();
-    let def_ref = {{bms_core_path}}::bindings::DeferredReflection{
-        get: std::sync::Arc::new(|ref_| Err(bevy::reflect::ReflectPathError::InvalidDowncast)),
-        get_mut: std::sync::Arc::new(move |ref_| {
-            if let Some(ret) = ref_.try_as_reflect_mut().map(|ret| ret.downcast_mut::<bevy::math::{{ mat_type }}>()).flatten(){
-                Ok(ret.col_mut(idx - 1))
-            } else {
-                Err(bevy::reflect::ReflectPathError::InvalidDowncast)
-            }	
-        })
+#[lua(metamethod="Index", with_context, no_proxy)]
+fn index(_self: Self, idx: usize, lua: &tealr::mlu::mlua::Lua) -> Result<tealr::mlu::mlua::Value, tealr::mlu::mlua::Error> {
+    let mut curr_ref = _self.0;
+
+    let path = match idx {
+        1 => "x_axis",
+        2 => "y_axis",
+        3 => "z_axis",
+        4 => "w_axis",
+        _ => "unknown_axis"
     };
-    curr_ref.reflect_path.push({{bms_core_path}}::bindings::ReflectionPathElem::new_deferred(def_ref));
-    {{ col_type | prefix_lua }}(curr_ref)
+
+    let parsed_path = bevy::reflect::ParsedPath::parse_static(path).expect("invariant");
+    curr_ref.index_path(bevy_mod_scripting_core::bindings::ReflectionPathElem::new_reflection(parsed_path));
+    crate::bindings::reference::LuaReflectReference(curr_ref).to_lua_proxy(lua)
 }
 {% endmacro matrix_index %}
 

crates/bevy_mod_scripting_core/src/bindings/world.rs

@@ -550,6 +550,20 @@ impl<'w> WorldAccessGuard<'w> {
     /// Call a function on a type which can be proxied, first by unproxying the input with world access,
     /// then calling the function and finally proxying the output with the allocator.
     pub fn proxy_call<'i, O: Proxy, T: Unproxy, F: Fn(T::Output<'_>) -> O::Input<'i>>(
+        &self,
+        proxied_input: T,
+        f: F,
+    ) -> ScriptResult<O> {
+        self.try_proxy_call(proxied_input, |o| Ok::<_, ScriptError>(f(o)))
+    }
+
+    pub fn try_proxy_call<
+        'i,
+        O: Proxy,
+        E: Into<Box<dyn std::error::Error + Send + Sync>>,
+        T: Unproxy,
+        F: Fn(T::Output<'_>) -> Result<O::Input<'i>, E>,
+    >(
         &self,
         mut proxied_input: T,
         f: F,
@@ -567,7 +581,10 @@ impl<'w> WorldAccessGuard<'w> {
             }
         })?;
 
-        let out = f(unproxied_input);
+        let out = f(unproxied_input).map_err(|e| {
+            let e: Box<dyn std::error::Error + Send + Sync> = e.into();
+            ScriptError::new_generic_error(e)
+        })?;
 
         let proxied_output = self.with_resource(|_, mut allocator: Mut<ReflectAllocator>| {
             O::proxy_with_allocator(out, &mut allocator)

crates/bevy_mod_scripting_core/src/error.rs

@@ -131,15 +131,11 @@ impl std::fmt::Display for ScriptError {
         if let Some(script) = &self.0.script {
             write!(
                 f,
-                "Encountered {} error in script `{}`: {}",
+                "{} in script `{}`: {}",
                 self.0.kind, script, self.0.reason
             )
         } else {
-            write!(
-                f,
-                "Encountered {} error in a script: {}",
-                self.0.kind, self.0.reason
-            )
+            write!(f, "{}: {}", self.0.kind, self.0.reason)
         }
     }
 }

crates/bevy_mod_scripting_derive/src/lib.rs

@@ -152,7 +152,7 @@ fn proxy_wrap_function_def(
     };
 
     let func_name = &f.sig.ident;
-    let (mut original_arg_idents, _) = f
+    let (mut original_arg_idents, mut original_arg_types) = f
         .sig
         .inputs
         .iter()
@@ -190,6 +190,7 @@ fn proxy_wrap_function_def(
 
     let args_var_to_use = if get_world_callback_access_fn.is_some() {
         original_arg_idents.remove(0);
+        original_arg_types.remove(0);
         args_tail_ident
     } else {
         args_ident
@@ -203,7 +204,7 @@ fn proxy_wrap_function_def(
     };
 
     // wrap function body in our unwrapping and wrapping logic, ignore pre-existing body
-    let mut fn_call = std::panic::catch_unwind(|| {
+    let mut fn_call = //std::panic::catch_unwind(|| {
         match (
             &f.default,
             &attrs.as_trait,
@@ -212,9 +213,19 @@ fn proxy_wrap_function_def(
             (_, _, true) => quote_spanned!(span=>
                 world.#func_name(#(#original_arg_idents),*)
             ),
-            (Some(body), _, _) => quote_spanned!(span=>
-                (||{ #body })()
-            ),
+            (Some(body), _, _) => {
+                if attrs.no_proxy.is_present() {
+                    // in this case the entire thing is just this
+                    quote_spanned!(span=>
+                        {(|#ctxt_arg_ident, (#(#original_arg_idents),*) : (#(#original_arg_types),*)|{ #body })(#ctxt_alias, #args_var_to_use)}
+                    )
+                } else {
+                    // in this case we are just using this to contain any ? calls and early returns
+                    quote_spanned!(span=> 
+                        (|| { #body })()
+                    )
+                }
+            },
             (_, None, _) => quote_spanned!(span=>
                 #target_type::#func_name(#(#original_arg_idents),*)
             ),
@@ -224,9 +235,9 @@ fn proxy_wrap_function_def(
                     <#target_type as #trait_path>::#func_name(#(#original_arg_idents),*)
                 )
             }
-        }
-    })
-    .unwrap(); // todo: handle the error nicer
+        };
+    //})
+    // .unwrap(); // todo: handle the error nicer
 
     if f.sig.unsafety.is_some() {
         fn_call = quote_spanned!(span=>
@@ -236,9 +247,9 @@ fn proxy_wrap_function_def(
 
     if attrs.no_proxy.is_present() {
         f.default = Some(parse_quote_spanned! {span=>
-            {
-                #fn_call
-            }
+            
+            #fn_call
+            
         });
     } else {
         let world = if let Some(world_getter_fn_path) = get_world_callback_access_fn {
@@ -254,11 +265,17 @@ fn proxy_wrap_function_def(
             )
         };
 
+        let proxy_call_name: Ident = if attrs.fallible.is_present() {
+            format_ident!("try_proxy_call", span = span)
+        } else {
+            format_ident!("proxy_call", span = span)
+        };
+
         f.default = Some(parse_quote_spanned! {span=>
             {
                 #args_split
                 #world
-                let out: #out_type = world.proxy_call(#args_var_to_use, |(#(#original_arg_idents),*)| {
+                let out: #out_type = world.#proxy_call_name(#args_var_to_use, |(#(#original_arg_idents),*)| {
                     #fn_call
                 }).map_err(|e| #mlua::Error::external(e))?;
                 Ok(out)
@@ -315,6 +332,9 @@ struct FunctionAttrs {
     /// i.e. will remove that argument from the function signature and use it's name as the context alias
     pub with_context: Flag,
 
+    /// if true will treat output as a fallible result
+    pub fallible: Flag,
+
     /// Skips the unproxying & proxying call, useful for functions that don't need to access the world
     pub no_proxy: Flag,
 }
@@ -377,7 +397,7 @@ pub fn impl_lua_proxy(input: TokenStream) -> TokenStream {
     // extract composites first
     let mut composites: HashMap<String, Vec<(TraitItemFn, FunctionAttrs)>> = HashMap::new();
     meta.functions.0.retain(|f| {
-        let attrs = FunctionAttrs::from_attributes(&f.attrs).unwrap();
+        let attrs = FunctionAttrs::from_attributes(&f.attrs).expect("Function attributes must be valid");
         if let Some(composite_id) = &attrs.composite {
             composites
                 .entry(composite_id.to_owned())
@@ -423,7 +443,7 @@ pub fn impl_lua_proxy(input: TokenStream) -> TokenStream {
             .collect::<Vec<_>>();
 
         let closure_args_types = closures.iter().map(|closure| {
-            let last = closure.inputs.last().unwrap();
+            let last = closure.inputs.last().expect("Closure must have at least one argument");
             if let syn::Pat::Type(pat_type) = last {
                 &pat_type.ty
             } else {
@@ -448,7 +468,7 @@ pub fn impl_lua_proxy(input: TokenStream) -> TokenStream {
     });
 
     let add_function_stmts = meta.functions.0.into_iter().filter_map(|mut f| {
-        let attrs = FunctionAttrs::from_attributes(&f.attrs).unwrap();
+        let attrs = FunctionAttrs::from_attributes(&f.attrs).expect("Function attributes must be valid");
 
         if attrs.skip.is_present() {
             return None;

crates/languages/bevy_mod_scripting_lua/src/bindings/providers/bevy_core.rs

@@ -21,23 +21,24 @@ use crate::{
     bms_lua_path = "crate",
     functions[r#"
 
+    #[lua(as_trait = "std::clone::Clone")]
+    fn clone(
+        _self: LuaReflectRefProxy<bevy::core::prelude::Name>,
+    ) -> LuaReflectValProxy<bevy::core::prelude::Name>;
+
+"#,
+    r#"
+
     #[lua(
         as_trait = "std::cmp::PartialEq::<bevy::core::prelude::Name>",
         composite = "eq",
+        metamethod = "Eq",
     )]
     fn eq(
         _self: LuaReflectRefProxy<bevy::core::prelude::Name>,
         other: LuaReflectRefProxy<bevy::core::prelude::Name>,
     ) -> bool;
 
-"#,
-    r#"
-
-    #[lua(as_trait = "std::clone::Clone")]
-    fn clone(
-        _self: LuaReflectRefProxy<bevy::core::prelude::Name>,
-    ) -> LuaReflectValProxy<bevy::core::prelude::Name>;
-
 "#,
     r#"
 #[lua(metamethod="ToString")]