diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index b947ccb9e5c..b0edf17c815 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -146,9 +146,7 @@ class FirCallResolver( transformer.components.containingDeclarations, ) towerResolver.reset() - val result = towerResolver.runResolver( - info, - ) + val result = towerResolver.runResolver(info, transformer.resolutionContext) val bestCandidates = result.bestCandidates() val reducedCandidates = if (!result.currentApplicability.isSuccess) { bestCandidates.toSet() @@ -256,6 +254,7 @@ class FirCallResolver( val localCollector = CandidateCollector(this, resolutionStageRunner) val result = towerResolver.runResolver( info, + transformer.resolutionContext, collector = localCollector, manager = TowerResolveManager(localCollector), ) @@ -317,7 +316,8 @@ class FirCallResolver( val result = towerResolver.runResolverForDelegatingConstructor( callInfo, - constructedType + constructedType, + transformer.resolutionContext ) return callResolver.selectDelegatingConstructorCall(delegatedConstructorCall, name, result, callInfo) @@ -396,11 +396,11 @@ class FirCallResolver( } } if (constructorSymbol == null) return null - val candidate = CandidateFactory(components, callInfo).createCandidate( + val candidate = CandidateFactory(transformer.resolutionContext, callInfo).createCandidate( constructorSymbol!!, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER ) - val applicability = resolutionStageRunner.processCandidate(candidate) + val applicability = resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext) return ResolutionResult(callInfo, applicability, listOf(candidate)) } @@ -541,8 +541,8 @@ class FirCallResolver( source: FirSourceElement?, name: Name ): FirErrorReferenceWithCandidate { - val candidate = CandidateFactory(components, callInfo).createErrorCandidate(diagnostic) - resolutionStageRunner.processCandidate(candidate, stopOnFirstError = false) + val candidate = CandidateFactory(transformer.resolutionContext, callInfo).createErrorCandidate(diagnostic) + resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext, stopOnFirstError = false) return FirErrorReferenceWithCandidate(source, name, candidate, diagnostic) } @@ -552,7 +552,7 @@ class FirCallResolver( diagnostic: ConeDiagnostic ): FirErrorReferenceWithCandidate { if (!candidate.fullyAnalyzed) { - resolutionStageRunner.processCandidate(candidate, stopOnFirstError = false) + resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext, stopOnFirstError = false) } return FirErrorReferenceWithCandidate(source, candidate.callInfo.name, candidate, diagnostic) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt index ca7c766e381..fc51c314b4d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt @@ -10,7 +10,10 @@ import kotlinx.collections.immutable.persistentListOf import org.jetbrains.kotlin.fir.FirCallResolver import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.resolve.calls.* +import org.jetbrains.kotlin.fir.resolve.calls.ImplicitDispatchReceiverValue +import org.jetbrains.kotlin.fir.resolve.calls.ImplicitExtensionReceiverValue +import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionStageRunner import org.jetbrains.kotlin.fir.resolve.dfa.FirDataFlowAnalyzer import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents @@ -56,8 +59,6 @@ interface BodyResolveComponents : SessionHolder { val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater val outerClassManager: FirOuterClassManager - - val resolutionContext: ResolutionContext } typealias FirLocalScopes = PersistentList diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt index 45e251b875e..69a6588c6e4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateCollector.kt @@ -29,8 +29,8 @@ open class CandidateCollector( bestGroup = TowerGroup.Last } - open fun consumeCandidate(group: TowerGroup, candidate: Candidate): CandidateApplicability { - val applicability = resolutionStageRunner.processCandidate(candidate) + open fun consumeCandidate(group: TowerGroup, candidate: Candidate, context: ResolutionContext): CandidateApplicability { + val applicability = resolutionStageRunner.processCandidate(candidate, context) if (applicability > currentApplicability || (applicability == currentApplicability && group < bestGroup)) { candidates.clear() @@ -45,13 +45,12 @@ open class CandidateCollector( return applicability } - fun bestCandidates() = candidates + fun bestCandidates(): List = candidates - fun shouldStopAtTheLevel(group: TowerGroup) = + fun shouldStopAtTheLevel(group: TowerGroup): Boolean = isSuccess() && bestGroup < group fun isSuccess(): Boolean { return currentApplicability.isSuccess } } - diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt index 60946001071..2819944d599 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildErrorFunction import org.jetbrains.kotlin.fir.declarations.builder.buildErrorProperty import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic 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.fir.symbols.impl.FirErrorFunctionSymbol @@ -21,30 +20,30 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind class CandidateFactory private constructor( - val bodyResolveComponents: BodyResolveComponents, + val context: ResolutionContext, val callInfo: CallInfo, private val baseSystem: ConstraintStorage ) { companion object { - private fun buildBaseSystem(bodyResolveComponents: BodyResolveComponents, callInfo: CallInfo): ConstraintStorage { - val system = bodyResolveComponents.inferenceComponents.createConstraintSystem() + private fun buildBaseSystem(context: ResolutionContext, callInfo: CallInfo): ConstraintStorage { + val system = context.inferenceComponents.createConstraintSystem() callInfo.arguments.forEach { system.addSubsystemFromExpression(it) } - system.addOtherSystem(bodyResolveComponents.inferenceComponents.inferenceSession.currentConstraintSystem) + system.addOtherSystem(context.bodyResolveContext.inferenceSession.currentConstraintSystem) return system.asReadOnlyStorage() } } - constructor(bodyResolveComponents: BodyResolveComponents, callInfo: CallInfo) : - this(bodyResolveComponents, callInfo, buildBaseSystem(bodyResolveComponents, callInfo)) + constructor(context: ResolutionContext, callInfo: CallInfo) : + this(context, callInfo, buildBaseSystem(context, callInfo)) fun replaceCallInfo(callInfo: CallInfo): CandidateFactory { if (this.callInfo.arguments.size != callInfo.arguments.size) { throw AssertionError("Incorrect replacement of call info in CandidateFactory") } - return CandidateFactory(bodyResolveComponents, callInfo, baseSystem) + return CandidateFactory(context, callInfo, baseSystem) } fun createCandidate( @@ -56,7 +55,7 @@ class CandidateFactory private constructor( ): Candidate { return Candidate( symbol, dispatchReceiverValue, implicitExtensionReceiverValue, - explicitReceiverKind, bodyResolveComponents.inferenceComponents.constraintSystemFactory, baseSystem, + explicitReceiverKind, context.inferenceComponents.constraintSystemFactory, baseSystem, builtInExtensionFunctionReceiverValue?.receiverExpression?.let { callInfo.withReceiverAsArgument(it) } ?: callInfo @@ -78,7 +77,7 @@ class CandidateFactory private constructor( dispatchReceiverValue = null, implicitExtensionReceiverValue = null, explicitReceiverKind = ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, - bodyResolveComponents.inferenceComponents.constraintSystemFactory, + context.inferenceComponents.constraintSystemFactory, baseSystem, callInfo ) @@ -87,7 +86,7 @@ class CandidateFactory private constructor( private fun createErrorFunctionSymbol(diagnostic: ConeDiagnostic): FirErrorFunctionSymbol { return FirErrorFunctionSymbol().also { buildErrorFunction { - session = this@CandidateFactory.bodyResolveComponents.session + session = context.session resolvePhase = FirResolvePhase.BODY_RESOLVE origin = FirDeclarationOrigin.Synthetic this.diagnostic = diagnostic @@ -99,7 +98,7 @@ class CandidateFactory private constructor( private fun createErrorPropertySymbol(diagnostic: ConeDiagnostic): FirErrorPropertySymbol { return FirErrorPropertySymbol(diagnostic).also { buildErrorProperty { - session = this@CandidateFactory.bodyResolveComponents.session + session = context.session resolvePhase = FirResolvePhase.BODY_RESOLVE origin = FirDeclarationOrigin.Synthetic name = FirErrorPropertySymbol.NAME diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStageRunner.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStageRunner.kt index 5994e768137..cd60d63f7a4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStageRunner.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStageRunner.kt @@ -13,8 +13,8 @@ import kotlin.coroutines.EmptyCoroutineContext import kotlin.coroutines.intrinsics.createCoroutineUnintercepted import kotlin.coroutines.resume -class ResolutionStageRunner(private val context: ResolutionContext) { - fun processCandidate(candidate: Candidate, stopOnFirstError: Boolean = true): CandidateApplicability { +class ResolutionStageRunner { + fun processCandidate(candidate: Candidate, context: ResolutionContext, stopOnFirstError: Boolean = true): CandidateApplicability { val sink = CheckerSinkImpl(stopOnFirstError = stopOnFirstError) var finished = false sink.continuation = suspend { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt index 9b08026ef74..60c5000e21c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.inference.* import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.SyntheticSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -32,7 +33,8 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.* data class ResolutionContext( val session: FirSession, - val bodyResolveComponents: BodyResolveComponents + val bodyResolveComponents: BodyResolveComponents, + val bodyResolveContext: BodyResolveContext ) { val inferenceComponents: InferenceComponents get() = bodyResolveComponents.inferenceComponents diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt index 07d5af371b0..e264c6b916b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessExpressionBuilder import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.calls.* -import org.jetbrains.kotlin.fir.resolve.calls.ExpressionReceiverValue import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol @@ -24,10 +23,12 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.util.OperatorNameConventions internal class FirInvokeResolveTowerExtension( - private val components: BodyResolveComponents, + private val context: ResolutionContext, private val manager: TowerResolveManager, private val candidateFactoriesAndCollectors: CandidateFactoriesAndCollectors ) { + private val components: BodyResolveComponents + get() = context.bodyResolveComponents fun enqueueResolveTasksForQualifier(info: CallInfo, receiver: FirResolvedQualifier) { if (info.callKind != CallKind.Function) return @@ -108,7 +109,7 @@ internal class FirInvokeResolveTowerExtension( manager, towerDataElementsForName, collector, - CandidateFactory(components, invokeReceiverInfo), + CandidateFactory(context, invokeReceiverInfo), onSuccessfulLevel = { towerGroup -> enqueueResolverTasksForInvokeReceiverCandidates( invokeBuiltinExtensionMode, info, @@ -182,7 +183,7 @@ internal class FirInvokeResolveTowerExtension( useImplicitReceiverAsBuiltinInvokeArgument: Boolean, receiverGroup: TowerGroup ) { - val invokeOnGivenReceiverCandidateFactory = CandidateFactory(components, invokeFunctionInfo) + val invokeOnGivenReceiverCandidateFactory = CandidateFactory(context, invokeFunctionInfo) val task = InvokeFunctionResolveTask( components, manager, @@ -385,4 +386,4 @@ private class InvokeFunctionResolveTask( group.InvokeResolvePriority(InvokeResolvePriority.COMMON_INVOKE), explicitReceiverKind ) -} \ No newline at end of file +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt index 074f2443d2a..4b63129157c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt @@ -25,24 +25,25 @@ class FirTowerResolver( fun runResolver( info: CallInfo, + context: ResolutionContext, collector: CandidateCollector = this.collector, manager: TowerResolveManager = this.manager ): CandidateCollector { - val candidateFactoriesAndCollectors = buildCandidateFactoriesAndCollectors(info, collector) + val candidateFactoriesAndCollectors = buildCandidateFactoriesAndCollectors(info, collector, context) - enqueueResolutionTasks(components, manager, candidateFactoriesAndCollectors, info) + enqueueResolutionTasks(context, manager, candidateFactoriesAndCollectors, info) manager.runTasks() return collector } private fun enqueueResolutionTasks( - components: BodyResolveComponents, + context: ResolutionContext, manager: TowerResolveManager, candidateFactoriesAndCollectors: CandidateFactoriesAndCollectors, info: CallInfo ) { - val invokeResolveTowerExtension = FirInvokeResolveTowerExtension(components, manager, candidateFactoriesAndCollectors) + val invokeResolveTowerExtension = FirInvokeResolveTowerExtension(context, manager, candidateFactoriesAndCollectors) val mainTask = FirTowerResolveTask( components, @@ -77,7 +78,8 @@ class FirTowerResolver( fun runResolverForDelegatingConstructor( info: CallInfo, - constructedType: ConeClassLikeType + constructedType: ConeClassLikeType, + context: ResolutionContext ): CandidateCollector { val outerType = components.outerClassManager.outerType(constructedType) val scope = constructedType.scope(components.session, components.scopeSession) ?: return collector @@ -90,7 +92,7 @@ class FirTowerResolver( else null - val candidateFactory = CandidateFactory(components, info) + val candidateFactory = CandidateFactory(context, info) val resultCollector = collector scope.processDeclaredConstructors { @@ -102,7 +104,8 @@ class FirTowerResolver( dispatchReceiver, implicitExtensionReceiverValue = null, builtInExtensionFunctionReceiverValue = null - ) + ), + context ) } @@ -111,9 +114,10 @@ class FirTowerResolver( private fun buildCandidateFactoriesAndCollectors( info: CallInfo, - collector: CandidateCollector + collector: CandidateCollector, + context: ResolutionContext ): CandidateFactoriesAndCollectors { - val candidateFactory = CandidateFactory(components, info) + val candidateFactory = CandidateFactory(context, info) val stubReceiverCandidateFactory = if (info.callKind == CallKind.CallableReference && info.stubReceiver != null) candidateFactory.replaceCallInfo(info.replaceExplicitReceiver(info.stubReceiver)) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt index 0213dafae42..f9c45c36064 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt @@ -160,7 +160,7 @@ private class TowerScopeLevelProcessor( val declarationReceiverType = (symbol as? FirCallableSymbol<*>)?.fir?.receiverTypeRef?.coneType if (declarationReceiverType is ConeClassLikeType) { if (!AbstractTypeChecker.isSubtypeOf( - candidateFactory.bodyResolveComponents.inferenceComponents.ctx, + candidateFactory.context.inferenceComponents.ctx, extensionReceiverType, declarationReceiverType.lookupTag.constructClassType( declarationReceiverType.typeArguments.map { ConeStarProjection }.toTypedArray(), @@ -181,7 +181,7 @@ private class TowerScopeLevelProcessor( dispatchReceiverValue, implicitExtensionReceiverValue, builtInExtensionFunctionReceiverValue - ) + ), candidateFactory.context ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/AbstractManyCandidatesInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/AbstractManyCandidatesInferenceSession.kt index 9bce9eb59b6..04e63d3b64f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/AbstractManyCandidatesInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/AbstractManyCandidatesInferenceSession.kt @@ -9,16 +9,20 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvable import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.Candidate +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.calls.candidate import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage abstract class AbstractManyCandidatesInferenceSession( - protected val components: BodyResolveComponents + protected val resolutionContext: ResolutionContext ) : FirInferenceSession() { private val errorCalls: MutableList = mutableListOf() protected val partiallyResolvedCalls: MutableList> = mutableListOf() private val completedCalls: MutableSet = mutableSetOf() + protected val components: BodyResolveComponents + get() = resolutionContext.bodyResolveComponents + override val currentConstraintSystem: ConstraintStorage get() = partiallyResolvedCalls.lastOrNull() ?.second @@ -44,4 +48,4 @@ abstract class AbstractManyCandidatesInferenceSession( protected val FirResolvable.candidate: Candidate get() = candidate()!! -} \ No newline at end of file +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt index 4f4f218b96e..9489f92307d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.inference.model.ConeFixVariableConstraintPosition import org.jetbrains.kotlin.fir.returnExpressions import org.jetbrains.kotlin.fir.types.* @@ -36,6 +37,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) { completionMode: ConstraintSystemCompletionMode, topLevelAtoms: List, candidateReturnType: ConeKotlinType, + context: ResolutionContext, collectVariablesFromContext: Boolean = false, analyze: (PostponedResolvedAtom) -> Unit ) { @@ -52,7 +54,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) { if ( completionMode == ConstraintSystemCompletionMode.FULL && - resolveLambdaOrCallableReferenceWithTypeVariableAsExpectedType(c, variableForFixation, postponedAtoms, analyze) + resolveLambdaOrCallableReferenceWithTypeVariableAsExpectedType(c, variableForFixation, postponedAtoms, context, analyze) ) { continue } @@ -81,6 +83,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) { c: ConstraintSystemCompletionContext, variableForFixation: VariableFixationFinder.VariableForFixation, postponedAtoms: List, + context: ResolutionContext, analyze: (PostponedResolvedAtom) -> Unit ): Boolean { val variable = variableForFixation.variable as ConeTypeVariableTypeConstructor @@ -110,7 +113,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) { isSuitable = { isBuiltinFunctionalType(components.session) }, typeVariableCreator = { ConeTypeVariableForLambdaReturnType(postponedAtom.atom, "_R") }, newAtomCreator = { returnTypeVariable, expectedType -> - postponedAtom.transformToResolvedLambda(csBuilder, components.resolutionContext, expectedType, returnTypeVariable) + postponedAtom.transformToResolvedLambda(csBuilder, context, expectedType, returnTypeVariable) } ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt index 68f5724b965..722b51db17f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt @@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.resolve.inference import org.jetbrains.kotlin.fir.expressions.FirResolvable import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.Candidate +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeStubType @@ -24,9 +24,9 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImp import org.jetbrains.kotlin.types.model.TypeConstructorMarker class FirBuilderInferenceSession( - components: BodyResolveComponents, + resolutionContext: ResolutionContext, private val stubsForPostponedVariables: Map, -) : AbstractManyCandidatesInferenceSession(components) { +) : AbstractManyCandidatesInferenceSession(resolutionContext) { private val commonCalls: MutableList> = mutableListOf() override fun shouldRunCompletion(call: T): Boolean where T : FirResolvable, T : FirStatement { @@ -96,7 +96,7 @@ class FirBuilderInferenceSession( context, ConstraintSystemCompletionMode.FULL, partiallyResolvedCalls.map { it.first as FirStatement }, - components.session.builtinTypes.unitType.type, + components.session.builtinTypes.unitType.type, resolutionContext, collectVariablesFromContext = true ) { error("Shouldn't be called in complete constraint system mode") diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt index 3e19bb2dc1c..2813da99b83 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer @@ -41,7 +42,7 @@ class FirCallCompleter( ) : BodyResolveComponents by components { val completer = ConstraintSystemCompleter(components) private val inferenceSession - get() = inferenceComponents.inferenceSession + get() = transformer.context.inferenceSession data class CompletionResult(val result: T, val callCompleted: Boolean) @@ -65,13 +66,13 @@ class FirCallCompleter( val completionMode = candidate.computeCompletionMode(inferenceComponents, expectedTypeRef, initialType) - val analyzer = createPostponedArgumentsAnalyzer() + val analyzer = createPostponedArgumentsAnalyzer(transformer.resolutionContext) call.transformSingle(InvocationKindTransformer, null) return when (completionMode) { ConstraintSystemCompletionMode.FULL -> { if (inferenceSession.shouldRunCompletion(call)) { - completer.complete(candidate.system.asConstraintSystemCompleterContext(), completionMode, listOf(call), initialType) { + completer.complete(candidate.system.asConstraintSystemCompleterContext(), completionMode, listOf(call), initialType, transformer.resolutionContext) { analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it, candidate) } val finalSubstitutor = @@ -94,7 +95,13 @@ class FirCallCompleter( } ConstraintSystemCompletionMode.PARTIAL -> { - completer.complete(candidate.system.asConstraintSystemCompleterContext(), completionMode, listOf(call), initialType) { + completer.complete( + candidate.system.asConstraintSystemCompleterContext(), + completionMode, + listOf(call), + initialType, + transformer.resolutionContext + ) { analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it, candidate) } val approximatedCall = call.transformSingle(integerOperatorsTypeUpdater, null) @@ -119,10 +126,10 @@ class FirCallCompleter( ) } - fun createPostponedArgumentsAnalyzer(): PostponedArgumentsAnalyzer { + fun createPostponedArgumentsAnalyzer(context: ResolutionContext): PostponedArgumentsAnalyzer { val lambdaAnalyzer = LambdaAnalyzerImpl() return PostponedArgumentsAnalyzer( - resolutionContext, + context, lambdaAnalyzer, inferenceComponents, transformer.components.callResolver @@ -179,7 +186,7 @@ class FirCallCompleter( val builderInferenceSession = runIf(stubsForPostponedVariables.isNotEmpty()) { @Suppress("UNCHECKED_CAST") - FirBuilderInferenceSession(components, stubsForPostponedVariables as Map) + FirBuilderInferenceSession(transformer.resolutionContext, stubsForPostponedVariables as Map) } val localContext = towerDataContextForAnonymousFunctions.get(lambdaArgument.symbol) ?: error( @@ -187,7 +194,7 @@ class FirCallCompleter( ) transformer.context.withTowerDataContext(localContext) { if (builderInferenceSession != null) { - components.inferenceComponents.withInferenceSession(builderInferenceSession) { + transformer.context.withInferenceSession(builderInferenceSession) { lambdaArgument.transformSingle(transformer, ResolutionMode.LambdaResolution(expectedReturnTypeRef)) } } else { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt index b075197b654..eb7e1d07766 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirDelegatedPropertyInferenceSession.kt @@ -13,13 +13,16 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirResolvable import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.references.FirNamedReference -import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.ConeTypeVariableTypeConstructor +import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder import org.jetbrains.kotlin.resolve.calls.inference.NewConstraintSystem import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor @@ -32,9 +35,9 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs class FirDelegatedPropertyInferenceSession( val property: FirProperty, initialCall: FirExpression, - components: BodyResolveComponents, + resolutionContext: ResolutionContext, private val postponedArgumentsAnalyzer: PostponedArgumentsAnalyzer, -) : AbstractManyCandidatesInferenceSession(components) { +) : AbstractManyCandidatesInferenceSession(resolutionContext) { init { val initialCandidate = (initialCall as? FirResolvable) ?.calleeReference @@ -65,13 +68,13 @@ class FirDelegatedPropertyInferenceSession( addOtherSystem(currentConstraintSystem) } prepareForCompletion(commonSystem, resolvedCalls) - components.inferenceComponents.withInferenceSession(DEFAULT) { + resolutionContext.bodyResolveContext.withInferenceSession(DEFAULT) { @Suppress("UNCHECKED_CAST") components.callCompleter.completer.complete( commonSystem.asConstraintSystemCompleterContext(), ConstraintSystemCompletionMode.FULL, resolvedCalls as List, - unitType + unitType, resolutionContext ) { postponedArgumentsAnalyzer.analyze( commonSystem.asPostponedArgumentsAnalyzerContext(), diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt index 96c169fce0e..351859a9750 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt @@ -6,10 +6,8 @@ package org.jetbrains.kotlin.fir.resolve.inference import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.PrivateForInline -import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.types.ConeInferenceContext +import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintIncorporator import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintInjector import org.jetbrains.kotlin.resolve.calls.inference.components.ResultTypeResolver @@ -17,32 +15,15 @@ import org.jetbrains.kotlin.resolve.calls.inference.components.TrivialConstraint import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl import org.jetbrains.kotlin.types.AbstractTypeApproximator -class InferenceComponents( - val ctx: ConeInferenceContext, - val session: FirSession, - val returnTypeCalculator: ReturnTypeCalculator, - val scopeSession: ScopeSession -) { +class InferenceComponents(val session: FirSession) { + val ctx: ConeInferenceContext = ConeTypeCheckerContext(isErrorTypeEqualsToAnything = false, isStubTypeEqualsToAnything = false, session) + val approximator: AbstractTypeApproximator = object : AbstractTypeApproximator(ctx) {} val trivialConstraintTypeInferenceOracle = TrivialConstraintTypeInferenceOracle.create(ctx) private val incorporator = ConstraintIncorporator(approximator, trivialConstraintTypeInferenceOracle, ConeConstraintSystemUtilContext) private val injector = ConstraintInjector(incorporator, approximator) val resultTypeResolver = ResultTypeResolver(approximator, trivialConstraintTypeInferenceOracle) - @set:PrivateForInline - var inferenceSession: FirInferenceSession = FirInferenceSession.DEFAULT - - @OptIn(PrivateForInline::class) - inline fun withInferenceSession(inferenceSession: FirInferenceSession, block: () -> R): R { - val oldSession = this.inferenceSession - this.inferenceSession = inferenceSession - return try { - block() - } finally { - this.inferenceSession = oldSession - } - } - val constraintSystemFactory = ConstraintSystemFactory() fun createConstraintSystem(): NewConstraintSystemImpl { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index 620c5258744..4030082da15 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt @@ -51,7 +51,7 @@ class FirSyntheticCallGenerator( private val checkNotNullFunction: FirSimpleFunction = generateSyntheticCheckNotNullFunction() private val elvisFunction: FirSimpleFunction = generateSyntheticElvisFunction() - fun generateCalleeForWhenExpression(whenExpression: FirWhenExpression): FirWhenExpression? { + fun generateCalleeForWhenExpression(whenExpression: FirWhenExpression, context: ResolutionContext): FirWhenExpression? { val stubReference = whenExpression.calleeReference // TODO: Investigate: assertion failed in ModularizedTest // assert(stubReference is FirStubReference) @@ -63,13 +63,14 @@ class FirSyntheticCallGenerator( val reference = generateCalleeReferenceWithCandidate( whenSelectFunction, argumentList, - SyntheticCallableId.WHEN.callableName + SyntheticCallableId.WHEN.callableName, + context = context ) ?: return null // TODO return whenExpression.transformCalleeReference(UpdateReference, reference) } - fun generateCalleeForTryExpression(tryExpression: FirTryExpression): FirTryExpression? { + fun generateCalleeForTryExpression(tryExpression: FirTryExpression, context: ResolutionContext): FirTryExpression? { val stubReference = tryExpression.calleeReference assert(stubReference is FirStubReference) @@ -85,26 +86,28 @@ class FirSyntheticCallGenerator( val reference = generateCalleeReferenceWithCandidate( trySelectFunction, argumentList, - SyntheticCallableId.TRY.callableName + SyntheticCallableId.TRY.callableName, + context = context ) ?: return null // TODO return tryExpression.transformCalleeReference(UpdateReference, reference) } - fun generateCalleeForCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall): FirCheckNotNullCall? { + fun generateCalleeForCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, context: ResolutionContext): FirCheckNotNullCall? { val stubReference = checkNotNullCall.calleeReference if (stubReference !is FirStubReference) return null val reference = generateCalleeReferenceWithCandidate( checkNotNullFunction, checkNotNullCall.argumentList, - SyntheticCallableId.CHECK_NOT_NULL.callableName + SyntheticCallableId.CHECK_NOT_NULL.callableName, + context = context ) ?: return null // TODO return checkNotNullCall.transformCalleeReference(UpdateReference, reference) } - fun generateCalleeForElvisExpression(elvisExpression: FirElvisExpression): FirElvisExpression? { + fun generateCalleeForElvisExpression(elvisExpression: FirElvisExpression, context: ResolutionContext): FirElvisExpression? { if (elvisExpression.calleeReference !is FirStubReference) return null val argumentList = buildArgumentList { @@ -114,7 +117,8 @@ class FirSyntheticCallGenerator( val reference = generateCalleeReferenceWithCandidate( elvisFunction, argumentList, - SyntheticCallableId.ELVIS_NOT_NULL.callableName + SyntheticCallableId.ELVIS_NOT_NULL.callableName, + context = context ) ?: return null return elvisExpression.transformCalleeReference(UpdateReference, reference) @@ -122,13 +126,18 @@ class FirSyntheticCallGenerator( fun resolveCallableReferenceWithSyntheticOuterCall( callableReferenceAccess: FirCallableReferenceAccess, - expectedTypeRef: FirTypeRef? + expectedTypeRef: FirTypeRef?, + context: ResolutionContext ): FirCallableReferenceAccess? { val argumentList = buildUnaryArgumentList(callableReferenceAccess) val reference = generateCalleeReferenceWithCandidate( - idFunction, argumentList, SyntheticCallableId.ID.callableName, CallKind.SyntheticIdForCallableReferencesResolution + idFunction, + argumentList, + SyntheticCallableId.ID.callableName, + CallKind.SyntheticIdForCallableReferencesResolution, + context ) ?: return callableReferenceAccess.transformCalleeReference( StoreCalleeReference, buildErrorNamedReference { @@ -149,11 +158,12 @@ class FirSyntheticCallGenerator( function: FirSimpleFunction, argumentList: FirArgumentList, name: Name, - callKind: CallKind = CallKind.SyntheticSelect + callKind: CallKind = CallKind.SyntheticSelect, + context: ResolutionContext ): FirNamedReferenceWithCandidate? { val callInfo = generateCallInfo(name, argumentList, callKind) - val candidate = generateCandidate(callInfo, function) - val applicability = resolutionStageRunner.processCandidate(candidate) + val candidate = generateCandidate(callInfo, function, context) + val applicability = resolutionStageRunner.processCandidate(candidate, context) if (applicability <= CandidateApplicability.INAPPLICABLE) { return null } @@ -161,8 +171,8 @@ class FirSyntheticCallGenerator( return FirNamedReferenceWithCandidate(null, name, candidate) } - private fun generateCandidate(callInfo: CallInfo, function: FirSimpleFunction): Candidate = - CandidateFactory(components, callInfo).createCandidate( + private fun generateCandidate(callInfo: CallInfo, function: FirSimpleFunction, context: ResolutionContext): Candidate = + CandidateFactory(context, callInfo).createCandidate( symbol = function.symbol, explicitReceiverKind = ExplicitReceiverKind.NO_EXPLICIT_RECEIVER ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt index 7eda23053d5..6e39b8d45ad 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStack import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowAnalyzerContext import org.jetbrains.kotlin.fir.resolve.dfa.PersistentFlow +import org.jetbrains.kotlin.fir.resolve.inference.FirInferenceSession import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope @@ -52,6 +53,20 @@ class BodyResolveContext( val towerDataContextForAnonymousFunctions: MutableMap = mutableMapOf() + @set:PrivateForInline + var inferenceSession: FirInferenceSession = FirInferenceSession.DEFAULT + + @OptIn(PrivateForInline::class) + inline fun withInferenceSession(inferenceSession: FirInferenceSession, block: () -> R): R { + val oldSession = this.inferenceSession + this.inferenceSession = inferenceSession + return try { + block() + } finally { + this.inferenceSession = oldSession + } + } + @OptIn(PrivateForInline::class) inline fun withNewTowerDataForClassParts(newContexts: FirTowerDataContextsForClassParts, f: () -> T): T { val old = towerDataContextsForClassParts diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt index 018d630a193..2b60aa92d6d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt @@ -11,13 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.builder.buildVarargArgumentsExpression -import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.renderWithType import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.arrayElementType @@ -43,7 +43,7 @@ internal fun inferenceComponents( scopeSession: ScopeSession ): InferenceComponents { val inferenceContext = session.typeContext - return InferenceComponents(inferenceContext, session, returnTypeCalculator, scopeSession) + return InferenceComponents(session) } internal fun remapArgumentsWithVararg( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt index a792ceb1009..62afda3376d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt @@ -5,8 +5,13 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve -import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.FirCallResolver +import org.jetbrains.kotlin.fir.FirQualifiedNameResolver +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.PrivateForInline +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.calls.ResolutionStageRunner @@ -23,6 +28,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer(phase) { abstract val context: BodyResolveContext abstract val components: BodyResolveTransformerComponents + abstract val resolutionContext: ResolutionContext @set:PrivateForInline abstract var implicitTypeOnly: Boolean @@ -93,8 +99,6 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb val transformer: FirBodyResolveTransformer, val context: BodyResolveContext ) : BodyResolveComponents { - override val resolutionContext: ResolutionContext = ResolutionContext(session, this@BodyResolveTransformerComponents) - override val fileImportsScope: List get() = context.fileImportsScope override val towerDataElements: List get() = context.towerDataContext.towerDataElements override val localScopes: FirLocalScopes get() = context.towerDataContext.localScopes @@ -112,7 +116,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb override val symbolProvider: FirSymbolProvider = session.firSymbolProvider override val inferenceComponents: InferenceComponents = inferenceComponents(session, returnTypeCalculator, scopeSession) - override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner(resolutionContext) + override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner() override val samResolver: FirSamResolver = FirSamResolverImpl(session, scopeSession) private val qualifiedResolver: FirQualifiedNameResolver = FirQualifiedNameResolver(this) override val callResolver: FirCallResolver = FirCallResolver( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index 266e07b2d78..7a2e1ac300a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.asTowerDataElement +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowAnalyzerContext import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve @@ -41,6 +42,8 @@ open class FirBodyResolveTransformer( final override val components: BodyResolveTransformerComponents = BodyResolveTransformerComponents(session, scopeSession, this, context) + final override val resolutionContext: ResolutionContext = ResolutionContext(session, components, context) + internal open val expressionsTransformer = FirExpressionsResolveTransformer(this) protected open val declarationsTransformer = FirDeclarationsResolveTransformer(this) private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index fb1cd0eb55c..7e37098280f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt @@ -79,7 +79,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran else -> { whenExpression = whenExpression.transformBranches(transformer, ResolutionMode.ContextDependent) - whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression) ?: run { + whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression, resolutionContext) ?: run { whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null) dataFlowAnalyzer.exitWhenExpression(whenExpression) whenExpression.resultType = buildErrorTypeRef { @@ -149,7 +149,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran var callCompleted = false @Suppress("NAME_SHADOWING") - var result = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression)?.let { + var result = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression, resolutionContext)?.let { val expectedTypeRef = data.expectedType val completionResult = callCompleter.completeCall(it, expectedTypeRef) callCompleted = completionResult.callCompleted @@ -218,7 +218,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran dataFlowAnalyzer.exitElvisLhs(elvisExpression) elvisExpression.transformRhs(transformer, ResolutionMode.ContextDependent) - val result = syntheticCallGenerator.generateCalleeForElvisExpression(elvisExpression)?.let { + val result = syntheticCallGenerator.generateCalleeForElvisExpression(elvisExpression, resolutionContext)?.let { callCompleter.completeCall(it, data.expectedType).result } ?: elvisExpression.also { it.resultType = buildErrorTypeRef { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 7028e1ef2c4..3cb8befe0ac 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -214,11 +214,11 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor val inferenceSession = FirDelegatedPropertyInferenceSession( property, delegateExpression, - components, - callCompleter.createPostponedArgumentsAnalyzer() + resolutionContext, + callCompleter.createPostponedArgumentsAnalyzer(resolutionContext) ) - components.inferenceComponents.withInferenceSession(inferenceSession) { + context.withInferenceSession(inferenceSession) { property.transformAccessors() val completedCalls = inferenceSession.completeCandidates() val finalSubstitutor = inferenceSession.createFinalSubstitutor() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index b9389dceab8..1e0a9a272c1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -456,7 +456,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform private inline fun resolveCandidateForAssignmentOperatorCall(block: () -> T): T { return dataFlowAnalyzer.withIgnoreFunctionCalls { callResolver.withNoArgumentsTransform { - inferenceComponents.withInferenceSession(InferenceSessionForAssignmentOperatorCall) { + context.withInferenceSession(InferenceSessionForAssignmentOperatorCall) { block() } } @@ -546,7 +546,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform checkNotNullCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent) var callCompleted = false - val result = components.syntheticCallGenerator.generateCalleeForCheckNotNullCall(checkNotNullCall)?.let { + val result = components.syntheticCallGenerator.generateCalleeForCheckNotNullCall(checkNotNullCall, resolutionContext)?.let { val completionResult = callCompleter.completeCall(it, data.expectedType) callCompleted = completionResult.callCompleted completionResult.result @@ -629,7 +629,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform if (data !is ResolutionMode.ContextDependent) { val resolvedReference = components.syntheticCallGenerator.resolveCallableReferenceWithSyntheticOuterCall( - callableReferenceAccess, data.expectedType, + callableReferenceAccess, data.expectedType, resolutionContext, ) ?: callableReferenceAccess return resolvedReference.compose() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt index f80d07eecac..b37b2ececc0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.resolve.ResolutionMode +import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult abstract class FirPartialBodyResolveTransformer( @@ -21,6 +22,10 @@ abstract class FirPartialBodyResolveTransformer( final override inline val components: BodyResolveTransformerComponents get() = transformer.components + @Suppress("OVERRIDE_BY_INLINE") + final override inline val resolutionContext: ResolutionContext + get() = transformer.resolutionContext + @set:PrivateForInline override var implicitTypeOnly: Boolean get() = transformer.implicitTypeOnly diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/resolver/SingleCandidateResolver.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/resolver/SingleCandidateResolver.kt index 0f8729df000..216b3f9ef9b 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/resolver/SingleCandidateResolver.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/resolver/SingleCandidateResolver.kt @@ -47,7 +47,7 @@ class SingleCandidateResolver( stubBodyResolveTransformer, bodyResolveComponents, ) - private val resolutionStageRunner = ResolutionStageRunner(ResolutionContext(firSession, bodyResolveComponents)) + private val resolutionStageRunner = ResolutionStageRunner() fun resolveSingleCandidate( resolutionParameters: ResolutionParameters @@ -62,14 +62,16 @@ class SingleCandidateResolver( val dispatchReceiverValue = infoProvider.dispatchReceiverValue() val implicitExtensionReceiverValue = infoProvider.implicitExtensionReceiverValue() - val candidate = CandidateFactory(bodyResolveComponents, callInfo).createCandidate( + val resolutionContext = stubBodyResolveTransformer.resolutionContext + + val candidate = CandidateFactory(resolutionContext, callInfo).createCandidate( resolutionParameters.callableSymbol, explicitReceiverKind = explicitReceiverKind, dispatchReceiverValue = dispatchReceiverValue, implicitExtensionReceiverValue = implicitExtensionReceiverValue, ) - val applicability = resolutionStageRunner.processCandidate(candidate, stopOnFirstError = true) + val applicability = resolutionStageRunner.processCandidate(candidate, resolutionContext, stopOnFirstError = true) if (applicability.isSuccess) { return completeResolvedCandidate(candidate, resolutionParameters) }