Add and fix test pattern for KFunction involving value class (to fix KT-31141).

compiler/testData/codegen/box/reflection/call/inlineClasses/inlineClassConstructor.kt

@@ -4,6 +4,7 @@
 
 import kotlin.reflect.KCallable
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 
 inline class Z(val x: Int) {
     constructor(a: Int, b: Int) : this(a + b)
@@ -13,36 +14,48 @@ inline class L(val x: Long) {
     constructor(a: Long, b: Long) : this(a + b)
 }
 
-inline class S(val x: String) {
+inline class S1(val x: String) {
     constructor(a: String, b: String) : this(a + b)
 }
 
+inline class S2(val x: String?) {
+    constructor(a: String?, b: String?) : this(a!! + b!!)
+}
+
 inline class A(val x: Any) {
     constructor(a: String, b: String) : this(a + b)
 }
 
 inline class Z2(val z: Z)
+inline class Z3(val z: Z?)
 
 fun box(): String {
-    val ctorZ1: (Int) -> Z = ::Z
-    val ctorZ2: (Int, Int) -> Z = ::Z
+    val ctorZ1_1: (Int) -> Z = ::Z
+    val ctorZ1_2: (Int, Int) -> Z = ::Z
     val ctorL1: (Long) -> L = ::L
     val ctorL2: (Long, Long) -> L = ::L
-    val ctorS1: (String) -> S = ::S
-    val ctorS2: (String, String) -> S = ::S
+    val ctorS1_1: (String) -> S1 = ::S1
+    val ctorS1_2: (String, String) -> S1 = ::S1
+    val ctorS2_1: (String) -> S2 = ::S2
+    val ctorS2_2: (String, String) -> S2 = ::S2
     val ctorA1: (Any) -> A = ::A
     val ctorA2: (String, String) -> A = ::A
 
-    assertEquals(Z(42), (ctorZ1 as KCallable<Z>).call(42))
-    assertEquals(Z(123), (ctorZ2 as KCallable<Z>).call(100, 23))
+    assertEquals(Z(42), (ctorZ1_1 as KCallable<Z>).call(42))
+    assertEquals(Z(123), (ctorZ1_2 as KCallable<Z>).call(100, 23))
     assertEquals(L(1L), (ctorL1 as KCallable<L>).call(1L))
     assertEquals(L(123L), (ctorL2 as KCallable<L>).call(100L, 23L))
-    assertEquals(S("abc"), (ctorS1 as KCallable<S>).call("abc"))
-    assertEquals(S("abc"), (ctorS2 as KCallable<S>).call("ab", "c"))
+    assertEquals(S1("abc"), (ctorS1_1 as KCallable<S1>).call("abc"))
+    assertEquals(S1("abc"), (ctorS1_2 as KCallable<S1>).call("ab", "c"))
+    assertEquals(S2("abc"), (ctorS2_1 as KCallable<S2>).call("abc"))
+    assertEquals(S2("abc"), (ctorS2_2 as KCallable<S2>).call("ab", "c"))
     assertEquals(A("abc"), (ctorA1 as KCallable<A>).call("abc"))
     assertEquals(A("abc"), (ctorA2 as KCallable<A>).call("a", "bc"))
 
     assertEquals(Z2(Z(42)), ::Z2.call(Z(42)))
+    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
+        assertEquals(Z3(Z(42)), ::Z3.call(Z(42)))
+    }
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/internalPrimaryValOfInlineClass.kt

@@ -10,8 +10,10 @@ inline class Z2(internal val x: Z)
 inline class L(internal val x: Long)
 inline class L2(internal val x: L)
 
-inline class A(internal val x: Any?)
-inline class A2(internal val x: A)
+inline class A1(internal val x: Any?)
+inline class A1_2(internal val x: A1)
+inline class A2(internal val x: Any)
+inline class A2_2(internal val x: A2)
 
 fun box(): String {
     assertEquals(42, Z::x.call(Z(42)))
@@ -20,21 +22,25 @@ fun box(): String {
     assertEquals(1234L, L::x.call(L(1234L)))
     assertEquals(1234L, L(1234L)::x.call())
 
-    assertEquals("abc", A::x.call(A("abc")))
-    assertEquals("abc", A("abc")::x.call())
-    assertEquals(null, A::x.call(A(null)))
-    assertEquals(null, A(null)::x.call())
+    assertEquals("abc", A1::x.call(A1("abc")))
+    assertEquals("abc", A1("abc")::x.call())
+    assertEquals(null, A1::x.call(A1(null)))
+    assertEquals(null, A1(null)::x.call())
+    assertEquals("abc", A2::x.call(A2("abc")))
+    assertEquals("abc", A2("abc")::x.call())
 
     assertEquals(Z(42), Z2::x.call(Z2(Z(42))))
     assertEquals(Z(42), Z2(Z(42))::x.call())
 
     assertEquals(L(1234L), L2::x.call(L2(L(1234L))))
     assertEquals(L(1234L), L2(L(1234L))::x.call())
 
-    assertEquals(A("abc"), A2::x.call(A2(A("abc"))))
-    assertEquals(A("abc"), A2(A("abc"))::x.call())
-    assertEquals(A(null), A2::x.call(A2(A(null))))
-    assertEquals(A(null), A2(A(null))::x.call())
+    assertEquals(A1("abc"), A1_2::x.call(A1_2(A1("abc"))))
+    assertEquals(A1("abc"), A1_2(A1("abc"))::x.call())
+    assertEquals(A1(null), A1_2::x.call(A1_2(A1(null))))
+    assertEquals(A1(null), A1_2(A1(null))::x.call())
+    assertEquals(A2("abc"), A2_2::x.call(A2_2(A2("abc"))))
+    assertEquals(A2("abc"), A2_2(A2("abc"))::x.call())
 
     return "OK"
-}
+}

compiler/testData/codegen/box/reflection/call/inlineClasses/nonNullObject/constructorWithInlineClassParameters.kt

@@ -0,0 +1,50 @@
+// TARGET_BACKEND: JVM
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+inline class S(val x: String)
+
+class Outer(val z1: S, val z2: S?) {
+    inner class Inner(val z3: S, val z4: S?) {
+        val test = "$z1 $z2 $z3 $z4"
+    }
+}
+
+inline class InlineNonNullOuter(val z1: S) {
+    @Suppress("INNER_CLASS_INSIDE_VALUE_CLASS")
+    inner class Inner(val z2: S, val z3: S?) {
+        val test = "$z1 $z2 $z3"
+    }
+}
+
+inline class InlineNullableOuter(val z1: S?) {
+    @Suppress("INNER_CLASS_INSIDE_VALUE_CLASS")
+    inner class Inner(val z2: S, val z3: S?) {
+        val test = "$z1 $z2 $z3"
+    }
+}
+
+fun box(): String {
+    val z1 = S("1")
+    val z2 = S("2")
+    val z3 = S("3")
+    val z4 = S("4")
+
+    val outer = ::Outer.call(z1, z2)
+    assertEquals(z1, outer.z1)
+    assertEquals(z2, outer.z2)
+
+    assertEquals("S(x=1) S(x=2) S(x=3) S(x=4)", Outer::Inner.call(outer, z3, z4).test)
+    assertEquals("S(x=1) S(x=2) S(x=2) S(x=4)", outer::Inner.call(z2, z4).test)
+
+    val inlineNonNullOuter = InlineNonNullOuter(z1)
+    assertEquals("S(x=1) S(x=2) S(x=3)", InlineNonNullOuter::Inner.call(inlineNonNullOuter, z2, z3).test)
+    assertEquals("S(x=1) S(x=2) S(x=2)", inlineNonNullOuter::Inner.call(z2, z2).test)
+
+    val inlineNullableOuter = InlineNullableOuter(z1)
+    assertEquals("S(x=1) S(x=2) S(x=3)", InlineNullableOuter::Inner.call(inlineNullableOuter, z2, z3).test)
+    assertEquals("S(x=1) S(x=2) S(x=2)", inlineNullableOuter::Inner.call(z2, z2).test)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/call/inlineClasses/nonNullObject/fieldAccessors.kt

@@ -0,0 +1,53 @@
+// TARGET_BACKEND: JVM
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.isAccessible
+import kotlin.test.assertEquals
+
+inline class S(val value: String) {
+    operator fun plus(other: S): S = S(this.value + other.value)
+}
+
+class C {
+    private var nonNullMember: S = S("")
+    private var nullableMember: S? = S("")
+
+    fun nonNullUnboundRef() = C::nonNullMember.apply { isAccessible = true }
+    fun nonNullBoundRef() = this::nonNullMember.apply { isAccessible = true }
+    fun nullableUnboundRef() = C::nullableMember.apply { isAccessible = true }
+    fun nullableBoundRef() = this::nullableMember.apply { isAccessible = true }
+}
+
+private var nonNullTopLevel: S = S("")
+private var nullableTopLevel: S? = S("")
+
+fun box(): String {
+    val c = C()
+    assertEquals(Unit, c.nonNullUnboundRef().setter.call(c, S("ab")))
+    assertEquals(S("ab"), c.nonNullUnboundRef().call(c))
+    assertEquals(S("ab"), c.nonNullUnboundRef().getter.call(c))
+
+    assertEquals(Unit, c.nonNullBoundRef().setter.call(S("cd")))
+    assertEquals(S("cd"), c.nonNullBoundRef().call())
+    assertEquals(S("cd"), c.nonNullBoundRef().getter.call())
+
+    assertEquals(Unit, c.nullableUnboundRef().setter.call(c, S("ab")))
+    assertEquals(S("ab"), c.nullableUnboundRef().call(c))
+    assertEquals(S("ab"), c.nullableUnboundRef().getter.call(c))
+
+    assertEquals(Unit, c.nullableBoundRef().setter.call(S("cd")))
+    assertEquals(S("cd"), c.nullableBoundRef().call())
+    assertEquals(S("cd"), c.nullableBoundRef().getter.call())
+
+    val nonNullTopLevel = ::nonNullTopLevel.apply { isAccessible = true }
+    assertEquals(Unit, nonNullTopLevel.setter.call(S("ef")))
+    assertEquals(S("ef"), nonNullTopLevel.call())
+    assertEquals(S("ef"), nonNullTopLevel.getter.call())
+
+    val nullableTopLevel = ::nullableTopLevel.apply { isAccessible = true }
+    assertEquals(Unit, nullableTopLevel.setter.call(S("ef")))
+    assertEquals(S("ef"), nullableTopLevel.call())
+    assertEquals(S("ef"), nullableTopLevel.getter.call())
+
+    return "OK"
+}