be more tolerant of duplicate type bindings

docs/api_core.rst

@@ -1535,13 +1535,24 @@ Class binding
 
 .. cpp:class:: template <typename T, typename... Ts> class_ : public object
 
-   Binding helper class to expose a custom C++ type `T` (declared using either the ``class`` or ``struct`` keyword)
-   in Python.
+   Binding helper class to expose a custom C++ type `T` (declared using either
+   the ``class`` or ``struct`` keyword) in Python.
 
    The variable length parameter `Ts` is optional and  can be used to specify
    the base class of `T` and/or an alias needed to realize :ref:`trampoline
    classes <trampolines>`.
 
+   When the type ``T`` was previously already registered (either within the
+   same extension or another extension), the the ``class_<..>`` declaration is
+   redundant. nanobind will print a warning message in this case:
+
+   .. code-block:: text
+
+      RuntimeWarning: nanobind: type 'MyType' was already registered!
+
+   The ``class_<..>`` instance will subsequently wrap the original type object
+   instead of creating a new one.
+
    .. cpp:function:: template <typename... Extra> class_(handle scope, const char * name, const Extra &... extra)
 
       Bind the type `T` to the identifier `name` within the scope `scope`. The

src/nb_func.cpp

@@ -701,7 +701,7 @@ static PyObject *nb_func_vectorcall_simple(PyObject *self,
     PyObject *result = nullptr,
              *self_arg = (is_method && nargs_in > 0) ? args_in[0] : nullptr;
 
-    /// Small array holding temporaries (implicit conversion/*args/**kwargs)
+    // Small array holding temporaries (implicit conversion/*args/**kwargs)
     cleanup_list cleanup(self_arg);
 
     // Handler routine that will be invoked in case of an error condition

src/nb_type.cpp

@@ -669,6 +669,16 @@ PyObject *nb_type_new(const type_init_data *t) noexcept {
     object modname;
     PyObject *mod = nullptr;
 
+    // Update hash table that maps from std::type_info to Python type
+    auto [it, success] =
+        internals.type_c2p.try_emplace(std::type_index(*t->type), nullptr);
+    if (!success) {
+        PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "nanobind: type '%s' was already registered!\n", t->name);
+        PyObject *tp = (PyObject *) it->second->type_py;
+        Py_INCREF(tp);
+        return tp;
+    }
+
     if (t->scope != nullptr) {
         if (PyModule_Check(t->scope)) {
             mod = t->scope;
@@ -850,12 +860,7 @@ PyObject *nb_type_new(const type_init_data *t) noexcept {
     if (modname.is_valid())
         setattr(result, "__module__", modname.ptr());
 
-    // Update hash table that maps from std::type_info to Python type
-    auto [it, success] =
-        internals.type_c2p.try_emplace(std::type_index(*t->type), to);
-    if (!success)
-        fail("nanobind::detail::nb_type_new(\"%s\"): type was already "
-             "registered!", t->name);
+    internals.type_c2p[std::type_index(*t->type)] = to;
 
     return result;
 }