Rename ToLua/ToLuaMulti -> IntoLua/IntoLuaMulti

15 files changed, 304 insertions, 304 deletions

diff --git a/src/chunk.rs b/src/chunk.rs
index 0315ef9..c142db4 100644
--- a/src/chunk.rs
+++ b/src/chunk.rs
@@ -9,7 +9,7 @@ use crate::error::{Error, Result};
 use crate::ffi;
 use crate::function::Function;
 use crate::lua::Lua;
-use crate::value::{FromLuaMulti, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -266,8 +266,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// All global variables (including the standard library!) are looked up in `_ENV`, so it may be
     /// necessary to populate the environment in order for scripts using custom environments to be
     /// useful.
-    pub fn set_environment<V: ToLua<'lua>>(mut self, env: V) -> Self {
-        self.env = env.to_lua(self.lua);
+    pub fn set_environment<V: IntoLua<'lua>>(mut self, env: V) -> Self {
+        self.env = env.into_lua(self.lua);
         self
     }
 
@@ -358,7 +358,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Load the chunk function and call it with the given arguments.
     ///
     /// This is equivalent to `into_function` and calling the resulting function.
-    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
+    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
         self.into_function()?.call(args)
     }
 
@@ -374,7 +374,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     pub fn call_async<'fut, A, R>(self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         match self.into_function() {
diff --git a/src/conversion.rs b/src/conversion.rs
index e5e1cf6..fc0a544 100644
--- a/src/conversion.rs
+++ b/src/conversion.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::convert::TryInto;
@@ -18,14 +16,14 @@ use crate::table::Table;
 use crate::thread::Thread;
 use crate::types::{LightUserData, MaybeSend};
 use crate::userdata::{AnyUserData, UserData};
-use crate::value::{FromLua, Nil, ToLua, Value};
+use crate::value::{FromLua, IntoLua, Nil, Value};
 
 #[cfg(feature = "unstable")]
 use crate::{function::OwnedFunction, table::OwnedTable, userdata::OwnedAnyUserData};
 
-impl<'lua> ToLua<'lua> for Value<'lua> {
+impl<'lua> IntoLua<'lua> for Value<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(self)
     }
 }
@@ -37,9 +35,9 @@ impl<'lua> FromLua<'lua> for Value<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for String<'lua> {
+impl<'lua> IntoLua<'lua> for String<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(self))
     }
 }
@@ -57,9 +55,9 @@ impl<'lua> FromLua<'lua> for String<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for Table<'lua> {
+impl<'lua> IntoLua<'lua> for Table<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(self))
     }
 }
@@ -79,9 +77,9 @@ impl<'lua> FromLua<'lua> for Table<'lua> {
 }
 
 #[cfg(feature = "unstable")]
-impl<'lua> ToLua<'lua> for OwnedTable {
+impl<'lua> IntoLua<'lua> for OwnedTable {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(Table(lua.adopt_owned_ref(self.0))))
     }
 }
@@ -94,9 +92,9 @@ impl<'lua> FromLua<'lua> for OwnedTable {
     }
 }
 
-impl<'lua> ToLua<'lua> for Function<'lua> {
+impl<'lua> IntoLua<'lua> for Function<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Function(self))
     }
 }
@@ -116,9 +114,9 @@ impl<'lua> FromLua<'lua> for Function<'lua> {
 }
 
 #[cfg(feature = "unstable")]
-impl<'lua> ToLua<'lua> for OwnedFunction {
+impl<'lua> IntoLua<'lua> for OwnedFunction {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Function(Function(lua.adopt_owned_ref(self.0))))
     }
 }
@@ -131,9 +129,9 @@ impl<'lua> FromLua<'lua> for OwnedFunction {
     }
 }
 
-impl<'lua> ToLua<'lua> for Thread<'lua> {
+impl<'lua> IntoLua<'lua> for Thread<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Thread(self))
     }
 }
@@ -152,9 +150,9 @@ impl<'lua> FromLua<'lua> for Thread<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for AnyUserData<'lua> {
+impl<'lua> IntoLua<'lua> for AnyUserData<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::UserData(self))
     }
 }
@@ -174,9 +172,9 @@ impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
 }
 
 #[cfg(feature = "unstable")]
-impl<'lua> ToLua<'lua> for OwnedAnyUserData {
+impl<'lua> IntoLua<'lua> for OwnedAnyUserData {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::UserData(AnyUserData(lua.adopt_owned_ref(self.0))))
     }
 }
@@ -189,9 +187,9 @@ impl<'lua> FromLua<'lua> for OwnedAnyUserData {
     }
 }
 
-impl<'lua, T: 'static + MaybeSend + UserData> ToLua<'lua> for T {
+impl<'lua, T: 'static + MaybeSend + UserData> IntoLua<'lua> for T {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::UserData(lua.create_userdata(self)?))
     }
 }
@@ -211,9 +209,9 @@ impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
     }
 }
 
-impl<'lua> ToLua<'lua> for Error {
+impl<'lua> IntoLua<'lua> for Error {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Error(self))
     }
 }
@@ -232,9 +230,9 @@ impl<'lua> FromLua<'lua> for Error {
     }
 }
 
-impl<'lua> ToLua<'lua> for bool {
+impl<'lua> IntoLua<'lua> for bool {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Boolean(self))
     }
 }
@@ -250,9 +248,9 @@ impl<'lua> FromLua<'lua> for bool {
     }
 }
 
-impl<'lua> ToLua<'lua> for LightUserData {
+impl<'lua> IntoLua<'lua> for LightUserData {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::LightUserData(self))
     }
 }
@@ -271,9 +269,9 @@ impl<'lua> FromLua<'lua> for LightUserData {
     }
 }
 
-impl<'lua> ToLua<'lua> for StdString {
+impl<'lua> IntoLua<'lua> for StdString {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&self)?))
     }
 }
@@ -294,23 +292,23 @@ impl<'lua> FromLua<'lua> for StdString {
     }
 }
 
-impl<'lua> ToLua<'lua> for &str {
+impl<'lua> IntoLua<'lua> for &str {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self)?))
     }
 }
 
-impl<'lua> ToLua<'lua> for Cow<'_, str> {
+impl<'lua> IntoLua<'lua> for Cow<'_, str> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.as_bytes())?))
     }
 }
 
-impl<'lua> ToLua<'lua> for Box<str> {
+impl<'lua> IntoLua<'lua> for Box<str> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&*self)?))
     }
 }
@@ -332,9 +330,9 @@ impl<'lua> FromLua<'lua> for Box<str> {
     }
 }
 
-impl<'lua> ToLua<'lua> for CString {
+impl<'lua> IntoLua<'lua> for CString {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.as_bytes())?))
     }
 }
@@ -362,23 +360,23 @@ impl<'lua> FromLua<'lua> for CString {
     }
 }
 
-impl<'lua> ToLua<'lua> for &CStr {
+impl<'lua> IntoLua<'lua> for &CStr {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.to_bytes())?))
     }
 }
 
-impl<'lua> ToLua<'lua> for Cow<'_, CStr> {
+impl<'lua> IntoLua<'lua> for Cow<'_, CStr> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.to_bytes())?))
     }
 }
 
-impl<'lua> ToLua<'lua> for BString {
+impl<'lua> IntoLua<'lua> for BString {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&self)?))
     }
 }
@@ -400,18 +398,18 @@ impl<'lua> FromLua<'lua> for BString {
     }
 }
 
-impl<'lua> ToLua<'lua> for &BStr {
+impl<'lua> IntoLua<'lua> for &BStr {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self)?))
     }
 }
 
 macro_rules! lua_convert_int {
     ($x:ty) => {
-        impl<'lua> ToLua<'lua> for $x {
+        impl<'lua> IntoLua<'lua> for $x {
             #[inline]
-            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+            fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
                 cast(self)
                     .map(Value::Integer)
                     .or_else(|| cast(self).map(Value::Number))
@@ -472,9 +470,9 @@ lua_convert_int!(usize);
 
 macro_rules! lua_convert_float {
     ($x:ty) => {
-        impl<'lua> ToLua<'lua> for $x {
+        impl<'lua> IntoLua<'lua> for $x {
             #[inline]
-            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+            fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
                 cast(self)
                     .ok_or_else(|| Error::ToLuaConversionError {
                         from: stringify!($x),
@@ -510,24 +508,24 @@ macro_rules! lua_convert_float {
 lua_convert_float!(f32);
 lua_convert_float!(f64);
 
-impl<'lua, T> ToLua<'lua> for &[T]
+impl<'lua, T> IntoLua<'lua> for &[T]
 where
-    T: Clone + ToLua<'lua>,
+    T: Clone + IntoLua<'lua>,
 {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(
             lua.create_sequence_from(self.iter().cloned())?,
         ))
     }
 }
 
-impl<'lua, T, const N: usize> ToLua<'lua> for [T; N]
+impl<'lua, T, const N: usize> IntoLua<'lua> for [T; N]
 where
-    T: ToLua<'lua>,
+    T: IntoLua<'lua>,
 {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self)?))
     }
 }
@@ -568,9 +566,9 @@ where
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
+impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Box<[T]> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self.into_vec())?))
     }
 }
@@ -582,9 +580,9 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Box<[T]> {
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
+impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Vec<T> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self)?))
     }
 }
@@ -609,11 +607,11 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
     }
 }
 
-impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>, S: BuildHasher> ToLua<'lua>
+impl<'lua, K: Eq + Hash + IntoLua<'lua>, V: IntoLua<'lua>, S: BuildHasher> IntoLua<'lua>
     for HashMap<K, V, S>
 {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(self)?))
     }
 }
@@ -635,9 +633,9 @@ impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Defa
     }
 }
 
-impl<'lua, K: Ord + ToLua<'lua>, V: ToLua<'lua>> ToLua<'lua> for BTreeMap<K, V> {
+impl<'lua, K: Ord + IntoLua<'lua>, V: IntoLua<'lua>> IntoLua<'lua> for BTreeMap<K, V> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(self)?))
     }
 }
@@ -657,9 +655,9 @@ impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<
     }
 }
 
-impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T, S> {
+impl<'lua, T: Eq + Hash + IntoLua<'lua>, S: BuildHasher> IntoLua<'lua> for HashSet<T, S> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(
             self.into_iter().map(|val| (val, true)),
         )?))
@@ -684,9 +682,9 @@ impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
     }
 }
 
-impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {
+impl<'lua, T: Ord + IntoLua<'lua>> IntoLua<'lua> for BTreeSet<T> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(
             self.into_iter().map(|val| (val, true)),
         )?))
@@ -711,11 +709,11 @@ impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
+impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Option<T> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         match self {
-            Some(val) => val.to_lua(lua),
+            Some(val) => val.into_lua(lua),
             None => Ok(Nil),
         }
     }
diff --git a/src/error.rs b/src/error.rs
index e50a2b2..e21960d 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
diff --git a/src/function.rs b/src/function.rs
index 0754982..d282a50 100644
--- a/src/function.rs
+++ b/src/function.rs
@@ -9,7 +9,7 @@ use crate::types::LuaRef;
 use crate::util::{
     assert_stack, check_stack, error_traceback, pop_error, ptr_to_cstr_bytes, StackGuard,
 };
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::value::{FromLuaMulti, IntoLuaMulti};
 
 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -96,11 +96,11 @@ impl<'lua> Function<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
+    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
         let lua = self.0.lua;
         let state = lua.state();
 
-        let mut args = args.to_lua_multi(lua)?;
+        let mut args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
         let results = unsafe {
@@ -163,7 +163,7 @@ impl<'lua> Function<'lua> {
     pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         let lua = self.0.lua;
@@ -204,7 +204,7 @@ impl<'lua> Function<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
+    pub fn bind<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
         unsafe extern "C" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
             let nargs = ffi::lua_gettop(state);
             let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(1)) as c_int;
@@ -223,7 +223,7 @@ impl<'lua> Function<'lua> {
         let lua = self.0.lua;
         let state = lua.state();
 
-        let args = args.to_lua_multi(lua)?;
+        let args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
         if nargs == 0 {
diff --git a/src/lib.rs b/src/lib.rs
index de72331..1a5ea36 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,10 +10,10 @@
 //!
 //! # Converting data
 //!
-//! The [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice
+//! The [`IntoLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice
 //! versa. They are implemented for many data structures found in Rust's standard library.
 //!
-//! For more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting
+//! For more general conversions, the [`IntoLuaMulti`] and [`FromLuaMulti`] traits allow converting
 //! between Rust types and *any number* of Lua values.
 //!
 //! Most code in `mlua` is generic over implementors of those traits, so in most places the normal
@@ -54,9 +54,9 @@
 //! [executing]: crate::Chunk::exec
 //! [evaluating]: crate::Chunk::eval
 //! [globals]: crate::Lua::globals
-//! [`ToLua`]: crate::ToLua
+//! [`IntoLua`]: crate::IntoLua
 //! [`FromLua`]: crate::FromLua
-//! [`ToLuaMulti`]: crate::ToLuaMulti
+//! [`IntoLuaMulti`]: crate::IntoLuaMulti
 //! [`FromLuaMulti`]: crate::FromLuaMulti
 //! [`Function`]: crate::Function
 //! [`UserData`]: crate::UserData
@@ -121,7 +121,7 @@ pub use crate::types::{Integer, LightUserData, Number, RegistryKey};
 pub use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
 };
-pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
+pub use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};
 
 #[cfg(not(feature = "luau"))]
 pub use crate::hook::HookTriggers;
@@ -157,7 +157,7 @@ pub use crate::{function::OwnedFunction, table::OwnedTable};
 /// This macro allows to write Lua code directly in Rust code.
 ///
 /// Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
-/// User's Rust types needs to implement [`UserData`] or [`ToLua`] traits.
+/// User's Rust types needs to implement [`UserData`] or [`IntoLua`] traits.
 ///
 /// Captured variables are **moved** into the chunk.
 ///
@@ -203,7 +203,7 @@ pub use crate::{function::OwnedFunction, table::OwnedTable};
 ///
 /// [`AsChunk`]: crate::AsChunk
 /// [`UserData`]: crate::UserData
-/// [`ToLua`]: crate::ToLua
+/// [`IntoLua`]: crate::IntoLua
 #[cfg(any(feature = "macros"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
diff --git a/src/lua.rs b/src/lua.rs
index ea0ac53..5acab41 100644
--- a/src/lua.rs
+++ b/src/lua.rs
@@ -37,7 +37,7 @@ use crate::util::{
     init_gc_metatable, init_userdata_metatable, pop_error, push_gc_userdata, push_string,
     push_table, rawset_field, safe_pcall, safe_xpcall, StackGuard, WrappedFailure,
 };
-use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};
 
 #[cfg(not(feature = "lua54"))]
 use crate::util::push_userdata;
@@ -785,7 +785,7 @@ impl Lua {
     pub unsafe fn entrypoint<'lua, A, R, F>(self, func: F) -> Result<c_int>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
         let entrypoint_inner = |lua: &'lua Lua, func: F| {
@@ -802,7 +802,7 @@ impl Lua {
             // We create callback rather than call `func` directly to catch errors
             // with attached stacktrace.
             let callback = lua.create_callback(Box::new(move |lua, args| {
-                func(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                func(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             }))?;
             callback.call(args)
         };
@@ -827,7 +827,7 @@ impl Lua {
     #[cfg(not(tarpaulin_include))]
     pub unsafe fn entrypoint1<'lua, R, F>(self, func: F) -> Result<c_int>
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
     {
         self.entrypoint(move |lua, _: ()| func(lua))
@@ -1446,8 +1446,8 @@ impl Lua {
     /// Creates a table and fills it with values from an iterator.
     pub fn create_table_from<'lua, K, V, I>(&'lua self, iter: I) -> Result<Table<'lua>>
     where
-        K: ToLua<'lua>,
-        V: ToLua<'lua>,
+        K: IntoLua<'lua>,
+        V: IntoLua<'lua>,
         I: IntoIterator<Item = (K, V)>,
     {
         let state = self.state();
@@ -1460,8 +1460,8 @@ impl Lua {
             let protect = !self.unlikely_memory_error();
             push_table(state, 0, lower_bound as c_int, protect)?;
             for (k, v) in iter {
-                self.push_value(k.to_lua(self)?)?;
-                self.push_value(v.to_lua(self)?)?;
+                self.push_value(k.into_lua(self)?)?;
+                self.push_value(v.into_lua(self)?)?;
                 if protect {
                     protect_lua!(state, 3, 1, fn(state) ffi::lua_rawset(state, -3))?;
                 } else {
@@ -1476,7 +1476,7 @@ impl Lua {
     /// Creates a table from an iterator of values, using `1..` as the keys.
     pub fn create_sequence_from<'lua, T, I>(&'lua self, iter: I) -> Result<Table<'lua>>
     where
-        T: ToLua<'lua>,
+        T: IntoLua<'lua>,
         I: IntoIterator<Item = T>,
     {
         let state = self.state();
@@ -1489,7 +1489,7 @@ impl Lua {
             let protect = !self.unlikely_memory_error();
             push_table(state, lower_bound as c_int, 0, protect)?;
             for (i, v) in iter.enumerate() {
-                self.push_value(v.to_lua(self)?)?;
+                self.push_value(v.into_lua(self)?)?;
                 if protect {
                     protect_lua!(state, 2, 1, |state| {
                         ffi::lua_rawseti(state, -2, (i + 1) as Integer);
@@ -1511,7 +1511,7 @@ impl Lua {
     /// intermediate Lua code.
     ///
     /// If the function returns `Ok`, the contained value will be converted to one or more Lua
-    /// values. For details on Rust-to-Lua conversions, refer to the [`ToLua`] and [`ToLuaMulti`]
+    /// values. For details on Rust-to-Lua conversions, refer to the [`IntoLua`] and [`IntoLuaMulti`]
     /// traits.
     ///
     /// # Examples
@@ -1546,16 +1546,16 @@ impl Lua {
     /// # }
     /// ```
     ///
-    /// [`ToLua`]: crate::ToLua
-    /// [`ToLuaMulti`]: crate::ToLuaMulti
+    /// [`IntoLua`]: crate::IntoLua
+    /// [`IntoLuaMulti`]: crate::IntoLuaMulti
     pub fn create_function<'lua, A, R, F>(&'lua self, func: F) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
         self.create_callback(Box::new(move |lua, args| {
-            func(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+            func(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
         }))
     }
 
@@ -1568,7 +1568,7 @@ impl Lua {
     pub fn create_function_mut<'lua, A, R, F>(&'lua self, func: F) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
     {
         let func = RefCell::new(func);
@@ -1635,7 +1635,7 @@ impl Lua {
     pub fn create_async_function<'lua, A, R, F, FR>(&'lua self, func: F) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>,
     {
@@ -1644,7 +1644,7 @@ impl Lua {
                 Ok(args) => args,
                 Err(e) => return Box::pin(future::err(e)),
             };
-            Box::pin(func(lua, args).and_then(move |ret| future::ready(ret.to_lua_multi(lua))))
+            Box::pin(func(lua, args).and_then(move |ret| future::ready(ret.into_lua_multi(lua))))
         }))
     }
 
@@ -1954,9 +1954,9 @@ impl Lua {
         })
     }
 
-    /// Converts a value that implements `ToLua` into a `Value` instance.
-    pub fn pack<'lua, T: ToLua<'lua>>(&'lua self, t: T) -> Result<Value<'lua>> {
-        t.to_lua(self)
+    /// Converts a value that implements `IntoLua` into a `Value` instance.
+    pub fn pack<'lua, T: IntoLua<'lua>>(&'lua self, t: T) -> Result<Value<'lua>> {
+        t.into_lua(self)
     }
 
     /// Converts a `Value` instance into a value that implements `FromLua`.
@@ -1964,9 +1964,9 @@ impl Lua {
         T::from_lua(value, self)
     }
 
-    /// Converts a value that implements `ToLuaMulti` into a `MultiValue` instance.
-    pub fn pack_multi<'lua, T: ToLuaMulti<'lua>>(&'lua self, t: T) -> Result<MultiValue<'lua>> {
-        t.to_lua_multi(self)
+    /// Converts a value that implements `IntoLuaMulti` into a `MultiValue` instance.
+    pub fn pack_multi<'lua, T: IntoLuaMulti<'lua>>(&'lua self, t: T) -> Result<MultiValue<'lua>> {
+        t.into_lua_multi(self)
     }
 
     /// Converts a `MultiValue` instance into a value that implements `FromLuaMulti`.
@@ -1983,10 +1983,10 @@ impl Lua {
     /// state.
     pub fn set_named_registry_value<'lua, T>(&'lua self, name: &str, t: T) -> Result<()>
     where
-        T: ToLua<'lua>,
+        T: IntoLua<'lua>,
     {
         let state = self.state();
-        let t = t.to_lua(self)?;
+        let t = t.into_lua(self)?;
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 5)?;
@@ -2039,8 +2039,8 @@ impl Lua {
     /// However, dropped [`RegistryKey`]s automatically reused to store new values.
     ///
     /// [`RegistryKey`]: crate::RegistryKey
-    pub fn create_registry_value<'lua, T: ToLua<'lua>>(&'lua self, t: T) -> Result<RegistryKey> {
-        let t = t.to_lua(self)?;
+    pub fn create_registry_value<'lua, T: IntoLua<'lua>>(&'lua self, t: T) -> Result<RegistryKey> {
+        let t = t.into_lua(self)?;
         if t == Value::Nil {
             // Special case to skip calling `luaL_ref` and use `LUA_REFNIL` instead
             let unref_list = unsafe { (*self.extra.get()).registry_unref_list.clone() };
@@ -2123,7 +2123,7 @@ impl Lua {
     /// See [`create_registry_value`] for more details.
     ///
     /// [`create_registry_value`]: #method.create_registry_value
-    pub fn replace_registry_value<'lua, T: ToLua<'lua>>(
+    pub fn replace_registry_value<'lua, T: IntoLua<'lua>>(
         &'lua self,
         key: &RegistryKey,
         t: T,
@@ -2132,7 +2132,7 @@ impl Lua {
             return Err(Error::MismatchedRegistryKey);
         }
 
-        let t = t.to_lua(self)?;
+        let t = t.into_lua(self)?;
         if t == Value::Nil && key.is_nil() {
             // Nothing to replace
             return Ok(());
diff --git a/src/multi.rs b/src/multi.rs
index 92b3d4f..b091561 100644
--- a/src/multi.rs
+++ b/src/multi.rs
@@ -1,23 +1,21 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::iter::FromIterator;
 use std::ops::{Deref, DerefMut};
 use std::result::Result as StdResult;
 
 use crate::error::Result;
 use crate::lua::Lua;
-use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil};
 
 /// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
 /// on success, or in the case of an error, returning `nil` and an error message.
-impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
+impl<'lua, T: IntoLua<'lua>, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<T, E> {
     #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
         let mut result = MultiValue::new_or_cached(lua);
         match self {
-            Ok(v) => result.push_front(v.to_lua(lua)?),
+            Ok(v) => result.push_front(v.into_lua(lua)?),
             Err(e) => {
-                result.push_front(e.to_lua(lua)?);
+                result.push_front(e.into_lua(lua)?);
                 result.push_front(Nil);
             }
         }
@@ -25,11 +23,11 @@ impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E>
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
+impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for T {
     #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
         let mut v = MultiValue::new_or_cached(lua);
-        v.push_front(self.to_lua(lua)?);
+        v.push_front(self.into_lua(lua)?);
         Ok(v)
     }
 }
@@ -43,9 +41,9 @@ impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
     }
 }
 
-impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
+impl<'lua> IntoLuaMulti<'lua> for MultiValue<'lua> {
     #[inline]
-    fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn into_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
         Ok(self)
     }
 }
@@ -128,11 +126,11 @@ impl<T> DerefMut for Variadic<T> {
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
+impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for Variadic<T> {
     #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
         let mut values = MultiValue::new_or_cached(lua);
-        values.refill(self.0.into_iter().map(|e| e.to_lua(lua)))?;
+        values.refill(self.0.into_iter().map(|e| e.into_lua(lua)))?;
         Ok(values)
     }
 }
@@ -152,9 +150,9 @@ impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
 
 macro_rules! impl_tuple {
     () => (
-        impl<'lua> ToLuaMulti<'lua> for () {
+        impl<'lua> IntoLuaMulti<'lua> for () {
             #[inline]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
                 Ok(MultiValue::new_or_cached(lua))
             }
         }
@@ -169,18 +167,18 @@ macro_rules! impl_tuple {
     );
 
     ($last:ident $($name:ident)*) => (
-        impl<'lua, $($name,)* $last> ToLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: ToLua<'lua>,)*
-                  $last: ToLuaMulti<'lua>
+        impl<'lua, $($name,)* $last> IntoLuaMulti<'lua> for ($($name,)* $last,)
+            where $($name: IntoLua<'lua>,)*
+                  $last: IntoLuaMulti<'lua>
         {
             #[allow(unused_mut)]
             #[allow(non_snake_case)]
             #[inline]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
                 let ($($name,)* $last,) = self;
 
-                let mut results = $last.to_lua_multi(lua)?;
-                push_reverse!(results, $($name.to_lua(lua)?,)*);
+                let mut results = $last.into_lua_multi(lua)?;
+                push_reverse!(results, $($name.into_lua(lua)?,)*);
                 Ok(results)
             }
         }
diff --git a/src/prelude.rs b/src/prelude.rs
index e1327e5..9111282 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -5,12 +5,12 @@ pub use crate::{
     AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Error as LuaError,
     ExternalError as LuaExternalError, ExternalResult as LuaExternalResult, FromLua, FromLuaMulti,
     Function as LuaFunction, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode,
-    Integer as LuaInteger, LightUserData as LuaLightUserData, Lua, LuaOptions,
-    MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber,
-    RegistryKey as LuaRegistryKey, Result as LuaResult, StdLib as LuaStdLib, String as LuaString,
-    Table as LuaTable, TableExt as LuaTableExt, TablePairs as LuaTablePairs,
-    TableSequence as LuaTableSequence, Thread as LuaThread, ThreadStatus as LuaThreadStatus, ToLua,
-    ToLuaMulti, UserData as LuaUserData, UserDataFields as LuaUserDataFields,
+    Integer as LuaInteger, IntoLua, IntoLuaMulti, LightUserData as LuaLightUserData, Lua,
+    LuaOptions, MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil,
+    Number as LuaNumber, RegistryKey as LuaRegistryKey, Result as LuaResult, StdLib as LuaStdLib,
+    String as LuaString, Table as LuaTable, TableExt as LuaTableExt, TablePairs as LuaTablePairs,
+    TableSequence as LuaTableSequence, Thread as LuaThread, ThreadStatus as LuaThreadStatus,
+    UserData as LuaUserData, UserDataFields as LuaUserDataFields,
     UserDataMetatable as LuaUserDataMetatable, UserDataMethods as LuaUserDataMethods,
     Value as LuaValue,
 };
diff --git a/src/scope.rs b/src/scope.rs
index c47ded2..b603e4a 100644
--- a/src/scope.rs
+++ b/src/scope.rs
@@ -20,7 +20,7 @@ use crate::util::{
     assert_stack, check_stack, get_userdata, init_userdata_metatable, push_table, rawset_field,
     take_userdata, StackGuard,
 };
-use crate::value::{FromLua, FromLuaMulti, MultiValue, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Value};
 
 #[cfg(feature = "lua54")]
 use crate::userdata::USER_VALUE_MAXSLOT;
@@ -65,7 +65,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     pub fn create_function<'callback, A, R, F>(&'callback self, func: F) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'callback>,
-        R: ToLuaMulti<'callback>,
+        R: IntoLuaMulti<'callback>,
         F: 'scope + Fn(&'callback Lua, A) -> Result<R>,
     {
         // Safe, because 'scope must outlive 'callback (due to Self containing 'scope), however the
@@ -79,7 +79,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
         // scope, and owned inside the callback itself.
         unsafe {
             self.create_callback(Box::new(move |lua, args| {
-                func(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                func(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             }))
         }
     }
@@ -98,7 +98,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     ) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'callback>,
-        R: ToLuaMulti<'callback>,
+        R: IntoLuaMulti<'callback>,
         F: 'scope + FnMut(&'callback Lua, A) -> Result<R>,
     {
         let func = RefCell::new(func);
@@ -127,7 +127,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     ) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'callback>,
-        R: ToLuaMulti<'callback>,
+        R: IntoLuaMulti<'callback>,
         F: 'scope + Fn(&'callback Lua, A) -> FR,
         FR: 'callback + Future<Output = Result<R>>,
     {
@@ -137,7 +137,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                     Ok(args) => args,
                     Err(e) => return Box::pin(future::err(e)),
                 };
-                Box::pin(func(lua, args).and_then(move |ret| future::ready(ret.to_lua_multi(lua))))
+                Box::pin(
+                    func(lua, args).and_then(move |ret| future::ready(ret.into_lua_multi(lua))),
+                )
             }))
         }
     }
@@ -625,13 +627,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_method<A, R, M>(&mut self, name: &str, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
     {
         self.methods.push((
             name.into(),
             NonStaticMethod::Method(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -639,13 +641,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_method_mut<A, R, M>(&mut self, name: &str, mut method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
     {
         self.methods.push((
             name.into(),
             NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -655,7 +657,7 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>,
     {
@@ -667,13 +669,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_function<A, R, F>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
         self.methods.push((
             name.into(),
             NonStaticMethod::Function(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -681,13 +683,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_function_mut<A, R, F>(&mut self, name: &str, mut function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
     {
         self.methods.push((
             name.into(),
             NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -696,7 +698,7 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_async_function<A, R, F, FR>(&mut self, _name: &str, _function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>,
     {
@@ -708,13 +710,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_meta_method<A, R, M>(&mut self, meta: impl Into<MetaMethod>, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
     {
         self.meta_methods.push((
             meta.into(),
             NonStaticMethod::Method(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -722,13 +724,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_meta_method_mut<A, R, M>(&mut self, meta: impl Into<MetaMethod>, mut method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
     {
         self.meta_methods.push((
             meta.into(),
             NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -738,7 +740,7 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>,
     {
@@ -750,13 +752,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_meta_function<A, R, F>(&mut self, meta: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
         self.meta_methods.push((
             meta.into(),
             NonStaticMethod::Function(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -764,13 +766,13 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_meta_function_mut<A, R, F>(&mut self, meta: impl Into<MetaMethod>, mut function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
     {
         self.meta_methods.push((
             meta.into(),
             NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -779,7 +781,7 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     fn add_async_meta_function<A, R, F, FR>(&mut self, _meta: impl Into<MetaMethod>, _function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>,
     {
@@ -809,13 +811,13 @@ impl<'lua, T: UserData> Default for NonStaticUserDataFields<'lua, T> {
 impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua, T> {
     fn add_field_method_get<R, M>(&mut self, name: &str, method: M)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>,
     {
         self.field_getters.push((
             name.into(),
             NonStaticMethod::Method(Box::new(move |lua, ud, _| {
-                method(lua, ud)?.to_lua_multi(lua)
+                method(lua, ud)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -828,20 +830,20 @@ impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua
         self.field_setters.push((
             name.into(),
             NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
 
     fn add_field_function_get<R, F>(&mut self, name: &str, function: F)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>,
     {
         self.field_getters.push((
             name.into(),
             NonStaticMethod::Function(Box::new(move |lua, args| {
-                function(lua, AnyUserData::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                function(lua, AnyUserData::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -855,7 +857,7 @@ impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua
             name.into(),
             NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
                 let (ud, val) = <_>::from_lua_multi(args, lua)?;
-                function(lua, ud, val)?.to_lua_multi(lua)
+                function(lua, ud, val)?.into_lua_multi(lua)
             })),
         ));
     }
@@ -863,13 +865,13 @@ impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua
     fn add_meta_field_with<R, F>(&mut self, meta: impl Into<MetaMethod>, f: F)
     where
         F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
     {
         let meta = meta.into();
         self.meta_fields.push((
             meta.clone(),
             Box::new(move |lua| {
-                let value = f(lua)?.to_lua(lua)?;
+                let value = f(lua)?.into_lua(lua)?;
                 if meta == MetaMethod::Index || meta == MetaMethod::NewIndex {
                     match value {
                         Value::Nil | Value::Table(_) | Value::Function(_) => {}
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index 2a0d691..9f79dad 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -10,7 +10,7 @@ use crate::string::String;
 use crate::table::Table;
 use crate::types::Integer;
 use crate::util::{check_stack, StackGuard};
-use crate::value::{ToLua, Value};
+use crate::value::{IntoLua, Value};
 
 /// A struct for serializing Rust values into Lua values.
 #[derive(Debug)]
@@ -110,7 +110,7 @@ macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
         fn $name(self, value: $t) -> Result<Value<'lua>> {
-            value.to_lua(self.lua)
+            value.into_lua(self.lua)
         }
     };
 }
diff --git a/src/table.rs b/src/table.rs
index 7099ce0..fb91fa1 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -13,7 +13,7 @@ use crate::ffi;
 use crate::function::Function;
 use crate::types::{Integer, LuaRef};
 use crate::util::{assert_stack, check_stack, StackGuard};
-use crate::value::{FromLua, FromLuaMulti, Nil, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Nil, Value};
 
 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -71,15 +71,15 @@ impl<'lua> Table<'lua> {
     /// ```
     ///
     /// [`raw_set`]: #method.raw_set
-    pub fn set<K: ToLua<'lua>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+    pub fn set<K: IntoLua<'lua>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()> {
         // Fast track
         if !self.has_metatable() {
             return self.raw_set(key, value);
         }
 
         let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
-        let value = value.to_lua(lua)?;
+        let key = key.into_lua(lua)?;
+        let value = value.into_lua(lua)?;
 
         let state = lua.state();
         unsafe {
@@ -117,7 +117,7 @@ impl<'lua> Table<'lua> {
     /// ```
     ///
     /// [`raw_get`]: #method.raw_get
-    pub fn get<K: ToLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
+    pub fn get<K: IntoLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
         // Fast track
         if !self.has_metatable() {
             return self.raw_get(key);
@@ -125,7 +125,7 @@ impl<'lua> Table<'lua> {
 
         let lua = self.0.lua;
         let state = lua.state();
-        let key = key.to_lua(lua)?;
+        let key = key.into_lua(lua)?;
 
         let value = unsafe {
             let _sg = StackGuard::new(state);
@@ -141,12 +141,12 @@ impl<'lua> Table<'lua> {
     }
 
     /// Checks whether the table contains a non-nil value for `key`.
-    pub fn contains_key<K: ToLua<'lua>>(&self, key: K) -> Result<bool> {
+    pub fn contains_key<K: IntoLua<'lua>>(&self, key: K) -> Result<bool> {
         Ok(self.get::<_, Value>(key)? != Value::Nil)
     }
 
     /// Appends a value to the back of the table.
-    pub fn push<V: ToLua<'lua>>(&self, value: V) -> Result<()> {
+    pub fn push<V: IntoLua<'lua>>(&self, value: V) -> Result<()> {
         // Fast track
         if !self.has_metatable() {
             return self.raw_push(value);
@@ -154,7 +154,7 @@ impl<'lua> Table<'lua> {
 
         let lua = self.0.lua;
         let state = lua.state();
-        let value = value.to_lua(lua)?;
+        let value = value.into_lua(lua)?;
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 4)?;
@@ -251,14 +251,14 @@ impl<'lua> Table<'lua> {
     }
 
     /// Sets a key-value pair without invoking metamethods.
-    pub fn raw_set<K: ToLua<'lua>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+    pub fn raw_set<K: IntoLua<'lua>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()> {
         #[cfg(feature = "luau")]
         self.check_readonly_write()?;
 
         let lua = self.0.lua;
         let state = lua.state();
-        let key = key.to_lua(lua)?;
-        let value = value.to_lua(lua)?;
+        let key = key.into_lua(lua)?;
+        let value = value.into_lua(lua)?;
 
         unsafe {
             let _sg = StackGuard::new(state);
@@ -279,10 +279,10 @@ impl<'lua> Table<'lua> {
     }
 
     /// Gets the value associated to `key` without invoking metamethods.
-    pub fn raw_get<K: ToLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
+    pub fn raw_get<K: IntoLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
         let lua = self.0.lua;
         let state = lua.state();
-        let key = key.to_lua(lua)?;
+        let key = key.into_lua(lua)?;
 
         let value = unsafe {
             let _sg = StackGuard::new(state);
@@ -299,7 +299,7 @@ impl<'lua> Table<'lua> {
 
     /// Inserts element value at position `idx` to the table, shifting up the elements from `table[idx]`.
     /// The worst case complexity is O(n), where n is the table length.
-    pub fn raw_insert<V: ToLua<'lua>>(&self, idx: Integer, value: V) -> Result<()> {
+    pub fn raw_insert<V: IntoLua<'lua>>(&self, idx: Integer, value: V) -> Result<()> {
         let lua = self.0.lua;
         let state = lua.state();
 
@@ -308,7 +308,7 @@ impl<'lua> Table<'lua> {
             return Err(Error::RuntimeError("index out of bounds".to_string()));
         }
 
-        let value = value.to_lua(lua)?;
+        let value = value.into_lua(lua)?;
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 5)?;
@@ -327,13 +327,13 @@ impl<'lua> Table<'lua> {
     }
 
     /// Appends a value to the back of the table without invoking metamethods.
-    pub fn raw_push<V: ToLua<'lua>>(&self, value: V) -> Result<()> {
+    pub fn raw_push<V: IntoLua<'lua>>(&self, value: V) -> Result<()> {
         #[cfg(feature = "luau")]
         self.check_readonly_write()?;
 
         let lua = self.0.lua;
         let state = lua.state();
-        let value = value.to_lua(lua)?;
+        let value = value.into_lua(lua)?;
 
         unsafe {
             let _sg = StackGuard::new(state);
@@ -385,10 +385,10 @@ impl<'lua> Table<'lua> {
     /// where n is the table length.
     ///
     /// For other key types this is equivalent to setting `table[key] = nil`.
-    pub fn raw_remove<K: ToLua<'lua>>(&self, key: K) -> Result<()> {
+    pub fn raw_remove<K: IntoLua<'lua>>(&self, key: K) -> Result<()> {
         let lua = self.0.lua;
         let state = lua.state();
-        let key = key.to_lua(lua)?;
+        let key = key.into_lua(lua)?;
         match key {
             Value::Integer(idx) => {
                 let size = self.raw_len();
@@ -718,7 +718,7 @@ pub trait TableExt<'lua> {
     /// The metamethod is called with the table as its first argument, followed by the passed arguments.
     fn call<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
     /// Asynchronously calls the table as function assuming it has `__call` metamethod.
@@ -729,7 +729,7 @@ pub trait TableExt<'lua> {
     fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut;
 
     /// Gets the function associated to `key` from the table and executes it,
@@ -741,8 +741,8 @@ pub trait TableExt<'lua> {
     /// This might invoke the `__index` metamethod.
     fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
     /// Gets the function associated to `key` from the table and executes it,
@@ -754,8 +754,8 @@ pub trait TableExt<'lua> {
     /// This might invoke the `__index` metamethod.
     fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
     /// Gets the function associated to `key` from the table and asynchronously executes it,
@@ -769,8 +769,8 @@ pub trait TableExt<'lua> {
     fn call_async_method<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut;
 
     /// Gets the function associated to `key` from the table and asynchronously executes it,
@@ -788,15 +788,15 @@ pub trait TableExt<'lua> {
     ) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut;
 }
 
 impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         // Convert table to a function and call via pcall that respects the `__call` metamethod.
@@ -807,7 +807,7 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         Function(self.0.clone()).call_async(args)
@@ -815,20 +815,20 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
 
     fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         let lua = self.0.lua;
-        let mut args = args.to_lua_multi(lua)?;
+        let mut args = args.into_lua_multi(lua)?;
         args.push_front(Value::Table(self.clone()));
         self.get::<_, Function>(key)?.call(args)
     }
 
     fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         self.get::<_, Function>(key)?.call(args)
@@ -838,12 +838,12 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call_async_method<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         let lua = self.0.lua;
-        let mut args = match args.to_lua_multi(lua) {
+        let mut args = match args.into_lua_multi(lua) {
             Ok(args) => args,
             Err(e) => return Box::pin(future::err(e)),
         };
@@ -855,8 +855,8 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call_async_function<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         match self.get::<_, Function>(key) {
diff --git a/src/thread.rs b/src/thread.rs
index dfce272..f708095 100644
--- a/src/thread.rs
+++ b/src/thread.rs
@@ -5,7 +5,7 @@ use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
 use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::value::{FromLuaMulti, IntoLuaMulti};
 
 #[cfg(any(
     feature = "lua54",
@@ -106,13 +106,13 @@ impl<'lua> Thread<'lua> {
     /// ```
     pub fn resume<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         let lua = self.0.lua;
         let state = lua.state();
 
-        let mut args = args.to_lua_multi(lua)?;
+        let mut args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
         let results = unsafe {
             let _sg = StackGuard::new(state);
@@ -276,10 +276,10 @@ impl<'lua> Thread<'lua> {
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
-        let args = args.to_lua_multi(self.0.lua);
+        let args = args.into_lua_multi(self.0.lua);
         AsyncThread {
             thread: self,
             args0: Some(args),
diff --git a/src/userdata.rs b/src/userdata.rs
index 0b0d3e7..c2275fb 100644
--- a/src/userdata.rs
+++ b/src/userdata.rs
@@ -22,7 +22,7 @@ use crate::lua::Lua;
 use crate::table::{Table, TablePairs};
 use crate::types::{Callback, LuaRef, MaybeSend};
 use crate::util::{check_stack, get_userdata, take_userdata, StackGuard};
-use crate::value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
 
 #[cfg(feature = "async")]
 use crate::types::AsyncCallback;
@@ -313,7 +313,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_method<A, R, M>(&mut self, name: &str, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>;
 
     /// Add a regular method which accepts a `&mut T` as the first parameter.
@@ -324,7 +324,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_method_mut<A, R, M>(&mut self, name: &str, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>;
 
     /// Add an async method which accepts a `T` as the first parameter and returns Future.
@@ -341,7 +341,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>;
 
@@ -358,7 +358,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_function<A, R, F>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>;
 
     /// Add a regular method as a mutable function which accepts generic arguments.
@@ -369,7 +369,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_function_mut<A, R, F>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>;
 
     /// Add a regular method as an async function which accepts generic arguments
@@ -385,7 +385,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_async_function<A, R, F, FR>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>;
 
@@ -400,7 +400,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_meta_method<A, R, M>(&mut self, meta: impl Into<MetaMethod>, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>;
 
     /// Add a metamethod as a function which accepts a `&mut T` as the first parameter.
@@ -414,7 +414,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_meta_method_mut<A, R, M>(&mut self, meta: impl Into<MetaMethod>, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>;
 
     /// Add an async metamethod which accepts a `T` as the first parameter and returns Future.
@@ -431,7 +431,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>;
 
@@ -443,7 +443,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_meta_function<A, R, F>(&mut self, meta: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>;
 
     /// Add a metamethod as a mutable function which accepts generic arguments.
@@ -454,7 +454,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_meta_function_mut<A, R, F>(&mut self, meta: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>;
 
     /// Add a metamethod which accepts generic arguments and returns Future.
@@ -469,7 +469,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     fn add_async_meta_function<A, R, F, FR>(&mut self, name: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>;
 
@@ -510,7 +510,7 @@ pub trait UserDataFields<'lua, T: UserData> {
     /// be used as a fall-back if no regular field or method are found.
     fn add_field_method_get<R, M>(&mut self, name: &str, method: M)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>;
 
     /// Add a regular field setter as a method which accepts a `&mut T` as the first parameter.
@@ -534,7 +534,7 @@ pub trait UserDataFields<'lua, T: UserData> {
     /// [`add_field_method_get`]: #method.add_field_method_get
     fn add_field_function_get<R, F>(&mut self, name: &str, function: F)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>;
 
     /// Add a regular field setter as a function which accepts a generic [`AnyUserData`] of type `T`
@@ -559,7 +559,7 @@ pub trait UserDataFields<'lua, T: UserData> {
     /// like `__gc` or `__metatable`.
     fn add_meta_field_with<R, F>(&mut self, meta: impl Into<MetaMethod>, f: F)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>;
 
     //
@@ -576,7 +576,7 @@ pub trait UserDataFields<'lua, T: UserData> {
 /// Trait for custom userdata types.
 ///
 /// By implementing this trait, a struct becomes eligible for use inside Lua code.
-/// Implementation of [`ToLua`] is automatically provided, [`FromLua`] is implemented
+/// Implementation of [`IntoLua`] is automatically provided, [`FromLua`] is implemented
 /// only for `T: UserData + Clone`.
 ///
 ///
@@ -590,7 +590,7 @@ pub trait UserDataFields<'lua, T: UserData> {
 ///
 /// impl UserData for MyUserData {}
 ///
-/// // `MyUserData` now implements `ToLua`:
+/// // `MyUserData` now implements `IntoLua`:
 /// lua.globals().set("myobject", MyUserData(123))?;
 ///
 /// lua.load("assert(type(myobject) == 'userdata')").exec()?;
@@ -636,7 +636,7 @@ pub trait UserDataFields<'lua, T: UserData> {
 /// # }
 /// ```
 ///
-/// [`ToLua`]: crate::ToLua
+/// [`IntoLua`]: crate::IntoLua
 /// [`FromLua`]: crate::FromLua
 /// [`UserDataFields`]: crate::UserDataFields
 /// [`UserDataMethods`]: crate::UserDataMethods
@@ -858,7 +858,7 @@ impl<'lua> AnyUserData<'lua> {
     /// [`get_user_value`]: #method.get_user_value
     /// [`set_nth_user_value`]: #method.set_nth_user_value
     #[inline]
-    pub fn set_user_value<V: ToLua<'lua>>(&self, v: V) -> Result<()> {
+    pub fn set_user_value<V: IntoLua<'lua>>(&self, v: V) -> Result<()> {
         self.set_nth_user_value(1, v)
     }
 
@@ -883,7 +883,7 @@ impl<'lua> AnyUserData<'lua> {
     /// For other Lua versions this functionality is provided using a wrapping table.
     ///
     /// [`get_nth_user_value`]: #method.get_nth_user_value
-    pub fn set_nth_user_value<V: ToLua<'lua>>(&self, n: usize, v: V) -> Result<()> {
+    pub fn set_nth_user_value<V: IntoLua<'lua>>(&self, n: usize, v: V) -> Result<()> {
         if n < 1 || n > u16::MAX as usize {
             return Err(Error::RuntimeError(
                 "user value index out of bounds".to_string(),
@@ -897,7 +897,7 @@ impl<'lua> AnyUserData<'lua> {
             check_stack(state, 5)?;
 
             lua.push_userdata_ref(&self.0)?;
-            lua.push_value(v.to_lua(lua)?)?;
+            lua.push_value(v.into_lua(lua)?)?;
 
             #[cfg(feature = "lua54")]
             if n < USER_VALUE_MAXSLOT {
@@ -982,7 +982,7 @@ impl<'lua> AnyUserData<'lua> {
     /// [`get_named_user_value`]: #method.get_named_user_value
     pub fn set_named_user_value<V>(&self, name: &str, v: V) -> Result<()>
     where
-        V: ToLua<'lua>,
+        V: IntoLua<'lua>,
     {
         let lua = self.0.lua;
         let state = lua.state();
@@ -991,7 +991,7 @@ impl<'lua> AnyUserData<'lua> {
             check_stack(state, 5)?;
 
             lua.push_userdata_ref(&self.0)?;
-            lua.push_value(v.to_lua(lua)?)?;
+            lua.push_value(v.into_lua(lua)?)?;
 
             // Multiple (extra) user values are emulated by storing them in a table
             protect_lua!(state, 2, 0, |state| {
@@ -1159,7 +1159,7 @@ impl<'lua> UserDataMetatable<'lua> {
     /// Access to restricted metamethods such as `__gc` or `__metatable` will cause an error.
     /// Setting `__index` or `__newindex` metamethods is also restricted because their values are cached
     /// for `mlua` internal usage.
-    pub fn set<K: Into<MetaMethod>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+    pub fn set<K: Into<MetaMethod>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()> {
         let key = key.into().validate()?;
         // `__index` and `__newindex` cannot be changed in runtime, because values are cached
         if key == MetaMethod::Index || key == MetaMethod::NewIndex {
diff --git a/src/userdata_impl.rs b/src/userdata_impl.rs
index 8853a90..aad6be6 100644
--- a/src/userdata_impl.rs
+++ b/src/userdata_impl.rs
@@ -11,7 +11,7 @@ use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
 use crate::util::{check_stack, get_userdata, StackGuard};
-use crate::value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(not(feature = "send"))]
 use std::rc::Rc;
@@ -51,7 +51,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_method<A, R, M>(&mut self, name: &str, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
     {
         self.methods.push((name.into(), Self::box_method(method)));
@@ -60,7 +60,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_method_mut<A, R, M>(&mut self, name: &str, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
     {
         self.methods
@@ -72,7 +72,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>,
     {
@@ -83,7 +83,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_function<A, R, F>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
         self.methods
@@ -93,7 +93,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_function_mut<A, R, F>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
     {
         self.methods
@@ -104,7 +104,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_async_function<A, R, F, FR>(&mut self, name: &str, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>,
     {
@@ -115,7 +115,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_meta_method<A, R, M>(&mut self, meta: impl Into<MetaMethod>, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
     {
         self.meta_methods
@@ -125,7 +125,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_meta_method_mut<A, R, M>(&mut self, meta: impl Into<MetaMethod>, method: M)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
     {
         self.meta_methods
@@ -137,7 +137,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>,
     {
@@ -148,7 +148,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_meta_function<A, R, F>(&mut self, meta: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
         self.meta_methods
@@ -158,7 +158,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_meta_function_mut<A, R, F>(&mut self, meta: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
     {
         self.meta_methods
@@ -169,7 +169,7 @@ impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMet
     fn add_async_meta_function<A, R, F, FR>(&mut self, meta: impl Into<MetaMethod>, function: F)
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>,
     {
@@ -206,7 +206,7 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
     fn box_method<A, R, M>(method: M) -> Callback<'lua, 'static>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
     {
         Box::new(move |lua, mut args| {
@@ -221,35 +221,35 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
                     match type_id {
                         Some(id) if id == TypeId::of::<T>() => {
                             let ud = get_userdata_ref::<T>(state)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         #[cfg(not(feature = "send"))]
                         Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
                             let ud = get_userdata_ref::<Rc<RefCell<T>>>(state)?;
                             let ud = ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
                             let ud = get_userdata_ref::<Arc<Mutex<T>>>(state)?;
                             let ud = ud.try_lock().map_err(|_| Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         #[cfg(feature = "parking_lot")]
                         Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
                             let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(state)?;
                             let ud = ud.try_lock().ok_or(Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
                             let ud = get_userdata_ref::<Arc<RwLock<T>>>(state)?;
                             let ud = ud.try_read().map_err(|_| Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         #[cfg(feature = "parking_lot")]
                         Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
                             let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(state)?;
                             let ud = ud.try_read().ok_or(Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         _ => Err(Error::UserDataTypeMismatch),
                     }
@@ -267,7 +267,7 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
     fn box_method_mut<A, R, M>(method: M) -> Callback<'lua, 'static>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
     {
         let method = RefCell::new(method);
@@ -286,7 +286,7 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
                     match type_id {
                         Some(id) if id == TypeId::of::<T>() => {
                             let mut ud = get_userdata_mut::<T>(state)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         #[cfg(not(feature = "send"))]
                         Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
@@ -294,31 +294,31 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
                             let mut ud = ud
                                 .try_borrow_mut()
                                 .map_err(|_| Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
                             let ud = get_userdata_mut::<Arc<Mutex<T>>>(state)?;
                             let mut ud =
                                 ud.try_lock().map_err(|_| Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         #[cfg(feature = "parking_lot")]
                         Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
                             let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(state)?;
                             let mut ud = ud.try_lock().ok_or(Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
                             let ud = get_userdata_mut::<Arc<RwLock<T>>>(state)?;
                             let mut ud =
                                 ud.try_write().map_err(|_| Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         #[cfg(feature = "parking_lot")]
                         Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
                             let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(state)?;
                             let mut ud = ud.try_write().ok_or(Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
                         }
                         _ => Err(Error::UserDataTypeMismatch),
                     }
@@ -338,7 +338,7 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
     where
         T: Clone,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
         MR: 'lua + Future<Output = Result<R>>,
     {
@@ -397,7 +397,9 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
                 }
             };
             match fut_res() {
-                Ok(fut) => Box::pin(fut.and_then(move |ret| future::ready(ret.to_lua_multi(lua)))),
+                Ok(fut) => {
+                    Box::pin(fut.and_then(move |ret| future::ready(ret.into_lua_multi(lua))))
+                }
                 Err(e) => Box::pin(future::err(e)),
             }
         })
@@ -406,16 +408,16 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
     fn box_function<A, R, F>(function: F) -> Callback<'lua, 'static>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
     {
-        Box::new(move |lua, args| function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua))
+        Box::new(move |lua, args| function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua))
     }
 
     fn box_function_mut<A, R, F>(function: F) -> Callback<'lua, 'static>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
     {
         let function = RefCell::new(function);
@@ -423,7 +425,7 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
             let function = &mut *function
                 .try_borrow_mut()
                 .map_err(|_| Error::RecursiveMutCallback)?;
-            function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+            function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
         })
     }
 
@@ -431,7 +433,7 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
     fn box_async_function<A, R, F, FR>(function: F) -> AsyncCallback<'lua, 'static>
     where
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
         FR: 'lua + Future<Output = Result<R>>,
     {
@@ -440,7 +442,9 @@ impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
                 Ok(args) => args,
                 Err(e) => return Box::pin(future::err(e)),
             };
-            Box::pin(function(lua, args).and_then(move |ret| future::ready(ret.to_lua_multi(lua))))
+            Box::pin(
+                function(lua, args).and_then(move |ret| future::ready(ret.into_lua_multi(lua))),
+            )
         })
     }
 }
@@ -470,7 +474,7 @@ impl<'lua, T: 'static + UserData> Default for StaticUserDataFields<'lua, T> {
 impl<'lua, T: 'static + UserData> UserDataFields<'lua, T> for StaticUserDataFields<'lua, T> {
     fn add_field_method_get<R, M>(&mut self, name: &str, method: M)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>,
     {
         self.field_getters.push((
@@ -490,7 +494,7 @@ impl<'lua, T: 'static + UserData> UserDataFields<'lua, T> for StaticUserDataFiel
 
     fn add_field_function_get<R, F>(&mut self, name: &str, function: F)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>,
     {
         self.field_getters.push((
@@ -514,14 +518,14 @@ impl<'lua, T: 'static + UserData> UserDataFields<'lua, T> for StaticUserDataFiel
 
     fn add_meta_field_with<R, F>(&mut self, meta: impl Into<MetaMethod>, f: F)
     where
-        R: ToLua<'lua>,
+        R: IntoLua<'lua>,
         F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
     {
         let meta = meta.into();
         self.meta_fields.push((
             meta.clone(),
             Box::new(move |lua| {
-                let value = f(lua)?.to_lua(lua)?;
+                let value = f(lua)?.into_lua(lua)?;
                 if meta == MetaMethod::Index || meta == MetaMethod::NewIndex {
                     match value {
                         Value::Nil | Value::Table(_) | Value::Function(_) => {}
diff --git a/src/value.rs b/src/value.rs
index 8d90b62..204e5f3 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -180,9 +180,9 @@ impl<'lua> Serialize for Value<'lua> {
 }
 
 /// Trait for types convertible to `Value`.
-pub trait ToLua<'lua> {
+pub trait IntoLua<'lua> {
     /// Performs the conversion.
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>>;
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>>;
 }
 
 /// Trait for types convertible from `Value`.
@@ -337,11 +337,11 @@ impl<'lua> MultiValue<'lua> {
 
 /// Trait for types convertible to any number of Lua values.
 ///
-/// This is a generalization of `ToLua`, allowing any number of resulting Lua values instead of just
-/// one. Any type that implements `ToLua` will automatically implement this trait.
-pub trait ToLuaMulti<'lua> {
+/// This is a generalization of `IntoLua`, allowing any number of resulting Lua values instead of just
+/// one. Any type that implements `IntoLua` will automatically implement this trait.
+pub trait IntoLuaMulti<'lua> {
     /// Performs the conversion.
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>>;
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>>;
 }
 
 /// Trait for types that can be created from an arbitrary number of Lua values.