Fix deprecations in testData: js semantics.

js/js.translator/testData/closure/cases/closureThisAndReceiver.kt

@@ -4,7 +4,7 @@ class A(val a: String) {
     fun A.foo() = { a + this.a + this@foo.a + this@A.a }()
     fun bar(a: A) = this.foo() + " " + a.foo()
 
-    fun A.boo() = { array(this, this@boo, this@A) }()
+    fun A.boo() = { arrayOf(this, this@boo, this@A) }()
     fun baz(a: A) = this.boo().stringify() + " " + a.boo().stringify()
 
     fun Array<A>.stringify(): String {

js/js.translator/testData/dynamic/cases/iterator.kt

@@ -23,8 +23,8 @@ fun test(expected: Int, d: dynamic, case: String) {
 }
 
 fun box(): String {
-    test(6, array(1, 2, 3), "array")
+    test(6, arrayOf(1, 2, 3), "array")
-    test(64, byteArray(42, 22), "byte array")
+    test(64, byteArrayOf(42, 22), "byte array")
     test(66, listOf(55, 3, 8), "list")
     test(167, setOf(55, 3, 8, 101), "set")
 

js/js.translator/testData/enum/cases/standardMethods.kt

@@ -27,9 +27,9 @@ fun box(): String {
     if (!ok2.identityEquals(ok)) return "ok2 not identity equal ok"
 
 
-    if (EmptyEnum.values().size != 0) return "EmptyEnum.values().size != 0"
+    if (EmptyEnum.values().size() != 0) return "EmptyEnum.values().size != 0"
 
-    if (A.values() != array(A.a, A.b, A.c)) return "Wrong A.values(): " + A.values().toString()
+    if (A.values() != arrayOf(A.a, A.b, A.c)) return "Wrong A.values(): " + A.values().toString()
 
     if (A.c.toString() != "c") return "A.c.toString() != c, it: ${A.c.toString()}"
     if (A.valueOf("b") != A.b) return "A.valueOf('b') != A.b"

js/js.translator/testData/expression/evaluationOrder/cases/assignToArrayElementWithSideEffect.kt

@@ -17,7 +17,7 @@ val baz: Int
     }
 
 fun box(): String {
-    val a = array(0,1,2,3)
+    val a = arrayOf(0,1,2,3)
 
 
     global = ""

js/js.translator/testData/expression/evaluationOrder/cases/callVarargs.kt

@@ -8,7 +8,7 @@ fun bar<T>(s: String, value: T): T {
 }
 
 fun baz<T>(vararg args: T): String {
-    return "baz: ${args.size}"
+    return "baz: ${args.size()}"
 }
 
 fun idVarArg<T>(vararg a: T) = a
@@ -22,7 +22,7 @@ fun box(): String {
     assertEquals("AB", global)
 
     global = ""
-    assertEquals("baz: 4", baz(bar("A", 1), *try {bar("B", array(2, 3))} catch(e: Exception) { bar("C", array(4, 5))}, bar("D", 6)))
+    assertEquals("baz: 4", baz(bar("A", 1), *try {bar("B", arrayOf(2, 3))} catch(e: Exception) { bar("C", arrayOf(4, 5))}, bar("D", 6)))
     assertEquals("ABD", global)
 
     return "OK"

js/js.translator/testData/expression/evaluationOrder/cases/intrinsicWithBreakContinueReturn.kt

@@ -57,7 +57,7 @@ fun box(): String {
     assertEquals(2, i, "break 5")
 
     i = 0
-    var bVarArray = array(true, false)
+    var bVarArray = arrayOf(true, false)
     while(i++<5) {
         if (i==2) {
             bVarArray[try { global += "A"; 0} finally {}] = 10 < (break as Int)

js/js.translator/testData/expression/evaluationOrder/cases/whenJsLiteralWithSideEffect.kt

@@ -8,9 +8,9 @@ fun bar(s: String): Int {
 }
 fun testWhen() {
     global = ""
-    when(array(bar("A"),2,3)) {
+    when(arrayOf(bar("A"),2,3)) {
-        array(1) -> println("1")
+        arrayOf(1) -> println("1")
-        array(2) -> println("2")
+        arrayOf(2) -> println("2")
         else  -> println("else")
     }
     assertEquals("A", global)
@@ -19,13 +19,13 @@ fun testWhen() {
 
 fun testIntrinsic() {
     global = ""
-    val x = array(bar("A")) == try { array(bar("B")) } finally {}
+    val x = arrayOf(bar("A")) == try { arrayOf(bar("B")) } finally {}
     assertEquals("AB", global)
 }
 
 fun testElvis() {
     global = ""
-    var x = array(bar("A")) ?: 10
+    var x = arrayOf(bar("A")) ?: 10
     assertEquals("A", global)
 }
 

js/js.translator/testData/expression/for/cases/forIteratesOverArray.kt

@@ -20,12 +20,12 @@ fun box(): Boolean {
     assertEquals(8, d)
 
     var s: String = ""
-    for(i in array(0,1,2))
+    for(i in arrayOf(0,1,2))
         try { s += "A${i}:"} finally {}
     assertEquals("A0:A1:A2:", s)
 
     var sLong = 0L
-    var aLong = longArray(1,2,3,4,5,6,7,8,9,10)
+    var aLong = longArrayOf(1,2,3,4,5,6,7,8,9,10)
     for(i in aLong)
         sLong += i
     assertEquals(55L, sLong)

js/js.translator/testData/expression/for/cases/labeledFor.kt

@@ -4,8 +4,8 @@ val a1 = arrayOfNulls<Int>(0)
 
 fun box(): Boolean {
     var bar = 33
-    outer@ for (a in array(1, 2)) {
+    outer@ for (a in arrayOf(1, 2)) {
-        for (b in array(1, 4)) {
+        for (b in arrayOf(1, 4)) {
             break@outer
         }
         bar = 42

js/js.translator/testData/expression/function/cases/mangling.kt

@@ -142,7 +142,7 @@ val CALEE_NAME = RegExp("""\b\w*(baz[^(]*)""")
 fun Function0<Unit>.extractNames(): Array<String> {
     val names = CALEE_NAME.exec(this.toString())
 
-    if (names == null || names.size != 2) {
+    if (names == null || names.size() != 2) {
         throw Exception("Cannot extract function name, $names for actual = \"$this\"")
     }
 

js/js.translator/testData/expression/function/cases/manglingAnyMethods.kt

@@ -39,7 +39,7 @@ val CALEE_NAME = RegExp("""((?:equals|hashCode|toString)[^(]*)""")
 fun <T> Function0<T>.extractNames(): Array<String> {
     val names = CALEE_NAME.exec(this.toString(): String)
 
-    if (names == null || names.size != 2) {
+    if (names == null || names.size() != 2) {
         throw Exception("Cannot extract function name, $names for actual = \"$this\"")
     }
 

js/js.translator/testData/expression/function/cases/vararg.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun testSize(expectedSize: Int, vararg i: Int): Boolean {
-    return (i.size == expectedSize)
+    return (i.size() == expectedSize)
 }
 
 fun testSum(expectedSum: Int, vararg i: Int): Boolean {
@@ -17,7 +17,7 @@ fun testSpreadOperator(vararg args: Int): Boolean {
     var sum = 0;
     for (a in args) sum += a
 
-    return testSize(args.size, *args) && testSum(sum, *args)
+    return testSize(args.size(), *args) && testSum(sum, *args)
 }
 
 class Bar(val size: Int, val sum: Int) {
@@ -74,34 +74,34 @@ fun box(): String {
     if (!spreadInObjectMethodCall(2, 3, 1, 2))
         return "failed when call method of object using spread operator"
 
-    if (!testVarargWithFunLit(1, 2, 3) { args -> args.size == 3 })
+    if (!testVarargWithFunLit(1, 2, 3) { args -> args.size() == 3 })
         return "failed when call function with vararg and fun literal"
 
-    val a = array(1, 2, 3)
+    val a = arrayOf(1, 2, 3)
-    val b = array(4, 5)
+    val b = arrayOf(4, 5)
 
-    assertEquals(5, array(*a, *b).size)
+    assertEquals(5, arrayOf(*a, *b).size())
-    assertEquals(8, array(10, *a, 20,  *b, 30).size)
+    assertEquals(8, arrayOf(10, *a, 20,  *b, 30).size())
 
-    assertEquals(5, idVarArgs(*a, *b).size)
+    assertEquals(5, idVarArgs(*a, *b).size())
-    assertEquals(8, idVarArgs(10, *a, 20,  *b, 30).size)
+    assertEquals(8, idVarArgs(10, *a, 20,  *b, 30).size())
 
-    assertEquals(9, array(1, *a, *a, 1, 2).size)
+    assertEquals(9, arrayOf(1, *a, *a, 1, 2).size())
-    assertEquals(9, idVarArgs(1, *a, *a, 1, 2).size)
+    assertEquals(9, idVarArgs(1, *a, *a, 1, 2).size())
 
-    assertEquals(9, array(1, *a, *array(1, 2, 3), 1, 2).size)
+    assertEquals(9, arrayOf(1, *a, *arrayOf(1, 2, 3), 1, 2).size())
-    assertEquals(9, idVarArgs(1, *a, *array(1, 2, 3), 1, 2).size)
+    assertEquals(9, idVarArgs(1, *a, *arrayOf(1, 2, 3), 1, 2).size())
 
     assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, 5, 6, 7, 8, 9) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4, 5, 6, 7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5, 6, 7, 8, 9)) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, *intArray(5, 6, 7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, *intArrayOf(5, 6, 7, 8, 9)) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4, 5, 6, 7), 8, 9) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5, 6, 7), 8, 9) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4, 5), *intArray(6, 7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5), *intArrayOf(6, 7, 8, 9)) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4), 5, 6, *intArray(7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4), 5, 6, *intArrayOf(7, 8, 9)) { 2*it })
 
-    assertEquals(2, idArrayVarArg(array(1), *array(array(2, 3, 4))).size())
+    assertEquals(2, idArrayVarArg(arrayOf(1), *arrayOf(arrayOf(2, 3, 4))).size())
-    assertEquals(3, idArrayVarArg(array(1, 2), *array(array(3, 4), array(5, 6))).size())
+    assertEquals(3, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6))).size())
-    assertEquals(6, idArrayVarArg(array(1, 2), *array(array(3, 4), array(5, 6)), array(7), *array(array(8, 9), array(10, 11))).size())
+    assertEquals(6, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6)), arrayOf(7), *arrayOf(arrayOf(8, 9), arrayOf(10, 11))).size())
 
     return "OK"
 }

js/js.translator/testData/expression/misc/cases/elvisReturnSimple.kt

@@ -8,7 +8,7 @@ package foo
 
 fun stringLen(s : String?) : Int {
     val s1 : String = s ?: return 0
-    return s1.length
+    return s1.length()
 }
 
 fun stringReturnInLeftLen(s : String?) : Int {

js/js.translator/testData/expression/string/cases/extensionMethods.kt

@@ -23,7 +23,6 @@ fun assertEquals(expected: Any, actual: Any, s: CharSequence, whatTested: String
 fun testString(s: String, expectedSize: Int, indexOfB: Int) {
     assertEquals(expectedSize, s.size, s, "size")
     assertEquals(expectedSize, s.length(), s, "length()")
-    assertEquals(expectedSize, s.length, s, "length")
     assertEquals(expectedSize == 0, s.isEmpty(), s, "isEmpty()")
     assertEquals(expectedSize != 0, s.startsWith(startsWithParam), s, "startsWith(\"$startsWithParam\")")
     assertEquals(expectedSize != 0, s.endsWith(endsWithParam), s, "endsWith(\"$endsWithParam\")")
@@ -37,7 +36,6 @@ fun testString(s: String, expectedSize: Int, indexOfB: Int) {
 fun testCharSequence(s: CharSequence, expectedSize: Int) {
     assertEquals(expectedSize, s.size, s, "size")
     assertEquals(expectedSize, s.length(), s, "length()")
-    assertEquals(expectedSize, s.length, s, "length")
     assertEquals(expectedSize == 0, s.isEmpty(), s, "isEmpty()")
 }
 

js/js.translator/testData/expression/string/cases/stringSplit.kt

@@ -2,11 +2,11 @@ package foo
 
 fun box(): String {
     val testInput = "test data\t1foo  2 bar"
-    val tests = array(
+    val tests = arrayOf(
-            " "     to array("test", "data\t1foo", "", "2", "bar"),
+            " "     to arrayOf("test", "data\t1foo", "", "2", "bar"),
-            "\\s+"  to array("test", "data", "1foo", "2", "bar"),
+            "\\s+"  to arrayOf("test", "data", "1foo", "2", "bar"),
-            "[sd]"  to array("te", "t ", "ata\t1foo  2 bar"),
+            "[sd]"  to arrayOf("te", "t ", "ata\t1foo  2 bar"),
-            "[\\d]" to array("test data\t", "foo  ", " bar")
+            "[\\d]" to arrayOf("test data\t", "foo  ", " bar")
     )
 
     for (test in tests) {

js/js.translator/testData/expression/when/cases/forWithOneStmWhen.kt

@@ -3,7 +3,7 @@ package foo
 
 fun box(): Boolean {
     var result = false
-    for (i in array(1))
+    for (i in arrayOf(1))
         when (i) {
             1 -> result = true
             else -> result = false

js/js.translator/testData/extensionProperty/cases/simplePropertyWithGetter.kt

@@ -1,7 +1,7 @@
 package foo
 
 val String.prop: Int
-    get() = length
+    get() = length()
 
 val Int.quadruple: Int
     get() = this * 4

js/js.translator/testData/inheritance/cases/inheritFromCharIterator.kt

@@ -1,10 +1,10 @@
 package foo
 
 class MyCharIterator : CharIterator() {
-    val data = array('O', 'K')
+    val data = arrayOf('O', 'K')
     var i = 0
 
-    override fun hasNext(): Boolean = i < data.size
+    override fun hasNext(): Boolean = i < data.size()
     override fun nextChar(): Char = data[i++]
 }
 

js/js.translator/testData/inline/cases/arrayLiteralAliasing.kt

@@ -9,7 +9,7 @@ package foo
 data class PairArray<T, R>(val fst: Array<T>, val snd: Array<R>)
 
 inline fun moveTo(source: Array<Int>, sink: Array<Int>): PairArray<Int, Int> {
-    val size = source.size
+    val size = source.size()
     for (i in 1..size) {
         val element = source[0]
         source.splice(0, 1)
@@ -20,8 +20,8 @@ inline fun moveTo(source: Array<Int>, sink: Array<Int>): PairArray<Int, Int> {
 }
 
 fun box(): String {
-    val expected = PairArray<Int, Int>(array(), array(1,2,3,4))
+    val expected = PairArray<Int, Int>(arrayOf(), arrayOf(1,2,3,4))
-    assertEquals(expected, moveTo(array(3, 4),  array(1, 2)))
+    assertEquals(expected, moveTo(arrayOf(3, 4),  arrayOf(1, 2)))
 
     return "OK"
 }

js/js.translator/testData/inline/cases/astCopy.kt

@@ -8,7 +8,7 @@ inline fun syntaxTestInline() {
     for (i in 1..10)
         result += 1
 
-    for (i in array(10).indices)
+    for (i in arrayOf(10).indices)
         result += i
 
     while (result < 30)

js/js.translator/testData/inline/cases/inlineLambdaNoCapture.kt

@@ -20,9 +20,9 @@ internal fun sumEven(a: Array<Int>): Int {
 }
 
 fun box(): String {
-    assertEquals(0, sumEven(array()))
+    assertEquals(0, sumEven(arrayOf()))
-    assertEquals(6, sumEven(array(1,2,3,4)))
+    assertEquals(6, sumEven(arrayOf(1,2,3,4)))
-    assertEquals(12, sumEven(array(1,2,3,4,6,7,9)))
+    assertEquals(12, sumEven(arrayOf(1,2,3,4,6,7,9)))
 
     return "OK"
 }

js/js.translator/testData/inline/cases/inlineLambdaWithCapture.kt

@@ -31,10 +31,10 @@ internal fun maxBySquare(a: Array<Int>, r: Result): Result {
 }
 
 fun box(): String {
-    var r1 = maxBySquare(array(1,2,3,4,5), Result())
+    var r1 = maxBySquare(arrayOf(1,2,3,4,5), Result())
     assertEquals(Result(5, 6), r1)
 
-    var r2 = maxBySquare(array(-5,1,2,3,4), Result())
+    var r2 = maxBySquare(arrayOf(-5,1,2,3,4), Result())
     assertEquals(Result(-5, 6), r2)
 
     return "OK"

js/js.translator/testData/inline/cases/vararg.kt

@@ -30,7 +30,7 @@ internal fun test3(list: Array<String>): String {
 fun box(): String {
     assertEquals("", test1())
     assertEquals("abc", test2())
-    assertEquals("abcd", test3(array("a", "b", "c", "d")))
+    assertEquals("abcd", test3(arrayOf("a", "b", "c", "d")))
 
     return "OK"
 }

js/js.translator/testData/inlineEvaluationOrder/cases/arrayAccess1.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    assertEquals(2, fizz(array(1, 2))[buzz(1)])
+    assertEquals(2, fizz(arrayOf(1, 2))[buzz(1)])
     assertEquals("fizz(1,2);buzz(1);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineEvaluationOrder/cases/arrayAccess2.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    assertEquals(2, array(1, 2)[fizz(0) + buzz(1)])
+    assertEquals(2, arrayOf(1, 2)[fizz(0) + buzz(1)])
     assertEquals("fizz(0);buzz(1);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineEvaluationOrder/cases/arrayAccess3.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    assertEquals(2, array(1, fizz(2))[fizz(0) + buzz(1)])
+    assertEquals(2, arrayOf(1, fizz(2))[fizz(0) + buzz(1)])
     assertEquals("fizz(2);fizz(0);buzz(1);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineEvaluationOrder/cases/arrayLiteral.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    assertEquals(array(1, 2), array(fizz(1), buzz(2)))
+    assertEquals(arrayOf(1, 2), arrayOf(fizz(1), buzz(2)))
     assertEquals("fizz(1);buzz(2);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineEvaluationOrder/cases/arrayLiteralMultipleInlineCalls.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    assertEquals(array(1, 2, 3, 4), array(fizz(1), buzz(2), fizz(3), buzz(4)))
+    assertEquals(arrayOf(1, 2, 3, 4), arrayOf(fizz(1), buzz(2), fizz(3), buzz(4)))
     assertEquals("fizz(1);buzz(2);fizz(3);buzz(4);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineEvaluationOrder/cases/arrayLiteralNested.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    assertEquals(array(array(1, 2), array(3, 4)), array(array(fizz(1), buzz(2)), array(fizz(3), buzz(4))))
+    assertEquals(arrayOf(arrayOf(1, 2), arrayOf(3, 4)), arrayOf(arrayOf(fizz(1), buzz(2)), arrayOf(fizz(3), buzz(4))))
     assertEquals("fizz(1);buzz(2);fizz(3);buzz(4);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineEvaluationOrder/cases/callQualifierComplex.kt

@@ -14,7 +14,7 @@ fun multiplyFunInline(): (Int, Int)->Int {
 }
 
 fun box(): String {
-    assertEquals(6, array(multiplyFun(), multiplyFunInline())[0](fizz(2), fizz(3)))
+    assertEquals(6, arrayOf(multiplyFun(), multiplyFunInline())[0](fizz(2), fizz(3)))
     assertEquals("multiplyFun();multiplyFunInline();fizz(2);fizz(3);", pullLog())
 
     return "OK"

js/js.translator/testData/inlineMultiFile/cases/builders/builders.1.kt

@@ -6,7 +6,7 @@
 package foo
 
 fun testAllInline() : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             html {
                 val htmlVal = 0
@@ -46,7 +46,7 @@ fun testAllInline() : String {
 }
 
 fun testHtmlNoInline() : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             htmlNoInline() {
                 val htmlVal = 0
@@ -86,7 +86,7 @@ fun testHtmlNoInline() : String {
 }
 
 fun testBodyNoInline() : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             html {
                 val htmlVal = 0
@@ -126,7 +126,7 @@ fun testBodyNoInline() : String {
 }
 
 fun testBodyHtmlNoInline() : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             htmlNoInline {
                 val htmlVal = 0

js/js.translator/testData/inlineMultiFile/cases/buildersAndLambdaCapturing/buildersAndLambdaCapturing.1.kt

@@ -8,7 +8,7 @@ package foo
 import kotlin.InlineOption.*
 
 inline fun testAllInline(f: () -> String) : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             html {
                 val htmlVal = 0
@@ -48,7 +48,7 @@ inline fun testAllInline(f: () -> String) : String {
 }
 
 inline fun testHtmlNoInline(crossinline f: () -> String) : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             htmlNoInline() {
                 val htmlVal = 0
@@ -88,7 +88,7 @@ inline fun testHtmlNoInline(crossinline f: () -> String) : String {
 }
 
 inline fun testBodyNoInline(crossinline f: () -> String) : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             html {
                 val htmlVal = 0
@@ -128,7 +128,7 @@ inline fun testBodyNoInline(crossinline f: () -> String) : String {
 }
 
 inline fun testBodyHtmlNoInline(crossinline f: () -> String) : String {
-    val args = array("1", "2", "3")
+    val args = arrayOf("1", "2", "3")
     val result =
             htmlNoInline {
                 val htmlVal = 0

js/js.translator/testData/inlineMultiFile/cases/closureChain/closureChain.1.kt

@@ -7,7 +7,7 @@ package foo
 
 fun test1(): Int {
     val inlineX = Inline()
-    return inlineX.foo({ z: Int -> "" + z}, 25, {String.() -> this.length})
+    return inlineX.foo({ z: Int -> "" + z}, 25, { String.() -> this.length() })
 }
 
 fun box(): String {

js/js.translator/testData/java/arrayList/cases/misc.kt

@@ -42,7 +42,7 @@ fun box(): Boolean {
     assertEquals(true, a.isEmpty(), "a.isEmpty()")
 
 
-    assertEquals(array(1, 500, 2, 3), list.toTypedArray(), "list.copyToArray()")
+    assertEquals(arrayOf(1, 500, 2, 3), list.toTypedArray(), "list.toTypedArray()")
     assertEquals("[1,500,2,3]", JSON.stringify(list), "JSON.stringify(list)")
     assertEquals("[1, 500, 2, 3]", list.toString(), "list.toString()")
     return true;

js/js.translator/testData/jsCode/cases/forIn.kt

@@ -11,8 +11,8 @@ fun countKeys(a: Array<Int>): Int = js("""
 """)
 
 fun box(): String {
-    assertEquals(3, countKeys(array(1,2,3)))
+    assertEquals(3, countKeys(arrayOf(1,2,3)))
-    assertEquals(4, countKeys(array(1,2,3,4)))
+    assertEquals(4, countKeys(arrayOf(1,2,3,4)))
 
     return "OK"
 }

js/js.translator/testData/jsCode/cases/literal.kt

@@ -5,8 +5,8 @@ package foo
 }
 
 fun assertArrayEquals<T>(expected: Array<T>, actual: Array<T>) {
-    val expectedSize = expected.size
+    val expectedSize = expected.size()
-    val actualSize = actual.size
+    val actualSize = actual.size()
 
     if (expectedSize != actualSize) {
         throw Exception("expected size -- $expectedSize, actual size -- $actualSize")
@@ -32,7 +32,7 @@ fun box(): String {
     val obj: HasName = js("({name: 'OBJ'})")
     assertEquals("OBJ", obj.name, "Object")
 
-    assertArrayEquals(array(1, 2, 3), js("[1, 2, 3]"))
+    assertArrayEquals(arrayOf(1, 2, 3), js("[1, 2, 3]"))
 
     return "OK"
 }

js/js.translator/testData/native/cases/vararg.kt

@@ -56,7 +56,7 @@ fun testSpreadOperatorWithSureCall(a: Bar?, vararg args: Int): Boolean {
 
 fun testCallOrder(vararg args: Int) =
         Bar.startNewTest() &&
-        Bar(args.size, 0).test(1, 1, *args) && Bar(args.size, 2).test(3, 1, *args) &&
+        Bar(args.size(), 0).test(1, 1, *args) && Bar(args.size(), 2).test(3, 1, *args) &&
         !Bar.hasOrderProblem
 
 @native
@@ -105,7 +105,7 @@ fun box(): String {
     if (!spreadInPackageMethodCall(2, 1, 2))
         return "failed when call package method using spread operator"
 
-    if (!(testNativeVarargWithFunLit(1, 2, 3) { args -> args.size == 3 }))
+    if (!(testNativeVarargWithFunLit(1, 2, 3) { args -> args.size() == 3 }))
         return "failed when call native function with vararg and fun literal"
 
     if (!(testSpreadOperatorWithSafeCall(null, null)))
@@ -127,23 +127,23 @@ fun box(): String {
     if (!(baz!!)?.test(0, 1, 1))
         return "failed when combined SureCall and SafeCall, maybe we lost cached expression"
 
-    val a = array(1, 2)
+    val a = arrayOf(1, 2)
     assertEquals(2, genericParamCount(*a))
     assertEquals(7, genericParamCount(1, *a, *a, 1, 2))
 
     assertEquals(45, sumOfParameters(1, 2, 3, 4, 5, 6, 7, 8, 9))
-    assertEquals(45, sumOfParameters(1, 2, *intArray(3, 4, 5, 6, 7, 8, 9)))
+    assertEquals(45, sumOfParameters(1, 2, *intArrayOf(3, 4, 5, 6, 7, 8, 9)))
-    assertEquals(45, sumOfParameters(1, 2, 3, 4, *intArray(5, 6, 7, 8, 9)))
+    assertEquals(45, sumOfParameters(1, 2, 3, 4, *intArrayOf(5, 6, 7, 8, 9)))
     assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, 5, 6, 7, 8, 9) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4, 5, 6, 7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5, 6, 7, 8, 9)) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, *intArray(5, 6, 7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, *intArrayOf(5, 6, 7, 8, 9)) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4, 5, 6, 7), 8, 9) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5, 6, 7), 8, 9) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4, 5), *intArray(6, 7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5), *intArrayOf(6, 7, 8, 9)) { 2*it })
-    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArray(3, 4), 5, 6, *intArray(7, 8, 9)) { 2*it })
+    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4), 5, 6, *intArrayOf(7, 8, 9)) { 2*it })
 
-    assertEquals(2, idArrayVarArg(array(1), *array(array(2, 3, 4))).size())
+    assertEquals(2, idArrayVarArg(arrayOf(1), *arrayOf(arrayOf(2, 3, 4))).size())
-    assertEquals(3, idArrayVarArg(array(1, 2), *array(array(3, 4), array(5, 6))).size())
+    assertEquals(3, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6))).size())
-    assertEquals(6, idArrayVarArg(array(1, 2), *array(array(3, 4), array(5, 6)), array(7), *array(array(8, 9), array(10, 11))).size())
+    assertEquals(6, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6)), arrayOf(7), *arrayOf(arrayOf(8, 9), arrayOf(10, 11))).size())
 
     return "OK"
 }

js/js.translator/testData/number/cases/longArray.kt

@@ -5,14 +5,14 @@ fun box(): String {
     val arr = LongArray(2)
 
     val expected: Long = 0
-    assertEquals(arr.size, 2)
+    assertEquals(arr.size(), 2)
     assertEquals(expected, arr[0])
     assertEquals(expected, arr[1])
 
     arr[0] = 2432902008176640000L
     assertEquals(2432902008176640000L, arr[0])
 
-    val arr1 = longArray(1,2,3, 2432902008176640000L)
+    val arr1 = longArrayOf(1,2,3, 2432902008176640000L)
     assertEquals(1L, arr1[0])
     assertEquals(2L, arr1[1])
     assertEquals(3L, arr1[2])

js/js.translator/testData/standardClasses/cases/arrayFactoryMethods.kt

@@ -9,15 +9,15 @@ fun test(testName: String, actual: Any, expectedAsString: String) {
 
 fun box(): String {
     try {
-        test("array", array(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("arrayOf", arrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
-        test("booleanArray", booleanArray(true, false, false, true, true), "true, false, false, true, true")
+        test("booleanArrayOf", booleanArrayOf(true, false, false, true, true), "true, false, false, true, true")
-        test("charArray'", charArray('0', '1', '2', '3', '4'), "'0', '1', '2', '3', '4'")
+        test("charArray'", charArrayOf('0', '1', '2', '3', '4'), "'0', '1', '2', '3', '4'")
-        test("byteArray", byteArray(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("byteArrayOf", byteArrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
-        test("shortArray", shortArray(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("shortArrayOf", shortArrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
-        test("intArray,", intArray(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("intArray,", intArrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
-        test("longArray", longArray(0, 1, 2, 3, 4), "Kotlin.Long.fromInt(0), Kotlin.Long.fromInt(1), Kotlin.Long.fromInt(2), Kotlin.Long.fromInt(3), Kotlin.Long.fromInt(4)")
+        test("longArrayOf", longArrayOf(0, 1, 2, 3, 4), "Kotlin.Long.fromInt(0), Kotlin.Long.fromInt(1), Kotlin.Long.fromInt(2), Kotlin.Long.fromInt(3), Kotlin.Long.fromInt(4)")
-        test("floatArray", floatArray(0.0f, 1.0f, 2.0f, 3.0f, 4.0f), "0.0, 1.0, 2.0, 3.0, 4.0")
+        test("floatArrayOf", floatArrayOf(0.0f, 1.0f, 2.0f, 3.0f, 4.0f), "0.0, 1.0, 2.0, 3.0, 4.0")
-        test("doubleArray", doubleArray(0.0, 1.1, 2.2, 3.3, 4.4), "0.0, 1.1, 2.2, 3.3, 4.4")
+        test("doubleArrayOf", doubleArrayOf(0.0, 1.1, 2.2, 3.3, 4.4), "0.0, 1.1, 2.2, 3.3, 4.4")
     }
     catch (e: Fail) {
         return e.message

js/js.translator/testData/standardClasses/cases/arraySize.kt

@@ -6,4 +6,4 @@ class A() {
 val a1 = arrayOfNulls<Int>(3)
 val a2 = arrayOfNulls<A>(2)
 
-fun box() = (a1.size == 3 && a2.size == 2)
+fun box() = (a1.size() == 3 && a2.size() == 2)

js/js.translator/testData/webDemoExamples1/cases/isCheck.kt

@@ -5,6 +5,6 @@ fun main(args: Array<String>) {
 
 fun getStringLength(obj: Any): Int? {
     if (obj is String)
-        return obj.length // no cast to String is needed
+        return obj.length() // no cast to String is needed
     return null
 }

js/js.translator/testData/webDemoExamples1/cases/multiLanguageHello.kt

@@ -1,5 +1,5 @@
 fun main(args: Array<String>) {
-    val language = if (args.size == 0) "EN" else args[0]
+    val language = if (args.size() == 0) "EN" else args[0]
     println(when (language) {
                 "EN" -> "Hello!"
                 "FR" -> "Salut!"

js/js.translator/testData/webDemoExamples1/cases/nullChecks.kt

@@ -10,7 +10,7 @@ fun myParseInt(str: String): Int? {
 }
 
 fun main(args: Array<String>) {
-    if (args.size < 2) {
+    if (args.size() < 2) {
         print("No number supplied");
     }
     else {

js/js.translator/testData/webDemoExamples1/cases/whileLoop.kt

@@ -1,5 +1,5 @@
 fun main(args: Array<String>) {
     var i = 0
-    while (i < args.size)
+    while (i < args.size())
         println(args[i++])
 }

js/js.translator/testData/webDemoExamples2/cases/bottles.kt

@@ -72,4 +72,4 @@ fun bottlesOfBeer(count: Int): String =
 // From the std package
 // This is an extension property, i.e. a property that is defined for the
 // type Array<T>, but does not sit inside the class Array
-fun <T> Array<T>.isEmpty() = size == 0
+fun <T> Array<T>.isEmpty() = size() == 0

js/js.translator/testData/webDemoExamples2/cases/life.kt

@@ -133,15 +133,15 @@ fun makeField(s: String): Field {
     val lines: List<String> = s.splitBy("\n")
 
     val w = Collections.max<String>(lines.toList(), comparator<String> { o1, o2 ->
-        val l1: Int = o1.size
+        val l1: Int = o1.length()
-        val l2 = o2.size
+        val l2 = o2.length()
         l1 - l2
     })!!
-    val data = Array(lines.size) { Array(w.size) { false } }
+    val data = Array(lines.size()) { Array(w.length()) { false } }
 
     // workaround
     for (i in data.indices) {
-        data[i] = Array(w.size) { false }
+        data[i] = Array(w.length()) { false }
         for (j in data[i].indices)
             data[i][j] = false
     }
@@ -153,7 +153,7 @@ fun makeField(s: String): Field {
         }
     }
 
-    return Field(w.size, lines.size) { i, j -> data[i][j] }
+    return Field(w.length(), lines.size()) { i, j -> data[i][j] }
 }
 
 // An excerpt from the Standard Library
@@ -163,4 +163,4 @@ fun <K, V> MutableMap<K, V>.set(k: K, v: V) {
     put(k, v)
 }
 
-val <T> Array<T>.isEmpty: Boolean get() = size == 0
+val <T> Array<T>.isEmpty: Boolean get() = size() == 0