gh-95348: Split clear_weakref into two functions

Objects/weakrefobject.c

@@ -46,38 +46,56 @@ new_weakref(PyObject *ob, PyObject *callback)
 }
 
 
-/* This function clears the passed-in reference and removes it from the
- * list of weak references for the referent.  This is the only code that
- * removes an item from the doubly-linked list of weak references for an
- * object; it is also responsible for clearing the callback slot.
+/* This function clears the passed-in reference. It must have been
+ * from the weaklist already. (See weaklist_remove_weakref().)
  */
 static void
 clear_weakref(PyWeakReference *self)
 {
     PyObject *callback = self->wr_callback;
 
-    if (self->wr_object != Py_None) {
-        PyWeakReference **list = GET_WEAKREFS_LISTPTR(self->wr_object);
+    self->wr_object = Py_None;
 
-        if (*list == self)
-            /* If 'self' is the end of the list (and thus self->wr_next == NULL)
-               then the weakref list itself (and thus the value of *list) will
-               end up being set to NULL. */
-            *list = self->wr_next;
-        self->wr_object = Py_None;
-        if (self->wr_prev != NULL)
-            self->wr_prev->wr_next = self->wr_next;
-        if (self->wr_next != NULL)
-            self->wr_next->wr_prev = self->wr_prev;
-        self->wr_prev = NULL;
-        self->wr_next = NULL;
-    }
     if (callback != NULL) {
         Py_DECREF(callback);
         self->wr_callback = NULL;
     }
 }
 
+/* This function removes the passed-in reference from the list of weak
+ * references for the referent.
+ */
+static void
+weaklist_remove_weakref(PyWeakReference **list, PyWeakReference *ref)
+{
+    if (*list == ref) {
+        /* If 'ref' is the end of the list (and thus ref->wr_next == NULL)
+            then the weakref list itself (and thus the value of *list) will
+            end up being set to NULL. */
+        *list = ref->wr_next;
+    }
+    if (ref->wr_prev != NULL) {
+        ref->wr_prev->wr_next = ref->wr_next;
+    }
+    if (ref->wr_next != NULL) {
+        ref->wr_next->wr_prev = ref->wr_prev;
+    }
+    ref->wr_prev = NULL;
+    ref->wr_next = NULL;
+}
+
+/* This function removes the pass in reference from the list of weak references 
+ * for the referent.
+ */
+static void
+remove_weakref_from_referent(PyWeakReference *self)
+{
+    if (self->wr_object != Py_None) {
+        PyWeakReference **list = GET_WEAKREFS_LISTPTR(self->wr_object);
+        weaklist_remove_weakref(list, self);
+    }
+}
+
 /* Cyclic gc uses this to *just* clear the passed-in reference, leaving
  * the callback intact and uncalled.  It must be possible to call self's
  * tp_dealloc() after calling this, so self has to be left in a sane enough
@@ -99,6 +117,7 @@ _PyWeakref_ClearRef(PyWeakReference *self)
     /* Preserve and restore the callback around clear_weakref. */
     callback = self->wr_callback;
     self->wr_callback = NULL;
+    remove_weakref_from_referent(self);
     clear_weakref(self);
     self->wr_callback = callback;
 }
@@ -107,6 +126,7 @@ static void
 weakref_dealloc(PyObject *self)
 {
     PyObject_GC_UnTrack(self);
+    remove_weakref_from_referent((PyWeakReference *) self);
     clear_weakref((PyWeakReference *) self);
     Py_TYPE(self)->tp_free(self);
 }
@@ -123,6 +143,7 @@ gc_traverse(PyWeakReference *self, visitproc visit, void *arg)
 static int
 gc_clear(PyWeakReference *self)
 {
+    remove_weakref_from_referent(self);
     clear_weakref(self);
     return 0;
 }
@@ -562,6 +583,7 @@ proxy_dealloc(PyWeakReference *self)
     if (self->wr_callback != NULL)
         PyObject_GC_UnTrack((PyObject *)self);
     clear_weakref(self);
+    remove_weakref_from_referent(self);
     PyObject_GC_Del(self);
 }
 
@@ -958,8 +980,11 @@ PyObject_ClearWeakRefs(PyObject *object)
     /* Remove the callback-less basic and proxy references */
     if (*list != NULL && (*list)->wr_callback == NULL) {
         clear_weakref(*list);
-        if (*list != NULL && (*list)->wr_callback == NULL)
+        weaklist_remove_weakref(list, *list);
+        if (*list != NULL && (*list)->wr_callback == NULL) {
             clear_weakref(*list);
+            weaklist_remove_weakref(list, *list);
+        }
     }
     if (*list != NULL) {
         PyWeakReference *current = *list;
@@ -972,6 +997,7 @@ PyObject_ClearWeakRefs(PyObject *object)
 
             current->wr_callback = NULL;
             clear_weakref(current);
+            weaklist_remove_weakref(list, current);
             if (callback != NULL) {
                 if (Py_REFCNT((PyObject *)current) > 0) {
                     handle_callback(current, callback);
@@ -1002,6 +1028,7 @@ PyObject_ClearWeakRefs(PyObject *object)
                 }
                 current->wr_callback = NULL;
                 clear_weakref(current);
+                weaklist_remove_weakref(list, current);
                 current = next;
             }
             for (i = 0; i < count; ++i) {
@@ -1036,5 +1063,7 @@ _PyStaticType_ClearWeakRefs(PyTypeObject *type)
            weaklist before clearing its wr_object and wr_callback.
            That is how we're able to loop over the list. */
         clear_weakref((PyWeakReference *)*list);
+        weaklist_remove_weakref((PyWeakReference **)list,
+                                (PyWeakReference *)list);
     }
 }