reintroduce PyTypeInfo methods (#4484)

guide/src/class/numeric.md

@@ -387,7 +387,7 @@ fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
 # fn main() -> PyResult<()> {
 #     Python::with_gil(|py| -> PyResult<()> {
 #         let globals = PyModule::import(py, "__main__")?.dict();
-#         globals.set_item("Number", Number::type_object_bound(py))?;
+#         globals.set_item("Number", Number::type_object(py))?;
 #
 #         py.run(SCRIPT, Some(&globals), None)?;
 #         Ok(())

src/err/mod.rs

@@ -160,7 +160,7 @@ impl PyErr {
     {
         PyErr::from_state(PyErrState::Lazy(Box::new(move |py| {
             PyErrStateLazyFnOutput {
-                ptype: T::type_object_bound(py).into(),
+                ptype: T::type_object(py).into(),
                 pvalue: args.arguments(py),
             }
         })))
@@ -215,7 +215,7 @@ impl PyErr {
     ///     assert_eq!(err.to_string(), "TypeError: some type error");
     ///
     ///     // Case #2: Exception type
-    ///     let err = PyErr::from_value(PyTypeError::type_object_bound(py).into_any());
+    ///     let err = PyErr::from_value(PyTypeError::type_object(py).into_any());
     ///     assert_eq!(err.to_string(), "TypeError: ");
     ///
     ///     // Case #3: Invalid exception value
@@ -587,7 +587,7 @@ impl PyErr {
     where
         T: PyTypeInfo,
     {
-        self.is_instance(py, &T::type_object_bound(py))
+        self.is_instance(py, &T::type_object(py))
     }
 
     /// Writes the error back to the Python interpreter's global state.
@@ -1187,21 +1187,18 @@ mod tests {
     fn test_pyerr_matches() {
         Python::with_gil(|py| {
             let err = PyErr::new::<PyValueError, _>("foo");
-            assert!(err.matches(py, PyValueError::type_object_bound(py)));
+            assert!(err.matches(py, PyValueError::type_object(py)));
 
             assert!(err.matches(
                 py,
-                (
-                    PyValueError::type_object_bound(py),
-                    PyTypeError::type_object_bound(py)
-                )
+                (PyValueError::type_object(py), PyTypeError::type_object(py))
             ));
 
-            assert!(!err.matches(py, PyTypeError::type_object_bound(py)));
+            assert!(!err.matches(py, PyTypeError::type_object(py)));
 
             // String is not a valid exception class, so we should get a TypeError
-            let err: PyErr = PyErr::from_type(crate::types::PyString::type_object_bound(py), "foo");
-            assert!(err.matches(py, PyTypeError::type_object_bound(py)));
+            let err: PyErr = PyErr::from_type(crate::types::PyString::type_object(py), "foo");
+            assert!(err.matches(py, PyTypeError::type_object(py)));
         })
     }
 

src/impl_/pymodule.rs

@@ -176,7 +176,7 @@ impl<T> AddTypeToModule<T> {
 
 impl<T: PyTypeInfo> PyAddToModule for AddTypeToModule<T> {
     fn add_to_module(&'static self, module: &Bound<'_, PyModule>) -> PyResult<()> {
-        module.add(T::NAME, T::type_object_bound(module.py()))
+        module.add(T::NAME, T::type_object(module.py()))
     }
 }
 

src/marker.rs

@@ -685,7 +685,7 @@ impl<'py> Python<'py> {
     where
         T: PyTypeInfo,
     {
-        T::type_object_bound(self)
+        T::type_object(self)
     }
 
     /// Deprecated name for [`Python::get_type`].

src/tests/common.rs

@@ -144,7 +144,7 @@ mod inner {
             $crate::tests::common::CatchWarnings::enter($py, |w| {
                 use $crate::types::{PyListMethods, PyStringMethods};
                 $body;
-                let expected_warnings = [$((<$category as $crate::type_object::PyTypeInfo>::type_object_bound($py), $message)),+];
+                let expected_warnings = [$((<$category as $crate::type_object::PyTypeInfo>::type_object($py), $message)),+];
                 assert_eq!(w.len(), expected_warnings.len());
                 for (warning, (category, message)) in w.iter().zip(expected_warnings) {
 

src/type_object.rs

@@ -46,7 +46,7 @@ pub unsafe trait PyTypeInfo: Sized {
 
     /// Returns the safe abstraction over the type object.
     #[inline]
-    fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType> {
+    fn type_object(py: Python<'_>) -> Bound<'_, PyType> {
         // Making the borrowed object `Bound` is necessary for soundness reasons. It's an extreme
         // edge case, but arbitrary Python code _could_ change the __class__ of an object and cause
         // the type object to be freed.
@@ -61,17 +61,38 @@ pub unsafe trait PyTypeInfo: Sized {
         }
     }
 
+    /// Deprecated name for [`PyTypeInfo::type_object`].
+    #[deprecated(since = "0.23.0", note = "renamed to `PyTypeInfo::type_object`")]
+    #[inline]
+    fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType> {
+        Self::type_object(py)
+    }
+
     /// Checks if `object` is an instance of this type or a subclass of this type.
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         unsafe { ffi::PyObject_TypeCheck(object.as_ptr(), Self::type_object_raw(object.py())) != 0 }
     }
 
+    /// Deprecated name for [`PyTypeInfo::is_type_of`].
+    #[deprecated(since = "0.23.0", note = "renamed to `PyTypeInfo::is_type_of`")]
+    #[inline]
+    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+        Self::is_type_of(object)
+    }
+
     /// Checks if `object` is an instance of this type.
     #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
         unsafe { ffi::Py_TYPE(object.as_ptr()) == Self::type_object_raw(object.py()) }
     }
+
+    /// Deprecated name for [`PyTypeInfo::is_exact_type_of`].
+    #[deprecated(since = "0.23.0", note = "renamed to `PyTypeInfo::is_exact_type_of`")]
+    #[inline]
+    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+        Self::is_exact_type_of(object)
+    }
 }
 
 /// Implemented by types which can be used as a concrete Python type inside `Py<T>` smart pointers.
@@ -93,7 +114,7 @@ where
 
     #[inline]
     fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        T::is_type_of_bound(object)
+        T::is_type_of(object)
     }
 }
 

src/types/any.rs

@@ -1430,12 +1430,12 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     #[inline]
     fn is_instance_of<T: PyTypeInfo>(&self) -> bool {
-        T::is_type_of_bound(self)
+        T::is_type_of(self)
     }
 
     #[inline]
     fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool {
-        T::is_exact_type_of_bound(self)
+        T::is_exact_type_of(self)
     }
 
     fn contains<V>(&self, value: V) -> PyResult<bool>
@@ -1917,7 +1917,7 @@ class SimpleClass:
     #[test]
     fn test_is_callable() {
         Python::with_gil(|py| {
-            assert!(PyList::type_object_bound(py).is_callable());
+            assert!(PyList::type_object(py).is_callable());
 
             let not_callable = 5.to_object(py).into_bound(py);
             assert!(!not_callable.is_callable());

src/types/code.rs

@@ -23,7 +23,7 @@ mod tests {
     #[test]
     fn test_type_object() {
         Python::with_gil(|py| {
-            assert_eq!(PyCode::type_object_bound(py).name().unwrap(), "code");
+            assert_eq!(PyCode::type_object(py).name().unwrap(), "code");
         })
     }
 }

src/types/ellipsis.rs

@@ -37,13 +37,13 @@ unsafe impl PyTypeInfo for PyEllipsis {
     }
 
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         // ellipsis is not usable as a base type
-        Self::is_exact_type_of_bound(object)
+        Self::is_exact_type_of(object)
     }
 
     #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
         object.is(&**Self::get(object.py()))
     }
 }
@@ -67,7 +67,7 @@ mod tests {
         Python::with_gil(|py| {
             assert!(PyEllipsis::get(py)
                 .get_type()
-                .is(&PyEllipsis::type_object_bound(py)));
+                .is(&PyEllipsis::type_object(py)));
         })
     }
 

src/types/mapping.rs

@@ -24,7 +24,7 @@ impl PyMapping {
     /// library). This is equivalent to `collections.abc.Mapping.register(T)` in Python.
     /// This registration is required for a pyclass to be downcastable from `PyAny` to `PyMapping`.
     pub fn register<T: PyTypeInfo>(py: Python<'_>) -> PyResult<()> {
-        let ty = T::type_object_bound(py);
+        let ty = T::type_object(py);
         get_mapping_abc(py)?.call_method1("register", (ty,))?;
         Ok(())
     }
@@ -172,7 +172,7 @@ impl PyTypeCheck for PyMapping {
     fn type_check(object: &Bound<'_, PyAny>) -> bool {
         // Using `is_instance` for `collections.abc.Mapping` is slow, so provide
         // optimized case dict as a well-known mapping
-        PyDict::is_type_of_bound(object)
+        PyDict::is_type_of(object)
             || get_mapping_abc(object.py())
                 .and_then(|abc| object.is_instance(abc))
                 .unwrap_or_else(|err| {

src/types/none.rs

@@ -38,13 +38,13 @@ unsafe impl PyTypeInfo for PyNone {
     }
 
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         // NoneType is not usable as a base type
-        Self::is_exact_type_of_bound(object)
+        Self::is_exact_type_of(object)
     }
 
     #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
         object.is(&**Self::get(object.py()))
     }
 }
@@ -79,9 +79,7 @@ mod tests {
     #[test]
     fn test_none_type_object_consistent() {
         Python::with_gil(|py| {
-            assert!(PyNone::get(py)
-                .get_type()
-                .is(&PyNone::type_object_bound(py)));
+            assert!(PyNone::get(py).get_type().is(&PyNone::type_object(py)));
         })
     }
 

src/types/notimplemented.rs

@@ -40,13 +40,13 @@ unsafe impl PyTypeInfo for PyNotImplemented {
     }
 
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         // NotImplementedType is not usable as a base type
-        Self::is_exact_type_of_bound(object)
+        Self::is_exact_type_of(object)
     }
 
     #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
         object.is(&**Self::get(object.py()))
     }
 }
@@ -70,7 +70,7 @@ mod tests {
         Python::with_gil(|py| {
             assert!(PyNotImplemented::get(py)
                 .get_type()
-                .is(&PyNotImplemented::type_object_bound(py)));
+                .is(&PyNotImplemented::type_object(py)));
         })
     }
 

src/types/pysuper.rs

@@ -61,12 +61,10 @@ impl PySuper {
         ty: &Bound<'py, PyType>,
         obj: &Bound<'py, PyAny>,
     ) -> PyResult<Bound<'py, PySuper>> {
-        PySuper::type_object_bound(ty.py())
-            .call1((ty, obj))
-            .map(|any| {
-                // Safety: super() always returns instance of super
-                unsafe { any.downcast_into_unchecked() }
-            })
+        PySuper::type_object(ty.py()).call1((ty, obj)).map(|any| {
+            // Safety: super() always returns instance of super
+            unsafe { any.downcast_into_unchecked() }
+        })
     }
 
     /// Deprecated name for [`PySuper::new`].

src/types/sequence.rs

@@ -27,7 +27,7 @@ impl PySequence {
     /// library). This is equivalent to `collections.abc.Sequence.register(T)` in Python.
     /// This registration is required for a pyclass to be downcastable from `PyAny` to `PySequence`.
     pub fn register<T: PyTypeInfo>(py: Python<'_>) -> PyResult<()> {
-        let ty = T::type_object_bound(py);
+        let ty = T::type_object(py);
         get_sequence_abc(py)?.call_method1("register", (ty,))?;
         Ok(())
     }
@@ -362,8 +362,8 @@ impl PyTypeCheck for PySequence {
     fn type_check(object: &Bound<'_, PyAny>) -> bool {
         // Using `is_instance` for `collections.abc.Sequence` is slow, so provide
         // optimized cases for list and tuples as common well-known sequences
-        PyList::is_type_of_bound(object)
-            || PyTuple::is_type_of_bound(object)
+        PyList::is_type_of(object)
+            || PyTuple::is_type_of(object)
             || get_sequence_abc(object.py())
                 .and_then(|abc| object.is_instance(abc))
                 .unwrap_or_else(|err| {

src/types/typeobject.rs

@@ -24,7 +24,7 @@ impl PyType {
     /// Creates a new type object.
     #[inline]
     pub fn new<T: PyTypeInfo>(py: Python<'_>) -> Bound<'_, PyType> {
-        T::type_object_bound(py)
+        T::type_object(py)
     }
 
     /// Deprecated name for [`PyType::new`].
@@ -202,7 +202,7 @@ impl<'py> PyTypeMethods<'py> for Bound<'py, PyType> {
     where
         T: PyTypeInfo,
     {
-        self.is_subclass(&T::type_object_bound(self.py()))
+        self.is_subclass(&T::type_object(self.py()))
     }
 
     fn mro(&self) -> Bound<'py, PyTuple> {