Fix deprecations in testData: BlackBoxWithStdLibCodegenTest

compiler/testData/codegen/boxWithStdlib/dataClasses/doubleParam.kt

@@ -26,5 +26,5 @@ fun box(): String {
     if (A(-2.72) !in s) return "Fail: -2.72 not found"
     if (A(NAN) !in s) return "Fail: NaN not found"
 
-    return if (s.size == 5) "OK" else "Fail $s"
+    return if (s.size() == 5) "OK" else "Fail $s"
 }

compiler/testData/codegen/boxWithStdlib/dataClasses/equals/genericarray.kt

@@ -1,6 +1,6 @@
 data class A(val v: Array<Int>)
 
 fun box() : String {
-  if(A(array(0,1,2)) != A(array(0,1,2))) return "fail"
+  if(A(arrayOf(0,1,2)) != A(arrayOf(0,1,2))) return "fail"
   return "OK"
 }

compiler/testData/codegen/boxWithStdlib/dataClasses/equals/intarray.kt

@@ -1,6 +1,6 @@
 data class A(val v: IntArray)
 
 fun box() : String {
-  if(A(intArray(0,1,2)) != A(intArray(0,1,2))) return "fail"
+  if(A(intArrayOf(0,1,2)) != A(intArrayOf(0,1,2))) return "fail"
   return "OK"
 }

compiler/testData/codegen/boxWithStdlib/dataClasses/floatParam.kt

@@ -26,5 +26,5 @@ fun box(): String {
     if (A(-2.72f) !in s) return "Fail: -2.72 not found"
     if (A(NAN) !in s) return "Fail: NaN not found"
 
-    return if (s.size == 5) "OK" else "Fail $s"
+    return if (s.size() == 5) "OK" else "Fail $s"
 }

compiler/testData/codegen/boxWithStdlib/dataClasses/hashcode/array.kt

@@ -1,6 +1,6 @@
 data class A(val a: IntArray, var b: Array<String>)
 
 fun box() : String {
-   if( A(intArray(1,2,3),array("239")).hashCode() != 31*java.util.Arrays.hashCode(intArray(0,1,2)) + "239".hashCode()) "fail"
+   if( A(intArrayOf(1,2,3),arrayOf("239")).hashCode() != 31*java.util.Arrays.hashCode(intArrayOf(0,1,2)) + "239".hashCode()) "fail"
    return "OK"
 }

compiler/testData/codegen/boxWithStdlib/enum/sortEnumEntries.kt

@@ -9,7 +9,7 @@ enum class Game {
 }
 
 fun box(): String {
-    val a = array(LIZARD, SCISSORS, SPOCK, ROCK, PAPER)
+    val a = arrayOf(LIZARD, SCISSORS, SPOCK, ROCK, PAPER)
     a.sort()
     val str = a.joinToString(" ")
     return if (str == "ROCK PAPER SCISSORS LIZARD SPOCK") "OK" else "Fail: $str"

compiler/testData/codegen/boxWithStdlib/fullJdk/kt2423.kt

@@ -1,5 +1,5 @@
 fun ok1(): Boolean {
-    val queue = linkedList(1, 2, 3)
+    val queue = linkedListOf(1, 2, 3)
     while (!queue.isEmpty()) {
         queue.poll()
         for (y in 1..3) {
@@ -12,8 +12,8 @@ fun ok1(): Boolean {
 }
 
 fun ok2(): Boolean {
-    val queue = linkedList(1, 2, 3)
+    val queue = linkedListOf(1, 2, 3)
-    val array = array(1, 2, 3)
+    val array = arrayOf(1, 2, 3)
     while (!queue.isEmpty()) {
         queue.poll()
         for (y in array) {
@@ -26,7 +26,7 @@ fun ok2(): Boolean {
 }
 
 fun ok3(): Boolean {
-    val queue = linkedList(1, 2, 3)
+    val queue = linkedListOf(1, 2, 3)
     while (!queue.isEmpty()) {
         queue.poll()
         var x = 0

compiler/testData/codegen/boxWithStdlib/fullJdk/kt2509.kt

@@ -4,7 +4,7 @@ fun box(): String {
 }
 
 class A: B() {
-        override var foo = array<Int?>(12, 13)
+        override var foo = arrayOf<Int?>(12, 13)
 }
 
 abstract class B {

compiler/testData/codegen/boxWithStdlib/fullJdk/regressions/collections.kt

@@ -36,18 +36,18 @@ fun <T> testMutableCollectionIterator(c: MutableCollection<T>, t: T) {
     assertEquals(0, c.size())
 }
 fun <T> testMutableCollectionAddAll(c: MutableCollection<T>, t1: T, t2: T) {
-    c.addAll(arrayList(t1, t2))
+    c.addAll(arrayListOf(t1, t2))
-    assertEquals(arrayList(t1, t2), c)
+    assertEquals(arrayListOf(t1, t2), c)
 }
 fun <T> testMutableCollectionRemoveAll(c: MutableCollection<T>, t1: T, t2: T) {
-    c.addAll(arrayList(t1, t2))
+    c.addAll(arrayListOf(t1, t2))
-    c.removeAll(arrayList(t1))
+    c.removeAll(arrayListOf(t1))
-    assertEquals(arrayList(t2), c)
+    assertEquals(arrayListOf(t2), c)
 }
 fun <T> testMutableCollectionRetainAll(c: MutableCollection<T>, t1: T, t2: T) {
-    c.addAll(arrayList(t1, t2))
+    c.addAll(arrayListOf(t1, t2))
-    c.retainAll(arrayList(t1))
+    c.retainAll(arrayListOf(t1))
-    assertEquals(arrayList(t1), c)
+    assertEquals(arrayListOf(t1), c)
 }
 fun <T> testMutableCollectionClear(c: MutableCollection<T>) {
     c.clear()
@@ -55,27 +55,27 @@ fun <T> testMutableCollectionClear(c: MutableCollection<T>) {
 }
 
 fun testCollection() {
-    testCollectionSize(arrayList<Int>())
+    testCollectionSize(arrayListOf<Int>())
-    testCollectionIsEmpty(arrayList<String>())
+    testCollectionIsEmpty(arrayListOf<String>())
-    testCollectionContains(arrayList(1))
+    testCollectionContains(arrayListOf(1))
-    testCollectionIterator(arrayList(1))
+    testCollectionIterator(arrayListOf(1))
-    testCollectionContainsAll(arrayList("a", "b"))
+    testCollectionContainsAll(arrayListOf("a", "b"))
 
-    testMutableCollectionAdd(arrayList(), "")
+    testMutableCollectionAdd(arrayListOf(), "")
-    testMutableCollectionRemove(arrayList("a"), "a")
+    testMutableCollectionRemove(arrayListOf("a"), "a")
-    testMutableCollectionIterator(arrayList(), 1)
+    testMutableCollectionIterator(arrayListOf(), 1)
-    testMutableCollectionAddAll(arrayList(), 1, 2)
+    testMutableCollectionAddAll(arrayListOf(), 1, 2)
-    testMutableCollectionRemoveAll(arrayList(), 1, 2)
+    testMutableCollectionRemoveAll(arrayListOf(), 1, 2)
-    testMutableCollectionRetainAll(arrayList(), 1, 2)
+    testMutableCollectionRetainAll(arrayListOf(), 1, 2)
-    testMutableCollectionClear(arrayList(1, 2))
+    testMutableCollectionClear(arrayListOf(1, 2))
 }
 
 
 fun <T> testListGet(l: List<T>, t: T) = assertEquals(t, l.get(0))
 fun <T> testListIndexOf(l: List<T>, t: T) = assertEquals(0, l.indexOf(t))
 fun <T> testListIterator(l: List<T>, t1 : T, t2 : T) {
-    val indexes = arrayList<Int>()
+    val indexes = arrayListOf<Int>()
-    val result = arrayList<T>()
+    val result = arrayListOf<T>()
     val it = l.listIterator()
     while (it.hasNext()) {
         indexes.add(it.nextIndex())
@@ -85,14 +85,14 @@ fun <T> testListIterator(l: List<T>, t1 : T, t2 : T) {
         indexes.add(it.previousIndex())
         result.add(it.previous())
     }
-    assertEquals(arrayList(0, 1, 1, 0), indexes)
+    assertEquals(arrayListOf(0, 1, 1, 0), indexes)
-    assertEquals(arrayList(t1, t2, t2, t1), result)
+    assertEquals(arrayListOf(t1, t2, t2, t1), result)
 }
-fun <T> testListSublist(l: List<T>, t: T) = assertEquals(arrayList(t), l.subList(0, 1))
+fun <T> testListSublist(l: List<T>, t: T) = assertEquals(arrayListOf(t), l.subList(0, 1))
 
 fun <T> testMutableListSet(l: MutableList<T>, t: T) {
     l.set(0, t)
-    assertEquals(arrayList(t), l)
+    assertEquals(arrayListOf(t), l)
 }
 fun <T> testMutableListIterator(l: MutableList<T>, t1: T, t2: T, t3: T) {
     val it = l.listIterator()
@@ -100,22 +100,22 @@ fun <T> testMutableListIterator(l: MutableList<T>, t1: T, t2: T, t3: T) {
         it.next()
         it.add(t3)
     }
-    assertEquals(arrayList(t1, t3, t2, t3), l)
+    assertEquals(arrayListOf(t1, t3, t2, t3), l)
 }
 
 fun testList() {
-    testListGet(arrayList(1), 1)
+    testListGet(arrayListOf(1), 1)
-    testListIndexOf(arrayList(1), 1)
+    testListIndexOf(arrayListOf(1), 1)
-    testListIterator(arrayList("a", "b"), "a", "b")
+    testListIterator(arrayListOf("a", "b"), "a", "b")
-    testListSublist(arrayList(1, 2), 1)
+    testListSublist(arrayListOf(1, 2), 1)
 
-    testMutableListSet(arrayList(2), 4)
+    testMutableListSet(arrayListOf(2), 4)
-    testMutableListIterator(arrayList(1, 2), 1, 2, 3)
+    testMutableListIterator(arrayListOf(1, 2), 1, 2, 3)
 }
 
 fun <K, V> testMapContainsKey(map: Map<K, V>, k: K) = assertTrue(map.containsKey(k))
-fun <K, V> testMapKeys(map: Map<K, V>, k1: K, k2: K) = assertEqualCollections(hashSet(k1, k2), map.keySet())
+fun <K, V> testMapKeys(map: Map<K, V>, k1: K, k2: K) = assertEqualCollections(hashSetOf(k1, k2), map.keySet())
-fun <K, V> testMapValues(map: Map<K, V>, v1: V, v2: V) = assertEqualCollections(hashSet(v1, v2), map.values())
+fun <K, V> testMapValues(map: Map<K, V>, v1: V, v2: V) = assertEqualCollections(hashSetOf(v1, v2), map.values())
 fun <K, V> testMapEntrySet(map: Map<K, V>, k : K, v: V) {
     for (entry in map.entrySet()) {
         assertEquals(k, entry.key)
@@ -126,16 +126,16 @@ fun <K, V> testMutableMapEntry(map: MutableMap<K, V>, k1 : K, v: V) {
     for (entry in map.entrySet()) {
         entry.setValue(v)
     }
-    assertEquals(hashMap(k1 to v), map)
+    assertEquals(hashMapOf(k1 to v), map)
 }
 
 
 fun testMap() {
-    testMapContainsKey(hashMap(1 to 'a', 2 to 'b'), 2)
+    testMapContainsKey(hashMapOf(1 to 'a', 2 to 'b'), 2)
-    testMapKeys(hashMap(1 to 'a', 2 to 'b'), 1, 2)
+    testMapKeys(hashMapOf(1 to 'a', 2 to 'b'), 1, 2)
-    testMapValues(hashMap(1 to 'a', 2 to 'b'), 'a', 'b')
+    testMapValues(hashMapOf(1 to 'a', 2 to 'b'), 'a', 'b')
-    testMapEntrySet(hashMap(1 to 'a'), 1, 'a')
+    testMapEntrySet(hashMapOf(1 to 'a'), 1, 'a')
-    testMutableMapEntry(hashMap(1 to 'a'), 1, 'b')
+    testMutableMapEntry(hashMapOf(1 to 'a'), 1, 'b')
 }
 
 fun box() : String {
@@ -145,4 +145,4 @@ fun box() : String {
     return "OK"
 }
 
-fun <T> assertEqualCollections(c1: Collection<T>, c2: Collection<T>) = assertEquals(c1.toCollection(hashSet<T>()), c2.toCollection(hashSet<T>()))
+fun <T> assertEqualCollections(c1: Collection<T>, c2: Collection<T>) = assertEquals(c1.toCollection(hashSetOf<T>()), c2.toCollection(hashSetOf<T>()))

compiler/testData/codegen/boxWithStdlib/fullJdk/regressions/kt864.kt

@@ -13,7 +13,7 @@ World""");
     val list1 = sample().useLines{it.toArrayList()}
     val list2 = sample().useLines<ArrayList<String>>{it.toArrayList()}
 
-    if(arrayList("Hello", "World") != list1) return "fail"
+    if(arrayListOf("Hello", "World") != list1) return "fail"
-    if(arrayList("Hello", "World") != list2) return "fail"
+    if(arrayListOf("Hello", "World") != list2) return "fail"
     return "OK"
   }

compiler/testData/codegen/boxWithStdlib/lazyCodegen/safeCallAndArray.kt

@@ -6,6 +6,6 @@ class C {
 
 fun box(): String? {
     val c: C? = C()
-    val arrayList = array(c?.calc(), "")
+    val arrayList = arrayOf(c?.calc(), "")
     return arrayList[0]
 }

compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/array.kt

@@ -6,7 +6,7 @@ annotation class Ann(val args: Array<KClass<*>>)
 class O
 class K
 
-@Ann(array(O::class, K::class)) class MyClass
+@Ann(arrayOf(O::class, K::class)) class MyClass
 
 fun box(): String {
     val args = javaClass<MyClass>().getAnnotation(javaClass<Ann>()).args

compiler/testData/codegen/boxWithStdlib/reflection/properties/propertyOfNestedClassAndArrayType.kt

@@ -8,7 +8,7 @@ class A {
 fun box(): String {
     val a = A()
 
-    (A::q).set(a, array(array(A.B("array"))))
+    (A::q).set(a, arrayOf(arrayOf(A.B("array"))))
     if (a.q!![0][0].result != "array") return "Fail array"
 
     (A::p).set(a, A.B("OK"))

compiler/testData/codegen/boxWithStdlib/regressions/Kt2495Test.kt

@@ -9,7 +9,7 @@ fun f(xs: Iterator<Int>): Int {
 }
 
 fun box(): String {
-    val list = arrayList(1, 2, 3)
+    val list = arrayListOf(1, 2, 3)
     val result = f(list.iterator())
     return if (6 == result) "OK" else "fail"
 }

compiler/testData/codegen/boxWithStdlib/regressions/getGenericInterfaces.kt

@@ -11,7 +11,7 @@ class ClassWithGenericSuperInterface: java.util.Comparator<String> {
 fun check(klass: Class<*>) {
     val interfaces = klass.getInterfaces().toList()
     val genericInterfaces = klass.getGenericInterfaces().toList()
-    if (interfaces.size != genericInterfaces.size) {
+    if (interfaces.size() != genericInterfaces.size()) {
         throw AssertionError("interfaces=$interfaces, genericInterfaces=$genericInterfaces")
     }
 }

compiler/testData/codegen/boxWithStdlib/regressions/kt1800.kt

@@ -20,7 +20,7 @@ public fun <T: Comparable<T>> Collection<T>.testMin(): T? {
 }
 
 fun box() : String {
-    val users = arrayList(
+    val users = arrayListOf(
             User("John", "Doe", 30),
             User("Jane", "Doe", 27))
 

compiler/testData/codegen/boxWithStdlib/regressions/kt2210.kt

@@ -3,6 +3,6 @@ class A<T>(t: Array<Array<T>>) {
 }
 
 fun box(): String {
-    A<Int>(array()) // <- java.lang.VerifyError: (class: A, method: getA signature: ()[[Ljava/lang/Object;) Wrong return type in function
+    A<Int>(arrayOf()) // <- java.lang.VerifyError: (class: A, method: getA signature: ()[[Ljava/lang/Object;) Wrong return type in function
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/regressions/kt5056.kt

@@ -1,4 +1,4 @@
 fun box(): String {
-    val list = array("a", "c", "b").toSortedList()
+    val list = arrayOf("a", "c", "b").sorted()
     return if (list.toString() == "[a, b, c]") "OK" else "Fail: $list"
 }

compiler/testData/codegen/boxWithStdlib/regressions/kt789.kt

@@ -8,5 +8,5 @@ fun box() : String {
     val a = ArrayList<Int>();
     a.add(1)
     a.add(2)
-    return if((a.size == 2) && (a.get(1) == 2) && (a.get(0) == 1)) "OK" else "fail"
+    return if((a.size() == 2) && (a.get(1) == 2) && (a.get(0) == 1)) "OK" else "fail"
 }

compiler/testData/codegen/boxWithStdlib/reified/copyToArray.kt

@@ -1,7 +1,7 @@
 import kotlin.test.assertEquals
 
 inline fun <reified T> copy(c: Collection<T>): Array<T> {
-    return c.copyToArray()
+    return c.toTypedArray()
 }
 
 fun box(): String {

compiler/testData/codegen/boxWithStdlib/reified/filterIsInstance.kt

@@ -5,7 +5,7 @@ inline fun<reified T> Array<Any>.filterIsInstance(): List<T> {
 }
 
 fun box(): String {
-    val src: Array<Any> = array(1,2,3.toDouble(), "abc", "cde")
+    val src: Array<Any> = arrayOf(1,2,3.toDouble(), "abc", "cde")
 
     assertEquals(arrayListOf(1,2), src.filterIsInstance<Int>())
     assertEquals(arrayListOf(3.0), src.filterIsInstance<Double>())

compiler/testData/codegen/boxWithStdlib/reified/nestedReified.kt

@@ -2,7 +2,7 @@ import kotlin.test.assertEquals
 
 inline fun <reified T : Any, reified R : Any> foo(): Array<String> {
     val x = object {
-        inline fun <reified T1 : Any, reified T : Any> bar(): Array<String> = array(
+        inline fun <reified T1 : Any, reified T : Any> bar(): Array<String> = arrayOf(
                 javaClass<T1>().getName(), javaClass<T>().getName(), javaClass<R>().getName()
         )
         fun f1() = bar<T, R>()
@@ -16,7 +16,7 @@ inline fun <reified T : Any, reified R : Any> foo(): Array<String> {
     val x3 = x.f3()
     val x4 = x.f4()
 
-    return array(
+    return arrayOf(
             x1[0], x1[1], x1[2],
             x2[0], x2[1], x2[2],
             x3[0], x3[1], x3[2],
@@ -27,7 +27,7 @@ inline fun <reified T : Any, reified R : Any> foo(): Array<String> {
 fun box(): String {
     val result = foo<Double, Int>()
 
-    val expected = array(
+    val expected = arrayOf(
             "java.lang.Double", "java.lang.Integer", "java.lang.Integer",
             "java.lang.Integer", "java.lang.Double", "java.lang.Integer",
             "java.lang.Boolean", "java.lang.Double", "java.lang.Integer",

compiler/testData/codegen/boxWithStdlib/reified/nestedReifiedSignature.kt

@@ -11,13 +11,13 @@ inline fun <reified T, reified R> foo(): Array<A<*,*,*>> {
         fun f4() = bar<T, Boolean>()
     }
 
-    return array(x.f1(), x.f2(), x.f3(), x.f4())
+    return arrayOf(x.f1(), x.f2(), x.f3(), x.f4())
 }
 
 fun box(): String {
     val result = foo<Double, Int>()
 
-    val expected = array(
+    val expected = arrayOf(
             Triple("java.lang.Double", "java.lang.Integer", "java.lang.Integer"),
             Triple("java.lang.Integer", "java.lang.Double", "java.lang.Integer"),
             Triple("java.lang.Boolean", "java.lang.Double", "java.lang.Integer"),

compiler/testData/codegen/boxWithStdlib/reified/spreads.kt

@@ -5,19 +5,19 @@ fun <T> foo(vararg a: T) = a.size()
 inline fun <reified T> bar(a: Array<T>, block: () -> T): Array<T> {
     assertEquals(4, foo(*a, block(), block()))
 
-    return array(*a, block(), block())
+    return arrayOf(*a, block(), block())
 }
 
-inline fun <reified T> empty() = array<T>()
+inline fun <reified T> empty() = arrayOf<T>()
 
 fun box(): String {
 
     var i = 0
-    val a: Array<String> = bar(array("1", "2")) { i++; i.toString() }
+    val a: Array<String> = bar(arrayOf("1", "2")) { i++; i.toString() }
     assertEquals("1234", a.join(""))
 
     i = 0
-    val b: Array<Int> = bar(array(0, 1)) { i++ }
+    val b: Array<Int> = bar(arrayOf(0, 1)) { i++ }
     assertEquals("0123", b.map { it.toString() }.join(""))
 
     return "OK"

compiler/testData/codegen/boxWithStdlib/reified/varargs.kt

@@ -5,10 +5,10 @@ fun <T> foo(vararg a: T) = a.size()
 inline fun <reified T> bar(block: () -> T): Array<T> {
     assertEquals(2, foo(block(), block()))
 
-    return array(block(), block(), block())
+    return arrayOf(block(), block(), block())
 }
 
-inline fun <reified T> empty() = array<T>()
+inline fun <reified T> empty() = arrayOf<T>()
 
 fun box(): String {
     var i = 0

compiler/testData/codegen/boxWithStdlib/storeStackBeforeInline/primitiveMerge.kt

@@ -9,7 +9,7 @@ inline fun foo() = "-"
 
 fun box(): String {
     val result1 = foobar1(if (1 == 1) true else bar(), foo(), "OK")
-    val result2 = foobar2(if (1 == 1) "true" else array("false"), foo(), "OK")
+    val result2 = foobar2(if (1 == 1) "true" else arrayOf("false"), foo(), "OK")
     assertEquals("true-OK", result1)
     assertEquals("true-OK", result2)
     return "OK"

compiler/testData/codegen/boxWithStdlib/toArray/copyToArray.kt

@@ -1,7 +1,7 @@
 import java.util.Arrays
 
 fun box(): String {
-    val array = Arrays.asList(2, 3, 9).copyToArray()
+    val array = Arrays.asList(2, 3, 9).toTypedArray()
     if (array !is Array<Int>) return array.javaClass.toString()
 
     val str = Arrays.toString(array)

compiler/testData/codegen/boxWithStdlib/toArray/kt3177-copyToArray.kt

@@ -6,7 +6,7 @@ fun box(): String {
     list.add(Pair("Sample", "http://cyber.law.harvard.edu/rss/examples/rss2sample.xml"))
     list.add(Pair("Scripting", "http://static.scripting.com/rss.xml"))
 
-    val keys = list.map { it.first }.copyToArray<String>()
+    val keys = list.map { it.first }.toTypedArray<String>()
 
     val keysToString = Arrays.toString(keys)
     if (keysToString != "[Sample, Scripting]") return keysToString

compiler/testData/codegen/boxWithStdlib/toArray/returnCopyToArray.kt

@@ -1,6 +1,6 @@
 import java.util.Arrays
 
-fun getCopyToArray(): Array<Int> = Arrays.asList(2, 3, 9).copyToArray()
+fun getCopyToArray(): Array<Int> = Arrays.asList(2, 3, 9).toTypedArray()
 
 fun box(): String {
     val str = Arrays.toString(getCopyToArray())

compiler/testData/codegen/boxWithStdlib/vararg/varargInFunParam.kt

@@ -3,43 +3,43 @@ fun box(): String {
     if (test1(1) != "1") return "fail 2"
     if (test1(1, 2) != "12") return "fail 3"
 
-    if (test1(*intArray()) != "") return "fail 4"
+    if (test1(*intArrayOf()) != "") return "fail 4"
-    if (test1(*intArray(1)) != "1") return "fail 5"
+    if (test1(*intArrayOf(1)) != "1") return "fail 5"
-    if (test1(*intArray(1, 2)) != "12") return "fail 6"
+    if (test1(*intArrayOf(1, 2)) != "12") return "fail 6"
 
     if (test1(p = 1) != "1") return "fail 7"
 
-    if (test1(p = *intArray()) != "") return "fail 8"
+    if (test1(p = *intArrayOf()) != "") return "fail 8"
-    if (test1(p = *intArray(1)) != "1") return "fail 9"
+    if (test1(p = *intArrayOf(1)) != "1") return "fail 9"
-    if (test1(p = *intArray(1, 2)) != "12") return "fail 10"
+    if (test1(p = *intArrayOf(1, 2)) != "12") return "fail 10"
 
     if (test2() != "") return "fail 11"
     if (test2("1") != "1") return "fail 12"
     if (test2("1", "2") != "12") return "fail 13"
 
-    if (test2(*array<String>()) != "") return "fail 14"
+    if (test2(*arrayOf<String>()) != "") return "fail 14"
-    if (test2(*array<String>("1")) != "1") return "fail 15"
+    if (test2(*arrayOf<String>("1")) != "1") return "fail 15"
-    if (test2(*array<String>("1", "2")) != "12") return "fail 16"
+    if (test2(*arrayOf<String>("1", "2")) != "12") return "fail 16"
 
     if (test2(p = "1") != "1") return "fail 17"
 
-    if (test2(p = *array<String>()) != "") return "fail 18"
+    if (test2(p = *arrayOf<String>()) != "") return "fail 18"
-    if (test2(p = *array<String>("1")) != "1") return "fail 19"
+    if (test2(p = *arrayOf<String>("1")) != "1") return "fail 19"
-    if (test2(p = *array<String>("1", "2")) != "12") return "fail 20"
+    if (test2(p = *arrayOf<String>("1", "2")) != "12") return "fail 20"
 
     if (test3<String>() != "") return "fail 21"
     if (test3("1") != "1") return "fail 22"
     if (test3("1", "2") != "12") return "fail 23"
 
-    if (test3(*array<String>()) != "") return "fail 24"
+    if (test3(*arrayOf<String>()) != "") return "fail 24"
-    if (test3(*array<String>("1")) != "1") return "fail 25"
+    if (test3(*arrayOf<String>("1")) != "1") return "fail 25"
-    if (test3(*array<String>("1", "2")) != "12") return "fail 26"
+    if (test3(*arrayOf<String>("1", "2")) != "12") return "fail 26"
 
     if (test3(p = "1") != "1") return "fail 27"
 
-    if (test3(p = *array<String>()) != "") return "fail 28"
+    if (test3(p = *arrayOf<String>()) != "") return "fail 28"
-    if (test3(p = *array<String>("1")) != "1") return "fail 29"
+    if (test3(p = *arrayOf<String>("1")) != "1") return "fail 29"
-    if (test3(p = *array<String>("1", "2")) != "12") return "fail 30"
+    if (test3(p = *arrayOf<String>("1", "2")) != "12") return "fail 30"
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/when/switchOptimizationDense.kt

@@ -17,7 +17,7 @@ fun dense(x: Int): Int {
 }
 
 fun box(): String {
-    var result = (-5..10).map(::dense).makeString()
+    var result = (-5..10).map(::dense).joinToString()
 
     if (result != "19, 9, 19, 19, 10, 11, 12, 19, 19, 13, 14, 15, 16, 17, 18, 19") return "dense:" + result
     return "OK"

compiler/testData/codegen/boxWithStdlib/when/switchOptimizationMultipleConditions.kt

@@ -8,7 +8,7 @@ fun foo(x: Int): Int {
 }
 
 fun box(): String {
-    var result = (0..10).map(::foo).makeString()
+    var result = (0..10).map(::foo).joinToString()
 
     if (result != "4, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4") return result
     return "OK"

compiler/testData/codegen/boxWithStdlib/when/switchOptimizationSparse.kt

@@ -10,7 +10,7 @@ fun sparse(x: Int): Int {
 }
 
 fun box(): String {
-    var result = (0..3).map(::sparse).makeString()
+    var result = (0..3).map(::sparse).joinToString()
 
     if (result != "4, 1, 2, 3") return "sparse:" + result
     return "OK"

compiler/testData/codegen/boxWithStdlib/when/switchOptimizationStatement.kt

@@ -22,11 +22,11 @@ fun nonExhaustive(x: Int): Int {
 }
 
 fun box(): String {
-    var result = (0..3).map(::exhaustive).makeString()
+    var result = (0..3).map(::exhaustive).joinToString()
 
     if (result != "4, 1, 2, 3") return "exhaustive:" + result
 
-    result = (0..3).map(::nonExhaustive).makeString()
+    result = (0..3).map(::nonExhaustive).joinToString()
 
     if (result != "4, 1, 2, 3") return "non-exhaustive:" + result
     return "OK"

compiler/testData/codegen/boxWithStdlib/when/switchOptimizationTypes.kt

@@ -35,19 +35,19 @@ fun charFoo(x: Char): Int {
 }
 
 fun box(): String {
-    var result = (1..4).map(::intFoo).makeString()
+    var result = (1..4).map(::intFoo).joinToString()
 
     if (result != "5, 6, 7, 8") return "int:" + result
 
-    result = (1.toShort()..4.toShort()).map(::shortFoo).makeString()
+    result = (1.toShort()..4.toShort()).map(::shortFoo).joinToString()
 
     if (result != "5, 6, 7, 8") return "short:" + result
 
-    result = (1.toByte()..4.toByte()).map(::byteFoo).makeString()
+    result = (1.toByte()..4.toByte()).map(::byteFoo).joinToString()
 
     if (result != "5, 6, 7, 8") return "byte:" + result
 
-    result = ('a'..'d').map(::charFoo).makeString()
+    result = ('a'..'d').map(::charFoo).joinToString()
 
     if (result != "5, 6, 7, 8") return "int:" + result
     return "OK"

compiler/testData/codegen/boxWithStdlib/when/switchOptimizationUnordered.kt

@@ -8,7 +8,7 @@ fun foo(x: Int): Int {
 }
 
 fun box(): String {
-    var result = (0..3).map(::foo).makeString()
+    var result = (0..3).map(::foo).joinToString()
 
     if (result != "8, 5, 6, 7") return "unordered:" + result
     return "OK"