Leaks when binding nested classes with default values in itializer

[tom-bola]

Hi,

Given a simple class hierarchy

struct A {};
struct B { A a; };
struct C { B b; };

and binding code

nb::class_<A>(m, "A");
nb::class_<B>(m, "B").def(nb::init<const A&>(), nb::arg("a") = A{});
nb::class_<C>(m, "C").def(nb::init<const B&>(), nb::arg("b") = B{});

I'm getting

nanobind: leaked 1 instances!
 - leaked instance 0x1057b3f68 of type "Bindings_pyb.A"
nanobind: leaked 2 types!
 - leaked type "Bindings_pyb.A"
 - leaked type "Bindings_pyb.B"
nanobind: leaked 1 functions!
 - leaked function "__init__"
nanobind: this is likely caused by a reference counting issue in the binding code.

This only happens when both "a" and "b" args are assigned a default value. The classes are nested but there is no reference cycle. I've read the FAQ section about leak reports but I don't see how it applies here. I would appreciate if someone could help me to understand the issue and how to work around it.

Thanks!

[wjakob]

There is a reference here that goes from a type object to an instance, which creates the potential for instance <-> type cycles. Something like that must be happening here, which is probably complicated to understand and related to Python implementation details related to type and module objects.

Nanobind instances are normally not registered with the GC, since this has a const. In this case, what I suspect is that the warning will go away if you provide at trivial Py_tp_visit callback that only visits the type object of the instance (see the testcases for example code). Can you try this and report back?

[tom-bola]

Thanks @wjakob! I added a trivial

int tp_visit(PyObject* self, visitproc visit, void* arg) {
    Py_VISIT(Py_TYPE(self));
    return 0;
}

and constructing the class as

PyType_Slot slots[] = {{Py_tp_traverse, (void*)detail::tp_visit}, {0, nullptr}};
auto cl = nb::class_<T>(scope, name, slots, std::forward<Args>(args)...);

fixes the reported leaks!