[K2, MPP] Handle overloaded properties

^KT-57532 Fixed

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

@@ -163,16 +163,23 @@ private class MemberLinksCollector(
     }
 
     private fun addLink(declaration: IrDeclarationBase) {
-        val actualMember = actualMembers.getMatch(declaration, expectActualMap, typeAliasMap)
+        val actualMemberMatches = actualMembers.getMatches(declaration, expectActualMap, typeAliasMap)
-        if (actualMember != null) {
+        when {
-            expectActualMap[declaration.symbol] = actualMember.symbol
+            actualMemberMatches.size == 1 -> {
-            if (declaration is IrProperty) {
+                val actualMember = actualMemberMatches.single()
-                val actualProperty = actualMember as IrProperty
+                expectActualMap[declaration.symbol] = actualMember.symbol
-                declaration.getter?.symbol?.let { expectActualMap[it] = actualProperty.getter!!.symbol }
+                if (declaration is IrProperty) {
-                declaration.setter?.symbol?.let { expectActualMap[it] = actualProperty.setter!!.symbol }
+                    val actualProperty = actualMember as IrProperty
+                    declaration.getter!!.symbol.let { expectActualMap[it] = actualProperty.getter!!.symbol }
+                    declaration.setter?.symbol?.let { expectActualMap[it] = actualProperty.setter!!.symbol }
+                }
+            }
+            actualMemberMatches.size > 1 -> {
+                // TODO: report AMBIGUOUS_ACTUALS here, see KT-57932
+            }
+            !declaration.parent.containsOptionalExpectation() && !(declaration is IrConstructor && declaration.isPrimary) -> {
+                diagnosticsReporter.reportMissingActual(declaration)
             }
-        } else if (!declaration.parent.containsOptionalExpectation() && !(declaration is IrConstructor && declaration.isPrimary)) {
-            diagnosticsReporter.reportMissingActual(declaration)
         }
     }
 

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

@@ -20,21 +20,29 @@ import org.jetbrains.kotlin.ir.util.kotlinFqName
 import org.jetbrains.kotlin.ir.util.module
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.multiplatform.OptionalAnnotationUtil
-import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
-fun Map<String, List<IrDeclaration>>.getMatch(
+internal fun Map<String, List<IrDeclaration>>.getMatches(
     expectDeclaration: IrDeclaration,
     expectActualTypesMap: Map<IrSymbol, IrSymbol>,
     expectActualTypeAliasMap: Map<FqName, FqName>
-): IrDeclaration? {
+): List<IrDeclaration> {
-    val members = this[generateIrElementFullNameFromExpect(expectDeclaration, expectActualTypeAliasMap)] ?: return null
+    val members = this[generateIrElementFullNameFromExpect(expectDeclaration, expectActualTypeAliasMap)] ?: return emptyList()
-    return if (expectDeclaration is IrFunction) {
+    return when (expectDeclaration) {
-        members.firstNotNullOfOrNull { runIf(expectDeclaration.match(it as IrFunction, expectActualTypesMap)) { it } }
+        is IrFunction -> members.getMatches(expectDeclaration, expectActualTypesMap) { it as IrFunction }
-    } else {
+        is IrProperty -> members.getMatches(expectDeclaration, expectActualTypesMap) { (it as IrProperty).getter!! }
-        members.singleOrNull()
+        else -> members
     }
 }
 
+private inline fun List<IrDeclaration>.getMatches(
+    expect: IrDeclaration,
+    expectActualTypesMap: Map<IrSymbol, IrSymbol>,
+    functionExtractor: (IrDeclaration) -> IrFunction
+): List<IrDeclaration> {
+    val expectFunction = functionExtractor(expect)
+    return filter { expectFunction.match(functionExtractor(it), expectActualTypesMap) }
+}
+
 private fun IrFunction.match(actualFunction: IrFunction, expectActualTypesMap: Map<IrSymbol, IrSymbol>): Boolean {
     fun getActualizedValueParameterSymbol(
         expectParameter: IrValueParameter,

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

@@ -83,7 +83,7 @@ class MissingFakeOverridesAdder(
             else -> return
         }
 
-        if (members.getMatch(newMember, expectActualMap, typeAliasMap) == null) {
+        if (members.getMatches(newMember, expectActualMap, typeAliasMap).isEmpty()) {
             declaration.declarations.add(newMember)
             members.getOrPut(generateIrElementFullNameFromExpect(newMember, typeAliasMap)) { mutableListOf() }.add(newMember)
         } else {

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

@@ -11,8 +11,18 @@ expect fun foo(s: S): S
 
 expect fun foo(i: Int): Int
 
+expect val Int.k: Int
+
+expect val String.k: String
+
+expect var Int.l: Int
+
+expect var String.l: String
+
 fun test(s: S) = foo(s)
 
+fun k() = "K".k + "".l
+
 // MODULE: platform()()(common)
 // FILE: platform.kt
 
@@ -20,6 +30,18 @@ actual fun foo(i: Int) = i
 
 actual fun foo(s: String) = s
 
+actual val Int.k: Int get() = 42
+
+actual val String.k: String get() = this
+
+actual var Int.l: Int
+    get() = 48
+    set(value) {}
+
+actual var String.l: String
+    get() = this
+    set(value) {}
+
 actual typealias S = String
 
-fun box() = test("OK")
+fun box() = test("O") + k()