sys.unraisablehook

Author: youknowone

Lib/test/_test_atexit.py

@@ -45,25 +45,19 @@ def func2(*args, **kwargs):
                           ('func2', (), {}),
                           ('func1', (1, 2), {})])
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'unraisablehook'
-    @unittest.expectedFailure
     def test_badargs(self):
         def func():
             pass
 
         # func() has no parameter, but it's called with 2 parameters
         self.assert_raises_unraisable(TypeError, func, 1 ,2)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'unraisablehook'
-    @unittest.expectedFailure
     def test_raise(self):
         def raise_type_error():
             raise TypeError
 
         self.assert_raises_unraisable(TypeError, raise_type_error)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'unraisablehook'
-    @unittest.expectedFailure
     def test_raise_unnormalized(self):
         # bpo-10756: Make sure that an unnormalized exception is handled
         # properly.
@@ -72,8 +66,6 @@ def div_zero():
 
         self.assert_raises_unraisable(ZeroDivisionError, div_zero)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'unraisablehook'
-    @unittest.expectedFailure
     def test_exit(self):
         self.assert_raises_unraisable(SystemExit, sys.exit)
 
@@ -124,8 +116,6 @@ def test_bound_methods(self):
         atexit._run_exitfuncs()
         self.assertEqual(l, [5])
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'unraisablehook'
-    @unittest.expectedFailure
     def test_atexit_with_unregistered_function(self):
         # See bpo-46025 for more info
         def func():

Lib/test/test_io.py

@@ -1114,8 +1114,6 @@ def _with():
         # a ValueError.
         self.assertRaises(ValueError, _with)
 
-    # TODO: RUSTPYTHON, sys.unraisablehook
-    @unittest.expectedFailure
     def test_error_through_destructor(self):
         # Test that the exception state is not modified by a destructor,
         # even if close() fails.
@@ -2121,8 +2119,6 @@ def reader_close():
         # Silence destructor error
         reader.close = lambda: None
 
-    # TODO: RUSTPYTHON, sys.unraisablehook
-    @unittest.expectedFailure
     def test_writer_close_error_on_close(self):
         def writer_close():
             writer_non_existing
@@ -2952,8 +2948,6 @@ def flush(self):
         support.gc_collect()
         self.assertEqual(record, [1, 2, 3])
 
-    # TODO: RUSTPYTHON, sys.unraisablehook
-    @unittest.expectedFailure
     def test_error_through_destructor(self):
         # Test that the exception state is not modified by a destructor,
         # even if close() fails.

Lib/test/test_signal.py

@@ -1291,8 +1291,7 @@ def handler(signum, frame):
         # Python handler
         self.assertEqual(len(sigs), N, "Some signals were lost")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip("TODO: RUSTPYTHON; hang")
     @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
                          "test needs SIGUSR1")
     def test_stress_modifying_handlers(self):

Lib/test/test_thread.py

@@ -135,8 +135,6 @@ def task():
                 time.sleep(POLL_SLEEP)
             self.assertEqual(thread._count(), orig)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'unraisablehook'
-    @unittest.expectedFailure
     def test_unraisable_exception(self):
         def task():
             started.release()

vm/src/pyobjectrc.rs

@@ -11,23 +11,27 @@
 //! PyRef<PyWeak> may looking like to be called as PyObjectWeak by the rule,
 //! but not to do to remember it is a PyRef object.
 
-use crate::common::atomic::{OncePtr, PyAtomic, Radium};
-use crate::common::linked_list::{Link, LinkedList, Pointers};
-use crate::common::lock::{PyMutex, PyMutexGuard, PyRwLock};
-use crate::common::refcount::RefCount;
+use crate::common::{
+    atomic::{OncePtr, PyAtomic, Radium},
+    linked_list::{Link, LinkedList, Pointers},
+    lock::{PyMutex, PyMutexGuard, PyRwLock},
+    refcount::RefCount,
+};
 use crate::{
     _pyobject::{AsObject, PyObjectPayload, PyResult},
-    builtins::{PyBaseExceptionRef, PyDictRef, PyTypeRef},
+    builtins::{PyDictRef, PyTypeRef},
     vm::VirtualMachine,
 };
-use std::any::TypeId;
-use std::borrow::Borrow;
-use std::cell::UnsafeCell;
-use std::fmt;
-use std::marker::PhantomData;
-use std::mem::ManuallyDrop;
-use std::ops::Deref;
-use std::ptr::{self, NonNull};
+use std::{
+    any::TypeId,
+    borrow::Borrow,
+    cell::UnsafeCell,
+    fmt,
+    marker::PhantomData,
+    mem::ManuallyDrop,
+    ops::Deref,
+    ptr::{self, NonNull},
+};
 
 // so, PyObjectRef is basically equivalent to `PyRc<PyInner<dyn PyObjectPayload>>`, except it's
 // only one pointer in width rather than 2. We do that by manually creating a vtable, and putting
@@ -732,7 +736,8 @@ impl PyObject {
             let ret = crate::vm::thread::with_vm(self, |vm| {
                 self.0.ref_count.inc();
                 if let Err(e) = slot_del(self, vm) {
-                    print_del_error(e, self, vm);
+                    let del_method = self.get_class_attr("__del__").unwrap();
+                    vm.run_unraisable(e, None, del_method);
                 }
                 self.0.ref_count.dec()
             });
@@ -804,26 +809,6 @@ impl Drop for PyObjectRef {
     }
 }
 
-#[cold]
-fn print_del_error(e: PyBaseExceptionRef, zelf: &PyObject, vm: &VirtualMachine) {
-    // exception in del will be ignored but printed
-    print!("Exception ignored in: ",);
-    let del_method = zelf.get_class_attr("__del__").unwrap();
-    let repr = &del_method.repr(vm);
-    match repr {
-        Ok(v) => println!("{v}"),
-        Err(_) => println!("{}", del_method.class().name()),
-    }
-    let tb_module = vm.import("traceback", None, 0).unwrap();
-    // TODO: set exc traceback
-    let print_stack = tb_module.get_attr("print_stack", vm).unwrap();
-    vm.invoke(&print_stack, ()).unwrap();
-
-    if let Ok(repr) = e.as_object().repr(vm) {
-        println!("{}", repr.as_str());
-    }
-}
-
 impl fmt::Debug for PyObjectRef {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // SAFETY: the vtable contains functions that accept payload types that always match up

vm/src/stdlib/atexit.rs

@@ -33,24 +33,17 @@ mod atexit {
     }
 
     #[pyfunction]
-    pub fn _run_exitfuncs(vm: &VirtualMachine) -> PyResult<()> {
-        let mut last_exc = None;
-        for (func, args) in vm.state.atexit_funcs.lock().drain(..).rev() {
+    pub fn _run_exitfuncs(vm: &VirtualMachine) {
+        let funcs: Vec<_> = std::mem::take(&mut *vm.state.atexit_funcs.lock());
+        for (func, args) in funcs.into_iter().rev() {
             if let Err(e) = vm.invoke(&func, args) {
-                last_exc = Some(e.clone());
-                if !e.fast_isinstance(&vm.ctx.exceptions.system_exit) {
-                    writeln!(
-                        crate::stdlib::sys::PyStderr(vm),
-                        "Error in atexit._run_exitfuncs:"
-                    );
-                    vm.print_exception(e);
+                let exit = e.fast_isinstance(&vm.ctx.exceptions.system_exit);
+                vm.run_unraisable(e, Some("Error in atexit._run_exitfuncs".to_owned()), func);
+                if exit {
+                    break;
                 }
             }
         }
-        match last_exc {
-            None => Ok(()),
-            Some(e) => Err(e),
-        }
     }
 
     #[pyfunction]

vm/src/stdlib/sys.rs

@@ -1,6 +1,6 @@
 use crate::{convert::ToPyObject, PyObject, PyResult, VirtualMachine};
 
-pub(crate) use sys::{MAXSIZE, MULTIARCH};
+pub(crate) use sys::{UnraisableHookArgs, MAXSIZE, MULTIARCH};
 
 #[pymodule]
 mod sys {
@@ -16,7 +16,7 @@ mod sys {
         types::PyStructSequence,
         version,
         vm::{Settings, VirtualMachine},
-        PyObjectRef, PyRef, PyRefExact, PyResult,
+        AsObject, PyObjectRef, PyRef, PyRefExact, PyResult,
     };
     use num_traits::ToPrimitive;
     use std::{env, mem, path};
@@ -448,6 +448,66 @@ mod sys {
         .into_struct_sequence(vm))
     }
 
+    fn _unraisablehook(unraisable: UnraisableHookArgs, vm: &VirtualMachine) -> PyResult<()> {
+        use super::PyStderr;
+
+        let stderr = PyStderr(vm);
+        if !vm.is_none(&unraisable.object) {
+            if !vm.is_none(&unraisable.err_msg) {
+                write!(stderr, "{}: ", unraisable.err_msg.str(vm)?);
+            } else {
+                write!(stderr, "Exception ignored in: ");
+            }
+            // exception in del will be ignored but printed
+            let repr = &unraisable.object.repr(vm);
+            let str = match repr {
+                Ok(v) => v.to_string(),
+                Err(_) => format!(
+                    "<object {} repr() failed>",
+                    unraisable.object.class().name()
+                ),
+            };
+            writeln!(stderr, "{str}");
+        } else if !vm.is_none(&unraisable.err_msg) {
+            writeln!(stderr, "{}:", unraisable.err_msg.str(vm)?);
+        }
+
+        // TODO: print received unraisable.exc_traceback
+        let tb_module = vm.import("traceback", None, 0)?;
+        let print_stack = tb_module.get_attr("print_stack", vm)?;
+        vm.invoke(&print_stack, ())?;
+
+        if vm.is_none(unraisable.exc_type.as_object()) {
+            // TODO: early return, but with what error?
+        }
+        assert!(unraisable
+            .exc_type
+            .fast_issubclass(&vm.ctx.exceptions.exception_type));
+
+        // TODO: print module name and qualname
+
+        if !vm.is_none(&unraisable.exc_value) {
+            write!(stderr, ": ");
+            if let Ok(str) = unraisable.exc_value.str(vm) {
+                write!(stderr, "{}", str.as_str());
+            } else {
+                write!(stderr, "<exception str() failed>");
+            }
+        }
+        writeln!(stderr);
+        // TODO: call file.flush()
+
+        Ok(())
+    }
+
+    #[pyfunction(name = "__unraisablehook__")]
+    #[pyfunction]
+    fn unraisablehook(unraisable: UnraisableHookArgs, vm: &VirtualMachine) {
+        if let Err(e) = _unraisablehook(unraisable, vm) {
+            println!("{}", e.as_object().repr(vm).unwrap().as_str());
+        }
+    }
+
     #[pyattr]
     fn hash_info(vm: &VirtualMachine) -> PyTupleRef {
         PyHashInfo::INFO.into_struct_sequence(vm)
@@ -672,6 +732,19 @@ mod sys {
     #[cfg(windows)]
     #[pyimpl(with(PyStructSequence))]
     impl WindowsVersion {}
+
+    #[pyclass(noattr, module = "sys", name = "UnraisableHookArgs")]
+    #[derive(Debug, PyStructSequence, TryIntoPyStructSequence)]
+    pub struct UnraisableHookArgs {
+        pub exc_type: PyTypeRef,
+        pub exc_value: PyObjectRef,
+        pub exc_traceback: PyObjectRef,
+        pub err_msg: PyObjectRef,
+        pub object: PyObjectRef,
+    }
+
+    #[pyimpl(with(PyStructSequence))]
+    impl UnraisableHookArgs {}
 }
 
 pub(crate) fn init_module(vm: &VirtualMachine, module: &PyObject, builtins: &PyObject) {

vm/src/stdlib/thread.rs

@@ -8,7 +8,6 @@ pub(crate) mod _thread {
         builtins::{PyDictRef, PyStrRef, PyTupleRef, PyTypeRef},
         convert::ToPyException,
         function::{ArgCallable, FuncArgs, KwArgs, OptionalArg},
-        py_io,
         types::{Constructor, GetAttr, SetAttr},
         utils::Either,
         AsObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
@@ -17,7 +16,7 @@ pub(crate) mod _thread {
         lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
         RawMutex, RawThreadId,
     };
-    use std::{cell::RefCell, fmt, io::Write, thread, time::Duration};
+    use std::{cell::RefCell, fmt, thread, time::Duration};
     use thread_local::ThreadLocal;
 
     // TIMEOUT_MAX_IN_MICROSECONDS is a value in microseconds
@@ -255,16 +254,11 @@ pub(crate) mod _thread {
             Ok(_obj) => {}
             Err(e) if e.fast_isinstance(&vm.ctx.exceptions.system_exit) => {}
             Err(exc) => {
-                // TODO: sys.unraisablehook
-                let stderr = std::io::stderr();
-                let mut stderr = py_io::IoWriter(stderr.lock());
-                let repr = func.as_ref().repr(vm).ok();
-                let repr = repr
-                    .as_ref()
-                    .map_or("<object repr() failed>", |s| s.as_str());
-                writeln!(*stderr, "Exception ignored in thread started by: {}", repr)
-                    .and_then(|()| vm.write_exception(&mut stderr, &exc))
-                    .ok();
+                vm.run_unraisable(
+                    exc,
+                    Some("Exception ignored in thread started by".to_owned()),
+                    func.into(),
+                );
             }
         }
         SENTINELS.with(|sents| {

vm/src/vm/mod.rs

@@ -282,6 +282,28 @@ impl VirtualMachine {
         self.run_frame_full(frame)
     }
 
+    #[cold]
+    pub fn run_unraisable(&self, e: PyBaseExceptionRef, msg: Option<String>, object: PyObjectRef) {
+        use crate::stdlib::sys::UnraisableHookArgs;
+
+        let sys_module = self.import("sys", None, 0).unwrap();
+        let unraisablehook = sys_module.get_attr("unraisablehook", self).unwrap();
+
+        let exc_type = e.class().clone();
+        let exc_traceback = e.traceback().to_pyobject(self); // TODO: actual traceback
+        let exc_value = e.into();
+        let args = UnraisableHookArgs {
+            exc_type,
+            exc_value,
+            exc_traceback,
+            err_msg: self.new_pyobj(msg),
+            object,
+        };
+        if let Err(e) = self.invoke(&unraisablehook, (args,)) {
+            println!("{}", e.as_object().repr(self).unwrap().as_str());
+        }
+    }
+
     #[inline(always)]
     pub fn run_frame_full(&self, frame: FrameRef) -> PyResult {
         match self.run_frame(frame)? {