A proper modality calculation was missing in IR fake override construction algorithm

#KT-41765 Fixed

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/IrOverridingUtil.kt

@@ -6,17 +6,14 @@
 package org.jetbrains.kotlin.ir.overrides
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.WrappedPropertyDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
-import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.util.collectAndFilterRealOverrides
 import org.jetbrains.kotlin.ir.util.isReal
 import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo
@@ -284,7 +281,11 @@ class IrOverridingUtil(
         if (!hasOpen && hasAbstract) {
             return if (transformAbstractToClassModality) current.modality else Modality.ABSTRACT
         }
-        return getMinimalModality(members, transformAbstractToClassModality, current.modality)
+
+        val realOverrides = members
+            .map{ originals[it]!! }
+            .collectAndFilterRealOverrides()
+        return getMinimalModality(realOverrides, transformAbstractToClassModality, current.modality)
     }
 
     private fun areEquivalent(a: IrOverridableMember, b: IrOverridableMember) = (a == b)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrFakeOverrideUtils.kt

@@ -33,27 +33,47 @@ val IrFunction.target: IrFunction get() = when (this) {
 fun IrSimpleFunction.collectRealOverrides(toSkip: (IrSimpleFunction) -> Boolean = { false }): Set<IrSimpleFunction> {
     if (isReal && !toSkip(this)) return setOf(this)
 
-    val visited = mutableSetOf<IrSimpleFunction>()
-    val realOverrides = mutableSetOf<IrSimpleFunction>()
+    return this.overriddenSymbols
+        .map { it.owner }
+        .collectAndFilterRealOverrides {
+            require(it is IrSimpleFunction) { "Expected IrSimpleFunction: ${it.render()}" }
+            toSkip(it)
+        }
+        .map { it as IrSimpleFunction }
+        .toSet()
+}
 
-    fun collectRealOverrides(func: IrSimpleFunction) {
-        if (!visited.add(func)) return
+fun Collection<IrOverridableMember>.collectAndFilterRealOverrides(toSkip: (IrOverridableMember) -> Boolean = { false }): Set<IrOverridableMember> {
 
-        if (func.isReal && !toSkip(func)) {
-            realOverrides += func
+    val visited = mutableSetOf<IrOverridableMember>()
+    val realOverrides = mutableSetOf<IrOverridableMember>()
+
+    fun overriddenSymbols(declaration: IrOverridableMember) = when (declaration) {
+        is IrSimpleFunction -> declaration.overriddenSymbols
+        is IrProperty -> (declaration.getter ?: declaration.setter)
+            ?.overriddenSymbols?.mapNotNull { it.owner.correspondingPropertySymbol }
+            ?: emptyList()
+        else -> error("Unexpected overridable member: ${declaration.render()}")
+    }
+
+    fun collectRealOverrides(member: IrOverridableMember) {
+        if (!visited.add(member)) return
+
+        if (member.isReal && !toSkip(member)) {
+            realOverrides += member
         } else {
-            func.overriddenSymbols.forEach { collectRealOverrides(it.owner) }
+            overriddenSymbols(member).forEach { collectRealOverrides(it.owner as IrOverridableMember) }
         }
     }
 
-    overriddenSymbols.forEach { collectRealOverrides(it.owner) }
+    this.forEach { collectRealOverrides(it) }
 
-    fun excludeRepeated(func: IrSimpleFunction) {
-        if (!visited.add(func)) return
+    fun excludeRepeated(member: IrOverridableMember) {
+        if (!visited.add(member)) return
 
-        func.overriddenSymbols.forEach {
+        overriddenSymbols(member).forEach {
             realOverrides.remove(it.owner)
-            excludeRepeated(it.owner)
+            excludeRepeated(it.owner as IrOverridableMember)
         }
     }