FIR: Provide BodyResolveComponents instead of InferenceComponents to resolution

It seems to be more reasonable to store SamResolver, ScopeSession
and other per-transformer/per-thread components there

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

@@ -12,13 +12,14 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedQualifierImpl
-import org.jetbrains.kotlin.fir.references.*
+import org.jetbrains.kotlin.fir.references.FirBackingFieldReferenceImpl
+import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
+import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
+import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStack
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.transformers.*
-import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference
-import org.jetbrains.kotlin.fir.resolve.transformers.resultType
 import org.jetbrains.kotlin.fir.resolve.typeForQualifier
 import org.jetbrains.kotlin.fir.resolve.typeFromCallee
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -60,12 +61,12 @@ class FirCallResolver(
             transformer.container
         ) { it.resultType }
         val resolver = CallResolver(
-            returnTypeCalculator, inferenceComponents, resolutionStageRunner,
+            returnTypeCalculator, this, resolutionStageRunner,
             topLevelScopes = topLevelScopes.asReversed(),
             localScopes = localScopes.asReversed()
         )
 
-        val consumer = createFunctionConsumer(session, name, info, inferenceComponents, resolver.collector, resolver)
+        val consumer = createFunctionConsumer(session, name, info, this, resolver.collector, resolver)
         val result = resolver.runTowerResolver(consumer, implicitReceiverStack.receiversAsReversed())
         val bestCandidates = result.bestCandidates()
         val reducedCandidates = if (result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED) {
@@ -154,7 +155,7 @@ class FirCallResolver(
             transformer.container
         ) { it.resultType }
         val resolver = CallResolver(
-            returnTypeCalculator, inferenceComponents, resolutionStageRunner,
+            returnTypeCalculator, this, resolutionStageRunner,
             topLevelScopes = topLevelScopes.asReversed(),
             localScopes = localScopes.asReversed()
         )
@@ -162,7 +163,7 @@ class FirCallResolver(
         val consumer = createVariableAndObjectConsumer(
             session,
             callee.name,
-            info, inferenceComponents,
+            info, this,
             resolver.collector
         )
         val result = resolver.runTowerResolver(consumer, implicitReceiverStack.receiversAsReversed())
@@ -252,4 +253,4 @@ class FirCallResolver(
             else -> "$symbol"
         }
     }
-}
+}

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

@@ -30,7 +30,8 @@ interface BodyResolveComponents : SessionHolder {
     val container: FirDeclaration
     val inferenceComponents: InferenceComponents
     val resolutionStageRunner: ResolutionStageRunner
+    val scopeSession: ScopeSession
 
     val <D> AbstractFirBasedSymbol<D>.phasedFir: D where D : FirDeclaration, D : FirSymbolOwner<D>
         get() = phasedFir(session, FirResolvePhase.DECLARATIONS)
-}
+}

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
@@ -17,8 +18,8 @@ enum class TowerDataKind {
 
 class CallResolver(
     val typeCalculator: ReturnTypeCalculator,
-    val components: InferenceComponents,
-    val resolutionStageRunner: ResolutionStageRunner,
+    val components: BodyResolveComponents,
+    private val resolutionStageRunner: ResolutionStageRunner,
     val topLevelScopes: List<FirScope>,
     val localScopes: List<FirLocalScope>
 ) {
@@ -207,4 +208,4 @@ class CallResolver(
 
         return collector
     }
-}
+}

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
@@ -49,17 +50,17 @@ class Candidate(
     val dispatchReceiverValue: ClassDispatchReceiverValue?,
     val implicitExtensionReceiverValue: ImplicitReceiverValue<*>?,
     val explicitReceiverKind: ExplicitReceiverKind,
-    private val inferenceComponents: InferenceComponents,
+    private val bodyResolveComponents: BodyResolveComponents,
     private val baseSystem: ConstraintStorage,
     val callInfo: CallInfo
 ) {
     val system by lazy {
-        val system = inferenceComponents.createConstraintSystem()
+        val system = bodyResolveComponents.inferenceComponents.createConstraintSystem()
         system.addOtherSystem(baseSystem)
         system
     }
 
-    val samResolver get() = inferenceComponents.samResolver
+    val samResolver get() = bodyResolveComponents.inferenceComponents.samResolver
 
     lateinit var substitutor: ConeSubstitutor
 

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

@@ -6,12 +6,13 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 open class CandidateCollector(
-    val components: InferenceComponents,
+    val components: BodyResolveComponents,
     val resolutionStageRunner: ResolutionStageRunner
 ) {
     val groupNumbers = mutableListOf<Int>()
@@ -70,7 +71,7 @@ open class CandidateCollector(
 class InvokeReceiverCandidateCollector(
     val callResolver: CallResolver,
     val invokeCallInfo: CallInfo,
-    components: InferenceComponents,
+    components: BodyResolveComponents,
     val invokeConsumer: AccumulatingTowerDataConsumer,
     resolutionStageRunner: ResolutionStageRunner
 ) : CandidateCollector(components, resolutionStageRunner) {
@@ -104,7 +105,7 @@ class InvokeReceiverCandidateCollector(
             invokeConsumer.addConsumer(
                 createSimpleFunctionConsumer(
                     session, OperatorNameConventions.INVOKE,
-                    boundInvokeCallInfo, components, callResolver.collector
+                    boundInvokeCallInfo, callResolver.components, callResolver.collector
                 )
             )
         }

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.returnExpressions
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer
@@ -13,14 +14,14 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 
 class CandidateFactory(
-    val inferenceComponents: InferenceComponents,
-    val callInfo: CallInfo
+    val bodyResolveComponents: BodyResolveComponents,
+    private val callInfo: CallInfo
 ) {
 
-    val baseSystem: ConstraintStorage
+    private val baseSystem: ConstraintStorage
 
     init {
-        val system = inferenceComponents.createConstraintSystem()
+        val system = bodyResolveComponents.inferenceComponents.createConstraintSystem()
         callInfo.explicitReceiver?.let { system.addSubsystemFromExpression(it) }
         callInfo.arguments.forEach {
             system.addSubsystemFromExpression(it)
@@ -36,7 +37,7 @@ class CandidateFactory(
     ): Candidate {
         return Candidate(
             symbol, dispatchReceiverValue, implicitExtensionReceiverValue,
-            explicitReceiverKind, inferenceComponents, baseSystem, callInfo
+            explicitReceiverKind, bodyResolveComponents, baseSystem, callInfo
         )
     }
 }
@@ -54,4 +55,4 @@ internal fun FirResolvable.candidate(): Candidate? {
         is FirNamedReferenceWithCandidate -> return callee.candidate
         else -> null
     }
-}
+}

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

@@ -7,13 +7,14 @@ package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.name.Name
 
 fun createVariableAndObjectConsumer(
     session: FirSession,
     name: Name,
     callInfo: CallInfo,
-    inferenceComponents: InferenceComponents,
+    bodyResolveComponents: BodyResolveComponents,
     resultCollector: CandidateCollector
 ): TowerDataConsumer {
     return PrioritizedTowerDataConsumer(
@@ -23,7 +24,7 @@ fun createVariableAndObjectConsumer(
             name,
             TowerScopeLevel.Token.Properties,
             callInfo,
-            inferenceComponents,
+            bodyResolveComponents,
             resultCollector
         ),
         createSimpleConsumer(
@@ -31,7 +32,7 @@ fun createVariableAndObjectConsumer(
             name,
             TowerScopeLevel.Token.Objects,
             callInfo,
-            inferenceComponents,
+            bodyResolveComponents,
             resultCollector
         )
     )
@@ -41,7 +42,7 @@ fun createSimpleFunctionConsumer(
     session: FirSession,
     name: Name,
     callInfo: CallInfo,
-    inferenceComponents: InferenceComponents,
+    bodyResolveComponents: BodyResolveComponents,
     resultCollector: CandidateCollector
 ): TowerDataConsumer {
     return createSimpleConsumer(
@@ -49,7 +50,7 @@ fun createSimpleFunctionConsumer(
         name,
         TowerScopeLevel.Token.Functions,
         callInfo,
-        inferenceComponents,
+        bodyResolveComponents,
         resultCollector
     )
 }
@@ -58,7 +59,7 @@ fun createFunctionConsumer(
     session: FirSession,
     name: Name,
     callInfo: CallInfo,
-    inferenceComponents: InferenceComponents,
+    bodyResolveComponents: BodyResolveComponents,
     resultCollector: CandidateCollector,
     callResolver: CallResolver
 ): TowerDataConsumer {
@@ -68,7 +69,7 @@ fun createFunctionConsumer(
         emptyList(),
         callInfo.isSafeCall,
         callInfo.typeArguments,
-        inferenceComponents.session,
+        bodyResolveComponents.session,
         callInfo.containingFile,
         callInfo.container,
         callInfo.typeProvider
@@ -80,7 +81,7 @@ fun createFunctionConsumer(
             name,
             TowerScopeLevel.Token.Functions,
             callInfo,
-            inferenceComponents,
+            bodyResolveComponents,
             resultCollector
         ),
         AccumulatingTowerDataConsumer(resultCollector).apply {
@@ -89,11 +90,11 @@ fun createFunctionConsumer(
                 name,
                 TowerScopeLevel.Token.Properties,
                 varCallInfo,
-                inferenceComponents,
+                bodyResolveComponents,
                 InvokeReceiverCandidateCollector(
                     callResolver,
                     invokeCallInfo = callInfo,
-                    components = inferenceComponents,
+                    components = bodyResolveComponents,
                     invokeConsumer = this,
                     resolutionStageRunner = resultCollector.resolutionStageRunner
                 )
@@ -107,10 +108,10 @@ fun createSimpleConsumer(
     name: Name,
     token: TowerScopeLevel.Token<*>,
     callInfo: CallInfo,
-    inferenceComponents: InferenceComponents,
+    bodyResolveComponents: BodyResolveComponents,
     resultCollector: CandidateCollector
 ): TowerDataConsumer {
-    val factory = CandidateFactory(inferenceComponents, callInfo)
+    val factory = CandidateFactory(bodyResolveComponents, callInfo)
     val explicitReceiver = callInfo.explicitReceiver
     return if (explicitReceiver != null) {
         val receiverValue = ExpressionReceiverValue(explicitReceiver, callInfo.typeProvider)

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

@@ -167,7 +167,7 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
         if (skipGroup(group, resultCollector)) return ProcessorAction.NEXT
         return when (kind) {
             TowerDataKind.EMPTY ->
-                MemberScopeTowerLevel(session, explicitReceiver, scopeSession = candidateFactory.inferenceComponents.scopeSession)
+                MemberScopeTowerLevel(session, explicitReceiver, scopeSession = candidateFactory.bodyResolveComponents.scopeSession)
                     .processElementsByName(
                         token,
                         name,
@@ -220,7 +220,7 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
                     val declarationReceiverType = declarationReceiverTypeRef?.type
                     if (declarationReceiverType is ConeClassType) {
                         if (!AbstractTypeChecker.isSubtypeOf(
-                                candidateFactory.inferenceComponents.ctx,
+                                candidateFactory.bodyResolveComponents.inferenceComponents.ctx,
                                 explicitReceiverType,
                                 declarationReceiverType.lookupTag.constructClassType(
                                     declarationReceiverType.typeArguments.map { ConeStarProjection }.toTypedArray(),

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt

@@ -46,7 +46,7 @@ open class FirBodyResolveTransformer(
     final override val session: FirSession,
     phase: FirResolvePhase,
     implicitTypeOnly: Boolean,
-    val scopeSession: ScopeSession = ScopeSession()
+    final override val scopeSession: ScopeSession = ScopeSession()
 ) : FirAbstractPhaseTransformer<Any?>(phase), BodyResolveComponents {
     var implicitTypeOnly: Boolean = implicitTypeOnly
         private set

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -87,7 +87,7 @@ class FirSyntheticCallGenerator(private val transformer: FirBodyResolveTransform
     }
 
     private fun generateCandidate(callInfo: CallInfo, function: FirMemberFunctionImpl): Candidate =
-        CandidateFactory(inferenceComponents, callInfo).createCandidate(
+        CandidateFactory(transformer, callInfo).createCandidate(
             symbol = function.symbol,
             dispatchReceiverValue = null,
             implicitExtensionReceiverValue = null,
@@ -156,4 +156,4 @@ class FirSyntheticCallGenerator(private val transformer: FirBodyResolveTransform
     ).apply {
         this.resolvePhase = FirResolvePhase.BODY_RESOLVE
     }
-}
+}