Avoid dynamic allocation and non-trivial destruction

... by using an std::array for the slots.

Author: b-pass

include/pybind11/detail/common.h

@@ -447,16 +447,16 @@ PYBIND11_WARNING_PUSH
 PYBIND11_WARNING_DISABLE_CLANG("-Wgnu-zero-variadic-macro-arguments")
 #define PYBIND11_MODULE(name, variable, ...)                                                      \
     static ::pybind11::module_::module_def PYBIND11_CONCAT(pybind11_module_def_, name);           \
-    static std::vector<PyModuleDef_Slot> PYBIND11_CONCAT(pybind11_module_slots_, name);           \
+    static ::pybind11::module_::slots_array PYBIND11_CONCAT(pybind11_module_slots_, name);        \
     static int PYBIND11_CONCAT(pybind11_exec_, name)(PyObject *);                                 \
     static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &);                     \
     PYBIND11_PLUGIN_IMPL(name) {                                                                  \
         PYBIND11_CHECK_PYTHON_VERSION                                                             \
         PYBIND11_ENSURE_INTERNALS_READY                                                           \
         auto &slots = PYBIND11_CONCAT(pybind11_module_slots_, name);                              \
-        slots.clear();                                                                            \
-        slots.emplace_back(PyModuleDef_Slot{                                                      \
-            Py_mod_exec, reinterpret_cast<void *>(&PYBIND11_CONCAT(pybind11_exec_, name))});      \
+        slots[0]                                                                                  \
+            = {Py_mod_exec, reinterpret_cast<void *>(&PYBIND11_CONCAT(pybind11_exec_, name))};    \
+        slots[1] = {0, nullptr};                                                                  \
         auto m = ::pybind11::module_::initialize_multiphase_module_def(                           \
             PYBIND11_TOSTRING(name),                                                              \
             nullptr,                                                                              \

include/pybind11/pybind11.h

@@ -1406,33 +1406,46 @@ class module_ : public object {
         return reinterpret_borrow<module_>(m);
     }
 
+    /// Must be a POD type, and must hold enough entries for all of the possible slots PLUS ONE for
+    /// the sentinel (0) end slot.
+    using slots_array = std::array<PyModuleDef_Slot, 4>;
+
     /** \rst
         Initialized a module def for use with multi-phase module initialization.
 
         ``def`` should point to a statically allocated module_def.
         ``slots`` must already contain a Py_mod_exec or Py_mod_create slot and will be filled with
-            additional slots (and the empty terminator slot) from the supplied options.
+            additional slots from the supplied options (and the empty sentinel slot).
     \endrst */
     template <typename... Options>
     static object initialize_multiphase_module_def(const char *name,
                                                    const char *doc,
                                                    module_def *def,
-                                                   std::vector<PyModuleDef_Slot> &slots,
+                                                   slots_array &slots,
                                                    Options &&...options) {
-        // remove zero end sentinel, if present
-        while (!slots.empty() && slots.back().slot == 0) {
-            slots.pop_back();
+        size_t next_slot = 0;
+        size_t term_slot = slots.size() - 1;
+
+        // find the end of the supplied slots
+        while (next_slot < term_slot && slots[next_slot].slot != 0) {
+            ++next_slot;
         }
 
         bool nogil PYBIND11_MAYBE_UNUSED = detail::gil_not_used_option(options...);
         if (nogil) {
 #if defined(Py_mod_gil) && defined(Py_GIL_DISABLED)
-            slots.emplace_back(PyModuleDef_Slot{Py_mod_gil, Py_MOD_GIL_NOT_USED});
+            if (next_slot >= term_slot) {
+                pybind11_fail("initialize_multiphase_module_def: not enough space in slots");
+            }
+            slots[next_slot++] = {Py_mod_gil, Py_MOD_GIL_NOT_USED});
 #endif
         }
 
-        // must have a zero end sentinel
-        slots.emplace_back(PyModuleDef_Slot{0, nullptr});
+        // slots must have a zero end sentinel
+        if (next_slot > term_slot) {
+            pybind11_fail("initialize_multiphase_module_def: not enough space in slots");
+        }
+        slots[next_slot++] = {0, nullptr};
 
         // module_def is PyModuleDef
         // Placement new (not an allocation).
@@ -1442,7 +1455,7 @@ class module_ : public object {
                         /* m_doc */ options::show_user_defined_docstrings() ? doc : nullptr,
                         /* m_size */ 0,
                         /* m_methods */ nullptr,
-                        /* m_slots */ slots.data(),
+                        /* m_slots */ &slots[0],
                         /* m_traverse */ nullptr,
                         /* m_clear */ nullptr,
                         /* m_free */ nullptr};