Minor. Add tests

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnyGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+fun useX(x: X<String>): String = x.x
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X("OK") })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnyGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+fun useX(x: X<String>): String = x.x
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call(fun(): X<String> { return X("OK") }))

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxIntGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Int>(val x: T)
+
+fun useX(x: X<Int>): String = if (x.x == 42) "OK" else "fail: $x"
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X(42) })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+fun useX(x: X<String?>): String = x.x!!
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X("OK") })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+fun useX(x: X<String?>): String = if (x.x == null) "OK" else "fail: $x"
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X(null) })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Int?>(val x: T)
+
+fun useX(x: X<Int?>): String = if (x.x == 42) "OK" else "fail: $x"
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X(42) })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Int?>(val x: T)
+
+fun useX(x: X<Int?>): String = if (x.x == null) "OK" else "fail: $x"
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X(null) })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: String?>(val x: T)
+
+fun useX(x: X<String?>): String = x.x ?: "fail: $x"
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X("OK") })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: String?>(val x: T)
+
+fun useX(x: X<String?>): String = if (x.x == null) "OK" else "fail: $x"
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X(null) })

compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxStringGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: String>(val x: T)
+
+fun useX(x: X<String>): String = x.x
+
+fun <T> call(fn: () -> T) = fn()
+
+fun box() = useX(call { X("OK") })

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethodGenericInt.kt

@@ -0,0 +1,19 @@
+// IGNORE_BACKEND: JVM
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface X<T> {
+    operator fun plus(n: Int) : T
+    fun next(): T = this + 1
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class A<T: Int>(val value: T) : X<A<Int>> {
+    override operator fun plus(n: Int): A<Int> = A(value + n)
+}
+
+fun box(): String {
+    val res = A(1).next()
+    return if (res.value == 2) "OK" else "FAIL $res"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnyGeneric.kt

@@ -0,0 +1,36 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+interface IBar {
+    fun bar(): Any
+}
+
+interface IFoo : IBar {
+    fun foo(): Any
+    override fun bar(): X<String>
+}
+
+class TestX : IFoo {
+    override fun foo(): X<String> = X("O")
+    override fun bar(): X<String> = X("K")
+}
+
+fun box(): String {
+    val t: IFoo = TestX()
+    val tFoo = t.foo()
+    if (tFoo !is X<*>) {
+        throw AssertionError("X expected: $tFoo")
+    }
+
+    val t2: IBar = TestX()
+    val tBar = t.bar()
+    if (tBar !is X<*>) {
+        throw AssertionError("X expected: $tBar")
+    }
+
+    return (t.foo() as X<String>).x!!.toString() + (t2.bar() as X<String>).x!!.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric.kt

@@ -0,0 +1,36 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+interface IBar {
+    fun bar(): Any
+}
+
+interface IFoo : IBar {
+    fun foo(): Any
+    override fun bar(): X<String>
+}
+
+class TestX : IFoo {
+    override fun foo(): X<String> = X("O")
+    override fun bar(): X<String> = X("K")
+}
+
+fun box(): String {
+    val t: IFoo = TestX()
+    val tFoo = t.foo()
+    if (tFoo !is X<*>) {
+        throw AssertionError("X expected: $tFoo")
+    }
+
+    val t2: IBar = TestX()
+    val tBar = t.bar()
+    if (tBar !is X<*>) {
+        throw AssertionError("X expected: $tBar")
+    }
+
+    return (t.foo() as X<String>).x!!.toString() + (t2.bar() as X<String>).x!!.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnyGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+interface IFoo {
+    fun foo(): Any
+    fun bar(): X<String>
+}
+
+class TestX : IFoo {
+    override fun foo(): X<String> = X("O")
+    override fun bar(): X<String> = X("K")
+}
+
+fun box(): String {
+    val t: IFoo = TestX()
+    val tFoo = t.foo()
+    if (tFoo !is X<*>) {
+        throw AssertionError("X expected: $tFoo")
+    }
+
+    return (t.foo() as X<String>).x.toString() + t.bar().x.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceGeneric.kt

@@ -0,0 +1,33 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo {
+    fun foo(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class ICFoo<T: IFoo>(val t: T): IFoo {
+    override fun foo(): String = t.foo()
+}
+
+interface IBar {
+    fun bar(): IFoo
+}
+
+object FooOK : IFoo {
+    override fun foo(): String = "OK"
+}
+
+class Test : IBar {
+    override fun bar(): ICFoo<IFoo> = ICFoo(FooOK)
+}
+
+fun box(): String {
+    val test: IBar = Test()
+    val bar = test.bar()
+    if (bar !is ICFoo<*>) {
+        throw AssertionError("bar: $bar")
+    }
+    return bar.foo()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Char>(val x: T)
+
+interface IFoo {
+    fun foo(): Any
+    fun bar(): X<Char>
+}
+
+class TestX : IFoo {
+    override fun foo(): X<Char> = X('O')
+    override fun bar(): X<Char> = X('K')
+}
+
+fun box(): String {
+    val t: IFoo = TestX()
+    val tFoo = t.foo()
+    if (tFoo !is X<*>) {
+        throw AssertionError("X expected: $tFoo")
+    }
+
+    return (t.foo() as X<Char>).x.toString() + t.bar().x.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListGeneric.kt

@@ -0,0 +1,53 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFooList {
+    fun foo(): List<String>
+}
+
+interface IFooMutableList {
+    fun foo(): MutableList<String>
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class AL<T: MutableList<String>>(val t: T) : MutableList<String> {
+    override val size: Int get() = t.size
+    override fun get(index: Int): String = t.get(index)
+    override fun set(index: Int, element: String): String = t.set(index, element)
+    override fun contains(element: String): Boolean = t.contains(element)
+    override fun containsAll(elements: Collection<String>): Boolean = t.containsAll(elements)
+    override fun indexOf(element: String): Int = t.indexOf(element)
+    override fun isEmpty(): Boolean = t.isEmpty()
+    override fun iterator(): MutableIterator<String> = t.iterator()
+    override fun lastIndexOf(element: String): Int = t.lastIndexOf(element)
+    override fun add(element: String): Boolean = t.add(element)
+    override fun add(index: Int, element: String) = t.add(index, element)
+    override fun addAll(index: Int, elements: Collection<String>): Boolean = t.addAll(index, elements)
+    override fun addAll(elements: Collection<String>): Boolean = t.addAll(elements)
+    override fun listIterator(): MutableListIterator<String> = t.listIterator()
+    override fun listIterator(index: Int): MutableListIterator<String> = t.listIterator(index)
+    override fun clear() { t.clear() }
+    override fun remove(element: String): Boolean = t.remove(element)
+    override fun removeAll(elements: Collection<String>): Boolean = t.removeAll(elements)
+    override fun removeAt(index: Int): String = t.removeAt(index)
+    override fun retainAll(elements: Collection<String>): Boolean = t.retainAll(elements)
+    override fun subList(fromIndex: Int, toIndex: Int): MutableList<String> = t.subList(fromIndex, toIndex)
+}
+
+class Test : IFooList, IFooMutableList {
+    val arr = arrayListOf<String>()
+    override fun foo() = AL(arr)
+}
+
+fun box(): String {
+    val t1: IFooList = Test()
+    val list1 = t1.foo()
+    if (list1 !is AL<*>) throw AssertionError("list1: $list1")
+
+    val t2: IFooMutableList = Test()
+    val list2 = t2.foo()
+    if (list2 !is AL<*>) throw AssertionError("list2: $list2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesGeneric.kt

@@ -0,0 +1,43 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IQ1
+interface IQ2
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T): IQ1, IQ2
+
+interface IFoo1 {
+    fun foo(): IQ1
+}
+
+interface IFoo2 {
+    fun foo(): IQ2
+}
+
+class Test : IFoo1, IFoo2 {
+    override fun foo() = X("OK")
+}
+
+fun box(): String {
+    val t1: IFoo1 = Test()
+    val x1 = t1.foo()
+    if (x1 !is X<*>) {
+        throw AssertionError("x1: X expected: $x1")
+    }
+    if (x1.x != "OK") {
+        throw AssertionError("x1: ${x1.x}")
+    }
+
+    val t2: IFoo2 = Test()
+    val x2 = t2.foo()
+    if (x2 !is X<*>) {
+        throw AssertionError("x2: X expected: $x2")
+    }
+    if (x2.x != "OK") {
+        throw AssertionError("x2: ${x2.x}")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+interface IFoo<T> {
+    fun foo(): T
+    fun bar(): X<String>
+}
+
+class TestX : IFoo<X<String>> {
+    override fun foo(): X<String> = X("O")
+    override fun bar(): X<String> = X("K")
+}
+
+fun box(): String {
+    val t: IFoo<X<String>> = TestX()
+    val tFoo: Any = t.foo()
+    if (tFoo !is X<*>) {
+        throw AssertionError("X expected: $tFoo")
+    }
+
+    return (t.foo() as X<*>).x.toString() + t.bar().x.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedGeneric.kt

@@ -0,0 +1,49 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface GFoo<out T> {
+    fun foo(): T
+}
+
+interface IBar {
+    fun bar(): String
+}
+
+interface SFooBar : GFoo<IBar>
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: String>(val x: T) : IBar {
+    override fun bar(): String = x
+}
+
+class Test : SFooBar {
+    override fun foo() = X("OK")
+}
+
+fun box(): String {
+    val t1: SFooBar = Test()
+    val foo1 = t1.foo()
+    if (foo1 !is X<*>) {
+        throw AssertionError("foo1: $foo1")
+    }
+    val bar1 = foo1.bar()
+    if (bar1 != "OK") {
+        throw AssertionError("bar1: $bar1")
+    }
+
+    val t2: GFoo<Any> = Test()
+    val foo2 = t2.foo()
+    if (foo2 !is IBar) {
+        throw AssertionError("foo2 !is IBar: $foo2")
+    }
+    val bar2 = foo2.bar()
+    if (bar2 != "OK") {
+        throw AssertionError("bar2: $bar2")
+    }
+    if (foo2 !is X<*>) {
+        throw AssertionError("foo2 !is X: $foo2")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesGeneric.kt

@@ -0,0 +1,24 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: String>(val x: T)
+
+interface IFoo1<T> {
+    fun foo(x: T): X<String>
+}
+
+interface IFoo2 {
+    fun foo(x: String): X<String>
+}
+
+class Test : IFoo1<String>, IFoo2 {
+    override fun foo(x: String): X<String> = X(x)
+}
+
+fun box(): String {
+    val t1: IFoo1<String> = Test()
+    val t2: IFoo2 = Test()
+    return t1.foo("O").x + t2.foo("K").x
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class ResultOrClosed<T>(val x: T)
+
+interface A<T> {
+    fun foo(): T
+}
+
+class B : A<ResultOrClosed<String>> {
+    override fun foo(): ResultOrClosed<String> = ResultOrClosed("OK")
+}
+
+fun box(): String {
+    val foo: Any = (B() as A<ResultOrClosed<String>>).foo()
+    if (foo !is ResultOrClosed<*>) throw AssertionError("foo: $foo")
+    return foo.x.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Generic.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class FieldValue<T: String>(val value: T)
+
+enum class RequestFields {
+    ENUM_ONE
+}
+
+class RequestInputParameters(
+    private val backingMap: Map<RequestFields, FieldValue<String>>
+) : Map<RequestFields, FieldValue<String>> by backingMap
+
+fun box(): String {
+    val testMap1 = mapOf(RequestFields.ENUM_ONE to FieldValue("value1"))
+    val test1 = testMap1[RequestFields.ENUM_ONE]!!
+    if (test1.value != "value1") throw AssertionError("test1: $test1")
+
+    val testMap2 = RequestInputParameters(mapOf(RequestFields.ENUM_ONE to FieldValue("value2")))
+    val test2 = testMap2[RequestFields.ENUM_ONE]!!
+    if (test2.value != "value2") throw AssertionError("test2: $test2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Generic.kt

@@ -0,0 +1,21 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class NumberInlineClass<T: Double>(val value: T)
+
+interface TypeAdapter<FROM, TO> {
+    fun decode(string: FROM): TO
+}
+
+class StringToDoubleTypeAdapter : TypeAdapter<String, NumberInlineClass<Double>> {
+    override fun decode(string: String) = NumberInlineClass<Double>(string.toDouble())
+}
+
+fun box(): String {
+    val typeAdapter = StringToDoubleTypeAdapter()
+    val test = typeAdapter.decode("2019")
+    if (test.value != 2019.0) throw AssertionError("test: $test")
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Marker(val i: Int)
+
+interface I<T> {
+    fun foo(i: Marker) : T
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IC<T: Any>(val a: T)
+
+class C : I<IC<String>> {
+    override fun foo(i: Marker): IC<String> = IC("OK")
+}
+
+fun box(): String {
+    val i: I<IC<String>> = C()
+    val foo: IC<String> = i.foo(Marker(0))
+    if (foo.a != "OK") return "FAIL 1"
+    val foo1: IC<String> = C().foo(Marker(0))
+    if (foo1.a != "OK") return "FAIL 2"
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+interface IFoo<out T : X<String>?> {
+    fun foo(): T
+}
+
+class Test : IFoo<X<String>> {
+    override fun foo(): X<String> = X("OK")
+}
+
+fun box(): String {
+    val t1: IFoo<X<String>> = Test()
+    val x1 = t1.foo()
+    if (x1 != X("OK")) throw AssertionError("x1: $x1")
+
+    val t2 = Test()
+    val x2 = t2.foo()
+    if (x2 != X("OK")) throw AssertionError("x2: $x2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+interface IFoo<out T : X<String>?> {
+    fun foo(): T
+}
+
+class Test : IFoo<X<String>> {
+    override fun foo(): X<String> = X("OK")
+}
+
+fun box(): String {
+    val t1: IFoo<X<String>> = Test()
+    val x1 = t1.foo()
+    if (x1 != X("OK")) throw AssertionError("x1: $x1")
+
+    val t2 = Test()
+    val x2 = t2.foo()
+    if (x2 != X("OK")) throw AssertionError("x2: $x2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND: JS_IR
+// WITH_STDLIB
+// IGNORE_BACKEND: JS_IR_ES6
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+interface IFoo<out T : X<String?>?> {
+    fun foo(): T
+}
+
+class Test : IFoo<X<String?>?> {
+    override fun foo(): X<String?>? = X(null)
+}
+
+fun box(): String {
+    val t1: IFoo<X<String?>?> = Test()
+    val x1 = t1.foo()
+    if (x1 != X(null)) throw AssertionError("x1: $x1")
+
+    val t2 = Test()
+    val x2 = t2.foo()
+    if (x2 != X(null)) throw AssertionError("x2: $x2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnyGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+interface IFoo {
+    fun foo(): X<String>?
+}
+
+class Test : IFoo {
+    override fun foo(): X<String>? = X("OK")
+}
+
+fun box(): String {
+    val t1: IFoo = Test()
+    val x1 = t1.foo()
+    if (x1 != X("OK")) throw AssertionError("x1: $x1")
+
+    val t2 = Test()
+    val x2 = t2.foo()
+    if (x2 != X("OK")) throw AssertionError("x2: $x2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+interface IFoo {
+    fun foo(): X<String?>?
+}
+
+class Test : IFoo {
+    override fun foo(): X<String?>? = X("OK")
+}
+
+fun box(): String {
+    val t1: IFoo = Test()
+    val x1 = t1.foo()
+    if (x1 != X("OK")) throw AssertionError("x1: $x1")
+
+    val t2 = Test()
+    val x2 = t2.foo()
+    if (x2 != X("OK")) throw AssertionError("x2: $x2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T>(val x: T)
+
+interface IFoo {
+    fun foo(): X<String?>?
+}
+
+class Test : IFoo {
+    override fun foo(): X<String?>? = X(null)
+}
+
+fun box(): String {
+    val t1: IFoo = Test()
+    val x1 = t1.foo()
+    if (x1 != X(null)) throw AssertionError("x1: $x1")
+
+    val t2 = Test()
+    val x2 = t2.foo()
+    if (x2 != X(null)) throw AssertionError("x2: $x2")
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aGeneric.kt

@@ -0,0 +1,55 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IQ {
+    fun ok(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: IQ>(val t: T): IQ {
+    override fun ok(): String = t.ok()
+}
+
+interface IFoo1 {
+    fun foo(): Any
+}
+
+interface IFoo2 {
+    fun foo(): IQ
+}
+
+object OK : IQ {
+    override fun ok(): String = "OK"
+}
+
+class Test : IFoo1, IFoo2 {
+    override fun foo(): X<IQ> = X(OK)
+}
+
+fun box(): String {
+    val t1: IFoo1 = Test()
+    val foo1 = t1.foo()
+    if (foo1 !is IQ) {
+        throw AssertionError("foo1 !is IQ: $foo1")
+    }
+    val ok1 = foo1.ok()
+    if (ok1 != "OK") {
+        throw AssertionError("ok1: $ok1")
+    }
+    if (foo1 !is X<*>) {
+        throw AssertionError("foo1 !is X: $foo1")
+    }
+
+    val t2: IFoo2 = Test()
+    val foo2 = t2.foo()
+    if (foo2 !is X<*>) {
+        throw AssertionError("foo2 !is X: $foo2")
+    }
+    val ok2 = foo2.ok()
+    if (ok2 != "OK") {
+        throw AssertionError("ok1: $ok2")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bGeneric.kt

@@ -0,0 +1,55 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IQ {
+    fun ok(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: IQ>(val t: T): IQ {
+    override fun ok(): String = t.ok()
+}
+
+interface IFoo1 {
+    fun foo(): IQ
+}
+
+interface IFoo2 {
+    fun foo(): Any
+}
+
+object OK : IQ {
+    override fun ok(): String = "OK"
+}
+
+class Test : IFoo1, IFoo2 {
+    override fun foo(): X<IQ> = X(OK)
+}
+
+fun box(): String {
+    val t1: IFoo1 = Test()
+    val foo1 = t1.foo()
+    if (foo1 !is X<*>) {
+        throw AssertionError("foo1 !is X: $foo1")
+    }
+    val ok1 = foo1.ok()
+    if (ok1 != "OK") {
+        throw AssertionError("ok1: $ok1")
+    }
+
+    val t2: IFoo2 = Test()
+    val foo2 = t2.foo()
+    if (foo2 !is IQ) {
+        throw AssertionError("foo2 !is IQ: $foo2")
+    }
+    val ok2 = foo2.ok()
+    if (ok2 != "OK") {
+        throw AssertionError("ok2: $ok2")
+    }
+    if (foo2 !is X<*>) {
+        throw AssertionError("foo2 !is X: $foo2")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aGeneric.kt

@@ -0,0 +1,57 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IBase
+
+interface IQ : IBase {
+    fun ok(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: IQ>(val t: T): IQ {
+    override fun ok(): String = t.ok()
+}
+
+interface IFoo1 {
+    fun foo(): Any
+}
+
+interface IFoo2<T : IBase> {
+    fun foo(): T
+}
+
+object OK : IQ {
+    override fun ok(): String = "OK"
+}
+
+class Test : IFoo1, IFoo2<IQ> {
+    override fun foo(): X<IQ> = X(OK)
+}
+
+fun box(): String {
+    val t1: IFoo1 = Test()
+    val foo1 = t1.foo()
+    if (foo1 !is IQ) {
+        throw AssertionError("foo1 !is IQ: $foo1")
+    }
+    val ok1 = foo1.ok()
+    if (ok1 != "OK") {
+        throw AssertionError("ok1: $ok1")
+    }
+    if (foo1 !is X<*>) {
+        throw AssertionError("foo1 !is X: $foo1")
+    }
+
+    val t2: IFoo2<IQ> = Test()
+    val foo2 = t2.foo()
+    if (foo2 !is X<*>) {
+        throw AssertionError("foo2 !is X: $foo2")
+    }
+    val ok2 = foo2.ok()
+    if (ok2 != "OK") {
+        throw AssertionError("ok1: $ok2")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bGeneric.kt

@@ -0,0 +1,57 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IBase
+
+interface IQ : IBase {
+    fun ok(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: IQ>(val t: T): IQ {
+    override fun ok(): String = t.ok()
+}
+
+interface IFoo1<T : IBase> {
+    fun foo(): T
+}
+
+interface IFoo2 {
+    fun foo(): Any
+}
+
+object OK : IQ {
+    override fun ok(): String = "OK"
+}
+
+class Test : IFoo1<IQ>, IFoo2 {
+    override fun foo(): X<IQ> = X(OK)
+}
+
+fun box(): String {
+    val t1: IFoo1<IQ> = Test()
+    val foo1 = t1.foo()
+    if (foo1 !is X<*>) {
+        throw AssertionError("foo1 !is X: $foo1")
+    }
+    val ok1 = foo1.ok()
+    if (ok1 != "OK") {
+        throw AssertionError("ok1: $ok1")
+    }
+
+    val t2: IFoo2 = Test()
+    val foo2 = t2.foo()
+    if (foo2 !is IQ) {
+        throw AssertionError("foo2 !is IQ: $foo2")
+    }
+    val ok2 = foo2.ok()
+    if (ok2 != "OK") {
+        throw AssertionError("ok2: $ok2")
+    }
+    if (foo2 !is X<*>) {
+        throw AssertionError("foo2 !is X: $foo2")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackGeneric.kt

@@ -0,0 +1,19 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: Any>(val x: T)
+
+interface IFoo<T> {
+    fun foo(): T
+}
+
+class TestX : IFoo<X<String>> {
+    override fun foo(): X<String> = X("OK")
+}
+
+fun box(): String {
+    val t: IFoo<X<String>> = TestX()
+    return ((t.foo() as Any) as X<*>).x.toString()
+}

compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsGeneric.kt

@@ -0,0 +1,40 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo1<out T> {
+    fun foo(): T
+}
+
+interface IFoo2<out T> {
+    fun foo(): T
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class X<T: String>(val x: T)
+
+class Test : IFoo1<X<String>>, IFoo2<X<String>> {
+    override fun foo(): X<String> = X("OK")
+}
+
+fun box(): String {
+    val t1: IFoo1<Any> = Test()
+    val foo1 = t1.foo()
+    if (foo1 !is X<*>) {
+        throw AssertionError("foo1 !is X: $foo1")
+    }
+    if (foo1.x != "OK") {
+        throw AssertionError("foo1.x != 'OK': $foo1")
+    }
+
+    val t2: IFoo2<Any> = Test()
+    val foo2 = t2.foo()
+    if (foo2 !is X<*>) {
+        throw AssertionError("foo2 !is X: $foo2")
+    }
+    if (foo2.x != "OK") {
+        throw AssertionError("foo2.x != 'OK': $foo2")
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFunGeneric.kt

@@ -0,0 +1,24 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+fun Z<Int>.test() = x
+fun L<Long>.test() = x
+fun S<String>.test() = x
+
+fun box(): String {
+    if (Z(42)::test.invoke() != 42) throw AssertionError()
+    if (L(1234L)::test.invoke() != 1234L) throw AssertionError()
+    if (S("abcdef")::test.invoke() != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionValGeneric.kt

@@ -0,0 +1,24 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+val Z<Int>.xx get() = x
+val L<Long>.xx get() = x
+val S<String>.xx get() = x
+
+fun box(): String {
+    if (Z(42)::xx.get() != 42) throw AssertionError()
+    if (L(1234L)::xx.get() != 1234L) throw AssertionError()
+    if (S("abcdef")::xx.get() != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFunGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) {
+    fun test() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) {
+    fun test() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) {
+    fun test() = x
+}
+
+fun box(): String {
+    if (Z(42)::test.invoke() != 42) throw AssertionError()
+    if (L(1234L)::test.invoke() != 1234L) throw AssertionError()
+    if (S("abcdef")::test.invoke() != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberValGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) {
+    val xx get() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) {
+    val xx get() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) {
+    val xx get() = x
+}
+
+fun box(): String {
+    if (Z(42)::xx.get() != 42) throw AssertionError()
+    if (L(1234L)::xx.get() != 1234L) throw AssertionError()
+    if (S("abcdef")::xx.get() != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryValGeneric.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+fun box(): String {
+    if (Z(42)::x.get() != 42) throw AssertionError()
+    if (L(1234L)::x.get() != 1234L) throw AssertionError()
+    if (S("abcdef")::x.get() != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParametersGeneric.kt

@@ -0,0 +1,19 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+import kotlin.test.assertEquals
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+class Outer(val z1: Z<Int>) {
+    inner class Inner(val z2: Z<Int>)
+}
+
+fun box(): String {
+    assertEquals(Z(1), ::Outer.invoke(Z(1)).z1)
+    assertEquals(Z(2), Outer::Inner.invoke(Outer(Z(1)), Z(2)).z2)
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToStringGeneric.kt

@@ -0,0 +1,29 @@
+// IGNORE_BACKEND: WASM
+// WASM_MUTE_REASON: IGNORED_IN_JS
+// IGNORE_BACKEND: JS, JS_IR, JS_IR_ES6, NATIVE
+// WITH_REFLECT
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+import kotlin.test.*
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: String>(val s: T)
+
+fun box(): String {
+    val a = Z("a")
+    val b = Z("b")
+
+    val equals = Z<String>::equals
+    assertTrue(equals.call(a, a))
+    assertFalse(equals.call(a, b))
+
+    val hashCode = Z<String>::hashCode
+    assertEquals(a.s.hashCode(), hashCode.call(a))
+
+    val toString = Z<String>::toString
+    assertEquals("Z(s=${a.s})", toString.call(a))
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParametersGeneric.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+fun test(aZ: Z<Int>, aL: L<Long>, aS: S<String>) = "${aZ.x} ${aL.x} ${aS.x}"
+
+fun box(): String {
+    if (::test.invoke(Z(1), L(1L), S("abc")) != "1 1 abc") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFunGeneric.kt

@@ -0,0 +1,24 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+fun Z<Int>.test() = x
+fun L<Long>.test() = x
+fun S<String>.test() = x
+
+fun box(): String {
+    if (Z<Int>::test.invoke(Z(42)) != 42) throw AssertionError()
+    if (L<Long>::test.invoke(L(1234L)) != 1234L) throw AssertionError()
+    if (S<String>::test.invoke(S("abcdef")) != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionValGeneric.kt

@@ -0,0 +1,24 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+val Z<Int>.xx get() = x
+val L<Long>.xx get() = x
+val S<String>.xx get() = x
+
+fun box(): String {
+    if ((Z<Int>::xx).get(Z(42)) != 42) throw AssertionError()
+    if ((L<Long>::xx).get(L(1234L)) != 1234L) throw AssertionError()
+    if ((S<String>::xx).get(S("abcdef")) != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryValGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+import kotlin.test.assertEquals
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(internal val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(internal val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(internal val x: T)
+
+fun box(): String {
+    assertEquals(42, Z<Int>::x.get(Z(42)))
+    assertEquals(1234L, L<Long>::x.get(L(1234L)))
+    assertEquals("abc", S<String>::x.get(S("abc")))
+
+    assertEquals(42, Z<Int>::x.invoke(Z(42)))
+    assertEquals(1234L, L<Long>::x.invoke(L(1234L)))
+    assertEquals("abc", S<String>::x.invoke(S("abc")))
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFunGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) {
+    fun test() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) {
+    fun test() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) {
+    fun test() = x
+}
+
+fun box(): String {
+    if (Z<Int>::test.invoke(Z(42)) != 42) throw AssertionError()
+    if (L<Long>::test.invoke(L(1234L)) != 1234L) throw AssertionError()
+    if (S<String>::test.invoke(S("abcdef")) != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberValGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) {
+    val xx get() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) {
+    val xx get() = x
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) {
+    val xx get() = x
+}
+
+fun box(): String {
+    if ((Z<Int>::xx).get(Z(42)) != 42) throw AssertionError()
+    if ((L<Long>::xx).get(L(1234L)) != 1234L) throw AssertionError()
+    if ((S<String>::xx).get(S("abcdef")) != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructorGeneric.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+fun box(): String {
+    if (42.let(::Z).x != 42) throw AssertionError()
+    if (1234L.let(::L).x != 1234L) throw AssertionError()
+    if ("abcdef".let(::S).x != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryValGeneric.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T)
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T)
+
+fun box(): String {
+    if ((Z<Int>::x).get(Z(42)) != 42) throw AssertionError()
+    if ((L<Long>::x).get(L(1234L)) != 1234L) throw AssertionError()
+    if ((S<String>::x).get(S("abcdef")) != "abcdef") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryValGeneric.kt

@@ -0,0 +1,38 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+import kotlin.test.assertEquals
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(private val x: T) {
+    companion object {
+        val xref = Z<Int>::x
+    }
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(private val x: T) {
+    companion object {
+        val xref = L<Long>::x
+    }
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(private val x: T) {
+    companion object {
+        val xref = S<String>::x
+    }
+}
+
+fun box(): String {
+    assertEquals(42, Z.xref.get(Z(42)))
+    assertEquals(1234L, L.xref.get(L(1234L)))
+    assertEquals("abc", S.xref.get(S("abc")))
+
+    assertEquals(42, Z.xref.invoke(Z(42)))
+    assertEquals(1234L, L.xref.invoke(L(1234L)))
+    assertEquals("abc", S.xref.invoke(S("abc")))
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVarGeneric.kt

@@ -0,0 +1,21 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+class C(var z: Z<Int>)
+
+fun box(): String {
+    val x = C(Z(42))
+
+    val ref = x::z
+
+    if (ref.get().x != 42) throw AssertionError()
+
+    ref.set(Z(1234))
+    if (ref.get().x != 1234) throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVarGeneric.kt

@@ -0,0 +1,21 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+class C(var z: Z<Int>)
+
+fun box(): String {
+    val ref = C::z
+
+    val x = C(Z(42))
+
+    if (ref.get(x).x != 42) throw AssertionError()
+
+    ref.set(x, Z(1234))
+    if (ref.get(x).x != 1234) throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVarGeneric.kt

@@ -0,0 +1,19 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T)
+
+var topLevel = Z(42)
+
+fun box(): String {
+    val ref = ::topLevel
+
+    if (ref.get().x != 42) throw AssertionError()
+
+    ref.set(Z(1234))
+    if (ref.get().x != 1234) throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986Generic.kt

@@ -0,0 +1,27 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Any>(val x: T)
+
+fun useR(r: R<String>) {
+    if (r.x as String != "OK") throw AssertionError("$r")
+}
+
+fun useR0(fn: () -> R<String>) {
+    useR(fn())
+}
+
+fun useR1(r: R<String>, fn: (R<String>) -> R<String>) {
+    useR(fn(r))
+}
+
+fun fnWithDefaultR(r: R<String> = R("OK")) = r
+
+fun box(): String {
+    useR0(::fnWithDefaultR)
+    useR1(R("OK"), ::fnWithDefaultR)
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyGeneric.kt

@@ -0,0 +1,33 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T: Any>(val value: T)
+
+object Foo {
+    fun foo(value: Value<String>) {
+        res = value.value
+    }
+
+    fun bar(value: Value<String>?) {
+        res = value?.value
+    }
+}
+
+var res: String? = "FAIL"
+
+fun box(): String {
+    Value("OK").let(Foo::foo)
+    if (res != "OK") return "FAIL 1: $res"
+    res = "FAIL 2"
+
+    Value("OK").let(Foo::bar)
+    if (res != "OK") return "FAIL 3: $res"
+    res = "FAIL 4"
+
+    null.let(Foo::bar)
+    if (res != null) return "FAIL 5: $res"
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric.kt

@@ -0,0 +1,33 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T>(val value: T)
+
+object Foo {
+    fun foo(value: Value<String?>) {
+        res = value.value
+    }
+
+    fun bar(value: Value<String?>?) {
+        res = value?.value
+    }
+}
+
+var res: String? = "FAIL"
+
+fun box(): String {
+    Value<String?>("OK").let(Foo::foo)
+    if (res != "OK") return "FAIL 1: $res"
+    res = "FAIL 2"
+
+    Value<String?>("OK").let(Foo::bar)
+    if (res != "OK") return "FAIL 3: $res"
+    res = "FAIL 4"
+
+    null.let(Foo::bar)
+    if (res != null) return "FAIL 5: $res"
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/let/intGeneric.kt

@@ -0,0 +1,33 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T: Int>(val value: T)
+
+object Foo {
+    fun foo(value: Value<Int>) {
+        res = value.value
+    }
+
+    fun bar(value: Value<Int>?) {
+        res = value?.value
+    }
+}
+
+var res: Int? = 0
+
+fun box(): String {
+    Value(42).let(Foo::foo)
+    if (res != 42) return "FAIL 1 $res"
+    res = 0
+
+    Value(42).let(Foo::bar)
+    if (res != 42) return "FAIL 2 $res"
+    res = 0
+
+    null.let(Foo::bar)
+    if (res != null) return "FAIL 3: $res"
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric.kt

@@ -0,0 +1,33 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T: Int?>(val value: T)
+
+object Foo {
+    fun foo(value: Value<Int?>) {
+        res = value.value
+    }
+
+    fun bar(value: Value<Int?>?) {
+        res = value?.value
+    }
+}
+
+var res: Int? = 0
+
+fun box(): String {
+    Value<Int?>(42).let(Foo::foo)
+    if (res != 42) return "FAIL 1 $res"
+    res = 0
+
+    Value<Int?>(42).let(Foo::bar)
+    if (res != 42) return "FAIL 2 $res"
+    res = 0
+
+    null.let(Foo::bar)
+    if (res != null) return "FAIL 3: $res"
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/let/nullGeneric.kt

@@ -0,0 +1,10 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T: Any>(val value: T)
+
+fun foo(value: Value<String>?) = value?.value
+
+fun box(): String = (null as Value<String>?).let(::foo) ?: "OK"

compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringGeneric.kt

@@ -0,0 +1,32 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T: String>(val value: T)
+
+object Foo {
+    fun foo(value: Value<String>) {
+        res = value.value
+    }
+
+    fun bar(value: Value<String>?) {
+        res = value?.value
+    }
+}
+
+var res: String? = "FAIL"
+
+fun box(): String {
+    Value("OK").let(Foo::foo)
+    if (res != "OK") return "FAIL 1: $res"
+    res = "FAIL 2"
+
+    Value("OK").let(Foo::bar)
+    if (res != "OK") return "FAIL 3: $res"
+    res = "FAIL 4"
+
+    null.let(Foo::bar)
+    if (res != null) return "FAIL 3: $res"
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric.kt

@@ -0,0 +1,32 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Value<T: String?>(val value: T)
+
+object Foo {
+    fun foo(value: Value<String?>) {
+        res = value.value
+    }
+
+    fun bar(value: Value<String?>?) {
+        res = value?.value
+    }
+}
+
+var res: String? = "FAIL"
+
+fun box(): String {
+    Value<String?>("OK").let(Foo::foo)
+    if (res != "OK") return "FAIL 1: $res"
+    res = "FAIL 2"
+
+    Value<String?>("OK").let(Foo::bar)
+    if (res != "OK") return "FAIL 3: $res"
+    res = "FAIL 4"
+
+    null.let(Foo::bar)
+    if (res != null) return "FAIL 3: $res"
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2Generic.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Long>(private val r: T) {
+    fun test() = ok()
+
+    companion object {
+        private fun ok() = "OK"
+    }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethodGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = ok()
+
+    companion object {
+        private fun ok() = "OK"
+    }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanionGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Composed<T: String>(val s: T) {
+    private constructor(s1: String, s2: String) : this((s1 + s2) as T)
+
+    companion object {
+        fun p1(s: String) = Composed<String>("O", s)
+    }
+}
+
+fun box() = Composed.p1("K").s

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambdaGeneric.kt

@@ -0,0 +1,16 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Composed<T: String>(val s: T) {
+
+    constructor(s: String, x: Int) : this(s.subSequence(0, x).toString() as T)
+
+    private constructor(s1: String, s2: String) : this((s1 + s2) as T, 2)
+
+    fun p1(s2: String) =
+        { Composed<String>(s, s2) }
+}
+
+fun box() = Composed<String>("O").p1("K1234")().s

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2Generic.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Long>(private val r: T) {
+    private fun ok() = "OK"
+
+    companion object {
+        fun test(r: R<Long>) = r.ok()
+    }
+}
+
+fun box() = R.test(R(0))

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanionGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    private fun ok() = "OK"
+
+    companion object {
+        fun test(r: R<Int>) = r.ok()
+    }
+}
+
+fun box() = R.test(R(0))

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2Generic.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Long>(private val r: T) {
+    fun test() = run { ok() }
+
+    private fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = run { ok() }
+
+    private fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2Generic.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Long>(private val r: T) {
+    fun test() = { ok() }()
+
+    private fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambdaGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+fun <T> eval(fn: () -> T) = fn()
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = eval { ok() }
+
+    private fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateStaticInlineClassCompanionMethodGeneric.kt

@@ -0,0 +1,16 @@
+// TARGET_BACKEND: JVM
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = ok()
+
+    companion object {
+        @JvmStatic
+        private fun ok() = "OK"
+    }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2Generic.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Long>(private val r: T) {
+    fun test() = { ok() }()
+
+    fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambdaGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = { ok() }()
+
+    fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObjectGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = object {
+        override fun toString() = ok()
+    }.toString()
+
+    fun ok() = "OK"
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFunGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+inline fun runInline(fn: () -> String) = fn()
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = runInline { "OK" }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858Generic.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Direction<T: Int>(private val direction: T) {
+    fun dx() = dx[direction]
+    fun dy() = dy[direction]
+
+    companion object {
+        private val dx = intArrayOf(0, 1, 0, -1)
+        private val dy = intArrayOf(-1, 0, 1, 0)
+    }
+}
+
+fun box(): String {
+    val dirs = arrayOf(Direction(0), Direction(1), Direction(2), Direction(3))
+    val expectedDx = intArrayOf(0, 1, 0, -1)
+    val expectedDy = intArrayOf(-1, 0, 1, 0)
+    for (i in 0 .. 3) {
+        if (dirs[i].dx() != expectedDx[i]) throw AssertionError()
+        if (dirs[i].dy() != expectedDy[i]) throw AssertionError()
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513Generic.kt

@@ -0,0 +1,11 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class A<T: String>(val b: T) {
+    override fun toString(): String =
+        buildString { append(b) }
+}
+
+fun box() = A("OK").toString()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780Generic.kt

@@ -0,0 +1,18 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Test<T: Int>(val x: T) {
+    private companion object {
+        private const val CONSTANT = "OK"
+    }
+
+    fun crash() = getInlineConstant()
+
+    private inline fun getInlineConstant(): String {
+        return CONSTANT
+    }
+}
+
+fun box() = Test(1).crash()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFunGeneric.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+fun <T> eval(fn: () -> T) = fn()
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = eval { "OK" }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFunGeneric.kt

@@ -0,0 +1,13 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() =
+        object {
+            override fun toString() = "OK"
+        }.toString()
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFunGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = pf()
+
+    companion object {
+        private fun pf() = "OK"
+    }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionValGeneric.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class R<T: Int>(private val r: T) {
+    fun test() = pv
+
+    companion object {
+        private val pv = "OK"
+    }
+}
+
+fun box() = R(0).test()

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/all-compatibilityGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// !JVM_DEFAULT_MODE: all-compatibility
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(s: String = "K") = "dispatch$s"
+    fun Int.extension(s: String = "K") = "${this}extension$s"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path
+
+fun box(): String {
+    val rp = RealPath(1)
+    val res = "${rp.dispatch()};${rp.dispatch("KK")};" +
+            with(rp) {
+                "${1.extension()};${2.extension("KK")}"
+            }
+    if (res != "dispatchK;dispatchKK;1extensionK;2extensionKK") return res
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/allGeneric.kt

@@ -0,0 +1,27 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(s: String = "K") = "dispatch$s"
+    fun Int.extension(s: String = "K") = "${this}extension$s"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path
+
+fun box(): String {
+    val rp = RealPath(1)
+    val res = "${rp.dispatch()};${rp.dispatch("KK")};" +
+            with(rp) {
+                "${1.extension()};${2.extension("KK")}"
+            }
+    if (res != "dispatchK;dispatchKK;1extensionK;2extensionKK") return res
+    return "OK"
+}
+

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/compatibilityGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(s: String = "K") = "dispatch$s"
+    fun Int.extension(s: String = "K") = "${this}extension$s"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path
+
+fun box(): String {
+    val rp = RealPath(1)
+    val res = "${rp.dispatch()};${rp.dispatch("KK")};" +
+            with(rp) {
+                "${1.extension()};${2.extension("KK")}"
+            }
+    if (res != "dispatchK;dispatchKK;1extensionK;2extensionKK") return res
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/defaultGeneric.kt

@@ -0,0 +1,25 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(s: String = "K") = "dispatch$s"
+    fun Int.extension(s: String = "K") = "${this}extension$s"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path
+
+fun box(): String {
+    val rp = RealPath(1)
+    val res = "${rp.dispatch()};${rp.dispatch("KK")};" +
+            with(rp) {
+                "${1.extension()};${2.extension("KK")}"
+            }
+    if (res != "dispatchK;dispatchKK;1extensionK;2extensionKK") return res
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibilityGeneric.kt

@@ -0,0 +1,31 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// !JVM_DEFAULT_MODE: all-compatibility
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(maxDepth: Int = 42)
+    fun Int.extension(maxDepth: Int = 42)
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path {
+    override fun dispatch(maxDepth: Int) = Unit
+
+    fun childrenDispatch(recursively: Boolean): Unit =
+        if (recursively) dispatch() else dispatch()
+
+    override fun Int.extension(maxDepth: Int) = Unit
+
+    fun Int.childrenExtension(recursively: Boolean): Unit =
+        if (recursively) extension() else extension()
+}
+
+fun box(): String {
+    RealPath(1)
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/allGeneric.kt

@@ -0,0 +1,31 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(maxDepth: Int = 42)
+    fun Int.extension(maxDepth: Int = 42)
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path {
+    override fun dispatch(maxDepth: Int) = Unit
+
+    fun childrenDispatch(recursively: Boolean): Unit =
+        if (recursively) dispatch() else dispatch()
+
+    override fun Int.extension(maxDepth: Int) = Unit
+
+    fun Int.childrenExtension(recursively: Boolean): Unit =
+        if (recursively) extension() else extension()
+}
+
+fun box(): String {
+    RealPath(1)
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibilityGeneric.kt

@@ -0,0 +1,31 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(maxDepth: Int = 42)
+    fun Int.extension(maxDepth: Int = 42)
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path {
+    override fun dispatch(maxDepth: Int) = Unit
+
+    fun childrenDispatch(recursively: Boolean): Unit =
+        if (recursively) dispatch() else dispatch()
+
+    override fun Int.extension(maxDepth: Int) = Unit
+
+    fun Int.childrenExtension(recursively: Boolean): Unit =
+        if (recursively) extension() else extension()
+}
+
+fun box(): String {
+    RealPath(1)
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/defaultGeneric.kt

@@ -0,0 +1,30 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Path {
+    fun dispatch(maxDepth: Int = 42)
+    fun Int.extension(maxDepth: Int = 42)
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class RealPath<T: Int>(val x: T) : Path {
+    override fun dispatch(maxDepth: Int) = Unit
+
+    fun childrenDispatch(recursively: Boolean): Unit =
+        if (recursively) dispatch() else dispatch()
+
+    override fun Int.extension(maxDepth: Int) = Unit
+
+    fun Int.childrenExtension(recursively: Boolean): Unit =
+        if (recursively) extension() else extension()
+}
+
+fun box(): String {
+    RealPath(1)
+    return "OK"
+}