Introduce PyInternalCaster

Author: kngwyu

pyo3-derive-backend/src/method.rs

@@ -65,7 +65,7 @@ impl<'a> FnSpec<'a> {
                     ref pat, ref ty, ..
                 }) => {
                     // skip first argument (cls)
-                    if (fn_type == FnType::FnClass || fn_type == FnType::FnNew) && !has_self {
+                    if fn_type == FnType::FnClass && !has_self {
                         has_self = true;
                         continue;
                     }

src/class/macros.rs

@@ -35,10 +35,10 @@ macro_rules! py_unary_pyref_func {
         where
             T: for<'p> $trait<'p>,
         {
-            use $crate::{pyclass::PyClassShell, FromPyPointer};
+            use $crate::pyclass::PyClassShell;
             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);
+            let slf: &mut PyClassShell<T> = &mut *(slf as *mut PyClassShell<T>);
             let res = $class::$f(slf).into();
             $crate::callback::cb_convert($conv, py, res)
         }

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::PyTypeInfo;
+use crate::type_object::{PyConcreteObject, PyTypeInfo};
 use crate::types::PyAny;
 use crate::types::PyTuple;
 use crate::{ffi, gil, Py, Python};
@@ -393,15 +393,13 @@ where
     #[inline]
     unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v T {
         let value = value.into();
-        let ptr = value as *const _ as *const u8 as *const T;
-        &*ptr
+        T::ConcreteLayout::internal_ref_cast(value)
     }
 
     #[inline]
     unsafe fn try_from_mut_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v mut T {
         let value = value.into();
-        let ptr = value as *const _ as *mut u8 as *mut T;
-        &mut *ptr
+        T::ConcreteLayout::internal_mut_cast(value)
     }
 }
 
@@ -453,10 +451,11 @@ where
     T: PyTypeInfo,
 {
     unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| py.unchecked_downcast(gil::register_owned(py, p)))
+        NonNull::new(ptr).map(|p| T::ConcreteLayout::internal_ref_cast(gil::register_owned(py, p)))
     }
     unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| py.unchecked_downcast(gil::register_borrowed(py, p)))
+        NonNull::new(ptr)
+            .map(|p| T::ConcreteLayout::internal_ref_cast(gil::register_borrowed(py, p)))
     }
 }
 
@@ -465,10 +464,11 @@ where
     T: PyTypeInfo,
 {
     unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| py.unchecked_mut_downcast(gil::register_owned(py, p)))
+        NonNull::new(ptr).map(|p| T::ConcreteLayout::internal_mut_cast(gil::register_owned(py, p)))
     }
     unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| py.unchecked_mut_downcast(gil::register_borrowed(py, p)))
+        NonNull::new(ptr)
+            .map(|p| T::ConcreteLayout::internal_mut_cast(gil::register_borrowed(py, p)))
     }
 }
 

src/instance.rs

@@ -1,11 +1,10 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
 use crate::err::{PyErr, PyResult};
 use crate::gil;
-use crate::instance;
 use crate::object::PyObject;
 use crate::objectprotocol::ObjectProtocol;
 use crate::pyclass::{PyClass, PyClassShell};
-use crate::type_object::PyTypeInfo;
+use crate::type_object::{PyConcreteObject, PyTypeInfo};
 use crate::types::PyAny;
 use crate::{ffi, IntoPy};
 use crate::{AsPyPointer, FromPyObject, IntoPyPointer, Python, ToPyObject};
@@ -36,11 +35,6 @@ 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,
@@ -128,7 +122,8 @@ pub trait AsPyRef<T: PyTypeInfo>: Sized {
 
 impl<T: PyTypeInfo> AsPyRef<T> for Py<T> {
     fn as_ref(&self, _py: Python) -> &T {
-        unsafe { &*(self as *const instance::Py<T> as *const T) }
+        let any = self as *const Py<T> as *const PyAny;
+        unsafe { T::ConcreteLayout::internal_ref_cast(&*any) }
     }
 }
 
@@ -143,8 +138,8 @@ impl<T> IntoPy<PyObject> for Py<T> {
     /// Converts `Py` instance -> PyObject.
     /// Consumes `self` without calling `Py_DECREF()`
     #[inline]
-    fn into_py(self, py: Python) -> PyObject {
-        unsafe { PyObject::from_owned_ptr(py, self.into_ptr()) }
+    fn into_py(self, _py: Python) -> PyObject {
+        unsafe { PyObject::from_not_null(self.into_non_null()) }
     }
 }
 
@@ -161,9 +156,25 @@ impl<T> IntoPyPointer for Py<T> {
     #[inline]
     #[must_use]
     fn into_ptr(self) -> *mut ffi::PyObject {
-        let ptr = self.0.as_ptr();
-        std::mem::forget(self);
-        ptr
+        self.into_non_null().as_ptr()
+    }
+}
+
+impl<'a, T> std::convert::From<&PyClassShell<T>> for Py<T>
+where
+    T: PyClass,
+{
+    fn from(shell: &PyClassShell<T>) -> Self {
+        unsafe { Py::from_borrowed_ptr(shell.as_ptr()) }
+    }
+}
+
+impl<'a, T> std::convert::From<&mut PyClassShell<T>> for Py<T>
+where
+    T: PyClass,
+{
+    fn from(shell: &mut PyClassShell<T>) -> Self {
+        unsafe { Py::from_borrowed_ptr(shell.as_ptr()) }
     }
 }
 

src/pyclass.rs

@@ -3,6 +3,7 @@ use crate::class::methods::{PyMethodDefType, PyMethodsProtocol};
 use crate::conversion::{AsPyPointer, FromPyPointer, ToPyObject};
 use crate::pyclass_slots::{PyClassDict, PyClassWeakRef};
 use crate::type_object::{type_flags, PyConcreteObject, PyTypeObject};
+use crate::types::PyAny;
 use crate::{class, ffi, gil, PyErr, PyObject, PyResult, PyTypeInfo, Python};
 use std::ffi::CString;
 use std::mem::ManuallyDrop;
@@ -112,7 +113,15 @@ impl<T: PyClass> PyClassShell<T> {
     }
 }
 
-impl<T: PyClass> PyConcreteObject for PyClassShell<T> {
+impl<T: PyClass> PyConcreteObject<T> for PyClassShell<T> {
+    unsafe fn internal_ref_cast(obj: &PyAny) -> &T {
+        let shell = obj.as_ptr() as *const PyClassShell<T>;
+        &*(*shell).pyclass
+    }
+    unsafe fn internal_mut_cast(obj: &PyAny) -> &mut T {
+        let shell = obj.as_ptr() as *const PyClassShell<T> as *mut PyClassShell<T>;
+        &mut *(*shell).pyclass
+    }
     unsafe fn py_drop(&mut self, py: Python) {
         ManuallyDrop::drop(&mut self.pyclass);
         self.dict.clear_dict(py);
@@ -121,6 +130,12 @@ impl<T: PyClass> PyConcreteObject for PyClassShell<T> {
     }
 }
 
+impl<T: PyClass> AsPyPointer for PyClassShell<T> {
+    fn as_ptr(&self) -> *mut ffi::PyObject {
+        (self as *const _) as *mut _
+    }
+}
+
 impl<T: PyClass> std::ops::Deref for PyClassShell<T> {
     type Target = T;
     fn deref(&self) -> &T {
@@ -134,7 +149,13 @@ impl<T: PyClass> std::ops::DerefMut for PyClassShell<T> {
     }
 }
 
-impl<T: PyClass> ToPyObject for PyClassShell<T> {
+impl<T: PyClass> ToPyObject for &PyClassShell<T> {
+    fn to_object(&self, py: Python<'_>) -> PyObject {
+        unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
+    }
+}
+
+impl<T: PyClass> ToPyObject for &mut PyClassShell<T> {
     fn to_object(&self, py: Python<'_>) -> PyObject {
         unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
     }
@@ -145,10 +166,11 @@ where
     T: PyClass,
 {
     unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| &**(gil::register_owned(py, p) as *const _ as *const Self))
+        NonNull::new(ptr).map(|p| &*(gil::register_owned(py, p).as_ptr() as *const PyClassShell<T>))
     }
     unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| &**(gil::register_borrowed(py, p) as *const _ as *const Self))
+        NonNull::new(ptr)
+            .map(|p| &*(gil::register_borrowed(py, p).as_ptr() as *const PyClassShell<T>))
     }
 }
 
@@ -157,10 +179,14 @@ where
     T: PyClass,
 {
     unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| &mut **(gil::register_owned(py, p) as *const _ as *mut Self))
+        NonNull::new(ptr).map(|p| {
+            &mut *(gil::register_owned(py, p).as_ptr() as *const PyClassShell<T> as *mut _)
+        })
     }
     unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|p| &mut **(gil::register_borrowed(py, p) as *const _ as *mut Self))
+        NonNull::new(ptr).map(|p| {
+            &mut *(gil::register_borrowed(py, p).as_ptr() as *const PyClassShell<T> as *mut _)
+        })
     }
 }
 

src/python.rs

@@ -7,7 +7,7 @@ use crate::ffi;
 use crate::gil::{self, GILGuard};
 use crate::instance::AsPyRef;
 use crate::object::PyObject;
-use crate::type_object::{PyTypeInfo, PyTypeObject};
+use crate::type_object::{PyConcreteObject, PyTypeInfo, PyTypeObject};
 use crate::types::{PyAny, PyDict, PyModule, PyType};
 use crate::AsPyPointer;
 use crate::{FromPyPointer, IntoPyPointer, PyTryFrom};
@@ -272,16 +272,6 @@ impl<'p> Python<'p> {
 }
 
 impl<'p> Python<'p> {
-    // TODO(kngwyu): Now offset dies, so what should this functions do
-    pub(crate) unsafe fn unchecked_downcast<T: PyTypeInfo>(self, ob: &PyAny) -> &'p T {
-        &*(ob as *const _ as *const T)
-    }
-
-    #[allow(clippy::cast_ref_to_mut)] // FIXME
-    pub(crate) unsafe fn unchecked_mut_downcast<T: PyTypeInfo>(self, ob: &PyAny) -> &'p mut T {
-        &mut *(ob as *const _ as *mut T)
-    }
-
     /// Register object in release pool, and try to downcast to specific type.
     pub fn checked_cast_as<T>(self, obj: PyObject) -> Result<&'p T, PyDowncastError>
     where
@@ -297,7 +287,7 @@ impl<'p> Python<'p> {
         T: PyTypeInfo,
     {
         let p = gil::register_owned(self, obj.into_nonnull());
-        self.unchecked_downcast(p)
+        T::ConcreteLayout::internal_ref_cast(p)
     }
 
     /// Register `ffi::PyObject` pointer in release pool

src/type_object.rs

@@ -4,24 +4,25 @@
 
 use crate::ffi;
 use crate::instance::Py;
+use crate::instance::PyNativeType;
 use crate::types::PyAny;
 use crate::types::PyType;
 use crate::AsPyPointer;
 use crate::Python;
 use std::ptr::NonNull;
 
 /// TODO: write document
-pub trait PyConcreteObject: Sized {
-    unsafe fn py_drop(&mut self, _py: Python) {}
-}
-
-impl<T: PyConcreteObject> AsPyPointer for T {
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        (self as *const _) as _
+pub trait PyConcreteObject<T>: Sized {
+    unsafe fn internal_ref_cast(obj: &PyAny) -> &T {
+        &*(obj as *const _ as *const T)
     }
+    unsafe fn internal_mut_cast(obj: &PyAny) -> &mut T {
+        &mut *(obj as *const _ as *const T as *mut T)
+    }
+    unsafe fn py_drop(&mut self, _py: Python) {}
 }
 
-impl PyConcreteObject for ffi::PyObject {}
+impl<T: PyNativeType> PyConcreteObject<T> for ffi::PyObject {}
 
 /// Our custom type flags
 pub mod type_flags {
@@ -39,7 +40,7 @@ pub mod type_flags {
 }
 
 /// Python type information.
-pub trait PyTypeInfo {
+pub trait PyTypeInfo: Sized {
     /// Type of objects to store in PyObject struct
     type Type;
 
@@ -59,7 +60,7 @@ pub trait PyTypeInfo {
     type BaseType: PyTypeInfo;
 
     /// Layout
-    type ConcreteLayout: PyConcreteObject;
+    type ConcreteLayout: PyConcreteObject<Self>;
 
     /// PyTypeObject instance for this type, which might still need to
     /// be initialized

tests/test_class_basics.rs

@@ -1,6 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::py_run;
-use pyo3::type_object::initialize_type;
+use pyo3::pyclass::initialize_type;
 
 mod common;
 

tests/test_class_new.rs

@@ -1,14 +1,13 @@
 use pyo3::prelude::*;
-use pyo3::PyRawObject;
 
 #[pyclass]
 struct EmptyClassWithNew {}
 
 #[pymethods]
 impl EmptyClassWithNew {
     #[new]
-    fn new(obj: &PyRawObject) {
-        obj.init(EmptyClassWithNew {});
+    fn new() -> EmptyClassWithNew {
+        EmptyClassWithNew {}
     }
 }
 
@@ -25,15 +24,16 @@ fn empty_class_with_new() {
 }
 
 #[pyclass]
+#[derive(Debug)]
 struct NewWithOneArg {
     _data: i32,
 }
 
 #[pymethods]
 impl NewWithOneArg {
     #[new]
-    fn new(obj: &PyRawObject, arg: i32) {
-        obj.init(NewWithOneArg { _data: arg })
+    fn new(arg: i32) -> NewWithOneArg {
+        NewWithOneArg { _data: arg }
     }
 }
 
@@ -56,11 +56,11 @@ struct NewWithTwoArgs {
 #[pymethods]
 impl NewWithTwoArgs {
     #[new]
-    fn new(obj: &PyRawObject, arg1: i32, arg2: i32) {
-        obj.init(NewWithTwoArgs {
+    fn new(arg1: i32, arg2: i32) -> Self {
+        NewWithTwoArgs {
             _data1: arg1,
             _data2: arg2,
-        })
+        }
     }
 }