FIR: don't recreate tower resolver / conflict resolver / call completer

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

@@ -32,12 +32,19 @@ import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
 
 class FirCallResolver(
     private val transformer: FirBodyResolveTransformer,
-    private val topLevelScopes: List<FirScope>,
+    topLevelScopes: List<FirScope>,
-    private val localScopes: List<FirLocalScope>,
+    localScopes: List<FirLocalScope>,
     override val implicitReceiverStack: ImplicitReceiverStack,
     private val qualifiedResolver: FirQualifiedNameResolver
 ) : BodyResolveComponents by transformer {
 
+    private val towerResolver = FirTowerResolver(
+        returnTypeCalculator, this, resolutionStageRunner,
+        topLevelScopes = topLevelScopes.asReversed(),
+        localScopes = localScopes.asReversed()
+    )
+    private val conflictResolver = ConeOverloadConflictResolver(TypeSpecificityComparator.NONE, inferenceComponents)
+
     fun resolveCallAndSelectCandidate(functionCall: FirFunctionCall, expectedTypeRef: FirTypeRef?, file: FirFile): FirFunctionCall {
         qualifiedResolver.reset()
         @Suppress("NAME_SHADOWING")
@@ -60,11 +67,7 @@ class FirCallResolver(
             file,
             transformer.container
         ) { it.resultType }
-        val towerResolver = FirTowerResolver(
+        towerResolver.reset()
-            returnTypeCalculator, this, resolutionStageRunner,
-            topLevelScopes = topLevelScopes.asReversed(),
-            localScopes = localScopes.asReversed()
-        )
 
         val consumer = createFunctionConsumer(session, name, info, this, towerResolver.collector, towerResolver)
         val result = towerResolver.runResolver(consumer, implicitReceiverStack.receiversAsReversed())
@@ -72,8 +75,7 @@ class FirCallResolver(
         val reducedCandidates = if (result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED) {
             bestCandidates.toSet()
         } else {
-            ConeOverloadConflictResolver(TypeSpecificityComparator.NONE, inferenceComponents)
+            conflictResolver.chooseMaximallySpecificCandidates(bestCandidates, discriminateGenerics = false)
-                .chooseMaximallySpecificCandidates(bestCandidates, discriminateGenerics = false)
         }
 
 
@@ -154,11 +156,7 @@ class FirCallResolver(
             file,
             transformer.container
         ) { it.resultType }
-        val towerResolver = FirTowerResolver(
+        towerResolver.reset()
-            returnTypeCalculator, this, resolutionStageRunner,
-            topLevelScopes = topLevelScopes.asReversed(),
-            localScopes = localScopes.asReversed()
-        )
 
         val consumer = createVariableAndObjectConsumer(
             session,

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

@@ -22,7 +22,7 @@ enum class TowerDataKind {
 class FirTowerResolver(
     val typeCalculator: ReturnTypeCalculator,
     val components: BodyResolveComponents,
-    private val resolutionStageRunner: ResolutionStageRunner,
+    resolutionStageRunner: ResolutionStageRunner,
     val topLevelScopes: List<FirScope>,
     val localScopes: List<FirLocalScope>
 ) {
@@ -137,7 +137,11 @@ class FirTowerResolver(
         return group
     }
 
-    val collector by lazy { CandidateCollector(components, resolutionStageRunner) }
+    fun reset() {
+        collector.newDataSet()
+    }
+
+    val collector = CandidateCollector(components, resolutionStageRunner)
     private lateinit var towerDataConsumer: TowerDataConsumer
     private lateinit var implicitReceiverValues: List<ImplicitReceiverValue<*>>
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt

@@ -36,6 +36,8 @@ import org.jetbrains.kotlin.types.model.TypeVariableMarker
 class FirCallCompleter(
     private val transformer: FirBodyResolveTransformer
 ) : BodyResolveComponents by transformer {
+    private val completer = ConstraintSystemCompleter(inferenceComponents)
+
     fun <T : FirResolvable> completeCall(call: T, expectedTypeRef: FirTypeRef?): T {
         val typeRef = typeFromCallee(call)
         if (typeRef.type is ConeKotlinErrorType) {
@@ -58,7 +60,6 @@ class FirCallCompleter(
         }
 
         val completionMode = candidate.computeCompletionMode(inferenceComponents, expectedTypeRef, initialType)
-        val completer = ConstraintSystemCompleter(inferenceComponents)
         val replacements = mutableMapOf<FirExpression, FirExpression>()
 
         val analyzer = PostponedArgumentsAnalyzer(LambdaAnalyzerImpl(replacements), { it.resultType }, inferenceComponents)