Refactor userdata-wrappers feature.

Support borrowing underlying data in `UserDataRef` and `UserDataRefMut`.

Author: khvzak

src/state.rs

@@ -1330,7 +1330,7 @@ impl Lua {
     /// This methods provides a way to add fields or methods to userdata objects of a type `T`.
     pub fn register_userdata_type<T: 'static>(&self, f: impl FnOnce(&mut UserDataRegistry<T>)) -> Result<()> {
         let type_id = TypeId::of::<T>();
-        let mut registry = UserDataRegistry::new(self, type_id);
+        let mut registry = UserDataRegistry::new(self);
         f(&mut registry);
 
         let lua = self.lock();
@@ -1499,7 +1499,6 @@ impl Lua {
         &self,
         f: impl for<'scope> FnOnce(&'scope Scope<'scope, 'env>) -> Result<R>,
     ) -> Result<R> {
-        // TODO: Update to `&Scope` in next major release
         f(&Scope::new(self.lock_arc()))
     }
 

src/state/raw.rs

@@ -864,7 +864,7 @@ impl RawLua {
             }
 
             // Create a new metatable from `UserData` definition
-            let mut registry = UserDataRegistry::new(self.lua(), type_id);
+            let mut registry = UserDataRegistry::new(self.lua());
             T::register(&mut registry);
 
             self.create_userdata_metatable(registry.into_raw())
@@ -885,7 +885,7 @@ impl RawLua {
             // Check if metatable creation is pending or create an empty metatable otherwise
             let registry = match (*self.extra.get()).pending_userdata_reg.remove(&type_id) {
                 Some(registry) => registry,
-                None => UserDataRegistry::<T>::new(self.lua(), type_id).into_raw(),
+                None => UserDataRegistry::<T>::new(self.lua()).into_raw(),
             };
             self.create_userdata_metatable(registry)
         })
@@ -1103,17 +1103,22 @@ impl RawLua {
     // Returns `TypeId` for the userdata ref, checking that it's registered and not destructed.
     //
     // Returns `None` if the userdata is registered but non-static.
-    pub(crate) unsafe fn get_userdata_ref_type_id(&self, vref: &ValueRef) -> Result<Option<TypeId>> {
-        self.get_userdata_type_id_inner(self.ref_thread(), vref.index)
+    #[inline(always)]
+    pub(crate) fn get_userdata_ref_type_id(&self, vref: &ValueRef) -> Result<Option<TypeId>> {
+        unsafe { self.get_userdata_type_id_inner(self.ref_thread(), vref.index) }
     }
 
     // Same as `get_userdata_ref_type_id` but assumes the userdata is already on the stack.
-    pub(crate) unsafe fn get_userdata_type_id<T>(&self, idx: c_int) -> Result<Option<TypeId>> {
-        match self.get_userdata_type_id_inner(self.state(), idx) {
+    pub(crate) unsafe fn get_userdata_type_id<T>(
+        &self,
+        state: *mut ffi::lua_State,
+        idx: c_int,
+    ) -> Result<Option<TypeId>> {
+        match self.get_userdata_type_id_inner(state, idx) {
             Ok(type_id) => Ok(type_id),
-            Err(Error::UserDataTypeMismatch) if ffi::lua_type(self.state(), idx) != ffi::LUA_TUSERDATA => {
+            Err(Error::UserDataTypeMismatch) if ffi::lua_type(state, idx) != ffi::LUA_TUSERDATA => {
                 // Report `FromLuaConversionError` instead
-                let idx_type_name = CStr::from_ptr(ffi::luaL_typename(self.state(), idx));
+                let idx_type_name = CStr::from_ptr(ffi::luaL_typename(state, idx));
                 let idx_type_name = idx_type_name.to_str().unwrap();
                 let message = format!("expected userdata of type '{}'", short_type_name::<T>());
                 Err(Error::from_lua_conversion(idx_type_name, "userdata", message))

src/userdata.rs

@@ -12,7 +12,10 @@ use crate::string::String;
 use crate::table::{Table, TablePairs};
 use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
 use crate::types::{MaybeSend, ValueRef};
-use crate::util::{check_stack, get_userdata, push_string, take_userdata, StackGuard};
+use crate::util::{
+    borrow_userdata_scoped, borrow_userdata_scoped_mut, check_stack, get_userdata, push_string,
+    take_userdata, StackGuard, TypeIdHints,
+};
 use crate::value::Value;
 
 #[cfg(feature = "async")]
@@ -26,7 +29,7 @@ use {
 
 // Re-export for convenience
 pub(crate) use cell::UserDataStorage;
-pub use cell::{UserDataRef, UserDataRefMut};
+pub use r#ref::{UserDataRef, UserDataRefMut};
 pub use registry::UserDataRegistry;
 pub(crate) use registry::{RawUserDataRegistry, UserDataProxy};
 
@@ -622,7 +625,10 @@ impl AnyUserData {
     /// Checks whether the type of this userdata is `T`.
     #[inline]
     pub fn is<T: 'static>(&self) -> bool {
-        self.inspect::<T, _, _>(|_| Ok(())).is_ok()
+        let lua = self.0.lua.lock();
+        let type_id = lua.get_userdata_ref_type_id(&self.0);
+        // We do not use wrapped types here, rather prefer to check the "real" type of the userdata
+        matches!(type_id, Ok(Some(type_id)) if type_id == TypeId::of::<T>())
     }
 
     /// Borrow this userdata immutably if it is of type `T`.
@@ -637,15 +643,19 @@ impl AnyUserData {
     /// [`DataTypeMismatch`]: crate::Error::UserDataTypeMismatch
     #[inline]
     pub fn borrow<T: 'static>(&self) -> Result<UserDataRef<T>> {
-        self.inspect(|ud| ud.try_borrow_owned())
+        let lua = self.0.lua.lock();
+        unsafe { UserDataRef::borrow_from_stack(&lua, lua.ref_thread(), self.0.index) }
     }
 
     /// Borrow this userdata immutably if it is of type `T`, passing the borrowed value
     /// to the closure.
     ///
     /// This method is the only way to borrow scoped userdata (created inside [`Lua::scope`]).
     pub fn borrow_scoped<T: 'static, R>(&self, f: impl FnOnce(&T) -> R) -> Result<R> {
-        self.inspect(|ud| ud.try_borrow_scoped(|ud| f(ud)))
+        let lua = self.0.lua.lock();
+        let type_id = lua.get_userdata_ref_type_id(&self.0)?;
+        let type_hints = TypeIdHints::new::<T>();
+        unsafe { borrow_userdata_scoped(lua.ref_thread(), self.0.index, type_id, type_hints, f) }
     }
 
     /// Borrow this userdata mutably if it is of type `T`.
@@ -660,15 +670,19 @@ impl AnyUserData {
     /// [`UserDataTypeMismatch`]: crate::Error::UserDataTypeMismatch
     #[inline]
     pub fn borrow_mut<T: 'static>(&self) -> Result<UserDataRefMut<T>> {
-        self.inspect(|ud| ud.try_borrow_owned_mut())
+        let lua = self.0.lua.lock();
+        unsafe { UserDataRefMut::borrow_from_stack(&lua, lua.ref_thread(), self.0.index) }
     }
 
     /// Borrow this userdata mutably if it is of type `T`, passing the borrowed value
     /// to the closure.
     ///
     /// This method is the only way to borrow scoped userdata (created inside [`Lua::scope`]).
     pub fn borrow_mut_scoped<T: 'static, R>(&self, f: impl FnOnce(&mut T) -> R) -> Result<R> {
-        self.inspect(|ud| ud.try_borrow_scoped_mut(|ud| f(ud)))
+        let lua = self.0.lua.lock();
+        let type_id = lua.get_userdata_ref_type_id(&self.0)?;
+        let type_hints = TypeIdHints::new::<T>();
+        unsafe { borrow_userdata_scoped_mut(lua.ref_thread(), self.0.index, type_id, type_hints, f) }
     }
 
     /// Takes the value out of this userdata.
@@ -687,9 +701,11 @@ impl AnyUserData {
             let type_id = lua.push_userdata_ref(&self.0)?;
             match type_id {
                 Some(type_id) if type_id == TypeId::of::<T>() => {
-                    // Try to borrow userdata exclusively
-                    let _ = (*get_userdata::<UserDataStorage<T>>(state, -1)).try_borrow_mut()?;
-                    take_userdata::<UserDataStorage<T>>(state).into_inner()
+                    if (*get_userdata::<UserDataStorage<T>>(state, -1)).has_exclusive_access() {
+                        take_userdata::<UserDataStorage<T>>(state).into_inner()
+                    } else {
+                        Err(Error::UserDataBorrowMutError)
+                    }
                 }
                 _ => Err(Error::UserDataTypeMismatch),
             }
@@ -965,24 +981,6 @@ impl AnyUserData {
         };
         is_serializable().unwrap_or(false)
     }
-
-    pub(crate) fn inspect<T, F, R>(&self, func: F) -> Result<R>
-    where
-        T: 'static,
-        F: FnOnce(&UserDataStorage<T>) -> Result<R>,
-    {
-        let lua = self.0.lua.lock();
-        unsafe {
-            let type_id = lua.get_userdata_ref_type_id(&self.0)?;
-            match type_id {
-                Some(type_id) if type_id == TypeId::of::<T>() => {
-                    let ud = get_userdata::<UserDataStorage<T>>(lua.ref_thread(), self.0.index);
-                    func(&*ud)
-                }
-                _ => Err(Error::UserDataTypeMismatch),
-            }
-        }
-    }
 }
 
 /// Handle to a [`AnyUserData`] metatable.
@@ -1106,6 +1104,7 @@ where
 mod cell;
 mod lock;
 mod object;
+mod r#ref;
 mod registry;
 mod util;