Fix type mapping of nullable inline class types in reflection

Based on #4761.

 #KT-31141 Fixed

Co-authored-by: wrongwrong <boranti1995@gmail.com>

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

@@ -2,7 +2,6 @@
 // WITH_REFLECT
 
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 inline class S(val x: String?)
 
@@ -32,32 +31,20 @@ fun box(): String {
     val z3 = S("3")
     val z4 = S("4")
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        val outer = ::Outer.call(z1, z2)
-        assertEquals(z1, outer.z1)
-        assertEquals(z2, outer.z2)
+    val outer = ::Outer.call(z1, z2)
+    assertEquals(z1, outer.z1)
+    assertEquals(z2, outer.z2)
 
-        assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-            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)
-        }
-    }
+    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)
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("S(x=1) S(x=2) S(x=3)", InlineNonNullOuter::Inner.call(inlineNonNullOuter, z2, z3).test)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("S(x=1) S(x=2) S(x=2)", inlineNonNullOuter::Inner.call(z2, z2).test)
-    }
+    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)
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("S(x=1) S(x=2) S(x=3)", InlineNullableOuter::Inner.call(inlineNullableOuter, z2, z3).test)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("S(x=1) S(x=2) S(x=2)", inlineNullableOuter::Inner.call(z2, z2).test)
-    }
+    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/nullableObject/fieldAccessors.kt

@@ -3,7 +3,6 @@
 
 import kotlin.reflect.jvm.isAccessible
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 inline class S(val value: String?) {
     operator fun plus(other: S): S = S(this.value!! + other.value!!)
@@ -32,17 +31,13 @@ fun box(): String {
     assertEquals(S("cd"), c.nonNullBoundRef().call())
     assertEquals(S("cd"), c.nonNullBoundRef().getter.call())
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        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.nullableUnboundRef().setter.call(c, S("ab")))
+    assertEquals(S("ab"), c.nullableUnboundRef().call(c))
+    assertEquals(S("ab"), c.nullableUnboundRef().getter.call(c))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, c.nullableBoundRef().setter.call(S("cd")))
-        assertEquals(S("cd"), c.nullableBoundRef().call())
-        assertEquals(S("cd"), c.nullableBoundRef().getter.call())
-    }
+    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")))
@@ -50,11 +45,9 @@ fun box(): String {
     assertEquals(S("ef"), nonNullTopLevel.getter.call())
 
     val nullableTopLevel = ::nullableTopLevel.apply { isAccessible = true }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, nullableTopLevel.setter.call(S("ef")))
-        assertEquals(S("ef"), nullableTopLevel.call())
-        assertEquals(S("ef"), nullableTopLevel.getter.call())
-    }
+    assertEquals(Unit, nullableTopLevel.setter.call(S("ef")))
+    assertEquals(S("ef"), nullableTopLevel.call())
+    assertEquals(S("ef"), nullableTopLevel.getter.call())
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/functionsWithInlineClassParameters.kt

@@ -23,26 +23,14 @@ fun S.extension3(): String = value!!
 fun S?.extension4(): String = this!!.value!!
 
 fun box(): String {
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("abc"), C::member.call(C(), S("a"), "b", S("c")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("def"), ::topLevel.call("d", S("e"), S("f")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("ghi"), S::extension1.call(S("g"), S("h"), S("i")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("jkl"), S::extension2.call(S("j"), S("k"), S("l")))
-    }
+    assertEquals(S("abc"), C::member.call(C(), S("a"), "b", S("c")))
+    assertEquals(S("def"), ::topLevel.call("d", S("e"), S("f")))
+    assertEquals(S("ghi"), S::extension1.call(S("g"), S("h"), S("i")))
+    assertEquals(S("jkl"), S::extension2.call(S("j"), S("k"), S("l")))
     assertEquals("_", S::extension3.call(S("_")))
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("_", S?::extension4.call(S("_")))
-    }
+    assertEquals("_", S?::extension4.call(S("_")))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("mno"), C()::member.call(S("m"), "n", S("o")))
-    }
+    assertEquals(S("mno"), C()::member.call(S("m"), "n", S("o")))
     assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
         assertEquals(S("pqr"), S("p")::extension1.call(S("q"), "r"))
     }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/jvmStaticFieldInObject.kt

@@ -5,7 +5,6 @@
 import kotlin.reflect.KMutableProperty1
 import kotlin.reflect.jvm.isAccessible
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 inline class S(val value: String?) {
     operator fun plus(other: S): S = S(this.value!! + other.value!!)
@@ -31,11 +30,9 @@ fun box(): String {
 
     val nullableUnboundRef = C::class.members.single { it.name == "p2" } as KMutableProperty1<C, S?>
     nullableUnboundRef.isAccessible = true
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, nullableUnboundRef.setter.call(C, S("ab")))
-        assertEquals(S("ab"), nullableUnboundRef.call(C))
-        assertEquals(S("ab"), nullableUnboundRef.getter.call(C))
-    }
+    assertEquals(Unit, nullableUnboundRef.setter.call(C, S("ab")))
+    assertEquals(S("ab"), nullableUnboundRef.call(C))
+    assertEquals(S("ab"), nullableUnboundRef.getter.call(C))
 
     val nonNullBoundRef = C.nonNullBoundRef()
     assertEquals(Unit, nonNullBoundRef.setter.call(S("cd")))
@@ -43,11 +40,9 @@ fun box(): String {
     assertEquals(S("cd"), nonNullBoundRef.getter.call())
 
     val nullableBoundRef = C.nullableBoundRef()
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, nullableBoundRef.setter.call(S("cd")))
-        assertEquals(S("cd"), nullableBoundRef.call())
-        assertEquals(S("cd"), nullableBoundRef.getter.call())
-    }
+    assertEquals(Unit, nullableBoundRef.setter.call(S("cd")))
+    assertEquals(S("cd"), nullableBoundRef.call())
+    assertEquals(S("cd"), nullableBoundRef.getter.call())
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/jvmStaticFunction.kt

@@ -4,7 +4,6 @@
 
 import kotlin.reflect.KFunction
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 inline class S(val value: String?) {
     operator fun plus(other: S): S = S(this.value!! + other.value!!)
@@ -23,22 +22,14 @@ interface I {
 }
 
 fun box(): String {
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("abc"), C::foo.call(S("a"), "b", S("c")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("def"), (I)::bar.call("d", S("e"), S("f")))
-    }
+    assertEquals(S("abc"), C::foo.call(S("a"), "b", S("c")))
+    assertEquals(S("def"), (I)::bar.call("d", S("e"), S("f")))
 
     val unboundFoo = C::class.members.single { it.name == "foo" } as KFunction<*>
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("ghi"), unboundFoo.call(C, S("g"), "h", S("i")))
-    }
+    assertEquals(S("ghi"), unboundFoo.call(C, S("g"), "h", S("i")))
 
     val unboundBar = I.Companion::class.members.single { it.name == "bar" } as KFunction<*>
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("jkl"), unboundBar.call(I, "j", S("k"), S("l")))
-    }
+    assertEquals(S("jkl"), unboundBar.call(I, "j", S("k"), S("l")))
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/nonOverridingFunOfInlineClass.kt

@@ -2,7 +2,6 @@
 // WITH_REFLECT
 
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 inline class S(val x: String?) {
     fun test(a: String, b: S, c: S?) = "$x$a${b.x}${c!!.x}"
@@ -20,26 +19,14 @@ fun box(): String {
     val plus = S("+")
     val aster = S("*")
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", S::test.call(S("42"), "-", plus, aster))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", S("42")::test.call("-", plus, aster))
-    }
+    assertEquals("42-+*", S::test.call(S("42"), "-", plus, aster))
+    assertEquals("42-+*", S("42")::test.call("-", plus, aster))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", Z::test.call(Z(42), "-", plus, aster))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", Z(42)::test.call("-", plus, aster))
-    }
+    assertEquals("42-+*", Z::test.call(Z(42), "-", plus, aster))
+    assertEquals("42-+*", Z(42)::test.call("-", plus, aster))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", A::test.call(A("42"), "-", plus, aster))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", A("42")::test.call("-", plus, aster))
-    }
+    assertEquals("42-+*", A::test.call(A("42"), "-", plus, aster))
+    assertEquals("42-+*", A("42")::test.call("-", plus, aster))
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/nonOverridingVarOfInlineClass.kt

@@ -2,7 +2,6 @@
 // WITH_REFLECT
 
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 var global = S("")
 
@@ -60,26 +59,14 @@ fun box(): String {
     assertEquals(S("S+42"), global)
 
     global = S("")
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S::nullableTest.call(S("42")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S("42")::nullableTest.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S::nullableTest.getter.call(S("42")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S("42")::nullableTest.getter.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        S::nullableTest.setter.call(S("42"), S("S-"))
-        assertEquals(S("S-42"), global)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        S("42")::nullableTest.setter.call(S("S+"))
-        assertEquals(S("S+42"), global)
-    }
+    assertEquals(S("42"), S::nullableTest.call(S("42")))
+    assertEquals(S("42"), S("42")::nullableTest.call())
+    assertEquals(S("42"), S::nullableTest.getter.call(S("42")))
+    assertEquals(S("42"), S("42")::nullableTest.getter.call())
+    S::nullableTest.setter.call(S("42"), S("S-"))
+    assertEquals(S("S-42"), global)
+    S("42")::nullableTest.setter.call(S("S+"))
+    assertEquals(S("S+42"), global)
 
     global = S("")
     assertEquals(S("42"), Z::nonNullTest.call(Z(42)))
@@ -92,26 +79,14 @@ fun box(): String {
     assertEquals(S("Z+42"), global)
 
     global = S("")
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z::nullableTest.call(Z(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z(42)::nullableTest.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z::nullableTest.getter.call(Z(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z(42)::nullableTest.getter.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        Z::nullableTest.setter.call(Z(42), S("Z-"))
-        assertEquals(S("Z-42"), global)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        Z(42)::nullableTest.setter.call(S("Z+"))
-        assertEquals(S("Z+42"), global)
-    }
+    assertEquals(S("42"), Z::nullableTest.call(Z(42)))
+    assertEquals(S("42"), Z(42)::nullableTest.call())
+    assertEquals(S("42"), Z::nullableTest.getter.call(Z(42)))
+    assertEquals(S("42"), Z(42)::nullableTest.getter.call())
+    Z::nullableTest.setter.call(Z(42), S("Z-"))
+    assertEquals(S("Z-42"), global)
+    Z(42)::nullableTest.setter.call(S("Z+"))
+    assertEquals(S("Z+42"), global)
 
     global = S("")
     assertEquals(S("42"), A::nonNullTest.call(A(42)))
@@ -124,26 +99,14 @@ fun box(): String {
     assertEquals(S("A+42"), global)
 
     global = S("")
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A::nullableTest.call(A(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A(42)::nullableTest.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A::nullableTest.getter.call(A(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A(42)::nullableTest.getter.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        A::nullableTest.setter.call(A(42), S("A-"))
-        assertEquals(S("A-42"), global)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        A(42)::nullableTest.setter.call(S("A+"))
-        assertEquals(S("A+42"), global)
-    }
+    assertEquals(S("42"), A::nullableTest.call(A(42)))
+    assertEquals(S("42"), A(42)::nullableTest.call())
+    assertEquals(S("42"), A::nullableTest.getter.call(A(42)))
+    assertEquals(S("42"), A(42)::nullableTest.getter.call())
+    A::nullableTest.setter.call(A(42), S("A-"))
+    assertEquals(S("A-42"), global)
+    A(42)::nullableTest.setter.call(S("A+"))
+    assertEquals(S("A+42"), global)
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/overridingFunOfInlineClass.kt

@@ -2,7 +2,6 @@
 // WITH_REFLECT
 
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 interface ITest {
     fun test(a: String, b: S, c: S?): String
@@ -24,26 +23,14 @@ fun box(): String {
     val plus = S("+")
     val aster = S("*")
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", S::test.call(S("42"), "-", plus, aster))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", S("42")::test.call("-", plus, aster))
-    }
+    assertEquals("42-+*", S::test.call(S("42"), "-", plus, aster))
+    assertEquals("42-+*", S("42")::test.call("-", plus, aster))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", Z::test.call(Z(42), "-", plus, aster))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", Z(42)::test.call("-", plus, aster))
-    }
+    assertEquals("42-+*", Z::test.call(Z(42), "-", plus, aster))
+    assertEquals("42-+*", Z(42)::test.call("-", plus, aster))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", A::test.call(A("42"), "-", plus, aster))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals("42-+*", A("42")::test.call("-", plus, aster))
-    }
+    assertEquals("42-+*", A::test.call(A("42"), "-", plus, aster))
+    assertEquals("42-+*", A("42")::test.call("-", plus, aster))
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/overridingVarOfInlineClass.kt

@@ -2,7 +2,6 @@
 // WITH_REFLECT
 
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 var global = S("")
 
@@ -65,26 +64,14 @@ fun box(): String {
     assertEquals(S("S+42"), global)
 
     global = S("")
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S::nullableTest.call(S("42")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S("42")::nullableTest.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S::nullableTest.getter.call(S("42")))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), S("42")::nullableTest.getter.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        S::nullableTest.setter.call(S("42"), S("S-"))
-        assertEquals(S("S-42"), global)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        S("42")::nullableTest.setter.call(S("S+"))
-        assertEquals(S("S+42"), global)
-    }
+    assertEquals(S("42"), S::nullableTest.call(S("42")))
+    assertEquals(S("42"), S("42")::nullableTest.call())
+    assertEquals(S("42"), S::nullableTest.getter.call(S("42")))
+    assertEquals(S("42"), S("42")::nullableTest.getter.call())
+    S::nullableTest.setter.call(S("42"), S("S-"))
+    assertEquals(S("S-42"), global)
+    S("42")::nullableTest.setter.call(S("S+"))
+    assertEquals(S("S+42"), global)
 
     global = S("")
     assertEquals(S("42"), Z::nonNullTest.call(Z(42)))
@@ -97,26 +84,14 @@ fun box(): String {
     assertEquals(S("Z+42"), global)
 
     global = S("")
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z::nullableTest.call(Z(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z(42)::nullableTest.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z::nullableTest.getter.call(Z(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), Z(42)::nullableTest.getter.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        Z::nullableTest.setter.call(Z(42), S("Z-"))
-        assertEquals(S("Z-42"), global)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        Z(42)::nullableTest.setter.call(S("Z+"))
-        assertEquals(S("Z+42"), global)
-    }
+    assertEquals(S("42"), Z::nullableTest.call(Z(42)))
+    assertEquals(S("42"), Z(42)::nullableTest.call())
+    assertEquals(S("42"), Z::nullableTest.getter.call(Z(42)))
+    assertEquals(S("42"), Z(42)::nullableTest.getter.call())
+    Z::nullableTest.setter.call(Z(42), S("Z-"))
+    assertEquals(S("Z-42"), global)
+    Z(42)::nullableTest.setter.call(S("Z+"))
+    assertEquals(S("Z+42"), global)
 
     global = S("")
     assertEquals(S("42"), A::nonNullTest.call(A(42)))
@@ -129,26 +104,14 @@ fun box(): String {
     assertEquals(S("A+42"), global)
 
     global = S("")
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A::nullableTest.call(A(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A(42)::nullableTest.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A::nullableTest.getter.call(A(42)))
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(S("42"), A(42)::nullableTest.getter.call())
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        A::nullableTest.setter.call(A(42), S("A-"))
-        assertEquals(S("A-42"), global)
-    }
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        A(42)::nullableTest.setter.call(S("A+"))
-        assertEquals(S("A+42"), global)
-    }
+    assertEquals(S("42"), A::nullableTest.call(A(42)))
+    assertEquals(S("42"), A(42)::nullableTest.call())
+    assertEquals(S("42"), A::nullableTest.getter.call(A(42)))
+    assertEquals(S("42"), A(42)::nullableTest.getter.call())
+    A::nullableTest.setter.call(A(42), S("A-"))
+    assertEquals(S("A-42"), global)
+    A(42)::nullableTest.setter.call(S("A+"))
+    assertEquals(S("A+42"), global)
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/properties.kt

@@ -3,7 +3,6 @@
 
 import kotlin.reflect.KMutableProperty2
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 
 inline class S(val value: String?) {
     operator fun plus(other: S): S = S(this.value!! + other.value!!)
@@ -61,17 +60,13 @@ fun box(): String {
     assertEquals(S("cd"), c::nonNullMember.call())
     assertEquals(S("cd"), c::nonNullMember.getter.call())
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, C::nullableMember.setter.call(c, S("ab")))
-        assertEquals(S("ab"), C::nullableMember.call(c))
-        assertEquals(S("ab"), C::nullableMember.getter.call(c))
-    }
+    assertEquals(Unit, C::nullableMember.setter.call(c, S("ab")))
+    assertEquals(S("ab"), C::nullableMember.call(c))
+    assertEquals(S("ab"), C::nullableMember.getter.call(c))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, c::nullableMember.setter.call(S("cd")))
-        assertEquals(S("cd"), c::nullableMember.call())
-        assertEquals(S("cd"), c::nullableMember.getter.call())
-    }
+    assertEquals(Unit, c::nullableMember.setter.call(S("cd")))
+    assertEquals(S("cd"), c::nullableMember.call())
+    assertEquals(S("cd"), c::nullableMember.getter.call())
 
     val nonNull_nonNullMemExt = C::class.members.single { it.name == "nonNull_nonNullMemExt" } as KMutableProperty2<C, S, S>
     assertEquals(Unit, nonNull_nonNullMemExt.setter.call(c, S(""), S("f")))
@@ -79,57 +74,43 @@ fun box(): String {
     assertEquals(S("ef"), nonNull_nonNullMemExt.getter.call(c, S("e")))
 
     val nonNull_nullableMemExt = C::class.members.single { it.name == "nonNull_nullableMemExt" } as KMutableProperty2<C, S, S?>
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, nonNull_nullableMemExt.setter.call(c, S(""), S("f")))
-        assertEquals(S("ef"), nonNull_nullableMemExt.call(c, S("e")))
-        assertEquals(S("ef"), nonNull_nullableMemExt.getter.call(c, S("e")))
-    }
+    assertEquals(Unit, nonNull_nullableMemExt.setter.call(c, S(""), S("f")))
+    assertEquals(S("ef"), nonNull_nullableMemExt.call(c, S("e")))
+    assertEquals(S("ef"), nonNull_nullableMemExt.getter.call(c, S("e")))
 
     val nullable_nonNullMemExt = C::class.members.single { it.name == "nullable_nonNullMemExt" } as KMutableProperty2<C, S?, S>
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, nullable_nonNullMemExt.setter.call(c, S(""), S("f")))
-        assertEquals(S("ef"), nullable_nonNullMemExt.call(c, S("e")))
-        assertEquals(S("ef"), nullable_nonNullMemExt.getter.call(c, S("e")))
-    }
+    assertEquals(Unit, nullable_nonNullMemExt.setter.call(c, S(""), S("f")))
+    assertEquals(S("ef"), nullable_nonNullMemExt.call(c, S("e")))
+    assertEquals(S("ef"), nullable_nonNullMemExt.getter.call(c, S("e")))
 
     val nullable_nullableMemExt = C::class.members.single { it.name == "nullable_nullableMemExt" } as KMutableProperty2<C, S?, S?>
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, nullable_nullableMemExt.setter.call(c, S(""), S("f")))
-        assertEquals(S("ef"), nullable_nullableMemExt.call(c, S("e")))
-        assertEquals(S("ef"), nullable_nullableMemExt.getter.call(c, S("e")))
-    }
+    assertEquals(Unit, nullable_nullableMemExt.setter.call(c, S(""), S("f")))
+    assertEquals(S("ef"), nullable_nullableMemExt.call(c, S("e")))
+    assertEquals(S("ef"), nullable_nullableMemExt.getter.call(c, S("e")))
 
     assertEquals(Unit, ::nonNullTopLevel.setter.call(S("gh")))
     assertEquals(S("gh"), ::nonNullTopLevel.call())
     assertEquals(S("gh"), ::nonNullTopLevel.getter.call())
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, ::nullableTopLevel.setter.call(S("gh")))
-        assertEquals(S("gh"), ::nullableTopLevel.call())
-        assertEquals(S("gh"), ::nullableTopLevel.getter.call())
-    }
+    assertEquals(Unit, ::nullableTopLevel.setter.call(S("gh")))
+    assertEquals(S("gh"), ::nullableTopLevel.call())
+    assertEquals(S("gh"), ::nullableTopLevel.getter.call())
 
     assertEquals(Unit, S::nonNull_nonNullExt.setter.call(S(""), S("j")))
     assertEquals(S("ij"), S::nonNull_nonNullExt.call(S("i")))
     assertEquals(S("ij"), S::nonNull_nonNullExt.getter.call(S("i")))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, S::nonNull_nullableExt.setter.call(S(""), S("j")))
-        assertEquals(S("ij"), S::nonNull_nullableExt.call(S("i")))
-        assertEquals(S("ij"), S::nonNull_nullableExt.getter.call(S("i")))
-    }
+    assertEquals(Unit, S::nonNull_nullableExt.setter.call(S(""), S("j")))
+    assertEquals(S("ij"), S::nonNull_nullableExt.call(S("i")))
+    assertEquals(S("ij"), S::nonNull_nullableExt.getter.call(S("i")))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, S?::nullable_nonNullExt.setter.call(S(""), S("j")))
-        assertEquals(S("ij"), S?::nullable_nonNullExt.call(S("i")))
-        assertEquals(S("ij"), S?::nullable_nonNullExt.getter.call(S("i")))
-    }
+    assertEquals(Unit, S?::nullable_nonNullExt.setter.call(S(""), S("j")))
+    assertEquals(S("ij"), S?::nullable_nonNullExt.call(S("i")))
+    assertEquals(S("ij"), S?::nullable_nonNullExt.getter.call(S("i")))
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        assertEquals(Unit, S?::nullable_nullableExt.setter.call(S(""), S("j")))
-        assertEquals(S("ij"), S?::nullable_nullableExt.call(S("i")))
-        assertEquals(S("ij"), S?::nullable_nullableExt.getter.call(S("i")))
-    }
+    assertEquals(Unit, S?::nullable_nullableExt.setter.call(S(""), S("j")))
+    assertEquals(S("ij"), S?::nullable_nullableExt.call(S("i")))
+    assertEquals(S("ij"), S?::nullable_nullableExt.getter.call(S("i")))
 
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject/suspendFunction.kt

@@ -5,7 +5,6 @@
 import kotlin.coroutines.startCoroutine
 import kotlin.reflect.full.callSuspend
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 import helpers.*
 
 inline class S(val value: String?)
@@ -37,34 +36,26 @@ fun box(): String {
         C::nonNullProduce.callSuspend(c).value!!
     }.let { assertEquals("nonNull", it) }
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        run0 {
-            C::nullableConsume.callSuspend(c, S("nullable"))
-            C::nullableProduce.callSuspend(c)!!.value!!
-        }.let { assertEquals("nullable", it) }
-    }
+    run0 {
+        C::nullableConsume.callSuspend(c, S("nullable"))
+        C::nullableProduce.callSuspend(c)!!.value!!
+    }.let { assertEquals("nullable", it) }
 
     run0 {
         C::nonNull_nonNullConsumeAndProduce.callSuspend(c, S("nonNull_nonNull")).value!!
     }.let { assertEquals("nonNull_nonNull", it) }
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        run0 {
-            C::nonNull_nullableConsumeAndProduce.callSuspend(c, S("nonNull_nullable"))!!.value!!
-        }.let { assertEquals("nonNull_nullable", it) }
-    }
+    run0 {
+        C::nonNull_nullableConsumeAndProduce.callSuspend(c, S("nonNull_nullable"))!!.value!!
+    }.let { assertEquals("nonNull_nullable", it) }
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        run0 {
-            C::nullable_nonNullConsumeAndProduce.callSuspend(c, S("nullable_nonNull")).value!!
-        }.let { assertEquals("nullable_nonNull", it) }
-    }
+    run0 {
+        C::nullable_nonNullConsumeAndProduce.callSuspend(c, S("nullable_nonNull")).value!!
+    }.let { assertEquals("nullable_nonNull", it) }
 
-    assertFailsWith<IllegalArgumentException>("Remove assertFailsWith and try again, as this problem may have been fixed.") {
-        run0 {
-            C::nullable_nullableConsumeAndProduce.callSuspend(c, S("nullable_nullable"))!!.value!!
-        }.let { assertEquals("nullable_nullable", it) }
-    }
+    run0 {
+        C::nullable_nullableConsumeAndProduce.callSuspend(c, S("nullable_nullable"))!!.value!!
+    }.let { assertEquals("nullable_nullable", it) }
 
     return "OK"
 }