Would intrusive ref counted objects get deallocated instantly if you call PYBIND11_OVERRIDE function in constructor?

[d0t2]

I've been debugging a really nasty segfault in a large (proprietary) python/C++ project which uses pybind11. The following is one possibility I'm considering:

Say you have the following in C++:

class MyClass : public IntrusiveRefCountedObject { // registered with pybind
private:
  OtherClass otherObj; // also inherits from `IntrusiveRefCountedObject` and registered with pybind
public:
  MyClass(OtherClass* otherObj) : otherObj(otherObj) {
    otherObj->doSomethingWith(this); // `doSomethingWith` is wrapped with `PYBIND11_OVERRIDE`
  }
  ...
}

And in python:

a = OtherClass()
b = MyClass(a)

Judging from the gdb backtrace, when you create a new instance in python with MyClass(a), the C++ constructor MyClass::MyClass is called before the python instance is initialized with pybind11::class_<...>::init_instance. Therefore, while you're in the MyClass constructor, your ref count is zero.

So when you call otherObj->doSomethingWith(this) (which has been wrapped with PYBIND11_OVERRIDE) while you're in the MyClass constructor, you would need to 1) create a python instance of otherObj to check if doSomethingWith is overridden in python, 2) if it is overridden, create a python instance of this to pass into the python function.

If OtherClass::doSomethingWith is overridden in python, you would immediately cause issues. Since presumably after you're done with the temporary python instance of this, the garbage collector would see the ref count is 0 and free it.

However, for my particular case, OtherClass::doSomethingWith is not overridden in python. And from debugging, I don't think MyClass::~MyClass is being called before pybind11::class_<...>::init_instance. But is it possible that the memory this is supposed to occupy gets freed anyway? Or some other issues happen?