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"
+}

compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -16916,51 +16916,101 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxAnyGeneric.kt")
+            public void testBoxAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxFunLiteralAny.kt")
             public void testBoxFunLiteralAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxFunLiteralAnyGeneric.kt")
+            public void testBoxFunLiteralAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxInt.kt")
             public void testBoxInt() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxInt.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxIntGeneric.kt")
+            public void testBoxIntGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxIntGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxNullableAny.kt")
             public void testBoxNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxNullableAnyGeneric.kt")
+            public void testBoxNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxNullableAnyNull.kt")
             public void testBoxNullableAnyNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNull.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxNullableAnyNullGeneric.kt")
+            public void testBoxNullableAnyNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxNullableInt.kt")
             public void testBoxNullableInt() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableInt.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxNullableIntGeneric.kt")
+            public void testBoxNullableIntGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxNullableIntNull.kt")
             public void testBoxNullableIntNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNull.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxNullableIntNullGeneric.kt")
+            public void testBoxNullableIntNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxNullableString.kt")
             public void testBoxNullableString() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableString.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxNullableStringGeneric.kt")
+            public void testBoxNullableStringGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxNullableStringNull.kt")
             public void testBoxNullableStringNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNull.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxNullableStringNullGeneric.kt")
+            public void testBoxNullableStringNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boxString.kt")
             public void testBoxString() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxString.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxStringGeneric.kt")
+            public void testBoxStringGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxStringGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt27586_1.kt")
             public void testKt27586_1() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/kt27586_1.kt");
@@ -16981,6 +17031,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethod.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boxReturnValueInDefaultMethodGenericInt.kt")
+            public void ignoreBoxReturnValueInDefaultMethodGenericInt() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethodGenericInt.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             private void runTest(String testDataFilePath) throws Exception {
                 KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
@@ -16998,66 +17053,131 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideChainErasedToAnyGeneric.kt")
+            public void testCovariantOverrideChainErasedToAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("covariantOverrideChainErasedToNullableAny.kt")
             public void testCovariantOverrideChainErasedToNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideChainErasedToNullableAnyGeneric.kt")
+            public void testCovariantOverrideChainErasedToNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("covariantOverrideErasedToAny.kt")
             public void testCovariantOverrideErasedToAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideErasedToAnyGeneric.kt")
+            public void testCovariantOverrideErasedToAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("covariantOverrideErasedToInterface.kt")
             public void testCovariantOverrideErasedToInterface() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterface.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideErasedToInterfaceGeneric.kt")
+            public void testCovariantOverrideErasedToInterfaceGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("covariantOverrideErasedToPrimitive.kt")
             public void testCovariantOverrideErasedToPrimitive() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitive.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideErasedToPrimitiveGeneric.kt")
+            public void testCovariantOverrideErasedToPrimitiveGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("covariantOverrideListVsMutableList.kt")
             public void testCovariantOverrideListVsMutableList() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableList.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideListVsMutableListGeneric.kt")
+            public void testCovariantOverrideListVsMutableListGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("covariantOverrideUnrelatedInterfaces.kt")
             public void testCovariantOverrideUnrelatedInterfaces() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfaces.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("covariantOverrideUnrelatedInterfacesGeneric.kt")
+            public void testCovariantOverrideUnrelatedInterfacesGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("genericOverride.kt")
             public void testGenericOverride() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverride.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("genericOverrideGeneric.kt")
+            public void testGenericOverrideGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("genericOverrideSpecialized.kt")
             public void testGenericOverrideSpecialized() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecialized.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("genericOverrideSpecializedGeneric.kt")
+            public void testGenericOverrideSpecializedGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassInOverriddenReturnTypes.kt")
             public void testInlineClassInOverriddenReturnTypes() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypes.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassInOverriddenReturnTypesGeneric.kt")
+            public void testInlineClassInOverriddenReturnTypesGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt28483.kt")
             public void testKt28483() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt28483Generic.kt")
+            public void testKt28483Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt31585.kt")
             public void testKt31585() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt31585Generic.kt")
+            public void testKt31585Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt35234.kt")
             public void testKt35234() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt35234Generic.kt")
+            public void testKt35234Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt35234a.kt")
             public void testKt35234a() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234a.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
@@ -17068,65 +17188,130 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClass.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideGenericWithInlineClassGeneric.kt")
+            public void testOverrideGenericWithInlineClassGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt")
             public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt")
+            public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt")
             public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric.kt")
+            public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt")
             public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric.kt")
+            public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("overrideNullableInlineClassWithNonNullAny.kt")
             public void testOverrideNullableInlineClassWithNonNullAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideNullableInlineClassWithNonNullAnyGeneric.kt")
+            public void testOverrideNullableInlineClassWithNonNullAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("overrideNullableInlineClassWithNonNullNullableAny.kt")
             public void testOverrideNullableInlineClassWithNonNullNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt")
+            public void testOverrideNullableInlineClassWithNonNullNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNull.kt")
             public void testOverrideNullableInlineClassWithNonNullNullableAnyNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNull.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt")
+            public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("relatedReturnTypes1a.kt")
             public void testRelatedReturnTypes1a() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1a.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("relatedReturnTypes1aGeneric.kt")
+            public void testRelatedReturnTypes1aGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("relatedReturnTypes1b.kt")
             public void testRelatedReturnTypes1b() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1b.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("relatedReturnTypes1bGeneric.kt")
+            public void testRelatedReturnTypes1bGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("relatedReturnTypes2a.kt")
             public void testRelatedReturnTypes2a() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2a.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("relatedReturnTypes2aGeneric.kt")
+            public void testRelatedReturnTypes2aGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("relatedReturnTypes2b.kt")
             public void testRelatedReturnTypes2b() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2b.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("relatedReturnTypes2bGeneric.kt")
+            public void testRelatedReturnTypes2bGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("uncastInlineClassToAnyAndBack.kt")
             public void testUncastInlineClassToAnyAndBack() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBack.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("uncastInlineClassToAnyAndBackGeneric.kt")
+            public void testUncastInlineClassToAnyAndBackGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("unrelatedGenerics.kt")
             public void testUnrelatedGenerics() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenerics.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
+
+            @TestMetadata("unrelatedGenericsGeneric.kt")
+            public void testUnrelatedGenericsGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
         }
 
         @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences")
@@ -17150,101 +17335,201 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boundInlineClassExtensionFunGeneric.kt")
+            public void testBoundInlineClassExtensionFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boundInlineClassExtensionVal.kt")
             public void testBoundInlineClassExtensionVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boundInlineClassExtensionValGeneric.kt")
+            public void testBoundInlineClassExtensionValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boundInlineClassMemberFun.kt")
             public void testBoundInlineClassMemberFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boundInlineClassMemberFunGeneric.kt")
+            public void testBoundInlineClassMemberFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boundInlineClassMemberVal.kt")
             public void testBoundInlineClassMemberVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boundInlineClassMemberValGeneric.kt")
+            public void testBoundInlineClassMemberValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("boundInlineClassPrimaryVal.kt")
             public void testBoundInlineClassPrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("boundInlineClassPrimaryValGeneric.kt")
+            public void testBoundInlineClassPrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("constructorWithInlineClassParameters.kt")
             public void testConstructorWithInlineClassParameters() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParameters.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("constructorWithInlineClassParametersGeneric.kt")
+            public void testConstructorWithInlineClassParametersGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParametersGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("equalsHashCodeToString.kt")
             public void testEqualsHashCodeToString() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToString.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("equalsHashCodeToStringGeneric.kt")
+            public void testEqualsHashCodeToStringGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToStringGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("funWithInlineClassParameters.kt")
             public void testFunWithInlineClassParameters() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParameters.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("funWithInlineClassParametersGeneric.kt")
+            public void testFunWithInlineClassParametersGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParametersGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassExtensionFun.kt")
             public void testInlineClassExtensionFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassExtensionFunGeneric.kt")
+            public void testInlineClassExtensionFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassExtensionVal.kt")
             public void testInlineClassExtensionVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassExtensionValGeneric.kt")
+            public void testInlineClassExtensionValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassInternalPrimaryVal.kt")
             public void testInlineClassInternalPrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassInternalPrimaryValGeneric.kt")
+            public void testInlineClassInternalPrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassMemberFun.kt")
             public void testInlineClassMemberFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassMemberFunGeneric.kt")
+            public void testInlineClassMemberFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassMemberVal.kt")
             public void testInlineClassMemberVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassMemberValGeneric.kt")
+            public void testInlineClassMemberValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassPrimaryConstructor.kt")
             public void testInlineClassPrimaryConstructor() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructor.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassPrimaryConstructorGeneric.kt")
+            public void testInlineClassPrimaryConstructorGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructorGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassPrimaryVal.kt")
             public void testInlineClassPrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassPrimaryValGeneric.kt")
+            public void testInlineClassPrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassPrivatePrimaryVal.kt")
             public void testInlineClassPrivatePrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassPrivatePrimaryValGeneric.kt")
+            public void testInlineClassPrivatePrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassTypeBoundMemberVar.kt")
             public void testInlineClassTypeBoundMemberVar() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVar.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassTypeBoundMemberVarGeneric.kt")
+            public void testInlineClassTypeBoundMemberVarGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVarGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassTypeMemberVar.kt")
             public void testInlineClassTypeMemberVar() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVar.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassTypeMemberVarGeneric.kt")
+            public void testInlineClassTypeMemberVarGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVarGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineClassTypeTopLevelVar.kt")
             public void testInlineClassTypeTopLevelVar() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVar.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineClassTypeTopLevelVarGeneric.kt")
+            public void testInlineClassTypeTopLevelVarGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVarGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt37986.kt")
             public void testKt37986() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt37986Generic.kt")
+            public void testKt37986Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences/let")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
@@ -17266,26 +17551,51 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/any.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("anyGeneric.kt")
+                public void testAnyGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("anyN.kt")
                 public void testAnyN() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyN.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("anyNGeneric.kt")
+                public void testAnyNGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("int.kt")
                 public void testInt() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/int.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("intGeneric.kt")
+                public void testIntGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("intN.kt")
                 public void testIntN() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intN.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("intNGeneric.kt")
+                public void testIntNGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("null.kt")
                 public void testNull() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/null.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("nullGeneric.kt")
+                public void testNullGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/nullGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("result.kt")
                 public void testResult() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/result.kt");
@@ -17296,10 +17606,20 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/string.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("stringGeneric.kt")
+                public void testStringGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("stringN.kt")
                 public void testStringN() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringN.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
+
+                @TestMetadata("stringNGeneric.kt")
+                public void testStringNGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
             }
         }
 
@@ -17325,16 +17645,36 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateInlineClassCompanionMethod2Generic.kt")
+            public void testAccessPrivateInlineClassCompanionMethod2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
+            @TestMetadata("accessPrivateInlineClassCompanionMethodGeneric.kt")
+            public void testAccessPrivateInlineClassCompanionMethodGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethodGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("accessPrivateInlineClassConstructorFromCompanion.kt")
             public void testAccessPrivateInlineClassConstructorFromCompanion() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanion.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateInlineClassConstructorFromCompanionGeneric.kt")
+            public void testAccessPrivateInlineClassConstructorFromCompanionGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanionGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("accessPrivateInlineClassConstructorFromLambda.kt")
             public void testAccessPrivateInlineClassConstructorFromLambda() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambda.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateInlineClassConstructorFromLambdaGeneric.kt")
+            public void testAccessPrivateInlineClassConstructorFromLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambdaGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("accessPrivateInlineClassMethodFromCompanion.kt")
             public void testAccessPrivateInlineClassMethodFromCompanion() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
@@ -17345,6 +17685,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateInlineClassMethodFromCompanion2Generic.kt")
+            public void testAccessPrivateInlineClassMethodFromCompanion2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
+            @TestMetadata("accessPrivateInlineClassMethodFromCompanionGeneric.kt")
+            public void testAccessPrivateInlineClassMethodFromCompanionGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanionGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda.kt")
             public void testAccessPrivateInlineClassMethodFromInlineLambda() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
@@ -17355,6 +17705,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda2Generic.kt")
+            public void testAccessPrivateInlineClassMethodFromInlineLambda2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
+            @TestMetadata("accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt")
+            public void testAccessPrivateInlineClassMethodFromInlineLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("accessPrivateInlineClassMethodFromLambda.kt")
             public void testAccessPrivateInlineClassMethodFromLambda() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
@@ -17365,11 +17725,26 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateInlineClassMethodFromLambda2Generic.kt")
+            public void testAccessPrivateInlineClassMethodFromLambda2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
+            @TestMetadata("accessPrivateInlineClassMethodFromLambdaGeneric.kt")
+            public void testAccessPrivateInlineClassMethodFromLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambdaGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("accessPrivateStaticInlineClassCompanionMethod.kt")
             public void testAccessPrivateStaticInlineClassCompanionMethod() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateStaticInlineClassCompanionMethod.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("accessPrivateStaticInlineClassCompanionMethodGeneric.kt")
+            public void testAccessPrivateStaticInlineClassCompanionMethodGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateStaticInlineClassCompanionMethodGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             public void testAllFilesPresentInContextsAndAccessors() throws Exception {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
             }
@@ -17384,50 +17759,105 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("captureInlineClassInstanceInLambda2Generic.kt")
+            public void testCaptureInlineClassInstanceInLambda2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
+            @TestMetadata("captureInlineClassInstanceInLambdaGeneric.kt")
+            public void testCaptureInlineClassInstanceInLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambdaGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("captureInlineClassInstanceInObject.kt")
             public void testCaptureInlineClassInstanceInObject() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObject.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("captureInlineClassInstanceInObjectGeneric.kt")
+            public void testCaptureInlineClassInstanceInObjectGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObjectGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("inlineLambdaInInlineClassFun.kt")
             public void testInlineLambdaInInlineClassFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("inlineLambdaInInlineClassFunGeneric.kt")
+            public void testInlineLambdaInInlineClassFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt26858.kt")
             public void testKt26858() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt26858Generic.kt")
+            public void testKt26858Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt27513.kt")
             public void testKt27513() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt27513Generic.kt")
+            public void testKt27513Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("kt30780.kt")
             public void testKt30780() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("kt30780Generic.kt")
+            public void testKt30780Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("lambdaInInlineClassFun.kt")
             public void testLambdaInInlineClassFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("lambdaInInlineClassFunGeneric.kt")
+            public void testLambdaInInlineClassFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("objectInInlineClassFun.kt")
             public void testObjectInInlineClassFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("objectInInlineClassFunGeneric.kt")
+            public void testObjectInInlineClassFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("toPrivateCompanionFun.kt")
             public void testToPrivateCompanionFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFun.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
 
+            @TestMetadata("toPrivateCompanionFunGeneric.kt")
+            public void testToPrivateCompanionFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFunGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
+
             @TestMetadata("toPrivateCompanionVal.kt")
             public void testToPrivateCompanionVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionVal.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
             }
+
+            @TestMetadata("toPrivateCompanionValGeneric.kt")
+            public void testToPrivateCompanionValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionValGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+            }
         }
 
         @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues")
@@ -17515,21 +17945,41 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/all.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("allGeneric.kt")
+                public void ignoreAllGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/allGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("all-compatibility.kt")
                 public void ignoreAll_compatibility() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/all-compatibility.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("all-compatibilityGeneric.kt")
+                public void ignoreAll_compatibilityGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/all-compatibilityGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("compatibility.kt")
                 public void ignoreCompatibility() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/compatibility.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("compatibilityGeneric.kt")
+                public void ignoreCompatibilityGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/compatibilityGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("default.kt")
                 public void ignoreDefault() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/default.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("defaultGeneric.kt")
+                public void ignoreDefaultGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/defaultGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 private void runTest(String testDataFilePath) throws Exception {
                     KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
@@ -17552,21 +18002,41 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("allGeneric.kt")
+                public void ignoreAllGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/allGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("all-compatibility.kt")
                 public void ignoreAll_compatibility() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("all-compatibilityGeneric.kt")
+                public void ignoreAll_compatibilityGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibilityGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("compatibility.kt")
                 public void ignoreCompatibility() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("compatibilityGeneric.kt")
+                public void ignoreCompatibilityGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibilityGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 @TestMetadata("default.kt")
                 public void ignoreDefault() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
                 }
 
+                @TestMetadata("defaultGeneric.kt")
+                public void ignoreDefaultGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/defaultGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+                }
+
                 private void runTest(String testDataFilePath) throws Exception {
                     KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }

core/compiler.common.jvm/src/org/jetbrains/kotlin/types/expandedTypeUtils.kt

@@ -33,7 +33,7 @@ private fun TypeSystemCommonBackendContext.computeExpandedTypeInner(
         classifier.isInlineClass() -> {
             // kotlinType is the boxed inline class type
 
-            val underlyingType = kotlinType.getSubstitutedUnderlyingType() ?: return null
+            val underlyingType = kotlinType.getUnsubstitutedUnderlyingType() ?: return null
             val expandedUnderlyingType = computeExpandedTypeInner(underlyingType, visitedClassifiers) ?: return null
             when {
                 !kotlinType.isNullableType() -> expandedUnderlyingType

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java

@@ -15990,60 +15990,120 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxAnyGeneric.kt")
+            public void testBoxAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxFunLiteralAny.kt")
             public void testBoxFunLiteralAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxFunLiteralAnyGeneric.kt")
+            public void testBoxFunLiteralAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxInt.kt")
             public void testBoxInt() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxIntGeneric.kt")
+            public void testBoxIntGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxNullableAny.kt")
             public void testBoxNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxNullableAnyGeneric.kt")
+            public void testBoxNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxNullableAnyNull.kt")
             public void testBoxNullableAnyNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxNullableAnyNullGeneric.kt")
+            public void testBoxNullableAnyNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxNullableInt.kt")
             public void testBoxNullableInt() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxNullableIntGeneric.kt")
+            public void testBoxNullableIntGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxNullableIntNull.kt")
             public void testBoxNullableIntNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxNullableIntNullGeneric.kt")
+            public void testBoxNullableIntNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxNullableString.kt")
             public void testBoxNullableString() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxNullableStringGeneric.kt")
+            public void testBoxNullableStringGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxNullableStringNull.kt")
             public void testBoxNullableStringNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxNullableStringNullGeneric.kt")
+            public void testBoxNullableStringNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boxString.kt")
             public void testBoxString() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxStringGeneric.kt")
+            public void testBoxStringGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt27586_1.kt")
             public void testKt27586_1() throws Exception {
@@ -16072,84 +16132,168 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boxReturnValueInDefaultMethodGenericInt.kt")
+            public void testBoxReturnValueInDefaultMethodGenericInt() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethodGenericInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideChainErasedToAny.kt")
             public void testCovariantOverrideChainErasedToAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideChainErasedToAnyGeneric.kt")
+            public void testCovariantOverrideChainErasedToAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideChainErasedToNullableAny.kt")
             public void testCovariantOverrideChainErasedToNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideChainErasedToNullableAnyGeneric.kt")
+            public void testCovariantOverrideChainErasedToNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideErasedToAny.kt")
             public void testCovariantOverrideErasedToAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideErasedToAnyGeneric.kt")
+            public void testCovariantOverrideErasedToAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideErasedToInterface.kt")
             public void testCovariantOverrideErasedToInterface() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideErasedToInterfaceGeneric.kt")
+            public void testCovariantOverrideErasedToInterfaceGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideErasedToPrimitive.kt")
             public void testCovariantOverrideErasedToPrimitive() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideErasedToPrimitiveGeneric.kt")
+            public void testCovariantOverrideErasedToPrimitiveGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideListVsMutableList.kt")
             public void testCovariantOverrideListVsMutableList() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableList.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideListVsMutableListGeneric.kt")
+            public void testCovariantOverrideListVsMutableListGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("covariantOverrideUnrelatedInterfaces.kt")
             public void testCovariantOverrideUnrelatedInterfaces() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfaces.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("covariantOverrideUnrelatedInterfacesGeneric.kt")
+            public void testCovariantOverrideUnrelatedInterfacesGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("genericOverride.kt")
             public void testGenericOverride() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("genericOverrideGeneric.kt")
+            public void testGenericOverrideGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("genericOverrideSpecialized.kt")
             public void testGenericOverrideSpecialized() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecialized.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("genericOverrideSpecializedGeneric.kt")
+            public void testGenericOverrideSpecializedGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassInOverriddenReturnTypes.kt")
             public void testInlineClassInOverriddenReturnTypes() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassInOverriddenReturnTypesGeneric.kt")
+            public void testInlineClassInOverriddenReturnTypesGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt28483.kt")
             public void testKt28483() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt28483Generic.kt")
+            public void testKt28483Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt31585.kt")
             public void testKt31585() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt31585Generic.kt")
+            public void testKt31585Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt35234.kt")
             public void testKt35234() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt35234Generic.kt")
+            public void testKt35234Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt35234a.kt")
             public void testKt35234a() throws Exception {
@@ -16162,77 +16306,155 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideGenericWithInlineClassGeneric.kt")
+            public void testOverrideGenericWithInlineClassGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt")
             public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt")
+            public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt")
             public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric.kt")
+            public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt")
             public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric.kt")
+            public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("overrideNullableInlineClassWithNonNullAny.kt")
             public void testOverrideNullableInlineClassWithNonNullAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideNullableInlineClassWithNonNullAnyGeneric.kt")
+            public void testOverrideNullableInlineClassWithNonNullAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("overrideNullableInlineClassWithNonNullNullableAny.kt")
             public void testOverrideNullableInlineClassWithNonNullNullableAny() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt")
+            public void testOverrideNullableInlineClassWithNonNullNullableAnyGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNull.kt")
             public void testOverrideNullableInlineClassWithNonNullNullableAnyNull() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt")
+            public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("relatedReturnTypes1a.kt")
             public void testRelatedReturnTypes1a() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("relatedReturnTypes1aGeneric.kt")
+            public void testRelatedReturnTypes1aGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("relatedReturnTypes1b.kt")
             public void testRelatedReturnTypes1b() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("relatedReturnTypes1bGeneric.kt")
+            public void testRelatedReturnTypes1bGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("relatedReturnTypes2a.kt")
             public void testRelatedReturnTypes2a() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("relatedReturnTypes2aGeneric.kt")
+            public void testRelatedReturnTypes2aGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("relatedReturnTypes2b.kt")
             public void testRelatedReturnTypes2b() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("relatedReturnTypes2bGeneric.kt")
+            public void testRelatedReturnTypes2bGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("uncastInlineClassToAnyAndBack.kt")
             public void testUncastInlineClassToAnyAndBack() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBack.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("uncastInlineClassToAnyAndBackGeneric.kt")
+            public void testUncastInlineClassToAnyAndBackGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("unrelatedGenerics.kt")
             public void testUnrelatedGenerics() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenerics.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
+
+            @Test
+            @TestMetadata("unrelatedGenericsGeneric.kt")
+            public void testUnrelatedGenericsGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
         }
 
         @Nested
@@ -16250,120 +16472,240 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boundInlineClassExtensionFunGeneric.kt")
+            public void testBoundInlineClassExtensionFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boundInlineClassExtensionVal.kt")
             public void testBoundInlineClassExtensionVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boundInlineClassExtensionValGeneric.kt")
+            public void testBoundInlineClassExtensionValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boundInlineClassMemberFun.kt")
             public void testBoundInlineClassMemberFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boundInlineClassMemberFunGeneric.kt")
+            public void testBoundInlineClassMemberFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boundInlineClassMemberVal.kt")
             public void testBoundInlineClassMemberVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boundInlineClassMemberValGeneric.kt")
+            public void testBoundInlineClassMemberValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("boundInlineClassPrimaryVal.kt")
             public void testBoundInlineClassPrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("boundInlineClassPrimaryValGeneric.kt")
+            public void testBoundInlineClassPrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("constructorWithInlineClassParameters.kt")
             public void testConstructorWithInlineClassParameters() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("constructorWithInlineClassParametersGeneric.kt")
+            public void testConstructorWithInlineClassParametersGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("equalsHashCodeToString.kt")
             public void testEqualsHashCodeToString() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("equalsHashCodeToStringGeneric.kt")
+            public void testEqualsHashCodeToStringGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("funWithInlineClassParameters.kt")
             public void testFunWithInlineClassParameters() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("funWithInlineClassParametersGeneric.kt")
+            public void testFunWithInlineClassParametersGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassExtensionFun.kt")
             public void testInlineClassExtensionFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassExtensionFunGeneric.kt")
+            public void testInlineClassExtensionFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassExtensionVal.kt")
             public void testInlineClassExtensionVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassExtensionValGeneric.kt")
+            public void testInlineClassExtensionValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassInternalPrimaryVal.kt")
             public void testInlineClassInternalPrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassInternalPrimaryValGeneric.kt")
+            public void testInlineClassInternalPrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassMemberFun.kt")
             public void testInlineClassMemberFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassMemberFunGeneric.kt")
+            public void testInlineClassMemberFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassMemberVal.kt")
             public void testInlineClassMemberVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassMemberValGeneric.kt")
+            public void testInlineClassMemberValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassPrimaryConstructor.kt")
             public void testInlineClassPrimaryConstructor() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassPrimaryConstructorGeneric.kt")
+            public void testInlineClassPrimaryConstructorGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassPrimaryVal.kt")
             public void testInlineClassPrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassPrimaryValGeneric.kt")
+            public void testInlineClassPrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassPrivatePrimaryVal.kt")
             public void testInlineClassPrivatePrimaryVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassPrivatePrimaryValGeneric.kt")
+            public void testInlineClassPrivatePrimaryValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassTypeBoundMemberVar.kt")
             public void testInlineClassTypeBoundMemberVar() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassTypeBoundMemberVarGeneric.kt")
+            public void testInlineClassTypeBoundMemberVarGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassTypeMemberVar.kt")
             public void testInlineClassTypeMemberVar() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassTypeMemberVarGeneric.kt")
+            public void testInlineClassTypeMemberVarGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineClassTypeTopLevelVar.kt")
             public void testInlineClassTypeTopLevelVar() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineClassTypeTopLevelVarGeneric.kt")
+            public void testInlineClassTypeTopLevelVarGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt37986.kt")
             public void testKt37986() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt37986Generic.kt")
+            public void testKt37986Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Nested
             @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences/let")
             @TestDataPath("$PROJECT_ROOT")
@@ -16379,30 +16721,60 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
 
+                @Test
+                @TestMetadata("anyGeneric.kt")
+                public void testAnyGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
+
                 @Test
                 @TestMetadata("anyN.kt")
                 public void testAnyN() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
 
+                @Test
+                @TestMetadata("anyNGeneric.kt")
+                public void testAnyNGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
+
                 @Test
                 @TestMetadata("int.kt")
                 public void testInt() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/int.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
 
+                @Test
+                @TestMetadata("intGeneric.kt")
+                public void testIntGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
+
                 @Test
                 @TestMetadata("intN.kt")
                 public void testIntN() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
 
+                @Test
+                @TestMetadata("intNGeneric.kt")
+                public void testIntNGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
+
                 @Test
                 @TestMetadata("null.kt")
                 public void testNull() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/null.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
 
+                @Test
+                @TestMetadata("nullGeneric.kt")
+                public void testNullGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/nullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
+
                 @Test
                 @TestMetadata("result.kt")
                 public void testResult() throws Exception {
@@ -16415,11 +16787,23 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
 
+                @Test
+                @TestMetadata("stringGeneric.kt")
+                public void testStringGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
+
                 @Test
                 @TestMetadata("stringN.kt")
                 public void testStringN() throws Exception {
                     runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
                 }
+
+                @Test
+                @TestMetadata("stringNGeneric.kt")
+                public void testStringNGeneric() throws Exception {
+                    runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+                }
             }
         }
 
@@ -16439,18 +16823,42 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("accessPrivateInlineClassCompanionMethod2Generic.kt")
+            public void testAccessPrivateInlineClassCompanionMethod2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
+            @Test
+            @TestMetadata("accessPrivateInlineClassCompanionMethodGeneric.kt")
+            public void testAccessPrivateInlineClassCompanionMethodGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethodGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("accessPrivateInlineClassConstructorFromCompanion.kt")
             public void testAccessPrivateInlineClassConstructorFromCompanion() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("accessPrivateInlineClassConstructorFromCompanionGeneric.kt")
+            public void testAccessPrivateInlineClassConstructorFromCompanionGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("accessPrivateInlineClassConstructorFromLambda.kt")
             public void testAccessPrivateInlineClassConstructorFromLambda() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("accessPrivateInlineClassConstructorFromLambdaGeneric.kt")
+            public void testAccessPrivateInlineClassConstructorFromLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("accessPrivateInlineClassMethodFromCompanion.kt")
             public void testAccessPrivateInlineClassMethodFromCompanion() throws Exception {
@@ -16463,6 +16871,18 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("accessPrivateInlineClassMethodFromCompanion2Generic.kt")
+            public void testAccessPrivateInlineClassMethodFromCompanion2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
+            @Test
+            @TestMetadata("accessPrivateInlineClassMethodFromCompanionGeneric.kt")
+            public void testAccessPrivateInlineClassMethodFromCompanionGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda.kt")
             public void testAccessPrivateInlineClassMethodFromInlineLambda() throws Exception {
@@ -16475,6 +16895,18 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda2Generic.kt")
+            public void testAccessPrivateInlineClassMethodFromInlineLambda2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
+            @Test
+            @TestMetadata("accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt")
+            public void testAccessPrivateInlineClassMethodFromInlineLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("accessPrivateInlineClassMethodFromLambda.kt")
             public void testAccessPrivateInlineClassMethodFromLambda() throws Exception {
@@ -16487,6 +16919,18 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("accessPrivateInlineClassMethodFromLambda2Generic.kt")
+            public void testAccessPrivateInlineClassMethodFromLambda2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
+            @Test
+            @TestMetadata("accessPrivateInlineClassMethodFromLambdaGeneric.kt")
+            public void testAccessPrivateInlineClassMethodFromLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             public void testAllFilesPresentInContextsAndAccessors() throws Exception {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
@@ -16504,59 +16948,125 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("captureInlineClassInstanceInLambda2Generic.kt")
+            public void testCaptureInlineClassInstanceInLambda2Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
+            @Test
+            @TestMetadata("captureInlineClassInstanceInLambdaGeneric.kt")
+            public void testCaptureInlineClassInstanceInLambdaGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("captureInlineClassInstanceInObject.kt")
             public void testCaptureInlineClassInstanceInObject() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("captureInlineClassInstanceInObjectGeneric.kt")
+            public void testCaptureInlineClassInstanceInObjectGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObjectGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("inlineLambdaInInlineClassFun.kt")
             public void testInlineLambdaInInlineClassFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("inlineLambdaInInlineClassFunGeneric.kt")
+            public void testInlineLambdaInInlineClassFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt26858.kt")
             public void testKt26858() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt26858Generic.kt")
+            public void testKt26858Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt27513.kt")
             public void testKt27513() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt27513Generic.kt")
+            public void testKt27513Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("kt30780.kt")
             public void testKt30780() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("kt30780Generic.kt")
+            public void testKt30780Generic() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("lambdaInInlineClassFun.kt")
             public void testLambdaInInlineClassFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("lambdaInInlineClassFunGeneric.kt")
+            public void testLambdaInInlineClassFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("objectInInlineClassFun.kt")
             public void testObjectInInlineClassFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("objectInInlineClassFunGeneric.kt")
+            public void testObjectInInlineClassFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("toPrivateCompanionFun.kt")
             public void testToPrivateCompanionFun() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
 
+            @Test
+            @TestMetadata("toPrivateCompanionFunGeneric.kt")
+            public void testToPrivateCompanionFunGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
+
             @Test
             @TestMetadata("toPrivateCompanionVal.kt")
             public void testToPrivateCompanionVal() throws Exception {
                 runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
             }
+
+            @Test
+            @TestMetadata("toPrivateCompanionValGeneric.kt")
+            public void testToPrivateCompanionValGeneric() throws Exception {
+                runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation());
+            }
         }
 
         @Nested