[FIR] Check for subtyping during actualization of supertypes of expect class

^KT-59356 Fixed

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java

@@ -169,6 +169,12 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst
         runTest("compiler/testData/diagnostics/tests/multiplatform/smartcastOnMemberPropertyFromCommonClass.kt");
     }
 
+    @Test
+    @TestMetadata("supertypeActualizationWithAny.kt")
+    public void testSupertypeActualizationWithAny() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/supertypeActualizationWithAny.kt");
+    }
+
     @Test
     @TestMetadata("varSetterVisibility.kt")
     public void testVarSetterVisibility() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java

@@ -169,6 +169,12 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi
         runTest("compiler/testData/diagnostics/tests/multiplatform/smartcastOnMemberPropertyFromCommonClass.kt");
     }
 
+    @Test
+    @TestMetadata("supertypeActualizationWithAny.kt")
+    public void testSupertypeActualizationWithAny() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/supertypeActualizationWithAny.kt");
+    }
+
     @Test
     @TestMetadata("varSetterVisibility.kt")
     public void testVarSetterVisibility() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -33669,6 +33669,18 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
+                @Test
+                @TestMetadata("transitiveSuperclassActualization_java.kt")
+                public void testTransitiveSuperclassActualization_java() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization_java.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -33669,6 +33669,18 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
+                @Test
+                @TestMetadata("transitiveSuperclassActualization_java.kt")
+                public void testTransitiveSuperclassActualization_java() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization_java.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContext.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext
 import org.jetbrains.kotlin.types.AbstractTypeChecker
+import org.jetbrains.kotlin.types.TypeCheckerState
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.model.*
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -43,6 +44,9 @@ class FirExpectActualMatchingContext(
     override val allowClassActualizationWithWiderVisibility: Boolean
         get() = true
 
+    override val allowTransitiveSupertypesActualization: Boolean
+        get() = true
+
     private fun CallableSymbolMarker.asSymbol(): FirCallableSymbol<*> = this as FirCallableSymbol<*>
     private fun FunctionSymbolMarker.asSymbol(): FirFunctionSymbol<*> = this as FirFunctionSymbol<*>
     private fun PropertySymbolMarker.asSymbol(): FirPropertySymbol = this as FirPropertySymbol
@@ -144,6 +148,9 @@ class FirExpectActualMatchingContext(
     override val RegularClassSymbolMarker.superTypes: List<KotlinTypeMarker>
         get() = asSymbol().resolvedSuperTypes
 
+    override val RegularClassSymbolMarker.defaultType: KotlinTypeMarker
+        get() = asSymbol().defaultType()
+
     override fun RegularClassSymbolMarker.collectAllMembers(isActualDeclaration: Boolean): List<FirBasedSymbol<*>> {
         val symbol = asSymbol()
         val session = when (isActualDeclaration) {
@@ -256,12 +263,24 @@ class FirExpectActualMatchingContext(
         if (actualType == null) return false
 
         return AbstractTypeChecker.equalTypes(
-            actualSession.typeContext.newTypeCheckerState(errorTypesEqualToAnything = true, stubTypesEqualToAnything = false),
+            createTypeCheckerState(),
             expectType,
             actualType
         )
     }
 
+    override fun actualTypeIsSubtypeOfExpectType(expectType: KotlinTypeMarker, actualType: KotlinTypeMarker): Boolean {
+        return AbstractTypeChecker.isSubtypeOf(
+            createTypeCheckerState(),
+            subType = actualType,
+            superType = expectType
+        )
+    }
+
+    private fun createTypeCheckerState(): TypeCheckerState {
+        return actualSession.typeContext.newTypeCheckerState(errorTypesEqualToAnything = true, stubTypesEqualToAnything = false)
+    }
+
     override fun RegularClassSymbolMarker.isNotSamInterface(): Boolean {
         val type = asSymbol().defaultType()
         val isSam = FirSamResolver(actualSession, scopeSession).isSamType(type)

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext
 import org.jetbrains.kotlin.types.AbstractTypeChecker
+import org.jetbrains.kotlin.types.TypeCheckerState
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.model.*
 import org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction
@@ -36,6 +37,9 @@ internal abstract class IrExpectActualMatchingContext(
     override val allowClassActualizationWithWiderVisibility: Boolean
         get() = true
 
+    override val allowTransitiveSupertypesActualization: Boolean
+        get() = true
+
     private inline fun <R> CallableSymbolMarker.processIr(
         onFunction: (IrFunction) -> R,
         onProperty: (IrProperty) -> R,
@@ -161,6 +165,9 @@ internal abstract class IrExpectActualMatchingContext(
     override val RegularClassSymbolMarker.superTypes: List<KotlinTypeMarker>
         get() = asIr().superTypes
 
+    override val RegularClassSymbolMarker.defaultType: KotlinTypeMarker
+        get() = asIr().defaultType
+
     override val CallableSymbolMarker.isExpect: Boolean
         get() = processIr(
             onFunction = { it.isExpect },
@@ -312,15 +319,31 @@ internal abstract class IrExpectActualMatchingContext(
          * When we match return types of (1) and (2) they both will have original type `S`, but from
          *   perspective of module `platform` it should be replaced with `String`
          */
-        val actualizedExpectType = actualizingSubstitutor.substitute(expectType as IrType)
-        val actualizedActualType = actualizingSubstitutor.substitute(actualType as IrType)
+        val actualizedExpectType = expectType.actualize()
+        val actualizedActualType = actualType.actualize()
         return AbstractTypeChecker.equalTypes(
-            typeContext.newTypeCheckerState(errorTypesEqualToAnything = true, stubTypesEqualToAnything = false),
+            createTypeCheckerState(),
             actualizedExpectType,
             actualizedActualType
         )
     }
 
+    private fun createTypeCheckerState(): TypeCheckerState {
+        return typeContext.newTypeCheckerState(errorTypesEqualToAnything = true, stubTypesEqualToAnything = false)
+    }
+
+    override fun actualTypeIsSubtypeOfExpectType(expectType: KotlinTypeMarker, actualType: KotlinTypeMarker): Boolean {
+        return AbstractTypeChecker.isSubtypeOf(
+            createTypeCheckerState(),
+            subType = actualType.actualize(),
+            superType = expectType.actualize()
+        )
+    }
+
+    private fun KotlinTypeMarker.actualize(): IrType {
+        return actualizingSubstitutor.substitute(this as IrType)
+    }
+
     private val actualizingSubstitutor = ActualizingSubstitutor()
 
     private inner class ActualizingSubstitutor : AbstractIrTypeSubstitutor() {

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualCompatibilityChecker.kt

@@ -122,17 +122,7 @@ object AbstractExpectActualCompatibilityChecker {
             }
         }
 
-        // Subtract kotlin.Any from supertypes because it's implicitly added if no explicit supertype is specified,
-        // and not added if an explicit supertype _is_ specified
-        val expectSupertypes = expectClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
-        val actualSupertypes = actualClass.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
-        if (
-            expectSupertypes.map { substitutor.safeSubstitute(it) }.any { expectSupertype ->
-                actualSupertypes.none { actualSupertype ->
-                    areCompatibleExpectActualTypes(expectSupertype, actualSupertype)
-                }
-            }
-        ) {
+        if (!areCompatibleSupertypes(expectClassSymbol, actualClass, substitutor)) {
             return Incompatible.Supertypes
         }
 
@@ -145,6 +135,52 @@ object AbstractExpectActualCompatibilityChecker {
         return ExpectActualCompatibility.Compatible
     }
 
+    context(ExpectActualMatchingContext<*>)
+    private fun areCompatibleSupertypes(
+        expectClassSymbol: RegularClassSymbolMarker,
+        actualClassSymbol: RegularClassSymbolMarker,
+        substitutor: TypeSubstitutorMarker,
+    ): Boolean {
+        return when (allowTransitiveSupertypesActualization) {
+            false -> areCompatibleSupertypesOneByOne(expectClassSymbol, actualClassSymbol, substitutor)
+            true -> areCompatibleSupertypesTransitive(expectClassSymbol, actualClassSymbol, substitutor)
+        }
+    }
+
+    context(ExpectActualMatchingContext<*>)
+    private fun areCompatibleSupertypesOneByOne(
+        expectClassSymbol: RegularClassSymbolMarker,
+        actualClassSymbol: RegularClassSymbolMarker,
+        substitutor: TypeSubstitutorMarker,
+    ): Boolean {
+        // Subtract kotlin.Any from supertypes because it's implicitly added if no explicit supertype is specified,
+        // and not added if an explicit supertype _is_ specified
+        val expectSupertypes = expectClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
+        val actualSupertypes = actualClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
+        return expectSupertypes.all { expectSupertype ->
+            val substitutedExpectType = substitutor.safeSubstitute(expectSupertype)
+            actualSupertypes.any { actualSupertype ->
+                areCompatibleExpectActualTypes(substitutedExpectType, actualSupertype)
+            }
+        }
+    }
+
+    context(ExpectActualMatchingContext<*>)
+    private fun areCompatibleSupertypesTransitive(
+        expectClassSymbol: RegularClassSymbolMarker,
+        actualClassSymbol: RegularClassSymbolMarker,
+        substitutor: TypeSubstitutorMarker,
+    ): Boolean {
+        val expectSupertypes = expectClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
+        val actualType = actualClassSymbol.defaultType
+        return expectSupertypes.all { expectSupertype ->
+            actualTypeIsSubtypeOfExpectType(
+                expectType = substitutor.safeSubstitute(expectSupertype),
+                actualType = actualType
+            )
+        }
+    }
+
     context(ExpectActualMatchingContext<*>)
     private fun areCompatibleClassScopes(
         expectClassSymbol: RegularClassSymbolMarker,

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt

@@ -50,6 +50,14 @@ interface ExpectActualMatchingContext<T : DeclarationSymbolMarker> : TypeSystemC
     val allowClassActualizationWithWiderVisibility: Boolean
         get() = false
 
+    /**
+     * This flag determines strategy for matching supertypes between expect and actual class
+     *  - `false` means that expect and actual supertypes are matched one by one
+     *  - `true` means that type of actual class should be subtype of each expect supertype of the expect class
+     */
+    val allowTransitiveSupertypesActualization: Boolean
+        get() = false
+
     val RegularClassSymbolMarker.classId: ClassId
     val TypeAliasSymbolMarker.classId: ClassId
     val CallableSymbolMarker.callableId: CallableId
@@ -74,6 +82,7 @@ interface ExpectActualMatchingContext<T : DeclarationSymbolMarker> : TypeSystemC
     val CallableSymbolMarker.visibility: Visibility
 
     val RegularClassSymbolMarker.superTypes: List<KotlinTypeMarker>
+    val RegularClassSymbolMarker.defaultType: KotlinTypeMarker
 
     val CallableSymbolMarker.isExpect: Boolean
     val CallableSymbolMarker.isInline: Boolean
@@ -125,6 +134,11 @@ interface ExpectActualMatchingContext<T : DeclarationSymbolMarker> : TypeSystemC
         actualType: KotlinTypeMarker?,
     ): Boolean
 
+    fun actualTypeIsSubtypeOfExpectType(
+        expectType: KotlinTypeMarker,
+        actualType: KotlinTypeMarker
+    ): Boolean
+
     fun RegularClassSymbolMarker.isNotSamInterface(): Boolean
 
     /*

compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.types.model.*
 import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
 import org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction
 import org.jetbrains.kotlin.utils.addToStdlib.castAll
+import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
 import org.jetbrains.kotlin.utils.keysToMap
 
 class ClassicExpectActualMatchingContext(val platformModule: ModuleDescriptor) : ExpectActualMatchingContext<MemberDescriptor>,
@@ -212,6 +213,13 @@ class ClassicExpectActualMatchingContext(val platformModule: ModuleDescriptor) :
         }
     }
 
+    override val RegularClassSymbolMarker.defaultType: KotlinTypeMarker
+        get() = asDescriptor().defaultType
+
+    override fun actualTypeIsSubtypeOfExpectType(expectType: KotlinTypeMarker, actualType: KotlinTypeMarker): Boolean {
+        shouldNotBeCalled("Checking for subtyping is used only in FIR and IR implementations")
+    }
+
     @OptIn(TypeRefinement::class)
     private fun areCompatibleTypesViaTypeRefinement(a: KotlinType, b: KotlinType): Boolean {
         val typeRefinerForPlatformModule = platformModule.getKotlinTypeRefiner().let { moduleRefiner ->

compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt

@@ -0,0 +1,31 @@
+// IGNORE_BACKEND_K1: ANY
+//   IGNORE_REASON: new rules for supertypes matching are implemented only in K2
+// IGNORE_BACKEND_K2: JS_IR
+//   IGNORE_REASON: `JsName` in js.translator/testData/_commonFiles/testUtils.kt is invisible for some reason
+// IGNORE_BACKEND: WASM
+//   IGNORE_REASON: wasm tests don't support IGNORE_BACKEND_K1 directive
+// LANGUAGE: +MultiPlatformProjects
+// ISSUE: KT-59356
+
+// MODULE: common
+// FILE: common.kt
+open class A {
+    open fun foo(): String = "Fail"
+}
+expect class C() : A
+
+fun commonBox(): String {
+    return C().foo()
+}
+
+// MODULE: platform-jvm()()(common)
+// FILE: main.kt
+open class B : A() {
+    override fun foo(): String = "OK"
+}
+
+actual class C actual constructor() : B()
+
+fun box(): String {
+    return commonBox()
+}

compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization_java.kt

@@ -0,0 +1,39 @@
+// TARGET_BACKEND: JVM_IR
+// IGNORE_BACKEND_K1: ANY
+//   IGNORE_REASON: new rules for supertypes matching are implemented only in K2
+// LANGUAGE: +MultiPlatformProjects
+// ISSUE: KT-59356
+
+// MODULE: common
+open class A {
+    open fun foo(): String = "Fail"
+}
+expect class C1() : A
+expect class C2() : A
+
+fun commonBox(): String {
+    return C1().foo() + C2().foo()
+}
+
+// MODULE: platform-jvm()()(common)
+// FILE: A_J.java
+public class A_J {}
+
+// FILE: B_J.java
+public class B_J extends A_J {
+    public String foo() { return "O"; }
+}
+
+// FILE: C2_J.java
+public class C2_J extends B_J {
+    public String foo() { return "K"; }
+}
+
+// FILE: main.kt
+actual typealias A = A_J
+actual class C1 : B_J()
+actual typealias C2 = C2_J
+
+fun box(): String {
+    return commonBox()
+}

compiler/testData/diagnostics/tests/multiplatform/supertypeActualizationWithAny.kt

@@ -0,0 +1,8 @@
+// FIR_IDENTICAL
+// MODULE: m1-common
+expect open class A
+expect class B : A
+
+// MODULE: m1-jvm()()(m1-common)
+actual typealias A = Any
+actual class B

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -22558,6 +22558,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                 runTest("compiler/testData/diagnostics/tests/multiplatform/smartcastOnMemberPropertyFromCommonClass.kt");
             }
 
+            @Test
+            @TestMetadata("supertypeActualizationWithAny.kt")
+            public void testSupertypeActualizationWithAny() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/supertypeActualizationWithAny.kt");
+            }
+
             @Test
             @TestMetadata("varSetterVisibility.kt")
             public void testVarSetterVisibility() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java

@@ -32085,6 +32085,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @Test
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -33669,6 +33669,18 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
+                @Test
+                @TestMetadata("transitiveSuperclassActualization_java.kt")
+                public void testTransitiveSuperclassActualization_java() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization_java.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java

@@ -33669,6 +33669,18 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
+                @Test
+                @TestMetadata("transitiveSuperclassActualization_java.kt")
+                public void testTransitiveSuperclassActualization_java() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization_java.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

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

@@ -27360,6 +27360,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/nonExternalEquals.kt");
                 }
 
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/widerVisibilityInActualClassifier.kt");

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

@@ -23439,6 +23439,12 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @Test
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java

@@ -23607,6 +23607,12 @@ public class FirJsCodegenBoxTestGenerated extends AbstractFirJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @Test
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java

@@ -23607,6 +23607,12 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @Test
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java

@@ -23607,6 +23607,12 @@ public class IrJsES6CodegenBoxTestGenerated extends AbstractIrJsES6CodegenBoxTes
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @Test
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @Test
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java

@@ -26673,6 +26673,12 @@ public class FirNativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTe
                         runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                     }
 
+                    @Test
+                    @TestMetadata("transitiveSuperclassActualization.kt")
+                    public void testTransitiveSuperclassActualization() throws Exception {
+                        runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                    }
+
                     @Test
                     @TestMetadata("widerVisibilityInActualClassifier.kt")
                     public void testWiderVisibilityInActualClassifier() throws Exception {

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java

@@ -27279,6 +27279,12 @@ public class FirNativeCodegenBoxTestNoPLGenerated extends AbstractNativeCodegenB
                         runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                     }
 
+                    @Test
+                    @TestMetadata("transitiveSuperclassActualization.kt")
+                    public void testTransitiveSuperclassActualization() throws Exception {
+                        runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                    }
+
                     @Test
                     @TestMetadata("widerVisibilityInActualClassifier.kt")
                     public void testWiderVisibilityInActualClassifier() throws Exception {

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java

@@ -26371,6 +26371,12 @@ public class NativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTest
                         runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                     }
 
+                    @Test
+                    @TestMetadata("transitiveSuperclassActualization.kt")
+                    public void testTransitiveSuperclassActualization() throws Exception {
+                        runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                    }
+
                     @Test
                     @TestMetadata("widerVisibilityInActualClassifier.kt")
                     public void testWiderVisibilityInActualClassifier() throws Exception {

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java

@@ -26674,6 +26674,12 @@ public class NativeCodegenBoxTestNoPLGenerated extends AbstractNativeCodegenBoxT
                         runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                     }
 
+                    @Test
+                    @TestMetadata("transitiveSuperclassActualization.kt")
+                    public void testTransitiveSuperclassActualization() throws Exception {
+                        runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                    }
+
                     @Test
                     @TestMetadata("widerVisibilityInActualClassifier.kt")
                     public void testWiderVisibilityInActualClassifier() throws Exception {

wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java

@@ -20968,6 +20968,11 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
                 }
 
+                @TestMetadata("transitiveSuperclassActualization.kt")
+                public void testTransitiveSuperclassActualization() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt");
+                }
+
                 @TestMetadata("widerVisibilityInActualClassifier.kt")
                 public void testWiderVisibilityInActualClassifier() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/widerVisibilityInActualClassifier.kt");