Check that type passed to scoped userdata self argument is userdata.

If passed type is non-userdata we try to get a pointer (which will be null) that triggers an assertion.
Having a check also allow us to generate right error message.
Fixes #569

Author: khvzak

src/userdata/registry.rs

@@ -14,7 +14,7 @@ use crate::userdata::{
     borrow_userdata_scoped, borrow_userdata_scoped_mut, AnyUserData, MetaMethod, TypeIdHints, UserData,
     UserDataFields, UserDataMethods, UserDataStorage,
 };
-use crate::util::{get_userdata, short_type_name};
+use crate::util::short_type_name;
 use crate::value::Value;
 
 #[cfg(feature = "async")]
@@ -143,16 +143,16 @@ impl<T> UserDataRegistry<T> {
                         method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
                     }))
                 }
-                #[rustfmt::skip]
-                UserDataType::Unique(target_ptr)
-                    if get_userdata::<UserDataStorage<T>>(state, self_index) as *mut c_void == target_ptr =>
-                {
+                UserDataType::Unique(target_ptr) if ffi::lua_touserdata(state, self_index) == target_ptr => {
                     let ud = target_ptr as *mut UserDataStorage<T>;
                     try_self_arg!((*ud).try_borrow_scoped(|ud| {
                         method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
                     }))
                 }
-                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
+                UserDataType::Unique(_) => {
+                    try_self_arg!(rawlua.get_userdata_type_id::<T>(state, self_index));
+                    Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch))
+                }
             }
         })
     }
@@ -192,16 +192,16 @@ impl<T> UserDataRegistry<T> {
                         method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
                     }))
                 }
-                #[rustfmt::skip]
-                UserDataType::Unique(target_ptr)
-                    if get_userdata::<UserDataStorage<T>>(state, self_index) as *mut c_void == target_ptr =>
-                {
+                UserDataType::Unique(target_ptr) if ffi::lua_touserdata(state, self_index) == target_ptr => {
                     let ud = target_ptr as *mut UserDataStorage<T>;
                     try_self_arg!((*ud).try_borrow_scoped_mut(|ud| {
                         method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
                     }))
                 }
-                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
+                UserDataType::Unique(_) => {
+                    try_self_arg!(rawlua.get_userdata_type_id::<T>(state, self_index));
+                    Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch))
+                }
             }
         })
     }

tests/scope.rs

@@ -276,6 +276,23 @@ fn test_scope_userdata_mismatch() -> Result<()> {
             Err(other) => panic!("wrong error type {other:?}"),
             Ok(_) => panic!("incorrectly returned Ok"),
         }
+
+        // Pass non-userdata type
+        let err = inc.call::<()>((&au, 321)).err().unwrap();
+        match err {
+            Error::CallbackError { ref cause, .. } => match cause.as_ref() {
+                Error::BadArgument { to, pos, name, cause } => {
+                    assert_eq!(to.as_deref(), Some("MyUserData.inc"));
+                    assert_eq!(*pos, 1);
+                    assert_eq!(name.as_deref(), Some("self"));
+                    assert!(matches!(*cause.as_ref(), Error::FromLuaConversionError { .. }));
+                }
+                other => panic!("wrong error type {other:?}"),
+            },
+            other => panic!("wrong error type {other:?}"),
+        }
+        let err_msg = "bad argument `self` to `MyUserData.inc`: error converting Lua number to userdata (expected userdata of type 'MyUserData')";
+        assert!(err.to_string().contains(err_msg));
         Ok(())
     })?;