Implement IntoLua for &Value

Author: khvzak

src/conversion.rs

@@ -33,6 +33,18 @@ impl<'lua> IntoLua<'lua> for Value<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &Value<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(self.clone())
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_value_ref(self)
+    }
+}
+
 impl<'lua> FromLua<'lua> for Value<'lua> {
     #[inline]
     fn from_lua(lua_value: Value<'lua>, _: &'lua Lua) -> Result<Self> {

src/lua.rs

@@ -2269,73 +2269,55 @@ impl Lua {
         extra.app_data.remove()
     }
 
+    /// Pushes a value that implements `IntoLua` onto the Lua stack.
+    ///
+    /// Uses 2 stack spaces, does not call checkstack.
     #[doc(hidden)]
     #[inline(always)]
     pub unsafe fn push<'lua>(&'lua self, value: impl IntoLua<'lua>) -> Result<()> {
         value.push_into_stack(self)
     }
 
-    /// Pushes a value onto the Lua stack.
+    /// Pushes a `Value` onto the Lua stack.
     ///
     /// Uses 2 stack spaces, does not call checkstack.
     #[doc(hidden)]
     pub unsafe fn push_value(&self, value: Value) -> Result<()> {
+        if let Value::Error(err) = value {
+            let protect = !self.unlikely_memory_error();
+            return push_gc_userdata(self.state(), WrappedFailure::Error(err), protect);
+        }
+        self.push_value_ref(&value)
+    }
+
+    /// Pushes a `&Value` (by reference) onto the Lua stack.
+    ///
+    /// Similar to [`Lua::push_value`], uses 2 stack spaces, does not call checkstack.
+    pub(crate) unsafe fn push_value_ref(&self, value: &Value) -> Result<()> {
         let state = self.state();
         match value {
-            Value::Nil => {
-                ffi::lua_pushnil(state);
-            }
-
-            Value::Boolean(b) => {
-                ffi::lua_pushboolean(state, b as c_int);
-            }
-
-            Value::LightUserData(ud) => {
-                ffi::lua_pushlightuserdata(state, ud.0);
-            }
-
-            Value::Integer(i) => {
-                ffi::lua_pushinteger(state, i);
-            }
-
-            Value::Number(n) => {
-                ffi::lua_pushnumber(state, n);
-            }
-
+            Value::Nil => ffi::lua_pushnil(state),
+            Value::Boolean(b) => ffi::lua_pushboolean(state, *b as c_int),
+            Value::LightUserData(ud) => ffi::lua_pushlightuserdata(state, ud.0),
+            Value::Integer(i) => ffi::lua_pushinteger(state, *i),
+            Value::Number(n) => ffi::lua_pushnumber(state, *n),
             #[cfg(feature = "luau")]
             Value::Vector(v) => {
                 #[cfg(not(feature = "luau-vector4"))]
                 ffi::lua_pushvector(state, v.x(), v.y(), v.z());
                 #[cfg(feature = "luau-vector4")]
                 ffi::lua_pushvector(state, v.x(), v.y(), v.z(), v.w());
             }
-
-            Value::String(s) => {
-                self.push_ref(&s.0);
-            }
-
-            Value::Table(t) => {
-                self.push_ref(&t.0);
-            }
-
-            Value::Function(f) => {
-                self.push_ref(&f.0);
-            }
-
-            Value::Thread(t) => {
-                self.push_ref(&t.0);
-            }
-
-            Value::UserData(ud) => {
-                self.push_ref(&ud.0);
-            }
-
+            Value::String(s) => self.push_ref(&s.0),
+            Value::Table(t) => self.push_ref(&t.0),
+            Value::Function(f) => self.push_ref(&f.0),
+            Value::Thread(t) => self.push_ref(&t.0),
+            Value::UserData(ud) => self.push_ref(&ud.0),
             Value::Error(err) => {
                 let protect = !self.unlikely_memory_error();
-                push_gc_userdata(state, WrappedFailure::Error(err), protect)?;
+                push_gc_userdata(state, WrappedFailure::Error(err.clone()), protect)?;
             }
         }
-
         Ok(())
     }
 

tests/conversion.rs

@@ -5,6 +5,23 @@ use std::ffi::{CStr, CString};
 use maplit::{btreemap, btreeset, hashmap, hashset};
 use mlua::{AnyUserData, Error, Function, IntoLua, Lua, Result, Table, Thread, UserDataRef, Value};
 
+#[test]
+fn test_value_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let v = Value::Boolean(true);
+    let v2 = (&v).into_lua(&lua)?;
+    assert_eq!(v, v2);
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("v", &v)?;
+    assert_eq!(v, table.get::<_, Value>("v")?);
+
+    Ok(())
+}
+
 #[test]
 fn test_string_into_lua() -> Result<()> {
     let lua = Lua::new();