Finally get a world proxy going for lua ✨

Author: makspll

.vscode/tasks.json

@@ -12,6 +12,12 @@
             "type": "promptString",
             "description": "The crate location of this unit test",
             "default": "bevy_mod_scripting"
+        },
+        {
+            "id": "features",
+            "type": "promptString",
+            "description": "The features to enable for this unit test",
+            "default": ""
         }
     ],
     "tasks": [
@@ -22,7 +28,8 @@
             "args": [
                 "build_test_in_package",
                 "PACKAGE=${input:package}",
-                "TEST_NAME=${input:test_name}"
+                "TEST_NAME=${input:test_name}",
+                "TEST_FEATURES=${input:features}"
             ]
         }
     ]

Cargo.toml

@@ -92,6 +92,7 @@ members = [
     "crates/languages/bevy_mod_scripting_rhai_derive",
     "crates/languages/bevy_mod_scripting_rune",
     "crates/bevy_mod_scripting_common",
+    "crates/bevy_mod_scripting_derive",
 ]
 resolver = "2"
 exclude = ["crates/bevy_api_gen", "crates/macro_tests"]

crates/bevy_mod_scripting_derive/Cargo.toml

@@ -19,7 +19,12 @@ proc-macro = true
 [dependencies]
 paste = "1.0.7"
 darling = "0.20.3"
-syn = { version = "2.0.38", features = ["full", "fold", "extra-traits"] }
+syn = { version = "2.0.38", features = [
+    "full",
+    "fold",
+    "extra-traits",
+    "visit-mut",
+] }
 quote = "1.0.8"
 proc-macro2 = "1.0"
 convert_case = "0.5.0"

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

@@ -10,15 +10,67 @@ use bevy_mod_scripting_core::{
     error::{ScriptError, ScriptResult},
 };
 use tealr::{
-    mlu::mlua::{Error, FromLua, IntoLua, Lua, Value},
+    mlu::mlua::{Error, FromLua, IntoLua, IntoLuaMulti, Lua, Value},
     ToTypename,
 };
 
-/// Local trait alias for the [`Proxied`] trait.
+use super::world::Nil;
+
+/// Think of this as a Local trait alias for the [`Proxy`] trait. Specifies the proxy type for a given type.
 pub trait LuaProxied {
     type Proxy;
 }
 
+/// Proxy which acts exactly like `T` when converting to Lua, but provides a `ToTypename` implementation based on another type `N`.
+/// Used internally basically only to support Result types in Lua directly.
+/// Will be unnecessary once I get rid of tealr.    
+pub(crate) struct TypenameProxy<T, N: ToTypename>(T, std::marker::PhantomData<N>);
+
+impl<T, N: ToTypename> TypenameProxy<T, N> {
+    pub fn new(value: T) -> Self {
+        Self(value, std::marker::PhantomData)
+    }
+}
+
+impl<T, N: ToTypename> ToTypename for TypenameProxy<T, N> {
+    fn to_typename() -> tealr::Type {
+        N::to_typename()
+    }
+}
+
+impl<'a, T: IntoLuaMulti<'a>, N: ToTypename> IntoLua<'a> for TypenameProxy<T, N> {
+    fn into_lua(self, lua: &'a Lua) -> tealr::mlu::mlua::Result<Value<'a>> {
+        self.0
+            .into_lua_multi(lua)
+            .map(|mut v| v.pop_front().unwrap())
+    }
+}
+
+/// Proxy which converts to lua by throwing the error. Can be used inside a [`Result`] to proxy into a result which will throw the error if it's an [`Err`] when converting to Lua.
+pub struct ErrorProxy<E>(E);
+
+impl<'a, E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>> IntoLua<'a>
+    for ErrorProxy<E>
+{
+    fn into_lua(self, _: &'a Lua) -> tealr::mlu::mlua::prelude::LuaResult<Value<'a>> {
+        Err(Error::external(self.0))
+    }
+}
+
+/// This should never really need to be used, but it's here so we can use the type in Lua.
+impl<E> ToTypename for ErrorProxy<E> {
+    fn to_typename() -> tealr::Type {
+        tealr::Type::new_single("Error", tealr::KindOfType::External)
+    }
+}
+
+impl<E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>> Proxy for ErrorProxy<E> {
+    type Input<'i> = E;
+    fn proxy<'i>(value: Self::Input<'i>) -> ScriptResult<Self> {
+        Ok(Self(value))
+    }
+}
+
 /// Convenience for proxying a type into lua via itself without implementing [`Proxy`] on it.
 /// Converts to Lua via T's implementation of IntoLua directly
 pub struct LuaIdentityProxy<T>(pub Option<T>);

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

@@ -177,6 +177,18 @@ impl LuaProxied for ReflectReference {
     type Proxy = LuaReflectReference;
 }
 
+impl From<LuaReflectReference> for ReflectReference {
+    fn from(value: LuaReflectReference) -> Self {
+        value.0
+    }
+}
+
+impl From<ReflectReference> for LuaReflectReference {
+    fn from(value: ReflectReference) -> Self {
+        Self(value)
+    }
+}
+
 impl TealData for LuaReflectReference {
     fn add_methods<'lua, T: tealr::mlu::TealDataMethods<'lua, Self>>(m: &mut T) {
         m.add_meta_function(

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

@@ -1,39 +1,39 @@
-use tealr::{
-    mlu::{mlua::IntoLua, TealData},
-    ToTypename,
-};
+// use tealr::{
+//     mlu::{mlua::IntoLua, TealData},
+//     ToTypename,
+// };
 
-pub struct LuaResult<T, E>(Result<T, E>);
+// pub struct LuaResult<T, E>(Result<T, E>);
 
-impl<T, E> TealData for LuaResult<T, E>
-where
-    T: ToTypename + for<'l> IntoLua<'l>,
-    E: ToTypename + for<'l> IntoLua<'l>,
-{
-    fn add_methods<'lua, M: tealr::mlu::TealDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("is_ok", |_, this, _: ()| Ok(this.0.is_ok()));
-        methods.add_method("is_err", |_, this, _: ()| Ok(this.0.is_err()));
-        methods.add_function("unwrap", |_, this: LuaResult<T, E>| match this.0 {
-            Ok(value) => Ok(value),
-            Err(_) => Err(tealr::mlu::mlua::Error::RuntimeError(
-                "called `LuaResult::unwrap()` on an `Err` value".to_string(),
-            )),
-        });
-        methods.add_method("unwrap_err", |_, this, _: ()| match &this.0 {
-            Ok(_) => Err(tealr::mlu::mlua::Error::RuntimeError(
-                "called `LuaResult::unwrap_err()` on an `Ok` value".to_string(),
-            )),
-            Err(value) => Ok(value),
-        });
-    }
+// impl<T, E> TealData for LuaResult<T, E>
+// where
+//     T: ToTypename + for<'l> IntoLua<'l>,
+//     E: ToTypename + for<'l> IntoLua<'l>,
+// {
+//     fn add_methods<'lua, M: tealr::mlu::TealDataMethods<'lua, Self>>(methods: &mut M) {
+//         methods.add_method("is_ok", |_, this, _: ()| Ok(this.0.is_ok()));
+//         methods.add_method("is_err", |_, this, _: ()| Ok(this.0.is_err()));
+//         methods.add_function("unwrap", |_, this: LuaResult<T, E>| match this.0 {
+//             Ok(value) => Ok(value),
+//             Err(_) => Err(tealr::mlu::mlua::Error::RuntimeError(
+//                 "called `LuaResult::unwrap()` on an `Err` value".to_string(),
+//             )),
+//         });
+//         methods.add_method("unwrap_err", |_, this, _: ()| match &this.0 {
+//             Ok(_) => Err(tealr::mlu::mlua::Error::RuntimeError(
+//                 "called `LuaResult::unwrap_err()` on an `Ok` value".to_string(),
+//             )),
+//             Err(value) => Ok(value),
+//         });
+//     }
 
-    fn add_fields<'lua, F: tealr::mlu::TealDataFields<'lua, Self>>(_fields: &mut F) {}
-}
+//     fn add_fields<'lua, F: tealr::mlu::TealDataFields<'lua, Self>>(_fields: &mut F) {}
+// }
 
-impl<T: ToTypename, E: ToTypename> ToTypename for LuaResult<T, E> {
-    fn to_typename() -> tealr::Type {
-        let t = std::any::type_name::<T>();
-        let e = std::any::type_name::<E>();
-        tealr::Type::new_single(format!("LuaResult<{t},{e}>"), tealr::KindOfType::External)
-    }
-}
+// impl<T: ToTypename, E: ToTypename> ToTypename for LuaResult<T, E> {
+//     fn to_typename() -> tealr::Type {
+//         let t = std::any::type_name::<T>();
+//         let e = std::any::type_name::<E>();
+//         tealr::Type::new_single(format!("LuaResult<{t},{e}>"), tealr::KindOfType::External)
+//     }
+// }

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

@@ -14,14 +14,28 @@ pub struct LuaTypeRegistration(pub ScriptTypeRegistration);
 
 impl_userdata_from_lua!(LuaTypeRegistration);
 
-impl TealData for LuaTypeRegistration {}
+impl TealData for LuaTypeRegistration {
+    fn add_fields<'lua, F: tealr::mlu::TealDataFields<'lua, Self>>(fields: &mut F) {
+        fields.document("The [short name](https://docs.rs/bevy/latest/bevy/reflect/struct.TypeRegistration.html#method.get_short_name) of a type");
+        fields.add_field_method_get("short_name", |_, s| Ok(s.0.short_name().to_owned()));
+
+        fields.document("The full name of the type");
+        fields.add_field_method_get("type_name", |_, s| Ok(s.0.type_name()));
+    }
+}
 
 impl From<ScriptTypeRegistration> for LuaTypeRegistration {
     fn from(value: ScriptTypeRegistration) -> Self {
         Self(value)
     }
 }
 
+impl From<&LuaTypeRegistration> for ScriptTypeRegistration {
+    fn from(value: &LuaTypeRegistration) -> Self {
+        todo!()
+    }
+}
+
 impl LuaProxied for ScriptTypeRegistration {
     type Proxy = LuaTypeRegistration;
 }