Make date-header keys collision-proof

The header LazyColumn key relied on the invariant that date-sorted comments make
each label one contiguous group. If the list ever arrived out of date order a
label could repeat non-contiguously, producing a duplicate key -> LazyColumn
IllegalArgumentException (a crash, where the legacy list only showed a redundant
header). withDateHeaders now mints a guaranteed-unique key per header (still just
the label in the normal case, disambiguated only on a non-contiguous repeat), so
correctness no longer depends on the sort order.

Author: nbradbury

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/CommentsRsListRow.kt

@@ -2,7 +2,8 @@ package org.wordpress.android.ui.commentsrs
 
 /** A rendered row in the rs comment list: either a date-group header or a comment. */
 sealed interface CommentsRsListRow {
-    data class DateHeader(val label: String) : CommentsRsListRow
+    /** [key] is a guaranteed-unique LazyColumn key; [label] is the (date) text shown to the user. */
+    data class DateHeader(val label: String, val key: String) : CommentsRsListRow
     data class Item(val comment: CommentRsUiModel) : CommentsRsListRow
 }
 
@@ -12,19 +13,31 @@ sealed interface CommentsRsListRow {
  * the previous one. The label is the row's own [CommentRsUiModel.relativeDate] — the same
  * javaDateToTimeSpan value the legacy list groups by — so no extra date handling is needed here.
  *
- * The label doubles as the header's LazyColumn key: comments are date-sorted, so a label maps to
- * exactly one contiguous group (unique key), and keying by the label rather than the group's first
- * comment keeps the header stable when a newer comment is prepended into an existing group.
+ * Each header carries a unique [CommentsRsListRow.DateHeader.key] for the LazyColumn. Comments are
+ * date-sorted, so a label normally maps to one contiguous group and the key is just the label —
+ * which keeps the header stable when a newer comment is prepended into an existing group. Should
+ * the list ever arrive out of date order, a repeated label is disambiguated rather than emitting a
+ * duplicate key (which LazyColumn rejects with a hard crash, unlike the legacy RecyclerView).
  */
 fun withDateHeaders(comments: List<CommentRsUiModel>): List<CommentsRsListRow> {
     val rows = ArrayList<CommentsRsListRow>(comments.size + 1)
+    val usedKeys = HashSet<String>()
     var lastLabel: String? = null
     for (comment in comments) {
         if (comment.relativeDate != lastLabel) {
-            rows.add(CommentsRsListRow.DateHeader(comment.relativeDate))
+            rows.add(CommentsRsListRow.DateHeader(comment.relativeDate, uniqueKey(comment.relativeDate, usedKeys)))
             lastLabel = comment.relativeDate
         }
         rows.add(CommentsRsListRow.Item(comment))
     }
     return rows
 }
+
+/** A stable per-label key, suffixed only if the same label recurs non-contiguously (see above). */
+private fun uniqueKey(label: String, used: MutableSet<String>): String {
+    val base = "header_$label"
+    if (used.add(base)) return base
+    var n = 1
+    while (!used.add("$base#$n")) n++
+    return "$base#$n"
+}

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/screens/CommentsRsTabListScreen.kt

@@ -148,7 +148,7 @@ private fun CommentListContent(
             items = rows,
             key = { row ->
                 when (row) {
-                    is CommentsRsListRow.DateHeader -> "header_${row.label}"
+                    is CommentsRsListRow.DateHeader -> row.key
                     is CommentsRsListRow.Item -> row.comment.remoteCommentId
                 }
             },

WordPress/src/test/java/org/wordpress/android/ui/commentsrs/CommentsRsListRowTest.kt

@@ -17,7 +17,7 @@ class CommentsRsListRowTest {
         val comment = comment(id = 1, date = "Today")
 
         assertThat(withDateHeaders(listOf(comment))).containsExactly(
-            DateHeader("Today"),
+            header("Today"),
             Item(comment)
         )
     }
@@ -28,7 +28,7 @@ class CommentsRsListRowTest {
         val b = comment(id = 2, date = "Today")
 
         assertThat(withDateHeaders(listOf(a, b))).containsExactly(
-            DateHeader("Today"),
+            header("Today"),
             Item(a),
             Item(b)
         )
@@ -42,12 +42,12 @@ class CommentsRsListRowTest {
         val d = comment(id = 4, date = "January 8")
 
         assertThat(withDateHeaders(listOf(a, b, c, d))).containsExactly(
-            DateHeader("Today"),
+            header("Today"),
             Item(a),
             Item(b),
-            DateHeader("Yesterday"),
+            header("Yesterday"),
             Item(c),
-            DateHeader("January 8"),
+            header("January 8"),
             Item(d)
         )
     }
@@ -64,6 +64,27 @@ class CommentsRsListRowTest {
         assertThat(afterHeader).isEqualTo(beforeHeader)
     }
 
+    @Test
+    fun `a label that recurs non-contiguously gets distinct header keys instead of crashing`() {
+        // Defensive: comments are normally date-sorted so a label is one contiguous group, but if
+        // the list ever arrives out of order two groups can share a label. LazyColumn rejects
+        // duplicate keys with a crash, so each header must still get a unique key.
+        val rows = withDateHeaders(
+            listOf(
+                comment(id = 1, date = "Today"),
+                comment(id = 2, date = "Yesterday"),
+                comment(id = 3, date = "Today")
+            )
+        )
+
+        val headers = rows.filterIsInstance<DateHeader>()
+        assertThat(headers.map { it.label }).containsExactly("Today", "Yesterday", "Today")
+        assertThat(headers.map { it.key }).doesNotHaveDuplicates()
+    }
+
+    /** A header as it appears in the normal (contiguous) case: key derived directly from the label. */
+    private fun header(label: String) = DateHeader(label, "header_$label")
+
     private fun comment(id: Long, date: String) = CommentRsUiModel(
         remoteCommentId = id,
         authorName = "Jane",