Fix calls to callable table and userdata fields

Close #746

Author: khvzak

src/table.rs

@@ -1307,6 +1307,8 @@ impl ObjectLike for Table {
     fn call_function<R: FromLuaMulti>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R> {
         match self.get(name)? {
             Value::Function(func) => func.call(args),
+            Value::Table(table) => table.call(args),
+            Value::UserData(ud) => ud.call(args),
             val => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
                 Err(Error::runtime(msg))
@@ -1322,6 +1324,8 @@ impl ObjectLike for Table {
     {
         match self.get(name) {
             Ok(Value::Function(func)) => func.call_async(args),
+            Ok(Value::Table(table)) => table.call_async(args),
+            Ok(Value::UserData(ud)) => ud.call_async(args),
             Ok(val) => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
                 AsyncCallFuture::error(Error::RuntimeError(msg))

src/traits.rs

@@ -169,14 +169,14 @@ pub trait ObjectLike: Sealed {
     where
         R: FromLuaMulti;
 
-    /// Gets the function associated to key `name` from the object and calls it,
+    /// Gets the callable value associated to key `name` from the object and calls it,
     /// passing the object itself along with `args` as function arguments.
     fn call_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R>
     where
         R: FromLuaMulti;
 
-    /// Gets the function associated to key `name` from the object and asynchronously calls it,
-    /// passing the object itself along with `args` as function arguments.
+    /// Gets the callable value associated to key `name` from the object and asynchronously calls
+    /// it, passing the object itself along with `args` as function arguments.
     ///
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
@@ -185,16 +185,16 @@ pub trait ObjectLike: Sealed {
     where
         R: FromLuaMulti;
 
-    /// Gets the function associated to key `name` from the object and calls it,
+    /// Gets the callable value associated to key `name` from the object and calls it,
     /// passing `args` as function arguments.
     ///
     /// This might invoke the `__index` metamethod.
     fn call_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R>
     where
         R: FromLuaMulti;
 
-    /// Gets the function associated to key `name` from the object and asynchronously calls it,
-    /// passing `args` as function arguments.
+    /// Gets the callable value associated to key `name` from the object and asynchronously calls
+    /// it, passing `args` as function arguments.
     ///
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]

src/userdata/object.rs

@@ -63,6 +63,8 @@ impl ObjectLike for AnyUserData {
     {
         match self.get(name)? {
             Value::Function(func) => func.call(args),
+            Value::Table(table) => table.call(args),
+            Value::UserData(ud) => ud.call(args),
             val => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
                 Err(Error::RuntimeError(msg))
@@ -77,6 +79,8 @@ impl ObjectLike for AnyUserData {
     {
         match self.get(name) {
             Ok(Value::Function(func)) => func.call_async(args),
+            Ok(Value::Table(table)) => table.call_async(args),
+            Ok(Value::UserData(ud)) => ud.call_async(args),
             Ok(val) => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
                 AsyncCallFuture::error(Error::RuntimeError(msg))

tests/async.rs

@@ -411,6 +411,13 @@ async fn test_async_table_object_like() -> Result<()> {
     )?;
     table.set_metatable(Some(metatable))?;
     assert_eq!(table.call_async::<i64>(()).await.unwrap(), 15);
+    lua.globals().set("callable_table", &table)?;
+    assert_eq!(
+        lua.globals()
+            .call_async_function::<i64>("callable_table", ())
+            .await?,
+        15
+    );
 
     match table.call_async_method::<()>("non_existent", ()).await {
         Err(Error::RuntimeError(err)) => {
@@ -465,6 +472,10 @@ async fn test_async_userdata() -> Result<()> {
     struct MyUserdata(u64);
 
     impl UserData for MyUserdata {
+        fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
+            fields.add_field_method_get("callable_userdata", |_, this| Ok(MyUserdata(this.0)));
+        }
+
         fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
             methods.add_async_method("get_value", |_, data, ()| async move {
                 sleep_ms(10).await;
@@ -558,6 +569,13 @@ async fn test_async_userdata() -> Result<()> {
     let n: u64 = userdata.call_async_method("get_value", ()).await?;
     assert_eq!(n, 24);
     userdata.call_async_function::<()>("sleep", 15).await?;
+    #[cfg(not(any(feature = "lua51", feature = "luau")))]
+    assert_eq!(
+        userdata
+            .call_async_function::<String>("callable_userdata", ())
+            .await?,
+        "elapsed:24ms"
+    );
 
     #[cfg(not(any(feature = "lua51", feature = "luau")))]
     assert_eq!(userdata.call_async::<String>(()).await?, "elapsed:24ms");

tests/table.rs

@@ -702,6 +702,13 @@ fn test_table_object_like() -> Result<()> {
     assert_eq!(table.call_method::<String>("method", "a")?, "method_1");
     assert_eq!(table.to_string()?, "table object");
 
+    assert_eq!(lua.globals().call_function::<String>("table", "b")?, "call_2");
+    let callable = lua
+        .load("return setmetatable({}, {__call = function(_, receiver, key) return receiver[key] end})")
+        .eval::<Table>()?;
+    table.set("callable", callable)?;
+    assert_eq!(table.call_method::<i32>("callable", "a")?, 1);
+
     match table.call_method::<()>("non_existent", ()) {
         Err(Error::RuntimeError(err)) => {
             assert!(err.contains("attempt to call a nil value (function 'non_existent')"))
@@ -712,6 +719,11 @@ fn test_table_object_like() -> Result<()> {
     // Test calling non-callable table
     let table2 = lua.create_table()?;
     assert!(matches!(table2.call::<()>(()), Err(Error::RuntimeError(_))));
+    table.set("non_callable", table2)?;
+    assert!(matches!(
+        table.call_function::<()>("non_callable", ()),
+        Err(Error::RuntimeError(_))
+    ));
 
     Ok(())
 }

tests/userdata.rs

@@ -976,6 +976,7 @@ fn test_userdata_object_like() -> Result<()> {
 
     impl UserData for MyUserData {
         fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
+            fields.add_field_method_get("callable_userdata", |_, this| Ok(*this));
             fields.add_field_method_get("n", |_, this| Ok(this.0));
             fields.add_field_method_set("n", |_, this, val| {
                 this.0 = val;
@@ -1004,6 +1005,7 @@ fn test_userdata_object_like() -> Result<()> {
     }
 
     assert_eq!(ud.call::<LuaString>(())?, "called");
+    assert_eq!(ud.call_function::<String>("callable_userdata", ())?, "called");
 
     ud.call_method::<()>("add", 2)?;
     assert_eq!(ud.get::<u32>("n")?, 323);