Merge pull request #2096 from davidhewitt/pyproto-feature

Add a `pyproto` 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,56 +849,36 @@ 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_::*;
+    fn for_all_items(visitor: &mut dyn FnMut(&pyo3::impl_::pyclass::PyClassItems)) {
+        use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<MyClass>::new();
         visitor(collector.py_methods());
-        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());
+        visitor(collector.pyclass_intrinsic_items());
     }
     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_::*;
-        let collector = PyClassImplCollector::<Self>::new();
-        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());
-        visitor(collector.methods_protocol_slots());
-    }
 }
 # Python::with_gil(|py| {
 #     let cls = py.get_type::<MyClass>();

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/defs.rs

@@ -64,27 +64,13 @@ impl Proto {
         })
     }
 
-    pub(crate) fn slots_trait(&self) -> syn::Ident {
-        syn::Ident::new(&format!("Py{}ProtocolSlots", self.name), Span::call_site())
+    pub(crate) fn items_trait(&self) -> syn::Ident {
+        syn::Ident::new(&format!("Py{}ProtocolItems", self.name), Span::call_site())
     }
 
-    pub(crate) fn slots_trait_slots(&self) -> syn::Ident {
+    pub(crate) fn items_trait_items(&self) -> syn::Ident {
         syn::Ident::new(
-            &format!("{}_protocol_slots", self.name.to_ascii_lowercase()),
-            Span::call_site(),
-        )
-    }
-
-    pub(crate) fn methods_trait(&self) -> syn::Ident {
-        syn::Ident::new(
-            &format!("Py{}ProtocolMethods", self.name),
-            Span::call_site(),
-        )
-    }
-
-    pub(crate) fn methods_trait_methods(&self) -> syn::Ident {
-        syn::Ident::new(
-            &format!("{}_protocol_methods", self.name.to_ascii_lowercase()),
+            &format!("{}_protocol_items", self.name.to_ascii_lowercase()),
             Span::call_site(),
         )
     }

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,
                 )
             },