Introduce the concept of closing a list

Author: dkhalanskyjb

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

@@ -13,10 +13,11 @@ public expect open class LockFreeLinkedListNode() {
     public val isRemoved: Boolean
     public val nextNode: LockFreeLinkedListNode
     public val prevNode: LockFreeLinkedListNode
-    public fun addLast(node: LockFreeLinkedListNode)
+    public fun addLast(node: LockFreeLinkedListNode): Boolean
     public fun addOneIfEmpty(node: LockFreeLinkedListNode): Boolean
     public inline fun addLastIf(node: LockFreeLinkedListNode, crossinline condition: () -> Boolean): Boolean
     public open fun remove(): Boolean
+    public fun close()
 
 }
 

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

@@ -120,21 +120,29 @@ public actual open class LockFreeLinkedListNode {
     // ------ addLastXXX ------
 
     /**
-     * Adds last item to this list.
+     * Adds last item to this list. Returns `false` if the list is closed.
      */
-    public actual fun addLast(node: Node) {
+    public actual fun addLast(node: Node): Boolean {
         while (true) { // lock-free loop on prev.next
-            if (prevNode.addNext(node, this)) return
+            val currentPrev = prevNode
+            if (currentPrev is CLOSED) return false
+            if (currentPrev.addNext(node, this)) return true
         }
     }
 
+    /**
+     * Forbids adding new items to this list.
+     */
+    public actual fun close() { addLast(CLOSED()) }
+
     /**
      * Adds last item to this list atomically if the [condition] is true.
      */
     public actual inline fun addLastIf(node: Node, crossinline condition: () -> Boolean): Boolean {
         val condAdd = makeCondAddOp(node, condition)
         while (true) { // lock-free loop on prev.next
             val prev = prevNode // sentinel node is never removed, so prev is always defined
+            if (prev is CLOSED) return false
             when (prev.tryCondAddNext(node, this, condAdd)) {
                 SUCCESS -> return true
                 FAILURE -> return false
@@ -362,3 +370,6 @@ public actual open class LockFreeLinkedListHead : LockFreeLinkedListNode() {
         validateNode(prev, next as Node)
     }
 }
+
+// not private due to what seems to be a compiler bug
+internal class CLOSED: LockFreeLinkedListNode()

kotlinx-coroutines-core/jsAndWasmShared/src/internal/LinkedList.kt

@@ -26,12 +26,18 @@ public open class LinkedListNode : DisposableHandle {
     public inline val prevNode get() = _prev
     public inline val isRemoved get() = _removed
 
-    public fun addLast(node: Node) {
+    public fun addLast(node: Node): Boolean {
         val prev = this._prev
+        if (prev is CLOSED) return false
         node._next = this
         node._prev = prev
         prev._next = node
         this._prev = node
+        return true
+    }
+
+    public fun close() {
+        addLast(CLOSED())
     }
 
     /*
@@ -41,15 +47,6 @@ public open class LinkedListNode : DisposableHandle {
      * invokes handler on remove
      */
     public open fun remove(): Boolean {
-        return removeImpl()
-    }
-
-    override fun dispose() {
-        remove()
-    }
-
-    @PublishedApi
-    internal fun removeImpl(): Boolean {
         if (_removed) return false
         val prev = this._prev
         val next = this._next
@@ -59,6 +56,10 @@ public open class LinkedListNode : DisposableHandle {
         return true
     }
 
+    override fun dispose() {
+        remove()
+    }
+
     public fun addOneIfEmpty(node: Node): Boolean {
         if (_next !== this) return false
         addLast(node)
@@ -67,34 +68,7 @@ public open class LinkedListNode : DisposableHandle {
 
     public inline fun addLastIf(node: Node, crossinline condition: () -> Boolean): Boolean {
         if (!condition()) return false
-        addLast(node)
-        return true
-    }
-
-    public inline fun addLastIfPrev(node: Node, predicate: (Node) -> Boolean): Boolean {
-        if (!predicate(_prev)) return false
-        addLast(node)
-        return true
-    }
-
-    public inline fun addLastIfPrevAndIf(
-        node: Node,
-        predicate: (Node) -> Boolean, // prev node predicate
-        crossinline condition: () -> Boolean // atomically checked condition
-    ): Boolean {
-        if (!predicate(_prev)) return false
-        if (!condition()) return false
-        addLast(node)
-        return true
-    }
-
-    public fun helpRemove() {} // No concurrency on JS -> no removal
-
-    public fun removeFirstOrNull(): Node? {
-        val next = _next
-        if (next === this) return null
-        check(next.removeImpl()) { "Should remove" }
-        return next
+        return addLast(node)
     }
 }
 
@@ -116,3 +90,5 @@ public open class LinkedListHead : LinkedListNode() {
     // just a defensive programming -- makes sure that list head sentinel is never removed
     public final override fun remove(): Nothing = throw UnsupportedOperationException()
 }
+
+private class CLOSED: LinkedListNode()