[FIR] Merge getSingleCompatibleOrWeaklyIncompatibleExpectForActualOrNull into getSingleExpectForActualOrNull

Use getSingleExpectForActualOrNull everywhere

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.FirExpectActualMatchingContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.getSingleCompatibleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.getSingleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.expectActualMatchingContextFactory
@@ -36,9 +35,7 @@ internal object FirDefaultArgumentsInExpectActualizedByFakeOverrideChecker : Fir
         }
         val actualClassSymbol = declaration.symbol
         // We want to report errors even if a candidate is incompatible, but it's single
-        val expectedSingleCandidate = actualClassSymbol.getSingleCompatibleExpectForActualOrNull()
-            ?: actualClassSymbol.getSingleExpectForActualOrNull()
-            ?: return
+        val expectedSingleCandidate = actualClassSymbol.getSingleExpectForActualOrNull() ?: return
         val expectClassSymbol = expectedSingleCandidate as FirRegularClassSymbol
 
         val matchingContext = context.session.expectActualMatchingContextFactory.create(context.session, context.scopeSession)

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
-import org.jetbrains.kotlin.fir.declarations.getSingleCompatibleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.getSingleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.scopes.collectAllFunctions
@@ -33,9 +32,7 @@ internal object FirDefaultArgumentsInExpectWithActualTypealiasChecker : FirTypeA
         }
         val actualTypealiasSymbol = declaration.symbol
         // We want to report errors even if a candidate is incompatible, but it's single
-        val expectedSingleCandidate = actualTypealiasSymbol.getSingleCompatibleExpectForActualOrNull()
-            ?: actualTypealiasSymbol.getSingleExpectForActualOrNull()
-            ?: return
+        val expectedSingleCandidate = actualTypealiasSymbol.getSingleExpectForActualOrNull() ?: return
         val expectClassSymbol = expectedSingleCandidate as FirRegularClassSymbol
 
         val membersWithDefaultValueParameters = getMembersWithDefaultValueParametersUnlessAnnotation(expectClassSymbol)

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

@@ -185,8 +185,7 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker() {
             else -> {}
         }
         // We want to report errors even if a candidate is incompatible, but it's single
-        val expectedSingleCandidate = symbol.getSingleCompatibleExpectForActualOrNull()
-            ?: symbol.getSingleExpectForActualOrNull()
+        val expectedSingleCandidate = symbol.getSingleExpectForActualOrNull()
         if (expectedSingleCandidate != null) {
             checkOptInAnnotation(declaration, expectedSingleCandidate, context, reporter)
             checkAnnotationsMatch(expectedSingleCandidate, symbol, context, reporter)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuperCallWithDefaultsChecker.kt

@@ -10,19 +10,17 @@ import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.explicitReceiverIsNotSuperReference
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.declarations.getSingleCompatibleOrWeaklyIncompatibleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
 import org.jetbrains.kotlin.fir.references.toResolvedNamedFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 
 object FirSuperCallWithDefaultsChecker : FirFunctionCallChecker() {
     override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
         if (expression.explicitReceiverIsNotSuperReference()) return
 
         val functionSymbol = expression.calleeReference.toResolvedNamedFunctionSymbol() ?: return
-        val relevantFunctionSymbol =
-            (functionSymbol.getSingleCompatibleOrWeaklyIncompatibleExpectForActualOrNull() as? FirNamedFunctionSymbol) ?: functionSymbol
+        val relevantFunctionSymbol = functionSymbol.getSingleExpectForActualOrNull() ?: functionSymbol
         if (!relevantFunctionSymbol.valueParameterSymbols.any { it.hasDefaultValue }) return
         val arguments = expression.argumentList as? FirResolvedArgumentList ?: return
         if (arguments.arguments.size < functionSymbol.valueParameterSymbols.size) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.calls
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.getSingleCompatibleOrWeaklyIncompatibleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.declarations.utils.modality
@@ -290,7 +290,7 @@ class ConeOverloadConflictResolver(
         val expectForActualSymbols = candidates
             .mapNotNullTo(mutableSetOf()) {
                 val callableSymbol = it.symbol as? FirCallableSymbol<*> ?: return@mapNotNullTo null
-                runIf(callableSymbol.isActual) { callableSymbol.getSingleCompatibleOrWeaklyIncompatibleExpectForActualOrNull() }
+                runIf(callableSymbol.isActual) { callableSymbol.getSingleExpectForActualOrNull() }
             }
 
         return if (expectForActualSymbols.isEmpty()) {

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

@@ -24,14 +24,6 @@ fun FirFunctionSymbol<*>.getSingleExpectForActualOrNull(): FirFunctionSymbol<*>?
     (this as FirBasedSymbol<*>).getSingleExpectForActualOrNull() as? FirFunctionSymbol<*>
 
 fun FirBasedSymbol<*>.getSingleExpectForActualOrNull(): FirBasedSymbol<*>? {
-    return expectForActual?.values?.singleOrNull()?.singleOrNull()
-}
-
-fun FirBasedSymbol<*>.getSingleCompatibleExpectForActualOrNull(): FirBasedSymbol<*>? {
-    return expectForActual?.get(ExpectActualCompatibility.Compatible)?.singleOrNull()
-}
-
-fun FirBasedSymbol<*>.getSingleCompatibleOrWeaklyIncompatibleExpectForActualOrNull(): FirBasedSymbol<*>? {
     val expectForActual = expectForActual ?: return null
     val compatibleOrWeakCompatible: List<FirBasedSymbol<*>> =
         expectForActual.entries.singleOrNull { it.key.isCompatibleOrWeaklyIncompatible }?.value ?: return null