Minor. Add more tests

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride2Generic.kt

@@ -0,0 +1,30 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class A<T: String>(val s: T)
+
+interface B<T, U> {
+    fun f(x: T, y: U): String
+}
+
+interface L<T> {
+    fun f(x: T, y: A<String>): String
+}
+
+interface R<T> {
+    fun f(x: A<String>, y: T): String
+}
+
+open class C {
+    open fun f(x: A<String>, y: A<String>): String = y.s
+}
+
+class D: C(), B<A<String>, A<String>>, L<A<String>>, R<A<String>> {
+    override fun f(x: A<String>, y: A<String>): String = x.s
+}
+
+fun box(): String {
+    return (D() as B<A<String>, A<String>>).f(A("OK"), A("Fail"))
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride3Generic.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class A<T: String>(val s: T)
+
+interface B<T> {
+    fun f(x: T): T
+}
+
+open class C {
+    open fun f(x: A<String>): A<String> = A("OK")
+}
+
+class D : C(), B<A<String>>
+
+fun box(): String {
+    return (D() as B<A<String>>).f(A("Fail")).s
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverrideGeneric.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class A<T: String>(val s: T)
+
+abstract class B<T, U> {
+    abstract fun f(x: T, y: U): String
+}
+
+open class C<T>: B<T, A<String>>() {
+    override fun f(x: T, y: A<String>): String = y.s + " 1"
+}
+
+open class D : C<A<String>>() {
+    override fun f(x: A<String>, y: A<String>): String = y.s + " 2"
+}
+
+class E : D() {
+    override fun f(x: A<String>, y: A<String>): String = x.s
+}
+
+fun box(): String {
+    return E().f(A("OK"), A("Fail"))
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceExtensionFunCallGeneric.kt

@@ -0,0 +1,43 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo {
+    fun Long.foo() = bar()
+    fun bar(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) : IFoo {
+    override fun bar(): String = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) : IFoo {
+    override fun bar(): String = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) : IFoo {
+    override fun bar(): String = "OK"
+}
+
+fun Z<Int>.testZ() {
+    if (1L.foo() != "OK") throw AssertionError()
+}
+
+fun L<Long>.testL() {
+    if (1L.foo() != "OK") throw AssertionError()
+}
+
+fun S<String>.testS() {
+    if (1L.foo() != "OK") throw AssertionError()
+}
+
+fun box(): String {
+    Z(42).testZ()
+    L(4L).testL()
+    S("").testS()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceMethodCallGeneric.kt

@@ -0,0 +1,31 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo {
+    fun foo() = bar()
+    fun bar(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) : IFoo {
+    override fun bar(): String = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) : IFoo {
+    override fun bar(): String = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) : IFoo {
+    override fun bar(): String = "OK"
+}
+
+fun box(): String {
+    if (Z(42).foo() != "OK") throw AssertionError()
+    if (L(4L).foo() != "OK") throw AssertionError()
+    if (S("").foo() != "OK") throw AssertionError()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceExtensionFunCallGeneric.kt

@@ -0,0 +1,43 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo<T : IFoo<T>> {
+    fun T.foo(): String = bar()
+    fun bar(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) : IFoo<Z<Int>> {
+    override fun bar(): String = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) : IFoo<L<Long>> {
+    override fun bar(): String = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) : IFoo<S<String>> {
+    override fun bar(): String = x
+}
+
+fun Z<Int>.testZ() {
+    if (Z(42).foo() != "OK") throw AssertionError()
+}
+
+fun L<Long>.testL() {
+    if (L(4L).foo() != "OK") throw AssertionError()
+}
+
+fun S<String>.testS() {
+    if (S("OK").foo() != "OK") throw AssertionError()
+}
+
+fun box(): String {
+    Z(42).testZ()
+    L(4L).testL()
+    S("").testS()
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceMethodCallGeneric.kt

@@ -0,0 +1,16 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo<T : IFoo<T>> {
+    fun foo(t: T): String = t.bar()
+    fun bar(): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) : IFoo<Z<Int>> {
+    override fun bar(): String = "OK"
+}
+
+fun box(): String =
+    Z(1).foo(Z(2))

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericInterfaceMethodCallGeneric.kt

@@ -0,0 +1,15 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo<T> {
+    fun foo(x: T): String
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) : IFoo<Z<Int>> {
+    override fun foo(x: Z<Int>) = "OK"
+}
+
+fun box(): String =
+    Z(1).foo(Z(2))

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericMethodWithInlineClassOverrideGeneric.kt

@@ -0,0 +1,18 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class A<T: String>(val s: T)
+
+abstract class B<T> {
+    abstract fun f(x: T): T
+}
+
+class C: B<A<String>>() {
+    override fun f(x: A<String>): A<String> = x
+}
+
+fun box(): String {
+    return C().f(A("OK")).s
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCallGeneric.kt

@@ -0,0 +1,54 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IFoo {
+    fun foo(): String = "K"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IcStr<T: String>(val y: T) : IFoo {
+    override fun foo(): String = y + super<IFoo>.foo()
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IcInt<T: Int>(val i: T) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IcLong<T: Long>(val l: T) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IcAny<T: Any>(val a: T?) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IcOverIc<T: IcLong<Long>>(val o: T) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class IcOverSuperInterface<T: IFoo>(val x: T) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+fun check(message: String, iFoo: IFoo) {
+    val actual = iFoo.foo()
+    if (actual != "OK")
+        throw Exception("$message: \"$actual\" != OK")
+}
+
+fun box(): String {
+    check("IcStr", IcStr("O"))
+    check("IcInt", IcInt(42))
+    check("IcLong", IcLong(42L))
+    check("IcAny", IcAny(""))
+    check("IcOverIc", IcOverIc(IcLong(42L)))
+    check("IcOverSuperInterface", IcOverSuperInterface(IcInt(42)))
+
+    return "OK"
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/overriddenDefaultInterfaceMethodCallGeneric.kt

@@ -0,0 +1,28 @@
+// WITH_STDLIB
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses, +GenericInlineClassParameter
+
+interface IBase {
+    fun foo() = "BAD"
+}
+
+interface IFoo : IBase {
+    override fun foo() = "OK"
+}
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class Z<T: Int>(val x: T) : IFoo
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class L<T: Long>(val x: T) : IFoo
+
+OPTIONAL_JVM_INLINE_ANNOTATION
+value class S<T: String>(val x: T) : IFoo
+
+fun box(): String {
+    if (Z(42).foo() != "OK") throw AssertionError()
+    if (L(4L).foo() != "OK") throw AssertionError()
+    if (S("").foo() != "OK") throw AssertionError()
+
+    return "OK"
+}