expose move constructor in low level interface

Author: wjakob

README.md

@@ -527,6 +527,15 @@ changes are detailed below.
        by initializing it yet again. */
     nb::inst_destruct(py_inst);
     assert(!nb::inst_ready(py_inst));
+
+    /* We can copy- or move-construct 'py_inst' from another instance of the
+       same type. This calls the C++ copy or move constructor and transitions
+       'py_inst' back to 'ready' status. Note that this is equivalent to calling
+       an in-place version of these constructors above but compiles to more
+       compact code (the 'nb::class_<MyClass>' declaration has already created
+       bindings for both constructors, and this simply calls those bindings). */
+    // nb::inst_copy(/* dst = */ py_inst, /* src = */ some_other_instance);
+    // nb::inst_move(/* dst = */ py_inst, /* src = */ some_other_instance);
     ```
 
     Note that these functions are all _unsafe_ in the sense that they do not

include/nanobind/nb_class.h

@@ -447,6 +447,7 @@ inline bool inst_ready(handle h) { return detail::nb_inst_ready(h.ptr()); }
 inline void inst_mark_ready(handle h) { detail::nb_inst_mark_ready(h.ptr()); }
 inline void inst_destruct(handle h) { detail::nb_inst_destruct(h.ptr()); }
 inline void inst_copy(handle dst, handle src) { detail::nb_inst_copy(dst.ptr(), src.ptr()); }
+inline void inst_move(handle dst, handle src) { detail::nb_inst_move(dst.ptr(), src.ptr()); }
 template <typename T> T *inst_ptr(handle h) { return (T *) detail::nb_inst_ptr(h.ptr()); }
 
 NAMESPACE_END(NB_NAMESPACE)

include/nanobind/nb_lib.h

@@ -243,6 +243,9 @@ NB_CORE void nb_inst_destruct(PyObject *o) noexcept;
 /// Copy-construct 'dst' from 'src' and mark it as ready (must have the same nb_type)
 NB_CORE void nb_inst_copy(PyObject *dst, const PyObject *src) noexcept;
 
+/// Move-construct 'dst' from 'src' and mark it as ready (must have the same nb_type)
+NB_CORE void nb_inst_move(PyObject *dst, const PyObject *src) noexcept;
+
 /// Check if an instance is ready
 NB_CORE bool nb_inst_ready(PyObject *o) noexcept;
 

src/nb_type.cpp

@@ -611,6 +611,7 @@ PyObject *nb_type_put(const std::type_info *cpp_type, void *value,
                 }
             } else {
                 memcpy(new_value, value, t->size);
+                memset(value, 0, t->size);
             }
         } else {
             if (t->flags & (uint32_t) type_flags::is_copy_constructible) {
@@ -825,5 +826,25 @@ void nb_inst_copy(PyObject *dst, const PyObject *src) noexcept {
     nbi->ready = nbi->destruct = true;
 }
 
+void nb_inst_move(PyObject *dst, const PyObject *src) noexcept {
+    nb_type *nbt = (nb_type *) Py_TYPE(src);
+    if (Py_TYPE(src) != Py_TYPE(dst) ||
+        (nbt->t.flags & (uint32_t) type_flags::is_move_constructible) == 0)
+        fail("nanobind::detail::nb_inst_move(): invalid arguments!");
+
+    nb_inst *nbi = (nb_inst *) dst;
+    void *src_data = inst_ptr((nb_inst *) src);
+    void *dst_data = inst_ptr(nbi);
+
+    if (nbt->t.flags & (uint32_t) type_flags::has_move) {
+        nbt->t.move(dst_data, src_data);
+    } else {
+        memcpy(dst_data, src_data, nbt->t.size);
+        memset(src_data, 0, nbt->t.size);
+    }
+
+    nbi->ready = nbi->destruct = true;
+}
+
 NAMESPACE_END(detail)
 NAMESPACE_END(NB_NAMESPACE)

tests/test_classes.cpp

@@ -2,6 +2,7 @@
 #include <nanobind/trampoline.h>
 #include <nanobind/operators.h>
 #include <nanobind/stl/string.h>
+#include <nanobind/stl/pair.h>
 #include <memory>
 
 namespace nb = nanobind;
@@ -347,6 +348,10 @@ NB_MODULE(test_classes_ext, m) {
         if (nb::inst_ready(py_inst))
             throw std::runtime_error("Internal error! (6)");
 
-        return py_inst_2;
+        nb::inst_move(py_inst, py_inst_2);
+        if (!nb::inst_ready(py_inst))
+            throw std::runtime_error("Internal error! (7)");
+
+        return std::make_pair(py_inst, py_inst_2);
     });
 }

tests/test_classes.py

@@ -414,11 +414,13 @@ def test20_type_callback():
     assert len(o) == 123
 
 def test21_low_level(clean):
-    s = t.test_lowlevel()
-    assert s.value() == 123
-    del s
+    s1, s2 = t.test_lowlevel()
+    assert s1.value() == 123 and s2.value() == 0
+    del s1
+    del s2
     assert_stats(
         value_constructed=1,
         copy_constructed=1,
-        destructed=2
+        move_constructed=1,
+        destructed=3
     )