fix

youknowone · youknowone · commit 0ba3a5545f78 · 2026-02-22T15:41:43.000+09:00
diff --git a/crates/common/src/refcount.rs b/crates/common/src/refcount.rs
@@ -119,12 +119,16 @@ impl RefCount {
 
     /// Returns true if successful
     #[inline]
+    #[must_use]
     pub fn safe_inc(&self) -> bool {
         let mut old = State::from_raw(self.state.load(Ordering::SeqCst));
         loop {
             if old.destructed() {
                 return false;
             }
+            if (old.strong() as usize) >= STRONG {
+                refcount_overflow();
+            }
             let new_state = old.add_strong(1);
             match self.state.compare_exchange(
                 old.as_raw(),
@@ -140,13 +144,12 @@ impl RefCount {
 
     /// Decrement strong count. Returns true when count drops to 0.
     #[inline]
+    #[must_use]
     pub fn dec(&self) -> bool {
         let old = State::from_raw(self.state.fetch_sub(COUNT, Ordering::SeqCst));
 
-        // LEAKED objects never reach 0.
-        // Undo the subtraction to prevent underflow from corrupting flag bits.
+        // LEAKED objects never reach 0
         if old.leaked() {
-            self.state.fetch_add(COUNT, Ordering::SeqCst);
             return false;
         }
 
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
@@ -1166,7 +1166,7 @@ impl PyObject {
                 // Undo the temporary resurrection. Always remove both
                 // temporary refs; the second dec returns true only when
                 // ref_count drops to 0 (no resurrection).
-                zelf.0.ref_count.dec();
+                let _ = zelf.0.ref_count.dec();
                 zelf.0.ref_count.dec()
             });
             match ret {
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
@@ -387,12 +387,12 @@ impl Interpreter {
     /// Finalization steps (matching Py_FinalizeEx):
     /// 1. Flush stdout and stderr.
     /// 1. Handle exit exception and turn it to exit code.
-    /// 1. Wait for thread shutdown (call threading._shutdown).
-    /// 1. Set finalizing flag (suppresses unraisable exceptions).
     /// 1. Call threading._shutdown() to join non-daemon threads.
     /// 1. Run atexit exit functions.
-    /// 1. GC pass and module cleanup (finalize_modules).
-    /// 1. Final GC pass.
+    /// 1. Set finalizing flag (suppresses unraisable exceptions from __del__).
+    /// 1. Forced GC collection pass (collect cycles while builtins are available).
+    /// 1. Module finalization (finalize_modules).
+    /// 1. Final stdout/stderr flush.
     ///
     /// Note that calling `finalize` is not necessary by purpose though.
     pub fn finalize(self, exc: Option<PyBaseExceptionRef>) -> u32 {
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
@@ -821,7 +821,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Phase 4: Clear module dicts in reverse import order.
+    /// Phase 5: Clear module dicts in reverse import order.
     /// Skip builtins and sys — those are cleared last in Phase 7.
     fn finalize_clear_module_dicts(&self, module_weakrefs: &[(String, PyRef<PyWeak>)]) {
         let builtins_dict = self.builtins.dict();
@@ -1119,18 +1119,6 @@ impl VirtualMachine {
             core::sync::atomic::Ordering::AcqRel,
         );
 
-        use crate::protocol::TraceEvent;
-        let result = match self.trace_event(TraceEvent::Call, None) {
-            Ok(()) => {
-                let result = f(frame);
-                if result.is_ok() {
-                    let _ = self.trace_event(TraceEvent::Return, None);
-                }
-                result
-            }
-            Err(e) => Err(e),
-        };
-
         // Ensure cleanup on panic: restore owner, pop exception, frame chain, frames Vec,
         // and recursion depth.
         scopeguard::defer! {
@@ -1146,7 +1134,17 @@ impl VirtualMachine {
             self.recursion_depth.update(|d| d - 1);
         }
 
-        result
+        use crate::protocol::TraceEvent;
+        match self.trace_event(TraceEvent::Call, None) {
+            Ok(()) => {
+                let result = f(frame);
+                if result.is_ok() {
+                    let _ = self.trace_event(TraceEvent::Return, None);
+                }
+                result
+            }
+            Err(e) => Err(e),
+        }
     }
 
     /// Returns a basic CompileOpts instance with options accurate to the vm. Used
