Merge boxWithStdlib testData into box, delete BoxWithStdlib test

compiler/testData/codegen/box/reified/DIExample.kt

@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+import kotlin.reflect.KProperty
+
+class Project {
+    fun <T> getInstance(cls: Class<T>): T =
+        when (cls.getName()) {
+            "java.lang.Integer" -> 1 as T
+            "java.lang.String" -> "OK" as T
+            else -> null!!
+        }
+}
+
+inline operator fun <reified T : Any> Project.getValue(t: Any?, p: KProperty<*>): T = getInstance(T::class.java)
+
+val project = Project()
+val x1: Int by project
+val x2: String by project
+
+fun box(): String {
+    assertEquals(1, x1)
+    assertEquals("OK", x2)
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/anonymousObject.kt

@@ -0,0 +1,21 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+abstract class A {
+    abstract fun f(): String
+}
+
+inline fun<reified T : Any> foo(): A {
+    return object : A() {
+        override fun f(): String {
+            return T::class.java.getName()
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo<String>();
+    assertEquals("java.lang.String", y.f())
+    return "OK"
+}

compiler/testData/codegen/box/reified/anonymousObjectNoPropagate.kt

@@ -0,0 +1,38 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+interface A {
+    fun f1(): String
+    fun f2(): String
+    fun f3(): String
+}
+
+fun doWork(block: () -> String) = block()
+inline fun doWorkInline(block: () -> String) = block()
+
+fun box(): String {
+    val x = object {
+        inline fun <reified T : Any> bar1(): A = object : A {
+            override fun f1(): String = T::class.java.getName()
+            override fun f2(): String = doWork { T::class.java.getName() }
+            override fun f3(): String = doWorkInline { T::class.java.getName() }
+        }
+
+        inline fun <reified T : Any> bar2() = T::class.java.getName()
+        inline fun <reified T : Any> bar3() = doWork { T::class.java.getName() }
+        inline fun <reified T : Any> bar4() = doWorkInline { T::class.java.getName() }
+    }
+
+    val y: A = x.bar1<String>()
+    assertEquals("java.lang.String", y.f1())
+    assertEquals("java.lang.String", y.f2())
+    assertEquals("java.lang.String", y.f3())
+
+
+    assertEquals("java.lang.Integer", x.bar2<Int>())
+    assertEquals("java.lang.Double", x.bar3<Double>())
+    assertEquals("java.lang.Long", x.bar4<Long>())
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/anonymousObjectReifiedSupertype.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+abstract class A<R> {
+    abstract fun f(): String
+}
+
+inline fun<reified T> foo(): A<T> {
+    return object : A<T>() {
+        override fun f(): String {
+            return "OK"
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo<String>();
+    assertEquals("OK", y.f())
+    assertEquals("A<java.lang.String>", y.javaClass.getGenericSuperclass()?.toString())
+    return "OK"
+}

compiler/testData/codegen/box/reified/approximateCapturedTypes.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+// Basically this test checks that no captured type used as argument for signature mapping
+class SwOperator<T>: Operator<List<T>, T>
+
+interface Operator<R, T>
+
+open class Inv<T>
+
+class Obs<Y> {
+    inline fun <reified X> lift(lift: Operator<out X, in Y>) = object : Inv<X>() {}
+}
+
+fun box(): String {
+    val o: Obs<CharSequence> = Obs()
+
+    val inv = o.lift(SwOperator())
+    val signature = inv.javaClass.genericSuperclass.toString()
+
+    if (signature != "Inv<java.util.List<?>>") return "fail 1: $signature"
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/arraysReification/instanceOf.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+inline fun <reified T> foo(x: Any?) = Pair(x is T, x is T?)
+
+fun box(): String {
+    val x1 = foo<Array<String>>(arrayOf(""))
+    if (x1.toString() != "(true, true)") return "fail 1"
+
+    val x2 = foo<Array<String>?>(arrayOf(""))
+    if (x2.toString() != "(true, true)") return "fail 2"
+
+    val x3 = foo<Array<String>>(null)
+    if (x3.toString() != "(false, true)") return "fail 3"
+
+    val x4 = foo<Array<String>?>(null)
+    if (x4.toString() != "(true, true)") return "fail 4"
+
+    val x5 = foo<Array<Double>?>(arrayOf(""))
+    if (x5.toString() != "(false, false)") return "fail 5"
+
+    val x6 = foo<Array<Double>?>(null)
+    if (x6.toString() != "(true, true)") return "fail 6"
+    return "OK"
+}

compiler/testData/codegen/box/reified/arraysReification/instanceOfArrays.kt

@@ -0,0 +1,37 @@
+// WITH_RUNTIME
+
+inline fun <reified T> foo(x: Any?) = Pair(x is T, x is T?)
+inline fun <reified F> bar(y: Any?) = foo<Array<F>>(y)
+inline fun <reified F> barNullable(y: Any?) = foo<Array<F>?>(y)
+
+fun box(): String {
+    val x1 = bar<String>(arrayOf(""))
+    if (x1.toString() != "(true, true)") return "fail 1"
+
+    val x3 = bar<String>(null)
+    if (x3.toString() != "(false, true)") return "fail 3"
+
+    val x4 = bar<String?>(null)
+    if (x4.toString() != "(false, true)") return "fail 4"
+
+    val x5 = bar<Double?>(arrayOf(""))
+    if (x5.toString() != "(false, false)") return "fail 5"
+
+    val x6 = bar<Double?>(null)
+    if (x6.toString() != "(false, true)") return "fail 6"
+
+    // barNullable
+
+    val x7 = barNullable<String>(arrayOf(""))
+    if (x7.toString() != "(true, true)") return "fail 7"
+
+    val x9 = barNullable<String>(null)
+    if (x9.toString() != "(true, true)") return "fail 9"
+
+    val x10 = barNullable<Double?>(arrayOf(""))
+    if (x10.toString() != "(false, false)") return "fail 11"
+
+    val x12 = barNullable<Double?>(null)
+    if (x12.toString() != "(true, true)") return "fail 12"
+    return "OK"
+}

compiler/testData/codegen/box/reified/arraysReification/jClass.kt

@@ -0,0 +1,15 @@
+// WITH_RUNTIME
+
+inline fun <reified T : Any> jClass() = T::class.java
+inline fun <reified T : Any> jClassArray() = jClass<Array<T>>()
+
+fun box(): String {
+    if (jClass<Array<String>>().simpleName != "String[]") return "fail 1"
+    if (jClass<IntArray>().simpleName != "int[]") return "fail 2"
+
+    if (jClassArray<String>().simpleName != "String[]") return "fail 3"
+    if (jClassArray<Array<String>>().simpleName != "String[][]") return "fail 4"
+    if (jClassArray<IntArray>().simpleName != "int[][]") return "fail 5"
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/arraysReification/jaggedArrayOfNulls.kt

@@ -0,0 +1,15 @@
+// WITH_RUNTIME
+
+inline fun <reified T> jaggedArrayOfNulls(): Array<Array<T>?> = arrayOfNulls<Array<T>>(1)
+
+fun box(): String {
+    val x1 = jaggedArrayOfNulls<String>().javaClass.simpleName
+    if (x1 != "String[][]") return "fail1: $x1"
+
+    val x2 = jaggedArrayOfNulls<Array<String>>().javaClass.simpleName
+    if (x2 != "String[][][]") return "fail2: $x2"
+
+    val x3 = jaggedArrayOfNulls<IntArray>().javaClass.simpleName
+    if (x3 != "int[][][]") return "fail3: $x3"
+    return "OK"
+}

compiler/testData/codegen/box/reified/checkcast.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+inline fun<reified T> checkcast(x: Any?): T {
+    return x as T
+}
+
+fun box(): String {
+    val x = checkcast<String>("abc")
+    assertEquals("abc", x)
+    val y = checkcast<Int>(1)
+    assertEquals(1, y)
+
+    try {
+        val z = checkcast<Int>("abc")
+    } catch (e: Exception) {
+        return "OK"
+    }
+
+    return "Fail"
+}

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

@@ -0,0 +1,17 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+inline fun <reified T> copy(c: Collection<T>): Array<T> {
+    return c.toTypedArray()
+}
+
+fun box(): String {
+    val a: Array<String> = copy(listOf("a", "b", "c"))
+    assertEquals("abc", a.joinToString(""))
+
+    val b: Array<Int> = copy(listOf(1,2,3))
+    assertEquals("123", b.map { it.toString() }.joinToString(""))
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/defaultJavaClass.kt

@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+inline fun <reified T : Any> foo(x: Class<T> = T::class.java): String = x.getName()
+
+inline fun <reified R : Any> bar(x: R): String = foo<R>()
+
+fun box(): String {
+    assertEquals("java.lang.String", foo<String>())
+    assertEquals("java.lang.Integer", foo<Int>())
+    assertEquals("java.lang.Object", foo<Any>())
+
+    assertEquals("java.lang.String", bar("abc"))
+    assertEquals("java.lang.Integer", bar(1))
+    assertEquals("java.lang.Object", bar(Any()))
+
+    return "OK"
+}

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

@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+inline fun<reified T> Array<Any>.filterIsInstance(): List<T> {
+    return this.filter { it is T }.map { it as T }
+}
+
+fun box(): String {
+    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>())
+    assertEquals(arrayListOf("abc", "cde"), src.filterIsInstance<String>())
+    assertEquals(src.toList(), src.filterIsInstance<Any>())
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/innerAnonymousObject.kt

@@ -0,0 +1,29 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+abstract class A<R> {
+    abstract fun f(): String
+    override fun toString() = f()
+}
+
+abstract class G {
+    abstract fun bar(): Any
+}
+
+inline fun<reified T> foo(): G {
+    return object : G() {
+        override fun bar(): Any {
+            return object : A<T>() {
+                 override fun f(): String = "OK"
+            }
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo<String>().bar();
+    assertEquals("OK", y.toString())
+    assertEquals("A<java.lang.String>", y.javaClass.getGenericSuperclass()?.toString())
+    return "OK"
+}

compiler/testData/codegen/box/reified/instanceof.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+inline fun<reified T> isinstance(x: Any?): Boolean {
+    return x is T
+}
+
+fun box(): String {
+    assert(isinstance<String>("abc"))
+    assert(isinstance<Int>(1))
+    assert(!isinstance<Int>("abc"))
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/javaClass.kt

@@ -0,0 +1,14 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+inline fun<reified T : Any> javaClassName(): String {
+    return T::class.java.getName()
+}
+
+fun box(): String {
+    assertEquals("java.lang.String", javaClassName<String>())
+    assertEquals("java.lang.Integer", javaClassName<Int>())
+    assertEquals("java.lang.Object", javaClassName<Any>())
+    return "OK"
+}

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

@@ -0,0 +1,44 @@
+// WITH_RUNTIME
+
+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> = arrayOf(
+                T1::class.java.getName(), T::class.java.getName(), R::class.java.getName()
+        )
+        fun f1() = bar<T, R>()
+        fun f2() = bar<R, T>()
+        fun f3() = bar<Boolean, T>()
+        fun f4() = bar<T, Boolean>()
+    }
+
+    val x1 = x.f1()
+    val x2 = x.f2()
+    val x3 = x.f3()
+    val x4 = x.f4()
+
+    return arrayOf(
+            x1[0], x1[1], x1[2],
+            x2[0], x2[1], x2[2],
+            x3[0], x3[1], x3[2],
+            x4[0], x4[1], x4[2]
+    )
+}
+
+fun box(): String {
+    val result = foo<Double, Int>()
+
+    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",
+            "java.lang.Double", "java.lang.Boolean", "java.lang.Integer"
+    )
+
+    for (i in expected.indices) {
+        assertEquals(expected[i], result[i], "$i-th element")
+    }
+
+    return "OK"
+}

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

@@ -0,0 +1,34 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+open class A<T1, T2, T3>
+
+inline fun <reified T, reified R> foo(): Array<A<*,*,*>> {
+    val x = object {
+        inline fun <reified T1, reified T> bar(): A<*,*,*> = object : A<T1,T,R>() {}
+        fun f1() = bar<T, R>()
+        fun f2() = bar<R, T>()
+        fun f3() = bar<Boolean, T>()
+        fun f4() = bar<T, Boolean>()
+    }
+
+    return arrayOf(x.f1(), x.f2(), x.f3(), x.f4())
+}
+
+fun box(): String {
+    val result = foo<Double, Int>()
+
+    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"),
+            Triple("java.lang.Double", "java.lang.Boolean", "java.lang.Integer")
+    ).map { "A<${it.first}, ${it.second}, ${it.third}>" }
+
+    for (i in expected.indices) {
+        assertEquals(expected[i], result[i].javaClass.getGenericSuperclass()?.toString(), "$i-th element")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/newArrayInt.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+inline fun<reified T> createArray(n: Int, crossinline block: () -> T): Array<T> {
+    return Array<T>(n) { block() }
+}
+
+fun box(): String {
+
+    val x = createArray<Int>(5) { 3 }
+
+    assert(x.all { it == 3 })
+    return "OK"
+}

compiler/testData/codegen/box/reified/nonInlineableLambdaInReifiedFunction.kt

@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+inline fun<reified T : Any> bar1(x: T): String = foo() {
+    T::class.java.getName()
+}
+inline fun<reified T : Any> bar2(x: T, y: String): String = foo() {
+    T::class.java.getName() + "#" + y
+}
+
+fun box(): String {
+
+    assertEquals("java.lang.Integer", bar1(1))
+    assertEquals("java.lang.String#OK", bar2("abc", "OK"))
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/recursiveInnerAnonymousObject.kt

@@ -0,0 +1,37 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+abstract class A<R> {
+    abstract fun f(): String
+    override fun toString() = f()
+}
+
+abstract class G {
+    abstract fun bar(): Any
+}
+
+inline fun<reified T> baz(): G {
+    return object : G() {
+        override fun bar(): Any {
+            return object : A<T>() {
+                override fun f(): String = "OK"
+            }
+        }
+    }
+}
+
+inline fun<T1, T2, T3, T4, T5, T6, reified R1, reified R2> foo(): Pair<G, G> {
+    return Pair(baz<R1>(), baz<R2>())
+}
+
+fun box(): String {
+    val res = foo<Int, Int, Int, Int, Int, Int, Int, String>();
+    val x1 = res.first.bar()
+    val x2 = res.second.bar()
+    assertEquals("OK", x1.toString())
+    assertEquals("OK", x2.toString())
+    assertEquals("A<java.lang.Integer>", x1.javaClass.getGenericSuperclass()?.toString())
+    assertEquals("A<java.lang.String>", x2.javaClass.getGenericSuperclass()?.toString())
+    return "OK"
+}

compiler/testData/codegen/box/reified/recursiveNewArray.kt

@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+inline fun<reified T> createArray(n: Int, crossinline block: () -> T): Array<T> {
+    return Array<T>(n) { block() }
+}
+
+inline fun<T1, T2, T3, T4, T5, T6, reified R> recursive(
+        crossinline block: () -> R
+): Array<R> {
+    return createArray(5) { block() }
+}
+
+fun box(): String {
+    val x = recursive<Int, Int, Int, Int, Int, Int, String>(){ "abc" }
+
+    assert(x.all { it == "abc" })
+    return "OK"
+}

compiler/testData/codegen/box/reified/recursiveNonInlineableLambda.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+inline fun<reified T : Any> bar1(): String = foo() {
+    T::class.java.getName()
+}
+inline fun<reified T : Any> bar2(y: String): String = foo() {
+    T::class.java.getName() + "#" + y
+}
+
+inline fun<T1, T2, reified R1 : Any, reified R2 : Any> bar3(y: String) =
+        Pair(bar1<R1>(), bar2<R2>(y))
+
+fun box(): String {
+    val x = bar3<Any, Double, Int, String>("OK")
+
+    assertEquals("java.lang.Integer", x.first)
+    assertEquals("java.lang.String#OK", x.second)
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/reifiedInlineFunOfObject.kt

@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+interface A {
+    fun f(): String
+    fun g(): String
+}
+
+fun box(): String {
+    val x: A = object : A {
+        private inline fun <reified T : Any> localClassName(): String = T::class.java.getName()
+        override fun f(): String = foo { localClassName<String>() }
+        override fun g(): String = foo { localClassName<Int>() }
+    }
+
+    assertEquals("java.lang.String", x.f())
+    assertEquals("java.lang.Integer", x.g())
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/reifiedInlineFunOfObjectWithinReified.kt

@@ -0,0 +1,30 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+inline fun <reified T : Any> className(): String = T::class.java.getName()
+
+inline fun <reified T : Any> lambdaShouldBeReified(): String = foo { className<T>() }
+
+interface A {
+    fun f(): String
+    fun g(): String
+}
+inline fun<reified T1 : Any, reified T2 : Any> AFactory(): A = object : A {
+    override fun f(): String = className<T1>()
+    override fun g(): String = foo { className<T2>() }
+}
+
+fun box(): String {
+    assertEquals("java.lang.String", lambdaShouldBeReified<String>())
+    assertEquals("java.lang.Integer", lambdaShouldBeReified<Int>())
+
+    val x: A = AFactory<String, Int>()
+
+    assertEquals("java.lang.String", x.f())
+    assertEquals("java.lang.Integer", x.g())
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/reifiedInlineIntoNonInlineableLambda.kt

@@ -0,0 +1,30 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+inline fun<reified T : Any> className(): String = T::class.java.getName()
+
+interface A {
+    fun f(): String
+    fun g(): String
+}
+
+fun box(): String {
+    val x = foo() {
+        className<String>()
+    }
+
+    assertEquals("java.lang.String", x)
+
+    val y: A = object : A {
+        override fun f(): String = foo { className<String>() }
+        override fun g(): String = foo { className<Int>() }
+    }
+
+    assertEquals("java.lang.String", y.f())
+    assertEquals("java.lang.Integer", y.g())
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/safecast.kt

@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+inline fun<reified T> safecast(x: Any?): T? {
+    return x as? T
+}
+
+fun box(): String {
+    val x = safecast<String>("abc")
+    assertEquals("abc", x)
+    val y = safecast<Int>(1)
+    assertEquals(1, y)
+
+    val z = safecast<Int>("abc")
+    assertEquals(null, z)
+
+    return "OK"
+}

compiler/testData/codegen/box/reified/sameIndexRecursive.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+inline fun<reified T1, reified T2> createArray(n: Int, crossinline block: () -> Pair<T1, T2>): Pair<Array<T1>, Array<T2>> {
+    return Pair(Array(n) { block().first }, Array(n) { block().second })
+}
+
+inline fun<T1, T2, T3, T4, T5, T6, reified R> recursive(
+        crossinline block: () -> R
+): Pair<Array<R>, Array<R>> {
+    return createArray(5) { Pair(block(), block()) }
+}
+
+fun box(): String {
+    val y = createArray(5) { Pair(1, "test") }
+    val x = recursive<Int, Int, Int, Int, Int, Int, String>(){ "abc" }
+
+    assert(y.first.all { it == 1 } )
+    assert(y.second.all { it == "test" })
+    assert(x.first.all { it == "abc" })
+    assert(x.second.all { it == "abc" })
+    return "OK"
+}

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

@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+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 arrayOf(*a, block(), block())
+}
+
+inline fun <reified T> empty() = arrayOf<T>()
+
+fun box(): String {
+
+    var i = 0
+    val a: Array<String> = bar(arrayOf("1", "2")) { i++; i.toString() }
+    assertEquals("1234", a.joinToString(""))
+
+    i = 0
+    val b: Array<Int> = bar(arrayOf(0, 1)) { i++ }
+    assertEquals("0123", b.map { it.toString() }.joinToString(""))
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun <T> foo(vararg a: T) = a.size
+
+inline fun <reified T> bar(block: () -> T): Array<T> {
+    assertEquals(2, foo(block(), block()))
+
+    return arrayOf(block(), block(), block())
+}
+
+inline fun <reified T> empty() = arrayOf<T>()
+
+fun box(): String {
+    var i = 0
+    val a: Array<String> = bar() { i++; i.toString() }
+    assertEquals("345", a.joinToString(""))
+
+    i = 0
+    val b: Array<Int> = bar() { i++ }
+    assertEquals("234", b.map { it.toString() }.joinToString(""))
+
+    val c: Array<String> = empty()
+    assertEquals(0, c.size)
+
+    return "OK"
+}