Add Function::deep_clone() (Luau only)

Author: khvzak

src/function.rs

@@ -504,6 +504,27 @@ impl<'lua> Function<'lua> {
         self.0.to_pointer()
     }
 
+    /// Creates a deep clone of the Lua function.
+    ///
+    /// Copies the function prototype and all its upvalues to the
+    /// newly created function.
+    ///
+    /// This function returns shallow clone (same handle) for Rust/C functions.
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn deep_clone(&self) -> Self {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe {
+            if ffi::lua_iscfunction(ref_thread, self.0.index) != 0 {
+                return self.clone();
+            }
+
+            ffi::lua_clonefunction(ref_thread, self.0.index);
+            Function(self.0.lua.pop_ref_thread())
+        }
+    }
+
     /// Convert this handle to owned version.
     #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
     #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]

tests/function.rs

@@ -244,6 +244,27 @@ fn test_function_pointer() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "luau")]
+#[test]
+fn test_function_deep_clone() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.globals().set("a", 1)?;
+    let func1 = lua.load("a += 1; return a").into_function()?;
+    let func2 = func1.deep_clone();
+
+    assert_ne!(func1.to_pointer(), func2.to_pointer());
+    assert_eq!(func1.call::<_, i32>(())?, 2);
+    assert_eq!(func2.call::<_, i32>(())?, 3);
+
+    // Check that for Rust functions deep_clone is just a clone
+    let rust_func = lua.create_function(|_, ()| Ok(42))?;
+    let rust_func2 = rust_func.deep_clone();
+    assert_eq!(rust_func.to_pointer(), rust_func2.to_pointer());
+
+    Ok(())
+}
+
 #[test]
 fn test_function_wrap() -> Result<()> {
     use mlua::Error;