Change some names containing 'foreign' to say 'interop' instead, so that we use 'foreign' specifically for types/frameworks that don't use our internals, rather than the concept of sharing with them

Author: oremanj

include/pybind11/detail/class.h

@@ -226,7 +226,7 @@ extern "C" inline void pybind11_meta_dealloc(PyObject *obj) {
             } else {
                 internals.registered_types_cpp.erase(tindex);
             }
-            get_foreign_internals().copy_move_ctors.erase(tindex);
+            get_interop_internals().copy_move_ctors.erase(tindex);
             internals.registered_types_py.erase(tinfo->type);
 
             // Actually just `std::erase_if`, but that's only available in C++20

include/pybind11/detail/common.h

@@ -354,7 +354,7 @@
 #define PYBIND11_ENSURE_INTERNALS_READY                                                           \
     {                                                                                             \
         pybind11::detail::get_internals_pp_manager().unref();                                     \
-        pybind11::detail::get_foreign_internals_pp_manager().unref();                             \
+        pybind11::detail::get_interop_internals_pp_manager().unref();                             \
         pybind11::detail::get_internals();                                                        \
     }
 

include/pybind11/detail/foreign.h

@@ -311,7 +311,7 @@ using copy_or_move_ctor = void *(*) (const void *);
 // version, it would be good for performance to also add a flag to `type_info`
 // indicating whether any foreign bindings are also known for its C++ type;
 // that way we can avoid an extra lookup when conversion to a native type fails.
-struct foreign_internals {
+struct interop_internals {
     // Registered foreign bindings for each C++ type.
     // Protected by internals::mutex.
     type_multimap<pymb_binding *> bindings;
@@ -337,34 +337,34 @@ struct foreign_internals {
     std::unique_ptr<pymb_framework> self;
 
     // Remember the C++ type associated with each binding by
-    // import_type_from_foreign(), so we can clean up `bindings` properly.
+    // import_for_interop(), so we can clean up `bindings` properly.
     // Protected by internals::mutex.
     std::unordered_map<pymb_binding *, const std::type_info *> manual_imports;
 
-    // Pointer to `detail::export_type_to_foreign` in foreign.h, or nullptr if
+    // Pointer to `detail::export_for_interop` in foreign.h, or nullptr if
     // export_all is false. This indirection is vital to avoid having every
     // compilation unit with a py::class_ pull in the callback methods in
     // foreign.h. Instead, only compilation units that call
-    // set_foreign_type_defaults(), import_foreign_type(), or
-    // export_type_to_foreign() will emit that code.
-    void (*export_type_to_foreign)(type_info *);
+    // interoperate_by_default(), import_for_interop(), or
+    // export_for_interop() will emit that code.
+    void (*export_for_interop)(type_info *);
 
     // Should we automatically advertise our types to other binding frameworks,
-    // or only when requested via pybind11::export_type_to_foreign()?
+    // or only when requested via pybind11::export_for_interop()?
     // Never becomes false once it is set to true.
     bool export_all = false;
 
     // Should we automatically use types advertised by other frameworks as
     // a fallback when we can't do a cast using pybind11 types, or only when
-    // requested via pybind11::import_foreign_type()?
+    // requested via pybind11::import_for_interop()?
     // Never becomes false once it is set to true.
     bool import_all = false;
 
     // Are there any entries in `bindings` that don't correspond to our
     // own types?
     bool imported_any = false;
 
-    inline ~foreign_internals();
+    inline ~interop_internals();
 
     // Returns true if we initialized, false if someone else already did.
     inline bool initialize_if_needed() {
@@ -778,17 +778,17 @@ inline auto with_exception_translators(const F &cb)
               local_internals.registered_exception_translators);
 }
 
-inline internals_pp_manager<foreign_internals> &get_foreign_internals_pp_manager() {
-    static internals_pp_manager<foreign_internals> foreign_internals_pp_manager(
-        PYBIND11_INTERNALS_ID "foreign", nullptr);
-    return foreign_internals_pp_manager;
+inline internals_pp_manager<interop_internals> &get_interop_internals_pp_manager() {
+    static internals_pp_manager<interop_internals> interop_internals_pp_manager(
+        PYBIND11_INTERNALS_ID "interop", nullptr);
+    return interop_internals_pp_manager;
 }
 
-inline foreign_internals &get_foreign_internals() {
-    auto &ppmgr = get_foreign_internals_pp_manager();
+inline interop_internals &get_interop_internals() {
+    auto &ppmgr = get_interop_internals_pp_manager();
     auto &ptr = *ppmgr.get_pp();
     if (!ptr) {
-        ptr.reset(new foreign_internals());
+        ptr.reset(new interop_internals());
     }
     return *ptr;
 }

include/pybind11/detail/internals.h

@@ -265,10 +265,10 @@ PYBIND11_NOINLINE handle get_type_handle(const std::type_info &tp,
         return handle((PyObject *) type_info->type);
     }
     if (foreign_ok) {
-        auto &foreign_internals = detail::get_foreign_internals();
-        if (foreign_internals.imported_any) {
+        auto &interop_internals = detail::get_interop_internals();
+        if (interop_internals.imported_any) {
             handle ret = with_internals([&](internals &) {
-                auto range = foreign_internals.bindings.equal_range(tp);
+                auto range = interop_internals.bindings.equal_range(tp);
                 if (range.first != range.second) {
                     return handle((PyObject *) range.first->second->pytype);
                 }
@@ -1052,7 +1052,7 @@ class type_caster_generic {
         if (!srcs.result.second) {
             // No pybind11 type info. See if we can use another framework's
             // type to complete this cast. Set srcs.used_foreign if so.
-            if (get_foreign_internals().imported_any) {
+            if (get_interop_internals().imported_any) {
                 if (handle ret = cast_foreign(srcs, policy, parent)) {
                     return ret;
                 }
@@ -1215,10 +1215,11 @@ class type_caster_generic {
         return nullptr;
     }
 
-    /// Try to load as a type exposed by a different binding framework.
+    /// Try to load as a type exposed by a different binding framework (which
+    /// might be an ABI-incompatible version of pybind11).
     bool try_load_other_framework(handle src, bool convert) {
-        auto &foreign_internals = get_foreign_internals();
-        if (!foreign_internals.imported_any || !cpptype || src.is_none()) {
+        auto &interop_internals = get_interop_internals();
+        if (!interop_internals.imported_any || !cpptype || src.is_none()) {
             return false;
         }
 
@@ -1245,30 +1246,35 @@ class type_caster_generic {
         return 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(handle src, bool convert) {
-        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
-        const auto pytype = type::handle_of(src);
-        if (!hasattr(pytype, local_key)) {
-            return try_load_other_framework(src, convert);
-        }
-
-        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
-        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp
-        // type
-        if (foreign_typeinfo->module_local_load == &local_load
-            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype))) {
+    /// Try to load as a type bound as py::module_local() in a different (but
+    /// ABI-compatible) pybind11 module.
+    bool try_load_other_module_local(handle src, type_info *remote_typeinfo) {
+        // Only consider this loader if it's not ours and it loads the correct cpp type
+        if (remote_typeinfo->module_local_load == &local_load
+            || (cpptype && !same_type(*cpptype, *remote_typeinfo->cpptype))) {
             return false;
         }
 
-        if (auto *result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
+        if (auto *result = remote_typeinfo->module_local_load(src.ptr(), remote_typeinfo)) {
             value = result;
             return true;
         }
         return 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(handle src, bool convert) {
+        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
+        const auto pytype = type::handle_of(src);
+        if (hasattr(pytype, local_key)) {
+            return try_load_other_module_local(
+                src, reinterpret_borrow<capsule>(getattr(pytype, local_key)));
+        } else {
+            return try_load_other_framework(src, convert);
+        }
+    }
+
     // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
     // bits of code between here and copyable_holder_caster where the two classes need different
     // logic (without having to resort to virtual inheritance).

include/pybind11/detail/type_caster_base.h

@@ -245,7 +245,7 @@ inline void finalize_interpreter() {
     if (detail::get_num_interpreters_seen() > 1) {
         detail::get_internals_pp_manager().unref();
         detail::get_local_internals_pp_manager().unref();
-        detail::get_foreign_internals_pp_manager().unref();
+        detail::get_interop_internals_pp_manager().unref();
 
         // We know there can be no other interpreter alive now, so we can lower the count
         detail::get_num_interpreters_seen() = 1;
@@ -257,7 +257,7 @@ inline void finalize_interpreter() {
     // and check it after Py_Finalize().
     detail::get_internals_pp_manager().get_pp();
     detail::get_local_internals_pp_manager().get_pp();
-    detail::get_foreign_internals_pp_manager().get_pp();
+    detail::get_interop_internals_pp_manager().get_pp();
 
     Py_Finalize();
 
@@ -266,7 +266,7 @@ inline void finalize_interpreter() {
     // interpreter
     detail::get_internals_pp_manager().destroy();
     detail::get_local_internals_pp_manager().destroy();
-    detail::get_foreign_internals_pp_manager().destroy();
+    detail::get_interop_internals_pp_manager().destroy();
 
     // We know there is no interpreter alive now, so we can reset the count
     detail::get_num_interpreters_seen() = 0;

include/pybind11/embed.h

@@ -1648,9 +1648,9 @@ class generic_type : public object {
             internals.registered_types_py[(PyTypeObject *) m_ptr] = {tinfo};
             PYBIND11_WARNING_POP
 
-            auto &foreign_internals = get_foreign_internals();
-            if (foreign_internals.export_all) {
-                foreign_internals.export_type_to_foreign(tinfo);
+            auto &interop_internals = get_interop_internals();
+            if (interop_internals.export_all) {
+                interop_internals.export_for_interop(tinfo);
             }
         });
 
@@ -2136,7 +2136,7 @@ class class_ : public detail::generic_type {
         generic_type::initialize(record);
 
         with_internals([&](internals &internals) {
-            get_foreign_internals().copy_move_ctors.emplace(
+            get_interop_internals().copy_move_ctors.emplace(
                 *record.type, detail::type_caster_base<type_>::copy_and_move_ctors());
             if (has_alias) {
                 auto &instances = record.module_local ? get_local_internals().registered_types_cpp

include/pybind11/pybind11.h

@@ -180,7 +180,7 @@ class subinterpreter {
         // internals themselves.
         detail::get_internals_pp_manager().get_pp();
         detail::get_local_internals_pp_manager().get_pp();
-        detail::get_foreign_internals_pp_manager().get_pp();
+        detail::get_interop_internals_pp_manager().get_pp();
 
         // End it
         Py_EndInterpreter(destroy_tstate);
@@ -189,7 +189,7 @@ class subinterpreter {
         // py::capsule calls `get_internals()` during destruction), so we destroy afterward.
         detail::get_internals_pp_manager().destroy();
         detail::get_local_internals_pp_manager().destroy();
-        detail::get_foreign_internals_pp_manager().destroy();
+        detail::get_interop_internals_pp_manager().destroy();
 
         // switch back to the old tstate and old GIL (if there was one)
         if (switch_back)