Minor, regroup compileKotlinAgainstKotlin tests on inline classes

2021-03-19 20:21:10 +01:00
parent 3124a4ddae
commit dac218dc39
28 changed files with 846 additions and 724 deletions
@@ -0,0 +1,21 @@
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// FILE: A.kt
+
+package a
+
+@Suppress("UNSUPPORTED_FEATURE")
+inline class Foo(val x: IntArray) {
+    val size: Int get() = x.size
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+import a.*
+
+fun box(): String {
+    val a = Foo(intArrayOf(3, 4))
+    if (a.size != 2) return "Fail"
+    return "OK"
+}
@@ -0,0 +1,14 @@
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// FILE: A.kt
+package lib
+
+inline class S(val string: String)
+
+class Test(val s: S)
+
+// MODULE: main(lib)
+// FILE: B.kt
+import lib.*
+
+fun box() = Test(S("OK")).s.string
@@ -0,0 +1,16 @@
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// FILE: A.kt
+package z
+
+inline class Z(val s: String)
+
+class X {
+    fun Int.foo(z: Z, value: String = "OK") = value
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import z.*
+
+fun box(): String = with(X()) { 1.foo(Z("")) }
@@ -0,0 +1,24 @@
+// !LANGUAGE: +InlineClasses
+
+// MODULE: lib
+// FILE: 1.kt
+
+inline class IC(val s: String)
+
+abstract class A {
+    fun foo(s: String) = IC(s)
+}
+
+open class C : A()
+
+class D: C()
+
+// MODULE: main(lib)
+// FILE: 2.kt
+
+fun box(): String {
+    var res = C().foo("OK").s
+    if (res != "OK") return "FAIL 1 $res"
+    res = D().foo("OK").s
+    return res
+}
@@ -0,0 +1,42 @@
+// !LANGUAGE: +InlineClasses
+// WITH_STDLIB
+
+// MODULE: lib
+// FILE: A.kt
+package z
+
+interface IFoo {
+    fun foo(): String
+}
+
+inline class Z(val s: String) : IFoo {
+    constructor(i: Int) : this(i.toString())
+
+    override fun foo(): String = s
+
+    fun bar() = s
+
+    inline fun <T> run(lambda: (String) -> T) = lambda(s)
+
+    companion object {
+        fun z(i: Int) = Z(i)
+    }
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import z.*
+
+fun test(z: Z) {
+    if (z.foo() != "1234") throw AssertionError()
+    if (z.bar() != "1234") throw AssertionError()
+    if (z.run { it } != "1234") throw AssertionError()
+    if (listOf(z)[0].s != "1234") throw AssertionError()
+}
+
+fun box(): String {
+    test(Z("1234"))
+    test(Z(1234))
+    test(Z.z(1234))
+    return "OK"
+}
@@ -0,0 +1,13 @@
+// MODULE: lib
+// FILE: A.kt
+
+inline class A(val x: String) {
+    inline fun f(other: A): A = other
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+fun box(): String {
+    return A("Fail").f(A("OK")).x
+}
@@ -0,0 +1,17 @@
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// FILE: A.kt
+
+package a
+
+inline class S(val value: String) {
+    inline val k: String
+        get() = value + "K"
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+fun box(): String {
+    return a.S("O").k
+}
@@ -0,0 +1,18 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// MODULE: lib
+// FILE: A.kt
+
+package a
+
+inline class Message(val value: String)
+
+class Box {
+    internal fun result(msg: Message): String = msg.value
+}
+
+// MODULE: main()(lib)
+// FILE: B.kt
+
+fun box(): String {
+    return a.Box().result(a.Message("OK"))
+}
@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+
+package a
+
+@Suppress("UNSUPPORTED_FEATURE")
+inline class Foo(val x: IntArray) {
+    val size: Int get() = x.size
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+import a.*
+
+fun box(): String {
+    val a = Foo(intArrayOf(3, 4))
+    if (a.size != 2) return "Fail"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+package lib
+
+inline class S(val string: String)
+
+class Test(val s: S)
+
+// MODULE: main(lib)
+// FILE: B.kt
+import lib.*
+
+fun box() = Test(S("OK")).s.string
@@ -0,0 +1,18 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+package z
+
+inline class Z(val s: String)
+
+class X {
+    fun Int.foo(z: Z, value: String = "OK") = value
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import z.*
+
+fun box(): String = with(X()) { 1.foo(Z("")) }
@@ -0,0 +1,25 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: 1.kt
+
+inline class IC(val s: String)
+
+abstract class A {
+    fun foo(s: String) = IC(s)
+}
+
+open class C : A()
+
+class D: C()
+
+// MODULE: main(lib)
+// FILE: 2.kt
+
+fun box(): String {
+    var res = C().foo("OK").s
+    if (res != "OK") return "FAIL 1 $res"
+    res = D().foo("OK").s
+    return res
+}
@@ -0,0 +1,43 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// WITH_STDLIB
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+package z
+
+interface IFoo {
+    fun foo(): String
+}
+
+inline class Z(val s: String) : IFoo {
+    constructor(i: Int) : this(i.toString())
+
+    override fun foo(): String = s
+
+    fun bar() = s
+
+    inline fun <T> run(lambda: (String) -> T) = lambda(s)
+
+    companion object {
+        fun z(i: Int) = Z(i)
+    }
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import z.*
+
+fun test(z: Z) {
+    if (z.foo() != "1234") throw AssertionError()
+    if (z.bar() != "1234") throw AssertionError()
+    if (z.run { it } != "1234") throw AssertionError()
+    if (listOf(z)[0].s != "1234") throw AssertionError()
+}
+
+fun box(): String {
+    test(Z("1234"))
+    test(Z(1234))
+    test(Z.z(1234))
+    return "OK"
+}
@@ -0,0 +1,16 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+
+inline class A(val x: String) {
+    inline fun f(other: A): A = other
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+fun box(): String {
+    return A("Fail").f(A("OK")).x
+}
@@ -0,0 +1,19 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+
+package a
+
+inline class S(val value: String) {
+    inline val k: String
+        get() = value + "K"
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+fun box(): String {
+    return a.S("O").k
+}
@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// WITH_REFLECT
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+package a
+
+import kotlin.reflect.jvm.isAccessible
+
+inline class S(val s: String)
+
+class Host {
+    companion object {
+        private val ok = S("OK")
+        val ref = ::ok.apply { isAccessible = true }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import a.*
+
+fun box() = Host.ref.call().s
@@ -0,0 +1,21 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// WITH_REFLECT
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: A.kt
+package a
+
+import kotlin.reflect.jvm.isAccessible
+
+inline class S(val s: String)
+
+private val ok = S("OK")
+
+val ref = ::ok.apply { isAccessible = true }
+
+// MODULE: main(lib)
+// FILE: B.kt
+import a.*
+
+fun box() = ref.call().s
@@ -0,0 +1,35 @@
+// TARGET_BACKEND: JVM
+// !LANGUAGE: +InlineClasses
+// WITH_STDLIB
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: a.kt
+
+package a
+
+var result = ""
+
+inline class P(val value: String)
+
+suspend fun foo(p: P = P("OK")) {
+    result = p.value
+}
+
+// MODULE: main(lib)
+// WITH_COROUTINES
+// FILE: b.kt
+
+import kotlin.coroutines.*
+import helpers.*
+import a.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    builder {
+        foo()
+    }
+    return result
+}
@@ -0,0 +1,33 @@
+// !LANGUAGE: +InlineClasses
+// WITH_STDLIB
+
+// MODULE: lib
+// USE_OLD_INLINE_CLASSES_MANGLING_SCHEME
+// FILE: 1.kt
+package test
+
+inline class IC(val s: String)
+
+fun ordinary(s: String, ic: IC): String = s + ic.s
+
+suspend fun suspend(s: String, ic: IC): String = s + ic.s
+
+// MODULE: main(lib)
+// FILE: 2.kt
+import kotlin.coroutines.*
+import test.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+fun box(): String {
+    var res = ordinary("O", IC("K"))
+    if (res != "OK") return "FAIL 1: $res"
+    builder {
+        res = suspend("O", IC("K"))
+    }
+    return res
+}
@@ -0,0 +1,24 @@
+// !LANGUAGE: +InlineClasses
+// IGNORE_BACKEND: JS_IR, JS, NATIVE
+// WITH_REFLECT
+
+// MODULE: lib
+// FILE: A.kt
+package a
+
+import kotlin.reflect.jvm.isAccessible
+
+inline class S(val s: String)
+
+class Host {
+    companion object {
+        private val ok = S("OK")
+        val ref = ::ok.apply { isAccessible = true }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import a.*
+
+fun box() = Host.ref.call().s
@@ -0,0 +1,21 @@
+// !LANGUAGE: +InlineClasses
+// IGNORE_BACKEND: JS_IR, JS, NATIVE
+// WITH_REFLECT
+
+// MODULE: lib
+// FILE: A.kt
+package a
+
+import kotlin.reflect.jvm.isAccessible
+
+inline class S(val s: String)
+
+private val ok = S("OK")
+
+val ref = ::ok.apply { isAccessible = true }
+
+// MODULE: main(lib)
+// FILE: B.kt
+import a.*
+
+fun box() = ref.call().s
@@ -0,0 +1,34 @@
+// !LANGUAGE: +InlineClasses
+// WITH_STDLIB
+
+// MODULE: lib
+// FILE: a.kt
+
+package a
+
+var result = ""
+
+inline class P(val value: String)
+
+suspend fun foo(p: P = P("OK")) {
+    result = p.value
+}
+
+// MODULE: main(lib)
+// WITH_COROUTINES
+// FILE: b.kt
+
+import kotlin.coroutines.*
+import helpers.*
+import a.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    builder {
+        foo()
+    }
+    return result
+}