refactor ToPyObject

src/conversion.rs

@@ -1,16 +1,16 @@
 use ffi;
 use err::PyResult;
-use pointers::{pptr, PyPtr};
+use pointers::pptr;
 use python::{Python, ToPythonPointer};
 use objects::{PyObject, PyTuple};
-use token::PyObjectMarker;
+use native::PyNativeObject;
 
 
 /// Conversion trait that allows various objects to be converted into PyObject
 pub trait ToPyObject {
 
     /// Converts self into a Python object.
-    fn to_object<'p>(&self, py: Python<'p>) -> PyPtr<PyObjectMarker>;
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p>;
 
     /// Converts self into a Python object and calls the specified closure
     /// on the native FFI pointer underlying the Python object.
@@ -113,7 +113,7 @@ impl<T> IntoPyObject for T where T: ToPyObject
 impl <'a, T: ?Sized> ToPyObject for &'a T where T: ToPyObject {
 
     #[inline]
-    default fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    default fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         <T as ToPyObject>::to_object(*self, py)
     }
 
@@ -129,10 +129,10 @@ impl <'a, T: ?Sized> ToPyObject for &'a T where T: ToPyObject {
 /// `Option::None` is converted to Python `None`.
 impl <T> ToPyObject for Option<T> where T: ToPyObject {
 
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         match *self {
             Some(ref val) => val.to_object(py),
-            None => py.None().into_pobject(),
+            None => py.None().into_object(py),
         }
     }
 }
@@ -150,8 +150,8 @@ impl<T> IntoPyObject for Option<T> where T: IntoPyObject {
 
 /// `()` is converted to Python `None`.
 impl ToPyObject for () {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        py.None().into_pobject()
+        py.None().into_object(py)
     }
 }
 

src/err.rs

@@ -4,11 +4,10 @@ use std::os::raw::c_char;
 use libc;
 
 use ffi;
-use pointers::{pptr, PyPtr};
+use pointers::pptr;
 use python::{ToPythonPointer, IntoPythonPointer, Python};
 use objects::{PyObject, PyType, exc};
 use native::PyNativeObject;
-use token::PyObjectMarker;
 use typeob::{PyTypeObject};
 use conversion::{ToPyObject, ToPyTuple, IntoPyObject};
 
@@ -117,9 +116,9 @@ impl PyErr {
     /// Example:
     ///  `return Err(PyErr::new::<exc::TypeError, _>(py, "Error message"));`
     pub fn new<T, V>(py: Python, value: V) -> PyErr
-        where T: PyTypeObject, V: ToPyObject
+        where T: PyTypeObject, V: IntoPyObject
     {
-        PyErr::new_helper(py, py.get_type::<T>().park(), value.to_object(py))
+        PyErr::new_helper(py, py.get_type::<T>().park(), value.into_object(py))
     }
 
     /// Gets whether an error is present in the Python interpreter's global state.
@@ -184,11 +183,11 @@ impl PyErr {
         }
     }
 
-    fn new_helper(_py: Python, ty: pptr, value: PyPtr<PyObjectMarker>) -> PyErr {
+    fn new_helper(_py: Python, ty: pptr, value: pptr) -> PyErr {
         assert!(unsafe { ffi::PyExceptionClass_Check(ty.as_ptr()) } != 0);
         PyErr {
             ptype: ty,
-            pvalue: Some(value.park()),
+            pvalue: Some(value),
             ptraceback: None
         }
     }
@@ -198,21 +197,21 @@ impl PyErr {
     /// `obj` must be an Python exception instance, the PyErr will use that instance.
     /// If `obj` is a Python exception type object, the PyErr will (lazily) create a new instance of that type.
     /// Otherwise, a `TypeError` is created instead.
-    pub fn from_instance<O>(py: Python, obj: O) -> PyErr where O: ToPyObject {
+    pub fn from_instance<O>(py: Python, obj: O) -> PyErr where O: IntoPyObject {
-        PyErr::from_instance_helper(py, obj.to_object(py))
+        PyErr::from_instance_helper(py, obj.into_object(py))
     }
 
-    fn from_instance_helper<'p>(py: Python, obj: PyPtr<PyObjectMarker>) -> PyErr {
+    fn from_instance_helper<'p>(py: Python, obj: pptr) -> PyErr {
         if unsafe { ffi::PyExceptionInstance_Check(obj.as_ptr()) } != 0 {
             PyErr {
                 ptype: unsafe { pptr::from_borrowed_ptr(
                     ffi::PyExceptionInstance_Class(obj.as_ptr())) },
-                pvalue: Some(obj.park()),
+                pvalue: Some(obj),
                 ptraceback: None
             }
         } else if unsafe { ffi::PyExceptionClass_Check(obj.as_ptr()) } != 0 {
             PyErr {
-                ptype: obj.park(),
+                ptype: obj,
                 pvalue: None,
                 ptraceback: None
             }

src/lib.rs

@@ -71,7 +71,7 @@ mod ppptr;
 pub use ppptr::{pyptr};
 
 mod token;
-pub use token::{PyObjectMarker, PythonToken, PythonObjectWithToken, PythonObjectWithGilToken};
+pub use token::{PythonToken, PythonObjectWithToken, PythonObjectWithGilToken};
 
 pub use err::{PyErr, PyResult, PyDowncastError};
 pub use objects::*;

src/native.rs

@@ -1,7 +1,6 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
 
-use pointers::{pptr, PyPtr};
+use pointers::pptr;
-use token::PyObjectMarker;
 use objects::PyObject;
 
 pub trait PyBaseObject : Sized {}
@@ -12,8 +11,6 @@ pub trait PyNativeObject<'p> : PyBaseObject {
 
     fn as_object(self) -> PyObject<'p>;
 
-    fn into_object(self) -> PyPtr<PyObjectMarker>;
-
     fn clone_object(&self) -> Self;
 
 }

src/objectprotocol.rs

@@ -479,7 +479,7 @@ mod test {
         use std::cmp::Ordering;
         let gil = Python::acquire_gil();
         let py = gil.python();
-        let one = 1i32.to_object(py).into_object(py);
+        let one = 1i32.to_object(py);
         assert_eq!(one.compare(1).unwrap(), Ordering::Equal);
         assert_eq!(one.compare(2).unwrap(), Ordering::Less);
         assert_eq!(one.compare(0).unwrap(), Ordering::Greater);

src/objects/boolobject.rs

@@ -1,7 +1,7 @@
-use ::{pyptr, PyPtr};
+use pyptr;
 use ffi;
-use token::PyObjectMarker;
 use python::{ToPythonPointer, Python};
+use objects::PyObject;
 use native::PyNativeObject;
 use conversion::ToPyObject;
 
@@ -29,8 +29,8 @@ impl<'p> PyBool<'p> {
 /// Converts a rust `bool` to a Python `bool`.
 impl ToPyObject for bool {
     #[inline]
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyBool::new(py, *self).into_object()
+        PyBool::new(py, *self).as_object()
     }
 
     #[inline]
@@ -62,7 +62,7 @@ mod test {
         let py = gil.python();
         assert!(py.True().is_true());
         assert_eq!(true, py.True().as_object().extract().unwrap());
-        assert!(true.to_object(py).into_object(py) == py.True().as_object());
+        assert!(true.to_object(py) == py.True().as_object());
     }
 
     #[test]
@@ -71,6 +71,6 @@ mod test {
         let py = gil.python();
         assert!(!py.False().is_true());
         assert_eq!(false, py.False().as_object().extract().unwrap());
-        assert!(false.to_object(py).into_object(py) == py.False().as_object());
+        assert!(false.to_object(py) == py.False().as_object());
     }
 }

src/objects/bytearray.rs

@@ -93,7 +93,7 @@ mod test {
         assert_eq!(src, bytearray.data());
 
         let ba = bytearray.to_object(py);
-        let bytearray = PyByteArray::from(ba.as_object(py)).unwrap();
+        let bytearray = PyByteArray::from(&ba).unwrap();
         assert_eq!(src.len(), bytearray.len());
         assert_eq!(src, bytearray.data());
 

src/objects/dict.rs

@@ -2,15 +2,16 @@
 //
 // based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
 
-use ::pyptr;
+use std::{mem, collections, hash, cmp};
+
 use ffi;
-use pointers::PyPtr;
+use pyptr;
 use python::{Python, ToPythonPointer, PyDowncastInto};
 use conversion::{ToPyObject};
 use objects::{PyObject, PyList};
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::PythonObjectWithGilToken;
 use err::{self, PyResult, PyErr};
-use std::{mem, collections, hash, cmp};
+use native::PyNativeObject;
 
 /// Represents a Python `dict`.
 pub struct PyDict<'p>(pyptr<'p>);
@@ -129,12 +130,12 @@ impl <K, V> ToPyObject for collections::HashMap<K, V>
     where K: hash::Hash+cmp::Eq+ToPyObject,
           V: ToPyObject
 {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         let dict = PyDict::new(py);
         for (key, value) in self {
             dict.set_item(key, value).unwrap();
         };
-        dict.to_object(py)
+        dict.as_object()
     }
 }
 
@@ -142,19 +143,19 @@ impl <K, V> ToPyObject for collections::BTreeMap<K, V>
     where K: cmp::Eq+ToPyObject,
           V: ToPyObject
 {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         let dict = PyDict::new(py);
         for (key, value) in self {
             dict.set_item(key, value).unwrap();
         };
-        dict.to_object(py)
+        dict.as_object()
     }
 }
 
 #[cfg(test)]
 mod test {
     use std::collections::{BTreeMap, HashMap};
-    use python::{Python, PyDowncastInto};
+    use python::Python;
     use conversion::ToPyObject;
     use objects::{PyDict, PyTuple};
     use ::PyDowncastFrom;
@@ -166,11 +167,11 @@ mod test {
         let py = gil.python();
         let mut v = HashMap::new();
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert_eq!(0, dict.len());
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict2 = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict2 = PyDict::downcast_from(&ob).unwrap();
         assert_eq!(1, dict2.len());
     }
 
@@ -181,7 +182,7 @@ mod test {
         let mut v = HashMap::new();
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert_eq!(true, dict.contains(7i32).unwrap());
         assert_eq!(false, dict.contains(8i32).unwrap());
     }
@@ -193,7 +194,7 @@ mod test {
         let mut v = HashMap::new();
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert_eq!(32, dict.get_item(7i32).unwrap().extract::<i32>().unwrap());
         assert_eq!(None, dict.get_item(8i32));
     }
@@ -205,7 +206,7 @@ mod test {
         let mut v = HashMap::new();
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert!(dict.set_item(7i32, 42i32).is_ok()); // change
         assert!(dict.set_item(8i32, 123i32).is_ok()); // insert
         assert_eq!(42i32, dict.get_item(7i32).unwrap().extract::<i32>().unwrap());
@@ -219,7 +220,7 @@ mod test {
         let mut v = HashMap::new();
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert!(dict.set_item(7i32, 42i32).is_ok()); // change
         assert!(dict.set_item(8i32, 123i32).is_ok()); // insert
         assert_eq!(32i32, *v.get(&7i32).unwrap()); // not updated!
@@ -234,7 +235,7 @@ mod test {
         let mut v = HashMap::new();
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert!(dict.del_item(7i32).is_ok());
         assert_eq!(0, dict.len());
         assert_eq!(None, dict.get_item(7i32));
@@ -247,7 +248,7 @@ mod test {
         let mut v = HashMap::new();
         v.insert(7, 32);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         assert!(dict.del_item(7i32).is_ok()); // change
         assert_eq!(32i32, *v.get(&7i32).unwrap()); // not updated!
     }
@@ -260,7 +261,8 @@ mod test {
         v.insert(7, 32);
         v.insert(8, 42);
         v.insert(9, 123);
-        let dict = PyDict::downcast_into(py, v.to_object(py)).unwrap();
+        let ob = v.to_object(py);
+        let dict = PyDict::downcast_from(&ob).unwrap();
         // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
         let mut key_sum = 0;
         let mut value_sum = 0;
@@ -282,7 +284,7 @@ mod test {
         v.insert(8, 42);
         v.insert(9, 123);
         let ob = v.to_object(py);
-        let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
+        let dict = PyDict::downcast_from(&ob).unwrap();
         // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
         let mut key_sum = 0;
         let mut value_sum = 0;
@@ -303,7 +305,7 @@ mod test {
         map.insert(1, 1);
 
         let m = map.to_object(py);
-        let py_map = PyDict::downcast_from(m.as_object(py)).unwrap();
+        let py_map = PyDict::downcast_from(&m).unwrap();
 
         assert!(py_map.len() == 1);
         assert!( py_map.get_item(1).unwrap().extract::<i32>().unwrap() == 1);
@@ -318,7 +320,7 @@ mod test {
         map.insert(1, 1);
 
         let m = map.to_object(py);
-        let py_map = PyDict::downcast_from(m.as_object(py)).unwrap();
+        let py_map = PyDict::downcast_from(&m).unwrap();
 
         assert!(py_map.len() == 1);
         assert!( py_map.get_item(1).unwrap().extract::<i32>().unwrap() == 1);

src/objects/iterator.rs

@@ -66,7 +66,7 @@ mod tests {
     fn vec_iter() {
         let gil_guard = Python::acquire_gil();
         let py = gil_guard.python();
-        let obj = vec![10, 20].to_object(py).into_object(py);
+        let obj = vec![10, 20].to_object(py);
         let mut it = obj.iter().unwrap();
         assert_eq!(10, it.next().unwrap().unwrap().extract().unwrap());
         assert_eq!(20, it.next().unwrap().unwrap().extract().unwrap());

src/objects/list.rs

@@ -5,10 +5,9 @@
 use ::pyptr;
 use err::{self, PyResult};
 use ffi::{self, Py_ssize_t};
-use pointers::PyPtr;
 use python::{Python, ToPythonPointer, IntoPythonPointer};
 use objects::PyObject;
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::PythonObjectWithGilToken;
 use conversion::{ToPyObject, IntoPyObject};
 
 /// Represents a Python `list`.
@@ -103,21 +102,21 @@ impl <'p> Iterator for PyListIterator<'p> {
 
 impl <T> ToPyObject for [T] where T: ToPyObject {
 
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         unsafe {
             let ptr = ffi::PyList_New(self.len() as Py_ssize_t);
             for (i, e) in self.iter().enumerate() {
                 let obj = e.to_object(py).into_ptr();
                 ffi::PyList_SetItem(ptr, i as Py_ssize_t, obj);
             }
-            PyPtr::from_owned_ptr_or_panic(ptr)
+            PyObject::from_owned_ptr_or_panic(py, ptr)
         }
     }
 }
 
 impl <T> ToPyObject for Vec<T> where T: ToPyObject {
 
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         self.as_slice().to_object(py)
     }
 
@@ -170,7 +169,7 @@ mod test {
         let py = gil.python();
         let v = vec![2, 3, 5, 7];
         let list = PyList::downcast_into(py, v.to_object(py)).unwrap();
-        let val = 42i32.to_object(py).into_object(py);
+        let val = 42i32.to_object(py);
         assert_eq!(2, list.get_item(0).extract::<i32>().unwrap());
         list.set_item(0, val).unwrap();
         assert_eq!(42, list.get_item(0).extract::<i32>().unwrap());
@@ -182,7 +181,7 @@ mod test {
         let py = gil.python();
         let v = vec![2, 3, 5, 7];
         let list = PyList::downcast_into(py, v.to_object(py)).unwrap();
-        let val = 42i32.to_object(py).into_object(py);
+        let val = 42i32.to_object(py);
         assert_eq!(4, list.len());
         assert_eq!(2, list.get_item(0).extract::<i32>().unwrap());
         list.insert_item(0, val).unwrap();

src/objects/mod.rs

@@ -57,9 +57,6 @@ macro_rules! pyobject_nativetype(
             fn as_object(self) -> $crate::PyObject<'p> {
                 unsafe { $crate::std::mem::transmute(self) }
             }
-            fn into_object(self) -> $crate::PyPtr<$crate::PyObjectMarker> {
-                unsafe { $crate::std::mem::transmute(self) }
-            }
             fn clone_object(&self) -> $name<'p> {
                 use $crate::{ToPythonPointer, PythonObjectWithGilToken};
                 unsafe {
@@ -177,9 +174,8 @@ macro_rules! pyobject_nativetype(
         impl<'a> $crate::ToPyObject for $name<'a>
         {
             #[inline]
-            fn to_object<'p>(&self, _py: $crate::Python<'p>)
+            fn to_object<'p>(&self, py: $crate::Python<'p>) -> $crate::PyObject<'p> {
-                             -> $crate::PyPtr<$crate::PyObjectMarker> {
+                $crate::PyObject::from_borrowed_ptr(py, self.0.as_ptr())
-                unsafe { $crate::PyPtr::from_borrowed_ptr(self.0.as_ptr()) }
             }
 
             #[inline]

src/objects/num.rs

@@ -7,13 +7,14 @@ extern crate num_traits;
 use self::num_traits::cast::cast;
 use std::os::raw::{c_long, c_double};
 
-use ::{PyPtr, pyptr};
 use ffi;
-use super::exc;
+use pyptr;
+use objects::exc;
 use objects::PyObject;
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::PythonObjectWithGilToken;
 use python::{ToPythonPointer, Python};
 use err::{PyResult, PyErr};
+use native::PyNativeObject;
 use conversion::{ToPyObject, FromPyObject};
 
 /// Represents a Python `int` object.
@@ -53,9 +54,9 @@ impl<'p> PyFloat<'p> {
 macro_rules! int_fits_c_long(
     ($rust_type:ty) => (
         impl ToPyObject for $rust_type {
-            fn to_object(&self, _py: Python) -> PyPtr<PyObjectMarker> {
+            fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
                 unsafe {
-                    PyPtr::from_owned_ptr_or_panic(ffi::PyLong_FromLong(*self as c_long))
+                    PyObject::from_owned_ptr_or_panic(py, ffi::PyLong_FromLong(*self as c_long))
                 }
             }
         }
@@ -78,7 +79,7 @@ macro_rules! int_fits_larger_int(
     ($rust_type:ty, $larger_type:ty) => (
         impl ToPyObject for $rust_type {
             #[inline]
-            fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+            fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
                 (*self as $larger_type).to_object(py)
             }
         }
@@ -108,10 +109,10 @@ fn err_if_invalid_value<'p, T: PartialEq>
 macro_rules! int_convert_u64_or_i64 (
     ($rust_type:ty, $pylong_from_ll_or_ull:expr, $pylong_as_ull_or_ull:expr) => (
         impl ToPyObject for $rust_type {
-
+            #[inline]
-            fn to_object(&self, _py: Python) -> PyPtr<PyObjectMarker> {
+            fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
                 unsafe {
-                    PyPtr::from_owned_ptr_or_panic($pylong_from_ll_or_ull(*self))
+                    PyObject::from_owned_ptr_or_panic(py, $pylong_from_ll_or_ull(*self))
                 }
             }
         }
@@ -169,8 +170,8 @@ int_fits_larger_int!(usize, u64);
 int_convert_u64_or_i64!(u64, ffi::PyLong_FromUnsignedLongLong, ffi::PyLong_AsUnsignedLongLong);
 
 impl ToPyObject for f64 {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyFloat::new(py, *self).to_object(py)
+        PyFloat::new(py, *self).as_object()
     }
 }
 
@@ -188,8 +189,8 @@ fn overflow_error(py: Python) -> PyErr {
 }
 
 impl ToPyObject for f32 {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyFloat::new(py, *self as f64).to_object(py)
+        PyFloat::new(py, *self as f64).as_object()
     }
 }
 
@@ -210,7 +211,7 @@ mod test {
                 let gil = Python::acquire_gil();
                 let py = gil.python();
                 let val = 123 as $t1;
-                let obj = val.to_object(py).into_object(py);
+                let obj = val.to_object(py);
                 assert_eq!(obj.extract::<$t2>().unwrap(), val as $t2);
             }
         )
@@ -239,7 +240,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = std::u32::MAX;
-        let obj = v.to_object(py).into_object(py);
+        let obj = v.to_object(py);
         assert_eq!(v, obj.extract::<u32>().unwrap());
         assert_eq!(v as u64, obj.extract::<u64>().unwrap());
         assert!(obj.extract::<i32>().is_err());
@@ -250,7 +251,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = std::i64::MAX;
-        let obj = v.to_object(py).into_object(py);
+        let obj = v.to_object(py);
         assert_eq!(v, obj.extract::<i64>().unwrap());
         assert_eq!(v as u64, obj.extract::<u64>().unwrap());
         assert!(obj.extract::<u32>().is_err());
@@ -261,7 +262,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = std::i64::MIN;
-        let obj = v.to_object(py).into_object(py);
+        let obj = v.to_object(py);
         assert_eq!(v, obj.extract::<i64>().unwrap());
         assert!(obj.extract::<i32>().is_err());
         assert!(obj.extract::<u64>().is_err());
@@ -272,7 +273,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = std::u64::MAX;
-        let obj = v.to_object(py).into_object(py);
+        let obj = v.to_object(py);
         assert_eq!(v, obj.extract::<u64>().unwrap());
         assert!(obj.extract::<i64>().is_err());
     }

src/objects/object.rs

@@ -26,6 +26,12 @@ impl<'p> PyObject<'p> {
         unsafe { Ok(PyObject(pyptr::from_owned_ptr_or_err(py, ptr)?)) }
     }
 
+    #[inline]
+    pub fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut ffi::PyObject)
+                                   -> PyObject<'p> {
+        unsafe { PyObject(pyptr::from_owned_ptr_or_panic(py, ptr)) }
+    }
+
     #[inline]
     pub fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject)
                                      -> Option<PyObject<'p>> {

src/objects/sequence.rs

@@ -259,7 +259,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = 42i32;
-        assert!(v.to_object(py).into_object(py).cast_into::<PySequence>(py).is_err());
+        assert!(v.to_object(py).cast_into::<PySequence>(py).is_err());
     }
 
     #[test]
@@ -267,17 +267,17 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = "London Calling";
-        assert!(v.to_object(py).into_object(py).cast_into::<PySequence>(py).is_ok());
+        assert!(v.to_object(py).cast_into::<PySequence>(py).is_ok());
     }
     #[test]
     fn test_seq_empty() {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert_eq!(0, seq.len().unwrap());
 
-        let needle = 7i32.to_object(py).into_object(py);
+        let needle = 7i32.to_object(py);
         assert_eq!(false, seq.contains(&needle).unwrap());
     }
 
@@ -286,16 +286,16 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert_eq!(6, seq.len().unwrap());
 
-        let bad_needle = 7i32.to_object(py).into_object(py);
+        let bad_needle = 7i32.to_object(py);
         assert_eq!(false, seq.contains(&bad_needle).unwrap());
 
-        let good_needle = 8i32.to_object(py).into_object(py);
+        let good_needle = 8i32.to_object(py);
         assert_eq!(true, seq.contains(&good_needle).unwrap());
 
-        let type_coerced_needle = 8f32.to_object(py).into_object(py);
+        let type_coerced_needle = 8f32.to_object(py);
         assert_eq!(true, seq.contains(&type_coerced_needle).unwrap());
     }
 
@@ -304,7 +304,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
         assert_eq!(1, seq.get_item(1).unwrap().extract::<i32>().unwrap());
         assert_eq!(2, seq.get_item(2).unwrap().extract::<i32>().unwrap());
@@ -328,7 +328,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert!(seq.del_item(10).is_err());
         assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
         assert!(seq.del_item(0).is_ok());
@@ -351,7 +351,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert_eq!(0, seq.index(1i32).unwrap());
         assert_eq!(2, seq.index(2i32).unwrap());
         assert_eq!(3, seq.index(3i32).unwrap());
@@ -365,7 +365,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert_eq!(2, seq.count(1i32).unwrap());
         assert_eq!(1, seq.count(2i32).unwrap());
         assert_eq!(1, seq.count(3i32).unwrap());
@@ -379,7 +379,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         let mut idx = 0;
         for el in seq.iter().unwrap() {
             assert_eq!(v[idx], el.unwrap().extract::<i32>().unwrap());
@@ -393,7 +393,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = vec!["It", "was", "the", "worst", "of", "times"];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
 
         let bad_needle = "blurst".to_object(py);
         assert_eq!(false, seq.contains(bad_needle).unwrap());
@@ -407,7 +407,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v : Vec<i32> = vec![1, 2, 3];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         let concat_seq = seq.concat(&seq).unwrap();
         assert_eq!(6, concat_seq.len().unwrap());
         let concat_v : Vec<i32> = vec![1, 2, 3, 1, 2, 3];
@@ -421,7 +421,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = "string";
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         let concat_seq = seq.concat(&seq).unwrap();
         assert_eq!(12, concat_seq.len().unwrap());
         /*let concat_v = "stringstring".to_owned();
@@ -435,7 +435,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = vec!["foo", "bar"];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         let repeat_seq = seq.repeat(3).unwrap();
         assert_eq!(6, repeat_seq.len().unwrap());
         let repeated = vec!["foo", "bar", "foo", "bar", "foo", "bar"];
@@ -449,7 +449,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = vec!["foo", "bar"];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert!(seq.list().is_ok());
     }
 
@@ -467,7 +467,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = ("foo", "bar");
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert!(seq.tuple().is_ok());
     }
 
@@ -476,7 +476,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let v = vec!["foo", "bar"];
-        let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
+        let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
         assert!(seq.tuple().is_ok());
     }
 

src/objects/set.rs

@@ -3,14 +3,13 @@
 
 use std::{hash, collections};
 use ffi;
-use pointers::PyPtr;
+use pyptr;
 use python::{Python, ToPythonPointer};
 use conversion::ToPyObject;
-use objects::{PyObject, PyIterator};
+use objects::PyObject;
 use err::{self, PyResult, PyErr};
-use pyptr;
+use native::PyNativeObject;
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::{PythonObjectWithGilToken};
-use objectprotocol::ObjectProtocol;
 
 
 /// Represents a Python `set`
@@ -80,34 +79,29 @@ impl<'p> PySet<'p> {
                 ffi::PySet_Pop(self.as_ptr()))
         }
     }
-
-    #[inline]
-    pub fn iter(&self) -> PyResult<PyIterator<'p>> {
-        Ok(self.to_object(self.gil()).into_object(self.gil()).iter()?)
-    }
 }
 
 impl<T> ToPyObject for collections::HashSet<T>
    where T: hash::Hash + Eq + ToPyObject
 {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         let set = PySet::new::<T>(py, &[]);
         for val in self {
             set.add(val).unwrap();
         }
-        set.to_object(py)
+        set.as_object()
     }
 }
 
 impl<T> ToPyObject for collections::BTreeSet<T>
    where T: hash::Hash + Eq + ToPyObject
 {
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
         let set = PySet::new::<T>(py, &[]);
         for val in self {
             set.add(val).unwrap();
         }
-        set.to_object(py)
+        set.as_object()
     }
 }
 
@@ -141,18 +135,15 @@ impl<'p> PyFrozenSet<'p> {
             }
         })
     }
-
-    #[inline]
-    pub fn iter(&self) -> PyResult<PyIterator<'p>> {
-        Ok(self.to_object(self.gil()).into_object(self.gil()).iter()?)
-    }
 }
 
 #[cfg(test)]
 mod test {
     use std::collections::{HashSet};
-    use python::{Python, PyDowncastFrom};
+    use python::{Python, PyDowncastInto};
+    use native::PyNativeObject;
     use conversion::ToPyObject;
+    use objectprotocol::ObjectProtocol;
     use super::{PySet, PyFrozenSet};
 
     #[test]
@@ -171,11 +162,11 @@ mod test {
 
         let mut v = HashSet::new();
         let ob = v.to_object(py);
-        let set = PySet::downcast_from(ob.as_object(py)).unwrap();
+        let set = PySet::downcast_into(py, ob.as_object()).unwrap();
         assert_eq!(0, set.len());
         v.insert(7);
         let ob = v.to_object(py);
-        let set2 = PySet::downcast_from(ob.as_object(py)).unwrap();
+        let set2 = PySet::downcast_into(py, ob.as_object()).unwrap();
         assert_eq!(1, set2.len());
     }
 

src/objects/slice.rs

@@ -3,12 +3,13 @@
 use std::os::raw::c_long;
 
 use ::pyptr;
-use pointers::PyPtr;
 use python::{ToPythonPointer, Python};
 use err::{PyErr, PyResult};
 use ffi::{self, Py_ssize_t};
+use native::PyNativeObject;
+use objects::PyObject;
 use conversion::ToPyObject;
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::PythonObjectWithGilToken;
 
 /// Represents a Python `slice` indices
 pub struct PySliceIndices {
@@ -78,7 +79,7 @@ impl<'p> PySlice<'p> {
 }
 
 impl ToPyObject for PySliceIndices {
-    fn to_object<'p>(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PySlice::new(py, self.start, self.stop, self.step).to_object(py)
+        PySlice::new(py, self.start, self.stop, self.step).as_object()
     }
 }

src/objects/string.rs

@@ -8,12 +8,13 @@ use std::ascii::AsciiExt;
 use std::borrow::Cow;
 use std::os::raw::c_char;
 
-use ::{PyPtr, pyptr};
 use ffi;
+use pyptr;
 use python::{ToPythonPointer, Python};
 use super::{exc, PyObject};
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::PythonObjectWithGilToken;
 use err::{PyResult, PyErr};
+use native::PyNativeObject;
 use conversion::{ToPyObject, RefFromPyObject};
 
 /// Represents a Python string.
@@ -220,8 +221,8 @@ impl<'p> PyBytes<'p> {
 /// See `PyString::new` for details on the conversion.
 impl ToPyObject for str {
     #[inline]
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyString::new(py, self).to_object(py)
+        PyString::new(py, self).as_object()
     }
 }
 
@@ -229,8 +230,8 @@ impl ToPyObject for str {
 /// See `PyString::new` for details on the conversion.
 impl <'a> ToPyObject for Cow<'a, str> {
     #[inline]
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyString::new(py, self).to_object(py)
+        PyString::new(py, self).as_object()
     }
 }
 
@@ -238,8 +239,8 @@ impl <'a> ToPyObject for Cow<'a, str> {
 /// See `PyString::new` for details on the conversion.
 impl ToPyObject for String {
     #[inline]
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyString::new(py, self).to_object(py)
+        PyString::new(py, self).as_object()
     }
 }
 
@@ -271,6 +272,7 @@ impl<'p> RefFromPyObject<'p> for str {
 #[cfg(test)]
 mod test {
     use python::Python;
+    use native::PyNativeObject;
     use conversion::{ToPyObject, RefFromPyObject};
 
     #[test]
@@ -279,7 +281,7 @@ mod test {
         let py = gil.python();
         let s = "\u{1F30F}";
         let py_string = s.to_object(py);
-        assert_eq!(s, py_string.as_object(py).extract::<String>().unwrap());
+        assert_eq!(s, py_string.as_object().extract::<String>().unwrap());
     }
 
     #[test]
@@ -289,7 +291,7 @@ mod test {
         let s = "Hello Python";
         let py_string = s.to_object(py);
         let mut called = false;
-        RefFromPyObject::with_extracted(&py_string.as_object(py),
+        RefFromPyObject::with_extracted(&py_string.as_object(),
             |s2: &str| {
                 assert_eq!(s, s2);
                 called = true;

src/objects/tuple.rs

@@ -4,13 +4,14 @@
 
 use std::slice;
 
-use ::{PyPtr, pyptr};
+use pyptr;
 use ffi::{self, Py_ssize_t};
 use err::{PyErr, PyResult};
 use python::{Python, ToPythonPointer, IntoPythonPointer};
 use conversion::{FromPyObject, ToPyObject, ToPyTuple, IntoPyObject};
 use objects::PyObject;
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use native::PyNativeObject;
+use token::PythonObjectWithGilToken;
 use super::exc;
 
 /// Represents a Python tuple object.
@@ -108,10 +109,10 @@ fn wrong_tuple_length(py: Python, t: &PyTuple, expected_length: usize) -> PyErr
 
 macro_rules! tuple_conversion ({$length:expr,$(($refN:ident, $n:tt, $T:ident)),+} => {
     impl <$($T: ToPyObject),+> ToPyObject for ($($T,)+) {
-        fn to_object<'p>(&self, py: Python<'p>) -> PyPtr<PyObjectMarker> {
+        fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
             PyTuple::new(py, &[
                 $(py_coerce_expr!(self.$n.to_object(py)),)+
-            ]).to_object(py)
+            ]).as_object()
         }
     }
 
@@ -125,7 +126,6 @@ macro_rules! tuple_conversion ({$length:expr,$(($refN:ident, $n:tt, $T:ident)),+
 
     impl<'s, $($T: FromPyObject<'s>),+> FromPyObject<'s> for ($($T,)+) {
         fn extract(obj: &'s PyObject<'s>) -> PyResult<Self>
-            //where S: ::typeob::PyTypeInfo
         {
             let t = try!(obj.cast_as::<PyTuple>());
             let slice = t.as_slice();
@@ -174,8 +174,8 @@ pub struct NoArgs;
 /// Converts `NoArgs` to an empty Python tuple.
 impl ToPyObject for NoArgs {
 
-    fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        PyTuple::empty(py).to_object(py)
+        PyTuple::empty(py).as_object()
     }
 }
 

src/pointers.rs

@@ -10,7 +10,7 @@ use err::{PyErr, PyResult, PyDowncastError};
 use conversion::{ToPyObject, IntoPyObject};
 use objects::PyObject;
 use python::{Python, ToPythonPointer, IntoPythonPointer};
-use token::{PyObjectMarker, PythonObjectWithGilToken};
+use token::PythonObjectWithGilToken;
 use typeob::{PyTypeInfo, PyObjectAlloc};
 
 
@@ -123,13 +123,6 @@ impl pptr {
         unsafe { std::mem::transmute(self) }
     }
 
-    /// Converts `pptr` instance -> PyObject<'p>
-    /// Consumes `self` without calling `Py_DECREF()`
-    #[inline]
-    pub fn into_pobject(self) -> PyPtr<PyObjectMarker> {
-        unsafe { std::mem::transmute(self) }
-    }
-
     /// Clone self, Calls Py_INCREF() on the ptr.
     #[inline]
     pub fn clone_ref(&self, _py: Python) -> pptr {
@@ -503,15 +496,6 @@ impl<'p, T> Py<'p, T>
         ptr
     }
 
-    /// Converts Py<'p, T> -> Py<'p, PyObject>
-    /// Consumes `self` without calling `Py_DECREF()`
-    #[inline]
-    pub fn into_object(self) -> Py<'p, PyObjectMarker> {
-        let p = Py {inner: self.inner, _t: PhantomData, py: self.py};
-        std::mem::forget(self);
-        p
-    }
-
     /// Converts Py<'p, T> -> PyObject<'p>. Calls Py_INCREF() on the ptr.
     #[inline]
     pub fn as_pyobject(&self) -> &PyObject<'p> {
@@ -801,8 +785,8 @@ impl<'source, T> ::FromPyObject<'source> for Py<'source, T> where T: PyTypeInfo
 impl <'a, T> ToPyObject for Py<'a, T> {
 
     #[inline]
-    default fn to_object<'p>(&self, _py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        unsafe { PyPtr::from_borrowed_ptr(self.inner) }
+        PyObject::from_borrowed_ptr(py, self.inner)
     }
 
     #[inline]
@@ -816,8 +800,8 @@ impl <'a, T> ToPyObject for Py<'a, T> {
 impl<T> ToPyObject for PyPtr<T> {
 
     #[inline]
-    default fn to_object(&self, _py: Python) -> PyPtr<PyObjectMarker> {
+    fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
-        unsafe { PyPtr::from_borrowed_ptr(self.inner) }
+        PyObject::from_borrowed_ptr(py, self.inner)
     }
 
     #[inline]

src/token.rs

@@ -1,13 +1,9 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
 
-use std::fmt;
 use std::marker::PhantomData;
 
-use ffi;
+use pointers::Py;
-use pointers::{Py, PyPtr};
+use python::Python;
-use err::{PyResult};
-use python::{Python, ToPythonPointer, PyDowncastInto};
-use objects::PyString;
 use typeob::{PyTypeInfo, PyObjectAlloc};
 
 
@@ -40,58 +36,3 @@ pub trait PythonObjectWithGilToken<'p> : Sized {
 pub trait PythonObjectWithToken : Sized {
     fn token<'p>(&'p self) -> Python<'p>;
 }
-
-pub struct PyObjectMarker;
-
-
-impl PyObjectMarker {
-
-    #[inline]
-    pub fn from_owned_ptr(_py: Python, ptr: *mut ffi::PyObject) -> PyPtr<PyObjectMarker> {
-        unsafe { PyPtr::from_owned_ptr(ptr) }
-    }
-
-    #[inline]
-    pub fn from_owned_ptr_or_err(py: Python, ptr: *mut ffi::PyObject)
-                                 -> PyResult<PyPtr<PyObjectMarker>> {
-        unsafe { PyPtr::from_owned_ptr_or_err(py, ptr) }
-    }
-
-    #[inline]
-    pub fn from_owned_ptr_or_opt(py: Python, ptr: *mut ffi::PyObject)
-                                 -> Option<PyPtr<PyObjectMarker>> {
-        unsafe { PyPtr::from_owned_ptr_or_opt(py, ptr) }
-    }
-
-    #[inline]
-    pub fn from_borrowed_ptr(_py: Python, ptr: *mut ffi::PyObject) -> PyPtr<PyObjectMarker> {
-        unsafe { PyPtr::from_borrowed_ptr(ptr) }
-    }
-}
-
-
-impl<'p> fmt::Debug for PyPtr<PyObjectMarker> {
-    default fn fmt(&self, f : &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        let gil = Python::acquire_gil();
-        let py = gil.python();
-
-        let repr_obj = unsafe {
-            PyString::downcast_from_owned_ptr(py, ffi::PyObject_Repr(self.as_ptr()))
-                .map_err(|_| fmt::Error)?
-        };
-        f.write_str(&repr_obj.to_string_lossy())
-    }
-}
-
-impl<'p> fmt::Display for PyPtr<PyObjectMarker> {
-    default fn fmt(&self, f : &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        let gil = Python::acquire_gil();
-        let py = gil.python();
-
-        let str_obj = unsafe {
-            PyString::downcast_from_owned_ptr(py, ffi::PyObject_Str(self.as_ptr()))
-                .map_err(|_| fmt::Error)?
-        };
-        f.write_str(&str_obj.to_string_lossy())
-    }
-}

tests/test_slice.rs

@@ -26,16 +26,16 @@ struct Test {}
 #[py::proto]
 impl<'p> PyMappingProtocol<'p> for Test
 {
-    fn __getitem__(&self, py: Python, idx: PyObject<'p>) -> PyResult<PyPtr<PyObjectMarker>> {
+    fn __getitem__(&self, py: Python, idx: PyObject<'p>) -> PyResult<pptr> {
         if let Ok(slice) = idx.cast_as::<PySlice>() {
             let indices = slice.indices(1000)?;
             if indices.start == 100 && indices.stop == 200 && indices.step == 1 {
-                return Ok("slice".to_object(py))
+                return Ok("slice".into_object(py))
             }
         }
         else if let Ok(idx) = idx.extract::<isize>() {
             if idx == 1 {
-                return Ok("int".to_object(py))
+                return Ok("int".into_object(py))
             }
         }
         Err(PyErr::new::<exc::ValueError, _>(py, "error"))