Systematically rename loaded_as to load_as (shared_ptr, unique_ptr) as suggested by @laramiel

Author: rwgk

include/pybind11/cast.h

@@ -886,7 +886,7 @@ struct copyable_holder_caster<
 
     explicit operator std::shared_ptr<type> &() {
         if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
-            shared_ptr_holder = sh_load_helper.loaded_as_shared_ptr(value);
+            shared_ptr_holder = sh_load_helper.load_as_shared_ptr(value);
         }
         return shared_ptr_holder;
     }
@@ -914,7 +914,7 @@ struct copyable_holder_caster<
         copyable_holder_caster loader;
         loader.load(responsible_parent, /*convert=*/false);
         assert(loader.typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder);
-        return loader.sh_load_helper.loaded_as_shared_ptr(loader.value, responsible_parent);
+        return loader.sh_load_helper.load_as_shared_ptr(loader.value, responsible_parent);
     }
 
 protected:
@@ -1074,7 +1074,7 @@ struct move_only_holder_caster<
 
     explicit operator std::unique_ptr<type, deleter>() {
         if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
-            return sh_load_helper.template loaded_as_unique_ptr<deleter>(value);
+            return sh_load_helper.template load_as_unique_ptr<deleter>(value);
         }
         pybind11_fail("Passing std::unique_ptr from Python to C++ requires smart_holder.");
     }

include/pybind11/detail/type_caster_base.h

@@ -715,20 +715,20 @@ struct load_helper : value_and_holder_helper {
         return std::shared_ptr<T>(raw_ptr, shared_ptr_parent_life_support(parent.ptr()));
     }
 
-    std::shared_ptr<T> loaded_as_shared_ptr(void *void_raw_ptr,
-                                            handle responsible_parent = nullptr) const {
+    std::shared_ptr<T> load_as_shared_ptr(void *void_raw_ptr,
+                                          handle responsible_parent = nullptr) const {
         if (!have_holder()) {
             return nullptr;
         }
         throw_if_uninitialized_or_disowned_holder(typeid(T));
         holder_type &hld = holder();
-        hld.ensure_is_not_disowned("loaded_as_shared_ptr");
+        hld.ensure_is_not_disowned("load_as_shared_ptr");
         if (hld.vptr_is_using_noop_deleter) {
             if (responsible_parent) {
                 return make_shared_ptr_with_responsible_parent(static_cast<T *>(void_raw_ptr),
                                                                responsible_parent);
             }
-            throw std::runtime_error("Non-owning holder (loaded_as_shared_ptr).");
+            throw std::runtime_error("Non-owning holder (load_as_shared_ptr).");
         }
         auto *type_raw_ptr = static_cast<T *>(void_raw_ptr);
         if (hld.pointee_depends_on_holder_owner) {
@@ -748,7 +748,7 @@ struct load_helper : value_and_holder_helper {
                 // This code is reachable only if there are multiple registered_instances for the
                 // same pointee.
                 if (reinterpret_cast<PyObject *>(loaded_v_h.inst) == sptsls_ptr->self) {
-                    pybind11_fail("smart_holder_type_caster_support loaded_as_shared_ptr failure: "
+                    pybind11_fail("smart_holder_type_caster_support load_as_shared_ptr failure: "
                                   "loaded_v_h.inst == sptsls_ptr->self");
                 }
             }
@@ -758,20 +758,20 @@ struct load_helper : value_and_holder_helper {
                     type_raw_ptr, shared_ptr_trampoline_self_life_support(loaded_v_h.inst));
             }
             if (hld.vptr_is_external_shared_ptr) {
-                pybind11_fail("smart_holder_type_casters loaded_as_shared_ptr failure: not "
+                pybind11_fail("smart_holder_type_casters load_as_shared_ptr failure: not "
                               "implemented: trampoline-self-life-support for external shared_ptr "
                               "to type inheriting from std::enable_shared_from_this.");
             }
-            pybind11_fail("smart_holder_type_casters: loaded_as_shared_ptr failure: internal "
-                          "inconsistency.");
+            pybind11_fail(
+                "smart_holder_type_casters: load_as_shared_ptr failure: internal inconsistency.");
         }
         std::shared_ptr<void> void_shd_ptr = hld.template as_shared_ptr<void>();
         return std::shared_ptr<T>(void_shd_ptr, type_raw_ptr);
     }
 
     template <typename D>
-    std::unique_ptr<T, D> loaded_as_unique_ptr(void *raw_void_ptr,
-                                               const char *context = "loaded_as_unique_ptr") {
+    std::unique_ptr<T, D> load_as_unique_ptr(void *raw_void_ptr,
+                                             const char *context = "load_as_unique_ptr") {
         if (!have_holder()) {
             return unique_with_deleter<T, D>(nullptr, std::unique_ptr<D>());
         }

tests/test_class_sh_basic.py

@@ -135,9 +135,7 @@ def test_cannot_disown_use_count_ne_1(pass_f, rtrn_f):
     stash.Add(obj)
     with pytest.raises(ValueError) as exc_info:
         pass_f(obj)
-    assert str(exc_info.value) == (
-        "Cannot disown use_count != 1 (loaded_as_unique_ptr)."
-    )
+    assert str(exc_info.value) == ("Cannot disown use_count != 1 (load_as_unique_ptr).")
 
 
 def test_unique_ptr_roundtrip(num_round_trips=1000):

tests/test_class_sh_mi_thunks.py

@@ -52,6 +52,5 @@ def test_get_shared_vec_size_unique():
     with pytest.raises(ValueError) as exc_info:
         m.vec_size_base0_unique_ptr(obj)
     assert (
-        str(exc_info.value)
-        == "Cannot disown external shared_ptr (loaded_as_unique_ptr)."
+        str(exc_info.value) == "Cannot disown external shared_ptr (load_as_unique_ptr)."
     )

tests/test_class_sh_property.py

@@ -21,7 +21,7 @@ def test_valu_getter(m_attr):
     assert field.num == -99
     with pytest.raises(ValueError) as excinfo:
         m.DisownOuter(outer)
-    assert str(excinfo.value) == "Cannot disown use_count != 1 (loaded_as_unique_ptr)."
+    assert str(excinfo.value) == "Cannot disown use_count != 1 (load_as_unique_ptr)."
     del field
     m.DisownOuter(outer)
     with pytest.raises(ValueError, match="Python instance was disowned") as excinfo:

tests/test_class_sh_trampoline_shared_from_this.py

@@ -241,7 +241,7 @@ def __init__(self, history):
         str_exc_info_value = str(exc_info.value)
     assert (
         str_exc_info_value
-        == "smart_holder_type_casters loaded_as_shared_ptr failure: not implemented:"
+        == "smart_holder_type_casters load_as_shared_ptr failure: not implemented:"
         " trampoline-self-life-support for external shared_ptr to type inheriting"
         " from std::enable_shared_from_this."
     )