Make is_instance() and is_subclass() take &PyAny

Should be (mostly?) compatible since `&PyType` auto-derefs to `&PyAny`.

Fixes #2694

guide/src/ecosystem/async-await.md

@@ -540,8 +540,6 @@ fn main() -> PyResult<()> {
                     uvloop
                         .as_ref(py)
                         .getattr("Loop")?
-                        .downcast::<PyType>()
-                        .unwrap()
                 )?);
                 Ok(())
             })?;

newsfragments/2695.changed.md

@@ -0,0 +1,3 @@
+`PyType::is_subclass`, `PyErr::is_instance` and `PyAny::is_instance` now take
+`&PyAny` instead of `&PyType` arguments, so that they work with objects that
+pretend to be types using `__subclasscheck__` and `__instancecheck__`.

src/conversions/path.rs

@@ -1,5 +1,4 @@
 use crate::intern;
-use crate::types::PyType;
 use crate::{FromPyObject, IntoPy, PyAny, PyObject, PyResult, Python, ToPyObject};
 use std::borrow::Cow;
 use std::ffi::OsString;
@@ -20,7 +19,7 @@ impl FromPyObject<'_> for PathBuf {
             Err(err) => {
                 let py = ob.py();
                 let pathlib = py.import(intern!(py, "pathlib"))?;
-                let pathlib_path: &PyType = pathlib.getattr(intern!(py, "Path"))?.downcast()?;
+                let pathlib_path = pathlib.getattr(intern!(py, "Path"))?;
                 if ob.is_instance(pathlib_path)? {
                     let path_str = ob.call_method0(intern!(py, "__str__"))?;
                     OsString::extract(path_str)?

src/err/mod.rs

@@ -448,7 +448,7 @@ impl PyErr {
 
     /// Returns true if the current exception is instance of `T`.
     #[inline]
-    pub fn is_instance(&self, py: Python<'_>, typ: &PyType) -> bool {
+    pub fn is_instance(&self, py: Python<'_>, typ: &PyAny) -> bool {
         unsafe { ffi::PyErr_GivenExceptionMatches(self.type_ptr(py), typ.as_ptr()) != 0 }
     }
 

src/types/any.rs

@@ -848,7 +848,7 @@ impl PyAny {
     /// Checks whether this object is an instance of type `ty`.
     ///
     /// This is equivalent to the Python expression `isinstance(self, ty)`.
-    pub fn is_instance(&self, ty: &PyType) -> PyResult<bool> {
+    pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool> {
         let result = unsafe { ffi::PyObject_IsInstance(self.as_ptr(), ty.as_ptr()) };
         err::error_on_minusone(self.py(), result)?;
         Ok(result == 1)
@@ -985,7 +985,7 @@ class SimpleClass:
     }
 
     #[test]
-    fn test_any_isinstance() {
+    fn test_any_isinstance_of() {
         Python::with_gil(|py| {
             let x = 5.to_object(py).into_ref(py);
             assert!(x.is_instance_of::<PyLong>().unwrap());
@@ -996,7 +996,7 @@ class SimpleClass:
     }
 
     #[test]
-    fn test_any_isinstance_of() {
+    fn test_any_isinstance() {
         Python::with_gil(|py| {
             let l = vec![1u8, 2].to_object(py).into_ref(py);
             assert!(l.is_instance(PyList::type_object(py)).unwrap());

src/types/dict.rs

@@ -519,8 +519,7 @@ mod tests {
     #[cfg(not(PyPy))]
     use crate::exceptions;
     #[cfg(not(PyPy))]
-    use crate::{types::PyList, PyTypeInfo};
-    use crate::{types::PyTuple, IntoPy, PyObject, PyTryFrom, Python, ToPyObject};
+    use crate::{types::PyList, types::PyTuple, IntoPy, PyObject, PyTryFrom, Python, ToPyObject};
     use std::collections::{BTreeMap, HashMap};
 
     #[test]
@@ -1042,7 +1041,7 @@ mod tests {
         Python::with_gil(|py| {
             let dict = abc_dict(py);
             let keys = dict.call_method0("keys").unwrap();
-            assert!(keys.is_instance(PyDictKeys::type_object(py)).unwrap());
+            assert!(keys.is_instance_of::<PyDictKeys>().unwrap());
         })
     }
 
@@ -1052,7 +1051,7 @@ mod tests {
         Python::with_gil(|py| {
             let dict = abc_dict(py);
             let values = dict.call_method0("values").unwrap();
-            assert!(values.is_instance(PyDictValues::type_object(py)).unwrap());
+            assert!(values.is_instance_of::<PyDictValues>().unwrap());
         })
     }
 
@@ -1062,7 +1061,7 @@ mod tests {
         Python::with_gil(|py| {
             let dict = abc_dict(py);
             let items = dict.call_method0("items").unwrap();
-            assert!(items.is_instance(PyDictItems::type_object(py)).unwrap());
+            assert!(items.is_instance_of::<PyDictItems>().unwrap());
         })
     }
 }

src/types/typeobject.rs

@@ -42,7 +42,7 @@ impl PyType {
     /// Checks whether `self` is a subclass of `other`.
     ///
     /// Equivalent to the Python expression `issubclass(self, other)`.
-    pub fn is_subclass(&self, other: &PyType) -> PyResult<bool> {
+    pub fn is_subclass(&self, other: &PyAny) -> PyResult<bool> {
         let result = unsafe { ffi::PyObject_IsSubclass(self.as_ptr(), other.as_ptr()) };
         err::error_on_minusone(self.py(), result)?;
         Ok(result == 1)