fixup to the previous commit

Author: dkhalanskyjb

kotlinx-coroutines-core/common/src/JobSupport.kt

@@ -515,7 +515,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
                                  */
                                 val latestState = this@JobSupport.state
                                 if (latestState is Finishing) {
-                                    // Assumption: children always have `invokeImmediately = true`.
+                                    assert { invokeImmediately }
                                     synchronized(latestState) { latestState.rootCause }?.let { handler.invoke(it) }
                                 }
                             }

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

@@ -84,8 +84,8 @@ public actual open class LockFreeLinkedListNode {
         while (true) { // lock-free loop on prev.next
             val currentPrev = prevNode
             return when {
-                currentPrev is LIST_CLOSED_FOR_ALL -> false
-                currentPrev is LIST_CLOSED_FOR_SOME ->
+                currentPrev is ListClosedForAll -> false
+                currentPrev is ListClosedForSome ->
                     allowedAfterPartialClosing && currentPrev.addLast(node, allowedAfterPartialClosing)
                 currentPrev.addNext(node, this) -> true
                 else -> continue
@@ -96,12 +96,12 @@ public actual open class LockFreeLinkedListNode {
     /**
      * Forbids adding some of the new items to this list.
      */
-    public actual fun closeForSome() { addLast(LIST_CLOSED_FOR_SOME(), allowedAfterPartialClosing = false) }
+    public actual fun closeForSome() { addLast(ListClosedForSome(), allowedAfterPartialClosing = false) }
 
     /**
      * Forbids adding new items to this list.
      */
-    public actual fun close() { addLast(LIST_CLOSED_FOR_ALL(), allowedAfterPartialClosing = true) }
+    public actual fun close() { addLast(ListClosedForAll(), allowedAfterPartialClosing = true) }
 
     /**
      * Given:
@@ -291,6 +291,6 @@ public actual open class LockFreeLinkedListHead : LockFreeLinkedListNode() {
     override val isRemoved: Boolean get() = false
 }
 
-private class LIST_CLOSED_FOR_SOME: LockFreeLinkedListNode()
+private class ListClosedForSome: LockFreeLinkedListNode()
 
-private class LIST_CLOSED_FOR_ALL: LockFreeLinkedListNode()
+private class ListClosedForAll: LockFreeLinkedListNode()

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

@@ -23,8 +23,8 @@ public open class LinkedListNode : DisposableHandle {
     public inline val isRemoved get() = _removed
 
     public fun addLast(node: Node, allowedAfterPartialClosing: Boolean): Boolean = when (val prev = this._prev) {
-        is LIST_CLOSED_FOR_ALL -> false
-        is LIST_CLOSED_FOR_SOME -> allowedAfterPartialClosing && prev.addLast(node, allowedAfterPartialClosing)
+        is ListClosedForAll -> false
+        is ListClosedForSome -> allowedAfterPartialClosing && prev.addLast(node, allowedAfterPartialClosing)
         else -> {
             node._next = this
             node._prev = prev
@@ -35,11 +35,11 @@ public open class LinkedListNode : DisposableHandle {
     }
 
     public fun closeForSome() {
-        addLast(LIST_CLOSED_FOR_SOME(), allowedAfterPartialClosing = true)
+        addLast(ListClosedForSome(), allowedAfterPartialClosing = true)
     }
 
     public fun close() {
-        addLast(LIST_CLOSED_FOR_ALL(), allowedAfterPartialClosing = false)
+        addLast(ListClosedForAll(), allowedAfterPartialClosing = false)
     }
 
     /*
@@ -88,6 +88,6 @@ public open class LinkedListHead : LinkedListNode() {
     public final override fun remove(): Nothing = throw UnsupportedOperationException()
 }
 
-private class LIST_CLOSED_FOR_SOME: LinkedListNode()
+private class ListClosedForSome: LinkedListNode()
 
-private class LIST_CLOSED_FOR_ALL: LinkedListNode()
+private class ListClosedForAll: LinkedListNode()