Remove ordinary method specialization

Author: jovenlin0527

pyo3-macros-backend/src/pyclass.rs

@@ -766,9 +766,6 @@ impl<'a> PyClassImplsBuilder<'a> {
                     visitor(collector.descr_protocol_methods());
                     visitor(collector.mapping_protocol_methods());
                     visitor(collector.number_protocol_methods());
-
-                    // It's collected last so Python ignore them if it found methods with same names.
-                    visitor(collector.py_class_default_impls());
                 }
                 fn get_new() -> ::std::option::Option<::pyo3::ffi::newfunc> {
                     use ::pyo3::class::impl_::*;
@@ -790,6 +787,8 @@ impl<'a> PyClassImplsBuilder<'a> {
                     // Implementation which uses dtolnay specialization to load all slots.
                     use ::pyo3::class::impl_::*;
                     let collector = PyClassImplCollector::<Self>::new();
+                    // This depends on Python implementation detail;
+                    // an old slot entry will be overriden by newer ones.
                     visitor(collector.py_class_default_slots());
                     visitor(collector.object_protocol_slots());
                     visitor(collector.number_protocol_slots());

src/class/impl_.rs

@@ -629,9 +629,6 @@ pub trait HasMethodsInventory {
 // Methods from #[pyo3(get, set)] on struct fields.
 methods_trait!(PyClassDescriptors, py_class_descriptors);
 
-// Methods that PyO3 implemented by default, but can be overridden by the user.
-methods_trait!(PyClassDefaultImpls, py_class_default_impls);
-
 // Methods from #[pymethods] if not using inventory.
 #[cfg(not(feature = "multiple-pymethods"))]
 methods_trait!(PyMethods, py_methods);

tests/test_default_impls.rs

@@ -5,99 +5,61 @@ use pyo3::py_run;
 
 mod common;
 
-// Tests for PyClassDefaultImpls
+// Tests for PyClassDefaultSlots
 #[pyclass]
-struct TestDefaultImpl;
+struct TestDefaultSlots;
 
 // generated using `Cargo expand`
 // equivalent to
 // ```
-// impl TestDefaultImpl {
-//     #[staticmethod]
-//     fn default() {}
-//     #[staticmethod]
-//     fn overriden() -> bool { false }
+// impl TestDefaultSlots {{
+//     fn __str__(&self) -> &'static str {
+//         "default"
+//     }
 // }
 // ```
-impl TestDefaultImpl {
-    fn __pyo3__default() {}
-    fn __pyo3__overriden() -> bool {
-        false
+impl TestDefaultSlots {
+    fn __pyo3__str__(&self) -> &'static str {
+        "default"
     }
 }
 
-impl pyo3::class::impl_::PyClassDefaultImpls<TestDefaultImpl>
-    for pyo3::class::impl_::PyClassImplCollector<TestDefaultImpl>
+impl ::pyo3::class::impl_::PyClassDefaultSlots<TestDefaultSlots>
+    for ::pyo3::class::impl_::PyClassImplCollector<TestDefaultSlots>
 {
-    fn py_class_default_impls(self) -> &'static [PyMethodDefType] {
-        static METHODS: &[::pyo3::class::methods::PyMethodDefType] = &[
-            ::pyo3::class::PyMethodDefType::Static(
-                ::pyo3::class::methods::PyMethodDef::noargs(
-                    "default\u{0}",
-                    ::pyo3::class::methods::PyCFunction({
-                        unsafe extern "C" fn __wrap(
-                            _slf: *mut ::pyo3::ffi::PyObject,
-                            _args: *mut ::pyo3::ffi::PyObject,
-                        ) -> *mut ::pyo3::ffi::PyObject {
-                            ::pyo3::callback::handle_panic(|_py| {
-                                ::pyo3::callback::convert(_py, TestDefaultImpl::__pyo3__default())
-                            })
-                        }
-                        __wrap
-                    }),
-                    "\u{0}",
-                )
-                .flags(::pyo3::ffi::METH_STATIC),
-            ),
-            ::pyo3::class::PyMethodDefType::Static(
-                ::pyo3::class::methods::PyMethodDef::noargs(
-                    "overriden\u{0}",
-                    ::pyo3::class::methods::PyCFunction({
-                        unsafe extern "C" fn __wrap(
-                            _slf: *mut ::pyo3::ffi::PyObject,
-                            _args: *mut ::pyo3::ffi::PyObject,
-                        ) -> *mut ::pyo3::ffi::PyObject {
-                            ::pyo3::callback::handle_panic(|_py| {
-                                ::pyo3::callback::convert(_py, TestDefaultImpl::__pyo3__overriden())
-                            })
-                        }
-                        __wrap
-                    }),
-                    "\u{0}",
-                )
-                .flags(::pyo3::ffi::METH_STATIC),
-            ),
-        ];
-        METHODS
-    }
-}
-
-#[pymethods]
-impl TestDefaultImpl {
-    #[staticmethod]
-    fn overriden() -> bool {
-        true
+    fn py_class_default_slots(self) -> &'static [::pyo3::ffi::PyType_Slot] {
+        &[{
+            unsafe extern "C" fn __wrap(
+                _raw_slf: *mut ::pyo3::ffi::PyObject,
+            ) -> *mut ::pyo3::ffi::PyObject {
+                let _slf = _raw_slf;
+                ::pyo3::callback::handle_panic(|_py| {
+                    let _cell = _py
+                        .from_borrowed_ptr::<::pyo3::PyAny>(_slf)
+                        .downcast::<::pyo3::PyCell<TestDefaultSlots>>()?;
+                    let _ref = _cell.try_borrow()?;
+                    let _slf = &_ref;
+                    ::pyo3::callback::convert(_py, TestDefaultSlots::__pyo3__str__(_slf))
+                })
+            }
+            ::pyo3::ffi::PyType_Slot {
+                slot: ::pyo3::ffi::Py_tp_str,
+                pfunc: __wrap as ::pyo3::ffi::reprfunc as _,
+            }
+        }]
     }
 }
 
 #[test]
-fn test_default_impl_exists() {
-    Python::with_gil(|py| {
-        let test_object = Py::new(py, TestDefaultImpl).unwrap();
-        py_run!(py, test_object, "test_object.default()");
-    })
-}
-
-#[test]
-fn test_default_impl_is_overriden() {
+fn test_default_slot_exists() {
     Python::with_gil(|py| {
-        let test_object = Py::new(py, TestDefaultImpl).unwrap();
-        py_assert!(py, test_object, "test_object.overriden() == True");
+        let test_object = Py::new(py, TestDefaultSlots).unwrap();
+        py_assert!(py, test_object, "str(test_object) == 'default'");
     })
 }
 
 #[pyclass]
-struct OverrideMagicMethod;
+struct OverrideSlot;
 
 // generated using `Cargo expand`
 // equivalent to
@@ -108,14 +70,14 @@ struct OverrideMagicMethod;
 //     }
 // }
 // ```
-impl OverrideMagicMethod {
+impl OverrideSlot {
     fn __pyo3__str__(&self) -> &'static str {
         "default"
     }
 }
 
-impl ::pyo3::class::impl_::PyClassDefaultSlots<OverrideMagicMethod>
-    for ::pyo3::class::impl_::PyClassImplCollector<OverrideMagicMethod>
+impl ::pyo3::class::impl_::PyClassDefaultSlots<OverrideSlot>
+    for ::pyo3::class::impl_::PyClassImplCollector<OverrideSlot>
 {
     fn py_class_default_slots(self) -> &'static [::pyo3::ffi::PyType_Slot] {
         &[{
@@ -126,10 +88,10 @@ impl ::pyo3::class::impl_::PyClassDefaultSlots<OverrideMagicMethod>
                 ::pyo3::callback::handle_panic(|_py| {
                     let _cell = _py
                         .from_borrowed_ptr::<::pyo3::PyAny>(_slf)
-                        .downcast::<::pyo3::PyCell<OverrideMagicMethod>>()?;
+                        .downcast::<::pyo3::PyCell<OverrideSlot>>()?;
                     let _ref = _cell.try_borrow()?;
                     let _slf = &_ref;
-                    ::pyo3::callback::convert(_py, OverrideMagicMethod::__pyo3__str__(_slf))
+                    ::pyo3::callback::convert(_py, OverrideSlot::__pyo3__str__(_slf))
                 })
             }
             ::pyo3::ffi::PyType_Slot {
@@ -141,16 +103,16 @@ impl ::pyo3::class::impl_::PyClassDefaultSlots<OverrideMagicMethod>
 }
 
 #[pymethods]
-impl OverrideMagicMethod {
+impl OverrideSlot {
     fn __str__(&self) -> &str {
         "overriden"
     }
 }
 
 #[test]
-fn test_override_magic_method() {
+fn test_override_slot() {
     Python::with_gil(|py| {
-        let test_object = Py::new(py, OverrideMagicMethod).unwrap();
+        let test_object = Py::new(py, OverrideSlot).unwrap();
         py_assert!(py, test_object, "str(test_object) == 'overriden'");
     })
 }