Make PyClassShell have dict&weakref

kngwyu · kngwyu · commit bdb66afe0a8c · 2019-12-08T17:18:25.000+09:00
diff --git a/pyo3-derive-backend/src/pyclass.rs b/pyo3-derive-backend/src/pyclass.rs
@@ -126,10 +126,10 @@ impl PyClassArgs {
         let flag = exp.path.segments.first().unwrap().ident.to_string();
         let path = match flag.as_str() {
             "gc" => {
-                parse_quote! {pyo3::type_object::PY_TYPE_FLAG_GC}
+                parse_quote! {pyo3::type_flags::GC}
             }
             "weakref" => {
-                parse_quote! {pyo3::type_object::PY_TYPE_FLAG_WEAKREF}
+                parse_quote! {pyo3::type_flags::WEAKREF}
             }
             "subclass" => {
                 if cfg!(not(feature = "unsound-subclass")) {
@@ -138,10 +138,10 @@ impl PyClassArgs {
                         "You need to activate the `unsound-subclass` feature if you want to use subclassing",
                     ));
                 }
-                parse_quote! {pyo3::type_object::PY_TYPE_FLAG_BASETYPE}
+                parse_quote! {pyo3::type_flags::BASETYPE}
             }
             "dict" => {
-                parse_quote! {pyo3::type_object::PY_TYPE_FLAG_DICT}
+                parse_quote! {pyo3::type_flags::DICT}
             }
             _ => {
                 return Err(syn::Error::new_spanned(
@@ -267,7 +267,7 @@ fn impl_class(
     let extra = {
         if let Some(freelist) = &attr.freelist {
             quote! {
-                impl pyo3::freelist::PyObjectWithFreeList for #cls {
+                impl pyo3::freelist::PyClassWithFreeList for #cls {
                     #[inline]
                     fn get_free_list() -> &'static mut pyo3::freelist::FreeList<*mut pyo3::ffi::PyObject> {
                         static mut FREELIST: *mut pyo3::freelist::FreeList<*mut pyo3::ffi::PyObject> = 0 as *mut _;
@@ -285,7 +285,7 @@ fn impl_class(
             }
         } else {
             quote! {
-                impl pyo3::type_object::PyObjectAlloc for #cls {}
+                impl pyo3::pyclass::PyClassAlloc for #cls {}
             }
         }
     };
@@ -308,24 +308,25 @@ fn impl_class(
     let mut has_gc = false;
     for f in attr.flags.iter() {
         if let syn::Expr::Path(ref epath) = f {
-            if epath.path == parse_quote! {pyo3::type_object::PY_TYPE_FLAG_WEAKREF} {
+            if epath.path == parse_quote! { pyo3::type_flags::WEAKREF } {
                 has_weakref = true;
-            } else if epath.path == parse_quote! {pyo3::type_object::PY_TYPE_FLAG_DICT} {
+            } else if epath.path == parse_quote! { pyo3::type_flags::DICT } {
                 has_dict = true;
-            } else if epath.path == parse_quote! {pyo3::type_object::PY_TYPE_FLAG_GC} {
+            } else if epath.path == parse_quote! { pyo3::type_flags::GC } {
                 has_gc = true;
             }
         }
     }
+    // TODO: implement dict and weakref
     let weakref = if has_weakref {
-        quote! {std::mem::size_of::<*const pyo3::ffi::PyObject>()}
+        quote! { type WeakRef = pyo3::pyclass_slots::PyClassWeakRefSlot; }
     } else {
-        quote! {0}
+        quote! { type WeakRef = pyo3::pyclass_slots::PyClassDummySlot; }
     };
     let dict = if has_dict {
-        quote! {std::mem::size_of::<*const pyo3::ffi::PyObject>()}
+        quote! { type Dict = pyo3::pyclass_slots::PyClassDictSlot; }
     } else {
-        quote! {0}
+        quote! { type Dict = pyo3::pyclass_slots::PyClassDummySlot; }
     };
     let module = if let Some(m) = &attr.module {
         quote! { Some(#m) }
@@ -358,32 +359,25 @@ fn impl_class(
         impl pyo3::type_object::PyTypeInfo for #cls {
             type Type = #cls;
             type BaseType = #base;
+            type ConcreteLayout = pyo3::pyclass::PyClassShell<Self>;
 
             const NAME: &'static str = #cls_name;
             const MODULE: Option<&'static str> = #module;
             const DESCRIPTION: &'static str = #doc;
             const FLAGS: usize = #(#flags)|*;
 
-            const SIZE: usize = {
-                Self::OFFSET as usize +
-                ::std::mem::size_of::<#cls>() + #weakref + #dict
-            };
-            const OFFSET: isize = {
-                // round base_size up to next multiple of align
-                (
-                    (<#base as pyo3::type_object::PyTypeInfo>::SIZE +
-                     ::std::mem::align_of::<#cls>() - 1)  /
-                        ::std::mem::align_of::<#cls>() * ::std::mem::align_of::<#cls>()
-                ) as isize
-            };
-
             #[inline]
             unsafe fn type_object() -> &'static mut pyo3::ffi::PyTypeObject {
                 static mut TYPE_OBJECT: pyo3::ffi::PyTypeObject = pyo3::ffi::PyTypeObject_INIT;
                 &mut TYPE_OBJECT
             }
         }
 
+        impl pyo3::PyClass for #cls {
+            #dict
+            #weakref
+        }
+
         impl pyo3::IntoPy<PyObject> for #cls {
             fn into_py(self, py: pyo3::Python) -> pyo3::PyObject {
                 pyo3::IntoPy::into_py(pyo3::Py::new(py, self).unwrap(), py)
diff --git a/pyo3-derive-backend/src/pymethod.rs b/pyo3-derive-backend/src/pymethod.rs
@@ -237,25 +237,14 @@ pub fn impl_wrap_new(cls: &syn::Type, name: &syn::Ident, spec: &FnSpec<'_>) -> T
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#name),"()");
             let _py = pyo3::Python::assume_gil_acquired();
             let _pool = pyo3::GILPool::new(_py);
-            match pyo3::type_object::PyRawObject::new(_py, #cls::type_object(), _cls) {
-                Ok(_obj) => {
-                    let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
-                    let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
-
-                    #body
-
-                    match _result {
-                        Ok(_) => pyo3::IntoPyPointer::into_ptr(_obj),
-                        Err(e) => {
-                            e.restore(_py);
-                            ::std::ptr::null_mut()
-                        }
-                    }
-                }
-                Err(e) => {
-                    e.restore(_py);
-                    ::std::ptr::null_mut()
-                }
+            let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
+            let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
+
+            #body
+
+            match <<#cls as pyo3::PyTypeInfo>::ConcreteLayout as pyo3::pyclass::PyClassNew>::new(_py, _result) {
+                Ok(_slf) => _slf as _,
+                Err(e) => e.restore_and_null(),
             }
         }
     }
diff --git a/src/class/iter.rs b/src/class/iter.rs
@@ -4,7 +4,7 @@
 
 use crate::callback::{CallbackConverter, PyObjectCallbackConverter};
 use crate::err::PyResult;
-use crate::{ffi, IntoPy, PyClass, PyClassShell, PyObject};
+use crate::{ffi, pyclass::PyClassShell, IntoPy, PyClass, PyObject};
 use crate::{IntoPyPointer, Python};
 use std::ptr;
 
diff --git a/src/class/macros.rs b/src/class/macros.rs
@@ -35,7 +35,7 @@ macro_rules! py_unary_pyref_func {
         where
             T: for<'p> $trait<'p>,
         {
-            use $crate::{FromPyPointer, PyClassShell};
+            use $crate::{pyclass::PyClassShell, FromPyPointer};
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
             let slf: &mut PyClassShell<T> = FromPyPointer::from_borrowed_ptr_or_panic(py, slf);
diff --git a/src/err.rs b/src/err.rs
@@ -326,6 +326,13 @@ impl PyErr {
         unsafe { ffi::PyErr_Restore(ptype.into_ptr(), pvalue, ptraceback.into_ptr()) }
     }
 
+    #[doc(hidden)]
+    /// Utility method for proc-macro code
+    pub fn restore_and_null<T>(self, py: Python) -> *mut T {
+        self.restore(py);
+        std::ptr::null_mut()
+    }
+
     /// Issue a warning message.
     /// May return a PyErr if warnings-as-errors is enabled.
     pub fn warn(py: Python, category: &PyAny, message: &str, stacklevel: i32) -> PyResult<()> {
diff --git a/src/freelist.rs b/src/freelist.rs
@@ -12,7 +12,7 @@ use std::os::raw::c_void;
 /// Implementing this trait for custom class adds free allocation list to class.
 /// The performance improvement applies to types that are often created and deleted in a row,
 /// so that they can benefit from a freelist.
-pub trait PyObjectWithFreeList {
+pub trait PyClassWithFreeList {
     fn get_free_list() -> &'static mut FreeList<*mut ffi::PyObject>;
 }
 
@@ -70,10 +70,10 @@ impl<T> FreeList<T> {
 
 impl<T> PyClassAlloc for T
 where
-    T: PyTypeInfo + PyObjectWithFreeList,
+    T: PyTypeInfo + PyClassWithFreeList,
 {
     unsafe fn alloc(_py: Python) -> *mut Self::ConcreteLayout {
-        if let Some(obj) = <Self as PyObjectWithFreeList>::get_free_list().pop() {
+        if let Some(obj) = <Self as PyClassWithFreeList>::get_free_list().pop() {
             ffi::PyObject_Init(obj, <Self as PyTypeInfo>::type_object());
             obj as _
         } else {
@@ -89,7 +89,7 @@ where
             return;
         }
 
-        if let Some(obj) = <Self as PyObjectWithFreeList>::get_free_list().insert(obj) {
+        if let Some(obj) = <Self as PyClassWithFreeList>::get_free_list().insert(obj) {
             match Self::type_object().tp_free {
                 Some(free) => free(obj as *mut c_void),
                 None => tp_free_fallback(obj),
diff --git a/src/instance.rs b/src/instance.rs
@@ -36,11 +36,16 @@ unsafe impl<T> Sync for Py<T> {}
 
 impl<T> Py<T> {
     /// Create new instance of T and move it under python management
+    ///
+    /// **NOTE**
+    /// This method's `where` bound is actually the same as `PyClass`.
+    /// However, since Rust still doesn't have higher order generics, we cannot represent
+    /// this bound by `PyClass`.
     pub fn new(py: Python, value: T) -> PyResult<Py<T>>
     where
         T: PyClass,
     {
-        let obj = unsafe { PyClassShell::<T>::new(py, value) };
+        let obj = unsafe { PyClassShell::new(py, value)? };
         let ob = unsafe { Py::from_owned_ptr(obj as _) };
         Ok(ob)
     }
diff --git a/src/internal_tricks.rs b/src/internal_tricks.rs
@@ -4,3 +4,22 @@ use std::rc::Rc;
 /// A marker type that makes the type !Send.
 /// Temporal hack until https://github.com/rust-lang/rust/issues/13231 is resolved.
 pub(crate) type Unsendable = PhantomData<Rc<()>>;
+
+pub struct PrivateMarker;
+
+macro_rules! private_decl {
+    () => {
+        /// This trait is private to implement; this method exists to make it
+        /// impossible to implement outside the crate.
+        fn __private__(&self) -> crate::internal_tricks::PrivateMarker;
+    }
+}
+
+macro_rules! private_impl {
+    () => {
+        #[doc(hidden)]
+        fn __private__(&self) -> crate::internal_tricks::PrivateMarker {
+            crate::internal_tricks::PrivateMarker
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -124,12 +124,12 @@ pub use crate::conversion::{
 };
 pub use crate::err::{PyDowncastError, PyErr, PyErrArguments, PyErrValue, PyResult};
 pub use crate::gil::{init_once, GILGuard, GILPool};
-pub use crate::instance::{ManagedPyRef, Py, PyNativeType};
+pub use crate::instance::{AsPyRef, ManagedPyRef, Py, PyNativeType};
 pub use crate::object::PyObject;
 pub use crate::objectprotocol::ObjectProtocol;
-pub use crate::pyclass::{PyClass, PyClassAlloc, PyClassShell};
+pub use crate::pyclass::{PyClass, PyClassShell};
 pub use crate::python::{prepare_freethreaded_python, Python};
-pub use crate::type_object::{PyConcreteObject, PyTypeInfo};
+pub use crate::type_object::{type_flags, PyConcreteObject, PyTypeInfo};
 
 // Re-exported for wrap_function
 #[doc(hidden)]
@@ -161,12 +161,14 @@ pub mod ffi;
 pub mod freelist;
 mod gil;
 mod instance;
+#[macro_use]
 mod internal_tricks;
 pub mod marshal;
 mod object;
 mod objectprotocol;
 pub mod prelude;
 pub mod pyclass;
+pub mod pyclass_slots;
 mod python;
 pub mod type_object;
 pub mod types;
diff --git a/src/object.rs b/src/object.rs
@@ -7,7 +7,6 @@ use crate::instance::{AsPyRef, PyNativeType};
 use crate::types::{PyAny, PyDict, PyTuple};
 use crate::{AsPyPointer, Py, Python};
 use crate::{FromPyObject, IntoPy, IntoPyPointer, PyTryFrom, ToBorrowedObject, ToPyObject};
-use std::convert::AsRef;
 use std::ptr::NonNull;
 
 /// A python object
diff --git a/src/pyclass.rs b/src/pyclass.rs
diff --git a/src/pyclass_slots.rs b/src/pyclass_slots.rs
diff --git a/src/type_object.rs b/src/type_object.rs
diff --git a/src/types/any.rs b/src/types/any.rs
diff --git a/src/types/mod.rs b/src/types/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ macro_rules! py_unary_pyref_func {`
`35`	`35`	`where`
`36`	`36`	`T: for<'p> $trait<'p>,`
`37`	`37`	`{`
`38`		`- use $crate::{FromPyPointer, PyClassShell};`
	`38`	`+ use $crate::{pyclass::PyClassShell, FromPyPointer};`
`39`	`39`	`let py = $crate::Python::assume_gil_acquired();`
`40`	`40`	`let _pool = $crate::GILPool::new(py);`
`41`	`41`	`let slf: &mut PyClassShell<T> = FromPyPointer::from_borrowed_ptr_or_panic(py, slf);`