pyproto: split into new feature

Author: davidhewitt

Cargo.toml

@@ -52,14 +52,17 @@ serde_json = "1.0.61"
 pyo3-build-config = { path = "pyo3-build-config", version = "0.15.1", features = ["resolve-config"] }
 
 [features]
-default = ["macros"]
+default = ["macros", "pyproto"]
 
 # Enables macros: #[pyclass], #[pymodule], #[pyfunction] etc.
 macros = ["pyo3-macros", "indoc", "unindent"]
 
 # Enables multiple #[pymethods] per #[pyclass]
 multiple-pymethods = ["inventory", "pyo3-macros/multiple-pymethods"]
 
+# Enables deprecated #[pyproto] macro
+pyproto = ["pyo3-macros/pyproto"]
+
 # Use this feature when building an extension module.
 # It tells the linker to keep the python symbols unresolved,
 # so that the module can also be used with statically linked python interpreters.
@@ -83,7 +86,7 @@ nightly = []
 
 # Activates all additional features
 # This is mostly intended for testing purposes - activating *all* of these isn't particularly useful.
-full = ["macros", "multiple-pymethods", "num-bigint", "num-complex", "hashbrown", "serde", "indexmap", "eyre", "anyhow"]
+full = ["macros", "pyproto", "multiple-pymethods", "num-bigint", "num-complex", "hashbrown", "serde", "indexmap", "eyre", "anyhow"]
 
 [[bench]]
 name = "bench_call"

Makefile

@@ -3,9 +3,6 @@
 ALL_ADDITIVE_FEATURES = macros multiple-pymethods num-bigint num-complex hashbrown serde indexmap eyre anyhow
 COVERAGE_PACKAGES = --package pyo3 --package pyo3-build-config --package pyo3-macros-backend --package pyo3-macros
 
-list_all_additive_features:
-	@echo $(ALL_ADDITIVE_FEATURES)
-
 test: lint test_py
 	cargo test
 	cargo test --features="abi3"

guide/src/class.md

@@ -849,17 +849,17 @@ impl pyo3::IntoPy<PyObject> for MyClass {
     }
 }
 
-impl pyo3::class::impl_::PyClassImpl for MyClass {
+impl pyo3::impl_::pyclass::PyClassImpl for MyClass {
     const DOC: &'static str = "Class for demonstration\u{0}";
     const IS_GC: bool = false;
     const IS_BASETYPE: bool = false;
     const IS_SUBCLASS: bool = false;
     type Layout = PyCell<MyClass>;
     type BaseType = PyAny;
-    type ThreadChecker = pyo3::class::impl_::ThreadCheckerStub<MyClass>;
+    type ThreadChecker = pyo3::impl_::pyclass::ThreadCheckerStub<MyClass>;
 
     fn for_each_method_def(visitor: &mut dyn FnMut(&[pyo3::class::PyMethodDefType])) {
-        use pyo3::class::impl_::*;
+        use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<MyClass>::new();
         visitor(collector.py_methods());
         visitor(collector.py_class_descriptors());
@@ -870,23 +870,23 @@ impl pyo3::class::impl_::PyClassImpl for MyClass {
         visitor(collector.number_protocol_methods());
     }
     fn get_new() -> Option<pyo3::ffi::newfunc> {
-        use pyo3::class::impl_::*;
+        use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<Self>::new();
         collector.new_impl()
     }
     fn get_alloc() -> Option<pyo3::ffi::allocfunc> {
-        use pyo3::class::impl_::*;
+        use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<Self>::new();
         collector.alloc_impl()
     }
     fn get_free() -> Option<pyo3::ffi::freefunc> {
-        use pyo3::class::impl_::*;
+        use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<Self>::new();
         collector.free_impl()
     }
     fn for_each_proto_slot(visitor: &mut dyn FnMut(&[pyo3::ffi::PyType_Slot])) {
         // Implementation which uses dtolnay specialization to load all slots.
-        use pyo3::class::impl_::*;
+        use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<Self>::new();
         visitor(collector.object_protocol_slots());
         visitor(collector.number_protocol_slots());

guide/src/features.md

@@ -65,6 +65,12 @@ Most users should only need a single `#[pymethods]` per `#[pyclass]`. In additio
 
 See [the `#[pyclass]` implementation details](class.md#implementation-details) for more information.
 
+### `pyproto`
+
+This feature enables the `#[pyproto]` macro, which is an alternative (older, soon-to-be-deprecated) to `#[pymethods]` for defining magic methods such as `__eq__`.
+
+> This feature is enabled by default. To disable it, set `default-features = false` for the `pyo3` entry in your Cargo.toml.
+
 ### `nightly`
 
 The `nightly` feature needs the nightly Rust compiler. This allows PyO3 to use Rust's unstable specialization feature to apply the following optimizations:

pyo3-macros-backend/Cargo.toml

@@ -22,3 +22,6 @@ pyo3-build-config = { path = "../pyo3-build-config", version = "0.15.1", feature
 version = "1"
 default-features = false
 features = ["derive", "parsing", "printing", "clone-impls", "full", "extra-traits"]
+
+[features]
+pyproto = []

pyo3-macros-backend/src/lib.rs

@@ -9,18 +9,21 @@
 mod utils;
 
 mod attributes;
+#[cfg(feature = "pyproto")]
 mod defs;
 mod deprecations;
 mod frompyobject;
 mod konst;
 mod method;
 mod module;
 mod params;
+#[cfg(feature = "pyproto")]
 mod proto_method;
 mod pyclass;
 mod pyfunction;
 mod pyimpl;
 mod pymethod;
+#[cfg(feature = "pyproto")]
 mod pyproto;
 mod wrap;
 
@@ -29,6 +32,7 @@ pub use module::{process_functions_in_module, pymodule_impl, PyModuleOptions};
 pub use pyclass::{build_py_class, build_py_enum, PyClassArgs};
 pub use pyfunction::{build_py_function, PyFunctionOptions};
 pub use pyimpl::{build_py_methods, PyClassMethodsType};
+#[cfg(feature = "pyproto")]
 pub use pyproto::build_py_proto;
 pub use utils::get_doc;
 pub use wrap::{wrap_pyfunction_impl, wrap_pymodule_impl, WrapPyFunctionArgs};

pyo3-macros-backend/src/method.rs

@@ -566,23 +566,23 @@ impl<'a> FnSpec<'a> {
         let doc = &self.doc;
         match self.convention {
             CallingConvention::Noargs => quote! {
-                _pyo3::class::methods::PyMethodDef::noargs(
+                _pyo3::impl_::pymethods::PyMethodDef::noargs(
                     #python_name,
-                    _pyo3::class::methods::PyCFunction(#wrapper),
+                    _pyo3::impl_::pymethods::PyCFunction(#wrapper),
                     #doc,
                 )
             },
             CallingConvention::Fastcall => quote! {
-                _pyo3::class::methods::PyMethodDef::fastcall_cfunction_with_keywords(
+                _pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                     #python_name,
-                    _pyo3::class::methods::PyCFunctionFastWithKeywords(#wrapper),
+                    _pyo3::impl_::pymethods::PyCFunctionFastWithKeywords(#wrapper),
                     #doc,
                 )
             },
             CallingConvention::Varargs => quote! {
-                _pyo3::class::methods::PyMethodDef::cfunction_with_keywords(
+                _pyo3::impl_::pymethods::PyMethodDef::cfunction_with_keywords(
                     #python_name,
-                    _pyo3::class::methods::PyCFunctionWithKeywords(#wrapper),
+                    _pyo3::impl_::pymethods::PyCFunctionWithKeywords(#wrapper),
                     #doc,
                 )
             },

pyo3-macros-backend/src/pyclass.rs

@@ -511,11 +511,11 @@ fn unit_variants_as_descriptors<'a>(
         .map(|var| gen_py_const(&cls_type, &variant_to_attribute(var)));
 
     quote! {
-        impl _pyo3::class::impl_::PyClassDescriptors<#cls>
-            for _pyo3::class::impl_::PyClassImplCollector<#cls>
+        impl _pyo3::impl_::pyclass::PyClassDescriptors<#cls>
+            for _pyo3::impl_::pyclass::PyClassImplCollector<#cls>
         {
-            fn py_class_descriptors(self) -> &'static [_pyo3::class::methods::PyMethodDefType] {
-                static METHODS: &[_pyo3::class::methods::PyMethodDefType] = &[#(#py_methods),*];
+            fn py_class_descriptors(self) -> &'static [_pyo3::impl_::pymethods::PyMethodDefType] {
+                static METHODS: &[_pyo3::impl_::pymethods::PyMethodDefType] = &[#(#py_methods),*];
                 METHODS
             }
         }
@@ -574,11 +574,11 @@ fn impl_descriptors(
         .collect::<syn::Result<_>>()?;
 
     Ok(quote! {
-        impl _pyo3::class::impl_::PyClassDescriptors<#cls>
-            for _pyo3::class::impl_::PyClassImplCollector<#cls>
+        impl _pyo3::impl_::pyclass::PyClassDescriptors<#cls>
+            for _pyo3::impl_::pyclass::PyClassImplCollector<#cls>
         {
-            fn py_class_descriptors(self) -> &'static [_pyo3::class::methods::PyMethodDefType] {
-                static METHODS: &[_pyo3::class::methods::PyMethodDefType] = &[#(#py_methods),*];
+            fn py_class_descriptors(self) -> &'static [_pyo3::impl_::pymethods::PyMethodDefType] {
+                static METHODS: &[_pyo3::impl_::pymethods::PyMethodDefType] = &[#(#py_methods),*];
                 METHODS
             }
         }
@@ -676,7 +676,7 @@ impl<'a> PyClassImplsBuilder<'a> {
         };
 
         let base_nativetype = if attr.has_extends {
-            quote! { <Self::BaseType as _pyo3::class::impl_::PyClassBaseType>::BaseNativeType }
+            quote! { <Self::BaseType as _pyo3::impl_::pyclass::PyClassBaseType>::BaseNativeType }
         } else {
             quote! { _pyo3::PyAny }
         };
@@ -749,13 +749,13 @@ impl<'a> PyClassImplsBuilder<'a> {
         };
 
         let thread_checker = if self.attr.has_unsendable {
-            quote! { _pyo3::class::impl_::ThreadCheckerImpl<#cls> }
+            quote! { _pyo3::impl_::pyclass::ThreadCheckerImpl<#cls> }
         } else if self.attr.has_extends {
             quote! {
-                _pyo3::class::impl_::ThreadCheckerInherited<#cls, <#cls as _pyo3::class::impl_::PyClassImpl>::BaseType>
+                _pyo3::impl_::pyclass::ThreadCheckerInherited<#cls, <#cls as _pyo3::impl_::pyclass::PyClassImpl>::BaseType>
             }
         } else {
-            quote! { _pyo3::class::impl_::ThreadCheckerStub<#cls> }
+            quote! { _pyo3::impl_::pyclass::ThreadCheckerStub<#cls> }
         };
 
         let (for_each_py_method, methods_protos, inventory, inventory_class) = match self
@@ -775,22 +775,51 @@ impl<'a> PyClassImplsBuilder<'a> {
                 );
                 (
                     quote! {
-                        for inventory in _pyo3::inventory::iter::<<Self as _pyo3::class::impl_::PyClassImpl>::Inventory>() {
-                            visitor(_pyo3::class::impl_::PyClassInventory::methods(inventory));
+                        for inventory in _pyo3::inventory::iter::<<Self as _pyo3::impl_::pyclass::PyClassImpl>::Inventory>() {
+                            visitor(_pyo3::impl_::pyclass::PyClassInventory::methods(inventory));
                         }
                     },
                     quote! {
-                        for inventory in _pyo3::inventory::iter::<<Self as _pyo3::class::impl_::PyClassImpl>::Inventory>() {
-                            visitor(_pyo3::class::impl_::PyClassInventory::slots(inventory));
+                        for inventory in _pyo3::inventory::iter::<<Self as _pyo3::impl_::pyclass::PyClassImpl>::Inventory>() {
+                            visitor(_pyo3::impl_::pyclass::PyClassInventory::slots(inventory));
                         }
                     },
                     Some(quote! { type Inventory = #inventory_class_name; }),
                     Some(define_inventory_class(&inventory_class_name)),
                 )
             }
         };
+
+        let pyproto_method_visitors = if cfg!(feature = "pyproto") {
+            Some(quote! {
+                visitor(collector.object_protocol_methods());
+                visitor(collector.async_protocol_methods());
+                visitor(collector.descr_protocol_methods());
+                visitor(collector.mapping_protocol_methods());
+                visitor(collector.number_protocol_methods());
+            })
+        } else {
+            None
+        };
+
+        let pyproto_proto_visitors = if cfg!(feature = "pyproto") {
+            Some(quote! {
+                visitor(collector.object_protocol_slots());
+                visitor(collector.number_protocol_slots());
+                visitor(collector.iter_protocol_slots());
+                visitor(collector.gc_protocol_slots());
+                visitor(collector.descr_protocol_slots());
+                visitor(collector.mapping_protocol_slots());
+                visitor(collector.sequence_protocol_slots());
+                visitor(collector.async_protocol_slots());
+                visitor(collector.buffer_protocol_slots());
+            })
+        } else {
+            None
+        };
+
         quote! {
-            impl _pyo3::class::impl_::PyClassImpl for #cls {
+            impl _pyo3::impl_::pyclass::PyClassImpl for #cls {
                 const DOC: &'static str = #doc;
                 const IS_GC: bool = #is_gc;
                 const IS_BASETYPE: bool = #is_basetype;
@@ -802,48 +831,36 @@ impl<'a> PyClassImplsBuilder<'a> {
                 #inventory
 
                 fn for_each_method_def(visitor: &mut dyn ::std::ops::FnMut(&[_pyo3::class::PyMethodDefType])) {
-                    use _pyo3::class::impl_::*;
+                    use _pyo3::impl_::pyclass::*;
                     let collector = PyClassImplCollector::<Self>::new();
                     #for_each_py_method;
                     visitor(collector.py_class_descriptors());
-                    visitor(collector.object_protocol_methods());
-                    visitor(collector.async_protocol_methods());
-                    visitor(collector.descr_protocol_methods());
-                    visitor(collector.mapping_protocol_methods());
-                    visitor(collector.number_protocol_methods());
+                    #pyproto_method_visitors
                 }
                 fn get_new() -> ::std::option::Option<_pyo3::ffi::newfunc> {
-                    use _pyo3::class::impl_::*;
+                    use _pyo3::impl_::pyclass::*;
                     let collector = PyClassImplCollector::<Self>::new();
                     collector.new_impl()
                 }
                 fn get_alloc() -> ::std::option::Option<_pyo3::ffi::allocfunc> {
-                    use _pyo3::class::impl_::*;
+                    use _pyo3::impl_::pyclass::*;
                     let collector = PyClassImplCollector::<Self>::new();
                     collector.alloc_impl()
                 }
                 fn get_free() -> ::std::option::Option<_pyo3::ffi::freefunc> {
-                    use _pyo3::class::impl_::*;
+                    use _pyo3::impl_::pyclass::*;
                     let collector = PyClassImplCollector::<Self>::new();
                     collector.free_impl()
                 }
 
                 fn for_each_proto_slot(visitor: &mut dyn ::std::ops::FnMut(&[_pyo3::ffi::PyType_Slot])) {
                     // Implementation which uses dtolnay specialization to load all slots.
-                    use _pyo3::class::impl_::*;
+                    use _pyo3::impl_::pyclass::*;
                     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());
-                    visitor(collector.iter_protocol_slots());
-                    visitor(collector.gc_protocol_slots());
-                    visitor(collector.descr_protocol_slots());
-                    visitor(collector.mapping_protocol_slots());
-                    visitor(collector.sequence_protocol_slots());
-                    visitor(collector.async_protocol_slots());
-                    visitor(collector.buffer_protocol_slots());
+                    #pyproto_proto_visitors
                     #methods_protos
                 }
 
@@ -861,7 +878,7 @@ impl<'a> PyClassImplsBuilder<'a> {
 
         self.attr.freelist.as_ref().map_or(quote!{}, |freelist| {
             quote! {
-                impl _pyo3::class::impl_::PyClassWithFreeList for #cls {
+                impl _pyo3::impl_::pyclass::PyClassWithFreeList for #cls {
                     #[inline]
                     fn get_free_list(_py: _pyo3::Python<'_>) -> &mut _pyo3::impl_::freelist::FreeList<*mut _pyo3::ffi::PyObject> {
                         static mut FREELIST: *mut _pyo3::impl_::freelist::FreeList<*mut _pyo3::ffi::PyObject> = 0 as *mut _;
@@ -875,17 +892,17 @@ impl<'a> PyClassImplsBuilder<'a> {
                     }
                 }
 
-                impl _pyo3::class::impl_::PyClassAllocImpl<#cls> for _pyo3::class::impl_::PyClassImplCollector<#cls> {
+                impl _pyo3::impl_::pyclass::PyClassAllocImpl<#cls> for _pyo3::impl_::pyclass::PyClassImplCollector<#cls> {
                     #[inline]
                     fn alloc_impl(self) -> ::std::option::Option<_pyo3::ffi::allocfunc> {
-                        ::std::option::Option::Some(_pyo3::class::impl_::alloc_with_freelist::<#cls>)
+                        ::std::option::Option::Some(_pyo3::impl_::pyclass::alloc_with_freelist::<#cls>)
                     }
                 }
 
-                impl _pyo3::class::impl_::PyClassFreeImpl<#cls> for _pyo3::class::impl_::PyClassImplCollector<#cls> {
+                impl _pyo3::impl_::pyclass::PyClassFreeImpl<#cls> for _pyo3::impl_::pyclass::PyClassImplCollector<#cls> {
                     #[inline]
                     fn free_impl(self) -> ::std::option::Option<_pyo3::ffi::freefunc> {
-                        ::std::option::Option::Some(_pyo3::class::impl_::free_with_freelist::<#cls>)
+                        ::std::option::Option::Some(_pyo3::impl_::pyclass::free_with_freelist::<#cls>)
                     }
                 }
             }
@@ -928,7 +945,7 @@ fn define_inventory_class(inventory_class_name: &syn::Ident) -> TokenStream {
             }
         }
 
-        impl _pyo3::class::impl_::PyClassInventory for #inventory_class_name {
+        impl _pyo3::impl_::pyclass::PyClassInventory for #inventory_class_name {
             fn methods(&'static self) -> &'static [_pyo3::class::PyMethodDefType] {
                 self.methods
             }