fix exception handling on Python 3.12

newsfragments/3306.changed.md

@@ -0,0 +1 @@
+Update `PyErr` for 3.12 betas to avoid deprecated ffi methods.

src/err/err_state.rs

@@ -7,11 +7,37 @@ use crate::{
 
 #[derive(Clone)]
 pub(crate) struct PyErrStateNormalized {
+    #[cfg(not(Py_3_12))]
     pub ptype: Py<PyType>,
     pub pvalue: Py<PyBaseException>,
+    #[cfg(not(Py_3_12))]
     pub ptraceback: Option<Py<PyTraceback>>,
 }
 
+impl PyErrStateNormalized {
+    #[cfg(not(Py_3_12))]
+    pub(crate) fn ptype<'py>(&'py self, py: Python<'py>) -> &'py PyType {
+        self.ptype.as_ref(py)
+    }
+
+    #[cfg(Py_3_12)]
+    pub(crate) fn ptype<'py>(&'py self, py: Python<'py>) -> &'py PyType {
+        self.pvalue.as_ref(py).get_type()
+    }
+
+    #[cfg(not(Py_3_12))]
+    pub(crate) fn ptraceback<'py>(&'py self, py: Python<'py>) -> Option<&'py PyTraceback> {
+        self.ptraceback
+            .as_ref()
+            .map(|traceback| traceback.as_ref(py))
+    }
+
+    #[cfg(Py_3_12)]
+    pub(crate) fn ptraceback<'py>(&'py self, py: Python<'py>) -> Option<&'py PyTraceback> {
+        unsafe { py.from_owned_ptr_or_opt(ffi::PyException_GetTraceback(self.pvalue.as_ptr())) }
+    }
+}
+
 pub(crate) struct PyErrStateLazyFnOutput {
     pub(crate) ptype: PyObject,
     pub(crate) pvalue: PyObject,
@@ -22,6 +48,7 @@ pub(crate) type PyErrStateLazyFn =
 
 pub(crate) enum PyErrState {
     Lazy(Box<PyErrStateLazyFn>),
+    #[cfg(not(Py_3_12))]
     FfiTuple {
         ptype: PyObject,
         pvalue: Option<PyObject>,
@@ -53,9 +80,8 @@ impl PyErrState {
             pvalue: args.arguments(py),
         }))
     }
-}
 
-impl PyErrState {
+    #[cfg(not(Py_3_12))]
     pub(crate) fn into_ffi_tuple(
         self,
         py: Python<'_>,
@@ -64,7 +90,11 @@ impl PyErrState {
             PyErrState::Lazy(lazy) => {
                 let PyErrStateLazyFnOutput { ptype, pvalue } = lazy(py);
                 if unsafe { ffi::PyExceptionClass_Check(ptype.as_ptr()) } == 0 {
-                    Self::exceptions_must_derive_from_base_exception(py).into_ffi_tuple(py)
+                    PyErrState::lazy(
+                        PyTypeError::type_object(py),
+                        "exceptions must derive from BaseException",
+                    )
+                    .into_ffi_tuple(py)
                 } else {
                     (ptype.into_ptr(), pvalue.into_ptr(), std::ptr::null_mut())
                 }
@@ -82,10 +112,57 @@ impl PyErrState {
         }
     }
 
-    fn exceptions_must_derive_from_base_exception(py: Python<'_>) -> Self {
-        PyErrState::lazy(
-            PyTypeError::type_object(py),
-            "exceptions must derive from BaseException",
-        )
+    #[cfg(not(Py_3_12))]
+    pub(crate) fn normalize(self, py: Python<'_>) -> PyErrStateNormalized {
+        let (mut ptype, mut pvalue, mut ptraceback) = self.into_ffi_tuple(py);
+
+        unsafe {
+            ffi::PyErr_NormalizeException(&mut ptype, &mut pvalue, &mut ptraceback);
+            PyErrStateNormalized {
+                ptype: Py::from_owned_ptr_or_opt(py, ptype).expect("Exception type missing"),
+                pvalue: Py::from_owned_ptr_or_opt(py, pvalue).expect("Exception value missing"),
+                ptraceback: Py::from_owned_ptr_or_opt(py, ptraceback),
+            }
+        }
+    }
+
+    #[cfg(Py_3_12)]
+    pub(crate) fn normalize(self, py: Python<'_>) -> PyErrStateNormalized {
+        // To keep the implementation simple, just write the exception into the interpreter,
+        // which will cause it to be normalized
+        self.restore(py);
+        // Safety: self.restore(py) will set the raised exception
+        let pvalue = unsafe { Py::from_owned_ptr(py, ffi::PyErr_GetRaisedException()) };
+        PyErrStateNormalized { pvalue }
+    }
+
+    #[cfg(not(Py_3_12))]
+    pub(crate) fn restore(self, py: Python<'_>) {
+        let (ptype, pvalue, ptraceback) = self.into_ffi_tuple(py);
+        unsafe { ffi::PyErr_Restore(ptype, pvalue, ptraceback) }
+    }
+
+    #[cfg(Py_3_12)]
+    pub(crate) fn restore(self, py: Python<'_>) {
+        match self {
+            PyErrState::Lazy(lazy) => {
+                let PyErrStateLazyFnOutput { ptype, pvalue } = lazy(py);
+                unsafe {
+                    if ffi::PyExceptionClass_Check(ptype.as_ptr()) == 0 {
+                        ffi::PyErr_SetString(
+                            PyTypeError::type_object_raw(py).cast(),
+                            "exceptions must derive from BaseException\0"
+                                .as_ptr()
+                                .cast(),
+                        )
+                    } else {
+                        ffi::PyErr_SetObject(ptype.as_ptr(), pvalue.as_ptr())
+                    }
+                }
+            }
+            PyErrState::Normalized(PyErrStateNormalized { pvalue }) => unsafe {
+                ffi::PyErr_SetRaisedException(pvalue.into_ptr())
+            },
+        }
     }
 }

src/err/mod.rs

@@ -178,8 +178,10 @@ impl PyErr {
     pub fn from_value(obj: &PyAny) -> PyErr {
         let state = if let Ok(obj) = obj.downcast::<PyBaseException>() {
             PyErrState::Normalized(PyErrStateNormalized {
+                #[cfg(not(Py_3_12))]
                 ptype: obj.get_type().into(),
                 pvalue: obj.into(),
+                #[cfg(not(Py_3_12))]
                 ptraceback: None,
             })
         } else {
@@ -203,7 +205,7 @@ impl PyErr {
     /// });
     /// ```
     pub fn get_type<'py>(&'py self, py: Python<'py>) -> &'py PyType {
-        self.normalized(py).ptype.as_ref(py)
+        self.normalized(py).ptype(py)
     }
 
     /// Returns the value of this exception.
@@ -243,10 +245,7 @@ impl PyErr {
     /// });
     /// ```
     pub fn traceback<'py>(&'py self, py: Python<'py>) -> Option<&'py PyTraceback> {
-        self.normalized(py)
-            .ptraceback
-            .as_ref()
-            .map(|obj| obj.as_ref(py))
+        self.normalized(py).ptraceback(py)
     }
 
     /// Gets whether an error is present in the Python interpreter's global state.
@@ -265,6 +264,11 @@ impl PyErr {
     /// expected to have been set, for example from [`PyErr::occurred`] or by an error return value
     /// from a C FFI function, use [`PyErr::fetch`].
     pub fn take(py: Python<'_>) -> Option<PyErr> {
+        Self::_take(py)
+    }
+
+    #[cfg(not(Py_3_12))]
+    fn _take(py: Python<'_>) -> Option<PyErr> {
         let (ptype, pvalue, ptraceback) = unsafe {
             let mut ptype: *mut ffi::PyObject = std::ptr::null_mut();
             let mut pvalue: *mut ffi::PyObject = std::ptr::null_mut();
@@ -302,17 +306,12 @@ impl PyErr {
                 .and_then(|obj| obj.extract(py).ok())
                 .unwrap_or_else(|| String::from("Unwrapped panic from Python code"));
 
-            eprintln!(
-                "--- PyO3 is resuming a panic after fetching a PanicException from Python. ---"
-            );
-            eprintln!("Python stack trace below:");
-
-            unsafe {
-                ffi::PyErr_Restore(ptype.into_ptr(), pvalue.into_ptr(), ptraceback.into_ptr());
-                ffi::PyErr_PrintEx(0);
-            }
-
-            std::panic::resume_unwind(Box::new(msg))
+            let state = PyErrState::FfiTuple {
+                ptype,
+                pvalue,
+                ptraceback,
+            };
+            Self::print_panic_and_unwind(py, state, msg)
         }
 
         Some(PyErr::from_state(PyErrState::FfiTuple {
@@ -322,6 +321,31 @@ impl PyErr {
         }))
     }
 
+    #[cfg(Py_3_12)]
+    fn _take(py: Python<'_>) -> Option<PyErr> {
+        let pvalue = unsafe { Py::from_owned_ptr_or_opt(py, ffi::PyErr_GetRaisedException()) }?;
+        let state = PyErrStateNormalized { pvalue };
+        if state.ptype(py).as_ptr() == PanicException::type_object_raw(py).cast() {
+            let msg: String = state.pvalue.as_ref(py).to_string();
+            Self::print_panic_and_unwind(py, PyErrState::Normalized(state), msg)
+        }
+
+        Some(PyErr::from_state(PyErrState::Normalized(state)))
+    }
+
+    fn print_panic_and_unwind(py: Python<'_>, state: PyErrState, msg: String) -> ! {
+        eprintln!("--- PyO3 is resuming a panic after fetching a PanicException from Python. ---");
+        eprintln!("Python stack trace below:");
+
+        state.restore(py);
+
+        unsafe {
+            ffi::PyErr_PrintEx(0);
+        }
+
+        std::panic::resume_unwind(Box::new(msg))
+    }
+
     /// Equivalent to [PyErr::take], but when no error is set:
     ///  - Panics in debug mode.
     ///  - Returns a `SystemError` in release mode.
@@ -443,15 +467,12 @@ impl PyErr {
     /// This is the opposite of `PyErr::fetch()`.
     #[inline]
     pub fn restore(self, py: Python<'_>) {
-        let state = match self.state.into_inner() {
-            Some(state) => state,
+        match self.state.into_inner() {
+            Some(state) => state.restore(py),
             // Safety: restore takes `self` by value so nothing else is accessing this err
             // and the invariant is that state is always defined except during make_normalized
             None => unsafe { std::hint::unreachable_unchecked() },
         };
-
-        let (ptype, pvalue, ptraceback) = state.into_ffi_tuple(py);
-        unsafe { ffi::PyErr_Restore(ptype, pvalue, ptraceback) }
     }
 
     /// Reports the error as unraisable.
@@ -635,17 +656,10 @@ impl PyErr {
                 .take()
                 .expect("Cannot normalize a PyErr while already normalizing it.")
         };
-        let (mut ptype, mut pvalue, mut ptraceback) = state.into_ffi_tuple(py);
 
         unsafe {
-            ffi::PyErr_NormalizeException(&mut ptype, &mut pvalue, &mut ptraceback);
             let self_state = &mut *self.state.get();
-            *self_state = Some(PyErrState::Normalized(PyErrStateNormalized {
-                ptype: Py::from_owned_ptr_or_opt(py, ptype).expect("Exception type missing"),
-                pvalue: Py::from_owned_ptr_or_opt(py, pvalue).expect("Exception value missing"),
-                ptraceback: Py::from_owned_ptr_or_opt(py, ptraceback),
-            }));
-
+            *self_state = Some(PyErrState::Normalized(state.normalize(py)));
             match self_state {
                 Some(PyErrState::Normalized(n)) => n,
                 _ => unreachable!(),
@@ -812,6 +826,7 @@ mod tests {
             assert!(err.is_instance_of::<exceptions::PyTypeError>(py));
             err.restore(py);
             let err = PyErr::fetch(py);
+
             assert!(err.is_instance_of::<exceptions::PyTypeError>(py));
             assert_eq!(
                 err.to_string(),