annotations to mitigate performance changes

Author: davidhewitt

src/err/mod.rs

@@ -53,6 +53,7 @@ pub struct PyDowncastError<'a> {
 impl<'a> PyDowncastError<'a> {
     /// Create a new `PyDowncastError` representing a failure to convert the object
     /// `from` into the type named in `to`.
+    #[cold]
     pub fn new(from: &'a PyAny, to: impl Into<Cow<'static, str>>) -> Self {
         PyDowncastError {
             from,

src/types/any.rs

@@ -847,6 +847,7 @@ impl PyAny {
     /// Extracts some type from the Python object.
     ///
     /// This is a wrapper function around [`FromPyObject::extract()`].
+    #[inline]
     pub fn extract<'a, D>(&'a self) -> PyResult<D>
     where
         D: FromPyObject<'a>,

src/types/mapping.rs

@@ -123,7 +123,10 @@ fn get_mapping_abc(py: Python<'_>) -> PyResult<&PyType> {
 impl PyTypeCheck for PyMapping {
     const NAME: &'static str = "Mapping";
 
+    #[inline]
     fn type_check(object: &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(object)
             || get_mapping_abc(object.py())
                 .and_then(|abc| object.is_instance(abc))
@@ -139,8 +142,6 @@ impl<'v> crate::PyTryFrom<'v> for PyMapping {
     fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v PyMapping, PyDowncastError<'v>> {
         let value = value.into();
 
-        // Using `is_instance` for `collections.abc.Mapping` is slow, so provide
-        // optimized case dict as a well-known mapping
         if PyMapping::type_check(value) {
             unsafe { return Ok(value.downcast_unchecked()) }
         }

src/types/mod.rs

@@ -219,6 +219,7 @@ macro_rules! pyobject_native_type_info(
 macro_rules! pyobject_native_type_extract {
     ($name:ty $(;$generics:ident)*) => {
         impl<'py, $($generics,)*> $crate::FromPyObject<'py> for &'py $name {
+            #[inline]
             fn extract(obj: &'py $crate::PyAny) -> $crate::PyResult<Self> {
                 obj.downcast().map_err(::std::convert::Into::into)
             }

src/types/sequence.rs

@@ -327,7 +327,10 @@ fn get_sequence_abc(py: Python<'_>) -> PyResult<&PyType> {
 impl PyTypeCheck for PySequence {
     const NAME: &'static str = "Sequence";
 
+    #[inline]
     fn type_check(object: &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(object)
             || PyTuple::is_type_of(object)
             || get_sequence_abc(object.py())
@@ -344,8 +347,6 @@ impl<'v> crate::PyTryFrom<'v> for PySequence {
     fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v PySequence, PyDowncastError<'v>> {
         let value = value.into();
 
-        // Using `is_instance` for `collections.abc.Sequence` is slow, so provide
-        // optimized cases for list and tuples as common well-known sequences
         if PySequence::type_check(value) {
             unsafe { return Ok(value.downcast_unchecked::<PySequence>()) }
         }