[PL][tests] Keep PL test data under "testData/klib/" dir

compiler/testData/klib/partial-linkage/inheritanceIssues/lib1/l1.kt

@@ -0,0 +1,64 @@
+interface InterfaceToAbstractClass
+interface InterfaceToOpenClass
+interface InterfaceToFinalClass
+interface InterfaceToAnnotationClass
+interface InterfaceToObject
+interface InterfaceToEnumClass
+interface InterfaceToValueClass
+interface InterfaceToDataClass
+
+open class OpenClassToFinalClass(val x: Int)
+open class OpenClassToAnnotationClass(val x: Int)
+open class OpenClassToObject(val x: Int)
+open class OpenClassToEnumClass(val x: Int)
+open class OpenClassToValueClass(val x: Int)
+open class OpenClassToDataClass(val x: Int)
+open class OpenClassToInterface(val x: Int)
+
+interface InterfaceToAbstractClass1
+interface InterfaceToAbstractClass2
+abstract class AbstractClass
+
+interface RemovedInterface {
+    fun abstractFun(): String
+    fun abstractFunWithDefaultImpl(): String = "RemovedInterface.abstractFunWithDefaultImpl"
+    val abstractVal: String
+    val abstractValWithDefaultImpl: String get() = "RemovedInterface.abstractValWithDefaultImpl"
+}
+
+abstract class RemovedAbstractClass {
+    abstract fun abstractFun(): String
+    open fun openFun(): String = "RemovedAbstractClass.openFun"
+    fun finalFun(): String = "RemovedAbstractClass.finalFun"
+    abstract val abstractVal: String
+    open val openVal: String get() = "RemovedAbstractClass.openVal"
+    val finalVal: String get() = "RemovedAbstractClass.finalVal"
+}
+
+open class RemovedOpenClass {
+    open fun openFun(): String = "RemovedOpenClass.openFun"
+    fun finalFun(): String = "RemovedOpenClass.finalFun"
+    open val openVal: String get() = "RemovedOpenClass.openVal"
+    val finalVal: String get() = "RemovedOpenClass.finalVal"
+}
+
+abstract class AbstractClassWithChangedConstructorSignature(name: String) {
+    val greeting = "Hello, $name!"
+}
+
+open class OpenClassWithChangedConstructorSignature(name: String) {
+    val greeting = "Hello, $name!"
+}
+
+open class SuperSuperClass {
+    open fun inheritsFrom() = "SuperSuperClass -> Any"
+}
+open class SuperClass : SuperSuperClass() {
+    override fun inheritsFrom() = "SuperClass -> " + super.inheritsFrom()
+}
+class SuperSuperClassReplacedBySuperClass : SuperSuperClass() {
+    override fun inheritsFrom() = "SuperSuperClassReplacedBySuperClass -> " + super.inheritsFrom()
+}
+class SuperClassReplacedBySuperSuperClass : SuperClass() {
+    override fun inheritsFrom() = "SuperClassReplacedBySuperSuperClass -> " + super.inheritsFrom()
+}

compiler/testData/klib/partial-linkage/inheritanceIssues/lib1/l1.kt.1

@@ -0,0 +1,64 @@
+abstract class InterfaceToAbstractClass
+open class InterfaceToOpenClass
+class InterfaceToFinalClass
+annotation class InterfaceToAnnotationClass
+object InterfaceToObject
+enum class InterfaceToEnumClass
+value class InterfaceToValueClass(val x: Int)
+data class InterfaceToDataClass(val x: Int)
+
+final class OpenClassToFinalClass(val x: Int)
+annotation class OpenClassToAnnotationClass(val x: Int)
+object OpenClassToObject { val x: Int = 42 }
+enum class OpenClassToEnumClass(val x: Int)
+value class OpenClassToValueClass(val x: Int)
+data class OpenClassToDataClass(val x: Int)
+interface OpenClassToInterface { val x: Int }
+
+abstract class InterfaceToAbstractClass1
+abstract class InterfaceToAbstractClass2
+abstract class AbstractClass
+
+//interface RemovedInterface {
+//    fun abstractFun(): String
+//    fun abstractFunWithDefaultImpl(): String = "RemovedInterface.abstractFunWithDefaultImpl"
+//    val abstractVal: String
+//    val abstractValWithDefaultImpl: String get() = "RemovedInterface.abstractValWithDefaultImpl"
+//}
+//
+//abstract class RemovedAbstractClass {
+//    abstract fun abstractFun(): String
+//    open fun openFun(): String = "RemovedAbstractClass.openFun"
+//    fun finalFun(): String = "RemovedAbstractClass.finalFun"
+//    abstract val abstractVal: String
+//    open val openVal: String get() = "RemovedAbstractClass.openVal"
+//    val finalVal: String get() = "RemovedAbstractClass.finalVal"
+//}
+//
+//open class RemovedOpenClass {
+//    open fun openFun(): String = "RemovedOpenClass.openFun"
+//    fun finalFun(): String = "RemovedOpenClass.finalFun"
+//    open val openVal: String get() = "RemovedOpenClass.openVal"
+//    val finalVal: String get() = "RemovedOpenClass.finalVal"
+//}
+
+abstract class AbstractClassWithChangedConstructorSignature(name: String, city: String) {
+    val greeting = "Hello, $name from $city!"
+}
+
+open class OpenClassWithChangedConstructorSignature(name: String, city: String) {
+    val greeting = "Hello, $name from $city!"
+}
+
+open class SuperSuperClass {
+    open fun inheritsFrom() = "SuperSuperClass -> Any"
+}
+open class SuperClass : SuperSuperClass() {
+    override fun inheritsFrom() = "SuperClass -> " + super.inheritsFrom()
+}
+class SuperSuperClassReplacedBySuperClass : /*SuperSuperClass()*/ SuperClass() {
+    override fun inheritsFrom() = "SuperSuperClassReplacedBySuperClass -> " + super.inheritsFrom()
+}
+class SuperClassReplacedBySuperSuperClass : /*SuperClass()*/ SuperSuperClass() {
+    override fun inheritsFrom() = "SuperClassReplacedBySuperSuperClass -> " + super.inheritsFrom()
+}

compiler/testData/klib/partial-linkage/inheritanceIssues/lib1/module.info

@@ -0,0 +1,6 @@
+STEP 0:
+    dependencies: stdlib
+STEP 1:
+    dependencies: stdlib
+    modifications:
+        U : l1.kt.1 -> l1.kt

compiler/testData/klib/partial-linkage/inheritanceIssues/lib2/l2.kt

@@ -0,0 +1,255 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+fun getInterfaceToAbstractClass() = object : InterfaceToAbstractClass {}
+inline fun getInterfaceToAbstractClassInline() = object : InterfaceToAbstractClass {}
+fun getInterfaceToAbstractClassAsAny(): Any = object : InterfaceToAbstractClass {}
+inline fun getInterfaceToAbstractClassAsAnyInline(): Any = object : InterfaceToAbstractClass {}
+fun getInterfaceToAbstractClassAsAny2(): Any { class Local : InterfaceToAbstractClass; return Local() }
+
+fun getInterfaceToOpenClass() = object : InterfaceToOpenClass {}
+inline fun getInterfaceToOpenClassInline() = object : InterfaceToOpenClass {}
+fun getInterfaceToOpenClassAsAny(): Any = object : InterfaceToOpenClass {}
+inline fun getInterfaceToOpenClassAsAnyInline(): Any = object : InterfaceToOpenClass {}
+fun getInterfaceToOpenClassAsAny2(): Any { class Local : InterfaceToOpenClass; return Local() }
+
+fun getInterfaceToFinalClass() = object : InterfaceToFinalClass {}
+inline fun getInterfaceToFinalClassInline() = object : InterfaceToFinalClass {}
+fun getInterfaceToFinalClassAsAny(): Any = object : InterfaceToFinalClass {}
+inline fun getInterfaceToFinalClassAsAnyInline(): Any = object : InterfaceToFinalClass {}
+fun getInterfaceToFinalClassAsAny2(): Any { class Local : InterfaceToFinalClass; return Local() }
+
+open class InterfaceToAbstractClassImpl : InterfaceToAbstractClass
+class InterfaceToAbstractClassImpl2 : InterfaceToAbstractClassImpl()
+open class InterfaceToOpenClassImpl : InterfaceToOpenClass
+class InterfaceToOpenClassImpl2 : InterfaceToOpenClassImpl()
+open class InterfaceToFinalClassImpl : InterfaceToFinalClass
+class InterfaceToFinalClassImpl2 : InterfaceToFinalClassImpl()
+
+class InterfaceToAbstractClassContainer {
+    open class InterfaceToAbstractClassImpl : InterfaceToAbstractClass
+    class InterfaceToAbstractClassImpl2 : InterfaceToAbstractClassImpl()
+    inner class InterfaceToAbstractClassInnerImpl : InterfaceToAbstractClass
+}
+class InterfaceToOpenClassContainer {
+    open class InterfaceToOpenClassImpl : InterfaceToOpenClass
+    class InterfaceToOpenClassImpl2 : InterfaceToOpenClassImpl()
+    inner class InterfaceToOpenClassInnerImpl : InterfaceToOpenClass
+}
+class InterfaceToFinalClassContainer {
+    open class InterfaceToFinalClassImpl : InterfaceToFinalClass
+    class InterfaceToFinalClassImpl2 : InterfaceToFinalClassImpl()
+    inner class InterfaceToFinalClassInnerImpl : InterfaceToFinalClass
+}
+
+fun getInterfaceToAbstractClassImpl() = InterfaceToAbstractClassImpl()
+inline fun getInterfaceToAbstractClassImplInline() = InterfaceToAbstractClassImpl()
+fun getInterfaceToAbstractClassImplAsAny(): Any = InterfaceToAbstractClassImpl()
+inline fun getInterfaceToAbstractClassImplAsAnyInline(): Any = InterfaceToAbstractClassImpl()
+
+fun getInterfaceToAbstractClassImpl2() = InterfaceToAbstractClassImpl2()
+inline fun getInterfaceToAbstractClassImpl2Inline() = InterfaceToAbstractClassImpl2()
+fun getInterfaceToAbstractClassImpl2AsAny(): Any = InterfaceToAbstractClassImpl2()
+inline fun getInterfaceToAbstractClassImpl2AsAnyInline(): Any = InterfaceToAbstractClassImpl2()
+
+fun getInterfaceToOpenClassImpl() = InterfaceToOpenClassImpl()
+inline fun getInterfaceToOpenClassImplInline() = InterfaceToOpenClassImpl()
+fun getInterfaceToOpenClassImplAsAny(): Any = InterfaceToOpenClassImpl()
+inline fun getInterfaceToOpenClassImplAsAnyInline(): Any = InterfaceToOpenClassImpl()
+
+fun getInterfaceToOpenClassImpl2() = InterfaceToOpenClassImpl2()
+inline fun getInterfaceToOpenClassImpl2Inline() = InterfaceToOpenClassImpl2()
+fun getInterfaceToOpenClassImpl2AsAny(): Any = InterfaceToOpenClassImpl2()
+inline fun getInterfaceToOpenClassImpl2AsAnyInline(): Any = InterfaceToOpenClassImpl2()
+
+fun getInterfaceToFinalClassImpl() = InterfaceToFinalClassImpl()
+inline fun getInterfaceToFinalClassImplInline() = InterfaceToFinalClassImpl()
+fun getInterfaceToFinalClassImplAsAny(): Any = InterfaceToFinalClassImpl()
+inline fun getInterfaceToFinalClassImplAsAnyInline(): Any = InterfaceToFinalClassImpl()
+
+fun getInterfaceToFinalClassImpl2() = InterfaceToFinalClassImpl2()
+inline fun getInterfaceToFinalClassImpl2Inline() = InterfaceToFinalClassImpl2()
+fun getInterfaceToFinalClassImpl2AsAny(): Any = InterfaceToFinalClassImpl2()
+inline fun getInterfaceToFinalClassImpl2AsAnyInline(): Any = InterfaceToFinalClassImpl2()
+
+fun getInterfaceToAbstractClassNestedImpl() = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl()
+inline fun getInterfaceToAbstractClassNestedImplInline() = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl()
+fun getInterfaceToAbstractClassNestedImplAsAny(): Any = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl()
+inline fun getInterfaceToAbstractClassNestedImplAsAnyInline(): Any = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl()
+
+fun getInterfaceToAbstractClassNestedImpl2() = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl2()
+inline fun getInterfaceToAbstractClassNestedImpl2Inline() = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl2()
+fun getInterfaceToAbstractClassNestedImpl2AsAny(): Any = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl2()
+inline fun getInterfaceToAbstractClassNestedImpl2AsAnyInline(): Any = InterfaceToAbstractClassContainer.InterfaceToAbstractClassImpl2()
+
+fun getInterfaceToAbstractClassInnerImpl() = InterfaceToAbstractClassContainer().InterfaceToAbstractClassInnerImpl()
+inline fun getInterfaceToAbstractClassInnerImplInline() = InterfaceToAbstractClassContainer().InterfaceToAbstractClassInnerImpl()
+fun getInterfaceToAbstractClassInnerImplAsAny(): Any = InterfaceToAbstractClassContainer().InterfaceToAbstractClassInnerImpl()
+inline fun getInterfaceToAbstractClassInnerImplAsAnyInline(): Any = InterfaceToAbstractClassContainer().InterfaceToAbstractClassInnerImpl()
+
+fun getInterfaceToOpenClassNestedImpl() = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl()
+inline fun getInterfaceToOpenClassNestedImplInline() = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl()
+fun getInterfaceToOpenClassNestedImplAsAny(): Any = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl()
+inline fun getInterfaceToOpenClassNestedImplAsAnyInline(): Any = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl()
+
+fun getInterfaceToOpenClassNestedImpl2() = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl2()
+inline fun getInterfaceToOpenClassNestedImpl2Inline() = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl2()
+fun getInterfaceToOpenClassNestedImpl2AsAny(): Any = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl2()
+inline fun getInterfaceToOpenClassNestedImpl2AsAnyInline(): Any = InterfaceToOpenClassContainer.InterfaceToOpenClassImpl2()
+
+fun getInterfaceToOpenClassInnerImpl() = InterfaceToOpenClassContainer().InterfaceToOpenClassInnerImpl()
+inline fun getInterfaceToOpenClassInnerImplInline() = InterfaceToOpenClassContainer().InterfaceToOpenClassInnerImpl()
+fun getInterfaceToOpenClassInnerImplAsAny(): Any = InterfaceToOpenClassContainer().InterfaceToOpenClassInnerImpl()
+inline fun getInterfaceToOpenClassInnerImplAsAnyInline(): Any = InterfaceToOpenClassContainer().InterfaceToOpenClassInnerImpl()
+
+fun getInterfaceToFinalClassNestedImpl() = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl()
+inline fun getInterfaceToFinalClassNestedImplInline() = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl()
+fun getInterfaceToFinalClassNestedImplAsAny(): Any = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl()
+inline fun getInterfaceToFinalClassNestedImplAsAnyInline(): Any = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl()
+
+fun getInterfaceToFinalClassNestedImpl2() = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl2()
+inline fun getInterfaceToFinalClassNestedImpl2Inline() = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl2()
+fun getInterfaceToFinalClassNestedImpl2AsAny(): Any = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl2()
+inline fun getInterfaceToFinalClassNestedImpl2AsAnyInline(): Any = InterfaceToFinalClassContainer.InterfaceToFinalClassImpl2()
+
+fun getInterfaceToFinalClassInnerImpl() = InterfaceToFinalClassContainer().InterfaceToFinalClassInnerImpl()
+inline fun getInterfaceToFinalClassInnerImplInline() = InterfaceToFinalClassContainer().InterfaceToFinalClassInnerImpl()
+fun getInterfaceToFinalClassInnerImplAsAny(): Any = InterfaceToFinalClassContainer().InterfaceToFinalClassInnerImpl()
+inline fun getInterfaceToFinalClassInnerImplAsAnyInline(): Any = InterfaceToFinalClassContainer().InterfaceToFinalClassInnerImpl()
+
+fun referenceToInterfaceToAbstractClassImpl() = InterfaceToAbstractClassImpl::class.simpleName.orEmpty()
+inline fun referenceToInterfaceToAbstractClassImplInline() = InterfaceToAbstractClassImpl::class.simpleName.orEmpty()
+fun referenceToInterfaceToAbstractClassImpl2() = InterfaceToAbstractClassImpl2::class.simpleName.orEmpty()
+inline fun referenceToInterfaceToAbstractClassImpl2Inline() = InterfaceToAbstractClassImpl2::class.simpleName.orEmpty()
+
+fun referenceToInterfaceToFinalClassImpl() = check(InterfaceToFinalClassImpl::class.simpleName != null)
+inline fun referenceToInterfaceToFinalClassImplInline() = check(InterfaceToFinalClassImpl::class.simpleName != null)
+fun referenceToInterfaceToFinalClassImpl2() = check(InterfaceToFinalClassImpl2::class.simpleName != null)
+inline fun referenceToInterfaceToFinalClassImpl2Inline() = check(InterfaceToFinalClassImpl2::class.simpleName != null)
+
+class InterfaceToAnnotationClassImpl : InterfaceToAnnotationClass
+class InterfaceToObjectImpl : InterfaceToObject
+class InterfaceToEnumClassImpl : InterfaceToEnumClass
+class InterfaceToValueClassImpl : InterfaceToValueClass
+class InterfaceToDataClassImpl : InterfaceToDataClass
+
+fun getInterfaceToAnnotationClassImpl() = InterfaceToAnnotationClassImpl()
+fun getInterfaceToAnnotationClassImplAsAny(): Any = InterfaceToAnnotationClassImpl()
+fun getInterfaceToObjectImpl() = InterfaceToObjectImpl()
+fun getInterfaceToObjectImplAsAny(): Any = InterfaceToObjectImpl()
+fun getInterfaceToEnumClassImpl() = InterfaceToEnumClassImpl()
+fun getInterfaceToEnumClassImplAsAny(): Any = InterfaceToEnumClassImpl()
+fun getInterfaceToValueClassImpl() = InterfaceToValueClassImpl()
+fun getInterfaceToValueClassImplAny(): Any = InterfaceToValueClassImpl()
+fun getInterfaceToDataClassImpl() = InterfaceToDataClassImpl()
+fun getInterfaceToDataClassImplAny(): Any = InterfaceToDataClassImpl()
+
+class OpenClassToFinalClassImpl : OpenClassToFinalClass(42)
+class OpenClassToAnnotationClassImpl : OpenClassToAnnotationClass(42)
+class OpenClassToObjectImpl : OpenClassToObject(42)
+class OpenClassToEnumClassImpl : OpenClassToEnumClass(42)
+class OpenClassToValueClassImpl : OpenClassToValueClass(42)
+class OpenClassToDataClassImpl : OpenClassToDataClass(42)
+class OpenClassToInterfaceImpl : OpenClassToInterface(42)
+
+fun getOpenClassToFinalClassImpl() = OpenClassToFinalClassImpl()
+fun getOpenClassToFinalClassImplAsAny(): Any = OpenClassToFinalClassImpl()
+fun getOpenClassToAnnotationClassImpl() = OpenClassToAnnotationClassImpl()
+fun getOpenClassToAnnotationClassImplAsAny(): Any = OpenClassToAnnotationClassImpl()
+fun getOpenClassToObjectImpl() = OpenClassToObjectImpl()
+fun getOpenClassToObjectImplAsAny(): Any = OpenClassToObjectImpl()
+fun getOpenClassToEnumClassImpl() = OpenClassToEnumClassImpl()
+fun getOpenClassToEnumClassImplAsAny(): Any = OpenClassToEnumClassImpl()
+fun getOpenClassToValueClassImpl() = OpenClassToValueClassImpl()
+fun getOpenClassToValueClassImplAsAny(): Any = OpenClassToValueClassImpl()
+fun getOpenClassToDataClassImpl() = OpenClassToDataClassImpl()
+fun getOpenClassToDataClassImplAsAny(): Any = OpenClassToDataClassImpl()
+fun getOpenClassToInterfaceImpl() = OpenClassToInterfaceImpl()
+fun getOpenClassToInterfaceImplAsAny(): Any = OpenClassToInterfaceImpl()
+
+value class ValueClassInheritsAbstractClass(val x: Int) : InterfaceToAbstractClass
+enum class EnumClassInheritsAbstractClass : InterfaceToAbstractClass { ENTRY }
+
+fun getValueClassInheritsAbstractClass() = ValueClassInheritsAbstractClass(42)
+fun getValueClassInheritsAbstractClassAsAny(): Any = ValueClassInheritsAbstractClass(42)
+fun getEnumClassInheritsAbstractClass() = EnumClassInheritsAbstractClass.ENTRY
+fun getEnumClassInheritsAbstractClassAsAny(): Any = EnumClassInheritsAbstractClass.ENTRY
+
+fun getInterfaceToAbstractClass12_1(): InterfaceToAbstractClass1 = object : InterfaceToAbstractClass1, InterfaceToAbstractClass2 {}
+inline fun getInterfaceToAbstractClass12_1Inline(): InterfaceToAbstractClass1 = object : InterfaceToAbstractClass1, InterfaceToAbstractClass2 {}
+fun getInterfaceToAbstractClass12_2(): InterfaceToAbstractClass2 = object : InterfaceToAbstractClass1, InterfaceToAbstractClass2 {}
+inline fun getInterfaceToAbstractClass12_2Inline(): InterfaceToAbstractClass2 = object : InterfaceToAbstractClass1, InterfaceToAbstractClass2 {}
+fun getInterfaceToAbstractClass12AsAny(): Any = object : InterfaceToAbstractClass1, InterfaceToAbstractClass2 {}
+inline fun getInterfaceToAbstractClass12AsAnyInline(): Any = object : InterfaceToAbstractClass1, InterfaceToAbstractClass2 {}
+
+fun getInterfaceToAbstractClassAndAbstractClass_1(): InterfaceToAbstractClass1 = object : InterfaceToAbstractClass1, AbstractClass() {}
+inline fun getInterfaceToAbstractClassAndAbstractClass_1Inline(): InterfaceToAbstractClass1 = object : InterfaceToAbstractClass1, AbstractClass() {}
+fun getInterfaceToAbstractClassAndAbstractClass_2(): AbstractClass = object : InterfaceToAbstractClass1, AbstractClass() {}
+inline fun getInterfaceToAbstractClassAndAbstractClass_2Inline(): AbstractClass = object : InterfaceToAbstractClass1, AbstractClass() {}
+fun getInterfaceToAbstractClassAndAbstractClassAsAny(): Any = object : InterfaceToAbstractClass1, AbstractClass() {}
+inline fun getInterfaceToAbstractClassAndAbstractClassAsAnyInline(): Any = object : InterfaceToAbstractClass1, AbstractClass() {}
+
+open class InterfaceToAbstractClass12Impl : InterfaceToAbstractClass1, InterfaceToAbstractClass2
+class InterfaceToAbstractClass12Impl2 : InterfaceToAbstractClass12Impl()
+open class InterfaceToAbstractClassAndAbstractClassImpl : InterfaceToAbstractClass1, AbstractClass()
+class InterfaceToAbstractClassAndAbstractClassImpl2 : InterfaceToAbstractClassAndAbstractClassImpl()
+
+fun getInterfaceToAbstractClass12Impl() = InterfaceToAbstractClass12Impl()
+inline fun getInterfaceToAbstractClass12ImplInline() = InterfaceToAbstractClass12Impl()
+fun getInterfaceToAbstractClass12ImplAsAny(): Any = InterfaceToAbstractClass12Impl()
+inline fun getInterfaceToAbstractClass12ImplAsAnyInline(): Any = InterfaceToAbstractClass12Impl()
+
+fun getInterfaceToAbstractClass12Impl2() = InterfaceToAbstractClass12Impl2()
+inline fun getInterfaceToAbstractClass12Impl2Inline() = InterfaceToAbstractClass12Impl2()
+fun getInterfaceToAbstractClass12Impl2AsAny(): Any = InterfaceToAbstractClass12Impl2()
+inline fun getInterfaceToAbstractClass12Impl2AsAnyInline(): Any = InterfaceToAbstractClass12Impl2()
+
+fun getInterfaceToAbstractClassAndAbstractClassImpl() = InterfaceToAbstractClassAndAbstractClassImpl()
+inline fun getInterfaceToAbstractClassAndAbstractClassImplInline() = InterfaceToAbstractClassAndAbstractClassImpl()
+fun getInterfaceToAbstractClassAndAbstractClassImplAsAny(): Any = InterfaceToAbstractClassAndAbstractClassImpl()
+inline fun getInterfaceToAbstractClassAndAbstractClassImplAsAnyInline(): Any = InterfaceToAbstractClassAndAbstractClassImpl()
+
+fun getInterfaceToAbstractClassAndAbstractClassImpl2() = InterfaceToAbstractClassAndAbstractClassImpl2()
+inline fun getInterfaceToAbstractClassAndAbstractClassImpl2Inline() = InterfaceToAbstractClassAndAbstractClassImpl2()
+fun getInterfaceToAbstractClassAndAbstractClassImpl2AsAny(): Any = InterfaceToAbstractClassAndAbstractClassImpl2()
+inline fun getInterfaceToAbstractClassAndAbstractClassImpl2AsAnyInline(): Any = InterfaceToAbstractClassAndAbstractClassImpl2()
+
+fun referenceToInterfaceToAbstractClass12Impl() = check(InterfaceToAbstractClass12Impl::class.simpleName != null)
+inline fun referenceToInterfaceToAbstractClass12ImplInline() = check(InterfaceToAbstractClass12Impl::class.simpleName != null)
+fun referenceToInterfaceToAbstractClass12Impl2Impl() = check(InterfaceToAbstractClass12Impl2::class.simpleName != null)
+inline fun referenceToInterfaceToAbstractClass12Impl2Inline() = check(InterfaceToAbstractClass12Impl2::class.simpleName != null)
+fun referenceToInterfaceToAbstractClassAndAbstractClassImpl() = check(InterfaceToAbstractClassAndAbstractClassImpl::class.simpleName != null)
+inline fun referenceToInterfaceToAbstractClassAndAbstractClassImplInline() = check(InterfaceToAbstractClassAndAbstractClassImpl::class.simpleName != null)
+fun referenceToInterfaceToAbstractClassAndAbstractClassImpl2Impl() = check(InterfaceToAbstractClassAndAbstractClassImpl2::class.simpleName != null)
+inline fun referenceToInterfaceToAbstractClassAndAbstractClassImpl2Inline() = check(InterfaceToAbstractClassAndAbstractClassImpl2::class.simpleName != null)
+
+class RemovedInterfaceImpl1 : RemovedInterface {
+    override fun abstractFun() = "RemovedInterfaceImpl1.abstractFun"
+    override val abstractVal get() = "RemovedInterfaceImpl1.abstractVal"
+}
+
+class RemovedInterfaceImpl2 : RemovedInterface {
+    override fun abstractFun() = abstractFunWithDefaultImpl()
+    override val abstractVal get() = abstractValWithDefaultImpl
+}
+
+class RemovedAbstractClassImpl1 : RemovedAbstractClass() {
+    override fun abstractFun() = "RemovedAbstractClassImpl1.abstractFun"
+    override fun openFun() = "RemovedAbstractClassImpl1.openFun"
+    override val abstractVal get() = "RemovedAbstractClassImpl1.abstractVal"
+    override val openVal get() = "RemovedAbstractClassImpl1.openVal"
+}
+
+class RemovedAbstractClassImpl2 : RemovedAbstractClass() {
+    override fun abstractFun() = "${openFun()}:${finalFun()}"
+    override val abstractVal get() = "$openVal: $finalVal"
+}
+
+class RemovedOpenClassImpl1 : RemovedOpenClass() {
+    override fun openFun() = "RemovedOpenClassImpl1.openFun"
+    override val openVal get() = "RemovedOpenClassImpl1.openVal"
+}
+
+class RemovedOpenClassImpl2 : RemovedOpenClass()
+
+class AbstractClassWithChangedConstructorSignatureImpl() : AbstractClassWithChangedConstructorSignature("Alice")
+class OpenClassWithChangedConstructorSignatureImpl() : OpenClassWithChangedConstructorSignature("Bob")

compiler/testData/klib/partial-linkage/inheritanceIssues/lib2/module.info

@@ -0,0 +1,2 @@
+STEP 0:
+    dependencies: stdlib, lib1

compiler/testData/klib/partial-linkage/inheritanceIssues/main/m.kt

@@ -0,0 +1,234 @@
+import abitestutils.abiTest
+
+fun box() = abiTest {
+    val removedInterfaceImpl1 = RemovedInterfaceImpl1()
+    val removedInterfaceImpl2 = RemovedInterfaceImpl2()
+    val removedAbstractClassImpl1 = RemovedAbstractClassImpl1()
+    val removedAbstractClassImpl2 = RemovedAbstractClassImpl2()
+    val removedOpenClassImpl1 = RemovedOpenClassImpl1()
+    val removedOpenClassImpl2 = RemovedOpenClassImpl2()
+    val superSuperClassReplacedBySuperClass = SuperSuperClassReplacedBySuperClass()
+    val superClassReplacedBySuperSuperClass = SuperClassReplacedBySuperSuperClass()
+
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClass() }
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassInline() }
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassAsAny() }
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassAsAnyInline() }
+    expectFailure(linkage("Class initialization error: Constructor 'Local.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassAsAny2() }
+
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClass() }
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassInline() }
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassAsAny() }
+    expectFailure(linkage("Anonymous object initialization error: Constructor '<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassAsAnyInline() }
+    expectFailure(linkage("Class initialization error: Constructor 'Local.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassAsAny2() }
+
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClass() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassInline() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassAsAny() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassAsAnyInline() }
+    expectFailure(linkage("Constructor 'Local.<init>' can not be called: Class 'Local' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassAsAny2() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImpl() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImplInline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImplAsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImplAsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImpl2() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImpl2Inline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImpl2AsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassImpl2AsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImpl() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImplInline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImplAsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImplAsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImpl2() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImpl2Inline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImpl2AsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassImpl2AsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToFinalClassImpl' can not be called: Function uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImpl() }
+    expectFailure(linkage("Function 'getInterfaceToFinalClassImplInline' can not be called: Function uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImplInline() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl.<init>' can not be called: Class 'InterfaceToFinalClassImpl' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImplAsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl.<init>' can not be called: Class 'InterfaceToFinalClassImpl' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImplAsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToFinalClassImpl2' can not be called: Function uses class 'InterfaceToFinalClassImpl' (via class 'InterfaceToFinalClassImpl2') that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImpl2() }
+    expectFailure(linkage("Function 'getInterfaceToFinalClassImpl2Inline' can not be called: Function uses class 'InterfaceToFinalClassImpl' (via class 'InterfaceToFinalClassImpl2') that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImpl2Inline() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl2.<init>' can not be called: Class 'InterfaceToFinalClassImpl2' uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImpl2AsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl2.<init>' can not be called: Class 'InterfaceToFinalClassImpl2' uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassImpl2AsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImpl() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImplInline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImplAsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImplAsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImpl2() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImpl2Inline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImpl2AsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToAbstractClassImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassNestedImpl2AsAnyInline() }
+
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToAbstractClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassInnerImpl() }
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToAbstractClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassInnerImplInline() }
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToAbstractClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassInnerImplAsAny() }
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToAbstractClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToAbstractClass' but calls 'Any.<init>' instead")) { getInterfaceToAbstractClassInnerImplAsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImpl() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImplInline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImplAsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImplAsAnyInline() }
+
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImpl2() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImpl2Inline() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImpl2AsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'InterfaceToOpenClassImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassNestedImpl2AsAnyInline() }
+
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToOpenClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassInnerImpl() }
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToOpenClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassInnerImplInline() }
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToOpenClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassInnerImplAsAny() }
+    expectFailure(linkage("Inner class initialization error: Constructor 'InterfaceToOpenClassInnerImpl.<init>' should call a constructor of direct super class 'InterfaceToOpenClass' but calls 'Any.<init>' instead")) { getInterfaceToOpenClassInnerImplAsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToFinalClassNestedImpl' can not be called: Function uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImpl() }
+    expectFailure(linkage("Function 'getInterfaceToFinalClassNestedImplInline' can not be called: Function uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImplInline() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl.<init>' can not be called: Class 'InterfaceToFinalClassImpl' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImplAsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl.<init>' can not be called: Class 'InterfaceToFinalClassImpl' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImplAsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToFinalClassNestedImpl2' can not be called: Function uses class 'InterfaceToFinalClassImpl' (via class 'InterfaceToFinalClassImpl2') that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImpl2() }
+    expectFailure(linkage("Function 'getInterfaceToFinalClassNestedImpl2Inline' can not be called: Function uses class 'InterfaceToFinalClassImpl' (via class 'InterfaceToFinalClassImpl2') that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImpl2Inline() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl2.<init>' can not be called: Class 'InterfaceToFinalClassImpl2' uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImpl2AsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassImpl2.<init>' can not be called: Class 'InterfaceToFinalClassImpl2' uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassNestedImpl2AsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToFinalClassInnerImpl' can not be called: Function uses inner class 'InterfaceToFinalClassInnerImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassInnerImpl() }
+    expectFailure(linkage("Function 'getInterfaceToFinalClassInnerImplInline' can not be called: Function uses inner class 'InterfaceToFinalClassInnerImpl' that inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassInnerImplInline() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassInnerImpl.<init>' can not be called: Inner class 'InterfaceToFinalClassInnerImpl' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassInnerImplAsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToFinalClassInnerImpl.<init>' can not be called: Inner class 'InterfaceToFinalClassInnerImpl' inherits from final class 'InterfaceToFinalClass'")) { getInterfaceToFinalClassInnerImplAsAnyInline() }
+
+    expectSuccess("InterfaceToAbstractClassImpl") { referenceToInterfaceToAbstractClassImpl() }
+    expectSuccess("InterfaceToAbstractClassImpl") { referenceToInterfaceToAbstractClassImplInline() }
+    expectSuccess("InterfaceToAbstractClassImpl2") { referenceToInterfaceToAbstractClassImpl2() }
+    expectSuccess("InterfaceToAbstractClassImpl2") { referenceToInterfaceToAbstractClassImpl2Inline() }
+
+    expectFailure(linkage("Reference to class 'InterfaceToFinalClassImpl' can not be evaluated: Expression uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { referenceToInterfaceToFinalClassImpl() }
+    expectFailure(linkage("Reference to class 'InterfaceToFinalClassImpl' can not be evaluated: Expression uses class 'InterfaceToFinalClassImpl' that inherits from final class 'InterfaceToFinalClass'")) { referenceToInterfaceToFinalClassImplInline() }
+    expectFailure(linkage("Reference to class 'InterfaceToFinalClassImpl2' can not be evaluated: Expression uses class 'InterfaceToFinalClassImpl' (via class 'InterfaceToFinalClassImpl2') that inherits from final class 'InterfaceToFinalClass'")) { referenceToInterfaceToFinalClassImpl2() }
+    expectFailure(linkage("Reference to class 'InterfaceToFinalClassImpl2' can not be evaluated: Expression uses class 'InterfaceToFinalClassImpl' (via class 'InterfaceToFinalClassImpl2') that inherits from final class 'InterfaceToFinalClass'")) { referenceToInterfaceToFinalClassImpl2Inline() }
+
+    expectFailure(linkage("Function 'getInterfaceToAnnotationClassImpl' can not be called: Function uses class 'InterfaceToAnnotationClassImpl' that has illegal inheritance from annotation class 'InterfaceToAnnotationClass'")) { getInterfaceToAnnotationClassImpl() }
+    expectFailure(linkage("Constructor 'InterfaceToAnnotationClassImpl.<init>' can not be called: Class 'InterfaceToAnnotationClassImpl' has illegal inheritance from annotation class 'InterfaceToAnnotationClass'")) { getInterfaceToAnnotationClassImplAsAny() }
+    expectFailure(linkage("Function 'getInterfaceToObjectImpl' can not be called: Function uses class 'InterfaceToObjectImpl' that inherits from final object 'InterfaceToObject'")) { getInterfaceToObjectImpl() }
+    expectFailure(linkage("Constructor 'InterfaceToObjectImpl.<init>' can not be called: Class 'InterfaceToObjectImpl' inherits from final object 'InterfaceToObject'")) { getInterfaceToObjectImplAsAny() }
+    expectFailure(linkage("Function 'getInterfaceToEnumClassImpl' can not be called: Function uses class 'InterfaceToEnumClassImpl' that inherits from final enum class 'InterfaceToEnumClass'")) { getInterfaceToEnumClassImpl() }
+    expectFailure(linkage("Constructor 'InterfaceToEnumClassImpl.<init>' can not be called: Class 'InterfaceToEnumClassImpl' inherits from final enum class 'InterfaceToEnumClass'")) { getInterfaceToEnumClassImplAsAny() }
+    expectFailure(linkage("Function 'getInterfaceToValueClassImpl' can not be called: Function uses class 'InterfaceToValueClassImpl' that inherits from final value class 'InterfaceToValueClass'")) { getInterfaceToValueClassImpl() }
+    expectFailure(linkage("Constructor 'InterfaceToValueClassImpl.<init>' can not be called: Class 'InterfaceToValueClassImpl' inherits from final value class 'InterfaceToValueClass'")) { getInterfaceToValueClassImplAny() }
+    expectFailure(linkage("Function 'getInterfaceToDataClassImpl' can not be called: Function uses class 'InterfaceToDataClassImpl' that inherits from final data class 'InterfaceToDataClass'")) { getInterfaceToDataClassImpl() }
+    expectFailure(linkage("Constructor 'InterfaceToDataClassImpl.<init>' can not be called: Class 'InterfaceToDataClassImpl' inherits from final data class 'InterfaceToDataClass'")) { getInterfaceToDataClassImplAny() }
+
+    expectFailure(linkage("Function 'getOpenClassToFinalClassImpl' can not be called: Function uses class 'OpenClassToFinalClassImpl' that inherits from final class 'OpenClassToFinalClass'")) { getOpenClassToFinalClassImpl() }
+    expectFailure(linkage("Constructor 'OpenClassToFinalClassImpl.<init>' can not be called: Class 'OpenClassToFinalClassImpl' inherits from final class 'OpenClassToFinalClass'")) { getOpenClassToFinalClassImplAsAny() }
+    expectFailure(linkage("Function 'getOpenClassToAnnotationClassImpl' can not be called: Function uses class 'OpenClassToAnnotationClassImpl' that has illegal inheritance from annotation class 'OpenClassToAnnotationClass'")) { getOpenClassToAnnotationClassImpl() }
+    expectFailure(linkage("Constructor 'OpenClassToAnnotationClassImpl.<init>' can not be called: Class 'OpenClassToAnnotationClassImpl' has illegal inheritance from annotation class 'OpenClassToAnnotationClass'")) { getOpenClassToAnnotationClassImplAsAny() }
+    expectFailure(linkage("Function 'getOpenClassToObjectImpl' can not be called: Function uses class 'OpenClassToObjectImpl' that inherits from final object 'OpenClassToObject'")) { getOpenClassToObjectImpl() }
+    expectFailure(linkage("Constructor 'OpenClassToObjectImpl.<init>' can not be called: Class 'OpenClassToObjectImpl' inherits from final object 'OpenClassToObject'")) { getOpenClassToObjectImplAsAny() }
+    expectFailure(linkage("Function 'getOpenClassToEnumClassImpl' can not be called: Function uses class 'OpenClassToEnumClassImpl' that inherits from final enum class 'OpenClassToEnumClass'")) { getOpenClassToEnumClassImpl() }
+    expectFailure(linkage("Constructor 'OpenClassToEnumClassImpl.<init>' can not be called: Class 'OpenClassToEnumClassImpl' inherits from final enum class 'OpenClassToEnumClass'")) { getOpenClassToEnumClassImplAsAny() }
+    expectFailure(linkage("Function 'getOpenClassToValueClassImpl' can not be called: Function uses class 'OpenClassToValueClassImpl' that inherits from final value class 'OpenClassToValueClass'")) { getOpenClassToValueClassImpl() }
+    expectFailure(linkage("Constructor 'OpenClassToValueClassImpl.<init>' can not be called: Class 'OpenClassToValueClassImpl' inherits from final value class 'OpenClassToValueClass'")) { getOpenClassToValueClassImplAsAny() }
+    expectFailure(linkage("Function 'getOpenClassToDataClassImpl' can not be called: Function uses class 'OpenClassToDataClassImpl' that inherits from final data class 'OpenClassToDataClass'")) { getOpenClassToDataClassImpl() }
+    expectFailure(linkage("Constructor 'OpenClassToDataClassImpl.<init>' can not be called: Class 'OpenClassToDataClassImpl' inherits from final data class 'OpenClassToDataClass'")) { getOpenClassToDataClassImplAsAny() }
+    expectFailure(linkage("Class initialization error: Constructor 'OpenClassToInterfaceImpl.<init>' should call a constructor of direct super class 'Any' but calls 'OpenClassToInterface.<init>' instead")) { getOpenClassToInterfaceImpl() }
+    expectFailure(linkage("Class initialization error: Constructor 'OpenClassToInterfaceImpl.<init>' should call a constructor of direct super class 'Any' but calls 'OpenClassToInterface.<init>' instead")) { getOpenClassToInterfaceImplAsAny() }
+
+    expectFailure(linkage("Function 'getValueClassInheritsAbstractClass' can not be called: Function uses value class 'ValueClassInheritsAbstractClass' that has illegal inheritance from class 'InterfaceToAbstractClass'")) { getValueClassInheritsAbstractClass() }
+    expectFailure(linkage("Constructor 'ValueClassInheritsAbstractClass.<init>' can not be called: Value class 'ValueClassInheritsAbstractClass' has illegal inheritance from class 'InterfaceToAbstractClass'")) { getValueClassInheritsAbstractClassAsAny() }
+    expectFailure(linkage("Function 'getEnumClassInheritsAbstractClass' can not be called: Function uses enum class 'EnumClassInheritsAbstractClass' that simultaneously inherits from 2 classes: 'Enum', 'InterfaceToAbstractClass'")) { getEnumClassInheritsAbstractClass() }
+    expectFailure(linkage("Can not get instance of singleton 'EnumClassInheritsAbstractClass.ENTRY': Expression uses enum class 'EnumClassInheritsAbstractClass' that simultaneously inherits from 2 classes: 'Enum', 'InterfaceToAbstractClass'")) { getEnumClassInheritsAbstractClassAsAny() }
+
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12_1() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12_1Inline() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12_2() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12_2Inline() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12AsAny() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12AsAnyInline() }
+
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClass_1() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClass_1Inline() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClass_2() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClass_2Inline() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassAsAny() }
+    expectFailure(linkage("Constructor '<init>' can not be called: Anonymous object simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassAsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToAbstractClass12Impl' can not be called: Function uses class 'InterfaceToAbstractClass12Impl' that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12Impl() }
+    expectFailure(linkage("Function 'getInterfaceToAbstractClass12ImplInline' can not be called: Function uses class 'InterfaceToAbstractClass12Impl' that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12ImplInline() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClass12Impl.<init>' can not be called: Class 'InterfaceToAbstractClass12Impl' simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12ImplAsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClass12Impl.<init>' can not be called: Class 'InterfaceToAbstractClass12Impl' simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12ImplAsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToAbstractClass12Impl2' can not be called: Function uses class 'InterfaceToAbstractClass12Impl' (via class 'InterfaceToAbstractClass12Impl2') that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12Impl2() }
+    expectFailure(linkage("Function 'getInterfaceToAbstractClass12Impl2Inline' can not be called: Function uses class 'InterfaceToAbstractClass12Impl' (via class 'InterfaceToAbstractClass12Impl2') that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12Impl2Inline() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClass12Impl2.<init>' can not be called: Class 'InterfaceToAbstractClass12Impl2' uses class 'InterfaceToAbstractClass12Impl' that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12Impl2AsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClass12Impl2.<init>' can not be called: Class 'InterfaceToAbstractClass12Impl2' uses class 'InterfaceToAbstractClass12Impl' that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { getInterfaceToAbstractClass12Impl2AsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToAbstractClassAndAbstractClassImpl' can not be called: Function uses class 'InterfaceToAbstractClassAndAbstractClassImpl' that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImpl() }
+    expectFailure(linkage("Function 'getInterfaceToAbstractClassAndAbstractClassImplInline' can not be called: Function uses class 'InterfaceToAbstractClassAndAbstractClassImpl' that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImplInline() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClassAndAbstractClassImpl.<init>' can not be called: Class 'InterfaceToAbstractClassAndAbstractClassImpl' simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImplAsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClassAndAbstractClassImpl.<init>' can not be called: Class 'InterfaceToAbstractClassAndAbstractClassImpl' simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImplAsAnyInline() }
+
+    expectFailure(linkage("Function 'getInterfaceToAbstractClassAndAbstractClassImpl2' can not be called: Function uses class 'InterfaceToAbstractClassAndAbstractClassImpl' (via class 'InterfaceToAbstractClassAndAbstractClassImpl2') that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImpl2() }
+    expectFailure(linkage("Function 'getInterfaceToAbstractClassAndAbstractClassImpl2Inline' can not be called: Function uses class 'InterfaceToAbstractClassAndAbstractClassImpl' (via class 'InterfaceToAbstractClassAndAbstractClassImpl2') that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImpl2Inline() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClassAndAbstractClassImpl2.<init>' can not be called: Class 'InterfaceToAbstractClassAndAbstractClassImpl2' uses class 'InterfaceToAbstractClassAndAbstractClassImpl' that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImpl2AsAny() }
+    expectFailure(linkage("Constructor 'InterfaceToAbstractClassAndAbstractClassImpl2.<init>' can not be called: Class 'InterfaceToAbstractClassAndAbstractClassImpl2' uses class 'InterfaceToAbstractClassAndAbstractClassImpl' that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { getInterfaceToAbstractClassAndAbstractClassImpl2AsAnyInline() }
+
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClass12Impl' can not be evaluated: Expression uses class 'InterfaceToAbstractClass12Impl' that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { referenceToInterfaceToAbstractClass12Impl() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClass12Impl' can not be evaluated: Expression uses class 'InterfaceToAbstractClass12Impl' that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { referenceToInterfaceToAbstractClass12ImplInline() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClass12Impl2' can not be evaluated: Expression uses class 'InterfaceToAbstractClass12Impl' (via class 'InterfaceToAbstractClass12Impl2') that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { referenceToInterfaceToAbstractClass12Impl2Impl() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClass12Impl2' can not be evaluated: Expression uses class 'InterfaceToAbstractClass12Impl' (via class 'InterfaceToAbstractClass12Impl2') that simultaneously inherits from 2 classes: 'InterfaceToAbstractClass1', 'InterfaceToAbstractClass2'")) { referenceToInterfaceToAbstractClass12Impl2Inline() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClassAndAbstractClassImpl' can not be evaluated: Expression uses class 'InterfaceToAbstractClassAndAbstractClassImpl' that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { referenceToInterfaceToAbstractClassAndAbstractClassImpl() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClassAndAbstractClassImpl' can not be evaluated: Expression uses class 'InterfaceToAbstractClassAndAbstractClassImpl' that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { referenceToInterfaceToAbstractClassAndAbstractClassImplInline() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClassAndAbstractClassImpl2' can not be evaluated: Expression uses class 'InterfaceToAbstractClassAndAbstractClassImpl' (via class 'InterfaceToAbstractClassAndAbstractClassImpl2') that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { referenceToInterfaceToAbstractClassAndAbstractClassImpl2Impl() }
+    expectFailure(linkage("Reference to class 'InterfaceToAbstractClassAndAbstractClassImpl2' can not be evaluated: Expression uses class 'InterfaceToAbstractClassAndAbstractClassImpl' (via class 'InterfaceToAbstractClassAndAbstractClassImpl2') that simultaneously inherits from 2 classes: 'AbstractClass', 'InterfaceToAbstractClass1'")) { referenceToInterfaceToAbstractClassAndAbstractClassImpl2Inline() }
+
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl1': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl1')")) { removedInterfaceImpl1.abstractFun() }
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl1': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl1')")) { removedInterfaceImpl1.abstractFunWithDefaultImpl() }
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl1': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl1')")) { removedInterfaceImpl1.abstractVal }
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl1': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl1')")) { removedInterfaceImpl1.abstractValWithDefaultImpl }
+
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl2': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl2')")) { removedInterfaceImpl2.abstractFun() }
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl2': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl2')")) { removedInterfaceImpl2.abstractFunWithDefaultImpl() }
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl2': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl2')")) { removedInterfaceImpl2.abstractVal }
+    expectFailure(linkage("Can not read value from variable 'removedInterfaceImpl2': Variable uses unlinked class symbol '/RemovedInterface' (via class 'RemovedInterfaceImpl2')")) { removedInterfaceImpl2.abstractValWithDefaultImpl }
+
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl1': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl1')")) { removedAbstractClassImpl1.abstractFun() }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl1': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl1')")) { removedAbstractClassImpl1.openFun() }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl1': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl1')")) { removedAbstractClassImpl1.finalFun() }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl1': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl1')")) { removedAbstractClassImpl1.abstractVal }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl1': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl1')")) { removedAbstractClassImpl1.openVal }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl1': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl1')")) { removedAbstractClassImpl1.finalVal }
+
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl2': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl2')")) { removedAbstractClassImpl2.abstractFun() }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl2': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl2')")) { removedAbstractClassImpl2.openFun() }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl2': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl2')")) { removedAbstractClassImpl2.finalFun() }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl2': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl2')")) { removedAbstractClassImpl2.abstractVal }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl2': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl2')")) { removedAbstractClassImpl2.openVal }
+    expectFailure(linkage("Can not read value from variable 'removedAbstractClassImpl2': Variable uses unlinked class symbol '/RemovedAbstractClass' (via class 'RemovedAbstractClassImpl2')")) { removedAbstractClassImpl2.finalVal }
+
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl1': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl1')")) { removedOpenClassImpl1.openFun() }
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl1': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl1')")) { removedOpenClassImpl1.finalFun() }
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl1': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl1')")) { removedOpenClassImpl1.openVal }
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl1': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl1')")) { removedOpenClassImpl1.finalVal }
+
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl2': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl2')")) { removedOpenClassImpl2.openFun() }
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl2': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl2')")) { removedOpenClassImpl2.finalFun() }
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl2': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl2')")) { removedOpenClassImpl2.openVal }
+    expectFailure(linkage("Can not read value from variable 'removedOpenClassImpl2': Variable uses unlinked class symbol '/RemovedOpenClass' (via class 'RemovedOpenClassImpl2')")) { removedOpenClassImpl2.finalVal }
+
+    expectFailure(linkage("Constructor 'AbstractClassWithChangedConstructorSignature.<init>' can not be called: No constructor found for symbol '/AbstractClassWithChangedConstructorSignature.<init>'")) { AbstractClassWithChangedConstructorSignatureImpl() }
+    expectFailure(linkage("Constructor 'OpenClassWithChangedConstructorSignature.<init>' can not be called: No constructor found for symbol '/OpenClassWithChangedConstructorSignature.<init>'")) { OpenClassWithChangedConstructorSignatureImpl() }
+
+    expectSuccess("SuperSuperClassReplacedBySuperClass -> SuperClass -> SuperSuperClass -> Any") { superSuperClassReplacedBySuperClass.inheritsFrom() }
+    expectSuccess(true) { SuperSuperClass::class.isInstance(superSuperClassReplacedBySuperClass) } // This check is done during the runtime.
+    expectSuccess(true) { SuperClass::class.isInstance(superSuperClassReplacedBySuperClass) } // This check is done during the runtime.
+
+    expectSuccess("SuperClassReplacedBySuperSuperClass -> SuperSuperClass -> Any") { superClassReplacedBySuperSuperClass.inheritsFrom() }
+    expectSuccess(true) { SuperSuperClass::class.isInstance(superClassReplacedBySuperSuperClass) } // This check is done during the runtime.
+    expectSuccess(false) { SuperClass::class.isInstance(superClassReplacedBySuperSuperClass) } // This check is done during the runtime.
+}

compiler/testData/klib/partial-linkage/inheritanceIssues/main/module.info

@@ -0,0 +1,2 @@
+STEP 0:
+    dependencies: stdlib, lib1, lib2

compiler/testData/klib/partial-linkage/inheritanceIssues/project.info

@@ -0,0 +1,7 @@
+MODULES: lib1, lib2, main
+
+STEP 0:
+    libs: lib1, lib2, main
+
+STEP 1:
+    libs: lib1