clean some unsafe

Author: CppCXY

crates/luars/src/compiler/func_state.rs

@@ -1,6 +1,7 @@
+use crate::LuaProto;
 use crate::compiler::{ExpDesc, ExpKind, ExpUnion, statement};
+use crate::lua_vm::GlobalState;
 use crate::lua_vm::lua_limits::{MAX_SRC_LEN, MAXCCALLS, MAXUPVAL, MAXVARS};
-use crate::{LuaProto, LuaVM};
 use crate::{LuaValue, compiler::parser::LuaLexer};
 
 // Upvalue descriptor
@@ -22,7 +23,7 @@ pub struct FuncState<'a> {
     /// encapsulate the single unsafe dereference.
     prev: Option<*mut FuncState<'a>>,
     pub lexer: &'a mut LuaLexer<'a>,
-    pub vm: &'a mut LuaVM,
+    pub vm: &'a mut GlobalState,
     pub compiler_state: &'a mut CompilerState,
     pub block_cnt_id: Option<BlockCntId>,
     pub pc: usize,                     // next position to code (equivalent to pc)
@@ -188,7 +189,7 @@ pub struct VarDesc {
 impl<'a> FuncState<'a> {
     pub fn new(
         lexer: &'a mut LuaLexer<'a>,
-        vm: &'a mut LuaVM,
+        vm: &'a mut GlobalState,
         compiler_state: &'a mut CompilerState,
         is_vararg: bool,
         source_name: String,

crates/luars/src/compiler/mod.rs

@@ -11,10 +11,10 @@ mod parser; // Lexer/token provider
 mod statement; // Statement parsing (lparser.c)
 
 // Re-exports
-use crate::LuaVM;
 pub use crate::compiler::parser::LuaLanguageLevel;
 use crate::compiler::parser::{LuaLexer, LuaTokenKind, LuaTokenize, Reader, TokensizeConfig};
 use crate::lua_value::{LuaProto, UpvalueDesc};
+use crate::lua_vm::GlobalState;
 use crate::lua_vm::OpCode;
 pub use code::*;
 pub use expression::*;
@@ -23,13 +23,13 @@ pub use func_state::*;
 // Structures are now in separate files (func_state.rs, expression.rs)
 
 // Port of luaY_parser from lparser.c
-pub fn compile_code(source: &str, vm: &mut LuaVM) -> Result<LuaProto, String> {
+pub fn compile_code(source: &str, vm: &mut GlobalState) -> Result<LuaProto, String> {
     compile_code_with_name(source, vm, "@chunk")
 }
 
 pub fn compile_code_with_name(
     source: &str,
-    vm: &mut LuaVM,
+    vm: &mut GlobalState,
     chunk_name: &str,
 ) -> Result<LuaProto, String> {
     let level = vm.version;

crates/luars/src/gc/object_allocator.rs

@@ -276,9 +276,7 @@ impl ObjectAllocator {
         let mut gc_thread =
             GcObjectOwner::Thread(Box::new(GcThread::new(thread, current_white, size as u32)));
         let ptr = gc_thread.as_thread_ptr().unwrap();
-        unsafe {
-            gc_thread.as_thread_mut().unwrap().set_thread_ptr(ptr);
-        }
+        gc_thread.as_thread_mut().unwrap().set_thread_ptr(ptr);
 
         gc.trace_object(gc_thread)?;
         Ok(LuaValue::thread(ptr))

crates/luars/src/lib_registry.rs

@@ -4,7 +4,7 @@
 use crate::lua_api;
 use crate::lua_value::LuaValue;
 use crate::lua_vm::LuaState;
-use crate::lua_vm::{CFunction, LuaResult, LuaVM};
+use crate::lua_vm::{CFunction, GlobalState, LuaResult};
 use crate::stdlib::{self, Stdlib};
 // use crate::stdlib;
 
@@ -19,7 +19,7 @@ pub trait LuaLibrary {
 }
 
 /// Type for value initializers - functions that create values when the module loads
-pub type ValueInitializer = fn(&mut LuaVM) -> LuaResult<LuaValue>;
+pub type ValueInitializer = fn(&mut GlobalState) -> LuaResult<LuaValue>;
 
 /// Type for module initializers - functions that set up additional module fields
 pub type ModuleInitializer = fn(&mut LuaState) -> LuaResult<()>;
@@ -168,15 +168,15 @@ impl LibraryRegistry {
     }
 
     /// Load all registered libraries into a VM
-    pub fn load_all(&self, vm: &mut LuaVM) -> LuaResult<()> {
+    pub fn load_all(&self, vm: &mut GlobalState) -> LuaResult<()> {
         for module in &self.modules {
             self.load_module(vm, module)?;
         }
         Ok(())
     }
 
     /// Load a specific module into the VM
-    pub fn load_module(&self, vm: &mut LuaVM, module: &LibraryModule) -> LuaResult<()> {
+    pub fn load_module(&self, vm: &mut GlobalState, module: &LibraryModule) -> LuaResult<()> {
         load_library_module(vm, module)
     }
 
@@ -186,7 +186,7 @@ impl LibraryRegistry {
     }
 }
 
-fn load_library_module(vm: &mut LuaVM, module: &LibraryModule) -> LuaResult<()> {
+fn load_library_module(vm: &mut GlobalState, module: &LibraryModule) -> LuaResult<()> {
     // Create a table for the library
     let lib_table = vm.create_table(0, 0)?;
 

crates/luars/src/lua_api/lua.rs

@@ -16,7 +16,7 @@ use crate::{LuaError, LuaFullError};
 /// This type sits on top of `luars::LuaVM` and exposes a narrower API that
 /// avoids raw `LuaValue` plumbing in the common host-facing surface.
 pub struct Lua {
-    vm: Box<LuaVM>,
+    vm: LuaVM,
 }
 
 impl Lua {

crates/luars/src/lua_value/chunk_serializer.rs

@@ -4,7 +4,7 @@
 use super::{LocVar, LuaProto, LuaValue, UpvalueDesc};
 use crate::Instruction;
 use crate::gc::{GcProto, ObjectAllocator, ProtoPtr};
-use crate::lua_vm::LuaVM;
+use crate::lua_vm::GlobalState;
 use crate::lua_vm::lua_limits::LUAI_MAXSHORTLEN;
 use std::collections::HashMap;
 use std::io::{Cursor, Read};
@@ -95,7 +95,10 @@ pub fn deserialize_chunk(data: &[u8]) -> Result<LuaProto, String> {
 }
 
 /// Deserialize binary data to a Chunk, directly creating strings with VM
-pub fn deserialize_chunk_with_strings_vm(data: &[u8], vm: &mut LuaVM) -> Result<LuaProto, String> {
+pub fn deserialize_chunk_with_strings_vm(
+    data: &[u8],
+    vm: &mut GlobalState,
+) -> Result<LuaProto, String> {
     let mut cursor = Cursor::new(data);
 
     // Verify magic number
@@ -736,7 +739,10 @@ fn read_constant(cursor: &mut Cursor<&[u8]>) -> Result<LuaValue, String> {
 }
 
 #[allow(dead_code)]
-fn read_chunk_with_vm(cursor: &mut Cursor<&[u8]>, vm: &mut LuaVM) -> Result<LuaProto, String> {
+fn read_chunk_with_vm(
+    cursor: &mut Cursor<&[u8]>,
+    vm: &mut GlobalState,
+) -> Result<LuaProto, String> {
     // Read code
     let code_len = read_u32(cursor)? as usize;
     let mut code = Vec::with_capacity(code_len);
@@ -827,7 +833,10 @@ fn read_chunk_with_vm(cursor: &mut Cursor<&[u8]>, vm: &mut LuaVM) -> Result<LuaP
 }
 
 #[allow(dead_code)]
-fn read_constant_with_vm(cursor: &mut Cursor<&[u8]>, vm: &mut LuaVM) -> Result<LuaValue, String> {
+fn read_constant_with_vm(
+    cursor: &mut Cursor<&[u8]>,
+    vm: &mut GlobalState,
+) -> Result<LuaValue, String> {
     let tag = read_u8(cursor)?;
     match tag {
         TAG_NIL => Ok(LuaValue::nil()),
@@ -846,7 +855,7 @@ fn read_constant_with_vm(cursor: &mut Cursor<&[u8]>, vm: &mut LuaVM) -> Result<L
 
 fn read_chunk_with_vm_dedup(
     cursor: &mut Cursor<&[u8]>,
-    vm: &mut LuaVM,
+    vm: &mut GlobalState,
     string_table: &mut Vec<String>,
 ) -> Result<LuaProto, String> {
     // Read code
@@ -940,7 +949,7 @@ fn read_chunk_with_vm_dedup(
 
 fn read_constant_with_vm_dedup(
     cursor: &mut Cursor<&[u8]>,
-    vm: &mut LuaVM,
+    vm: &mut GlobalState,
     string_table: &mut Vec<String>,
 ) -> Result<LuaValue, String> {
     let tag = read_u8(cursor)?;