Fix deprecations in testData: arrayOf usages.

compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt

@@ -7,8 +7,8 @@ annotation class Ann(
         val a: Ann2 = Ann2(),
         val e: MyEnum = MyEnum.A,
         val c: KClass<*> = A::class,
-        val ia: IntArray = intArray(1, 2),
-        val sa: Array<String> = array("a", "b")
+        val ia: IntArray = intArrayOf(1, 2),
+        val sa: Array<String> = arrayOf("a", "b")
 )
 
 fun box(): String {

compiler/testData/codegen/boxWithStdlib/annotations/varargInAnnotationParameter.kt

@@ -5,15 +5,15 @@ annotation class Ann(vararg val p: Int)
 @Ann(1) class MyClass2
 @Ann(1, 2) class MyClass3
 
-@Ann(*intArray()) class MyClass4
-@Ann(*intArray(1)) class MyClass5
-@Ann(*intArray(1, 2)) class MyClass6
+@Ann(*intArrayOf()) class MyClass4
+@Ann(*intArrayOf(1)) class MyClass5
+@Ann(*intArrayOf(1, 2)) class MyClass6
 
 @Ann(p = 1) class MyClass7
 
-@Ann(p = *intArray()) class MyClass8
-@Ann(p = *intArray(1)) class MyClass9
-@Ann(p = *intArray(1, 2)) class MyClass10
+@Ann(p = *intArrayOf()) class MyClass8
+@Ann(p = *intArrayOf(1)) class MyClass9
+@Ann(p = *intArrayOf(1, 2)) class MyClass10
 
 fun box(): String {
     test(javaClass<MyClass1>(), "")

compiler/testData/codegen/boxWithStdlib/arrays/cloneArray.kt

@@ -1,13 +1,13 @@
 import java.util.Arrays.equals
 
 fun box(): String {
-    val s = array("live", "long")
+    val s = arrayOf("live", "long")
     val t = s.clone()
     t : Array<String>
     if (!equals(s, t)) return "Fail string"
     if (s identityEquals t) return "Fail string identity"
 
-    val ss = array(s, s)
+    val ss = arrayOf(s, s)
     val tt = ss.clone()
     tt : Array<Array<String>>
     if (!equals(ss, tt)) return "Fail string[]"

compiler/testData/codegen/boxWithStdlib/arrays/clonePrimitiveArrays.kt

@@ -1,35 +1,35 @@
 import java.util.Arrays.equals
 
 fun box(): String {
-    val i = intArray(1, 2)
+    val i = intArrayOf(1, 2)
     if (!equals(i, i.clone())) return "Fail int"
     if (i.clone() identityEquals i) return "Fail int identity"
 
-    val j = longArray(1L, 2L)
+    val j = longArrayOf(1L, 2L)
     if (!equals(j, j.clone())) return "Fail long"
     if (j.clone() identityEquals j) return "Fail long identity"
 
-    val s = shortArray(1.toShort(), 2.toShort())
+    val s = shortArrayOf(1.toShort(), 2.toShort())
     if (!equals(s, s.clone())) return "Fail short"
     if (s.clone() identityEquals s) return "Fail short identity"
 
-    val b = byteArray(1.toByte(), 2.toByte())
+    val b = byteArrayOf(1.toByte(), 2.toByte())
     if (!equals(b, b.clone())) return "Fail byte"
     if (b.clone() identityEquals b) return "Fail byte identity"
 
-    val c = charArray('a', 'b')
+    val c = charArrayOf('a', 'b')
     if (!equals(c, c.clone())) return "Fail char"
     if (c.clone() identityEquals c) return "Fail char identity"
 
-    val d = doubleArray(1.0, -1.0)
+    val d = doubleArrayOf(1.0, -1.0)
     if (!equals(d, d.clone())) return "Fail double"
     if (d.clone() identityEquals d) return "Fail double identity"
 
-    val f = floatArray(1f, -1f)
+    val f = floatArrayOf(1f, -1f)
     if (!equals(f, f.clone())) return "Fail float"
     if (f.clone() identityEquals f) return "Fail float identity"
 
-    val z = booleanArray(true, false)
+    val z = booleanArrayOf(true, false)
     if (!equals(z, z.clone())) return "Fail boolean"
     if (z.clone() identityEquals z) return "Fail boolean identity"
 

compiler/testData/codegen/boxWithStdlib/arrays/inProjectionAsParameter.kt

@@ -1,9 +1,9 @@
 fun test(y: Array<in Array<String>>) {
-    y[0] = kotlin.array("OK")
+    y[0] = kotlin.arrayOf("OK")
 }
 
 fun box() : String {
-    val x : Array<Array<*>> = kotlin.array(kotlin.array(1))
+    val x : Array<Array<*>> = kotlin.arrayOf(kotlin.arrayOf(1))
     test(x)
     return x[0][0] as String
 }

compiler/testData/codegen/boxWithStdlib/arrays/inProjectionOfArray.kt

@@ -1,10 +1,10 @@
 fun box(): String {
-    val x : Array<Array<*>> = array(array(1))
+    val x : Array<Array<*>> = arrayOf(arrayOf(1))
     val y : Array<in Array<String>> = x
 
     if (y.size() != 1) return "fail 1"
 
-    y[0] = array("OK")
+    y[0] = arrayOf("OK")
 
     return x[0][0] as String
 }

compiler/testData/codegen/boxWithStdlib/arrays/inProjectionOfList.kt

@@ -1,5 +1,5 @@
 fun box(): String {
-    val x: Array<List<*>> = array(listOf(1))
+    val x: Array<List<*>> = arrayOf(listOf(1))
     val y : Array<in List<String>> = x
 
     if (y.size() != 1) return "fail 1"

compiler/testData/codegen/boxWithStdlib/arrays/kt3771.kt

@@ -5,7 +5,7 @@ fun fill(dest : Array<in String>, v : String) {
 fun box() : String {
 //fun main(args : Array<String>) {
     val s : String = "bar"
-    val any : Array<Any> = array(1, "foo", 1.234)
+    val any : Array<Any> = arrayOf(1, "foo", 1.234)
     fill(any, s)
     /* shouldn't throw
 ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

compiler/testData/codegen/boxWithStdlib/arrays/kt4357.kt

@@ -1,8 +1,8 @@
 fun box(): String {
-    val array = intArray(11, 12, 13)
+    val array = intArrayOf(11, 12, 13)
     val p = array get 0
     if (p != 11) return "fail 1: $p"
 
-    val stringArray = array("OK", "FAIL")
+    val stringArray = arrayOf("OK", "FAIL")
     return stringArray get 0
 }

compiler/testData/codegen/boxWithStdlib/arrays/kt7009.kt

@@ -1,4 +1,4 @@
 fun box() : String {
-    val value = (1 to doubleArray(1.0)).second[0]
+    val value = (1 to doubleArrayOf(1.0)).second[0]
     return if (value == 1.0) "OK" else "fail"
 }

compiler/testData/codegen/boxWithStdlib/arrays/kt7338.kt

@@ -3,5 +3,5 @@ fun foo(x : Any): String {
 }
 
 fun box(): String {
-    return foo(array("OK"))
+    return foo(arrayOf("OK"))
 }

compiler/testData/codegen/boxWithStdlib/callableReference/property/extensionToArray.kt

@@ -2,5 +2,5 @@ val Array<String>.firstElement: String get() = get(0)
 
 fun box(): String {
     val p = Array<String>::firstElement
-    return p.get(array("OK", "Fail"))
+    return p.get(arrayOf("OK", "Fail"))
 }