KT-75801: optimize functions converting object array to list

This contains two different cases of optimization:
 * Array<T>.(take|takeLast|takeWhile) functions : replace loop copy with copyOfRange().asList()
 * Array<T>.toList() and Array<Array<T>>.flatten() : force using direct array copy instead of delegating to mutable list.

Primitive array functions were not modified, because of unboxing. When the optimization is applied to primitive arrays, the initial copy might indeed get faster, but then, unboxing would be delayed on List.get() calls, therefore adding performance penalty on the consumer side.

Benchmarks being used:
- original set of benchmarks: https://github.com/alexismanin/kt-benchmark-array-to-list
- later validated on: https://github.com/fzhinkin/kt-benchmark-array-to-list/tree/run-filter-on-pre-allocated-list

^KT-75801 Fixed
^KT-82033 Fixed

Initial GH PR: #5426

Merge-request: KT-MR-21026
Merged-by: Filipp Zhinkin <[email protected]>

Author: alexismanin

libraries/stdlib/common/src/generated/_Arrays.kt

@@ -4944,14 +4944,7 @@ public fun <T> Array<out T>.take(n: Int): List<T> {
     if (n == 0) return emptyList()
     if (n >= size) return toList()
     if (n == 1) return listOf(this[0])
-    var count = 0
-    val list = ArrayList<T>(n)
-    for (item in this) {
-        list.add(item)
-        if (++count == n)
-            break
-    }
-    return list
+    return copyOfRange(0, n).asList()
 }
 
 /**
@@ -5143,10 +5136,7 @@ public fun <T> Array<out T>.takeLast(n: Int): List<T> {
     val size = size
     if (n >= size) return toList()
     if (n == 1) return listOf(this[size - 1])
-    val list = ArrayList<T>(n)
-    for (index in size - n until size)
-        list.add(this[index])
-    return list
+    return copyOfRange(size - n, size).asList()
 }
 
 /**
@@ -5433,13 +5423,11 @@ public inline fun CharArray.takeLastWhile(predicate: (Char) -> Boolean): List<Ch
  * @sample samples.collections.Collections.Transformations.take
  */
 public inline fun <T> Array<out T>.takeWhile(predicate: (T) -> Boolean): List<T> {
-    val list = ArrayList<T>()
-    for (item in this) {
-        if (!predicate(item))
-            break
-        list.add(item)
-    }
-    return list
+    var i = 0
+    while (i < size && predicate(this[i])) i++
+    return if (i == 0) emptyList()
+           else if (i == 1) listOf(this[0])
+           else copyOfRange(0, i).asList()
 }
 
 /**
@@ -10277,7 +10265,7 @@ public fun <T> Array<out T>.toList(): List<T> {
     return when (size) {
         0 -> emptyList()
         1 -> listOf(this[0])
-        else -> this.toMutableList()
+        else -> copyOf().asList()
     }
 }
 

libraries/stdlib/src/kotlin/collections/Arrays.kt

@@ -17,11 +17,21 @@ import kotlin.contracts.*
  * @sample samples.collections.Arrays.Transformations.flattenArray
  */
 public fun <T> Array<out Array<out T>>.flatten(): List<T> {
-    val result = ArrayList<T>(sumOf { it.size })
-    for (element in this) {
-        result.addAll(element)
+    val totalSizeLong = sumOf { it.size.toLong() }
+    if (totalSizeLong == 0L) return emptyList()
+    require(totalSizeLong <= Int.MAX_VALUE.toLong()) {
+        "Sum of all arrays lengths ($totalSizeLong) exceeds maximum list size (${Int.MAX_VALUE})"
     }
-    return result
+
+    val outputArray = arrayOfNulls<Any?>(totalSizeLong.toInt())
+    var offset = 0
+    for (innerArray in this) {
+        innerArray.copyInto(outputArray, offset)
+        offset += innerArray.size
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    return outputArray.asList() as List<T>
 }
 
 /**

libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt

@@ -192,7 +192,7 @@ object Filtering : TemplateGroupBase() {
             """
         }
 
-        body(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) {
+        body(ArraysOfPrimitives, ArraysOfUnsigned) {
             """
             require(n >= 0) { "Requested element count $n is less than zero." }
             if (n == 0) return emptyList()
@@ -208,6 +208,17 @@ object Filtering : TemplateGroupBase() {
             return list
             """
         }
+
+        // For object arrays, ensure a single array copy instead of copying using a loop (see KT-75801)
+        body(ArraysOfObjects) {
+            """
+            require(n >= 0) { "Requested element count $n is less than zero." }
+            if (n == 0) return emptyList()
+            if (n >= size) return toList()
+            if (n == 1) return listOf(this[0])
+            return copyOfRange(0, n).asList()
+            """
+        }
     }
 
     val f_dropLast = fn("dropLast(n: Int)") {
@@ -270,7 +281,7 @@ object Filtering : TemplateGroupBase() {
             """
         }
 
-        body(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) {
+        body(ArraysOfPrimitives, ArraysOfUnsigned) {
             """
             require(n >= 0) { "Requested element count $n is less than zero." }
             if (n == 0) return emptyList()
@@ -284,6 +295,19 @@ object Filtering : TemplateGroupBase() {
             return list
             """
         }
+
+        // For object arrays, ensure a single array copy instead of copying using a loop (see KT-75801)
+        body(ArraysOfObjects) {
+            """
+            require(n >= 0) { "Requested element count $n is less than zero." }
+            if (n == 0) return emptyList()
+            val size = size
+            if (n >= size) return toList()
+            if (n == 1) return listOf(this[size - 1])
+            return copyOfRange(size - n, size).asList()
+            """
+        }
+
         body(Lists) {
             """
             require(n >= 0) { "Requested element count $n is less than zero." }
@@ -413,6 +437,17 @@ object Filtering : TemplateGroupBase() {
             returns("Sequence<T>")
             body { """return TakeWhileSequence(this, predicate)""" }
         }
+
+        // For object arrays, ensure a single array copy instead of copying using a loop (see KT-75801)
+        body(ArraysOfObjects) {
+            """
+            var i = 0
+            while (i < ${f.code.size} && predicate(this[i])) i++
+            return if (i == 0) emptyList()
+                   else if (i == 1) listOf(this[0])
+                   else copyOfRange(0, i).asList()
+            """
+        }
     }
 
     val f_dropLastWhile = fn("dropLastWhile(predicate: (T) -> Boolean)") {

libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt

@@ -174,7 +174,7 @@ object Snapshots : TemplateGroupBase() {
             return this.toMutableList().optimizeReadOnlyList()
             """
         }
-        body(CharSequences, ArraysOfPrimitives, ArraysOfObjects) {
+        body(CharSequences, ArraysOfPrimitives) {
             """
             return when (${f.code.size}) {
                 0 -> emptyList()
@@ -183,6 +183,16 @@ object Snapshots : TemplateGroupBase() {
             }
             """
         }
+        // For object array, ensure a single array copy instead of delegating to `toMutableList`, which can cause two copies (see KT-75801)
+        body(ArraysOfObjects) {
+            """
+            return when (${f.code.size}) {
+                0 -> emptyList()
+                1 -> listOf(this[0])
+                else -> copyOf().asList()
+            }
+            """
+        }
         body(Sequences) { optimizedSequenceToCollection("emptyList", "listOf", "ArrayList") }
         specialFor(Maps) {
             doc { "Returns a [List] containing all key-value pairs." }