Avoid recreating internals during type dealloc

Introduce a non-creating internals lookup and use it in
pybind11_meta_dealloc so teardown paths don’t accidentally rebuild
internals and their static types during Py_EndInterpreter. This prevents
with_internals from triggering make_static_property_type while the
interpreter is finalizing, which heaptrack showed as leaked allocations.

Changes:
- add is_interpreter_finalizing() helper
- add internals_pp_manager::get_pp_if_exists() and a state-dict lookup
  helper that does not create capsules
- switch reset() to use the non-creating lookup
- update pybind11_meta_dealloc to operate only when internals exist,
  avoiding implicit internals creation during GC/finalization

This reduces the leaked allocations tied to pybind11_meta_dealloc and
keeps teardown from reinitializing internals after they were reset.

Author: rwgk

include/pybind11/detail/class.h

@@ -207,49 +207,64 @@ extern "C" inline PyObject *pybind11_meta_call(PyObject *type, PyObject *args, P
 
 /// Cleanup the type-info for a pybind11-registered type.
 extern "C" inline void pybind11_meta_dealloc(PyObject *obj) {
-    with_internals([obj](internals &internals) {
-        auto *type = (PyTypeObject *) obj;
-
-        // A pybind11-registered type will:
-        // 1) be found in internals.registered_types_py
-        // 2) have exactly one associated `detail::type_info`
-        auto found_type = internals.registered_types_py.find(type);
-        if (found_type != internals.registered_types_py.end() && found_type->second.size() == 1
-            && found_type->second[0]->type == type) {
-
-            auto *tinfo = found_type->second[0];
-            auto tindex = std::type_index(*tinfo->cpptype);
-            internals.direct_conversions.erase(tindex);
-
-            auto &local_internals = get_local_internals();
-            if (tinfo->module_local) {
-                local_internals.registered_types_cpp.erase(tinfo->cpptype);
-            } else {
-                internals.registered_types_cpp.erase(tindex);
-#if PYBIND11_INTERNALS_VERSION >= 12
-                internals.registered_types_cpp_fast.erase(tinfo->cpptype);
-                for (const std::type_info *alias : tinfo->alias_chain) {
-                    auto num_erased = internals.registered_types_cpp_fast.erase(alias);
-                    (void) num_erased;
-                    assert(num_erased > 0);
-                }
-#endif
+    if (is_interpreter_finalizing()) {
+        PyType_Type.tp_dealloc(obj);
+        return;
+    }
+
+    auto *internals_pp = get_internals_pp_manager().get_pp_if_exists();
+    if (!internals_pp || internals_pp->get() == nullptr) {
+        PyType_Type.tp_dealloc(obj);
+        return;
+    }
+
+    auto &internals = *internals_pp->get();
+    PYBIND11_LOCK_INTERNALS(internals);
+
+    auto *type = (PyTypeObject *) obj;
+
+    // A pybind11-registered type will:
+    // 1) be found in internals.registered_types_py
+    // 2) have exactly one associated `detail::type_info`
+    auto found_type = internals.registered_types_py.find(type);
+    if (found_type != internals.registered_types_py.end() && found_type->second.size() == 1
+        && found_type->second[0]->type == type) {
+
+        auto *tinfo = found_type->second[0];
+        auto tindex = std::type_index(*tinfo->cpptype);
+        internals.direct_conversions.erase(tindex);
+
+        auto *local_internals_pp = get_local_internals_pp_manager().get_pp_if_exists();
+        auto *local_internals_ptr = local_internals_pp ? local_internals_pp->get() : nullptr;
+        if (tinfo->module_local) {
+            if (local_internals_ptr) {
+                local_internals_ptr->registered_types_cpp.erase(tinfo->cpptype);
             }
-            internals.registered_types_py.erase(tinfo->type);
-
-            // Actually just `std::erase_if`, but that's only available in C++20
-            auto &cache = internals.inactive_override_cache;
-            for (auto it = cache.begin(), last = cache.end(); it != last;) {
-                if (it->first == (PyObject *) tinfo->type) {
-                    it = cache.erase(it);
-                } else {
-                    ++it;
-                }
+        } else {
+            internals.registered_types_cpp.erase(tindex);
+#if PYBIND11_INTERNALS_VERSION >= 12
+            internals.registered_types_cpp_fast.erase(tinfo->cpptype);
+            for (const std::type_info *alias : tinfo->alias_chain) {
+                auto num_erased = internals.registered_types_cpp_fast.erase(alias);
+                (void) num_erased;
+                assert(num_erased > 0);
             }
+#endif
+        }
+        internals.registered_types_py.erase(tinfo->type);
 
-            delete tinfo;
+        // Actually just `std::erase_if`, but that's only available in C++20
+        auto &cache = internals.inactive_override_cache;
+        for (auto it = cache.begin(), last = cache.end(); it != last;) {
+            if (it->first == (PyObject *) tinfo->type) {
+                it = cache.erase(it);
+            } else {
+                ++it;
+            }
         }
-    });
+
+        delete tinfo;
+    }
 
     PyType_Type.tp_dealloc(obj);
 }

include/pybind11/detail/internals.h

@@ -203,6 +203,14 @@ inline bool is_interpreter_alive() {
 #endif
 }
 
+inline bool is_interpreter_finalizing() {
+#if PY_VERSION_HEX < 0x030D0000
+    return _Py_IsFinalizing() != 0;
+#else
+    return Py_IsFinalizing() != 0;
+#endif
+}
+
 #ifdef Py_GIL_DISABLED
 // Wrapper around PyMutex to provide BasicLockable semantics
 class pymutex {
@@ -707,6 +715,26 @@ class internals_pp_manager {
         return internals_singleton_pp_;
     }
 
+    /// Get the current pointer-to-pointer if it already exists, without creating it.
+    std::unique_ptr<InternalsType> *get_pp_if_exists() {
+#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+        if (has_seen_non_main_interpreter()) {
+            auto *tstate = get_thread_state_unchecked();
+            if (tstate && tstate->interp != last_istate_tls()) {
+                gil_scoped_acquire_simple gil;
+                last_istate_tls() = tstate->interp;
+                internals_p_tls() = get_pp_from_state_dict_if_exists();
+            }
+            return internals_p_tls();
+        }
+#endif
+        if (!internals_singleton_pp_) {
+            gil_scoped_acquire_simple gil;
+            internals_singleton_pp_ = get_pp_from_state_dict_if_exists();
+        }
+        return internals_singleton_pp_;
+    }
+
     /// Drop all the references we're currently holding.
     void unref() {
 #ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
@@ -728,23 +756,10 @@ class internals_pp_manager {
             gil_scoped_acquire_simple gil;
             auto *tstate = get_thread_state_unchecked();
             if (tstate) {
-                try {
-                    // Get the capsule directly from the state dict and reset the unique_ptr
-                    auto state_dict = reinterpret_borrow<dict>(get_python_state_dict());
-                    PyObject *capsule_obj = dict_getitemstring(state_dict.ptr(), holder_id_);
-                    if (capsule_obj) {
-                        void *raw_ptr = PyCapsule_GetPointer(capsule_obj, /*name=*/nullptr);
-                        if (raw_ptr) {
-                            auto *pp = static_cast<std::unique_ptr<InternalsType> *>(raw_ptr);
-                            if (pp && pp->get() != nullptr) {
-                                // Only reset if the unique_ptr actually contains an object
-                                pp->reset();
-                            }
-                        }
-                    }
-                } catch (...) {
-                    // If we can't get the state dict or capsule, silently continue
-                    // The capsule destructor will clean up eventually
+                auto *pp = get_pp_from_state_dict_if_exists();
+                if (pp && pp->get() != nullptr) {
+                    // Only reset if the unique_ptr actually contains an object
+                    pp->reset();
                 }
             }
             return;
@@ -810,6 +825,30 @@ class internals_pp_manager {
         return pp;
     }
 
+    std::unique_ptr<InternalsType> *get_pp_from_state_dict_if_exists() {
+        error_scope err_scope; // preserve any existing Python error states
+        try {
+            auto state_dict = reinterpret_borrow<dict>(get_python_state_dict());
+            PyObject *capsule_obj = dict_getitemstring(state_dict.ptr(), holder_id_);
+            if (capsule_obj == nullptr) {
+                if (PyErr_Occurred()) {
+                    PyErr_Clear();
+                }
+                return nullptr;
+            }
+            void *raw_ptr = PyCapsule_GetPointer(capsule_obj, /*name=*/nullptr);
+            if (!raw_ptr) {
+                if (PyErr_Occurred()) {
+                    PyErr_Clear();
+                }
+                return nullptr;
+            }
+            return static_cast<std::unique_ptr<InternalsType> *>(raw_ptr);
+        } catch (const error_already_set &) {
+            return nullptr;
+        }
+    }
+
 #ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
     static PyInterpreterState *&last_istate_tls() {
         static thread_local PyInterpreterState *last_istate = nullptr;