From 874d8a0835ff0d0d8239108d01bb2d1628918e42 Mon Sep 17 00:00:00 2001
From: kngwyu <yuji.kngw.80s.revive@gmail.com>
Date: Mon, 4 Mar 2019 13:50:43 +0900
Subject: [PATCH] Rename PyObjectRef with PyAny

---
 pyo3-derive-backend/src/pyclass.rs |  2 +-
 src/buffer.rs                      |  4 +--
 src/class/basic.rs                 |  4 +--
 src/class/descr.rs                 | 10 +++---
 src/class/macros.rs                | 32 +++++++++----------
 src/class/sequence.rs              |  6 ++--
 src/conversion.rs                  | 44 ++++++++++++--------------
 src/derive_utils.rs                |  4 +--
 src/err.rs                         | 11 ++-----
 src/exceptions.rs                  |  6 ++--
 src/gil.rs                         | 10 +++---
 src/instance.rs                    | 20 ++++++------
 src/object.rs                      | 14 ++++-----
 src/objectprotocol.rs              | 50 +++++++++++++-----------------
 src/python.rs                      | 18 +++++------
 src/type_object.rs                 |  6 ++--
 src/types/boolobject.rs            | 10 +++---
 src/types/complex.rs               |  6 ++--
 src/types/dict.rs                  |  8 ++---
 src/types/floatob.rs               |  6 ++--
 src/types/iterator.rs              |  6 ++--
 src/types/list.rs                  | 10 +++---
 src/types/mod.rs                   | 24 +++++++-------
 src/types/module.rs                | 10 +++---
 src/types/num2.rs                  |  6 ++--
 src/types/num3.rs                  |  6 ++--
 src/types/num_common.rs            |  4 +--
 src/types/sequence.rs              | 38 ++++++++++-------------
 src/types/string.rs                |  8 ++---
 src/types/string2.rs               |  6 ++--
 src/types/stringutils.rs           |  8 ++---
 src/types/tuple.rs                 | 18 +++++------
 tests/test_arithmetics.rs          | 22 ++++++-------
 tests/test_datetime.rs             |  4 +--
 tests/test_dunder.rs               |  8 ++---
 tests/test_gc.rs                   |  4 +--
 36 files changed, 214 insertions(+), 239 deletions(-)

diff --git a/pyo3-derive-backend/src/pyclass.rs b/pyo3-derive-backend/src/pyclass.rs
index f11d44bf..817f4e76 100644
--- a/pyo3-derive-backend/src/pyclass.rs
+++ b/pyo3-derive-backend/src/pyclass.rs
@@ -37,7 +37,7 @@ impl Default for PyClassArgs {
             // 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::PyObjectRef},
+            base: parse_quote! {::pyo3::types::PyAny},
         }
     }
 }
diff --git a/src/buffer.rs b/src/buffer.rs
index 8990a7f4..f483d293 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -20,7 +20,7 @@
 use crate::err::{self, PyResult};
 use crate::exceptions;
 use crate::ffi;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::Python;
 use libc;
@@ -163,7 +163,7 @@ fn validate(b: &ffi::Py_buffer) {
 
 impl PyBuffer {
     /// Get the underlying buffer from the specified python object.
-    pub fn get(py: Python, obj: &PyObjectRef) -> PyResult<PyBuffer> {
+    pub fn get(py: Python, obj: &PyAny) -> PyResult<PyBuffer> {
         unsafe {
             let mut buf = Box::new(mem::zeroed::<ffi::Py_buffer>());
             err::error_on_minusone(
diff --git a/src/class/basic.rs b/src/class/basic.rs
index 95208d64..2b419470 100644
--- a/src/class/basic.rs
+++ b/src/class/basic.rs
@@ -15,7 +15,7 @@ use crate::exceptions;
 use crate::ffi;
 use crate::objectprotocol::ObjectProtocol;
 use crate::type_object::PyTypeInfo;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::IntoPyPointer;
 use crate::Python;
 use crate::{FromPyObject, IntoPyObject};
@@ -440,7 +440,7 @@ where
             let _pool = crate::GILPool::new();
             let py = Python::assume_gil_acquired();
             let slf = py.from_borrowed_ptr::<T>(slf);
-            let arg = py.from_borrowed_ptr::<PyObjectRef>(arg);
+            let arg = py.from_borrowed_ptr::<PyAny>(arg);
 
             let res = match extract_op(op) {
                 Ok(op) => match arg.extract() {
diff --git a/src/class/descr.rs b/src/class/descr.rs
index c7ceff36..060bb192 100644
--- a/src/class/descr.rs
+++ b/src/class/descr.rs
@@ -10,35 +10,35 @@ use crate::class::methods::PyMethodDef;
 use crate::err::PyResult;
 use crate::ffi;
 use crate::type_object::PyTypeInfo;
-use crate::types::{PyObjectRef, PyType};
+use crate::types::{PyAny, PyType};
 use crate::{FromPyObject, IntoPyObject};
 use std::os::raw::c_int;
 
 /// Descriptor interface
 #[allow(unused_variables)]
 pub trait PyDescrProtocol<'p>: PyTypeInfo {
-    fn __get__(&'p self, instance: &'p PyObjectRef, owner: Option<&'p PyType>) -> Self::Result
+    fn __get__(&'p self, instance: &'p PyAny, owner: Option<&'p PyType>) -> Self::Result
     where
         Self: PyDescrGetProtocol<'p>,
     {
         unimplemented!()
     }
 
-    fn __set__(&'p self, instance: &'p PyObjectRef, value: &'p PyObjectRef) -> Self::Result
+    fn __set__(&'p self, instance: &'p PyAny, value: &'p PyAny) -> Self::Result
     where
         Self: PyDescrSetProtocol<'p>,
     {
         unimplemented!()
     }
 
-    fn __delete__(&'p self, instance: &'p PyObjectRef) -> Self::Result
+    fn __delete__(&'p self, instance: &'p PyAny) -> Self::Result
     where
         Self: PyDescrDeleteProtocol<'p>,
     {
         unimplemented!()
     }
 
-    fn __set_name__(&'p self, instance: &'p PyObjectRef) -> Self::Result
+    fn __set_name__(&'p self, instance: &'p PyAny) -> Self::Result
     where
         Self: PyDescrSetNameProtocol<'p>,
     {
diff --git a/src/class/macros.rs b/src/class/macros.rs
index e8a94efd..c2cd3da0 100644
--- a/src/class/macros.rs
+++ b/src/class/macros.rs
@@ -87,7 +87,7 @@ macro_rules! py_binary_func {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
             let slf = py.mut_from_borrowed_ptr::<T>(slf);
-            let arg = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg);
+            let arg = py.from_borrowed_ptr::<$crate::types::PyAny>(arg);
 
             let result = match arg.extract() {
                 Ok(arg) => slf.$f(arg).into(),
@@ -114,8 +114,8 @@ macro_rules! py_binary_num_func {
             use $crate::ObjectProtocol;
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
-            let lhs = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(lhs);
-            let rhs = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(rhs);
+            let lhs = py.from_borrowed_ptr::<$crate::types::PyAny>(lhs);
+            let rhs = py.from_borrowed_ptr::<$crate::types::PyAny>(rhs);
 
             let result = match lhs.extract() {
                 Ok(lhs) => match rhs.extract() {
@@ -147,7 +147,7 @@ macro_rules! py_binary_self_func {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
             let slf1 = py.mut_from_borrowed_ptr::<T>(slf);
-            let arg = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg);
+            let arg = py.from_borrowed_ptr::<$crate::types::PyAny>(arg);
 
             let result = match arg.extract() {
                 Ok(arg) => slf1.$f(arg).into(),
@@ -216,8 +216,8 @@ macro_rules! py_ternary_func {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
             let slf = py.mut_from_borrowed_ptr::<T>(slf);
-            let arg1 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg1);
-            let arg2 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg2);
+            let arg1 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg2);
 
             let result = match arg1.extract() {
                 Ok(arg1) => match arg2.extract() {
@@ -249,9 +249,9 @@ macro_rules! py_ternary_num_func {
 
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
-            let arg1 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg1);
-            let arg2 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg2);
-            let arg3 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg3);
+            let arg1 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg2);
+            let arg3 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg3);
 
             let result = match arg1.extract() {
                 Ok(arg1) => match arg2.extract() {
@@ -287,8 +287,8 @@ macro_rules! py_ternary_self_func {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
             let slf1 = py.mut_from_borrowed_ptr::<T>(slf);
-            let arg1 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg1);
-            let arg2 = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(arg2);
+            let arg1 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg2);
 
             let result = match arg1.extract() {
                 Ok(arg1) => match arg2.extract() {
@@ -335,8 +335,8 @@ macro_rules! py_func_set {
                     ),
                 ))
             } else {
-                let name = py.mut_from_borrowed_ptr::<$crate::types::PyObjectRef>(name);
-                let value = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(value);
+                let name = py.mut_from_borrowed_ptr::<$crate::types::PyAny>(name);
+                let value = py.from_borrowed_ptr::<$crate::types::PyAny>(value);
                 match name.extract() {
                     Ok(name) => match value.extract() {
                         Ok(value) => slf.$fn_set(name, value).into(),
@@ -376,7 +376,7 @@ macro_rules! py_func_del {
 
             let result = if value.is_null() {
                 let slf = py.mut_from_borrowed_ptr::<U>(slf);
-                let name = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(name);
+                let name = py.from_borrowed_ptr::<$crate::types::PyAny>(name);
 
                 match name.extract() {
                     Ok(name) => slf.$fn_del(name).into(),
@@ -416,7 +416,7 @@ macro_rules! py_func_set_del {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
             let slf = py.mut_from_borrowed_ptr::<$generic>(slf);
-            let name = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(name);
+            let name = py.from_borrowed_ptr::<$crate::types::PyAny>(name);
 
             let result = if value.is_null() {
                 match name.extract() {
@@ -424,7 +424,7 @@ macro_rules! py_func_set_del {
                     Err(e) => Err(e.into()),
                 }
             } else {
-                let value = py.from_borrowed_ptr::<$crate::types::PyObjectRef>(value);
+                let value = py.from_borrowed_ptr::<$crate::types::PyAny>(value);
                 match name.extract() {
                     Ok(name) => match value.extract() {
                         Ok(value) => slf.$fn_set(name, value).into(),
diff --git a/src/class/sequence.rs b/src/class/sequence.rs
index d959bb4e..2f684edc 100644
--- a/src/class/sequence.rs
+++ b/src/class/sequence.rs
@@ -9,7 +9,7 @@ use crate::exceptions;
 use crate::ffi;
 use crate::objectprotocol::ObjectProtocol;
 use crate::type_object::PyTypeInfo;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::Python;
 use crate::{FromPyObject, IntoPyObject};
 use std::os::raw::c_int;
@@ -241,7 +241,7 @@ where
                     stringify!(T)
                 )))
             } else {
-                let value = py.from_borrowed_ptr::<PyObjectRef>(value);
+                let value = py.from_borrowed_ptr::<PyAny>(value);
                 match value.extract() {
                     Ok(value) => slf.__setitem__(key as isize, value).into(),
                     Err(e) => Err(e),
@@ -358,7 +358,7 @@ mod sq_ass_item_impl {
                 let result = if value.is_null() {
                     slf.__delitem__(key as isize).into()
                 } else {
-                    let value = py.from_borrowed_ptr::<PyObjectRef>(value);
+                    let value = py.from_borrowed_ptr::<PyAny>(value);
                     match value.extract() {
                         Ok(value) => slf.__setitem__(key as isize, value).into(),
                         Err(e) => Err(e),
diff --git a/src/conversion.rs b/src/conversion.rs
index 5210f707..72b7442e 100644
--- a/src/conversion.rs
+++ b/src/conversion.rs
@@ -6,7 +6,7 @@ use crate::err::{PyDowncastError, PyResult};
 use crate::ffi;
 use crate::object::PyObject;
 use crate::type_object::PyTypeInfo;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::types::PyTuple;
 use crate::Py;
 use crate::Python;
@@ -182,7 +182,7 @@ pub trait IntoPyObject {
 /// the inherent method `PyObject::extract()` can be used.
 pub trait FromPyObject<'source>: Sized {
     /// Extracts `Self` from the source `PyObject`.
-    fn extract(ob: &'source PyObjectRef) -> PyResult<Self>;
+    fn extract(ob: &'source PyAny) -> PyResult<Self>;
 }
 
 /// Identity conversion: allows using existing `PyObject` instances where
@@ -262,7 +262,7 @@ where
     T: PyTryFrom<'a>,
 {
     #[inline]
-    default fn extract(ob: &'a PyObjectRef) -> PyResult<&'a T> {
+    default fn extract(ob: &'a PyAny) -> PyResult<&'a T> {
         Ok(T::try_from(ob)?)
     }
 }
@@ -273,7 +273,7 @@ where
     T: PyTryFrom<'a>,
 {
     #[inline]
-    default fn extract(ob: &'a PyObjectRef) -> PyResult<&'a mut T> {
+    default fn extract(ob: &'a PyAny) -> PyResult<&'a mut T> {
         Ok(T::try_from_mut(ob)?)
     }
 }
@@ -282,7 +282,7 @@ impl<'a, T> FromPyObject<'a> for Option<T>
 where
     T: FromPyObject<'a>,
 {
-    fn extract(obj: &'a PyObjectRef) -> PyResult<Self> {
+    fn extract(obj: &'a PyAny) -> PyResult<Self> {
         if obj.as_ptr() == unsafe { ffi::Py_None() } {
             Ok(None)
         } else {
@@ -314,31 +314,29 @@ pub trait PyTryInto<T>: Sized {
 /// This trait is similar to `std::convert::TryFrom`
 pub trait PyTryFrom<'v>: Sized {
     /// Cast from a concrete Python object type to PyObject.
-    fn try_from<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v Self, PyDowncastError>;
+    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError>;
 
     /// Cast from a concrete Python object type to PyObject. With exact type check.
-    fn try_from_exact<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v Self, PyDowncastError>;
+    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError>;
 
     /// Cast from a concrete Python object type to PyObject.
-    fn try_from_mut<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v mut Self, PyDowncastError>;
+    fn try_from_mut<V: Into<&'v PyAny>>(value: V) -> Result<&'v mut Self, PyDowncastError>;
 
     /// Cast from a concrete Python object type to PyObject. With exact type check.
-    fn try_from_mut_exact<V: Into<&'v PyObjectRef>>(
-        value: V,
-    ) -> Result<&'v mut Self, PyDowncastError>;
+    fn try_from_mut_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v mut Self, PyDowncastError>;
 
-    /// Cast a PyObjectRef to a specific type of PyObject. The caller must
+    /// Cast a PyAny to a specific type of PyObject. The caller must
     /// have already verified the reference is for this type.
-    unsafe fn try_from_unchecked<V: Into<&'v PyObjectRef>>(value: V) -> &'v Self;
+    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v Self;
 
-    /// Cast a PyObjectRef to a specific type of PyObject. The caller must
+    /// Cast a PyAny to a specific type of PyObject. The caller must
     /// have already verified the reference is for this type.
     #[allow(clippy::mut_from_ref)]
-    unsafe fn try_from_mut_unchecked<V: Into<&'v PyObjectRef>>(value: V) -> &'v mut Self;
+    unsafe fn try_from_mut_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v mut Self;
 }
 
 // TryFrom implies TryInto
-impl<U> PyTryInto<U> for PyObjectRef
+impl<U> PyTryInto<U> for PyAny
 where
     U: for<'v> PyTryFrom<'v>,
 {
@@ -360,7 +358,7 @@ impl<'v, T> PyTryFrom<'v> for T
 where
     T: PyTypeInfo,
 {
-    fn try_from<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v T, PyDowncastError> {
+    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v T, PyDowncastError> {
         let value = value.into();
         unsafe {
             if T::is_instance(value) {
@@ -371,7 +369,7 @@ where
         }
     }
 
-    fn try_from_exact<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v T, PyDowncastError> {
+    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v T, PyDowncastError> {
         let value = value.into();
         unsafe {
             if T::is_exact_instance(value) {
@@ -382,7 +380,7 @@ where
         }
     }
 
-    fn try_from_mut<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v mut T, PyDowncastError> {
+    fn try_from_mut<V: Into<&'v PyAny>>(value: V) -> Result<&'v mut T, PyDowncastError> {
         let value = value.into();
         unsafe {
             if T::is_instance(value) {
@@ -393,9 +391,7 @@ where
         }
     }
 
-    fn try_from_mut_exact<V: Into<&'v PyObjectRef>>(
-        value: V,
-    ) -> Result<&'v mut T, PyDowncastError> {
+    fn try_from_mut_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v mut T, PyDowncastError> {
         let value = value.into();
         unsafe {
             if T::is_exact_instance(value) {
@@ -407,7 +403,7 @@ where
     }
 
     #[inline]
-    unsafe fn try_from_unchecked<V: Into<&'v PyObjectRef>>(value: V) -> &'v T {
+    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v T {
         let value = value.into();
         let ptr = if T::OFFSET == 0 {
             value as *const _ as *const u8 as *const T
@@ -418,7 +414,7 @@ where
     }
 
     #[inline]
-    unsafe fn try_from_mut_unchecked<V: Into<&'v PyObjectRef>>(value: V) -> &'v mut T {
+    unsafe fn try_from_mut_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v mut T {
         let value = value.into();
         let ptr = if T::OFFSET == 0 {
             value as *const _ as *mut u8 as *mut T
diff --git a/src/derive_utils.rs b/src/derive_utils.rs
index 8e787e6f..5aabaad4 100644
--- a/src/derive_utils.rs
+++ b/src/derive_utils.rs
@@ -8,7 +8,7 @@ use crate::err::PyResult;
 use crate::exceptions::TypeError;
 use crate::ffi;
 use crate::init_once;
-use crate::types::{PyDict, PyModule, PyObjectRef, PyString, PyTuple};
+use crate::types::{PyAny, PyDict, PyModule, PyString, PyTuple};
 use crate::GILPool;
 use crate::Python;
 use crate::{IntoPyObject, PyTryFrom};
@@ -40,7 +40,7 @@ pub fn parse_fn_args<'p>(
     kwargs: Option<&'p PyDict>,
     accept_args: bool,
     accept_kwargs: bool,
-    output: &mut [Option<&'p PyObjectRef>],
+    output: &mut [Option<&'p PyAny>],
 ) -> PyResult<()> {
     let nargs = args.len();
     let nkeywords = kwargs.map_or(0, PyDict::len);
diff --git a/src/err.rs b/src/err.rs
index 18b32a34..79c36fe2 100644
--- a/src/err.rs
+++ b/src/err.rs
@@ -5,7 +5,7 @@ use crate::ffi;
 use crate::instance::Py;
 use crate::object::PyObject;
 use crate::type_object::PyTypeObject;
-use crate::types::{PyObjectRef, PyType};
+use crate::types::{PyAny, PyType};
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Python;
@@ -115,7 +115,7 @@ impl PyErr {
     /// 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(obj: &PyObjectRef) -> PyErr {
+    pub fn from_instance(obj: &PyAny) -> PyErr {
         let ptr = obj.as_ptr();
 
         if unsafe { ffi::PyExceptionInstance_Check(ptr) } != 0 {
@@ -317,12 +317,7 @@ impl PyErr {
 
     /// Issue a warning message.
     /// May return a PyErr if warnings-as-errors is enabled.
-    pub fn warn(
-        py: Python,
-        category: &PyObjectRef,
-        message: &str,
-        stacklevel: i32,
-    ) -> PyResult<()> {
+    pub fn warn(py: Python, category: &PyAny, message: &str, stacklevel: i32) -> PyResult<()> {
         let message = CString::new(message)?;
         unsafe {
             error_on_minusone(
diff --git a/src/exceptions.rs b/src/exceptions.rs
index f836c521..90fb6265 100644
--- a/src/exceptions.rs
+++ b/src/exceptions.rs
@@ -5,7 +5,7 @@
 use crate::err::{PyErr, PyResult};
 use crate::ffi;
 use crate::type_object::PyTypeObject;
-use crate::types::{PyObjectRef, PyTuple};
+use crate::types::{PyAny, PyTuple};
 use crate::Python;
 use crate::{AsPyPointer, ToPyObject};
 use std::ffi::CStr;
@@ -317,7 +317,7 @@ impl UnicodeDecodeError {
         input: &[u8],
         range: ops::Range<usize>,
         reason: &CStr,
-    ) -> PyResult<&'p PyObjectRef> {
+    ) -> PyResult<&'p PyAny> {
         unsafe {
             let input: &[c_char] = &*(input as *const [u8] as *const [c_char]);
             py.from_owned_ptr_or_err(ffi::PyUnicodeDecodeError_Create(
@@ -336,7 +336,7 @@ impl UnicodeDecodeError {
         py: Python<'p>,
         input: &[u8],
         err: std::str::Utf8Error,
-    ) -> PyResult<&'p PyObjectRef> {
+    ) -> PyResult<&'p PyAny> {
         let pos = err.valid_up_to();
         UnicodeDecodeError::new_err(
             py,
diff --git a/src/gil.rs b/src/gil.rs
index 7f04b511..8d41075c 100644
--- a/src/gil.rs
+++ b/src/gil.rs
@@ -3,7 +3,7 @@
 //! Interaction with python's global interpreter lock
 
 use crate::ffi;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::Python;
 use spin;
 use std::ptr::NonNull;
@@ -230,14 +230,14 @@ pub unsafe fn register_pointer(obj: NonNull<ffi::PyObject>) {
     (**pool.p.lock()).push(obj);
 }
 
-pub unsafe fn register_owned(_py: Python, obj: NonNull<ffi::PyObject>) -> &PyObjectRef {
+pub unsafe fn register_owned(_py: Python, obj: NonNull<ffi::PyObject>) -> &PyAny {
     let pool = &mut *POOL;
-    &*(pool.owned.push_back(obj) as *const _ as *const PyObjectRef)
+    &*(pool.owned.push_back(obj) as *const _ as *const PyAny)
 }
 
-pub unsafe fn register_borrowed(_py: Python, obj: NonNull<ffi::PyObject>) -> &PyObjectRef {
+pub unsafe fn register_borrowed(_py: Python, obj: NonNull<ffi::PyObject>) -> &PyAny {
     let pool = &mut *POOL;
-    &*(pool.borrowed.push_back(obj) as *const _ as *const PyObjectRef)
+    &*(pool.borrowed.push_back(obj) as *const _ as *const PyAny)
 }
 
 impl GILGuard {
diff --git a/src/instance.rs b/src/instance.rs
index 0395c812..4e851888 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -7,7 +7,7 @@ use crate::object::PyObject;
 use crate::objectprotocol::ObjectProtocol;
 use crate::type_object::PyTypeCreate;
 use crate::type_object::{PyTypeInfo, PyTypeObject};
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Python;
@@ -173,21 +173,21 @@ impl<'a, T: PyTypeInfo> DerefMut for PyRefMut<'a, T> {
     }
 }
 
-impl<'a, T> From<PyRef<'a, T>> for &'a PyObjectRef
+impl<'a, T> From<PyRef<'a, T>> for &'a PyAny
 where
     T: PyTypeInfo,
 {
-    fn from(pref: PyRef<'a, T>) -> &'a PyObjectRef {
-        unsafe { &*(pref.as_ptr() as *const PyObjectRef) }
+    fn from(pref: PyRef<'a, T>) -> &'a PyAny {
+        unsafe { &*(pref.as_ptr() as *const PyAny) }
     }
 }
 
-impl<'a, T> From<PyRefMut<'a, T>> for &'a PyObjectRef
+impl<'a, T> From<PyRefMut<'a, T>> for &'a PyAny
 where
     T: PyTypeInfo,
 {
-    fn from(pref: PyRefMut<'a, T>) -> &'a PyObjectRef {
-        unsafe { &*(pref.as_ptr() as *const PyObjectRef) }
+    fn from(pref: PyRefMut<'a, T>) -> &'a PyAny {
+        unsafe { &*(pref.as_ptr() as *const PyAny) }
     }
 }
 
@@ -484,7 +484,7 @@ where
     &'a T: 'a + FromPyObject<'a>,
 {
     /// Extracts `Self` from the source `PyObject`.
-    fn extract(ob: &'a PyObjectRef) -> PyResult<Self> {
+    fn extract(ob: &'a PyAny) -> PyResult<Self> {
         unsafe {
             ob.extract::<&T>()
                 .map(|val| Py::from_borrowed_ptr(val.as_ptr()))
@@ -506,9 +506,9 @@ where
 /// ```
 /// use pyo3::ffi;
 /// use pyo3::{ToPyObject, AsPyPointer, PyNativeType, ManagedPyRef};
-/// use pyo3::types::{PyDict, PyObjectRef};
+/// use pyo3::types::{PyDict, PyAny};
 ///
-/// pub fn get_dict_item<'p>(dict: &'p PyDict, key: &impl ToPyObject) -> Option<&'p PyObjectRef> {
+/// pub fn get_dict_item<'p>(dict: &'p PyDict, key: &impl ToPyObject) -> Option<&'p PyAny> {
 ///     let key = ManagedPyRef::from_to_pyobject(dict.py(), key);
 ///     unsafe {
 ///         dict.py().from_borrowed_ptr_or_opt(ffi::PyDict_GetItem(dict.as_ptr(), key.as_ptr()))
diff --git a/src/object.rs b/src/object.rs
index 831b33e2..2fae5a22 100644
--- a/src/object.rs
+++ b/src/object.rs
@@ -4,7 +4,7 @@ use crate::err::{PyDowncastError, PyErr, PyResult};
 use crate::ffi;
 use crate::gil;
 use crate::instance::{AsPyRef, PyNativeType, PyRef, PyRefMut};
-use crate::types::{PyDict, PyObjectRef, PyTuple};
+use crate::types::{PyAny, PyDict, PyTuple};
 use crate::AsPyPointer;
 use crate::Py;
 use crate::Python;
@@ -254,14 +254,14 @@ impl PyObject {
     }
 }
 
-impl AsPyRef<PyObjectRef> for PyObject {
+impl AsPyRef<PyAny> for PyObject {
     #[inline]
-    fn as_ref(&self, _py: Python) -> PyRef<PyObjectRef> {
-        unsafe { PyRef::from_ref(&*(self as *const _ as *const PyObjectRef)) }
+    fn as_ref(&self, _py: Python) -> PyRef<PyAny> {
+        unsafe { PyRef::from_ref(&*(self as *const _ as *const PyAny)) }
     }
     #[inline]
-    fn as_mut(&mut self, _py: Python) -> PyRefMut<PyObjectRef> {
-        unsafe { PyRefMut::from_mut(&mut *(self as *mut _ as *mut PyObjectRef)) }
+    fn as_mut(&mut self, _py: Python) -> PyRefMut<PyAny> {
+        unsafe { PyRefMut::from_mut(&mut *(self as *mut _ as *mut PyAny)) }
     }
 }
 
@@ -309,7 +309,7 @@ impl IntoPyObject for PyObject {
 impl<'a> FromPyObject<'a> for PyObject {
     #[inline]
     /// Extracts `Self` from the source `PyObject`.
-    fn extract(ob: &'a PyObjectRef) -> PyResult<Self> {
+    fn extract(ob: &'a PyAny) -> PyResult<Self> {
         unsafe { Ok(PyObject::from_borrowed_ptr(ob.py(), ob.as_ptr())) }
     }
 }
diff --git a/src/objectprotocol.rs b/src/objectprotocol.rs
index b93a5a07..4602b8cb 100644
--- a/src/objectprotocol.rs
+++ b/src/objectprotocol.rs
@@ -7,7 +7,7 @@ use crate::ffi;
 use crate::instance::PyNativeType;
 use crate::object::PyObject;
 use crate::type_object::PyTypeInfo;
-use crate::types::{PyDict, PyIterator, PyObjectRef, PyString, PyTuple, PyType};
+use crate::types::{PyAny, PyDict, PyIterator, PyString, PyTuple, PyType};
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Py;
@@ -26,7 +26,7 @@ pub trait ObjectProtocol {
 
     /// Retrieves an attribute value.
     /// This is equivalent to the Python expression `self.attr_name`.
-    fn getattr<N>(&self, attr_name: N) -> PyResult<&PyObjectRef>
+    fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>
     where
         N: ToPyObject;
 
@@ -88,19 +88,15 @@ pub trait ObjectProtocol {
 
     /// Calls the object.
     /// This is equivalent to the Python expression: `self(*args, **kwargs)`
-    fn call(
-        &self,
-        args: impl IntoPy<Py<PyTuple>>,
-        kwargs: Option<&PyDict>,
-    ) -> PyResult<&PyObjectRef>;
+    fn call(&self, args: impl IntoPy<Py<PyTuple>>, kwargs: Option<&PyDict>) -> PyResult<&PyAny>;
 
     /// Calls the object.
     /// This is equivalent to the Python expression: `self()`
-    fn call0(&self) -> PyResult<&PyObjectRef>;
+    fn call0(&self) -> PyResult<&PyAny>;
 
     /// Calls the object.
     /// This is equivalent to the Python expression: `self(*args)`
-    fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyObjectRef>;
+    fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>;
 
     /// Calls a method on the object.
     /// This is equivalent to the Python expression: `self.name(*args, **kwargs)`
@@ -122,15 +118,15 @@ pub trait ObjectProtocol {
         name: &str,
         args: impl IntoPy<Py<PyTuple>>,
         kwargs: Option<&PyDict>,
-    ) -> PyResult<&PyObjectRef>;
+    ) -> PyResult<&PyAny>;
 
     /// Calls a method on the object.
     /// This is equivalent to the Python expression: `self.name()`
-    fn call_method0(&self, name: &str) -> PyResult<&PyObjectRef>;
+    fn call_method0(&self, name: &str) -> PyResult<&PyAny>;
 
     /// Calls a method on the object with positional arguments only .
     /// This is equivalent to the Python expression: `self.name(*args)`
-    fn call_method1(&self, name: &str, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyObjectRef>;
+    fn call_method1(&self, name: &str, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>;
 
     /// Retrieves the hash code of the object.
     /// This is equivalent to the Python expression: `hash(self)`
@@ -149,7 +145,7 @@ pub trait ObjectProtocol {
     fn len(&self) -> PyResult<usize>;
 
     /// This is equivalent to the Python expression: `self[key]`
-    fn get_item<K>(&self, key: K) -> PyResult<&PyObjectRef>
+    fn get_item<K>(&self, key: K) -> PyResult<&PyAny>
     where
         K: ToBorrowedObject;
 
@@ -192,14 +188,14 @@ pub trait ObjectProtocol {
     fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError>
     where
         D: PyTryFrom<'a>,
-        &'a PyObjectRef: std::convert::From<&'a Self>;
+        &'a PyAny: std::convert::From<&'a Self>;
 
     /// Extracts some type from the Python object.
     /// This is a wrapper function around `FromPyObject::extract()`.
     fn extract<'a, D>(&'a self) -> PyResult<D>
     where
         D: FromPyObject<'a>,
-        &'a PyObjectRef: std::convert::From<&'a Self>;
+        &'a PyAny: std::convert::From<&'a Self>;
 
     /// Returns reference count for python object.
     fn get_refcnt(&self) -> isize;
@@ -222,7 +218,7 @@ where
         })
     }
 
-    fn getattr<N>(&self, attr_name: N) -> PyResult<&PyObjectRef>
+    fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>
     where
         N: ToPyObject,
     {
@@ -325,11 +321,7 @@ where
         unsafe { ffi::PyCallable_Check(self.as_ptr()) != 0 }
     }
 
-    fn call(
-        &self,
-        args: impl IntoPy<Py<PyTuple>>,
-        kwargs: Option<&PyDict>,
-    ) -> PyResult<&PyObjectRef> {
+    fn call(&self, args: impl IntoPy<Py<PyTuple>>, kwargs: Option<&PyDict>) -> PyResult<&PyAny> {
         let args = args.into_py(self.py()).into_ptr();
         let kwargs = kwargs.into_ptr();
         let result = unsafe {
@@ -343,11 +335,11 @@ where
         result
     }
 
-    fn call0(&self) -> PyResult<&PyObjectRef> {
+    fn call0(&self) -> PyResult<&PyAny> {
         self.call((), None)
     }
 
-    fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyObjectRef> {
+    fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny> {
         self.call(args, None)
     }
 
@@ -356,7 +348,7 @@ where
         name: &str,
         args: impl IntoPy<Py<PyTuple>>,
         kwargs: Option<&PyDict>,
-    ) -> PyResult<&PyObjectRef> {
+    ) -> PyResult<&PyAny> {
         name.with_borrowed_ptr(self.py(), |name| unsafe {
             let py = self.py();
             let ptr = ffi::PyObject_GetAttr(self.as_ptr(), name);
@@ -374,11 +366,11 @@ where
         })
     }
 
-    fn call_method0(&self, name: &str) -> PyResult<&PyObjectRef> {
+    fn call_method0(&self, name: &str) -> PyResult<&PyAny> {
         self.call_method(name, (), None)
     }
 
-    fn call_method1(&self, name: &str, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyObjectRef> {
+    fn call_method1(&self, name: &str, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny> {
         self.call_method(name, args, None)
     }
 
@@ -413,7 +405,7 @@ where
         }
     }
 
-    fn get_item<K>(&self, key: K) -> PyResult<&PyObjectRef>
+    fn get_item<K>(&self, key: K) -> PyResult<&PyAny>
     where
         K: ToBorrowedObject,
     {
@@ -474,7 +466,7 @@ where
     fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError>
     where
         D: PyTryFrom<'a>,
-        &'a PyObjectRef: std::convert::From<&'a Self>,
+        &'a PyAny: std::convert::From<&'a Self>,
     {
         D::try_from(self)
     }
@@ -482,7 +474,7 @@ where
     fn extract<'a, D>(&'a self) -> PyResult<D>
     where
         D: FromPyObject<'a>,
-        &'a PyObjectRef: std::convert::From<&'a T>,
+        &'a PyAny: std::convert::From<&'a T>,
     {
         FromPyObject::extract(self.into())
     }
diff --git a/src/python.rs b/src/python.rs
index 6c699652..94c9d029 100644
--- a/src/python.rs
+++ b/src/python.rs
@@ -8,7 +8,7 @@ use crate::gil::{self, GILGuard};
 use crate::instance::AsPyRef;
 use crate::object::PyObject;
 use crate::type_object::{PyTypeInfo, PyTypeObject};
-use crate::types::{PyDict, PyModule, PyObjectRef, PyType};
+use crate::types::{PyAny, PyDict, PyModule, PyType};
 use crate::AsPyPointer;
 use crate::{IntoPyPointer, PyTryFrom};
 use std::ffi::CString;
@@ -95,7 +95,7 @@ impl<'p> Python<'p> {
         code: &str,
         globals: Option<&PyDict>,
         locals: Option<&PyDict>,
-    ) -> PyResult<&'p PyObjectRef> {
+    ) -> PyResult<&'p PyAny> {
         self.run_code(code, ffi::Py_eval_input, globals, locals)
     }
 
@@ -108,7 +108,7 @@ impl<'p> Python<'p> {
         code: &str,
         globals: Option<&PyDict>,
         locals: Option<&PyDict>,
-    ) -> PyResult<&'p PyObjectRef> {
+    ) -> PyResult<&'p PyAny> {
         self.run_code(code, ffi::Py_file_input, globals, locals)
     }
 
@@ -124,7 +124,7 @@ impl<'p> Python<'p> {
         start: c_int,
         globals: Option<&PyDict>,
         locals: Option<&PyDict>,
-    ) -> PyResult<&'p PyObjectRef> {
+    ) -> PyResult<&'p PyAny> {
         let code = CString::new(code)?;
 
         unsafe {
@@ -193,7 +193,7 @@ impl<'p> Python<'p> {
 }
 
 impl<'p> Python<'p> {
-    unsafe fn unchecked_downcast<T: PyTypeInfo>(self, ob: &PyObjectRef) -> &'p T {
+    unsafe fn unchecked_downcast<T: PyTypeInfo>(self, ob: &PyAny) -> &'p T {
         if T::OFFSET == 0 {
             &*(ob as *const _ as *const T)
         } else {
@@ -203,7 +203,7 @@ impl<'p> Python<'p> {
     }
 
     #[allow(clippy::cast_ref_to_mut)] // FIXME
-    unsafe fn unchecked_mut_downcast<T: PyTypeInfo>(self, ob: &PyObjectRef) -> &'p mut T {
+    unsafe fn unchecked_mut_downcast<T: PyTypeInfo>(self, ob: &PyAny) -> &'p mut T {
         if T::OFFSET == 0 {
             &mut *(ob as *const _ as *mut T)
         } else {
@@ -231,7 +231,7 @@ impl<'p> Python<'p> {
     }
 
     /// Register `ffi::PyObject` pointer in release pool
-    pub unsafe fn from_borrowed_ptr_to_obj(self, ptr: *mut ffi::PyObject) -> &'p PyObjectRef {
+    pub unsafe fn from_borrowed_ptr_to_obj(self, ptr: *mut ffi::PyObject) -> &'p PyAny {
         match NonNull::new(ptr) {
             Some(p) => gil::register_borrowed(self, p),
             None => crate::err::panic_after_error(),
@@ -390,7 +390,7 @@ impl<'p> Python<'p> {
 #[cfg(test)]
 mod test {
     use crate::objectprotocol::ObjectProtocol;
-    use crate::types::{PyBool, PyDict, PyInt, PyList, PyObjectRef};
+    use crate::types::{PyAny, PyBool, PyDict, PyInt, PyList};
     use crate::Python;
 
     #[test]
@@ -440,7 +440,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         assert!(py
-            .is_instance::<PyBool, PyObjectRef>(PyBool::new(py, true).into())
+            .is_instance::<PyBool, PyAny>(PyBool::new(py, true).into())
             .unwrap());
         let list = PyList::new(py, &[1, 2, 3, 4]);
         assert!(!py.is_instance::<PyBool, _>(list.as_ref()).unwrap());
diff --git a/src/type_object.rs b/src/type_object.rs
index 9a30b804..07234846 100644
--- a/src/type_object.rs
+++ b/src/type_object.rs
@@ -5,7 +5,7 @@
 use crate::class::methods::PyMethodDefType;
 use crate::err::{PyErr, PyResult};
 use crate::instance::{Py, PyNativeType};
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::types::PyType;
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
@@ -45,12 +45,12 @@ pub trait PyTypeInfo {
     unsafe fn type_object() -> &'static mut ffi::PyTypeObject;
 
     /// Check if `*mut ffi::PyObject` is instance of this type
-    fn is_instance(object: &PyObjectRef) -> bool {
+    fn is_instance(object: &PyAny) -> bool {
         unsafe { ffi::PyObject_TypeCheck(object.as_ptr(), Self::type_object()) != 0 }
     }
 
     /// Check if `*mut ffi::PyObject` is exact instance of this type
-    fn is_exact_instance(object: &PyObjectRef) -> bool {
+    fn is_exact_instance(object: &PyAny) -> bool {
         unsafe { (*object.as_ptr()).ob_type == Self::type_object() }
     }
 }
diff --git a/src/types/boolobject.rs b/src/types/boolobject.rs
index be2207f4..79e46268 100644
--- a/src/types/boolobject.rs
+++ b/src/types/boolobject.rs
@@ -1,7 +1,7 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
 use crate::ffi;
 use crate::object::PyObject;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::FromPyObject;
 use crate::PyResult;
@@ -56,7 +56,7 @@ impl IntoPyObject for bool {
 ///
 /// Fails with `TypeError` if the input is not a Python `bool`.
 impl<'source> FromPyObject<'source> for bool {
-    fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+    fn extract(obj: &'source PyAny) -> PyResult<Self> {
         Ok(<PyBool as PyTryFrom>::try_from(obj)?.is_true())
     }
 }
@@ -64,7 +64,7 @@ impl<'source> FromPyObject<'source> for bool {
 #[cfg(test)]
 mod test {
     use crate::objectprotocol::ObjectProtocol;
-    use crate::types::{PyBool, PyObjectRef};
+    use crate::types::{PyAny, PyBool};
     use crate::Python;
     use crate::ToPyObject;
 
@@ -73,7 +73,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         assert!(PyBool::new(py, true).is_true());
-        let t: &PyObjectRef = PyBool::new(py, true).into();
+        let t: &PyAny = PyBool::new(py, true).into();
         assert_eq!(true, t.extract().unwrap());
         assert_eq!(true.to_object(py), PyBool::new(py, true).into());
     }
@@ -83,7 +83,7 @@ mod test {
         let gil = Python::acquire_gil();
         let py = gil.python();
         assert!(!PyBool::new(py, false).is_true());
-        let t: &PyObjectRef = PyBool::new(py, false).into();
+        let t: &PyAny = PyBool::new(py, false).into();
         assert_eq!(false, t.extract().unwrap());
         assert_eq!(false.to_object(py), PyBool::new(py, false).into());
     }
diff --git a/src/types/complex.rs b/src/types/complex.rs
index c68e4d31..0917f919 100644
--- a/src/types/complex.rs
+++ b/src/types/complex.rs
@@ -119,7 +119,7 @@ impl<'py> Neg for &'py PyComplex {
 mod complex_conversion {
     use super::*;
     use crate::err::PyErr;
-    use crate::types::PyObjectRef;
+    use crate::types::PyAny;
     use crate::PyResult;
     use crate::{FromPyObject, IntoPyObject, ToPyObject};
     use num_complex::Complex;
@@ -156,7 +156,7 @@ mod complex_conversion {
             #[cfg(any(not(Py_LIMITED_API), not(Py_3)))]
             #[allow(clippy::float_cmp)] // The comparison is for an error value
             impl<'source> FromPyObject<'source> for Complex<$float> {
-                fn extract(obj: &'source PyObjectRef) -> PyResult<Complex<$float>> {
+                fn extract(obj: &'source PyAny) -> PyResult<Complex<$float>> {
                     unsafe {
                         let val = ffi::PyComplex_AsCComplex(obj.as_ptr());
                         if val.real == -1.0 && PyErr::occurred(obj.py()) {
@@ -170,7 +170,7 @@ mod complex_conversion {
             #[cfg(all(Py_LIMITED_API, Py_3))]
             #[allow(clippy::float_cmp)] // The comparison is for an error value
             impl<'source> FromPyObject<'source> for Complex<$float> {
-                fn extract(obj: &'source PyObjectRef) -> PyResult<Complex<$float>> {
+                fn extract(obj: &'source PyAny) -> PyResult<Complex<$float>> {
                     unsafe {
                         let ptr = obj.as_ptr();
                         let real = ffi::PyComplex_RealAsDouble(ptr);
diff --git a/src/types/dict.rs b/src/types/dict.rs
index 815cf077..b7fae879 100644
--- a/src/types/dict.rs
+++ b/src/types/dict.rs
@@ -4,7 +4,7 @@ use crate::err::{self, PyErr, PyResult};
 use crate::ffi;
 use crate::instance::PyNativeType;
 use crate::object::PyObject;
-use crate::types::{PyList, PyObjectRef};
+use crate::types::{PyAny, PyList};
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Python;
@@ -83,7 +83,7 @@ impl PyDict {
 
     /// Gets an item from the dictionary.
     /// Returns None if the item is not present, or if an error occurs.
-    pub fn get_item<K>(&self, key: K) -> Option<&PyObjectRef>
+    pub fn get_item<K>(&self, key: K) -> Option<&PyAny>
     where
         K: ToBorrowedObject,
     {
@@ -165,7 +165,7 @@ pub struct PyDictIterator<'py> {
 }
 
 impl<'py> Iterator for PyDictIterator<'py> {
-    type Item = (&'py PyObjectRef, &'py PyObjectRef);
+    type Item = (&'py PyAny, &'py PyAny);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -183,7 +183,7 @@ impl<'py> Iterator for PyDictIterator<'py> {
 }
 
 impl<'a> std::iter::IntoIterator for &'a PyDict {
-    type Item = (&'a PyObjectRef, &'a PyObjectRef);
+    type Item = (&'a PyAny, &'a PyAny);
     type IntoIter = PyDictIterator<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
diff --git a/src/types/floatob.rs b/src/types/floatob.rs
index 6a96db41..73154b79 100644
--- a/src/types/floatob.rs
+++ b/src/types/floatob.rs
@@ -7,7 +7,7 @@ use crate::ffi;
 use crate::instance::{Py, PyNativeType};
 use crate::object::PyObject;
 use crate::objectprotocol::ObjectProtocol;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::FromPyObject;
 use crate::PyResult;
@@ -53,7 +53,7 @@ impl IntoPyObject for f64 {
 impl<'source> FromPyObject<'source> for f64 {
     // PyFloat_AsDouble returns -1.0 upon failure
     #![cfg_attr(feature = "cargo-clippy", allow(clippy::float_cmp))]
-    fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+    fn extract(obj: &'source PyAny) -> PyResult<Self> {
         let v = unsafe { ffi::PyFloat_AsDouble(obj.as_ptr()) };
 
         if v == -1.0 && PyErr::occurred(obj.py()) {
@@ -77,7 +77,7 @@ impl IntoPyObject for f32 {
 }
 
 impl<'source> FromPyObject<'source> for f32 {
-    fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+    fn extract(obj: &'source PyAny) -> PyResult<Self> {
         Ok(obj.extract::<f64>()? as f32)
     }
 }
diff --git a/src/types/iterator.rs b/src/types/iterator.rs
index b0bed3d5..74d1ff67 100644
--- a/src/types/iterator.rs
+++ b/src/types/iterator.rs
@@ -5,7 +5,7 @@
 use crate::err::{PyDowncastError, PyErr, PyResult};
 use crate::ffi;
 use crate::instance::PyNativeType;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::Python;
 
@@ -30,7 +30,7 @@ use crate::Python;
 /// # Ok(())
 /// # }
 /// ```
-pub struct PyIterator<'p>(&'p PyObjectRef);
+pub struct PyIterator<'p>(&'p PyAny);
 
 impl<'p> PyIterator<'p> {
     /// Constructs a `PyIterator` from a Python iterator object.
@@ -52,7 +52,7 @@ impl<'p> PyIterator<'p> {
 }
 
 impl<'p> Iterator for PyIterator<'p> {
-    type Item = PyResult<&'p PyObjectRef>;
+    type Item = PyResult<&'p PyAny>;
 
     /// Retrieves the next item from an iterator.
     /// Returns `None` when the iterator is exhausted.
diff --git a/src/types/list.rs b/src/types/list.rs
index baaef9ea..2e0170f4 100644
--- a/src/types/list.rs
+++ b/src/types/list.rs
@@ -6,7 +6,7 @@ use crate::err::{self, PyResult};
 use crate::ffi::{self, Py_ssize_t};
 use crate::instance::PyNativeType;
 use crate::object::PyObject;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Python;
@@ -59,7 +59,7 @@ impl PyList {
     /// Gets the item at the specified index.
     ///
     /// Panics if the index is out of range.
-    pub fn get_item(&self, index: isize) -> &PyObjectRef {
+    pub fn get_item(&self, index: isize) -> &PyAny {
         unsafe {
             self.py()
                 .from_borrowed_ptr(ffi::PyList_GetItem(self.as_ptr(), index as Py_ssize_t))
@@ -141,10 +141,10 @@ pub struct PyListIterator<'a> {
 }
 
 impl<'a> Iterator for PyListIterator<'a> {
-    type Item = &'a PyObjectRef;
+    type Item = &'a PyAny;
 
     #[inline]
-    fn next(&mut self) -> Option<&'a PyObjectRef> {
+    fn next(&mut self) -> Option<&'a PyAny> {
         if self.index < self.list.len() as isize {
             let item = self.list.get_item(self.index);
             self.index += 1;
@@ -156,7 +156,7 @@ impl<'a> Iterator for PyListIterator<'a> {
 }
 
 impl<'a> std::iter::IntoIterator for &'a PyList {
-    type Item = &'a PyObjectRef;
+    type Item = &'a PyAny;
     type IntoIter = PyListIterator<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
diff --git a/src/types/mod.rs b/src/types/mod.rs
index 91c3d49e..a7c84b62 100644
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@@ -40,11 +40,11 @@ macro_rules! pyobject_downcast (
         impl<'a, $($type_param,)*> $crate::FromPyObject<'a> for &'a $name
         {
             /// Extracts `Self` from the source `PyObject`.
-            fn extract(ob: &'a $crate::types::PyObjectRef) -> $crate::PyResult<Self>
+            fn extract(ob: &'a $crate::types::PyAny) -> $crate::PyResult<Self>
             {
                 unsafe {
                     if $checkfunction(ob.as_ptr()) != 0 {
-                        Ok(&*(ob as *const $crate::types::PyObjectRef as *const $name))
+                        Ok(&*(ob as *const $crate::types::PyAny as *const $name))
                     } else {
                         Err($crate::PyDowncastError.into())
                     }
@@ -57,10 +57,10 @@ macro_rules! pyobject_downcast (
 #[macro_export]
 macro_rules! pyobject_native_type_named (
     ($name: ty $(,$type_param: ident)*) => {
-        impl<$($type_param,)*> ::std::convert::AsRef<$crate::types::PyObjectRef> for $name {
+        impl<$($type_param,)*> ::std::convert::AsRef<$crate::types::PyAny> for $name {
             #[inline]
-            fn as_ref(&self) -> &$crate::types::PyObjectRef {
-                unsafe{&*(self as *const $name as *const $crate::types::PyObjectRef)}
+            fn as_ref(&self) -> &$crate::types::PyAny {
+                unsafe{&*(self as *const $name as *const $crate::types::PyAny)}
             }
         }
 
@@ -91,9 +91,9 @@ macro_rules! pyobject_native_type (
         pyobject_native_type_named!($name $(,$type_param)*);
         pyobject_native_type_convert!($name, $typeobject, $checkfunction $(,$type_param)*);
 
-        impl<'a, $($type_param,)*> ::std::convert::From<&'a $name> for &'a $crate::types::PyObjectRef {
+        impl<'a, $($type_param,)*> ::std::convert::From<&'a $name> for &'a $crate::types::PyAny {
             fn from(ob: &'a $name) -> Self {
-                unsafe{&*(ob as *const $name as *const $crate::types::PyObjectRef)}
+                unsafe{&*(ob as *const $name as *const $crate::types::PyAny)}
             }
         }
     };
@@ -104,7 +104,7 @@ macro_rules! pyobject_native_type_convert(
     ($name: ty, $typeobject: expr, $checkfunction: path $(,$type_param: ident)*) => {
         impl<$($type_param,)*> $crate::type_object::PyTypeInfo for $name {
             type Type = ();
-            type BaseType = $crate::types::PyObjectRef;
+            type BaseType = $crate::types::PyAny;
 
             const NAME: &'static str = stringify!($name);
             const SIZE: usize = ::std::mem::size_of::<$crate::ffi::PyObject>();
@@ -116,7 +116,7 @@ macro_rules! pyobject_native_type_convert(
             }
 
             #[allow(unused_unsafe)]
-            fn is_instance(ptr: &$crate::types::PyObjectRef) -> bool {
+            fn is_instance(ptr: &$crate::types::PyAny) -> bool {
                 use $crate::AsPyPointer;
 
                 unsafe { $checkfunction(ptr.as_ptr()) > 0 }
@@ -167,9 +167,9 @@ macro_rules! pyobject_native_type_convert(
 
 /// Represents general python instance.
 #[repr(transparent)]
-pub struct PyObjectRef(PyObject);
-pyobject_native_type_named!(PyObjectRef);
-pyobject_native_type_convert!(PyObjectRef, ffi::PyBaseObject_Type, ffi::PyObject_Check);
+pub struct PyAny(PyObject);
+pyobject_native_type_named!(PyAny);
+pyobject_native_type_convert!(PyAny, ffi::PyBaseObject_Type, ffi::PyObject_Check);
 
 mod boolobject;
 mod bytearray;
diff --git a/src/types/module.rs b/src/types/module.rs
index a2119895..1289434e 100644
--- a/src/types/module.rs
+++ b/src/types/module.rs
@@ -11,7 +11,7 @@ use crate::objectprotocol::ObjectProtocol;
 use crate::type_object::PyTypeCreate;
 use crate::type_object::PyTypeObject;
 use crate::types::PyTuple;
-use crate::types::{PyDict, PyObjectRef};
+use crate::types::{PyAny, PyDict};
 use crate::AsPyPointer;
 use crate::IntoPy;
 use crate::Py;
@@ -115,25 +115,25 @@ impl PyModule {
         name: &str,
         args: impl IntoPy<Py<PyTuple>>,
         kwargs: Option<&PyDict>,
-    ) -> PyResult<&PyObjectRef> {
+    ) -> PyResult<&PyAny> {
         self.getattr(name)?.call(args, kwargs)
     }
 
     /// Calls a function in the module.
     /// This is equivalent to the Python expression: `getattr(module, name)()`
-    pub fn call0(&self, name: &str) -> PyResult<&PyObjectRef> {
+    pub fn call0(&self, name: &str) -> PyResult<&PyAny> {
         self.getattr(name)?.call0()
     }
 
     /// Calls a function in the module.
     /// This is equivalent to the Python expression: `getattr(module, name)(*args)`
-    pub fn call1(&self, name: &str, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyObjectRef> {
+    pub fn call1(&self, name: &str, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny> {
         self.getattr(name)?.call1(args)
     }
 
     /// Gets a member from the module.
     /// This is equivalent to the Python expression: `getattr(module, name)`
-    pub fn get(&self, name: &str) -> PyResult<&PyObjectRef> {
+    pub fn get(&self, name: &str) -> PyResult<&PyAny> {
         self.getattr(name)
     }
 
diff --git a/src/types/num2.rs b/src/types/num2.rs
index 7f32a454..7c5dd432 100644
--- a/src/types/num2.rs
+++ b/src/types/num2.rs
@@ -8,7 +8,7 @@ use crate::exceptions;
 use crate::ffi;
 use crate::instance::{Py, PyNativeType};
 use crate::object::PyObject;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Python;
@@ -79,7 +79,7 @@ macro_rules! int_fits_c_long(
         }
 
         impl<'source> FromPyObject<'source> for $rust_type {
-            fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+            fn extract(obj: &'source PyAny) -> PyResult<Self> {
                 let val = unsafe { ffi::PyLong_AsLong(obj.as_ptr()) };
                 if val == -1 && PyErr::occurred(obj.py()) {
                     return Err(PyErr::fetch(obj.py()));
@@ -119,7 +119,7 @@ macro_rules! int_convert_u64_or_i64 (
         }
 
         impl <'source> FromPyObject<'source> for $rust_type {
-            fn extract(obj: &'source PyObjectRef) -> PyResult<$rust_type>
+            fn extract(obj: &'source PyAny) -> PyResult<$rust_type>
             {
                 let ptr = obj.as_ptr();
                 unsafe {
diff --git a/src/types/num3.rs b/src/types/num3.rs
index ad91624a..0bbd9b93 100644
--- a/src/types/num3.rs
+++ b/src/types/num3.rs
@@ -8,7 +8,7 @@ use crate::exceptions;
 use crate::ffi;
 use crate::instance::PyNativeType;
 use crate::object::PyObject;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::Python;
 use crate::{FromPyObject, IntoPyObject, ToPyObject};
@@ -47,7 +47,7 @@ macro_rules! int_fits_c_long (
         }
 
         impl<'source> FromPyObject<'source> for $rust_type {
-            fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+            fn extract(obj: &'source PyAny) -> PyResult<Self> {
                 let ptr = obj.as_ptr();
                 let val = unsafe {
                     let num = ffi::PyNumber_Index(ptr);
@@ -87,7 +87,7 @@ macro_rules! int_convert_u64_or_i64 (
             }
         }
         impl<'source> FromPyObject<'source> for $rust_type {
-            fn extract(ob: &'source PyObjectRef) -> PyResult<$rust_type>
+            fn extract(ob: &'source PyAny) -> PyResult<$rust_type>
             {
                 let ptr = ob.as_ptr();
                 unsafe {
diff --git a/src/types/num_common.rs b/src/types/num_common.rs
index 44d6cc6b..e0874553 100644
--- a/src/types/num_common.rs
+++ b/src/types/num_common.rs
@@ -32,7 +32,7 @@ macro_rules! int_fits_larger_int (
         }
 
         impl<'source> FromPyObject<'source> for $rust_type {
-            fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+            fn extract(obj: &'source PyAny) -> PyResult<Self> {
                 let val = $crate::objectprotocol::ObjectProtocol::extract::<$larger_type>(obj)?;
                 match cast::<$larger_type, $rust_type>(val) {
                     Some(v) => Ok(v),
@@ -71,7 +71,7 @@ macro_rules! int_convert_bignum (
             }
         }
         impl<'source> FromPyObject<'source> for $rust_type {
-            fn extract(ob: &'source PyObjectRef) -> PyResult<$rust_type> {
+            fn extract(ob: &'source PyAny) -> PyResult<$rust_type> {
                 unsafe {
                     let num = ffi::PyNumber_Index(ob.as_ptr());
                     if num.is_null() {
diff --git a/src/types/sequence.rs b/src/types/sequence.rs
index 06d32827..98153544 100644
--- a/src/types/sequence.rs
+++ b/src/types/sequence.rs
@@ -6,7 +6,7 @@ use crate::ffi::{self, Py_ssize_t};
 use crate::instance::PyNativeType;
 use crate::object::PyObject;
 use crate::objectprotocol::ObjectProtocol;
-use crate::types::{PyList, PyObjectRef, PyTuple};
+use crate::types::{PyAny, PyList, PyTuple};
 use crate::AsPyPointer;
 use crate::{FromPyObject, PyTryFrom, ToBorrowedObject};
 
@@ -33,11 +33,11 @@ impl PySequence {
         unsafe {
             let ptr = self
                 .py()
-                .from_owned_ptr_or_err::<PyObjectRef>(ffi::PySequence_Concat(
+                .from_owned_ptr_or_err::<PyAny>(ffi::PySequence_Concat(
                     self.as_ptr(),
                     other.as_ptr(),
                 ))?;
-            Ok(&*(ptr as *const PyObjectRef as *const PySequence))
+            Ok(&*(ptr as *const PyAny as *const PySequence))
         }
     }
 
@@ -49,11 +49,11 @@ impl PySequence {
         unsafe {
             let ptr = self
                 .py()
-                .from_owned_ptr_or_err::<PyObjectRef>(ffi::PySequence_Repeat(
+                .from_owned_ptr_or_err::<PyAny>(ffi::PySequence_Repeat(
                     self.as_ptr(),
                     count as Py_ssize_t,
                 ))?;
-            Ok(&*(ptr as *const PyObjectRef as *const PySequence))
+            Ok(&*(ptr as *const PyAny as *const PySequence))
         }
     }
 
@@ -87,7 +87,7 @@ impl PySequence {
 
     /// Return the ith element of the Sequence. Equivalent to python `o[index]`
     #[inline]
-    pub fn get_item(&self, index: isize) -> PyResult<&PyObjectRef> {
+    pub fn get_item(&self, index: isize) -> PyResult<&PyAny> {
         unsafe {
             self.py()
                 .from_owned_ptr_or_err(ffi::PySequence_GetItem(self.as_ptr(), index as Py_ssize_t))
@@ -97,7 +97,7 @@ impl PySequence {
     /// Return the slice of sequence object o between begin and end.
     /// This is the equivalent of the Python expression `o[begin:end]`
     #[inline]
-    pub fn get_slice(&self, begin: isize, end: isize) -> PyResult<&PyObjectRef> {
+    pub fn get_slice(&self, begin: isize, end: isize) -> PyResult<&PyAny> {
         unsafe {
             self.py().from_owned_ptr_or_err(ffi::PySequence_GetSlice(
                 self.as_ptr(),
@@ -139,7 +139,7 @@ impl PySequence {
     /// Assign the sequence object v to the slice in sequence object o from i1 to i2.
     /// This is the equivalent of the Python statement `o[i1:i2] = v`
     #[inline]
-    pub fn set_slice(&self, i1: isize, i2: isize, v: &PyObjectRef) -> PyResult<()> {
+    pub fn set_slice(&self, i1: isize, i2: isize, v: &PyAny) -> PyResult<()> {
         unsafe {
             err::error_on_minusone(
                 self.py(),
@@ -238,7 +238,7 @@ impl<'a, T> FromPyObject<'a> for Vec<T>
 where
     T: FromPyObject<'a>,
 {
-    default fn extract(obj: &'a PyObjectRef) -> PyResult<Self> {
+    default fn extract(obj: &'a PyAny) -> PyResult<Self> {
         extract_sequence(obj)
     }
 }
@@ -247,7 +247,7 @@ impl<'source, T> FromPyObject<'source> for Vec<T>
 where
     for<'a> T: FromPyObject<'a> + buffer::Element + Copy,
 {
-    fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+    fn extract(obj: &'source PyAny) -> PyResult<Self> {
         // first try buffer protocol
         if let Ok(buf) = buffer::PyBuffer::get(obj.py(), obj) {
             if buf.dimensions() == 1 {
@@ -263,7 +263,7 @@ where
     }
 }
 
-fn extract_sequence<'s, T>(obj: &'s PyObjectRef) -> PyResult<Vec<T>>
+fn extract_sequence<'s, T>(obj: &'s PyAny) -> PyResult<Vec<T>>
 where
     T: FromPyObject<'s>,
 {
@@ -276,7 +276,7 @@ where
 }
 
 impl<'v> PyTryFrom<'v> for PySequence {
-    fn try_from<V: Into<&'v PyObjectRef>>(value: V) -> Result<&'v PySequence, PyDowncastError> {
+    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v PySequence, PyDowncastError> {
         let value = value.into();
         unsafe {
             if ffi::PySequence_Check(value.as_ptr()) != 0 {
@@ -287,15 +287,11 @@ impl<'v> PyTryFrom<'v> for PySequence {
         }
     }
 
-    fn try_from_exact<V: Into<&'v PyObjectRef>>(
-        value: V,
-    ) -> Result<&'v PySequence, PyDowncastError> {
+    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v PySequence, PyDowncastError> {
         <PySequence as PyTryFrom>::try_from(value)
     }
 
-    fn try_from_mut<V: Into<&'v PyObjectRef>>(
-        value: V,
-    ) -> Result<&'v mut PySequence, PyDowncastError> {
+    fn try_from_mut<V: Into<&'v PyAny>>(value: V) -> Result<&'v mut PySequence, PyDowncastError> {
         let value = value.into();
         unsafe {
             if ffi::PySequence_Check(value.as_ptr()) != 0 {
@@ -306,20 +302,20 @@ impl<'v> PyTryFrom<'v> for PySequence {
         }
     }
 
-    fn try_from_mut_exact<V: Into<&'v PyObjectRef>>(
+    fn try_from_mut_exact<V: Into<&'v PyAny>>(
         value: V,
     ) -> Result<&'v mut PySequence, PyDowncastError> {
         <PySequence as PyTryFrom>::try_from_mut(value)
     }
 
     #[inline]
-    unsafe fn try_from_unchecked<V: Into<&'v PyObjectRef>>(value: V) -> &'v PySequence {
+    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PySequence {
         let ptr = value.into() as *const _ as *const PySequence;
         &*ptr
     }
 
     #[inline]
-    unsafe fn try_from_mut_unchecked<V: Into<&'v PyObjectRef>>(value: V) -> &'v mut PySequence {
+    unsafe fn try_from_mut_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v mut PySequence {
         let ptr = value.into() as *const _ as *mut PySequence;
         &mut *ptr
     }
diff --git a/src/types/string.rs b/src/types/string.rs
index 41c90c2c..90685abf 100644
--- a/src/types/string.rs
+++ b/src/types/string.rs
@@ -5,7 +5,7 @@ use crate::exceptions;
 use crate::ffi;
 use crate::instance::{Py, PyNativeType};
 use crate::object::PyObject;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::Python;
 use std::borrow::Cow;
@@ -34,11 +34,7 @@ impl PyString {
         unsafe { Py::from_owned_ptr_or_panic(ffi::PyUnicode_FromStringAndSize(ptr, len)) }
     }
 
-    pub fn from_object<'p>(
-        src: &'p PyObjectRef,
-        encoding: &str,
-        errors: &str,
-    ) -> PyResult<&'p PyString> {
+    pub fn from_object<'p>(src: &'p PyAny, encoding: &str, errors: &str) -> PyResult<&'p PyString> {
         unsafe {
             src.py()
                 .from_owned_ptr_or_err::<PyString>(ffi::PyUnicode_FromEncodedObject(
diff --git a/src/types/string2.rs b/src/types/string2.rs
index 0468a850..75e04bfe 100644
--- a/src/types/string2.rs
+++ b/src/types/string2.rs
@@ -2,7 +2,7 @@
 //
 // based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
 
-use super::PyObjectRef;
+use super::PyAny;
 use crate::err::{PyErr, PyResult};
 use crate::exceptions;
 use crate::ffi;
@@ -50,7 +50,7 @@ impl PyString {
         }
     }
 
-    pub fn from_object(src: &PyObjectRef, encoding: &str, errors: &str) -> PyResult<Py<PyString>> {
+    pub fn from_object(src: &PyAny, encoding: &str, errors: &str) -> PyResult<Py<PyString>> {
         unsafe {
             Ok(Py::from_owned_ptr_or_err(
                 src.py(),
@@ -137,7 +137,7 @@ impl PyUnicode {
         unsafe { Py::from_owned_ptr_or_panic(ffi::PyUnicode_FromStringAndSize(ptr, len)) }
     }
 
-    pub fn from_object(src: &PyObjectRef, encoding: &str, errors: &str) -> PyResult<Py<PyUnicode>> {
+    pub fn from_object(src: &PyAny, encoding: &str, errors: &str) -> PyResult<Py<PyUnicode>> {
         unsafe {
             Ok(Py::from_owned_ptr_or_err(
                 src.py(),
diff --git a/src/types/stringutils.rs b/src/types/stringutils.rs
index 0837eee1..87959ed4 100644
--- a/src/types/stringutils.rs
+++ b/src/types/stringutils.rs
@@ -1,7 +1,7 @@
 use crate::err::PyResult;
 use crate::instance::PyNativeType;
 use crate::object::PyObject;
-use crate::types::{PyObjectRef, PyString};
+use crate::types::{PyAny, PyString};
 use crate::FromPyObject;
 use crate::Python;
 use crate::{IntoPyObject, PyTryFrom, ToPyObject};
@@ -58,7 +58,7 @@ impl<'a> IntoPyObject for &'a String {
 /// Allows extracting strings from Python objects.
 /// Accepts Python `str` and `unicode` objects.
 impl<'source> crate::FromPyObject<'source> for Cow<'source, str> {
-    fn extract(ob: &'source PyObjectRef) -> PyResult<Self> {
+    fn extract(ob: &'source PyAny) -> PyResult<Self> {
         <PyString as PyTryFrom>::try_from(ob)?.to_string()
     }
 }
@@ -66,7 +66,7 @@ impl<'source> crate::FromPyObject<'source> for Cow<'source, str> {
 /// Allows extracting strings from Python objects.
 /// Accepts Python `str` and `unicode` objects.
 impl<'a> crate::FromPyObject<'a> for &'a str {
-    fn extract(ob: &'a PyObjectRef) -> PyResult<Self> {
+    fn extract(ob: &'a PyAny) -> PyResult<Self> {
         let s: Cow<'a, str> = crate::FromPyObject::extract(ob)?;
         match s {
             Cow::Borrowed(r) => Ok(r),
@@ -81,7 +81,7 @@ impl<'a> crate::FromPyObject<'a> for &'a str {
 /// Allows extracting strings from Python objects.
 /// Accepts Python `str` and `unicode` objects.
 impl<'source> FromPyObject<'source> for String {
-    fn extract(obj: &'source PyObjectRef) -> PyResult<Self> {
+    fn extract(obj: &'source PyAny) -> PyResult<Self> {
         <PyString as PyTryFrom>::try_from(obj)?
             .to_string()
             .map(Cow::into_owned)
diff --git a/src/types/tuple.rs b/src/types/tuple.rs
index 0da9500c..5f67cf69 100644
--- a/src/types/tuple.rs
+++ b/src/types/tuple.rs
@@ -6,7 +6,7 @@ use crate::exceptions;
 use crate::ffi::{self, Py_ssize_t};
 use crate::instance::{AsPyRef, Py, PyNativeType};
 use crate::object::PyObject;
-use crate::types::PyObjectRef;
+use crate::types::PyAny;
 use crate::AsPyPointer;
 use crate::IntoPyPointer;
 use crate::Python;
@@ -72,7 +72,7 @@ impl PyTuple {
     /// Gets the item at the specified index.
     ///
     /// Panics if the index is out of range.
-    pub fn get_item(&self, index: usize) -> &PyObjectRef {
+    pub fn get_item(&self, index: usize) -> &PyAny {
         // TODO: reconsider whether we should panic
         // It's quite inconsistent that this method takes `Python` when `len()` does not.
         assert!(index < self.len());
@@ -111,10 +111,10 @@ pub struct PyTupleIterator<'a> {
 }
 
 impl<'a> Iterator for PyTupleIterator<'a> {
-    type Item = &'a PyObjectRef;
+    type Item = &'a PyAny;
 
     #[inline]
-    fn next(&mut self) -> Option<&'a PyObjectRef> {
+    fn next(&mut self) -> Option<&'a PyAny> {
         if self.index < self.slice.len() {
             let item = self.slice[self.index].as_ref(self.py);
             self.index += 1;
@@ -126,7 +126,7 @@ impl<'a> Iterator for PyTupleIterator<'a> {
 }
 
 impl<'a> IntoIterator for &'a PyTuple {
-    type Item = &'a PyObjectRef;
+    type Item = &'a PyAny;
     type IntoIter = PyTupleIterator<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -180,7 +180,7 @@ 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 PyObjectRef) -> PyResult<Self>
+        fn extract(obj: &'s PyAny) -> PyResult<Self>
         {
             let t = <PyTuple as PyTryFrom>::try_from(obj)?;
             let slice = t.as_slice();
@@ -254,7 +254,7 @@ tuple_conversion!(
 mod test {
     use crate::instance::AsPyRef;
     use crate::objectprotocol::ObjectProtocol;
-    use crate::types::PyObjectRef;
+    use crate::types::PyAny;
     use crate::types::PyTuple;
     use crate::Python;
     use crate::{PyTryFrom, ToPyObject};
@@ -267,7 +267,7 @@ mod test {
         let pyob = PyTuple::new(py, &[1, 2, 3]);
         let ob = pyob.as_ref(py);
         assert_eq!(3, ob.len());
-        let ob: &PyObjectRef = ob.into();
+        let ob: &PyAny = ob.into();
         assert_eq!((1, 2, 3), ob.extract().unwrap());
 
         let mut map = HashSet::new();
@@ -283,7 +283,7 @@ mod test {
         let ob = (1, 2, 3).to_object(py);
         let tuple = <PyTuple as PyTryFrom>::try_from(ob.as_ref(py)).unwrap();
         assert_eq!(3, tuple.len());
-        let ob: &PyObjectRef = tuple.into();
+        let ob: &PyAny = tuple.into();
         assert_eq!((1, 2, 3), ob.extract().unwrap());
     }
 
diff --git a/tests/test_arithmetics.rs b/tests/test_arithmetics.rs
index 1f5afe9c..e1e56715 100644
--- a/tests/test_arithmetics.rs
+++ b/tests/test_arithmetics.rs
@@ -1,7 +1,7 @@
 use pyo3::class::basic::CompareOp;
 use pyo3::class::*;
 use pyo3::prelude::*;
-use pyo3::types::PyObjectRef;
+use pyo3::types::PyAny;
 
 #[macro_use]
 mod common;
@@ -127,35 +127,35 @@ fn inplace_operations() {
 
 #[pyproto]
 impl PyNumberProtocol for BinaryArithmetic {
-    fn __add__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __add__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} + {:?}", lhs, rhs))
     }
 
-    fn __sub__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __sub__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} - {:?}", lhs, rhs))
     }
 
-    fn __mul__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __mul__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} * {:?}", lhs, rhs))
     }
 
-    fn __lshift__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __lshift__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} << {:?}", lhs, rhs))
     }
 
-    fn __rshift__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __rshift__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} >> {:?}", lhs, rhs))
     }
 
-    fn __and__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __and__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} & {:?}", lhs, rhs))
     }
 
-    fn __xor__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __xor__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} ^ {:?}", lhs, rhs))
     }
 
-    fn __or__(lhs: &PyObjectRef, rhs: &PyObjectRef) -> PyResult<String> {
+    fn __or__(lhs: &PyAny, rhs: &PyAny) -> PyResult<String> {
         Ok(format!("{:?} | {:?}", lhs, rhs))
     }
 }
@@ -195,7 +195,7 @@ impl PyObjectProtocol for RichComparisons {
         Ok("RC")
     }
 
-    fn __richcmp__(&self, other: &PyObjectRef, op: CompareOp) -> PyResult<String> {
+    fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyResult<String> {
         match op {
             CompareOp::Lt => Ok(format!("{} < {:?}", self.__repr__().unwrap(), other)),
             CompareOp::Le => Ok(format!("{} <= {:?}", self.__repr__().unwrap(), other)),
@@ -216,7 +216,7 @@ impl PyObjectProtocol for RichComparisons2 {
         Ok("RC2")
     }
 
-    fn __richcmp__(&self, _other: &PyObjectRef, op: CompareOp) -> PyResult<PyObject> {
+    fn __richcmp__(&self, _other: &PyAny, op: CompareOp) -> PyResult<PyObject> {
         let gil = GILGuard::acquire();
         match op {
             CompareOp::Eq => Ok(true.to_object(gil.python())),
diff --git a/tests/test_datetime.rs b/tests/test_datetime.rs
index bca02f4e..5c738087 100644
--- a/tests/test_datetime.rs
+++ b/tests/test_datetime.rs
@@ -2,13 +2,13 @@
 
 use pyo3::ffi::*;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyObjectRef};
+use pyo3::types::{PyAny, PyDict};
 
 fn _get_subclasses<'p>(
     py: &'p Python,
     py_type: &str,
     args: &str,
-) -> PyResult<(&'p PyObjectRef, &'p PyObjectRef, &'p PyObjectRef)> {
+) -> PyResult<(&'p PyAny, &'p PyAny, &'p PyAny)> {
     // Import the class from Python and create some subclasses
     let datetime = py.import("datetime")?;
 
diff --git a/tests/test_dunder.rs b/tests/test_dunder.rs
index 66f97ad7..a75267e2 100644
--- a/tests/test_dunder.rs
+++ b/tests/test_dunder.rs
@@ -6,7 +6,7 @@ use pyo3::class::{
 use pyo3::exceptions::{IndexError, ValueError};
 use pyo3::ffi;
 use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyDict, PyObjectRef, PySlice, PyString, PyType};
+use pyo3::types::{PyAny, PyBytes, PyDict, PySlice, PyString, PyType};
 use pyo3::AsPyPointer;
 use std::{isize, iter};
 
@@ -351,8 +351,8 @@ impl<'p> PyContextProtocol<'p> for ContextManager {
     fn __exit__(
         &mut self,
         ty: Option<&'p PyType>,
-        _value: Option<&'p PyObjectRef>,
-        _traceback: Option<&'p PyObjectRef>,
+        _value: Option<&'p PyAny>,
+        _traceback: Option<&'p PyAny>,
     ) -> PyResult<bool> {
         let gil = GILGuard::acquire();
         self.exit_called = true;
@@ -405,7 +405,7 @@ struct Test {}
 
 #[pyproto]
 impl<'p> PyMappingProtocol<'p> for Test {
-    fn __getitem__(&self, idx: &PyObjectRef) -> PyResult<PyObject> {
+    fn __getitem__(&self, idx: &PyAny) -> PyResult<PyObject> {
         let gil = GILGuard::acquire();
         if let Ok(slice) = idx.cast_as::<PySlice>() {
             let indices = slice.indices(1000)?;
diff --git a/tests/test_gc.rs b/tests/test_gc.rs
index 523b5e5a..7a9d032c 100644
--- a/tests/test_gc.rs
+++ b/tests/test_gc.rs
@@ -3,7 +3,7 @@ use pyo3::class::PyTraverseError;
 use pyo3::class::PyVisit;
 use pyo3::ffi;
 use pyo3::prelude::*;
-use pyo3::types::PyObjectRef;
+use pyo3::types::PyAny;
 use pyo3::types::PyTuple;
 use pyo3::AsPyPointer;
 use pyo3::PyRawObject;
@@ -95,7 +95,7 @@ impl Drop for ClassWithDrop {
 
             let _empty1 = PyTuple::empty(py);
             let _empty2: PyObject = PyTuple::empty(py).into();
-            let _empty3: &PyObjectRef = py.from_owned_ptr(ffi::PyTuple_New(0));
+            let _empty3: &PyAny = py.from_owned_ptr(ffi::PyTuple_New(0));
         }
     }
 }