Minimal (!) changes to have py::potentially_slicing_weak_ptr<T>(handle) as the public API. For CI testing, before changing the names around more widely, and the documentation.

Author: rwgk

include/pybind11/cast.h

@@ -983,7 +983,7 @@ struct copyable_holder_caster<
         return shared_ptr_storage;
     }
 
-    std::shared_ptr<type> &potentially_slicing_shared_ptr() {
+    std::weak_ptr<type> potentially_slicing_weak_ptr() {
         if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
             shared_ptr_storage
                 = sh_load_helper.load_as_shared_ptr(value,
@@ -1122,15 +1122,15 @@ PYBIND11_NAMESPACE_END(detail)
 ///     - the std::shared_ptr would own a reference to the derived Python object,
 ///       completing the cycle
 template <typename T>
-std::shared_ptr<T> potentially_slicing_shared_ptr(handle obj) {
+std::weak_ptr<T> potentially_slicing_weak_ptr(handle obj) {
     detail::make_caster<std::shared_ptr<T>> caster;
     if (caster.load(obj, /*convert=*/true)) {
-        return caster.potentially_slicing_shared_ptr();
+        return caster.potentially_slicing_weak_ptr();
     }
     const char *obj_type_name = detail::obj_class_name(obj.ptr());
     throw type_error("\"" + std::string(obj_type_name)
-                     + "\" object is not convertible to std::shared_ptr<T> (with T = "
-                     + type_id<T>() + ")");
+                     + "\" object is not convertible to std::weak_ptr<T> (with T = " + type_id<T>()
+                     + ")");
 }
 
 PYBIND11_NAMESPACE_BEGIN(detail)

tests/test_potentially_slicing_shared_ptr.cpp

@@ -71,7 +71,7 @@ std::shared_ptr<VB> rtrn_obj_cast_shared_ptr(py::handle obj) {
 
 template <typename VB>
 std::shared_ptr<VB> rtrn_potentially_slicing_shared_ptr(py::handle obj) {
-    return py::potentially_slicing_shared_ptr<VB>(obj);
+    return py::potentially_slicing_weak_ptr<VB>(obj).lock();
 }
 
 template <typename VB>
@@ -93,7 +93,7 @@ struct SpOwner {
 
 template <typename VB>
 struct WpOwner {
-    void set_wp(const std::shared_ptr<VB> &sp) { wp = sp; }
+    void set_wp(const std::weak_ptr<VB> &wp_) { wp = wp_; }
 
     int get_code() const {
         auto sp = wp.lock();
@@ -126,10 +126,13 @@ void wrap(py::module_ &m,
 
     py::classh<WpOwner<VB>>(m, wpo_pyname)
         .def(py::init<>())
-        .def("set_wp", &WpOwner<VB>::set_wp)
+        .def("set_wp",
+             [](WpOwner<VB> &self, py::handle obj) {
+                 self.set_wp(obj.cast<std::shared_ptr<VB>>());
+             })
         .def("set_wp_potentially_slicing",
              [](WpOwner<VB> &self, py::handle obj) {
-                 self.set_wp(py::potentially_slicing_shared_ptr<VB>(obj));
+                 self.set_wp(py::potentially_slicing_weak_ptr<VB>(obj));
              })
         .def("get_code", &WpOwner<VB>::get_code)
         .def("get_trampoline_state", &WpOwner<VB>::get_trampoline_state);

tests/test_potentially_slicing_shared_ptr.py

@@ -163,12 +163,12 @@ def test_potentially_slicing_shared_ptr_not_convertible_error():
     with pytest.raises(Exception) as excinfo:
         m.SH_rtrn_potentially_slicing_shared_ptr("")
     assert str(excinfo.value) == (
-        '"str" object is not convertible to std::shared_ptr<T>'
+        '"str" object is not convertible to std::weak_ptr<T>'
         " (with T = pybind11_tests::potentially_slicing_shared_ptr::VirtBase<0>)"
     )
     with pytest.raises(Exception) as excinfo:
         m.SP_rtrn_potentially_slicing_shared_ptr([])
     assert str(excinfo.value) == (
-        '"list" object is not convertible to std::shared_ptr<T>'
+        '"list" object is not convertible to std::weak_ptr<T>'
         " (with T = pybind11_tests::potentially_slicing_shared_ptr::VirtBase<1>)"
     )