use core::cell::Cell;

/// Maximum nesting depth for deallocation before deferring.

/// CPython uses UNWIND_NO_NESTING = 50.

const TRASHCAN_LIMIT: usize = 50;

type DeallocFn = unsafe fn(*mut super::PyObject);

type DeallocQueue = Vec<(*mut super::PyObject, DeallocFn)>;

thread_local! {

static DEALLOC_DEPTH: Cell<usize> = const { Cell::new(0) };

static DEALLOC_QUEUE: Cell<DeallocQueue> = const { Cell::new(Vec::new()) };

}

/// Try to begin deallocation. Returns true if we should proceed,

/// false if the object was deferred (depth exceeded).

#[inline]

pub(super) unsafe fn begin(

obj: *mut super::PyObject,

dealloc: unsafe fn(*mut super::PyObject),

) -> bool {

DEALLOC_DEPTH.with(|d| {

let depth = d.get();

if depth >= TRASHCAN_LIMIT {

// Depth exceeded: defer this deallocation

DEALLOC_QUEUE.with(|q| {

let mut queue = q.take();

queue.push((obj, dealloc));

q.set(queue);

});

false

} else {

d.set(depth + 1);

true

}

})

}

/// End deallocation and process any deferred objects if at outermost level.

#[inline]

pub(super) unsafe fn end() {

let depth = DEALLOC_DEPTH.with(|d| {

let depth = d.get();

debug_assert!(depth > 0, "trashcan::end called without matching begin");

let depth = depth - 1;

d.set(depth);

depth

});

if depth == 0 {

// Process deferred deallocations iteratively

loop {

let next = DEALLOC_QUEUE.with(|q| {

let mut queue = q.take();

let item = queue.pop();

q.set(queue);

item

});

if let Some((obj, dealloc)) = next {

unsafe { dealloc(obj) };

} else {

break;

}

}

}

}

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>) };

}

// Drop child references - may trigger recursive destruction.

drop(edges);

// Trashcan: decrement depth and process deferred objects at outermost level

unsafe { trashcan::end() };

x: &PyObject,

f: &mut fmt::Formatter<'_>,

) -> fmt::Result {

let x = unsafe { &*(x as *const PyObject as *const PyInner<T>) };

fmt::Debug::fmt(x, f)

let x = unsafe { &*(x as *const PyObject as *const PyInner<T>) };

let payload = &x.payload;

payload.try_traverse(tracer_fn)

type Handle = NonNull<PyObject>;

type Target = PyObject;

fn as_raw(handle: &NonNull<PyObject>) -> NonNull<PyObject> {

*handle

}

unsafe fn from_raw(ptr: NonNull<PyObject>) -> NonNull<PyObject> {

ptr

}

unsafe fn pointers(target: NonNull<PyObject>) -> NonNull<Pointers<PyObject>> {

let inner_ptr = target.as_ptr() as *mut PyInner<Erased>;

unsafe { NonNull::new_unchecked(&raw mut (*inner_ptr).gc_pointers) }

}

fn new(dict: Option<PyDictRef>, member_count: usize, has_dict: bool) -> Self {

Self {

dict: if has_dict {

Some(InstanceDict::from_opt(dict))

} else {

None

},

slots: core::iter::repeat_with(|| PyRwLock::new(None))

.take(member_count)

.collect_vec()

.into_boxed_slice(),

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "[ObjExt]")

}

pub(super) ref_count: RefCount,

pub(super) vtable: &'static PyObjVTable,

/// GC bits for free-threading (like ob_gc_bits)

pub(super) gc_bits: PyAtomic<u8>,

/// GC generation index (0-2=gen, GC_PERMANENT=permanent, GC_UNTRACKED=not tracked).

/// Uses PyAtomic for interior mutability (writes happen through &self under list locks).

pub(super) gc_generation: PyAtomic<u8>,

/// Intrusive linked list pointers for GC generational tracking

pub(super) gc_pointers: Pointers<PyObject>,

pub(super) typ: PyAtomicRef<PyType>, // __class__ member

pub(super) payload: T,

/// Read type flags and member_count via raw pointers to avoid Stacked Borrows

/// violations during bootstrap, where type objects have self-referential typ pointers.

#[inline(always)]

fn read_type_flags(&self) -> (crate::types::PyTypeFlags, usize) {

let typ_ptr = self.typ.load_raw();

let slots = unsafe { core::ptr::addr_of!((*typ_ptr).0.payload.slots) };

let flags = unsafe { core::ptr::addr_of!((*slots).flags).read() };

let member_count = unsafe { core::ptr::addr_of!((*slots).member_count).read() };

(flags, member_count)

}

/// Access the ObjExt prefix at a negative offset from this PyInner.

/// Returns None if this object was allocated without dict/slots.

///

/// Layout: [ObjExt?][WeakRefList?][PyInner]

/// ObjExt offset depends on whether WeakRefList is also present.

#[inline(always)]

pub(super) fn ext_ref(&self) -> Option<&ObjExt> {

let (flags, member_count) = self.read_type_flags();

let has_ext = flags.has_feature(crate::types::PyTypeFlags::HAS_DICT) || member_count > 0;

if !has_ext {

return None;

}

let has_weakref = flags.has_feature(crate::types::PyTypeFlags::HAS_WEAKREF);

let offset = if has_weakref {

WEAKREF_OFFSET + EXT_OFFSET

} else {

EXT_OFFSET

};

let self_addr = (self as *const Self as *const u8).addr();

let ext_ptr = core::ptr::with_exposed_provenance::<ObjExt>(self_addr.wrapping_sub(offset));

Some(unsafe { &*ext_ptr })

}

/// Access the WeakRefList prefix at a fixed negative offset from this PyInner.

/// Returns None if the type does not support weakrefs.

///

/// Layout: [ObjExt?][WeakRefList?][PyInner]

/// WeakRefList is always immediately before PyInner (fixed WEAKREF_OFFSET).

#[inline(always)]

pub(super) fn weakref_list_ref(&self) -> Option<&WeakRefList> {

let (flags, _) = self.read_type_flags();

if !flags.has_feature(crate::types::PyTypeFlags::HAS_WEAKREF) {

return None;

}

let self_addr = (self as *const Self as *const u8).addr();

let ptr = core::ptr::with_exposed_provenance::<WeakRefList>(

self_addr.wrapping_sub(WEAKREF_OFFSET),

);

Some(unsafe { &*ptr })

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "[PyObject {:?}]", &self.payload)

}

/// DO notice that call `trace` on `Py<T>` means apply `tracer_fn` on `Py<T>`'s children,

/// not like call `trace` on `PyRef<T>` which apply `tracer_fn` on `PyRef<T>` itself

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {

self.0.traverse(tracer_fn)

}

/// DO notice that call `trace` on `PyObject` means apply `tracer_fn` on `PyObject`'s children,

/// not like call `trace` on `PyObjectRef` which apply `tracer_fn` on `PyObjectRef` itself

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {

self.0.traverse(tracer_fn)

}

use core::sync::atomic::{AtomicU8, Ordering};

const NUM_WEAKREF_LOCKS: usize = 64;

static LOCKS: [AtomicU8; NUM_WEAKREF_LOCKS] = [const { AtomicU8::new(0) }; NUM_WEAKREF_LOCKS];

pub(super) struct WeakrefLockGuard {

idx: usize,

}

impl Drop for WeakrefLockGuard {

fn drop(&mut self) {

LOCKS[self.idx].store(0, Ordering::Release);

}

}

pub(super) fn lock(addr: usize) -> WeakrefLockGuard {

let idx = (addr >> 4) % NUM_WEAKREF_LOCKS;

loop {

if LOCKS[idx]

.compare_exchange_weak(0, 1, Ordering::Acquire, Ordering::Relaxed)

.is_ok()

{

return WeakrefLockGuard { idx };

}

core::hint::spin_loop();

}

}

/// Reset all weakref stripe locks after fork in child process.

/// Locks held by parent threads would cause infinite spin in the child.

#[cfg(all(unix, feature = "host_env"))]

pub(crate) fn reset_all_after_fork() {

for lock in &LOCKS {

lock.store(0, Ordering::Release);

}

}

pub(super) struct WeakrefLockGuard;

impl Drop for WeakrefLockGuard {

fn drop(&mut self) {}

}

pub(super) fn lock(_addr: usize) -> WeakrefLockGuard {

WeakrefLockGuard

}

/// Head of the intrusive doubly-linked list of weakrefs.

head: PyAtomic<*mut Py<PyWeak>>,

/// Cached generic weakref (no callback, exact weakref type).

/// Matches try_reuse_basic_ref in weakrefobject.c.

generic: PyAtomic<*mut Py<PyWeak>>,

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

f.debug_struct("WeakRefList").finish_non_exhaustive()

}

unsafe {

let mut ptrs = WeakLink::pointers(node);

let prev = ptrs.as_ref().get_prev();

let next = ptrs.as_ref().get_next();

if let Some(prev) = prev {

WeakLink::pointers(prev).as_mut().set_next(next);

} else {

// node is the head

wrl.head.store(

next.map_or(ptr::null_mut(), |p| p.as_ptr()),

Ordering::Relaxed,

);

}

if let Some(next) = next {

WeakLink::pointers(next).as_mut().set_prev(prev);

}

ptrs.as_mut().set_prev(None);

ptrs.as_mut().set_next(None);

}

pub(super) fn new() -> Self {

Self {

head: Radium::new(ptr::null_mut()),

generic: Radium::new(ptr::null_mut()),

}

}

/// get_or_create_weakref

fn add(

&self,

obj: &PyObject,

cls: PyTypeRef,

cls_is_weakref: bool,

callback: Option<PyObjectRef>,

dict: Option<PyDictRef>,

) -> PyRef<PyWeak> {

let is_generic = cls_is_weakref && callback.is_none();

// Try reuse under lock first (fast path, no allocation)

{

let _lock = weakref_lock::lock(obj as *const PyObject as usize);

if is_generic {

let generic_ptr = self.generic.load(Ordering::Relaxed);

if !generic_ptr.is_null() {

let generic = unsafe { &*generic_ptr };

if generic.0.ref_count.safe_inc() {

return unsafe { PyRef::from_raw(generic_ptr) };

}

}

}

}

// Allocate OUTSIDE the stripe lock. PyRef::new_ref may trigger

// maybe_collect → GC → WeakRefList::clear on another object that

// hashes to the same stripe, which would deadlock on the spinlock.

let weak_payload = PyWeak {

pointers: Pointers::new(),

wr_object: Radium::new(obj as *const PyObject as *mut PyObject),

callback: UnsafeCell::new(callback),

hash: Radium::new(crate::common::hash::SENTINEL),

};

let weak = PyRef::new_ref(weak_payload, cls, dict);

// Re-acquire lock for linked list insertion

let _lock = weakref_lock::lock(obj as *const PyObject as usize);

// Re-check: another thread may have inserted a generic ref while we

// were allocating outside the lock. If so, reuse it and drop ours.

if is_generic {

let generic_ptr = self.generic.load(Ordering::Relaxed);

if !generic_ptr.is_null() {

let generic = unsafe { &*generic_ptr };

if generic.0.ref_count.safe_inc() {

// Nullify wr_object so drop_inner won't unlink an

// un-inserted node (which would corrupt the list head).

weak.wr_object.store(ptr::null_mut(), Ordering::Relaxed);

return unsafe { PyRef::from_raw(generic_ptr) };

}

}

}

// Insert into linked list under stripe lock

let node_ptr = NonNull::from(&*weak);

unsafe {

let mut ptrs = WeakLink::pointers(node_ptr);

if is_generic {

// Generic ref goes to head (insert_head for basic ref)

let old_head = self.head.load(Ordering::Relaxed);

ptrs.as_mut().set_next(NonNull::new(old_head));

ptrs.as_mut().set_prev(None);

if let Some(old_head) = NonNull::new(old_head) {

WeakLink::pointers(old_head)

.as_mut()

.set_prev(Some(node_ptr));

}

self.head.store(node_ptr.as_ptr(), Ordering::Relaxed);

self.generic.store(node_ptr.as_ptr(), Ordering::Relaxed);

} else {

// Non-generic refs go after generic ref (insert_after)

let generic_ptr = self.generic.load(Ordering::Relaxed);

if let Some(after) = NonNull::new(generic_ptr) {

let after_next = WeakLink::pointers(after).as_ref().get_next();

ptrs.as_mut().set_prev(Some(after));

ptrs.as_mut().set_next(after_next);

WeakLink::pointers(after).as_mut().set_next(Some(node_ptr));

if let Some(next) = after_next {

WeakLink::pointers(next).as_mut().set_prev(Some(node_ptr));

}

} else {

// No generic ref; insert at head

let old_head = self.head.load(Ordering::Relaxed);

ptrs.as_mut().set_next(NonNull::new(old_head));

ptrs.as_mut().set_prev(None);

if let Some(old_head) = NonNull::new(old_head) {

WeakLink::pointers(old_head)

.as_mut()

.set_prev(Some(node_ptr));

}

self.head.store(node_ptr.as_ptr(), Ordering::Relaxed);

}

}

}

weak

}

/// Clear all weakrefs and call their callbacks.

/// Called when the owner object is being dropped.

// PyObject_ClearWeakRefs

fn clear(&self, obj: &PyObject) {

let obj_addr = obj as *const PyObject as usize;

let _lock = weakref_lock::lock(obj_addr);

// Clear generic cache

self.generic.store(ptr::null_mut(), Ordering::Relaxed);

// Walk the list, collecting weakrefs with callbacks

let mut callbacks: Vec<(PyRef<PyWeak>, PyObjectRef)> = Vec::new();

let mut current = NonNull::new(self.head.load(Ordering::Relaxed));

while let Some(node) = current {

let next = unsafe { WeakLink::pointers(node).as_ref().get_next() };

let wr = unsafe { node.as_ref() };

// Mark weakref as dead

wr.0.payload

.wr_object

.store(ptr::null_mut(), Ordering::Relaxed);

// Unlink from list

unsafe {

let mut ptrs = WeakLink::pointers(node);

ptrs.as_mut().set_prev(None);

ptrs.as_mut().set_next(None);

}

// Collect callback only if we can still acquire a strong ref.

if wr.0.ref_count.safe_inc() {

let wr_ref = unsafe { PyRef::from_raw(wr as *const Py<PyWeak>) };

let cb = unsafe { wr.0.payload.callback.get().replace(None) };

if let Some(cb) = cb {

callbacks.push((wr_ref, cb));

}

}

current = next;

}

self.head.store(ptr::null_mut(), Ordering::Relaxed);

// Invoke callbacks outside the lock

drop(_lock);

for (wr, cb) in callbacks {

crate::vm::thread::with_vm(&cb, |vm| {

let _ = cb.call((wr.clone(),), vm);

});

}

}

/// Clear all weakrefs but DON'T call callbacks. Instead, return them for later invocation.

/// Used by GC to ensure ALL weakrefs are cleared BEFORE any callbacks are invoked.

/// handle_weakrefs() clears all weakrefs first, then invokes callbacks.

fn clear_for_gc_collect_callbacks(&self, obj: &PyObject) -> Vec<(PyRef<PyWeak>, PyObjectRef)> {

let obj_addr = obj as *const PyObject as usize;

let _lock = weakref_lock::lock(obj_addr);

// Clear generic cache

self.generic.store(ptr::null_mut(), Ordering::Relaxed);

let mut callbacks = Vec::new();

let mut current = NonNull::new(self.head.load(Ordering::Relaxed));

while let Some(node) = current {

let next = unsafe { WeakLink::pointers(node).as_ref().get_next() };

let wr = unsafe { node.as_ref() };

// Mark weakref as dead

wr.0.payload

.wr_object

.store(ptr::null_mut(), Ordering::Relaxed);

// Unlink from list

unsafe {

let mut ptrs = WeakLink::pointers(node);

ptrs.as_mut().set_prev(None);

ptrs.as_mut().set_next(None);

}

// Collect callback without invoking only if we can keep weakref alive.

if wr.0.ref_count.safe_inc() {

let wr_ref = unsafe { PyRef::from_raw(wr as *const Py<PyWeak>) };

let cb = unsafe { wr.0.payload.callback.get().replace(None) };

if let Some(cb) = cb {

callbacks.push((wr_ref, cb));

}

}

current = next;

}

self.head.store(ptr::null_mut(), Ordering::Relaxed);

callbacks

}

fn count(&self, obj: &PyObject) -> usize {

let _lock = weakref_lock::lock(obj as *const PyObject as usize);

let mut count = 0usize;

let mut current = NonNull::new(self.head.load(Ordering::Relaxed));

while let Some(node) = current {

if unsafe { node.as_ref() }.0.ref_count.get() > 0 {

count += 1;

}

current = unsafe { WeakLink::pointers(node).as_ref().get_next() };

}

count

}

fn get_weak_references(&self, obj: &PyObject) -> Vec<PyRef<PyWeak>> {

let _lock = weakref_lock::lock(obj as *const PyObject as usize);

let mut v = Vec::new();

let mut current = NonNull::new(self.head.load(Ordering::Relaxed));

while let Some(node) = current {

let wr = unsafe { node.as_ref() };

if wr.0.ref_count.safe_inc() {

v.push(unsafe { PyRef::from_raw(wr as *const Py<PyWeak>) });

}

current = unsafe { WeakLink::pointers(node).as_ref().get_next() };

}

v

}

fn default() -> Self {

Self::new()

}

type Handle = PyRef<PyWeak>;

type Target = Py<PyWeak>;

#[inline(always)]

fn as_raw(handle: &PyRef<PyWeak>) -> NonNull<Self::Target> {

NonNull::from(&**handle)

}

#[inline(always)]

unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {

unsafe { PyRef::from_raw(ptr.as_ptr()) }

}

#[inline(always)]

unsafe fn pointers(target: NonNull<Self::Target>) -> NonNull<Pointers<Self::Target>> {

// SAFETY: requirements forwarded from caller

unsafe { NonNull::new_unchecked(&raw mut (*target.as_ptr()).0.payload.pointers) }

}

pointers: Pointers<Py<Self>>,

/// Direct pointer to the referent object, null when dead.

/// Equivalent to wr_object in PyWeakReference.

wr_object: PyAtomic<*mut PyObject>,

/// Protected by stripe lock (keyed on wr_object address).

callback: UnsafeCell<Option<PyObjectRef>>,

pub(crate) hash: PyAtomic<crate::common::hash::PyHash>,