[FIR] Add compatibleOnly parameter to getSingleCompatibleExpectForActualOrNull

Rename `getSingleCompatibleExpectForActualOrNull` to `getSingleExpectForActualOrNull`

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirActualCallableDeclarationChecker.kt

@@ -10,11 +10,15 @@ import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.expectForActual
+import org.jetbrains.kotlin.fir.declarations.getSingleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.areCompatibleExpectActualTypes
+import org.jetbrains.kotlin.fir.types.createExpectActualTypeParameterSubstitutor
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
 
 object FirActualCallableDeclarationChecker : FirCallableDeclarationChecker() {
@@ -37,7 +41,7 @@ object FirActualCallableDeclarationChecker : FirCallableDeclarationChecker() {
 
     private fun checkReturnTypes(callableDeclaration: FirCallableDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         val actualFunctionSymbol = callableDeclaration.symbol
-        val expectFunctionSymbol = actualFunctionSymbol.getSingleCompatibleExpectForActualOrNull() as? FirCallableSymbol ?: return
+        val expectFunctionSymbol = actualFunctionSymbol.getSingleExpectForActualOrNull() as? FirCallableSymbol ?: return
 
         val expectTypeParameters = expectFunctionSymbol.getContainingClassSymbol(expectFunctionSymbol.moduleData.session)
             ?.typeParameterSymbols.orEmpty()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt

@@ -180,7 +180,7 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker() {
                 }
             }
         }
-        val expectedSingleCandidate = compatibilityToMembersMap.values.singleOrNull()?.firstOrNull()
+        val expectedSingleCandidate = symbol.getSingleExpectForActualOrNull()
         if (expectedSingleCandidate != null) {
             checkIfExpectHasDefaultArgumentsAndActualizedWithTypealias(
                 expectedSingleCandidate,

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -700,7 +700,7 @@ class FirElementSerializer private constructor(
         val builder = ProtoBuf.ValueParameter.newBuilder()
 
         val declaresDefaultValue = parameter.defaultValue != null ||
-                function.symbol.getSingleCompatibleExpectForActualOrNull().containsDefaultValue(index)
+                function.symbol.getSingleExpectForActualOrNull(compatibleOnly = true).containsDefaultValue(index)
 
         val flags = Flags.getValueParameterFlags(
             additionalAnnotations.isNotEmpty() || parameter.nonSourceAnnotations(session).isNotEmpty(),

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDefaultParametersResolver.kt

@@ -21,7 +21,7 @@ class FirDefaultParametersResolver : FirSessionComponent {
         originScope: FirScope?,
         index: Int,
     ): Boolean {
-        if (valueParameter.defaultValue != null || function.symbol.getSingleCompatibleExpectForActualOrNull().containsDefaultValue(index)) {
+        if (valueParameter.defaultValue != null || function.symbol.getSingleExpectForActualOrNull().containsDefaultValue(index)) {
             return true
         }
         if (function !is FirSimpleFunction) return false
@@ -45,7 +45,7 @@ class FirDefaultParametersResolver : FirSessionComponent {
 
         typeScope.processOverriddenFunctions(symbol) { overridden ->
             if (overridden.containsDefaultValue(index) ||
-                overridden.getSingleCompatibleExpectForActualOrNull().containsDefaultValue(index)
+                overridden.getSingleExpectForActualOrNull().containsDefaultValue(index)
             ) {
                 result = true
                 return@processOverriddenFunctions ProcessorAction.STOP

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/ExpectActualAttributes.kt

@@ -19,22 +19,22 @@ typealias ExpectForActualData = Map<ExpectActualCompatibility<FirBasedSymbol<*>>
 @SymbolInternals
 var FirDeclaration.expectForActual: ExpectForActualData? by FirDeclarationDataRegistry.data(ExpectForActualAttributeKey)
 
-fun FirFunctionSymbol<*>.getSingleCompatibleExpectForActualOrNull() =
+fun FirFunctionSymbol<*>.getSingleExpectForActualOrNull(compatibleOnly: Boolean = false) =
-    (this as FirBasedSymbol<*>).getSingleCompatibleExpectForActualOrNull() as? FirFunctionSymbol<*>
+    (this as FirBasedSymbol<*>).getSingleExpectForActualOrNull(compatibleOnly) as? FirFunctionSymbol<*>
 
-fun FirBasedSymbol<*>.getSingleCompatibleExpectForActualOrNull(): FirBasedSymbol<*>? {
+fun FirBasedSymbol<*>.getSingleExpectForActualOrNull(compatibleOnly: Boolean = false): FirBasedSymbol<*>? {
     val expectForActual = expectForActual ?: return null
-    var compatibleActuals: List<FirBasedSymbol<*>>? = null
+    var actuals: List<FirBasedSymbol<*>>? = null
     for ((key, item) in expectForActual) {
-        if (key.compatible) {
+        if (!compatibleOnly || key.compatible) {
-            if (compatibleActuals == null) {
+            if (actuals == null) {
-                compatibleActuals = item
+                actuals = item
             } else {
-                return null // Exit if there are more than one list with compatible actuals
+                return null // Exit if there are more than one list with actuals
             }
         }
     }
-    return compatibleActuals?.singleOrNull()
+    return actuals?.singleOrNull()
 }
 
 val FirBasedSymbol<*>.expectForActual: ExpectForActualData?

compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt

@@ -336,7 +336,7 @@ class ExpectedActualDeclarationChecker(
                 }
             }
         }
-        val expectSingleCandidate = compatibility.values.singleOrNull()?.firstOrNull()
+        val expectSingleCandidate = compatibility.values.singleOrNull()?.singleOrNull()
         if (expectSingleCandidate != null) {
             checkIfExpectHasDefaultArgumentsAndActualizedWithTypealias(expectSingleCandidate, reportOn, trace)
         }