Rename ResolutionCandidateApplicability to CandidateApplicability

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.calls
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability
 
 abstract class ResolutionDiagnostic(val applicability: CandidateApplicability)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterImpl.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi.Call
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.calls.model.*
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
 import org.jetbrains.kotlin.types.KotlinType
 import java.util.*
 
@@ -102,6 +102,6 @@ class TypeMismatchDiagnostic(
     val callArgument: KotlinCallArgument,
     val expectedType: KotlinType,
     val actualType: KotlinType
-) : KotlinCallDiagnostic(ResolutionCandidateApplicability.INAPPLICABLE) {
+) : KotlinCallDiagnostic(CandidateApplicability.INAPPLICABLE) {
     override fun report(reporter: DiagnosticReporter) = reporter.onCallArgument(callArgument, this)
-}
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt

@@ -922,12 +922,12 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
     }
 }
 
-fun ResolutionCandidateApplicability.toResolutionStatus(): ResolutionStatus = when (this) {
+fun CandidateApplicability.toResolutionStatus(): ResolutionStatus = when (this) {
-    ResolutionCandidateApplicability.RESOLVED,
+    CandidateApplicability.RESOLVED,
-    ResolutionCandidateApplicability.RESOLVED_LOW_PRIORITY,
+    CandidateApplicability.RESOLVED_LOW_PRIORITY,
-    ResolutionCandidateApplicability.RESOLVED_WITH_ERROR,
+    CandidateApplicability.RESOLVED_WITH_ERROR,
-    ResolutionCandidateApplicability.RESOLVED_NEED_PRESERVE_COMPATIBILITY -> ResolutionStatus.SUCCESS
+    CandidateApplicability.RESOLVED_NEED_PRESERVE_COMPATIBILITY -> ResolutionStatus.SUCCESS
-    ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER -> ResolutionStatus.RECEIVER_TYPE_ERROR
+    CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER -> ResolutionStatus.RECEIVER_TYPE_ERROR
     else -> ResolutionStatus.OTHER_ERROR
 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt

@@ -420,7 +420,7 @@ class NewResolutionOldInference(
         operator fun component1() = diagnostics
         operator fun component2() = resolvedCall
 
-        override val resultingApplicability: ResolutionCandidateApplicability by lazy(LazyThreadSafetyMode.NONE) {
+        override val resultingApplicability: CandidateApplicability by lazy(LazyThreadSafetyMode.NONE) {
             getResultApplicability(diagnostics)
         }
 
@@ -606,15 +606,15 @@ fun transformToReceiverWithSmartCastInfo(
     )
 }
 
-internal class PreviousResolutionError(candidateLevel: ResolutionCandidateApplicability) : ResolutionDiagnostic(candidateLevel)
+internal class PreviousResolutionError(candidateLevel: CandidateApplicability) : ResolutionDiagnostic(candidateLevel)
 
 internal fun createPreviousResolveError(status: ResolutionStatus): PreviousResolutionError? {
     val level = when (status) {
         ResolutionStatus.SUCCESS, ResolutionStatus.INCOMPLETE_TYPE_INFERENCE -> return null
-        ResolutionStatus.UNSAFE_CALL_ERROR -> ResolutionCandidateApplicability.MAY_THROW_RUNTIME_ERROR
+        ResolutionStatus.UNSAFE_CALL_ERROR -> CandidateApplicability.MAY_THROW_RUNTIME_ERROR
-        ResolutionStatus.ARGUMENTS_MAPPING_ERROR -> ResolutionCandidateApplicability.INAPPLICABLE_ARGUMENTS_MAPPING_ERROR
+        ResolutionStatus.ARGUMENTS_MAPPING_ERROR -> CandidateApplicability.INAPPLICABLE_ARGUMENTS_MAPPING_ERROR
-        ResolutionStatus.RECEIVER_TYPE_ERROR -> ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER
+        ResolutionStatus.RECEIVER_TYPE_ERROR -> CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER
-        else -> ResolutionCandidateApplicability.INAPPLICABLE
+        else -> CandidateApplicability.INAPPLICABLE
     }
     return PreviousResolutionError(level)
 }
@@ -665,4 +665,4 @@ internal fun reportResolvedUsingDeprecatedVisibility(
         )
     }
 
-}
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt

@@ -261,7 +261,7 @@ class PSICallResolver(
             return transformManyCandidatesAndRecordTrace(it, tracingStrategy, trace, context)
         }
 
-        if (getResultApplicability(diagnostics) == ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER) {
+        if (getResultApplicability(diagnostics) == CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER) {
             val singleCandidate = result.resultCallAtom() ?: error("Should be not null for result: $result")
             val resolvedCall = kotlinToResolvedCallTransformer.onlyTransform<D>(singleCandidate, diagnostics).also {
                 tracingStrategy.unresolvedReferenceWrongReceiver(trace, listOf(it))
@@ -333,7 +333,7 @@ class PSICallResolver(
 
     private fun Collection<KotlinResolutionCandidate>.areAllFailedWithInapplicableWrongReceiver() =
         all {
-            it.resultingApplicability == ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER
+            it.resultingApplicability == CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER
         }
 
     private fun CallResolutionResult.areAllInapplicable(): Boolean {
@@ -343,9 +343,9 @@ class PSICallResolver(
         }
 
         val applicability = getResultApplicability(diagnostics)
-        return applicability == ResolutionCandidateApplicability.INAPPLICABLE ||
+        return applicability == CandidateApplicability.INAPPLICABLE ||
-                applicability == ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER ||
+                applicability == CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER ||
-                applicability == ResolutionCandidateApplicability.HIDDEN
+                applicability == CandidateApplicability.HIDDEN
     }
 
     // true if we found something

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/model/ConstraintPositionAndErrors.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.resolve.calls.inference.model
 
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability.*
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability.*
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.TypeVariableMarker
 
@@ -78,7 +78,7 @@ object SimpleConstraintSystemConstraintPosition : ConstraintPosition()
 
 // ------------------------------------------------ Errors ------------------------------------------------
 
-sealed class ConstraintSystemError(val applicability: ResolutionCandidateApplicability)
+sealed class ConstraintSystemError(val applicability: CandidateApplicability)
 
 class NewConstraintError(
     val lowerType: KotlinTypeMarker,

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/tower/CandidateApplicability.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.resolve.calls.tower
 
-enum class ResolutionCandidateApplicability {
+enum class CandidateApplicability {
     RESOLVED, // call success or has uncompleted inference or in other words possible successful candidate
     RESOLVED_WITH_ERROR, // call has error, but it is still successful from resolution perspective
     RESOLVED_NEED_PRESERVE_COMPATIBILITY, // call resolved successfully, but using new features that changes resolve
@@ -21,5 +21,5 @@ enum class ResolutionCandidateApplicability {
     RESOLVED_TO_SAM_WITH_VARARG, // migration warning up to 1.5 (when resolve to function with SAM conversion and array without spread as vararg)
 }
 
-val ResolutionCandidateApplicability.isSuccess: Boolean
+val CandidateApplicability.isSuccess: Boolean
-    get() = this <= ResolutionCandidateApplicability.RESOLVED_LOW_PRIORITY
+    get() = this <= CandidateApplicability.RESOLVED_LOW_PRIORITY

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/TypeArgumentsToParametersMapper.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.resolve.calls.components
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.*
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability
 
 class TypeArgumentsToParametersMapper {
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/Diagnostics.kt

@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.resolve.calls.model
 
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
 
-abstract class KotlinCallDiagnostic(val candidateApplicability: ResolutionCandidateApplicability) {
+abstract class KotlinCallDiagnostic(val candidateApplicability: CandidateApplicability) {
     abstract fun report(reporter: DiagnosticReporter)
 }
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallDiagnostics.kt

@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.components.CallableReferenceCandidate
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability.*
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability.*
 import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.UnwrappedType
 
@@ -142,7 +142,7 @@ class SmartCastDiagnostic(
 sealed class UnstableSmartCast(
     val argument: ExpressionKotlinCallArgument,
     val targetType: UnwrappedType,
-    applicability: ResolutionCandidateApplicability,
+    applicability: CandidateApplicability,
 ) : KotlinCallDiagnostic(applicability) {
     override fun report(reporter: DiagnosticReporter) = reporter.onCallArgument(argument, this)
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionCandidate.kt

@@ -84,7 +84,7 @@ class KotlinResolutionCandidate(
 ) : Candidate, KotlinDiagnosticsHolder {
     val diagnosticsFromResolutionParts = arrayListOf<KotlinCallDiagnostic>() // TODO: this is mutable list, take diagnostics only once!
     private var newSystem: NewConstraintSystemImpl? = null
-    private var currentApplicability = ResolutionCandidateApplicability.RESOLVED
+    private var currentApplicability = CandidateApplicability.RESOLVED
     private var subResolvedAtoms: MutableList<ResolvedAtom> = arrayListOf()
 
     private val stepCount = resolutionSequence.sumBy { it.run { workCount() } }
@@ -155,7 +155,7 @@ class KotlinResolutionCandidate(
         get() = callComponents.statelessCallbacks.getVariableCandidateIfInvoke(resolvedCall.atom)
 
     private val variableApplicability
-        get() = variableCandidateIfInvoke?.resultingApplicability ?: ResolutionCandidateApplicability.RESOLVED
+        get() = variableCandidateIfInvoke?.resultingApplicability ?: CandidateApplicability.RESOLVED
 
     override val isSuccessful: Boolean
         get() {
@@ -163,7 +163,7 @@ class KotlinResolutionCandidate(
             return currentApplicability.isSuccess && variableApplicability.isSuccess && !getSystem().hasContradiction
         }
 
-    override val resultingApplicability: ResolutionCandidateApplicability
+    override val resultingApplicability: CandidateApplicability
         get() {
             processParts(stopOnFirstError = false)
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
 import org.jetbrains.kotlin.resolve.calls.model.DiagnosticReporter
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCallDiagnostic
-import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability.*
+import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability.*
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.scopes.ResolutionScope
@@ -90,14 +90,14 @@ class CandidateWithBoundDispatchReceiver(
 )
 
 @JvmName("getResultApplicabilityForConstraintErrors")
-fun getResultApplicability(diagnostics: Collection<ConstraintSystemError>): ResolutionCandidateApplicability =
+fun getResultApplicability(diagnostics: Collection<ConstraintSystemError>): CandidateApplicability =
     diagnostics.maxByOrNull { it.applicability }?.applicability ?: RESOLVED
 
 @JvmName("getResultApplicabilityForCallDiagnostics")
-fun getResultApplicability(diagnostics: Collection<KotlinCallDiagnostic>): ResolutionCandidateApplicability =
+fun getResultApplicability(diagnostics: Collection<KotlinCallDiagnostic>): CandidateApplicability =
     diagnostics.maxByOrNull { it.candidateApplicability }?.candidateApplicability ?: RESOLVED
 
-abstract class ResolutionDiagnostic(candidateApplicability: ResolutionCandidateApplicability) :
+abstract class ResolutionDiagnostic(candidateApplicability: CandidateApplicability) :
     KotlinCallDiagnostic(candidateApplicability) {
     override fun report(reporter: DiagnosticReporter) {
         // do nothing

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt

@@ -35,7 +35,7 @@ interface Candidate {
     // this operation should be very fast
     val isSuccessful: Boolean
 
-    val resultingApplicability: ResolutionCandidateApplicability
+    val resultingApplicability: CandidateApplicability
 
     fun addCompatibilityWarning(other: Candidate)
 }
@@ -315,7 +315,7 @@ class TowerResolver {
 
         override fun pushCandidates(candidates: Collection<C>) {
             candidates.filterNotTo(allCandidates) {
-                it.resultingApplicability == ResolutionCandidateApplicability.HIDDEN
+                it.resultingApplicability == CandidateApplicability.HIDDEN
             }
         }
     }
@@ -352,12 +352,12 @@ class TowerResolver {
         }
 
         private fun isSuccessfulCandidate(candidate: C): Boolean {
-            return candidate.resultingApplicability == ResolutionCandidateApplicability.RESOLVED
+            return candidate.resultingApplicability == CandidateApplicability.RESOLVED
-                    || candidate.resultingApplicability == ResolutionCandidateApplicability.RESOLVED_WITH_ERROR
+                    || candidate.resultingApplicability == CandidateApplicability.RESOLVED_WITH_ERROR
         }
 
         private fun isSuccessfulPreserveCompatibility(candidate: C): Boolean =
-            candidate.resultingApplicability == ResolutionCandidateApplicability.RESOLVED_NEED_PRESERVE_COMPATIBILITY
+            candidate.resultingApplicability == CandidateApplicability.RESOLVED_NEED_PRESERVE_COMPATIBILITY
 
         override fun pushCandidates(candidates: Collection<C>) {
             val thereIsSuccessful = candidates.any { it.isSuccessful }
@@ -378,12 +378,12 @@ class TowerResolver {
         override fun getFinalCandidates(): Collection<C> {
             val moreSuitableGroup = candidateGroups.minByOrNull { it.groupApplicability } ?: return emptyList()
             val groupApplicability = moreSuitableGroup.groupApplicability
-            if (groupApplicability == ResolutionCandidateApplicability.HIDDEN) return emptyList()
+            if (groupApplicability == CandidateApplicability.HIDDEN) return emptyList()
 
             return moreSuitableGroup.filter { it.resultingApplicability == groupApplicability }
         }
 
-        private val Collection<C>.groupApplicability: ResolutionCandidateApplicability
+        private val Collection<C>.groupApplicability: CandidateApplicability
-            get() = minOfOrNull { it.resultingApplicability } ?: ResolutionCandidateApplicability.HIDDEN
+            get() = minOfOrNull { it.resultingApplicability } ?: CandidateApplicability.HIDDEN
     }
 }

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerUtils.kt

@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 
 private val INAPPLICABLE_STATUSES = setOf(
-    ResolutionCandidateApplicability.INAPPLICABLE,
+    CandidateApplicability.INAPPLICABLE,
-    ResolutionCandidateApplicability.INAPPLICABLE_ARGUMENTS_MAPPING_ERROR,
+    CandidateApplicability.INAPPLICABLE_ARGUMENTS_MAPPING_ERROR,
-    ResolutionCandidateApplicability.INAPPLICABLE_WRONG_RECEIVER
+    CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER
 )
 
 val CallableDescriptor.isSynthesized: Boolean
@@ -31,7 +31,7 @@ val CallableDescriptor.isSynthesized: Boolean
 val CandidateWithBoundDispatchReceiver.requiresExtensionReceiver: Boolean
     get() = descriptor.extensionReceiverParameter != null
 
-val ResolutionCandidateApplicability.isInapplicable: Boolean
+val CandidateApplicability.isInapplicable: Boolean
     get() = this in INAPPLICABLE_STATUSES
 
 fun <C : Candidate> C.forceResolution(): C {