RustPython
diff --git a/crates/common/src/linked_list.rs b/crates/common/src/linked_list.rs
@@ -157,6 +157,15 @@ impl<L: Link> LinkedList<L, L::Target> {
         let ptr = L::as_raw(&val);
         assert_ne!(self.head, Some(ptr));
         unsafe {
+            // Verify the node is not already in a list (pointers must be clean)
+            debug_assert!(
+                L::pointers(ptr).as_ref().get_prev().is_none(),
+                "push_front: node already has prev pointer (double-insert?)"
+            );
+            debug_assert!(
+                L::pointers(ptr).as_ref().get_next().is_none(),
+                "push_front: node already has next pointer (double-insert?)"
+            );
             L::pointers(ptr).as_mut().set_next(self.head);
             L::pointers(ptr).as_mut().set_prev(None);
 
@@ -192,6 +201,20 @@ impl<L: Link> LinkedList<L, L::Target> {
     //     }
     // }
 
+    /// Removes the first element from the list and returns it, or None if empty.
+    pub fn pop_front(&mut self) -> Option<L::Handle> {
+        let head = self.head?;
+        unsafe {
+            self.head = L::pointers(head).as_ref().get_next();
+            if let Some(new_head) = self.head {
+                L::pointers(new_head).as_mut().set_prev(None);
+            }
+            L::pointers(head).as_mut().set_next(None);
+            L::pointers(head).as_mut().set_prev(None);
+            Some(L::from_raw(head))
+        }
+    }
+
     /// Returns whether the linked list does not contain any node
     pub const fn is_empty(&self) -> bool {
         self.head.is_none()
@@ -212,7 +235,11 @@ impl<L: Link> LinkedList<L, L::Target> {
     pub unsafe fn remove(&mut self, node: NonNull<L::Target>) -> Option<L::Handle> {
         unsafe {
             if let Some(prev) = L::pointers(node).as_ref().get_prev() {
-                debug_assert_eq!(L::pointers(prev).as_ref().get_next(), Some(node));
+                debug_assert_eq!(
+                    L::pointers(prev).as_ref().get_next(),
+                    Some(node),
+                    "linked list corruption: prev->next != node (prev={prev:p}, node={node:p})"
+                );
                 L::pointers(prev)
                     .as_mut()
                     .set_next(L::pointers(node).as_ref().get_next());
@@ -225,7 +252,11 @@ impl<L: Link> LinkedList<L, L::Target> {
             }
 
             if let Some(next) = L::pointers(node).as_ref().get_next() {
-                debug_assert_eq!(L::pointers(next).as_ref().get_prev(), Some(node));
+                debug_assert_eq!(
+                    L::pointers(next).as_ref().get_prev(),
+                    Some(node),
+                    "linked list corruption: next->prev != node (next={next:p}, node={node:p})"
+                );
                 L::pointers(next)
                     .as_mut()
                     .set_prev(L::pointers(node).as_ref().get_prev());