fix: Make non-embedded module clear their locals before deallocation

include/pybind11/detail/internals.h

@@ -510,11 +510,19 @@ struct local_internals {
 };
 
 /// Works like `get_internals`, but for things which are locally registered.
+/// There is one variable storing the local internals for each module, but every embedded module
+/// shares the same locals.
 inline local_internals &get_local_internals() {
     static local_internals locals;
     return locals;
 }
 
+/// Clears the locally registered types and exception translators.
+inline void clear_local_internals() {
+    detail::get_local_internals().registered_types_cpp.clear();
+    detail::get_local_internals().registered_exception_translators.clear();
+}
+
 /// Constructs a std::string with the given arguments, stores it in `internals`, and returns its
 /// `c_str()`.  Such strings objects have a long storage duration -- the internal strings are only
 /// cleared when the program exits or after interpreter shutdown (when embedding), and so are

include/pybind11/embed.h

@@ -42,7 +42,7 @@
     static ::pybind11::module_::module_def PYBIND11_CONCAT(pybind11_module_def_, name);           \
     static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &);                     \
     static PyObject PYBIND11_CONCAT(*pybind11_init_wrapper_, name)() {                            \
-        auto m = ::pybind11::module_::create_extension_module(                                    \
+        auto m = ::pybind11::module_::create_embedded_extension_module(                           \
             PYBIND11_TOSTRING(name), nullptr, &PYBIND11_CONCAT(pybind11_module_def_, name));      \
         try {                                                                                     \
             PYBIND11_CONCAT(pybind11_init_, name)(m);                                             \
@@ -200,8 +200,7 @@ inline void finalize_interpreter() {
     }
     // Local internals contains data managed by the current interpreter, so we must clear them to
     // avoid undefined behaviors when initializing another interpreter
-    detail::get_local_internals().registered_types_cpp.clear();
-    detail::get_local_internals().registered_exception_translators.clear();
+    detail::clear_local_internals();
 
     Py_Finalize();
 

include/pybind11/pybind11.h

@@ -1232,7 +1232,7 @@ class module_ : public object {
                         /* m_slots */ nullptr,
                         /* m_traverse */ nullptr,
                         /* m_clear */ nullptr,
-                        /* m_free */ nullptr};
+                        /* m_free */ [](void *) { detail::clear_local_internals(); }};
         auto *m = PyModule_Create(def);
         if (m == nullptr) {
             if (PyErr_Occurred()) {
@@ -1245,6 +1245,38 @@ class module_ : public object {
         //       For Python 2, reinterpret_borrow was correct.
         return reinterpret_borrow<module_>(m);
     }
+
+    /** \rst
+        Create a new top-level embedded module.
+
+        ``def`` should point to a statically allocated module_def.
+    \endrst */
+    static module_
+    create_embedded_extension_module(const char *name, const char *doc, module_def *def) {
+        // module_def is PyModuleDef
+        // Placement new (not an allocation).
+        def = new (def)
+            PyModuleDef{/* m_base */ PyModuleDef_HEAD_INIT,
+                        /* m_name */ name,
+                        /* m_doc */ options::show_user_defined_docstrings() ? doc : nullptr,
+                        /* m_size */ -1,
+                        /* m_methods */ nullptr,
+                        /* m_slots */ nullptr,
+                        /* m_traverse */ nullptr,
+                        /* m_clear */ nullptr,
+                        /* m_free */ nullptr};
+        auto *m = PyModule_Create(def);
+        if (m == nullptr) {
+            if (PyErr_Occurred()) {
+                throw error_already_set();
+            }
+            pybind11_fail("Internal error in module_::create_embedded_extension_module()");
+        }
+        // TODO: Should be reinterpret_steal for Python 3, but Python also steals it again when
+        //       returned from PyInit_...
+        //       For Python 2, reinterpret_borrow was correct.
+        return reinterpret_borrow<module_>(m);
+    }
 };
 
 // When inside a namespace (or anywhere as long as it's not the first item on a line),

tests/test_embed/external_module.cpp

@@ -13,7 +13,10 @@ PYBIND11_MODULE(external_module, m) {
         int v;
     };
 
+    class B {};
+
     py::class_<A>(m, "A").def(py::init<int>()).def_readwrite("value", &A::v);
+    py::class_<B>(m, "B", py::module_local());
 
     m.def("internals_at",
           []() { return reinterpret_cast<uintptr_t>(&py::detail::get_internals()); });