[FIR] drop obsolete FirResolveContextCollector

This interface is unused

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

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)

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,
             )
         }
     }

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(
+    protected fun createReturnTypeCalculator(): LLFirReturnTypeCalculatorWithJump = LLFirReturnTypeCalculatorWithJump(
-        firResolveContextCollector: FirResolveContextCollector?,
-    ): LLFirReturnTypeCalculatorWithJump = LLFirReturnTypeCalculatorWithJump(
         scopeSession,
         llImplicitBodyResolveComputationSession,
         lockProvider,
-        firResolveContextCollector,
     )
 
     abstract val transformer: FirAbstractBodyResolveTransformerDispatcher

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)
-    ): LLFirTargetResolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector)
 
     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),
+        returnTypeCalculator = createReturnTypeCalculator(),
-        firResolveContextCollector = firResolveContextCollector,
     )
 
     override fun doResolveWithoutLock(target: FirElementWithResolveState): Boolean {

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)
-    ): LLFirTargetResolver = LLFirBodyTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector)
 
     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),
+        returnTypeCalculator = createReturnTypeCalculator(),
-        firResolveContextCollector = firResolveContextCollector,
     ) {
         override val preserveCFGForClasses: Boolean get() = false
         override val buildCfgForScripts: Boolean get() = false

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) {

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)
-    ): LLFirTargetResolver = LLFirContractsTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector)
 
     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(
+    override val transformer = FirContractResolveTransformer(resolveTargetSession, scopeSession)
-        resolveTargetSession,
-        scopeSession,
-        firResolveContextCollector = firResolveContextCollector,
-    )
 
     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 {

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) {

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) {}

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)
-    ): LLFirTargetResolver = LLFirImplicitBodyTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector)
 
     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(),
-        returnTypeCalculator = createReturnTypeCalculator(firResolveContextCollector = firResolveContextCollector),
     ) {
         override val preserveCFGForClasses: Boolean get() = false
         override val buildCfgForScripts: Boolean get() = false

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) {

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)
             }
         }
 

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,
         )
 

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) {}

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,

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) {

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) {

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

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)

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.

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))

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 : FirClassLikeDeclaration> F.runContractAndBodiesResolutionForLocalClass(
     components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents,
     resolutionMode: ResolutionMode,
-    localClassesNavigationInfo: LocalClassesNavigationInfo,
+    localClassesNavigationInfo: LocalClassesNavigationInfo
-    firResolveContextCollector: FirResolveContextCollector? = null
 ): F {
     val currentReturnTypeCalculator = components.context.returnTypeCalculator as? ReturnTypeCalculatorWithJump
     val prevDesignation = currentReturnTypeCalculator?.designationMapForLocalClasses ?: emptyMap()
@@ -106,7 +105,6 @@ fun <F : FirClassLikeDeclaration> 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

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirResolveContextCollector.kt

@@ -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)
-}

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 : FirClassLikeDeclaration> 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 : FirClassLikeDeclaration> F.runAllPhasesForLocalClass(
         components,
         resolutionMode,
         localClassesNavigationInfo,
-        firResolveContextCollector
     )
     return this
 }

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)

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()

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)