Adjusting type_caster<std::reference_wrapper<T>> to support const/non-const propagation in cast_op.

include/pybind11/cast.h

@@ -960,9 +960,15 @@ template <typename type> class type_caster<std::reference_wrapper<type>> {
 private:
     using caster_t = make_caster<type>;
     caster_t subcaster;
-    using subcaster_cast_op_type = typename caster_t::template cast_op_type<type>;
-    static_assert(std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value,
-            "std::reference_wrapper<T> caster requires T to have a caster with an `T &` operator");
+    using reference_t = typename std::add_lvalue_reference<type>::type;
+    using subcaster_cast_op_type =
+        typename caster_t::template cast_op_type<reference_t>;
+
+    static_assert((std::is_same<typename std::remove_const<type>::type &,
+                             subcaster_cast_op_type>::value ||
+                std::is_same<reference_t, subcaster_cast_op_type>::value),
+               "std::reference_wrapper<T> caster requires T to have a caster "
+               "with an operator `T &` or `const T&`");
 public:
     bool load(handle src, bool convert) { return subcaster.load(src, convert); }
     static constexpr auto name = caster_t::name;
@@ -973,7 +979,7 @@ template <typename type> class type_caster<std::reference_wrapper<type>> {
         return caster_t::cast(&src.get(), policy, parent);
     }
     template <typename T> using cast_op_type = std::reference_wrapper<type>;
-    operator std::reference_wrapper<type>() { return subcaster.operator subcaster_cast_op_type&(); }
+    operator std::reference_wrapper<type>() { return subcaster.operator subcaster_cast_op_type(); }
 };
 
 #define PYBIND11_TYPE_CASTER(type, py_name) \

tests/CMakeLists.txt

@@ -93,6 +93,7 @@ set(PYBIND11_TEST_FILES
     test_callbacks.cpp
     test_chrono.cpp
     test_class.cpp
+    test_const_ref_caster.cpp
     test_constants_and_functions.cpp
     test_copy_move.cpp
     test_custom_type_casters.cpp

tests/test_builtin_casters.cpp

@@ -147,6 +147,17 @@ TEST_SUBMODULE(builtin_casters, m) {
     // test_reference_wrapper
     m.def("refwrap_builtin", [](std::reference_wrapper<int> p) { return 10 * p.get(); });
     m.def("refwrap_usertype", [](std::reference_wrapper<UserType> p) { return p.get().value(); });
+    m.def("refwrap_usertype_const", [](std::reference_wrapper<const UserType> p) { return p.get().value(); });
+
+    m.def("refwrap_lvalue", []() -> std::reference_wrapper<UserType> {
+        static UserType x(1);
+        return std::ref(x);
+    });
+    m.def("refwrap_lvalue_const", []() -> std::reference_wrapper<const UserType> {
+        static UserType x(1);
+        return std::cref(x);
+    });
+
     // Not currently supported (std::pair caster has return-by-value cast operator);
     // triggers static_assert failure.
     //m.def("refwrap_pair", [](std::reference_wrapper<std::pair<int, int>>) { });

tests/test_builtin_casters.py

@@ -315,6 +315,7 @@ def test_reference_wrapper():
     """std::reference_wrapper for builtin and user types"""
     assert m.refwrap_builtin(42) == 420
     assert m.refwrap_usertype(UserType(42)) == 42
+    assert m.refwrap_usertype_const(UserType(42)) == 42
 
     with pytest.raises(TypeError) as excinfo:
         m.refwrap_builtin(None)
@@ -324,6 +325,9 @@ def test_reference_wrapper():
         m.refwrap_usertype(None)
     assert "incompatible function arguments" in str(excinfo.value)
 
+    assert m.refwrap_lvalue().value == 1
+    assert m.refwrap_lvalue_const().value == 1
+
     a1 = m.refwrap_list(copy=True)
     a2 = m.refwrap_list(copy=True)
     assert [x.value for x in a1] == [2, 3]

tests/test_const_ref_caster.cpp

@@ -0,0 +1,88 @@
+/*
+    tests/test_const_ref_caster.cpp
+
+    This test verifies that const-ref is propagated through type_caster cast_op.
+
+    The returned ConstRefCasted type is a mimimal type that is constructed to
+    reference the casting mode used.
+*/
+
+#include <pybind11/complex.h>
+
+#include "pybind11_tests.h"
+
+
+struct ConstRefCasted {
+  bool is_const;
+  bool is_ref;
+};
+
+PYBIND11_NAMESPACE_BEGIN(pybind11)
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <>
+class type_caster<ConstRefCasted> {
+ public:
+  static constexpr auto name = _<ConstRefCasted>();
+
+  bool load(handle, bool) { return true; }
+
+  operator ConstRefCasted&&() { value = {false, false}; return std::move(value); }
+  operator ConstRefCasted&() { value = {false, true}; return value; }
+  operator ConstRefCasted*() { value = {false, false}; return &value; }
+
+  operator const ConstRefCasted&() { value = {true, true}; return value; }
+  operator const ConstRefCasted*() { value = {true, false}; return &value; }
+
+  // 
+  template <typename T_>
+  using cast_op_type =
+      /// const
+      conditional_t<
+          std::is_same<remove_reference_t<T_>, const ConstRefCasted*>::value, const ConstRefCasted*,
+      conditional_t<
+          std::is_same<T_, const ConstRefCasted&>::value, const ConstRefCasted&,
+      // non-const
+      conditional_t<
+          std::is_same<remove_reference_t<T_>, ConstRefCasted*>::value, ConstRefCasted*,
+      conditional_t<
+          std::is_same<T_, ConstRefCasted&>::value, ConstRefCasted&,
+          /* else */ConstRefCasted&&>>>>;
+
+ private:
+  ConstRefCasted value = {false, false};
+};
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(pybind11)
+
+TEST_SUBMODULE(const_ref_caster, m) {
+  py::class_<ConstRefCasted>(m, "ConstRefCasted",
+                             "A `py::class_` type for testing")
+      .def(py::init<>())
+      .def_readonly("is_const", &ConstRefCasted::is_const)
+      .def_readonly("is_ref", &ConstRefCasted::is_ref);
+
+
+  m.def("takes", [](ConstRefCasted x) {
+    return !x.is_const && !x.is_ref;
+  });
+  m.def("takes_ptr", [](ConstRefCasted* x) {
+    return !x->is_const && !x->is_ref;
+  });
+  m.def("takes_ref", [](ConstRefCasted& x) {
+    return !x.is_const && x.is_ref;
+  });
+  m.def("takes_ref_wrap", [](std::reference_wrapper<ConstRefCasted> x) {
+    return !x.get().is_const && x.get().is_ref;
+  });
+
+  m.def("takes_const_ptr", [](const ConstRefCasted* x) {
+    return x->is_const && !x->is_ref;
+  });
+  m.def("takes_const_ref", [](const ConstRefCasted& x) {
+    return x.is_const && x.is_ref;
+  });
+  m.def("takes_const_ref_wrap",
+        [](std::reference_wrapper<const ConstRefCasted> x) {
+          return x.get().is_const && x.get().is_ref;
+        });
+}

tests/test_const_ref_caster.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+import env  # noqa: F401
+
+from pybind11_tests import const_ref_caster as m
+
+
+def test_takes():
+	assert m.takes(m.ConstRefCasted())
+
+	assert m.takes_ptr(m.ConstRefCasted())
+	assert m.takes_ref(m.ConstRefCasted())
+	assert m.takes_ref_wrap(m.ConstRefCasted())
+
+	assert m.takes_const_ptr(m.ConstRefCasted())
+	assert m.takes_const_ref(m.ConstRefCasted())
+	assert m.takes_const_ref_wrap(m.ConstRefCasted())