fix shutdown

youknowone · youknowone · commit 0b8ce97f5ee7 · 2026-01-17T23:41:09.000+09:00
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
@@ -135,8 +135,13 @@ impl Interpreter {
             // threading module may not be imported, so ignore import errors.
             if let Ok(threading) = vm.import("threading", 0)
                 && let Ok(shutdown) = threading.get_attr("_shutdown", vm)
+                && let Err(e) = shutdown.call((), vm)
             {
-                let _ = shutdown.call((), vm);
+                vm.run_unraisable(
+                    e,
+                    Some("Exception ignored in threading shutdown".to_owned()),
+                    threading,
+                );
             }
 
             // Mark as finalizing AFTER thread shutdown
@@ -152,35 +157,6 @@ impl Interpreter {
     }
 }
 
-/// Wait until threading._shutdown completes, provided
-/// the threading module was imported in the first place.
-/// The shutdown routine will wait until all non-daemon
-/// "threading" threads have completed.
-fn wait_for_thread_shutdown(vm: &VirtualMachine) {
-    // Try to get the threading module if it was already imported
-    // Use sys.modules.get("threading") like PyImport_GetModule
-    let threading = match (|| -> PyResult<_> {
-        let sys_modules = vm.sys_module.get_attr("modules", vm)?;
-        let threading = sys_modules.get_item("threading", vm)?;
-        Ok(threading)
-    })() {
-        Ok(module) => module,
-        Err(_) => {
-            // threading not imported, nothing to do
-            return;
-        }
-    };
-
-    // Call threading._shutdown()
-    if let Err(e) = vm.call_method(&threading, "_shutdown", ()) {
-        vm.run_unraisable(
-            e,
-            Some("Exception ignored on threading shutdown".to_owned()),
-            threading,
-        );
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
@@ -550,14 +550,15 @@ impl VirtualMachine {
 
     #[cold]
     pub fn run_unraisable(&self, e: PyBaseExceptionRef, msg: Option<String>, object: PyObjectRef) {
-        // Suppress unraisable exceptions during interpreter finalization.
-        // when daemon thread exceptions and
-        // __del__ errors are silently ignored during shutdown.
+        // During interpreter finalization, sys.unraisablehook may not be available,
+        // but we still need to report exceptions (especially from atexit callbacks).
+        // Write directly to stderr like PyErr_FormatUnraisable.
         if self
             .state
             .finalizing
             .load(std::sync::atomic::Ordering::Acquire)
         {
+            self.write_unraisable_to_stderr(&e, msg.as_deref(), &object);
             return;
         }
 
@@ -579,6 +580,57 @@ impl VirtualMachine {
         }
     }
 
+    /// Write unraisable exception to stderr during finalization.
+    /// Similar to _PyErr_WriteUnraisableDefaultHook in CPython.
+    fn write_unraisable_to_stderr(
+        &self,
+        e: &PyBaseExceptionRef,
+        msg: Option<&str>,
+        object: &PyObjectRef,
+    ) {
+        // Get stderr once and reuse it
+        let stderr = crate::stdlib::sys::get_stderr(self).ok();
+
+        let write_to_stderr = |s: &str, stderr: &Option<PyObjectRef>, vm: &VirtualMachine| {
+            if let Some(stderr) = stderr {
+                let _ = vm.call_method(stderr, "write", (s.to_owned(),));
+            } else {
+                eprint!("{}", s);
+            }
+        };
+
+        // Format: "Exception ignored {msg} {object_repr}\n"
+        if let Some(msg) = msg {
+            write_to_stderr(&format!("Exception ignored {}", msg), &stderr, self);
+        } else {
+            write_to_stderr("Exception ignored in: ", &stderr, self);
+        }
+
+        if let Ok(repr) = object.repr(self) {
+            write_to_stderr(&format!("{}\n", repr.as_str()), &stderr, self);
+        } else {
+            write_to_stderr("<object repr failed>\n", &stderr, self);
+        }
+
+        // Write exception type and message
+        let exc_type_name = e.class().name();
+        if let Ok(exc_str) = e.as_object().str(self) {
+            let exc_str = exc_str.as_str();
+            if exc_str.is_empty() {
+                write_to_stderr(&format!("{}\n", exc_type_name), &stderr, self);
+            } else {
+                write_to_stderr(&format!("{}: {}\n", exc_type_name, exc_str), &stderr, self);
+            }
+        } else {
+            write_to_stderr(&format!("{}\n", exc_type_name), &stderr, self);
+        }
+
+        // Flush stderr to ensure output is visible
+        if let Some(ref stderr) = stderr {
+            let _ = self.call_method(stderr, "flush", ());
+        }
+    }
+
     #[inline(always)]
     pub fn run_frame(&self, frame: FrameRef) -> PyResult {
         match self.with_frame(frame, |f| f.run(self))? {
