Possible memory issues when using `shared_ptr` as holder type

[lyskov]

Dear Pybind11 developers, i would like to report a strange case which on a surface looks like a situation when C++ fail to retain ownership of classes defined in Python and derived from C++ base classes.

Below is a minimal example to reproduce this. Note that Python script have --bug command line argument which allow to trigger a bug. And if option is not supplied then code work as expected without any errors.

In short: issues seems to arise when derived class is created in C++ by a 'clone' method. It looks like after creation 'Python' portion of Snake class will get immediately deleted unless it explicitly stored in one of Python variables.

When --bug is supplied execution terminated with error message:

Snake.clone!
Traceback (most recent call last):
  File "inheritance-clone.py", line 34, in <module>
    example.clone_and_call_go(a)
RuntimeError: Tried to call pure virtual function "Animal::go"

#include <pybind11/pybind11.h>


class Animal {
public:
    virtual ~Animal() { }
    virtual std::string go(int n_times) = 0;

    virtual std::shared_ptr<Animal> clone() = 0;
};


std::string clone_and_call_go(std::shared_ptr<Animal> animal) {
    auto new_animal = animal->clone();
    return new_animal->go(3);
}


class PyAnimal : public Animal {
public:
    /* Inherit the constructors */
    using Animal::Animal;

    /* Trampoline (need one for each virtual function) */
    std::string go(int n_times) override {
        PYBIND11_OVERLOAD_PURE(
            std::string, /* Return type */
            Animal,      /* Parent class */
            go,          /* Name of function in C++ (must match Python name) */
            n_times      /* Argument(s) */
        );
    }

	std::shared_ptr<Animal> clone() override {
        PYBIND11_OVERLOAD_PURE(
            std::shared_ptr<Animal>,
            Animal,
            clone
        );
    }

};


namespace py = pybind11;

PYBIND11_MODULE(example, m) {

	py::class_<Animal, std::shared_ptr<Animal>, PyAnimal>(m, "Animal")
        .def(py::init<>())
        .def("go",    &Animal::go)
        .def("clone", &Animal::clone)
	;

	m.def("clone_and_call_go", &clone_and_call_go);

}

import argparse

import example

class Snake(example.Animal):
    def __init__(self, bug):
        #super().__init__()
        example.Animal.__init__(self)
        self.copies_ = []
        self.bug_ = bug

    def go(self, n_times):
        s = 'Snake.go({})'.format(n_times)
        print(s)
        return s

    def clone(self):
        print('Snake.clone!')
        copy = Snake(bug=self.bug_)
        if not self.bug_:
            self.copies_.append(copy)
        return copy



if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--bug", action="store_true", help="Disables the workaround, showcases the bug")
    args = parser.parse_args()


    a = Snake(args.bug)

    example.clone_and_call_go(a)

[lyskov]

This issue might be possible duplicate of #1389

[EricCousineau-TRI]

Yup, most def. a duplicate of #1333 / #1389. Closing in lieu of #1333 as the tracking issue.

Feel free to reopen if you think this is a unique case!