Cleanup: rename getSingleExpectForActualOrNull w.r.t. KT-62590

New name makes slightly more sense after KT-6259 is fixed

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

@@ -28,7 +28,7 @@ object FirOverloadsChecker : FirFunctionChecker() {
         val annotation = declaration.getAnnotationByClassId(JVM_OVERLOADS_CLASS_ID, session) ?: return
 
         val ownerOfParametersWithDefaultValues = declaration.symbol.takeIf { !it.isActual }
-            ?: declaration.symbol.getSingleExpectForActualOrNull()
+            ?: declaration.symbol.getSingleMatchedExpectForActualOrNull()
             ?: return
 
         val containingDeclaration = declaration.getContainingClassSymbol(session)

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

@@ -12,7 +12,7 @@ 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.getSingleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleMatchedExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.expectActualMatchingContextFactory
 import org.jetbrains.kotlin.fir.isDelegated
@@ -37,7 +37,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.getSingleExpectForActualOrNull() ?: return
+        val expectedSingleCandidate = actualClassSymbol.getSingleMatchedExpectForActualOrNull() ?: return
         val expectClassSymbol = expectedSingleCandidate as FirRegularClassSymbol
 
         val expectActualMatchingContext = context.session.expectActualMatchingContextFactory.create(

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

@@ -12,7 +12,7 @@ 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.getSingleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleMatchedExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.scopes.collectAllFunctions
 import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors
@@ -32,7 +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.getSingleExpectForActualOrNull() ?: return
+        val expectedSingleCandidate = actualTypealiasSymbol.getSingleMatchedExpectForActualOrNull() ?: return
         val expectClassSymbol = expectedSingleCandidate as FirRegularClassSymbol
 
         val membersWithDefaultValueParameters = getMembersWithDefaultValueParametersUnlessAnnotation(expectClassSymbol)

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

@@ -131,7 +131,7 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker() {
                 allowedWritingMemberExpectForActualMapping = true,
             )
             val actualContainingClass = context.containingDeclarations.lastOrNull()?.symbol as? FirRegularClassSymbol
-            val expectContainingClass = actualContainingClass?.getSingleExpectForActualOrNull() as? FirRegularClassSymbol
+            val expectContainingClass = actualContainingClass?.getSingleMatchedExpectForActualOrNull() as? FirRegularClassSymbol
             getCheckingCompatibility(
                 symbol,
                 expectedSingleCandidate,

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

@@ -10,7 +10,7 @@ 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.getSingleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleMatchedExpectForActualOrNull
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
 import org.jetbrains.kotlin.fir.references.toResolvedNamedFunctionSymbol
@@ -20,7 +20,7 @@ object FirSuperCallWithDefaultsChecker : FirFunctionCallChecker() {
         if (expression.explicitReceiverIsNotSuperReference()) return
 
         val functionSymbol = expression.calleeReference.toResolvedNamedFunctionSymbol() ?: return
-        val relevantFunctionSymbol = functionSymbol.getSingleExpectForActualOrNull() ?: functionSymbol
+        val relevantFunctionSymbol = functionSymbol.getSingleMatchedExpectForActualOrNull() ?: functionSymbol
         if (!relevantFunctionSymbol.valueParameterSymbols.any { it.hasDefaultValue }) return
         val arguments = expression.argumentList as? FirResolvedArgumentList ?: return
         if (arguments.arguments.size < functionSymbol.valueParameterSymbols.size) {

compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt

@@ -116,7 +116,7 @@ private fun FirFunction.containsDefaultValue(index: Int): Boolean = valueParamet
  *  for this actual.
  */
 fun FirFunction.itOrExpectHasDefaultParameterValue(index: Int): Boolean =
-    containsDefaultValue(index) || symbol.getSingleExpectForActualOrNull()?.fir?.containsDefaultValue(index) == true
+    containsDefaultValue(index) || symbol.getSingleMatchedExpectForActualOrNull()?.fir?.containsDefaultValue(index) == true
 
 fun FirSimpleFunction.isEquals(session: FirSession): Boolean {
     if (name != OperatorNameConventions.EQUALS) return false

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.getSingleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleMatchedExpectForActualOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.isActual
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.declarations.utils.modality
@@ -297,7 +297,7 @@ class ConeOverloadConflictResolver(
         val expectForActualSymbols = candidates
             .mapNotNullTo(mutableSetOf()) {
                 val callableSymbol = it.symbol as? FirCallableSymbol<*> ?: return@mapNotNullTo null
-                runIf(callableSymbol.isActual) { callableSymbol.getSingleExpectForActualOrNull() }
+                runIf(callableSymbol.isActual) { callableSymbol.getSingleMatchedExpectForActualOrNull() }
             }
 
         return if (expectForActualSymbols.isEmpty()) {

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

@@ -28,16 +28,22 @@ typealias ExpectForActualMatchingData = Map<ExpectActualMatchingCompatibility, L
 @SymbolInternals
 var FirDeclaration.expectForActual: ExpectForActualMatchingData? by FirDeclarationDataRegistry.data(ExpectForActualAttributeKey)
 
-/**
+// Used in Compose. It's not clear for how long the compatibility must be preserved.
- * @see expectForActual
+// Please consult https://jetbrains.team/p/kti/documents/a/18Yt390c5HIq
- */
+@Deprecated("Use getSingleMatchedExpectForActualOrNull instead", ReplaceWith("getSingleMatchedExpectForActualOrNull()"))
 fun FirFunctionSymbol<*>.getSingleExpectForActualOrNull(): FirFunctionSymbol<*>? =
-    (this as FirBasedSymbol<*>).getSingleExpectForActualOrNull() as? FirFunctionSymbol<*>
+    getSingleMatchedExpectForActualOrNull()
 
 /**
  * @see expectForActual
  */
-fun FirBasedSymbol<*>.getSingleExpectForActualOrNull(): FirBasedSymbol<*>? =
+fun FirFunctionSymbol<*>.getSingleMatchedExpectForActualOrNull(): FirFunctionSymbol<*>? =
+    (this as FirBasedSymbol<*>).getSingleMatchedExpectForActualOrNull() as? FirFunctionSymbol<*>
+
+/**
+ * @see expectForActual
+ */
+fun FirBasedSymbol<*>.getSingleMatchedExpectForActualOrNull(): FirBasedSymbol<*>? =
     expectForActual?.get(ExpectActualMatchingCompatibility.MatchedSuccessfully)?.singleOrNull()
 
 /**