Function default_dealloc

crates/vm/src/object/core.rs:158–221

Default dealloc: handles __del__, weakref clearing, tp_clear, and memory free. Equivalent to subtype_dealloc.

(obj: *mut PyObject)

/// Default dealloc: handles __del__, weakref clearing, tp_clear, and memory free.
/// Equivalent to subtype_dealloc.
pub(super) unsafe fn default_dealloc<T: PyPayload>(obj: *mut PyObject) {
    let obj_ref = unsafe { &*(obj as *const PyObject) };
    if let Err(()) = obj_ref.drop_slow_inner() {
        return; // resurrected by __del__
    }

    // Trashcan: limit recursive deallocation depth to prevent stack overflow
    if !unsafe { trashcan::begin(obj, default_dealloc::<T>) } {
        return; // deferred to queue
    }

    let vtable = obj_ref.0.vtable;

    // Untrack from GC BEFORE deallocation.
    // Must happen before memory is freed because intrusive list removal
    // reads the object's gc_pointers (prev/next).
    if obj_ref.is_gc_tracked() {
        let ptr = unsafe { NonNull::new_unchecked(obj) };
        unsafe {
            crate::gc_state::gc_state().untrack_object(ptr);
        }
        // Verify untrack cleared the tracked flag and generation
        debug_assert!(
            !obj_ref.is_gc_tracked(),
            "object still tracked after untrack_object"
        );
        debug_assert_eq!(
            obj_ref.gc_generation(),
            crate::object::GC_UNTRACKED,
            "gc_generation not reset after untrack_object"
        );
    }

    // Try to store in freelist for reuse BEFORE tp_clear, so that
    // size-based freelists (e.g. PyTuple) can read the payload directly.
    // Only exact base types (not heaptype or structseq subtypes) go into the freelist.
    let typ = obj_ref.class();
    let pushed = if T::HAS_FREELIST
        && typ.heaptype_ext.is_none()
        && core::ptr::eq(typ, T::class(crate::vm::Context::genesis()))
    {
        unsafe { T::freelist_push(obj) }
    } else {
        false
    };

    // Extract child references to break circular refs (tp_clear).
    // This runs regardless of freelist push — the object's children must be released.
    let mut edges = Vec::new();
    if let Some(clear_fn) = vtable.clear {
        unsafe { clear_fn(obj, &mut edges) };
    }

    if !pushed {
        // Deallocate the object memory (handles ObjExt prefix if present)
        unsafe { PyInner::dealloc(obj as *mut PyInner<T>) };
    }