Split single lua module to multiple submodules under state

Author: khvzak

src/chunk.rs

@@ -7,7 +7,7 @@ use std::string::String as StdString;
 
 use crate::error::{Error, ErrorContext, Result};
 use crate::function::Function;
-use crate::lua::{Lua, WeakLua};
+use crate::state::{Lua, WeakLua};
 use crate::table::Table;
 use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti};
 

src/conversion.rs

@@ -12,7 +12,7 @@ use num_traits::cast;
 
 use crate::error::{Error, Result};
 use crate::function::Function;
-use crate::lua::{Lua, LuaInner};
+use crate::state::{Lua, RawLua};
 use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
@@ -34,7 +34,7 @@ impl IntoLua for &Value {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         lua.push_value(self)
     }
 }
@@ -60,7 +60,7 @@ impl IntoLua for &String {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         lua.push_ref(&self.0);
         Ok(())
     }
@@ -93,7 +93,7 @@ impl IntoLua for &Table {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         lua.push_ref(&self.0);
         Ok(())
     }
@@ -127,7 +127,7 @@ impl IntoLua for &Function {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         lua.push_ref(&self.0);
         Ok(())
     }
@@ -161,7 +161,7 @@ impl IntoLua for &Thread {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         lua.push_ref(&self.0);
         Ok(())
     }
@@ -195,7 +195,7 @@ impl IntoLua for &AnyUserData {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         lua.push_ref(&self.0);
         Ok(())
     }
@@ -250,7 +250,7 @@ impl IntoLua for RegistryKey {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         <&RegistryKey>::push_into_stack(&self, lua)
     }
 }
@@ -261,7 +261,7 @@ impl IntoLua for &RegistryKey {
         lua.registry_value(self)
     }
 
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         if !lua.owns_registry_value(self) {
             return Err(Error::MismatchedRegistryKey);
         }
@@ -290,7 +290,7 @@ impl IntoLua for bool {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         ffi::lua_pushboolean(lua.state(), self as c_int);
         Ok(())
     }
@@ -307,7 +307,7 @@ impl FromLua for bool {
     }
 
     #[inline]
-    unsafe fn from_stack(idx: c_int, lua: &LuaInner) -> Result<Self> {
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
         Ok(ffi::lua_toboolean(lua.state(), idx) != 0)
     }
 }
@@ -363,7 +363,7 @@ impl IntoLua for StdString {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         push_bytes_into_stack(self, lua)
     }
 }
@@ -384,7 +384,7 @@ impl FromLua for StdString {
     }
 
     #[inline]
-    unsafe fn from_stack(idx: c_int, lua: &LuaInner) -> Result<Self> {
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
         let state = lua.state();
         if ffi::lua_type(state, idx) == ffi::LUA_TSTRING {
             let mut size = 0;
@@ -410,7 +410,7 @@ impl IntoLua for &str {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         push_bytes_into_stack(self, lua)
     }
 }
@@ -522,7 +522,7 @@ impl FromLua for BString {
         }
     }
 
-    unsafe fn from_stack(idx: c_int, lua: &LuaInner) -> Result<Self> {
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
         let state = lua.state();
         match ffi::lua_type(state, idx) {
             ffi::LUA_TSTRING => {
@@ -553,7 +553,7 @@ impl IntoLua for &BStr {
 }
 
 #[inline]
-unsafe fn push_bytes_into_stack<T>(this: T, lua: &LuaInner) -> Result<()>
+unsafe fn push_bytes_into_stack<T>(this: T, lua: &RawLua) -> Result<()>
 where
     T: IntoLua + AsRef<[u8]>,
 {
@@ -584,7 +584,7 @@ macro_rules! lua_convert_int {
             }
 
             #[inline]
-            unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+            unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
                 match cast(self) {
                     Some(i) => ffi::lua_pushinteger(lua.state(), i),
                     None => ffi::lua_pushnumber(lua.state(), self as ffi::lua_Number),
@@ -881,7 +881,7 @@ impl<T: IntoLua> IntoLua for Option<T> {
     }
 
     #[inline]
-    unsafe fn push_into_stack(self, lua: &LuaInner) -> Result<()> {
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
         match self {
             Some(val) => val.push_into_stack(lua)?,
             None => ffi::lua_pushnil(lua.state()),
@@ -900,7 +900,7 @@ impl<T: FromLua> FromLua for Option<T> {
     }
 
     #[inline]
-    unsafe fn from_stack(idx: c_int, lua: &LuaInner) -> Result<Self> {
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
         if ffi::lua_isnil(lua.state(), idx) != 0 {
             Ok(None)
         } else {

src/function.rs

@@ -5,7 +5,7 @@ use std::ptr;
 use std::slice;
 
 use crate::error::{Error, Result};
-use crate::lua::Lua;
+use crate::state::Lua;
 use crate::table::Table;
 use crate::types::{Callback, MaybeSend, ValueRef};
 use crate::util::{
@@ -161,11 +161,13 @@ impl Function {
         R: FromLuaMulti,
     {
         let lua = self.0.lua.lock();
-        let thread_res = lua.create_recycled_thread(self).map(|th| {
-            let mut th = th.into_async(args);
-            th.set_recyclable(true);
-            th
-        });
+        let thread_res = unsafe {
+            lua.create_recycled_thread(self).map(|th| {
+                let mut th = th.into_async(args);
+                th.set_recyclable(true);
+                th
+            })
+        };
         async move { thread_res?.await }
     }
 

src/hook.rs

@@ -1,14 +1,14 @@
 use std::borrow::Cow;
 use std::cell::UnsafeCell;
-use std::mem::ManuallyDrop;
+use std::ops::Deref;
 #[cfg(not(feature = "luau"))]
 use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::c_int;
 
 use ffi::lua_Debug;
 use parking_lot::ReentrantMutexGuard;
 
-use crate::lua::{Lua, LuaInner};
+use crate::state::RawLua;
 use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
 
 /// Contains information about currently executing Lua code.
@@ -20,38 +20,46 @@ use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
 ///
 /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
 /// [`Lua::set_hook`]: crate::Lua::set_hook
-pub struct Debug<'lua> {
-    lua: ManuallyDrop<ReentrantMutexGuard<'lua, LuaInner>>,
+pub struct Debug<'a> {
+    lua: EitherLua<'a>,
     ar: ActivationRecord,
     #[cfg(feature = "luau")]
     level: c_int,
 }
 
-impl<'lua> Drop for Debug<'lua> {
-    fn drop(&mut self) {
-        if let ActivationRecord::Owned(_) = self.ar {
-            unsafe { ManuallyDrop::drop(&mut self.lua) }
+enum EitherLua<'a> {
+    Owned(ReentrantMutexGuard<'a, RawLua>),
+    Borrowed(&'a RawLua),
+}
+
+impl Deref for EitherLua<'_> {
+    type Target = RawLua;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            EitherLua::Owned(guard) => &*guard,
+            EitherLua::Borrowed(lua) => lua,
         }
     }
 }
 
-impl<'lua> Debug<'lua> {
+impl<'a> Debug<'a> {
     // We assume the lock is held when this function is called.
     #[cfg(not(feature = "luau"))]
-    pub(crate) fn new(lua: &'lua Lua, ar: *mut lua_Debug) -> Self {
+    pub(crate) fn new(lua: &'a RawLua, ar: *mut lua_Debug) -> Self {
         Debug {
-            lua: unsafe { lua.guard_unchecked() },
+            lua: EitherLua::Borrowed(lua),
             ar: ActivationRecord::Borrowed(ar),
         }
     }
 
     pub(crate) fn new_owned(
-        guard: ReentrantMutexGuard<'lua, LuaInner>,
+        guard: ReentrantMutexGuard<'a, RawLua>,
         _level: c_int,
         ar: lua_Debug,
     ) -> Self {
         Debug {
-            lua: ManuallyDrop::new(guard),
+            lua: EitherLua::Owned(guard),
             ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
             #[cfg(feature = "luau")]
             level: _level,

src/lib.rs

@@ -84,12 +84,12 @@ mod conversion;
 mod error;
 mod function;
 mod hook;
-mod lua;
 #[cfg(feature = "luau")]
 mod luau;
 mod memory;
 mod multi;
 // mod scope;
+mod state;
 mod stdlib;
 mod string;
 mod table;
@@ -107,7 +107,7 @@ pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
 pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
 pub use crate::function::{Function, FunctionInfo};
 pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
-pub use crate::lua::{GCMode, Lua, LuaOptions};
+pub use crate::state::{GCMode, Lua, LuaOptions};
 pub use crate::multi::Variadic;
 // pub use crate::scope::Scope;
 pub use crate::stdlib::StdLib;