From 80b698ce32b4d25bb068580c9400d4d55c6c5b9c Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Sat, 17 Feb 2024 23:18:42 +0100 Subject: [PATCH] [FIR] drop obsolete FirResolveContextCollector This interface is unused --- .../level/api/fir/api/targets/targetUtils.kt | 2 +- .../fir/PersistentCheckerContextFactory.kt | 3 +- .../LLFirModuleLazyDeclarationResolver.kt | 6 - .../LLFirAbstractBodyTargetResolver.kt | 6 +- .../LLFirAnnotationArgumentsLazyResolver.kt | 8 +- .../fir/transformers/LLFirBodyLazyResolver.kt | 8 +- .../LLFirCompilerAnnotationsLazyResolver.kt | 2 - .../LLFirContractsLazyResolver.kt | 107 +----------------- .../LLFirExpectActualMatcherLazyResolver.kt | 2 - ...FirGeneratedCompanionObjectLazyResolver.kt | 2 - .../LLFirImplicitTypesLazyResolver.kt | 8 +- .../api/fir/transformers/LLFirLazyResolver.kt | 5 +- .../transformers/LLFirLazyResolverRunner.kt | 6 +- .../LLFirReturnTypeCalculatorWithJump.kt | 3 - .../LLFirSealedClassInheritorsLazyResolver.kt | 2 - .../transformers/LLFirStatusLazyResolver.kt | 2 - .../LLFirSupertypeLazyResolver.kt | 2 - .../fir/transformers/LLFirTypeLazyResolver.kt | 2 - ...bstractBodyResolveTransformerDispatcher.kt | 3 +- .../body/resolve/FirBodyResolveTransformer.kt | 4 +- .../FirDeclarationsResolveTransformer.kt | 13 +-- .../FirExpressionsResolveTransformer.kt | 9 +- .../body/resolve/FirImplicitBodyResolve.kt | 6 +- .../resolve/FirResolveContextCollector.kt | 38 ------- .../body/resolve/LocalClassesResolution.kt | 4 +- ...actContractResolveTransformerDispatcher.kt | 5 +- .../FirContractResolveTransformer.kt | 4 +- .../FirAnnotationArgumentsTransformer.kt | 4 +- 28 files changed, 27 insertions(+), 239 deletions(-) delete mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirResolveContextCollector.kt diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt index 2699b4b6449..2bb20985e66 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt @@ -25,7 +25,7 @@ internal fun LLFirResolveTarget.resolve(phase: FirResolvePhase) { } val lazyDeclarationResolver = session.moduleComponents.firModuleLazyDeclarationResolver - lazyDeclarationResolver.lazyResolveTarget(this, phase, towerDataContextCollector = null) + lazyDeclarationResolver.lazyResolveTarget(this, phase) } internal val LLFirResolveTarget.session: LLFirSession get() = target.llFirSession diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt index 978f48c5434..be54cc33ea6 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -17,7 +17,6 @@ internal object PersistentCheckerContextFactory { scopeSession = sessionHolder.scopeSession, implicitBodyResolveComputationSession = LLImplicitBodyResolveComputationSession(), lockProvider = LLFirGlobalResolveComponents.getInstance(sessionHolder.session).lockProvider, - towerDataContextCollector = null, ) return PersistentCheckerContext(sessionHolder, returnTypeCalculator) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt index 773d67fb557..cd880c9e409 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.utils.exceptions.rethrowExceptionWithDetails @@ -84,7 +83,6 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod target, scopeSession, toPhase, - towerDataContextCollector = null, ) } catch (e: Exception) { handleExceptionFromResolve(e, targetElement, fromPhase, toPhase) @@ -102,7 +100,6 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod fun lazyResolveTarget( target: LLFirResolveTarget, toPhase: FirResolvePhase, - towerDataContextCollector: FirResolveContextCollector?, ) { try { target.firFile?.let(::resolveFileToImportsWithLock) @@ -112,7 +109,6 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod target, moduleComponents.scopeSessionProvider.getScopeSession(), toPhase, - towerDataContextCollector, ) } catch (e: Exception) { handleExceptionFromResolve(e, target, toPhase) @@ -135,7 +131,6 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod target: LLFirResolveTarget, scopeSession: ScopeSession, toPhase: FirResolvePhase, - towerDataContextCollector: FirResolveContextCollector?, ) { var currentPhase = getMinResolvePhase(target).coerceAtLeast(FirResolvePhase.IMPORTS) if (currentPhase >= toPhase) return @@ -154,7 +149,6 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod target, scopeSession, lockProvider, - towerDataContextCollector, ) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt index 68b8351b878..41110bb6342 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformerDispatcher -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.visitors.transformSingle internal abstract class LLFirAbstractBodyTargetResolver( @@ -26,13 +25,10 @@ internal abstract class LLFirAbstractBodyTargetResolver( protected val llImplicitBodyResolveComputationSession: LLImplicitBodyResolveComputationSession = LLImplicitBodyResolveComputationSession(), isJumpingPhase: Boolean = false, ) : LLFirTargetResolver(resolveTarget, lockProvider, resolvePhase, isJumpingPhase) { - protected fun createReturnTypeCalculator( - firResolveContextCollector: FirResolveContextCollector?, - ): LLFirReturnTypeCalculatorWithJump = LLFirReturnTypeCalculatorWithJump( + protected fun createReturnTypeCalculator(): LLFirReturnTypeCalculatorWithJump = LLFirReturnTypeCalculatorWithJump( scopeSession, llImplicitBodyResolveComputationSession, lockProvider, - firResolveContextCollector, ) abstract val transformer: FirAbstractBodyResolveTransformerDispatcher diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt index c9a5c3e82c8..b6a0e0cbf85 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.isError import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumentsTransformer import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -35,8 +34,7 @@ internal object LLFirAnnotationArgumentsLazyResolver : LLFirLazyResolver(FirReso target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, - ): LLFirTargetResolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) + ): LLFirTargetResolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target !is FirAnnotationContainer) return @@ -79,7 +77,6 @@ private class LLFirAnnotationArgumentsTargetResolver( resolveTarget: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - firResolveContextCollector: FirResolveContextCollector?, ) : LLFirAbstractBodyTargetResolver( resolveTarget, lockProvider, @@ -102,8 +99,7 @@ private class LLFirAnnotationArgumentsTargetResolver( resolveTargetSession, scopeSession, resolverPhase, - returnTypeCalculator = createReturnTypeCalculator(firResolveContextCollector = firResolveContextCollector), - firResolveContextCollector = firResolveContextCollector, + returnTypeCalculator = createReturnTypeCalculator(), ) override fun doResolveWithoutLock(target: FirElementWithResolveState): Boolean { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt index fa962c93eea..c7343712dc7 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt @@ -37,7 +37,6 @@ import org.jetbrains.kotlin.fir.resolve.dfa.cfg.isUsedInControlFlowGraphBuilderF import org.jetbrains.kotlin.fir.resolve.dfa.cfg.isUsedInControlFlowGraphBuilderForFile import org.jetbrains.kotlin.fir.resolve.dfa.cfg.isUsedInControlFlowGraphBuilderForScript import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractsDslNames import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase @@ -56,8 +55,7 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, - ): LLFirTargetResolver = LLFirBodyTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) + ): LLFirTargetResolver = LLFirBodyTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { when (target) { @@ -76,7 +74,6 @@ private class LLFirBodyTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - firResolveContextCollector: FirResolveContextCollector?, ) : LLFirAbstractBodyTargetResolver( target, lockProvider, @@ -88,8 +85,7 @@ private class LLFirBodyTargetResolver( phase = resolverPhase, implicitTypeOnly = false, scopeSession = scopeSession, - returnTypeCalculator = createReturnTypeCalculator(firResolveContextCollector = firResolveContextCollector), - firResolveContextCollector = firResolveContextCollector, + returnTypeCalculator = createReturnTypeCalculator(), ) { override val preserveCFGForClasses: Boolean get() = false override val buildCfgForScripts: Boolean get() = false diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt index 118979d8e3a..c138029ae83 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt @@ -24,7 +24,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCallCopy import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.plugin.CompilerRequiredAnnotationsComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompilerRequiredAnnotationsResolveTransformer import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol @@ -37,7 +36,6 @@ internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirReso target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirCompilerRequiredAnnotationsTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt index f940ad1924a..ca03c7e9d25 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt @@ -19,19 +19,15 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.isCopyCreatedInScope import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef -import org.jetbrains.kotlin.util.PrivateForInline internal object LLFirContractsLazyResolver : LLFirLazyResolver(FirResolvePhase.CONTRACTS) { override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, - ): LLFirTargetResolver = LLFirContractsTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) + ): LLFirTargetResolver = LLFirContractsTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target !is FirContractDescriptionOwner) return @@ -43,22 +39,15 @@ private class LLFirContractsTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - firResolveContextCollector: FirResolveContextCollector?, ) : LLFirAbstractBodyTargetResolver( target, lockProvider, scopeSession, FirResolvePhase.CONTRACTS, ) { - override val transformer = FirContractResolveTransformer( - resolveTargetSession, - scopeSession, - firResolveContextCollector = firResolveContextCollector, - ) + override val transformer = FirContractResolveTransformer(resolveTargetSession, scopeSession) override fun doLazyResolveUnderLock(target: FirElementWithResolveState) { - collectTowerDataContext(target) - // There is no sense to resolve such declarations as they do not have contracts if (target is FirCallableDeclaration && target.isCopyCreatedInScope) return @@ -100,98 +89,6 @@ private class LLFirContractsTargetResolver( else -> throwUnexpectedFirElementError(target) } } - - - private inline fun actionWithContextCollector( - noinline action: () -> Unit, - crossinline collect: (FirResolveContextCollector, BodyResolveContext) -> Unit, - ): () -> Unit { - val collector = transformer.firResolveContextCollector ?: return action - return { - collect(collector, transformer.context) - action() - } - } - - @Deprecated("Should never be called directly, only for override purposes, please use withFile", level = DeprecationLevel.ERROR) - override fun withContainingFile(firFile: FirFile, action: () -> Unit) { - val actionWithCollector = actionWithContextCollector(action) { collector, context -> - collector.addFileContext(firFile, context.towerDataContext) - } - - @Suppress("DEPRECATION_ERROR") - super.withContainingFile(firFile, actionWithCollector) - } - - @Deprecated("Should never be called directly, only for override purposes, please use withScript", level = DeprecationLevel.ERROR) - override fun withContainingScript(firScript: FirScript, action: () -> Unit) { - val actionWithCollector = actionWithContextCollector(action) { collector, context -> - collector.addDeclarationContext(firScript, context) - } - - @Suppress("DEPRECATION_ERROR") - super.withContainingScript(firScript, actionWithCollector) - } - - @Deprecated("Should never be called directly, only for override purposes, please use withRegularClass", level = DeprecationLevel.ERROR) - override fun withContainingRegularClass(firClass: FirRegularClass, action: () -> Unit) { - val actionWithCollector = actionWithContextCollector(action) { collector, context -> - collector.addDeclarationContext(firClass, context) - } - - @Suppress("DEPRECATION_ERROR") - super.withContainingRegularClass(firClass, actionWithCollector) - } - - private fun collectTowerDataContext(target: FirElementWithResolveState) { - val contextCollector = transformer.firResolveContextCollector - if (contextCollector == null || target !is FirDeclaration) return - - val bodyResolveContext = transformer.context - withTypeParametersIfMemberDeclaration(bodyResolveContext, target) { - when (target) { - is FirRegularClass -> { - contextCollector.addClassHeaderContext(target, bodyResolveContext.towerDataContext) - } - - is FirFunction -> bodyResolveContext.forFunctionBody(target, transformer.components) { - contextCollector.addDeclarationContext(target, bodyResolveContext) - for (valueParameter in target.valueParameters) { - bodyResolveContext.withValueParameter(valueParameter, transformer.session) { - contextCollector.addDeclarationContext(valueParameter, bodyResolveContext) - } - } - } - - is FirScript -> {} - - else -> contextCollector.addDeclarationContext(target, bodyResolveContext) - } - } - - /** - * [withRegularClass] and [withScript] already have [FirResolveContextCollector.addDeclarationContext] call, - * so we shouldn't do anything inside - */ - when (target) { - is FirRegularClass -> withRegularClass(target) { } - is FirScript -> withScript(target) { } - else -> {} - } - } - - private inline fun withTypeParametersIfMemberDeclaration( - context: BodyResolveContext, - target: FirElementWithResolveState, - action: () -> Unit, - ) { - if (target is FirMemberDeclaration) { - @OptIn(PrivateForInline::class) - context.withTypeParametersOf(target, action) - } else { - action() - } - } } private object ContractStateKeepers { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt index f31783c0df4..ac17a3cb965 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.isCopyCreatedInScope import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.mpp.FirExpectActualMatcherTransformer import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase @@ -24,7 +23,6 @@ internal object LLFirExpectActualMatcherLazyResolver : LLFirLazyResolver(FirReso target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirExpectActualMatchingTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt index 0e8750394c5..aa23cb18943 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompanionGenerationTransformer internal object LLFirGeneratedCompanionObjectLazyResolver : LLFirLazyResolver(FirResolvePhase.COMPANION_GENERATION) { @@ -19,7 +18,6 @@ internal object LLFirGeneratedCompanionObjectLazyResolver : LLFirLazyResolver(Fi target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirCompanionGenerationTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {} diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt index f6e6db34805..2add2907973 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt @@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.isCopyCreatedInScope import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitAwareBodyResolveTransformer -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -33,8 +32,7 @@ internal object LLFirImplicitTypesLazyResolver : LLFirLazyResolver(FirResolvePha target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, - ): LLFirTargetResolver = LLFirImplicitBodyTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) + ): LLFirTargetResolver = LLFirImplicitBodyTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target !is FirCallableDeclaration) return @@ -129,7 +127,6 @@ internal class LLFirImplicitBodyTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - firResolveContextCollector: FirResolveContextCollector?, llImplicitBodyResolveComputationSessionParameter: LLImplicitBodyResolveComputationSession? = null, ) : LLFirAbstractBodyTargetResolver( target, @@ -145,8 +142,7 @@ internal class LLFirImplicitBodyTargetResolver( phase = resolverPhase, implicitTypeOnly = true, scopeSession = scopeSession, - firResolveContextCollector = firResolveContextCollector, - returnTypeCalculator = createReturnTypeCalculator(firResolveContextCollector = firResolveContextCollector), + returnTypeCalculator = createReturnTypeCalculator(), ) { override val preserveCFGForClasses: Boolean get() = false override val buildCfgForScripts: Boolean get() = false diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt index fca7a0fc5b5..8efd5879439 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt @@ -12,7 +12,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment /** @@ -26,9 +25,8 @@ internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) { target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = createTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) + val resolver = createTargetResolver(target, lockProvider, scopeSession) requireWithAttachment( resolverPhase == resolver.resolverPhase, { @@ -46,7 +44,6 @@ internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) { target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver fun checkIsResolved(target: FirElementWithResolveState) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt index 50bf6f838c3..c83a670356c 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector internal object LLFirLazyResolverRunner { fun runLazyResolverByPhase( @@ -17,12 +16,11 @@ internal object LLFirLazyResolverRunner { target: LLFirResolveTarget, scopeSession: ScopeSession, lockProvider: LLFirLockProvider, - towerDataContextCollector: FirResolveContextCollector?, ) { val lazyResolver = LLFirLazyPhaseResolverByPhase.getByPhase(phase) lockProvider.withGlobalLock { lockProvider.withGlobalPhaseLock(phase) { - lazyResolver.resolve(target, lockProvider, scopeSession, towerDataContextCollector) + lazyResolver.resolve(target, lockProvider, scopeSession) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt index 12546c6bb11..c87c7b8c9b7 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirImplici import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ReturnTypeCalculatorWithJump import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef @@ -24,7 +23,6 @@ internal class LLFirReturnTypeCalculatorWithJump( scopeSession: ScopeSession, implicitBodyResolveComputationSession: LLImplicitBodyResolveComputationSession, private val lockProvider: LLFirLockProvider, - private val towerDataContextCollector: FirResolveContextCollector?, ) : ReturnTypeCalculatorWithJump(scopeSession, implicitBodyResolveComputationSession) { override fun resolveDeclaration(declaration: FirCallableDeclaration): FirResolvedTypeRef { if (declaration.returnTypeRef !is FirImplicitTypeRef) { @@ -40,7 +38,6 @@ internal class LLFirReturnTypeCalculatorWithJump( designation, lockProvider = lockProvider, scopeSession = targetSession.getScopeSession(), - firResolveContextCollector = towerDataContextCollector, llImplicitBodyResolveComputationSessionParameter = computationSession, ) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt index 0c6c650c18b..bd1a5d11b69 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt @@ -10,14 +10,12 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockPro import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector internal object LLFirSealedClassInheritorsLazyResolver : LLFirLazyResolver(FirResolvePhase.SEALED_CLASS_INHERITORS) { override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirSealedClassInheritorsDesignatedResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {} diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt index 9af0fcca15d..7b37e6dedb8 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -35,7 +34,6 @@ internal object LLFirStatusLazyResolver : LLFirLazyResolver(FirResolvePhase.STAT target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirStatusTargetResolver( target = target, lockProvider = lockProvider, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt index fd9322fac9b..b517cbf05e9 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt @@ -27,7 +27,6 @@ import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider import org.jetbrains.kotlin.fir.resolve.transformers.FirSupertypeResolverVisitor import org.jetbrains.kotlin.fir.resolve.transformers.SupertypeComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.SupertypeComputationStatus -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.resolve.transformers.platformSupertypeUpdater import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase @@ -38,7 +37,6 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirSuperTypeTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt index f32345115fc..cc112f8128f 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -35,7 +34,6 @@ internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES) target: LLFirResolveTarget, lockProvider: LLFirLockProvider, scopeSession: ScopeSession, - towerDataContextCollector: FirResolveContextCollector?, ): LLFirTargetResolver = LLFirTypeTargetResolver(target, lockProvider, scopeSession) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt index a0e7a3e573e..8518defb8cb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -28,7 +28,6 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( scopeSession: ScopeSession, val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorForFullBodyResolve.Default, outerBodyResolveContext: BodyResolveContext? = null, - val firResolveContextCollector: FirResolveContextCollector? = null, ) : FirAbstractBodyResolveTransformer(phase) { open val preserveCFGForClasses: Boolean get() = !implicitTypeOnly 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 9eb00cbc85c..941e140d05e 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 @@ -1,5 +1,5 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -18,7 +18,6 @@ open class FirBodyResolveTransformer( scopeSession: ScopeSession, returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorForFullBodyResolve.Default, outerBodyResolveContext: BodyResolveContext? = null, - firResolveContextCollector: FirResolveContextCollector? = null ) : FirAbstractBodyResolveTransformerDispatcher( session, phase, @@ -26,7 +25,6 @@ open class FirBodyResolveTransformer( scopeSession, returnTypeCalculator, outerBodyResolveContext, - firResolveContextCollector ) { final override val expressionsTransformer = FirExpressionsResolveTransformer(this) final override val declarationsTransformer = FirDeclarationsResolveTransformer(this) 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 5263fb9078f..81dec38a0f9 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 @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -77,7 +77,6 @@ open class FirDeclarationsResolveTransformer( } protected fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration { - transformer.firResolveContextCollector?.addDeclarationContext(declaration, context) return transformer.transformDeclarationContent(declaration, data) } @@ -678,7 +677,7 @@ open class FirDeclarationsResolveTransformer( context.withContainingClass(regularClass) { val isLocal = regularClass.isLocal if (isLocal && regularClass !in context.targetedLocalClasses) { - return regularClass.runAllPhasesForLocalClass(components, data, transformer.firResolveContextCollector) + return regularClass.runAllPhasesForLocalClass(components, data) } if (isLocal || !implicitTypeOnly) { @@ -724,14 +723,13 @@ open class FirDeclarationsResolveTransformer( override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias = whileAnalysing(session, typeAlias) { if (implicitTypeOnly) return typeAlias if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) { - return typeAlias.runAllPhasesForLocalClass(components, data, transformer.firResolveContextCollector) + return typeAlias.runAllPhasesForLocalClass(components, data) } @OptIn(PrivateForInline::class) context.withContainer(typeAlias) { doTransformTypeParameters(typeAlias) typeAlias.transformAnnotations(transformer, data) - transformer.firResolveContextCollector?.addDeclarationContext(typeAlias, context) typeAlias.transformExpandedTypeRef(transformer, data) } @@ -742,8 +740,6 @@ open class FirDeclarationsResolveTransformer( file: FirFile, data: ResolutionMode, ): FirFile = withFile(file) { - transformer.firResolveContextCollector?.addFileContext(file, context.towerDataContext) - transformDeclarationContent(file, data) as FirFile } @@ -798,7 +794,7 @@ open class FirDeclarationsResolveTransformer( ): FirAnonymousObject = whileAnalysing(session, anonymousObject) { context.withContainingClass(anonymousObject) { if (anonymousObject !in context.targetedLocalClasses) { - return anonymousObject.runAllPhasesForLocalClass(components, data, transformer.firResolveContextCollector) + return anonymousObject.runAllPhasesForLocalClass(components, data) } require(anonymousObject.controlFlowGraphReference == null) @@ -895,7 +891,6 @@ open class FirDeclarationsResolveTransformer( val bodyResolved = function.bodyResolved dataFlowAnalyzer.enterFunction(function) - transformer.firResolveContextCollector?.addDeclarationContext(function, context) if (shouldResolveEverything) { // Annotations here are required only in the case of a local class member function. // Separate annotation transformers are responsible in the case of non-local functions. 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 8c36e5f3c21..11a1579c69e 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 @@ -1,5 +1,5 @@ /* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -558,7 +558,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT data else ResolutionMode.ContextIndependent - collectStatementContext(block.statements[index]) + TransformData.Data(value) } block.transformOtherChildren(transformer, data) @@ -573,10 +573,6 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT dataFlowAnalyzer.exitBlock(block) } - private fun collectStatementContext(statement: FirStatement) { - transformer.firResolveContextCollector?.addStatementContext(statement, context) - } - override fun transformThisReceiverExpression( thisReceiverExpression: FirThisReceiverExpression, data: ResolutionMode, @@ -994,7 +990,6 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT return binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryLogicExpression) .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)) .also(dataFlowAnalyzer::exitLeftBinaryLogicExpressionArgument) - .also { collectStatementContext(it.rightOperand) } .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)) .also(dataFlowAnalyzer::exitBinaryLogicExpression) .transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index 4c06a2f877e..d266ed16e6c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -73,8 +73,7 @@ class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSes fun F.runContractAndBodiesResolutionForLocalClass( components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents, resolutionMode: ResolutionMode, - localClassesNavigationInfo: LocalClassesNavigationInfo, - firResolveContextCollector: FirResolveContextCollector? = null + localClassesNavigationInfo: LocalClassesNavigationInfo ): F { val currentReturnTypeCalculator = components.context.returnTypeCalculator as? ReturnTypeCalculatorWithJump val prevDesignation = currentReturnTypeCalculator?.designationMapForLocalClasses ?: emptyMap() @@ -106,7 +105,6 @@ fun F.runContractAndBodiesResolutionForLocalClass( implicitTypeOnly = false, returnTypeCalculator, outerBodyResolveContext = newContext, - firResolveContextCollector = firResolveContextCollector, ) return this.transform(transformer, resolutionMode) @@ -120,7 +118,6 @@ open class FirImplicitAwareBodyResolveTransformer( implicitTypeOnly: Boolean, returnTypeCalculator: ReturnTypeCalculatorWithJump, outerBodyResolveContext: BodyResolveContext? = null, - firResolveContextCollector: FirResolveContextCollector? = null, ) : FirBodyResolveTransformer( session, phase, @@ -128,7 +125,6 @@ open class FirImplicitAwareBodyResolveTransformer( scopeSession, returnTypeCalculator, outerBodyResolveContext, - firResolveContextCollector ) { override fun transformForeignAnnotationCall(symbol: FirBasedSymbol<*>, annotationCall: FirAnnotationCall): FirAnnotationCall { val outerTransformer = (returnTypeCalculator as ReturnTypeCalculatorWithJump).outerTransformer diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirResolveContextCollector.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirResolveContextCollector.kt deleted file mode 100644 index f7ef7eeeae7..00000000000 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirResolveContextCollector.kt +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve - -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirTowerDataContext -import org.jetbrains.kotlin.fir.expressions.FirStatement - -/** - * Collector needed to collect TowerDataContext in IDE for in-air resolved fir elements. - */ -interface FirResolveContextCollector { - fun addFileContext(file: FirFile, context: FirTowerDataContext) - fun addStatementContext(statement: FirStatement, context: BodyResolveContext) - fun addDeclarationContext(declaration: FirDeclaration, context: BodyResolveContext) - - /** - * Here by "header" we understand the parts of the class declaration which resolution is not affected - * by the class own supertypes. - * - * It includes any type reference mentioned before the body of the class, except for: - * - primary constructor declaration with annotations - * - super type constructor **value arguments** with annotations - * - * Also, it includes class type parameters, because they are available anywhere inside the class declaration. - * - * N.B. We collect header contexts only for [FirRegularClass]es, ignoring - * [org.jetbrains.kotlin.fir.declarations.FirAnonymousObject]s. That's because anonymous objects are in - * fact expressions, and it should be enough for [FirTowerDataContextCollector] to have a context for - * the containing declaration to correctly process everything inside anonymous objects. - */ - fun addClassHeaderContext(declaration: FirRegularClass, context: FirTowerDataContext) -} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt index 18bb834cdcc..3f587ab2fb9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.runTypeResolvePhaseForLocal fun F.runAllPhasesForLocalClass( components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents, resolutionMode: ResolutionMode, - firResolveContextCollector: FirResolveContextCollector? ): F { if (status is FirResolvedDeclarationStatus) return this if (this is FirRegularClass) { @@ -64,7 +63,6 @@ fun F.runAllPhasesForLocalClass( components, resolutionMode, localClassesNavigationInfo, - firResolveContextCollector ) return this } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirAbstractContractResolveTransformerDispatcher.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirAbstractContractResolveTransformerDispatcher.kt index a0f96e7e6eb..21928352cae 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirAbstractContractResolveTransformerDispatcher.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirAbstractContractResolveTransformerDispatcher.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -31,7 +31,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveCon import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformerDispatcher import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImplWithoutSource import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry @@ -43,7 +42,6 @@ abstract class FirAbstractContractResolveTransformerDispatcher( session: FirSession, scopeSession: ScopeSession, outerBodyResolveContext: BodyResolveContext? = null, - firResolveContextCollector: FirResolveContextCollector? = null, ) : FirAbstractBodyResolveTransformerDispatcher( session, FirResolvePhase.CONTRACTS, @@ -51,7 +49,6 @@ abstract class FirAbstractContractResolveTransformerDispatcher( scopeSession, returnTypeCalculator = ReturnTypeCalculatorForFullBodyResolve.Contract, outerBodyResolveContext = outerBodyResolveContext, - firResolveContextCollector = firResolveContextCollector, ) { final override val expressionsTransformer: FirExpressionsResolveTransformer = FirExpressionsResolveTransformer(this) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt index 1369e33a474..20b51aed99a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -13,12 +13,10 @@ class FirContractResolveTransformer( session: FirSession, scopeSession: ScopeSession, outerBodyResolveContext: BodyResolveContext? = null, - firResolveContextCollector: FirResolveContextCollector? = null, ) : FirAbstractContractResolveTransformerDispatcher( session, scopeSession, outerBodyResolveContext, - firResolveContextCollector, ) { override val contractDeclarationsTransformer: FirDeclarationsContractResolveTransformer get() = FirDeclarationsContractResolveTransformer() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsTransformer.kt index 1f8ce7f8711..8ef98eaa16d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsTransformer.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -38,7 +38,6 @@ open class FirAnnotationArgumentsTransformer( resolvePhase: FirResolvePhase, outerBodyResolveContext: BodyResolveContext? = null, returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorForFullBodyResolve.Default, - firResolveContextCollector: FirResolveContextCollector? = null, ) : FirAbstractBodyResolveTransformerDispatcher( session, resolvePhase, @@ -46,7 +45,6 @@ open class FirAnnotationArgumentsTransformer( scopeSession, outerBodyResolveContext = outerBodyResolveContext, returnTypeCalculator = returnTypeCalculator, - firResolveContextCollector = firResolveContextCollector, ) { final override val expressionsTransformer: FirExpressionsResolveTransformer = FirExpressionTransformerForAnnotationArguments(this)