Simplify LockFreeLinkedList

Author: dkhalanskyjb

kotlinx-coroutines-core/concurrent/src/internal/LockFreeLinkedList.kt

@@ -94,7 +94,7 @@ public actual open class LockFreeLinkedListNode {
     // prev.next correction, which does not provide linearizable backwards iteration, but can be used to
     // resume forward iteration when current node was removed.
     public actual val prevNode: Node
-        get() = correctPrev(null) ?: findPrevNonRemoved(_prev.value)
+        get() = correctPrev() ?: findPrevNonRemoved(_prev.value)
 
     private tailrec fun findPrevNonRemoved(current: Node): Node {
         if (!current.isRemoved) return current
@@ -210,7 +210,7 @@ public actual open class LockFreeLinkedListNode {
             val removed = (next as Node).removed()
             if (_next.compareAndSet(next, removed)) {
                 // was removed successfully (linearized remove) -- fixup the list
-                next.correctPrev(null)
+                next.correctPrev()
                 return null
             }
         }
@@ -250,7 +250,7 @@ public actual open class LockFreeLinkedListNode {
             if (next._prev.compareAndSet(nextPrev, this)) {
                 // This newly added node could have been removed, and the above CAS would have added it physically again.
                 // Let us double-check for this situation and correct if needed
-                if (isRemoved) next.correctPrev(null)
+                if (isRemoved) next.correctPrev()
                 return
             }
         }
@@ -268,7 +268,7 @@ public actual open class LockFreeLinkedListNode {
      *   remover of this node will ultimately call [correctPrev] on the next node and that will fix all
      *   the links from this node, too.
      */
-    private tailrec fun correctPrev(op: OpDescriptor?): Node? {
+    private tailrec fun correctPrev(): Node? {
         val oldPrev = _prev.value
         var prev: Node = oldPrev
         var last: Node? = null // will be set so that last.next === prev
@@ -281,22 +281,21 @@ public actual open class LockFreeLinkedListNode {
                     // otherwise need to update prev
                     if (!this._prev.compareAndSet(oldPrev, prev)) {
                         // Note: retry from scratch on failure to update prev
-                        return correctPrev(op)
+                        return correctPrev()
                     }
                     return prev // return the correct prev
                 }
                 // slow path when we need to help remove operations
                 this.isRemoved -> return null // nothing to do, this node was removed, bail out asap to save time
-                prevNext === op -> return prev // part of the same op -- don't recurse, didn't correct prev
                 prevNext is OpDescriptor -> { // help & retry
                     prevNext.perform(prev)
-                    return correctPrev(op) // retry from scratch
+                    return correctPrev() // retry from scratch
                 }
                 prevNext is Removed -> {
                     if (last !== null) {
                         // newly added (prev) node is already removed, correct last.next around it
                         if (!last._next.compareAndSet(prev, prevNext.ref)) {
-                            return correctPrev(op) // retry from scratch on failure to update next
+                            return correctPrev() // retry from scratch on failure to update next
                         }
                         prev = last
                         last = null