Add Table::remove

Author: khvzak

src/table.rs

@@ -341,6 +341,54 @@ impl Table {
         }
     }
 
+    /// Removes a key from the table.
+    ///
+    /// If `key` is an integer, mlua shifts down the elements from `table[key+1]`,
+    /// and erases element `table[key]`. The complexity is `O(n)` in the worst case,
+    /// where `n` is the table length.
+    ///
+    /// For other key types this is equivalent to setting `table[key] = nil`.
+    ///
+    /// This might invoke the `__len`, `__index` and `__newindex` metamethods.
+    /// Use the [`raw_remove`] method if that is not desired.
+    ///
+    /// [`raw_remove`]: Table::raw_remove
+    pub fn remove(&self, key: impl IntoLua) -> Result<()> {
+        // Fast track (skip protected call)
+        if !self.has_metatable() {
+            return self.raw_remove(key);
+        }
+
+        let lua = self.0.lua.lock();
+        let key = key.into_lua(lua.lua())?;
+        match key {
+            Value::Integer(idx) => {
+                let size = self.len()?;
+                if idx < 1 || idx > size {
+                    return Err(Error::runtime("index out of bounds"));
+                }
+
+                let state = lua.state();
+                unsafe {
+                    let _sg = StackGuard::new(state);
+                    check_stack(state, 4)?;
+
+                    lua.push_ref(&self.0);
+                    protect_lua!(state, 1, 0, |state| {
+                        for i in idx..size {
+                            // table[i] = table[i+1]
+                            ffi::lua_geti(state, -1, i + 1);
+                            ffi::lua_seti(state, -2, i);
+                        }
+                        ffi::lua_pushnil(state);
+                        ffi::lua_seti(state, -2, size);
+                    })
+                }
+            }
+            _ => self.set(key, Nil),
+        }
+    }
+
     /// Compares two tables for equality.
     ///
     /// Tables are compared by reference first.

tests/table.rs

@@ -142,6 +142,38 @@ fn test_table_insert_remove() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_table_remove_metatable() -> Result<()> {
+    let lua = Lua::new();
+
+    let inner = lua.create_sequence_from([1, 2, 3, 4, 5])?;
+    let mt = lua.create_table()?;
+    mt.set("__index", &inner)?;
+    mt.set("__newindex", &inner)?;
+    mt.set("__len", {
+        let inner = inner.clone();
+        lua.create_function(move |_, ()| Ok(inner.raw_len()))?
+    })?;
+
+    let t = lua.create_table()?;
+    t.set_metatable(Some(mt))?;
+
+    t.remove(2)?; // removes value `2`
+    assert_eq!(t.len()?, 4);
+    assert_eq!(
+        inner.pairs().collect::<Result<Vec<(i64, i64)>>>()?,
+        vec![(1, 1), (2, 3), (3, 4), (4, 5)]
+    );
+
+    // Remove non-integer key
+    t.set("abc", "abcdef")?;
+    assert_eq!(inner.get::<String>("abc")?, "abcdef");
+    t.remove("abc")?;
+    assert_eq!(inner.get::<Value>("abc")?, Value::Nil);
+
+    Ok(())
+}
+
 #[test]
 fn test_table_clear() -> Result<()> {
     let lua = Lua::new();