Small tweaks and binary size reduction

* Remove recursion flag and extra typeinfo checks.

* Change loader from member function pointer to a regular
  function pointer for improved portability.

* Reduce binary size on clang.

Author: dean0x7d

include/pybind11/cast.h

@@ -51,7 +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;
+    void *(*module_local_load)(PyObject *, const type_info *) = 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;
@@ -586,6 +586,8 @@ class type_caster_generic {
     PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
      : typeinfo(get_type_info(type_info)) { }
 
+    type_caster_generic(const type_info *typeinfo) : typeinfo(typeinfo) { }
+
     bool load(handle src, bool convert) {
         return load_impl<type_caster_generic>(src, convert);
     }
@@ -663,8 +665,6 @@ class type_caster_generic {
         return inst.release();
     }
 
-protected:
-
     // Base methods for generic caster; there are overridden in copyable_holder_caster
     void load_value(value_and_holder &&v_h) {
         auto *&vptr = v_h.value_ptr();
@@ -694,35 +694,22 @@ class type_caster_generic {
     }
     void check_holder_compat() {}
 
-    // 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
-    //   the other module to load it.
-    // - the input type is a globally-registered type, but we failed to load it because we have a module-local
-    //   override; we can replace our typeinfo with the global typeinfo and try loading again.
-    PYBIND11_NOINLINE bool try_external_load(handle src) {
-        allow_externals = true; // Don't recurse
-
-        str local_key("_pybind11_module_local_typeinfo");
-        if (hasattr((PyObject *) Py_TYPE(src.ptr()), local_key)) {
-            type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(src, local_key));
-
-            // Only consider this foreign loader if actually foreign
-            if (foreign_typeinfo->module_local_load != &type_caster_generic::load) {
-                typeinfo = foreign_typeinfo;
-                return (this->*(foreign_typeinfo->module_local_load))(src, false);
-            }
+    /// Try to load with foreign typeinfo, if available. Used when there is no
+    /// native typeinfo, or when the native one wasn't able to produce a value.
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
+        constexpr auto *local_key = "_pybind11_module_local_typeinfo";
+        const auto pytype = src.get_type();
+        if (!hasattr(pytype, local_key))
             return false;
-        }
 
-        // The type is not module_local; if the type we looked up is, try again with the global type
-        if (typeinfo && typeinfo->module_local) {
-            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
-                typeinfo = gtype;
-                return load(src, false);
-            }
-        }
+        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
+        if (foreign_typeinfo == typeinfo)
+            return false; // Only consider this foreign loader if actually foreign
 
+        if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
+            value = result;
+            return true;
+        }
         return false;
     }
 
@@ -732,7 +719,7 @@ class type_caster_generic {
     template <typename ThisT>
     PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
         if (!src) return false;
-        if (!typeinfo) return allow_externals && try_external_load(src);
+        if (!typeinfo) return try_load_foreign_module_local(src);
         if (src.is_none()) {
             // Defer accepting None to other overloads (if we aren't in convert mode):
             if (!convert) return false;
@@ -798,7 +785,16 @@ class type_caster_generic {
                 return true;
         }
 
-        return allow_externals && try_external_load(src);
+        // Failed to match local typeinfo. Try again with global.
+        if (typeinfo->module_local) {
+            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
+                typeinfo = gtype;
+                return load(src, false);
+            }
+        }
+
+        // Global typeinfo has precedence over foreign module_local
+        return try_load_foreign_module_local(src);
     }
 
 
@@ -820,7 +816,6 @@ class type_caster_generic {
 
     const type_info *typeinfo = nullptr;
     void *value = nullptr;
-    bool allow_externals = true;
 };
 
 /**

include/pybind11/detail/common.h

@@ -355,9 +355,6 @@ enum class return_value_policy : uint8_t {
     reference_internal
 };
 
-// forward declaration:
-class handle;
-
 NAMESPACE_BEGIN(detail)
 
 inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); }
@@ -488,9 +485,6 @@ struct type_equal_to {
 template <typename value_type>
 using type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
 
-// forward declaration
-class type_caster_generic;
-
 /// Internal data structure used to track registered instances and types
 struct internals {
     type_map<void *> registered_types_cpp; // std::type_index -> type_info

include/pybind11/pybind11.h

@@ -868,9 +868,13 @@ class generic_type : public object {
         }
 
         if (rec.module_local) {
-            // 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;
+            // Stash the local typeinfo and loader so that external modules can access it.
+            tinfo->module_local_load = [](PyObject *src, const type_info *ti) -> void * {
+                auto caster = type_caster_generic(ti);
+                if (caster.load(src, false))
+                    return caster.value;
+                return nullptr;
+            };
             setattr(m_ptr, "_pybind11_module_local_typeinfo", capsule(tinfo));
         }
     }