Make all classes with the same instance size derive from a common base

In order to fully satisfy Python's inheritance type layout requirements,
all types should have a common 'solid' base. A solid base is one which
has the same instance size as the derived type (not counting the space
required for the optional `dict_ptr` and `weakrefs_ptr`). Thus, `object`
does not qualify as a solid base for pybind11 types and this can lead to
issues with multiple inheritance.

To get around this, new base types are created: one per unique instance
size. There is going to be very few of these bases. They ensure Python's
MRO checks will pass when multiple bases are involved.

include/pybind11/cast.h

@@ -26,6 +26,7 @@ struct type_info {
     PyTypeObject *type;
     size_t type_size;
     void (*init_holder)(PyObject *, const void *);
+    void (*dealloc)(PyObject *);
     std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
     std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
     std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;

include/pybind11/common.h

@@ -122,7 +122,6 @@
 #define PYBIND11_SLICE_OBJECT PyObject
 #define PYBIND11_FROM_STRING PyUnicode_FromString
 #define PYBIND11_STR_TYPE ::pybind11::str
-#define PYBIND11_OB_TYPE(ht_type) (ht_type).ob_base.ob_base.ob_type
 #define PYBIND11_PLUGIN_IMPL(name) \
     extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
 #else
@@ -141,7 +140,6 @@
 #define PYBIND11_SLICE_OBJECT PySliceObject
 #define PYBIND11_FROM_STRING PyString_FromString
 #define PYBIND11_STR_TYPE ::pybind11::bytes
-#define PYBIND11_OB_TYPE(ht_type) (ht_type).ob_type
 #define PYBIND11_PLUGIN_IMPL(name) \
     static PyObject *pybind11_init_wrapper();               \
     extern "C" PYBIND11_EXPORT void init##name() {          \
@@ -363,10 +361,14 @@ struct internals {
     std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across extensions
     PyTypeObject *static_property_type;
     PyTypeObject *default_metaclass;
+    std::unordered_map<size_t, PyObject *> bases; // one base type per `instance_size` (very few)
 #if defined(WITH_THREAD)
     decltype(PyThread_create_key()) tstate = 0; // Usually an int but a long on Cygwin64 with Python 3.x
     PyInterpreterState *istate = nullptr;
 #endif
+
+    /// Return the appropriate base type for the given instance size
+    PyObject *get_base(size_t instance_size);
 };
 
 /// Return a reference to the current 'internals' information

tests/test_inheritance.cpp

@@ -36,6 +36,10 @@ public:
     Hamster(const std::string &name) : Pet(name, "rodent") {}
 };
 
+class Chimera : public Pet {
+    Chimera() : Pet("Kimmy", "chimera") {}
+};
+
 std::string pet_name_species(const Pet &pet) {
     return pet.name() + " is a " + pet.species();
 }
@@ -74,6 +78,8 @@ test_initializer inheritance([](py::module &m) {
     py::class_<Hamster, Pet>(m, "Hamster")
         .def(py::init<std::string>());
 
+    py::class_<Chimera, Pet>(m, "Chimera");
+
     m.def("pet_name_species", pet_name_species);
     m.def("dog_bark", dog_bark);
 

tests/test_inheritance.py

@@ -2,7 +2,7 @@ import pytest
 
 
 def test_inheritance(msg):
-    from pybind11_tests import Pet, Dog, Rabbit, Hamster, dog_bark, pet_name_species
+    from pybind11_tests import Pet, Dog, Rabbit, Hamster, Chimera, dog_bark, pet_name_species
 
     roger = Rabbit('Rabbit')
     assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot"
@@ -30,6 +30,10 @@ def test_inheritance(msg):
         Invoked with: <m.Pet object at 0>
     """
 
+    with pytest.raises(TypeError) as excinfo:
+        Chimera("lion", "goat")
+    assert "No constructor defined!" in str(excinfo.value)
+
 
 def test_automatic_upcasting():
     from pybind11_tests import return_class_1, return_class_2, return_class_n, return_none

tests/test_multiple_inheritance.cpp

@@ -81,3 +81,73 @@ test_initializer multiple_inheritance_nonexplicit([](py::module &m) {
     m.def("bar_base2a", [](Base2a *b) { return b->bar(); });
     m.def("bar_base2a_sharedptr", [](std::shared_ptr<Base2a> b) { return b->bar(); });
 });
+
+struct Vanilla {
+    std::string vanilla() { return "Vanilla"; };
+};
+
+struct WithStatic1 {
+    static std::string static_func1() { return "WithStatic1"; };
+    static int static_value1;
+};
+
+struct WithStatic2 {
+    static std::string static_func2() { return "WithStatic2"; };
+    static int static_value2;
+};
+
+struct WithDict { };
+
+struct VanillaStaticMix1 : Vanilla, WithStatic1, WithStatic2 {
+    static std::string static_func() { return "VanillaStaticMix1"; }
+    static int static_value;
+};
+
+struct VanillaStaticMix2 : WithStatic1, Vanilla, WithStatic2 {
+    static std::string static_func() { return "VanillaStaticMix2"; }
+    static int static_value;
+};
+
+struct VanillaDictMix1 : Vanilla, WithDict { };
+struct VanillaDictMix2 : WithDict, Vanilla { };
+
+int WithStatic1::static_value1 = 1;
+int WithStatic2::static_value2 = 2;
+int VanillaStaticMix1::static_value = 12;
+int VanillaStaticMix2::static_value = 12;
+
+test_initializer mi_static_properties([](py::module &pm) {
+    auto m = pm.def_submodule("mi");
+
+    py::class_<Vanilla>(m, "Vanilla")
+        .def(py::init<>())
+        .def("vanilla", &Vanilla::vanilla);
+
+    py::class_<WithStatic1>(m, "WithStatic1", py::metaclass())
+        .def(py::init<>())
+        .def_static("static_func1", &WithStatic1::static_func1)
+        .def_readwrite_static("static_value1", &WithStatic1::static_value1);
+
+    py::class_<WithStatic2>(m, "WithStatic2", py::metaclass())
+        .def(py::init<>())
+        .def_static("static_func2", &WithStatic2::static_func2)
+        .def_readwrite_static("static_value2", &WithStatic2::static_value2);
+
+    py::class_<VanillaStaticMix1, Vanilla, WithStatic1, WithStatic2>(
+        m, "VanillaStaticMix1", py::metaclass())
+        .def(py::init<>())
+        .def_static("static_func", &VanillaStaticMix1::static_func)
+        .def_readwrite_static("static_value", &VanillaStaticMix1::static_value);
+
+    py::class_<VanillaStaticMix2, WithStatic1, Vanilla, WithStatic2>(
+        m, "VanillaStaticMix2", py::metaclass())
+        .def(py::init<>())
+        .def_static("static_func", &VanillaStaticMix2::static_func)
+        .def_readwrite_static("static_value", &VanillaStaticMix2::static_value);
+
+#if !defined(PYPY_VERSION)
+    py::class_<WithDict>(m, "WithDict", py::dynamic_attr()).def(py::init<>());
+    py::class_<VanillaDictMix1, Vanilla, WithDict>(m, "VanillaDictMix1").def(py::init<>());
+    py::class_<VanillaDictMix2, WithDict, Vanilla>(m, "VanillaDictMix2").def(py::init<>());
+#endif
+});

tests/test_multiple_inheritance.py

+import pytest
+
+
 def test_multiple_inheritance_cpp():
     from pybind11_tests import MIType
 
@@ -49,6 +52,17 @@ def test_multiple_inheritance_mix2():
     assert mt.bar() == 4
 
 
+def test_multiple_inheritance_error():
+    """Inheriting from multiple C++ bases in Python is not supported"""
+    from pybind11_tests import Base1, Base2
+
+    with pytest.raises(TypeError) as excinfo:
+        # noinspection PyUnusedLocal
+        class MI(Base1, Base2):
+            pass
+    assert "Can't inherit from multiple C++ classes in Python" in str(excinfo.value)
+
+
 def test_multiple_inheritance_virtbase():
     from pybind11_tests import Base12a, bar_base2a, bar_base2a_sharedptr
 
@@ -60,3 +74,38 @@ def test_multiple_inheritance_virtbase():
     assert mt.bar() == 4
     assert bar_base2a(mt) == 4
     assert bar_base2a_sharedptr(mt) == 4
+
+
+def test_mi_static_properties():
+    """Mixing bases with and without static properties should be possible
+     and the result should be independent of base definition order"""
+    from pybind11_tests import mi
+
+    for d in (mi.VanillaStaticMix1(), mi.VanillaStaticMix2()):
+        assert d.vanilla() == "Vanilla"
+        assert d.static_func1() == "WithStatic1"
+        assert d.static_func2() == "WithStatic2"
+        assert d.static_func() == d.__class__.__name__
+
+        mi.WithStatic1.static_value1 = 1
+        mi.WithStatic2.static_value2 = 2
+        assert d.static_value1 == 1
+        assert d.static_value2 == 2
+        assert d.static_value == 12
+
+        d.static_value1 = 0
+        assert d.static_value1 == 0
+        d.static_value2 = 0
+        assert d.static_value2 == 0
+        d.static_value = 0
+        assert d.static_value == 0
+
+
+@pytest.unsupported_on_pypy
+def test_mi_dynamic_attributes():
+    """Mixing bases with and without dynamic attribute support"""
+    from pybind11_tests import mi
+
+    for d in (mi.VanillaDictMix1(), mi.VanillaDictMix2()):
+        d.dynamic = 1
+        assert d.dynamic == 1