[K/JS] Optimize copyOf(newSize) function for primitive arrays

All primitive arrays - apart from LongArray and BooleanArray - are
compiled to JS TypedArrays. This means that instead of iterating all
indexes we can simply use TypedArray.set or TypedArray.slice depending
on the inputted new size.

^KT-77646

Author: lppedd

libraries/stdlib/js/src/generated/_ArraysJs.kt

@@ -940,7 +940,13 @@ public fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
  */
 public actual fun ByteArray.copyOf(newSize: Int): ByteArray {
     require(newSize >= 0) { "Invalid new array size: $newSize." }
-    return fillFrom(this, ByteArray(newSize))
+    return if (newSize > this.size) {
+        ByteArray(newSize).also { copy ->
+            copy.asDynamic().set(this, 0)
+        }
+    } else {
+        this.asDynamic().slice(0, newSize)
+    }
 }
 
 /**
@@ -954,7 +960,13 @@ public actual fun ByteArray.copyOf(newSize: Int): ByteArray {
  */
 public actual fun ShortArray.copyOf(newSize: Int): ShortArray {
     require(newSize >= 0) { "Invalid new array size: $newSize." }
-    return fillFrom(this, ShortArray(newSize))
+    return if (newSize > this.size) {
+        ShortArray(newSize).also { copy ->
+            copy.asDynamic().set(this, 0)
+        }
+    } else {
+        this.asDynamic().slice(0, newSize)
+    }
 }
 
 /**
@@ -968,7 +980,13 @@ public actual fun ShortArray.copyOf(newSize: Int): ShortArray {
  */
 public actual fun IntArray.copyOf(newSize: Int): IntArray {
     require(newSize >= 0) { "Invalid new array size: $newSize." }
-    return fillFrom(this, IntArray(newSize))
+    return if (newSize > this.size) {
+        IntArray(newSize).also { copy ->
+            copy.asDynamic().set(this, 0)
+        }
+    } else {
+        this.asDynamic().slice(0, newSize)
+    }
 }
 
 /**
@@ -996,7 +1014,13 @@ public actual fun LongArray.copyOf(newSize: Int): LongArray {
  */
 public actual fun FloatArray.copyOf(newSize: Int): FloatArray {
     require(newSize >= 0) { "Invalid new array size: $newSize." }
-    return fillFrom(this, FloatArray(newSize))
+    return if (newSize > this.size) {
+        FloatArray(newSize).also { copy ->
+            copy.asDynamic().set(this, 0)
+        }
+    } else {
+        this.asDynamic().slice(0, newSize)
+    }
 }
 
 /**
@@ -1010,7 +1034,13 @@ public actual fun FloatArray.copyOf(newSize: Int): FloatArray {
  */
 public actual fun DoubleArray.copyOf(newSize: Int): DoubleArray {
     require(newSize >= 0) { "Invalid new array size: $newSize." }
-    return fillFrom(this, DoubleArray(newSize))
+    return if (newSize > this.size) {
+        DoubleArray(newSize).also { copy ->
+            copy.asDynamic().set(this, 0)
+        }
+    } else {
+        this.asDynamic().slice(0, newSize)
+    }
 }
 
 /**
@@ -1038,7 +1068,14 @@ public actual fun BooleanArray.copyOf(newSize: Int): BooleanArray {
  */
 public actual fun CharArray.copyOf(newSize: Int): CharArray {
     require(newSize >= 0) { "Invalid new array size: $newSize." }
-    return withType("CharArray", fillFrom(this, CharArray(newSize)))
+    val copy = if (newSize > this.size) {
+        CharArray(newSize).also { copy ->
+            copy.asDynamic().set(this, 0)
+        }
+    } else {
+        this.asDynamic().slice(0, newSize)
+    }
+    return withType("CharArray", copy)
 }
 
 /**

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

@@ -1076,14 +1076,36 @@ object ArrayOps : TemplateGroupBase() {
                 returns("SELF")
                 on(Platform.JS) {
                     when (primitive!!) {
-                        PrimitiveType.Boolean ->
-                            body { "return withType(\"BooleanArray\", arrayCopyResize(this, newSize, false))" }
-                        PrimitiveType.Char ->
-                            body { "return withType(\"CharArray\", fillFrom(this, ${primitive}Array(newSize)))" }
-                        PrimitiveType.Long ->
-                            body { "return withType(\"LongArray\", arrayCopyResize(this, newSize, ${primitive!!.zero()}))" }
-                        else ->
-                            body { "return fillFrom(this, ${primitive}Array(newSize))" }
+                        PrimitiveType.Long -> body {
+                            "return withType(\"LongArray\", arrayCopyResize(this, newSize, ${primitive!!.zero()}))"
+                        }
+                        PrimitiveType.Boolean -> body {
+                            "return withType(\"BooleanArray\", arrayCopyResize(this, newSize, false))"
+                        }
+                        PrimitiveType.Char -> body {
+                            """
+                            val copy = if (newSize > this.size) {
+                                CharArray(newSize).also { copy ->
+                                    copy.asDynamic().set(this, 0)
+                                }
+                            } else {
+                                this.asDynamic().slice(0, newSize)
+                            }
+                            
+                            return withType("CharArray", copy)
+                            """.trimIndent()
+                        }
+                        else -> body {
+                            """
+                            return if (newSize > this.size) {
+                                ${primitive}Array(newSize).also { copy ->
+                                    copy.asDynamic().set(this, 0)
+                                }
+                            } else {
+                                this.asDynamic().slice(0, newSize)
+                            }
+                            """.trimIndent()
+                        }
                     }
                     body { newSizeCheck + "\n" + body }
                 }