Add py::potentially_slicing_shared_ptr()

Author: rwgk

include/pybind11/cast.h

@@ -983,6 +983,16 @@ struct copyable_holder_caster<
         return shared_ptr_storage;
     }
 
+    std::shared_ptr<type> &potentially_slicing_shared_ptr() {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            shared_ptr_storage
+                = sh_load_helper.load_as_shared_ptr(value,
+                                                    /*responsible_parent=*/nullptr,
+                                                    /*force_potentially_slicing_shared_ptr=*/true);
+        }
+        return shared_ptr_storage;
+    }
+
     static handle
     cast(const std::shared_ptr<type> &src, return_value_policy policy, handle parent) {
         const auto *ptr = src.get();
@@ -1077,6 +1087,21 @@ struct copyable_holder_caster<
 template <typename T>
 class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> {};
 
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename T>
+std::shared_ptr<T> potentially_slicing_shared_ptr(handle obj) {
+    detail::make_caster<std::shared_ptr<T>> caster;
+    if (caster.load(obj, /*convert=*/true)) {
+        return caster.potentially_slicing_shared_ptr();
+    }
+    const char *type_name_obj = detail::obj_class_name(obj.ptr());
+    throw type_error("\"" + std::string(type_name_obj)
+                     + "\" object is not convertible to std::shared_ptr<T>");
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
 // SMART_HOLDER_BAKEIN_FOLLOW_ON: Rewrite comment, with reference to unique_ptr specialization.
 /// Type caster for holder types like std::unique_ptr.
 /// Please consider the SFINAE hook an implementation detail, as explained

include/pybind11/detail/type_caster_base.h

@@ -754,7 +754,9 @@ struct load_helper : value_and_holder_helper {
     }
 
     std::shared_ptr<T> load_as_shared_ptr(void *void_raw_ptr,
-                                          handle responsible_parent = nullptr) const {
+                                          handle responsible_parent = nullptr,
+                                          bool force_potentially_slicing_shared_ptr
+                                          = false) const {
         if (!have_holder()) {
             return nullptr;
         }
@@ -769,7 +771,7 @@ struct load_helper : value_and_holder_helper {
             throw std::runtime_error("Non-owning holder (load_as_shared_ptr).");
         }
         auto *type_raw_ptr = static_cast<T *>(void_raw_ptr);
-        if (python_instance_is_alias) {
+        if (python_instance_is_alias && !force_potentially_slicing_shared_ptr) {
             auto *vptr_gd_ptr = std::get_deleter<memory::guarded_delete>(hld.vptr);
             if (vptr_gd_ptr != nullptr) {
                 std::shared_ptr<void> released_ptr = vptr_gd_ptr->released_ptr.lock();

tests/test_class_sh_trampoline_weak_ptr.cpp

@@ -58,7 +58,7 @@ TEST_SUBMODULE(class_sh_trampoline_weak_ptr, m) {
         .def(py::init<>())
         .def("set_wp",
              [](WpOwner &self, py::handle obj) {
-                 self.set_wp(obj.cast<std::shared_ptr<VirtBase>>());
+                 self.set_wp(py::potentially_slicing_shared_ptr<VirtBase>(obj));
              })
         .def("get_code", &WpOwner::get_code);
 

tests/test_class_sh_trampoline_weak_ptr.py

@@ -22,10 +22,7 @@ def test_weak_ptr_owner(vtype, expected_code):
     assert obj.get_code() == expected_code
 
     wpo.set_wp(obj)
-    if vtype is m.VirtBase:
-        assert wpo.get_code() == expected_code
-    else:
-        assert wpo.get_code() == -999  # THIS NEEDS FIXING (issue #5623)
+    assert wpo.get_code() == expected_code
 
     del obj
     if env.PYPY or env.GRAALPY: