Store load member function pointer in typeinfo for module-local types

Simplifies the storage in the python type slightly by just storing the
type_info pointer in a capsule (rather than a tuple/pair of capsules).
This also avoids the need for an intermediate function to call the
member function: the member function pointer can't be stored in a `void
*` (and thus not a capsule), but it *can* be stored in the `type_info`.

Author: jagerman

include/pybind11/cast.h

@@ -51,6 +51,7 @@ struct type_info {
     std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
     buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
     void *get_buffer_data = nullptr;
+    bool (type_caster_generic::*module_local_load)(handle, bool) = nullptr;
     /* A simple type never occurs as a (direct or indirect) parent
      * of a class that makes use of multiple inheritance */
     bool simple_type : 1;
@@ -693,16 +694,6 @@ class type_caster_generic {
     }
     void check_holder_compat() {}
 
-public:
-    // Helper to invoke a local `load` on a foreign-module type_caster_generic object.  A reference
-    // to this gets stashed in the type object of module-local types so that external types can call
-    // into the local module's type_caster_generic::load if their own types fail to load.
-    static bool local_load(void *caster_in, handle src) {
-        auto &caster = *reinterpret_cast<type_caster_generic *>(caster_in);
-        return caster.load(src, false);
-    }
-
-protected:
     // If loading failed with the type visible to this module see if we can load by looking to
     // other modules.  There are two possibilities here:
     // - the input type is actually for another module's `py::module_local` type; we can try getting
@@ -712,16 +703,14 @@ class type_caster_generic {
     PYBIND11_NOINLINE bool try_external_load(handle src) {
         allow_externals = true; // Don't recurse
 
-        str local_key("_pybind11_module_local_data");
+        str local_key("_pybind11_module_local_typeinfo");
         if (hasattr((PyObject *) Py_TYPE(src.ptr()), local_key)) {
-            tuple t = reinterpret_borrow<tuple>(getattr(src, local_key));
-            type_info *foreign_typeinfo = reinterpret_borrow<capsule>(t[0]);
-            auto foreign_load = reinterpret_cast<bool (*)(void *, handle)>((void *) reinterpret_borrow<capsule>(t[1]));
+            type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(src, local_key));
 
             // Only consider this foreign loader if actually foreign
-            if (foreign_load != &type_caster_generic::local_load) {
+            if (foreign_typeinfo->module_local_load != &type_caster_generic::load) {
                 typeinfo = foreign_typeinfo;
-                return foreign_load(this, src);
+                return (this->*(foreign_typeinfo->module_local_load))(src, false);
             }
             return false;
         }

include/pybind11/pybind11.h

@@ -868,13 +868,10 @@ class generic_type : public object {
         }
 
         if (rec.module_local) {
-            // Stash a pointer to the local module's type_caster_generic::local_load so that
-            // external modules can get at our `load` to try loading a C++ type from our local
-            // Python type.
-            tuple t(2);
-            t[0] = capsule(tinfo);
-            t[1] = capsule((void *) &type_caster_generic::local_load);
-            setattr(m_ptr, "_pybind11_module_local_data", t);
+            // Stash a capsule containing the local module's typeinfo so that external modules can
+            // get at our type loader to try loading a C++ type from our module-local Python type.
+            tinfo->module_local_load = &type_caster_generic::load;
+            setattr(m_ptr, "_pybind11_module_local_typeinfo", capsule(tinfo));
         }
     }