Make it enable to safely inherit native types

Author: kngwyu

pyo3-derive-backend/src/pyclass.rs

@@ -16,6 +16,7 @@ pub struct PyClassArgs {
     pub name: Option<syn::Expr>,
     pub flags: Vec<syn::Expr>,
     pub base: syn::TypePath,
+    pub has_extends: bool,
     pub module: Option<syn::LitStr>,
 }
 
@@ -39,8 +40,9 @@ impl Default for PyClassArgs {
             module: None,
             // We need the 0 as value for the constant we're later building using quote for when there
             // are no other flags
-            flags: vec![parse_quote! {0}],
-            base: parse_quote! {pyo3::types::PyAny},
+            flags: vec![parse_quote! { 0 }],
+            base: parse_quote! { pyo3::types::PyAny },
+            has_extends: false,
         }
     }
 }
@@ -89,6 +91,7 @@ impl PyClassArgs {
                         path: exp.path.clone(),
                         qself: None,
                     };
+                    self.has_extends = true;
                 }
                 _ => {
                     return Err(syn::Error::new_spanned(
@@ -318,7 +321,7 @@ fn impl_class(
             }
         }
     }
-    // TODO: implement dict and weakref
+
     let weakref = if has_weakref {
         quote! { type WeakRef = pyo3::pyclass_slots::PyClassWeakRefSlot; }
     } else {
@@ -355,6 +358,11 @@ fn impl_class(
 
     let base = &attr.base;
     let flags = &attr.flags;
+    let extended = if attr.has_extends {
+        quote! { pyo3::type_flags::EXTENDED }
+    } else {
+        quote! { 0 }
+    };
 
     Ok(quote! {
         impl pyo3::type_object::PyTypeInfo for #cls {
@@ -365,7 +373,7 @@ fn impl_class(
             const NAME: &'static str = #cls_name;
             const MODULE: Option<&'static str> = #module;
             const DESCRIPTION: &'static str = #doc;
-            const FLAGS: usize = #(#flags)|*;
+            const FLAGS: usize = #(#flags)|* | #extended;
 
             #[inline]
             unsafe fn type_object() -> &'static mut pyo3::ffi::PyTypeObject {

src/conversion.rs

@@ -3,7 +3,7 @@
 //! Conversions between various states of rust and python types and their wrappers.
 use crate::err::{self, PyDowncastError, PyResult};
 use crate::object::PyObject;
-use crate::type_object::{PyConcreteObject, PyTypeInfo};
+use crate::type_object::{PyObjectLayout, PyTypeInfo};
 use crate::types::PyAny;
 use crate::types::PyTuple;
 use crate::{ffi, gil, Py, Python};

src/ffi/code.rs

@@ -31,13 +31,6 @@ pub struct PyCodeObject {
     pub co_extra: *mut c_void,
 }
 
-impl Default for PyCodeObject {
-    #[inline]
-    fn default() -> Self {
-        unsafe { ::std::mem::zeroed() }
-    }
-}
-
 /* Masks for co_flags */
 pub const CO_OPTIMIZED: c_int = 0x0001;
 pub const CO_NEWLOCALS: c_int = 0x0002;

src/ffi/complexobject.rs

@@ -27,19 +27,17 @@ extern "C" {
     pub fn PyComplex_ImagAsDouble(op: *mut PyObject) -> c_double;
 }
 
-#[cfg(not(Py_LIMITED_API))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct Py_complex {
     pub real: c_double,
     pub imag: c_double,
 }
 
-#[cfg(not(Py_LIMITED_API))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyComplexObject {
-    _ob_base: PyObject,
+    pub ob_base: PyObject,
     pub cval: Py_complex,
 }
 

src/ffi/datetime.rs

@@ -13,6 +13,22 @@ extern "C" {
     pub static mut PyDictValues_Type: PyTypeObject;
 }
 
+#[repr(C)]
+pub struct PyDictKeysObject {
+    _unused: [u8; 0],
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct PyDictObject {
+    pub ob_base: PyObject,
+    pub ma_used: Py_ssize_t,
+    #[cfg(Py_3_6)]
+    pub ma_version_tag: u64,
+    pub ma_keys: *mut PyDictKeysObject,
+    pub ma_values: *mut *mut PyObject,
+}
+
 #[inline]
 pub unsafe fn PyDict_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)

src/ffi/dictobject.rs

@@ -1,7 +1,6 @@
 use crate::ffi::object::*;
 use std::os::raw::{c_double, c_int};
 
-#[cfg(not(Py_LIMITED_API))]
 #[repr(C)]
 pub struct PyFloatObject {
     pub ob_base: PyObject,

src/ffi/floatobject.rs

@@ -5,13 +5,7 @@ use std::os::raw::c_int;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyListObject {
-    #[cfg(py_sys_config = "Py_TRACE_REFS")]
-    pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config = "Py_TRACE_REFS")]
-    pub _ob_prev: *mut PyObject,
-    pub ob_refcnt: Py_ssize_t,
-    pub ob_type: *mut PyTypeObject,
-    pub ob_size: Py_ssize_t,
+    pub ob_base: PyVarObject,
     pub ob_item: *mut *mut PyObject,
     pub allocated: Py_ssize_t,
 }

src/ffi/listobject.rs

@@ -6,8 +6,10 @@ use std::os::raw::{
 };
 
 /// This is an opaque type in the python c api
-#[repr(transparent)]
-pub struct PyLongObject(*mut c_void);
+#[repr(C)]
+pub struct PyLongObject {
+    _unused: [u8; 0],
+}
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {

src/ffi/longobject.rs

@@ -1,5 +1,5 @@
 use crate::ffi::object::*;
-use crate::ffi::pyport::Py_ssize_t;
+use crate::ffi::pyport::{Py_hash_t, Py_ssize_t};
 use std::os::raw::c_int;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
@@ -11,6 +11,28 @@ extern "C" {
     pub static mut PySetIter_Type: PyTypeObject;
 }
 
+pub const PySet_MINSIZE: usize = 8;
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct setentry {
+    pub key: *mut PyObject,
+    pub hash: Py_hash_t,
+}
+
+#[repr(C)]
+pub struct PySetObject {
+    pub ob_base: PyObject,
+    pub fill: Py_ssize_t,
+    pub used: Py_ssize_t,
+    pub mask: Py_ssize_t,
+    pub table: *mut setentry,
+    pub hash: Py_hash_t,
+    pub finger: Py_ssize_t,
+    pub smalltable: [setentry; PySet_MINSIZE],
+    pub weakreflist: *mut PyObject,
+}
+
 #[inline]
 #[cfg_attr(PyPy, link_name = "PyPyFrozenSet_CheckExact")]
 pub unsafe fn PyFrozenSet_CheckExact(ob: *mut PyObject) -> c_int {