Merge "Use forAllData instead of forEachData for deactivating" into androidx-main

Author: Treehugger Robot

compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Composer.kt

@@ -4202,45 +4202,40 @@ internal fun SlotWriter.deactivateCurrentGroup(rememberManager: RememberManager)
 
     // To ensure this order, we call `enters` as a pre-order traversal
     // of the group tree, and then call `leaves` in the inverse order.
-    val start = currentGroup
-    val end = currentGroupEnd
-    for (group in start until end) {
-        val node = node(group)
-        if (node is ComposeNodeLifecycleCallback) {
-            val endRelativeOrder = slotsSize - slotsStartIndex(group)
-            rememberManager.deactivating(node, endRelativeOrder, -1, -1)
-        }
-
-        forEachData(group) { slotIndex, data ->
-            when (data) {
-                is RememberObserverHolder -> {
-                    val wrapped = data.wrapped
-                    if (wrapped is ReusableRememberObserver) {
-                        // do nothing, the value should be preserved on reuse
-                    } else {
-                        removeData(group, slotIndex, data)
-                        val endRelativeOrder = slotsSize - slotIndex
-                        withAfterAnchorInfo(data.after) { priority, endRelativeAfter ->
-                            rememberManager.forgetting(
-                                wrapped,
-                                endRelativeOrder,
-                                priority,
-                                endRelativeAfter
-                            )
-                        }
+    forAllData(currentGroup) { slotIndex, data ->
+        when (data) {
+            is ComposeNodeLifecycleCallback -> {
+                val endRelativeOrder = slotsSize - slotIndex
+                rememberManager.deactivating(data, endRelativeOrder, -1, -1)
+            }
+            is RememberObserverHolder -> {
+                val wrapped = data.wrapped
+                if (wrapped is ReusableRememberObserver) {
+                    // do nothing, the value should be preserved on reuse
+                } else {
+                    removeData(slotIndex, data)
+                    val endRelativeOrder = slotsSize - slotIndex
+                    withAfterAnchorInfo(data.after) { priority, endRelativeAfter ->
+                        rememberManager.forgetting(
+                            wrapped,
+                            endRelativeOrder,
+                            priority,
+                            endRelativeAfter
+                        )
                     }
                 }
-                is RecomposeScopeImpl -> {
-                    removeData(group, slotIndex, data)
-                    data.release()
-                }
+            }
+            is RecomposeScopeImpl -> {
+                removeData(slotIndex, data)
+                data.release()
             }
         }
     }
 }
 
-private fun SlotWriter.removeData(group: Int, index: Int, data: Any?) {
-    runtimeCheck(data === set(group, index, Composer.Empty)) { "Slot table is out of sync" }
+private fun SlotWriter.removeData(index: Int, data: Any?) {
+    val result = clear(index)
+    runtimeCheck(data === result) { "Slot table is out of sync (expected $data, got $result)" }
 }
 
 @JvmInline

compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/SlotTable.kt

@@ -1624,6 +1624,14 @@ internal class SlotWriter(
         return result
     }
 
+    /** Set the slot by index to Composer.Empty, returning previous value */
+    fun clear(slotIndex: Int): Any? {
+        val address = dataIndexToDataAddress(slotIndex)
+        val result = slots[address]
+        slots[address] = Composer.Empty
+        return result
+    }
+
     /**
      * Skip the current slot without updating. If the slot table is inserting then and
      * [Composer.Empty] slot is added and [skip] return [Composer.Empty].
@@ -2023,16 +2031,6 @@ internal class SlotWriter(
         }
     }
 
-    inline fun forEachData(group: Int, block: (index: Int, data: Any?) -> Unit) {
-        val address = groupIndexToAddress(group)
-        val slotsStart = groups.slotIndex(address)
-        val slotsEnd = groups.dataIndex(groupIndexToAddress(group + 1))
-
-        for (slot in slotsStart until slotsEnd) {
-            block(slot - slotsStart, slots[dataIndexToDataAddress(slot)])
-        }
-    }
-
     inline fun forAllData(group: Int, block: (index: Int, data: Any?) -> Unit) {
         val address = groupIndexToAddress(group)
         val start = groups.dataIndex(address)