use PyErr_SetRaisedException in raise_lazy

Author: bschoenmaeckers

pyo3-ffi/src/compat/py_3_9.rs

@@ -18,3 +18,13 @@ compat_function!(
         crate::PyObject_CallMethodObjArgs(obj, name, std::ptr::null_mut::<crate::PyObject>())
     }
 );
+
+compat_function!(
+    // Added to python in 3.9 but available in 3.8 using private vectorcall api
+    originally_defined_for(all(Py_3_8, not(any(Py_LIMITED_API, PyPy))));
+
+    #[inline]
+    pub unsafe fn PyObject_CallOneArg(func: *mut crate::PyObject, arg: *mut crate::PyObject) -> *mut crate::PyObject {
+        crate::PyObject_CallFunctionObjArgs(func, arg, std::ptr::null_mut::<crate::PyObject>())
+    }
+);

src/err/err_state.rs

@@ -383,22 +383,42 @@ fn lazy_into_normalized_ffi_tuple(
 }
 
 /// Raises a "lazy" exception state into the Python interpreter.
-///
-/// In principle this could be split in two; first a function to create an exception
-/// in a normalized state, and then a call to `PyErr_SetRaisedException` to raise it.
-///
-/// This would require either moving some logic from C to Rust, or requesting a new
-/// API in CPython.
 fn raise_lazy(py: Python<'_>, lazy: Box<PyErrStateLazyFn>) {
     let PyErrStateLazyFnOutput { ptype, pvalue } = lazy(py);
+
     unsafe {
         if ffi::PyExceptionClass_Check(ptype.as_ptr()) == 0 {
             ffi::PyErr_SetString(
                 PyTypeError::type_object_raw(py).cast(),
                 c"exceptions must derive from BaseException".as_ptr(),
-            )
+            );
         } else {
-            ffi::PyErr_SetObject(ptype.as_ptr(), pvalue.as_ptr())
+            #[cfg(not(Py_3_12))]
+            ffi::PyErr_SetObject(ptype.as_ptr(), pvalue.as_ptr());
+
+            #[cfg(Py_3_12)]
+            {
+                let exc = if ffi::PyExceptionInstance_Check(pvalue.as_ptr()) != 0 {
+                    // If it's already an exception instance, keep it as-is.
+                    ffi::Py_NewRef(pvalue.as_ptr())
+                } else if pvalue.as_ptr() == ffi::Py_None() {
+                    // If the value is None, call the type with no arguments.
+                    ffi::PyObject_CallNoArgs(ptype.as_ptr())
+                } else if ffi::PyTuple_Check(pvalue.as_ptr()) != 0 {
+                    // If the value is a tuple, unpack it as arguments to the type.
+                    ffi::PyObject_Call(ptype.as_ptr(), pvalue.as_ptr(), std::ptr::null_mut())
+                } else {
+                    // Fallback: type(value)
+                    ffi::compat::PyObject_CallOneArg(ptype.as_ptr(), pvalue.as_ptr())
+                };
+
+                if exc.is_null() {
+                    // Exception constructor raised an exception, so propagate that instead of the original one.
+                    return;
+                }
+
+                ffi::PyErr_SetRaisedException(exc);
+            }
         }
     }
 }