Remove Clone requirement from UserDataFields::add_field()

Author: khvzak

src/state/raw.rs

@@ -805,10 +805,9 @@ impl RawLua {
             rawset_field(state, -2, MetaMethod::validate(&k)?)?;
         }
         let mut has_name = false;
-        for (k, f) in registry.meta_fields {
+        for (k, push_field) in registry.meta_fields {
             has_name = has_name || k == MetaMethod::Type;
-            let rawlua = mem::transmute::<&RawLua, &RawLua>(self);
-            mlua_assert!(f(rawlua, 0)? == 1, "field function must return one value");
+            push_field(self)?;
             rawset_field(state, -2, MetaMethod::validate(&k)?)?;
         }
         // Set `__name/__type` if not provided
@@ -832,31 +831,38 @@ impl RawLua {
                         ffi::lua_pop(state, 1);
                         push_table(state, 0, fields_nrec, true)?;
                     }
-                    for (k, f) in registry.fields {
-                        let rawlua = mem::transmute::<&RawLua, &RawLua>(self);
-                        mlua_assert!(f(rawlua, 0)? == 1, "field function must return one value");
+                    for (k, push_field) in mem::take(&mut registry.fields) {
+                        push_field(self)?;
                         rawset_field(state, -2, &k)?;
                     }
                     rawset_field(state, metatable_index, "__index")?;
                 }
                 _ => {
                     ffi::lua_pop(state, 1);
-                    // Propagate fields to the field getters
-                    for (k, f) in registry.fields {
-                        registry.field_getters.push((k, f))
-                    }
+                    // Fields will be converted to functions and added to field getters
                 }
             }
         }
 
         let mut field_getters_index = None;
-        let field_getters_nrec = registry.field_getters.len();
+        let field_getters_nrec = registry.field_getters.len() + registry.fields.len();
         if field_getters_nrec > 0 {
             push_table(state, 0, field_getters_nrec, true)?;
             for (k, m) in registry.field_getters {
                 self.push(self.create_callback(m)?)?;
                 rawset_field(state, -2, &k)?;
             }
+            for (k, push_field) in registry.fields {
+                unsafe extern "C-unwind" fn return_field(state: *mut ffi::lua_State) -> c_int {
+                    ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
+                    1
+                }
+                push_field(self)?;
+                protect_lua!(state, 1, 1, fn(state) {
+                    ffi::lua_pushcclosure(state, return_field, 1);
+                })?;
+                rawset_field(state, -2, &k)?;
+            }
             field_getters_index = Some(ffi::lua_absindex(state, -1));
             extra_tables_count += 1;
         }

src/userdata.rs

@@ -467,7 +467,7 @@ pub trait UserDataFields<T> {
     /// be used as a fall-back if no regular field or method are found.
     fn add_field<V>(&mut self, name: impl ToString, value: V)
     where
-        V: IntoLua + Clone + 'static;
+        V: IntoLua + 'static;
 
     /// Add a regular field getter as a method which accepts a `&T` as the parameter.
     ///
@@ -528,7 +528,7 @@ pub trait UserDataFields<T> {
     /// like `__gc` or `__metatable`.
     fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
     where
-        V: IntoLua + Clone + 'static;
+        V: IntoLua + 'static;
 
     /// Add a metatable field computed from `f`.
     ///
@@ -540,7 +540,7 @@ pub trait UserDataFields<T> {
     /// like `__gc` or `__metatable`.
     fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
     where
-        F: Fn(&Lua) -> Result<R> + MaybeSend + 'static,
+        F: FnOnce(&Lua) -> Result<R> + 'static,
         R: IntoLua;
 }
 

src/userdata/registry.rs

@@ -7,7 +7,7 @@ use std::os::raw::c_int;
 use std::string::String as StdString;
 
 use crate::error::{Error, Result};
-use crate::state::Lua;
+use crate::state::{Lua, RawLua};
 use crate::types::{Callback, MaybeSend};
 use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMethods, UserDataRef, UserDataRefMut,
@@ -23,13 +23,15 @@ use {
     std::future::{self, Future},
 };
 
+type StaticFieldCallback = Box<dyn FnOnce(&RawLua) -> Result<()> + 'static>;
+
 /// Handle to registry for userdata methods and metamethods.
 pub struct UserDataRegistry<T: 'static> {
     // Fields
-    pub(crate) fields: Vec<(String, Callback)>,
+    pub(crate) fields: Vec<(String, StaticFieldCallback)>,
     pub(crate) field_getters: Vec<(String, Callback)>,
     pub(crate) field_setters: Vec<(String, Callback)>,
-    pub(crate) meta_fields: Vec<(String, Callback)>,
+    pub(crate) meta_fields: Vec<(String, StaticFieldCallback)>,
 
     // Methods
     pub(crate) methods: Vec<(String, Callback)>,
@@ -283,11 +285,13 @@ fn get_function_name<T>(name: &str) -> StdString {
 impl<T: 'static> UserDataFields<T> for UserDataRegistry<T> {
     fn add_field<V>(&mut self, name: impl ToString, value: V)
     where
-        V: IntoLua + Clone + 'static,
+        V: IntoLua + 'static,
     {
         let name = name.to_string();
-        let callback: Callback = Box::new(move |lua, _| unsafe { value.clone().push_into_stack_multi(lua) });
-        self.fields.push((name, callback));
+        self.fields.push((
+            name,
+            Box::new(move |rawlua| unsafe { value.push_into_stack(rawlua) }),
+        ));
     }
 
     fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
@@ -332,28 +336,28 @@ impl<T: 'static> UserDataFields<T> for UserDataRegistry<T> {
 
     fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
     where
-        V: IntoLua + Clone + 'static,
+        V: IntoLua + 'static,
     {
         let name = name.to_string();
         self.meta_fields.push((
             name.clone(),
-            Box::new(move |lua, _| unsafe {
-                Self::check_meta_field(lua.lua(), &name, value.clone())?.push_into_stack_multi(lua)
+            Box::new(move |rawlua| unsafe {
+                Self::check_meta_field(rawlua.lua(), &name, value)?.push_into_stack(rawlua)
             }),
         ));
     }
 
     fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
     where
-        F: Fn(&Lua) -> Result<R> + MaybeSend + 'static,
+        F: FnOnce(&Lua) -> Result<R> + 'static,
         R: IntoLua,
     {
         let name = name.to_string();
         self.meta_fields.push((
             name.clone(),
-            Box::new(move |rawlua, _| unsafe {
+            Box::new(move |rawlua| unsafe {
                 let lua = rawlua.lua();
-                Self::check_meta_field(lua, &name, f(lua)?)?.push_into_stack_multi(rawlua)
+                Self::check_meta_field(lua, &name, f(lua)?)?.push_into_stack(rawlua)
             }),
         ));
     }