More CI fixes

Author: oremanj

.codespell-ignore-lines

@@ -2,6 +2,7 @@ template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined
     template <typename ThisT>
         auto &this_ = static_cast<ThisT &>(*this);
                 if (load_impl<ThisT>(temp, false)) {
+                return load_impl<ThisT>(src, false);
         ssize_t nd = 0;
         auto trivial = broadcast(buffers, nd, shape);
         auto ndim = (size_t) nd;

include/pybind11/cast.h

@@ -110,9 +110,10 @@ class type_caster_enum_type {
 
     // NOLINTNEXTLINE(google-explicit-constructor)
     operator EnumType &() {
-        return native_loaded ? native_value
-               : legacy_ptr  ? *legacy_ptr
-                             : throw reference_cast_error();
+        if (!native_loaded && !legacy_ptr) {
+            throw reference_cast_error();
+        }
+        return native_loaded ? native_value : *legacy_ptr;
     }
 
 private:

include/pybind11/detail/common.h

@@ -284,8 +284,8 @@ inline bool is_uniquely_referenced(PyObject *obj) {
 #else // backport for 3.13
 inline bool is_uniquely_referenced(PyObject *obj) {
     return _Py_IsOwnedByCurrentThread(obj)
-           && _Py_atomic_load_uint32_relaxed(&ob->ob_ref_local) == 1
-           && _Py_atomic_load_ssize_relaxed(&ob->ob_ref_shared) == 0;
+           && _Py_atomic_load_uint32_relaxed(&obj->ob_ref_local) == 1
+           && _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared) == 0;
 }
 #endif
 

include/pybind11/detail/foreign.h

@@ -22,8 +22,9 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 PYBIND11_NOINLINE void foreign_exception_translator(std::exception_ptr p) {
     auto &interop_internals = get_interop_internals();
     for (pymb_framework *fw : interop_internals.exc_frameworks) {
-        if (fw->translate_exception(&p))
+        if (fw->translate_exception(&p) != 0) {
             return;
+        }
     }
     std::rethrow_exception(p);
 }
@@ -47,14 +48,14 @@ inline void import_foreign_binding(pymb_binding *binding, const std::type_info *
     // Caller must hold the internals lock
     auto &interop_internals = get_interop_internals();
     interop_internals.imported_any = true;
-    auto range = interop_internals.bindings.equal_range(*cpptype);
-    for (auto it = range.first; it != range.second; ++it) {
-        if (it->second == binding) {
+    auto &lst = interop_internals.bindings[*cpptype];
+    for (pymb_binding *existing : lst) {
+        if (existing == binding) {
             return; // already imported
         }
     }
     ++interop_internals.bindings_update_count;
-    interop_internals.bindings.emplace(*cpptype, binding);
+    lst.append(binding);
 }
 
 // Callback functions for other frameworks to operate on our objects
@@ -77,14 +78,14 @@ inline void *interop_cb_from_python(pymb_binding *binding,
                 = reinterpret_borrow<capsule>(pytype.attr(native_enum_info::attribute_name()));
             auto *info = cap.get_pointer<native_enum_info>();
             auto value = handle(pyobj).attr("value");
-            uint64_t ival;
+            uint64_t ival = 0;
             if (info->is_signed && handle(value) < int_(0)) {
                 ival = (uint64_t) cast<int64_t>(value);
             } else {
                 ival = cast<uint64_t>(value);
             }
             bytes holder{reinterpret_cast<const char *>(&ival)
-                             + PYBIND11_BIG_ENDIAN * (8 - info->size_bytes),
+                             + PYBIND11_BIG_ENDIAN * size_t(8 - info->size_bytes),
                          info->size_bytes};
             keep_referenced(keep_referenced_ctx, holder.ptr());
             return PyBytes_AsString(holder.ptr());
@@ -198,7 +199,7 @@ inline PyObject *interop_cb_to_python(pymb_binding *binding,
             auto cap
                 = reinterpret_borrow<capsule>(pytype.attr(native_enum_info::attribute_name()));
             auto *info = cap.get_pointer<native_enum_info>();
-            uint64_t key;
+            uint64_t key = 0;
             switch (info->size_bytes) {
                 case 1:
                     key = *(uint8_t *) cobj;
@@ -215,10 +216,11 @@ inline PyObject *interop_cb_to_python(pymb_binding *binding,
                 default:
                     return nullptr;
             }
-            if (rvp_ == pymb_rv_policy_take_ownership)
+            if (rvp_ == pymb_rv_policy_take_ownership) {
                 ::operator delete(cobj);
+            }
             if (info->is_signed) {
-                int64_t ikey = (int64_t) key;
+                auto ikey = (int64_t) key;
                 if (info->size_bytes < 8) {
                     // sign extend
                     ikey <<= (64 - (info->size_bytes * 8));
@@ -275,7 +277,7 @@ inline PyObject *interop_cb_to_python(pymb_binding *binding,
             srcs.init_instance = init_instance_unregistered;
         }
         handle ret = type_caster_generic::cast(srcs, rvp, {}, copy_ctor, move_ctor);
-        feedback->is_new = srcs.is_new;
+        feedback->is_new = uint8_t(srcs.is_new);
         return ret.ptr();
     } catch (...) {
         translate_exception(std::current_exception());
@@ -309,7 +311,9 @@ inline int interop_cb_keep_alive(PyObject *nurse, void *payload, void (*cb)(void
                 // Create a shared_ptr whose destruction will perform the action
                 std::shared_ptr<void> owner(payload, cb_to_use);
                 // Use the aliasing constructor to make its get() return the right thing
+                // NB: this constructor accepts an rvalue reference only in C++20
                 new (std::addressof(v_h.holder<std::shared_ptr<void>>()))
+                    // NOLINTNEXTLINE(performance-move-const-arg)
                     std::shared_ptr<void>(std::move(owner), v_h.value_ptr());
                 v_h.set_holder_constructed();
                 success = true;
@@ -403,13 +407,12 @@ inline int interop_cb_translate_exception(void *eptr) noexcept {
 inline void interop_cb_remove_local_binding(pymb_binding *binding) noexcept {
     with_internals([&](internals &) {
         auto &interop_internals = get_interop_internals();
-        auto *cpptype = (const std::type_info *) binding->native_type;
-        auto range = interop_internals.bindings.equal_range(*cpptype);
-        for (auto it = range.first; it != range.second; ++it) {
-            if (it->second == binding) {
-                ++interop_internals.bindings_update_count;
+        const auto *cpptype = (const std::type_info *) binding->native_type;
+        auto it = interop_internals.bindings.find(*cpptype);
+        if (it != interop_internals.bindings.end() && it->second.erase(binding)) {
+            ++interop_internals.bindings_update_count;
+            if (it->second.empty()) {
                 interop_internals.bindings.erase(it);
-                return;
             }
         }
     });
@@ -433,12 +436,11 @@ inline void interop_cb_remove_foreign_binding(pymb_binding *binding) noexcept {
     with_internals([&](internals &) {
         auto &interop_internals = get_interop_internals();
         auto remove_from_type = [&](const std::type_info *type) {
-            auto range = interop_internals.bindings.equal_range(*type);
-            for (auto it = range.first; it != range.second; ++it) {
-                if (it->second == binding) {
-                    ++interop_internals.bindings_update_count;
+            auto it = interop_internals.bindings.find(*type);
+            if (it != interop_internals.bindings.end() && it->second.erase(binding)) {
+                ++interop_internals.bindings_update_count;
+                if (it->second.empty()) {
                     interop_internals.bindings.erase(it);
-                    break;
                 }
             }
         };
@@ -641,11 +643,10 @@ PYBIND11_NOINLINE void interop_enable_import_all() {
 PYBIND11_NOINLINE void
 export_for_interop(const std::type_info *cpptype, PyTypeObject *pytype, type_info *ti) {
     auto &interop_internals = get_interop_internals();
-    auto range = interop_internals.bindings.equal_range(*cpptype);
-    for (auto it = range.first; it != range.second; ++it) {
-        if (it->second->framework == interop_internals.self.get()
-            && it->second->pytype == pytype) {
-            return; // already exported
+    auto &lst = interop_internals.bindings[*cpptype];
+    for (pymb_binding *existing : lst) {
+        if (existing->framework == interop_internals.self.get() && existing->pytype == pytype) {
+            return; // already imported
         }
     }
 
@@ -657,7 +658,7 @@ export_for_interop(const std::type_info *cpptype, PyTypeObject *pytype, type_inf
     binding->context = ti;
 
     ++interop_internals.bindings_update_count;
-    interop_internals.bindings.emplace(*cpptype, binding);
+    lst.append(binding);
     pymb_add_binding(binding, /* tp_finalize_will_remove */ 0);
 }
 
@@ -688,7 +689,7 @@ PYBIND11_NOINLINE void interop_enable_export_all() {
                     handle(entry.second).attr(native_enum_info::attribute_name()));
                 auto *info = cap.get_pointer<native_enum_info>();
                 detail::export_for_interop(info->cpptype, (PyTypeObject *) entry.second, nullptr);
-            } catch (error_already_set &) {
+            } catch (error_already_set &) { // NOLINT(bugprone-empty-catch)
                 // Ignore native enums without a __pybind11_enum__ capsule;
                 // they might be from an older version of pybind11
             }
@@ -710,10 +711,11 @@ PYBIND11_NOINLINE void *try_foreign_bindings(const std::type_info *type,
     do {
         PYBIND11_LOCK_INTERNALS(internals);
         (void) internals; // suppress unused warning on non-ft builds
-        auto range = interop_internals.bindings.equal_range(*type);
-        auto it = range.first;
-        for (; it != range.second; ++it) {
-            auto *binding = it->second;
+        auto it = interop_internals.bindings.find(*type);
+        if (it == interop_internals.bindings.end()) {
+            return nullptr;
+        }
+        for (pymb_binding *binding : it->second) {
             if (binding->framework == interop_internals.self.get()
                 && (!binding->context
                     || !is_local_to_other_module((type_info *) binding->context))) {
@@ -741,13 +743,13 @@ PYBIND11_NOINLINE void *try_foreign_bindings(const std::type_info *type,
             // was done within attempt(), or concurrently during attempt()
             // while we didn't hold the internals lock
             if (interop_internals.bindings_update_count != update_count) {
-                // Concurrent update occurred; retry
-                update_count = interop_internals.bindings_update_count;
+                // Concurrent update occurred; stop iterating
                 break;
             }
         }
-        if (it != range.second) {
+        if (interop_internals.bindings_update_count != update_count) {
             // We broke out early due to a concurrent update. Retry from the top.
+            update_count = interop_internals.bindings_update_count;
             continue;
         }
         return nullptr;
@@ -775,7 +777,7 @@ inline void import_for_interop(handle pytype) {
     auto &interop_internals = detail::get_interop_internals();
     interop_internals.initialize_if_needed();
     detail::with_internals(
-        [&](detail::internals &) { detail::import_for_interop(std::move(pytype), cpptype); });
+        [&](detail::internals &) { detail::import_for_interop(pytype, cpptype); });
 }
 
 inline void export_for_interop(handle ty) {
@@ -806,7 +808,8 @@ inline void export_for_interop(handle ty) {
         if (ours) {
             return;
         }
-    } catch (error_already_set &) {
+    } catch (error_already_set &) { // NOLINT(bugprone-empty-catch)
+        // Could be an older native enum without __pybind11_enum__ capsule
     }
     pybind11_fail("pybind11::export_for_interop: not a "
                   "pybind11 class or enum bound in this domain");

include/pybind11/detail/internals.h

@@ -184,9 +184,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>;
-template <typename value_type>
-using type_multimap
-    = std::unordered_multimap<std::type_index, value_type, type_hash, type_equal_to>;
 
 struct override_hash {
     inline size_t operator()(const std::pair<const PyObject *, const char *> &v) const {
@@ -313,10 +310,72 @@ using copy_or_move_ctor = void *(*) (const void *);
 // 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 interop_internals {
+    // A vector optimized for the case of storing one element.
+    class binding_list {
+    public:
+        binding_list() : single(nullptr) {}
+        binding_list(const binding_list &) = delete;
+        binding_list(binding_list &&other) noexcept : vec(other.vec) { other.vec = 0; }
+        ~binding_list() {
+            if (is_vec()) {
+                delete as_vec();
+            }
+        }
+
+        bool empty() const { return single == nullptr; }
+        pymb_binding **begin() {
+            return empty() ? nullptr : is_vec() ? as_vec()->data() : &single;
+        }
+        pymb_binding **end() {
+            return empty()    ? nullptr
+                   : is_vec() ? as_vec()->data() + as_vec()->size()
+                              : &single + 1;
+        }
+        void append(pymb_binding *binding) {
+            if (empty()) {
+                single = binding;
+            } else if (!is_vec()) {
+                vec = uintptr_t(new Vec{single, binding}) | uintptr_t(1);
+            } else {
+                as_vec()->push_back(binding);
+            }
+        }
+        bool erase(pymb_binding *binding) {
+            if (is_vec()) {
+                Vec *v = as_vec();
+                for (auto it = v->begin(); it != v->end(); ++it) {
+                    if (*it == binding) {
+                        v->erase(it);
+                        if (v->size() == 1) {
+                            single = (*v)[0];
+                            delete v;
+                        }
+                        return true;
+                    }
+                }
+            } else if (single == binding) {
+                single = nullptr;
+                return true;
+            }
+            return false;
+        }
+
+    private:
+        // Discriminated pointer: points to pymb_binding if the low bit is clear,
+        // or to std::vector<pymb_binding> if the low bit is set.
+        using Vec = std::vector<pymb_binding *>;
+        union {
+            pymb_binding *single;
+            uintptr_t vec;
+        };
+        bool is_vec() const { return (vec & uintptr_t(1)) != 0; }
+        Vec *as_vec() const { return (Vec *) (vec & ~uintptr_t(1)); }
+    };
+
     // Registered pymetabind bindings for each C++ type, including both our
     // own (exported) and other frameworks' (imported).
     // Protected by internals::mutex.
-    type_multimap<pymb_binding *> bindings;
+    type_map<binding_list> bindings;
 
     // For each C++ type with a native binding, store pointers to its
     // copy and move constructors. These would ideally move inside `type_info`
@@ -801,9 +860,8 @@ inline auto with_exception_translators(const F &cb)
 }
 
 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;
+    return internals_pp_manager<interop_internals>::get_instance(PYBIND11_INTERNALS_ID "interop",
+                                                                 nullptr);
 }
 
 inline interop_internals &get_interop_internals() {

include/pybind11/detail/native_enum_data.h

@@ -215,7 +215,7 @@ inline void native_enum_data::finalize() {
 
         auto &interop_internals = get_interop_internals();
         if (interop_internals.export_all) {
-            auto info = enum_info.get_pointer<native_enum_info>();
+            auto *info = enum_info.get_pointer<native_enum_info>();
             interop_internals.export_for_interop(
                 info->cpptype, (PyTypeObject *) py_enum.ptr(), nullptr);
         }

include/pybind11/detail/type_caster_base.h

@@ -266,9 +266,10 @@ PYBIND11_NOINLINE handle get_type_handle(const std::type_info &tp,
         auto &interop_internals = detail::get_interop_internals();
         if (interop_internals.imported_any) {
             handle ret = with_internals([&](internals &) {
-                auto range = interop_internals.bindings.equal_range(tp);
-                if (range.first != range.second) {
-                    return handle((PyObject *) range.first->second->pytype);
+                auto it = interop_internals.bindings.find(tp);
+                if (it != interop_internals.bindings.end() && !it->second.empty()) {
+                    pymb_binding *binding = *it->second.begin();
+                    return handle((PyObject *) binding->pytype);
                 }
                 return handle();
             });
@@ -1067,9 +1068,9 @@ class type_caster_generic {
             result_v = try_foreign_bindings(srcs.original.type, attempt, &cap);
         }
 
-        PyObject *result = (PyObject *) result_v;
+        auto *result = (PyObject *) result_v;
         if (result && policy == return_value_policy::reference_internal && srcs.is_new
-            && !srcs.used_foreign->keep_alive(result, parent.ptr(), nullptr)) {
+            && srcs.used_foreign->keep_alive(result, parent.ptr(), nullptr) == 0) {
             keep_alive_impl(result, parent.ptr());
         }
         return result;
@@ -1303,9 +1304,8 @@ class type_caster_generic {
         if (hasattr(pytype, local_key)) {
             return try_load_other_module_local(
                 src, reinterpret_borrow<capsule>(getattr(pytype, local_key)));
-        } else {
-            return foreign_ok && try_load_other_framework(src, convert);
         }
+        return foreign_ok && try_load_other_framework(src, convert);
     }
 
     // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
@@ -1372,7 +1372,7 @@ class type_caster_generic {
         if (convert) {
             for (const auto &converter : typeinfo->implicit_conversions) {
                 auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
-                if (load_impl<ThisT>(temp, false)) { // codespell:ignore ThisT
+                if (load_impl<ThisT>(temp, false)) {
                     loader_life_support::add_patient(temp);
                     return true;
                 }