Throw TypeError when subclasses forget to call __init__

- Based on pybind/pybind11#2152
- Fixes #1210

Author: virtuald

src/nb_type.cpp

@@ -498,6 +498,68 @@ static int nb_type_init(PyObject *self, PyObject *args, PyObject *kwds) {
     return 0;
 }
 
+/// metaclass `__call__` function that is used to create all nanobind objects
+static PyObject *nb_type_call(PyObject *type, PyObject *args, PyObject *kwargs) {
+
+    // use the default metaclass call to create/initialize the object
+#if defined(Py_LIMITED_API)
+    PyObject *self = ((ternaryfunc)PyType_GetSlot(&PyType_Type, Py_tp_call))(type, args, kwargs);
+#else
+    PyObject *self = PyType_Type.tp_call(type, args, kwargs);
+#endif
+    if (self == nullptr) {
+        return nullptr;
+    }
+
+    // This must be a nanobind instance
+    nb_inst *inst = (nb_inst *) self;
+
+    // Walk through the MRO and check if all nanobind base classes are initialized
+    PyTypeObject *tp = (PyTypeObject *) type;
+#if defined(Py_LIMITED_API)
+    // In limited API, we must use __mro__ attribute instead of tp->tp_mro
+   PyObject *mro = PyObject_GetAttrString((PyObject *) tp, "__mro__");
+    if (!mro) {
+        Py_DECREF(self);
+        return nullptr;
+    }
+#else
+    PyObject *mro = tp->tp_mro;
+    if (!mro) {
+        Py_DECREF(self);
+        PyErr_SetString(PyExc_TypeError, "MRO is not available");
+        return nullptr;
+    }
+#endif
+
+    Py_ssize_t n = NB_TUPLE_GET_SIZE(mro);
+    for (Py_ssize_t i = 0; i < n; ++i) {
+        PyTypeObject *base = (PyTypeObject *) NB_TUPLE_GET_ITEM(mro, i);
+
+        // Check if this base is a nanobind type
+        if (!nb_type_check((PyObject *) base))
+            continue;
+
+        // For each nanobind base, check if it's initialized
+        if (inst->state == nb_inst::state_uninitialized) {
+            const type_data *t = nb_type_data(Py_TYPE(self));
+            PyErr_Format(PyExc_TypeError,
+                        "%.200s.__init__() must be called when overriding __init__",
+                        t->name);
+            #if defined(Py_LIMITED_API)
+                Py_DECREF(mro);
+            #endif
+            Py_DECREF(self);
+            return nullptr;
+        }
+    }
+
+    #if defined(Py_LIMITED_API)
+        Py_DECREF(mro);
+    #endif
+    return self;
+}
+
 /// Special case to handle 'Class.property = value' assignments
 int nb_type_setattro(PyObject* obj, PyObject* name, PyObject* value) {
     nb_internals *int_p = internals;
@@ -861,6 +923,7 @@ static PyTypeObject *nb_type_tp(size_t supplement) noexcept {
             { Py_tp_dealloc, (void *) nb_type_dealloc },
             { Py_tp_setattro, (void *) nb_type_setattro },
             { Py_tp_init, (void *) nb_type_init },
+            { Py_tp_call, (void *) nb_type_call },
 #if defined(Py_LIMITED_API)
             { Py_tp_members, (void *) members },
 #endif

tests/test_classes.py

@@ -256,13 +256,9 @@ def name(self):
         def what(self):
             return "b"
 
-    with pytest.warns(
-        RuntimeWarning,
-        match="nanobind: attempted to access an uninitialized instance of type",
-    ):
-        with pytest.raises(TypeError) as excinfo:
-            t.go(Incomplete2())
-    assert "incompatible function arguments" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        Incomplete2()
+    assert "__init__() must be called when overriding __init__" in str(excinfo.value)
 
 
 def test12_large_pointers():