Removed writeonly attribute methods per owner request. Use cpp_function() for null reader

Author: TD22057

include/pybind11/pybind11.h

@@ -1174,14 +1174,6 @@ class class_ : public detail::generic_type {
         return *this;
     }
 
-    template <typename C, typename D, typename... Extra>
-    class_ &def_writeonly(const char *name, D C::*pm, const Extra& ...extra) {
-        static_assert(std::is_base_of<C, type>::value, "def_writeonly() requires a class member (or base class member)");
-        cpp_function fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
-        def_property_writeonly(name, fset, extra...);
-        return *this;
-    }
-
     template <typename D, typename... Extra>
     class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
         cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
@@ -1197,58 +1189,31 @@ class class_ : public detail::generic_type {
         return *this;
     }
 
-    template <typename D, typename... Extra>
-    class_ &def_writeonly_static(const char *name, D *pm, const Extra& ...extra) {
-        cpp_function fset([pm](object, const D &value) { *pm = value; }, scope(*this));
-        def_property_writeonly_static(name, fset, extra...);
-        return *this;
-    }
-
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename... Extra>
     class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
         return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
                                      return_value_policy::reference_internal, extra...);
     }
 
-    template <typename Setter, typename... Extra>
-    class_ &def_property_writeonly(const char *name, const Setter &fset, const Extra& ...extra) {
-        return def_property_writeonly(name, cpp_function(method_adaptor<type>(fset)),extra...);
-    }
-
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
     class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
         return def_property(name, fget, cpp_function(), extra...);
     }
 
-    template <typename... Extra>
-    class_ &def_property_writeonly(const char *name, const cpp_function &fset, const Extra& ...extra) {
-        return def_property(name, cpp_function(), fset, extra...);
-    }
-
     /// Uses return_value_policy::reference by default
     template <typename Getter, typename... Extra>
     class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
         return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
     }
 
-    template <typename Setter, typename... Extra>
-    class_ &def_property_writeonly_static(const char *name, const Setter &fset, const Extra& ...extra) {
-        return def_property_writeonly_static(name, cpp_function(fset), extra...);
-    }
-
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
     class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
         return def_property_static(name, fget, cpp_function(), extra...);
     }
 
-    template <typename... Extra>
-    class_ &def_property_writeonly_static(const char *name, const cpp_function &fset, const Extra& ...extra) {
-        return def_property_static(name, cpp_function(), fset, extra...);
-    }
-
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename Setter, typename... Extra>
     class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {

tests/test_methods_and_attributes.cpp

@@ -279,17 +279,19 @@ TEST_SUBMODULE(methods_and_attributes, m) {
         .def(py::init<>())
         .def_readonly("def_readonly", &TestProperties::value)
         .def_readwrite("def_readwrite", &TestProperties::value)
-        .def_writeonly("def_writeonly", &TestProperties::value)
-        .def_property_writeonly("def_property_writeonly", &TestProperties::set)
+        .def_property("def_writeonly", py::cpp_function(),
+                      [](TestProperties& s,int v) { s.value = v; } )
+        .def_property("def_property_writeonly", py::cpp_function(), &TestProperties::set)
         .def_property_readonly("def_property_readonly", &TestProperties::get)
         .def_property("def_property", &TestProperties::get, &TestProperties::set)
         .def_readonly_static("def_readonly_static", &TestProperties::static_value)
         .def_readwrite_static("def_readwrite_static", &TestProperties::static_value)
-        .def_writeonly_static("def_writeonly_static", &TestProperties::static_value)
+        .def_property_static("def_writeonly_static", py::cpp_function(),
+                             [](py::object, int v){ TestProperties::static_value = v; })
         .def_property_readonly_static("def_property_readonly_static",
                                       [](py::object) { return TestProperties::static_get(); })
-        .def_property_writeonly_static("def_property_writeonly_static",
-                                       [](py::object, int v) { return TestProperties::static_set(v); })
+        .def_property_static("def_property_writeonly_static", py::cpp_function(),
+                             [](py::object, int v) { return TestProperties::static_set(v); })
         .def_property_static("def_property_static",
                              [](py::object) { return TestProperties::static_get(); },
                              [](py::object, int v) { TestProperties::static_set(v); })