clean 100 unsafe

Author: CppCXY

crates/luars/src/compiler/code.rs

@@ -2126,7 +2126,7 @@ pub fn posfix(
                     BinaryOperator::OpBAnd => TmKind::Band, // TM_BAND
                     BinaryOperator::OpBOr => TmKind::Bor,   // TM_BOR
                     BinaryOperator::OpBXor => TmKind::Bxor, // TM_BXOR
-                    _ => TmKind::N,                         // Invalid for other ops
+                    _ => TmKind::None,                      // Invalid for other ops
                 };
                 // Use code_abck to include flip bit (k-flag) like in MMBINI
                 code_abck(
@@ -2193,7 +2193,7 @@ pub fn posfix(
                     BinaryOperator::OpBXor => TmKind::Bxor,
                     BinaryOperator::OpShl => TmKind::Shl,
                     BinaryOperator::OpShr => TmKind::Shr,
-                    _ => TmKind::N,
+                    _ => TmKind::None,
                 };
                 code_abc(fs, OpCode::MmBin, o1 as u32, o2 as u32, tm_event as u32);
                 fixline(fs, line);

crates/luars/src/gc/gc_kind.rs

@@ -11,3 +11,20 @@ pub enum GcObjectKind {
     Userdata = 7,
     Proto = 8,
 }
+
+impl GcObjectKind {
+    pub fn from_u8(value: u8) -> Option<Self> {
+        match value {
+            0 => Some(Self::String),
+            1 => Some(Self::Table),
+            2 => Some(Self::Function),
+            3 => Some(Self::CClosure),
+            4 => Some(Self::RClosure),
+            5 => Some(Self::Upvalue),
+            6 => Some(Self::Thread),
+            7 => Some(Self::Userdata),
+            8 => Some(Self::Proto),
+            _ => None,
+        }
+    }
+}

crates/luars/src/gc/gc_object.rs

@@ -539,7 +539,10 @@ impl GcObjectPtr {
     #[inline(always)]
     pub fn kind(&self) -> GcObjectKind {
         // Safety: tag values 0-8 match repr(u8) of GcObjectKind
-        unsafe { std::mem::transmute(self.tag()) }
+        match GcObjectKind::from_u8(self.tag()) {
+            Some(k) => k,
+            None => unreachable!(),
+        }
     }
 
     #[inline(always)]

crates/luars/src/gc/object_allocator.rs

@@ -71,6 +71,7 @@ impl ObjectAllocator {
         start: usize,
         end: usize,
     ) -> CreateResult {
+        // TODO: performance optimizations:
         let source_is_ascii = s_value.as_str().is_some_and(str::is_ascii);
         let Some(bytes) = s_value.as_bytes() else {
             return self.create_string(gc, "");

crates/luars/src/lib_registry.rs

@@ -48,7 +48,7 @@ impl PreloadModule {
 
 impl LuaLibrary for PreloadModule {
     fn install(&self, lua: &mut lua_api::Lua) -> LuaResult<()> {
-        let vm = unsafe { lua.vm_mut() };
+        let vm = lua.vm_mut();
         vm.register_preload(&self.name, self.loader)
     }
 }
@@ -91,7 +91,7 @@ impl LibraryModule {
 
 impl LuaLibrary for LibraryModule {
     fn install(&self, lua: &mut lua_api::Lua) -> LuaResult<()> {
-        let vm = unsafe { lua.vm_mut() };
+        let vm = lua.vm_mut();
         load_library_module(vm, self)
     }
 }

crates/luars/src/lua_api/lua.rs

@@ -459,7 +459,8 @@ impl Lua {
         &mut self,
         reference: &mut T,
     ) -> LuaResult<UserDataRef<T>> {
-        let value = unsafe { self.vm.main_state().create_userdata_ref(reference) }?;
+        let ud = unsafe { LuaUserdata::from_ref(reference) };
+        let value = self.vm.create_userdata(ud)?;
         self.value_to_userdata(value)
     }
 
@@ -584,7 +585,7 @@ impl Lua {
     ///
     /// The caller must preserve Lua VM invariants while holding the returned
     /// mutable reference and must not keep invalidated references across VM operations.
-    pub unsafe fn vm_mut(&mut self) -> &mut LuaVM {
+    pub fn vm_mut(&mut self) -> &mut LuaVM {
         &mut self.vm
     }
 }

crates/luars/src/lua_api/scope.rs

@@ -220,6 +220,15 @@ impl<T: UserDataTrait> ScopedBorrowedUserData<T> {
     fn alive(&self) -> bool {
         self.active.get()
     }
+
+    #[allow(clippy::mut_from_ref)]
+    fn mutate(&self) -> Option<&mut T> {
+        if self.alive() {
+            Some(unsafe { &mut *self.ptr })
+        } else {
+            None
+        }
+    }
 }
 
 impl<T: UserDataTrait> UserDataTrait for ScopedBorrowedUserData<T> {
@@ -232,129 +241,83 @@ impl<T: UserDataTrait> UserDataTrait for ScopedBorrowedUserData<T> {
     }
 
     fn get_field(&self, key: &str) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.get_field(key)
+        self.mutate()?.get_field(key)
     }
 
     fn set_field(&mut self, key: &str, value: UdValue) -> Option<Result<(), String>> {
         if !self.alive() {
             return Some(Err(scoped_expired_error().to_owned()));
         }
-        unsafe { &mut *self.ptr }.set_field(key, value)
+        self.mutate()?.set_field(key, value)
     }
 
     fn lua_tostring(&self) -> Option<String> {
-        if !self.alive() {
-            return Some(scoped_expired_error().to_owned());
-        }
-        unsafe { &*self.ptr }.lua_tostring()
+        self.mutate()?.lua_tostring()
     }
 
     fn lua_eq(&self, other: &dyn UserDataTrait) -> Option<bool> {
-        if !self.alive() {
-            return Some(false);
-        }
-        unsafe { &*self.ptr }.lua_eq(other)
+        self.mutate()?.lua_eq(other)
     }
 
     fn lua_lt(&self, other: &dyn UserDataTrait) -> Option<bool> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_lt(other)
+        self.mutate()?.lua_lt(other)
     }
 
     fn lua_le(&self, other: &dyn UserDataTrait) -> Option<bool> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_le(other)
+        self.mutate()?.lua_le(other)
     }
 
     fn lua_len(&self) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_len()
+        self.mutate()?.lua_len()
     }
 
     fn lua_unm(&self) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_unm()
+        self.mutate()?.lua_unm()
     }
 
     fn lua_add(&self, other: &UdValue) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_add(other)
+        self.mutate()?.lua_add(other)
     }
 
     fn lua_sub(&self, other: &UdValue) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_sub(other)
+        self.mutate()?.lua_sub(other)
     }
 
     fn lua_mul(&self, other: &UdValue) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_mul(other)
+        self.mutate()?.lua_mul(other)
     }
 
     fn lua_div(&self, other: &UdValue) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_div(other)
+        self.mutate()?.lua_div(other)
     }
 
     fn lua_mod(&self, other: &UdValue) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_mod(other)
+        self.mutate()?.lua_mod(other)
     }
 
     fn lua_concat(&self, other: &UdValue) -> Option<UdValue> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_concat(other)
+        self.mutate()?.lua_concat(other)
     }
 
     fn lua_call(&self) -> Option<crate::CFunction> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_call()
+        self.mutate()?.lua_call()
     }
 
     fn lua_next(&self, control: &UdValue) -> Option<(UdValue, UdValue)> {
-        if !self.alive() {
-            return None;
-        }
-        unsafe { &*self.ptr }.lua_next(control)
+        self.mutate()?.lua_next(control)
     }
 
     fn field_names(&self) -> &'static [&'static str] {
-        if !self.alive() {
-            return &[];
+        match self.mutate() {
+            Some(m) => m.field_names(),
+            None => &[],
         }
-        unsafe { &*self.ptr }.field_names()
     }
 
     fn as_any(&self) -> &dyn Any {
-        if self.alive() {
-            unsafe { &*self.ptr }.as_any()
-        } else {
-            self
+        match self.mutate() {
+            Some(m) => m.as_any(),
+            None => self,
         }
     }