Disallow inheriting from multiple C++ bases in Python

* Also rename `pybind11_init` in `class_support.h` to avoid ambiguity
with the one in `common.h`.

* Make `py::metaclass` constructor explicit.

Author: dean0x7d

include/pybind11/attr.h

@@ -61,7 +61,7 @@ struct metaclass {
     metaclass() = default;
 
     /// Override pybind11's default metaclass
-    metaclass(handle value) : value(value) { }
+    explicit metaclass(handle value) : value(value) { }
 };
 
 /// Annotation to mark enums as an arithmetic type

include/pybind11/class_support.h

@@ -85,6 +85,34 @@ inline PyTypeObject *make_static_property_type() {
 
 #endif // PYPY
 
+/** Inheriting from multiple C++ types in Python is not supported -- set an error instead.
+    A Python definition (`class C(A, B): pass`) will call `tp_new` so we check for multiple
+    C++ bases here. On the other hand, C++ type definitions (`py::class_<C, A, B>(m, "C")`)
+    don't not use `tp_new` and will not trigger this error. */
+extern "C" inline PyObject *pybind11_meta_new(PyTypeObject *metaclass, PyObject *args,
+                                              PyObject *kwargs) {
+    PyObject *bases = PyTuple_GetItem(args, 1); // arguments: (name, bases, dict)
+    if (!bases)
+        return nullptr;
+
+    auto &internals = get_internals();
+    auto num_cpp_bases = 0;
+    for (auto base : reinterpret_borrow<tuple>(bases)) {
+        auto base_type = (PyTypeObject *) base.ptr();
+        auto instance_size = static_cast<size_t>(base_type->tp_basicsize);
+        if (PyObject_IsSubclass(base.ptr(), internals.get_base(instance_size)))
+            ++num_cpp_bases;
+    }
+
+    if (num_cpp_bases > 1) {
+        PyErr_SetString(PyExc_TypeError, "Can't inherit from multiple C++ classes in Python."
+                                         "Use py::class_ to define the class in C++ instead.");
+        return nullptr;
+    } else {
+        return PyType_Type.tp_new(metaclass, args, kwargs);
+    }
+}
+
 /** Types with static properties need to handle `Type.static_prop = x` in a specific way.
     By default, Python replaces the `static_property` itself, but for wrapped C++ types
     we need to call `static_property.__set__()` in order to propagate the new value to
@@ -135,6 +163,8 @@ inline PyTypeObject* make_default_metaclass() {
     type->tp_name = name;
     type->tp_base = &PyType_Type;
     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
+
+    type->tp_new = pybind11_meta_new;
     type->tp_setattro = pybind11_meta_setattro;
 
     if (PyType_Ready(type) < 0)
@@ -145,7 +175,7 @@ inline PyTypeObject* make_default_metaclass() {
 
 /// Instance creation function for all pybind11 types. It only allocates space for the
 /// C++ object, but doesn't call the constructor -- an `__init__` function must do that.
-extern "C" inline PyObject *pybind11_new(PyTypeObject *type, PyObject *, PyObject *) {
+extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) {
     PyObject *self = type->tp_alloc(type, 0);
     auto instance = (instance_essentials<void> *) self;
     auto tinfo = get_type_info(type);
@@ -159,7 +189,7 @@ extern "C" inline PyObject *pybind11_new(PyTypeObject *type, PyObject *, PyObjec
 /// An `__init__` function constructs the C++ object. Users should provide at least one
 /// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the
 /// following default function will be used which simply throws an exception.
-extern "C" inline int pybind11_init(PyObject *self, PyObject *, PyObject *) {
+extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
     PyTypeObject *type = Py_TYPE(self);
     std::string msg;
 #if defined(PYPY_VERSION)
@@ -173,7 +203,7 @@ extern "C" inline int pybind11_init(PyObject *self, PyObject *, PyObject *) {
 
 /// Instance destructor function for all pybind11 types. It calls `type_info.dealloc`
 /// to destroy the C++ object itself, while the rest is Python bookkeeping.
-extern "C" inline void pybind11_dealloc(PyObject *self) {
+extern "C" inline void pybind11_object_dealloc(PyObject *self) {
     auto instance = (instance_essentials<void> *) self;
     if (instance->value) {
         auto type = Py_TYPE(self);
@@ -190,7 +220,7 @@ extern "C" inline void pybind11_dealloc(PyObject *self) {
             }
         }
         if (!found)
-            pybind11_fail("pybind11_dealloc(): Tried to deallocate unregistered instance!");
+            pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
 
         if (instance->weakrefs)
             PyObject_ClearWeakRefs(self);
@@ -230,9 +260,9 @@ inline PyObject *make_object_base_type(size_t instance_size) {
     type->tp_basicsize = static_cast<ssize_t>(instance_size);
     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
 
-    type->tp_new = pybind11_new;
-    type->tp_init = pybind11_init;
-    type->tp_dealloc = pybind11_dealloc;
+    type->tp_new = pybind11_object_new;
+    type->tp_init = pybind11_object_init;
+    type->tp_dealloc = pybind11_object_dealloc;
 
     /* Support weak references (needed for the keep_alive feature) */
     type->tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
@@ -429,7 +459,7 @@ inline PyObject* make_new_python_type(const type_record &rec) {
         type->tp_bases = bases.release().ptr();
 
     /* Don't inherit base __init__ */
-    type->tp_init = pybind11_init;
+    type->tp_init = pybind11_object_init;
 
     /* Supported protocols */
     type->tp_as_number = &heap_type->as_number;

tests/test_multiple_inheritance.py

@@ -52,6 +52,17 @@ def __init__(self, i, j):
     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