[FIR] Fix all illegal usages of declarationSiteSession in compiler

There are still some usages in IDE which should be investigated

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt

@@ -44,6 +44,7 @@ import kotlin.contracts.contract
 object FirCallsEffectAnalyzer : FirControlFlowChecker() {
 
     override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) {
+        val session = context.session
         val function = (graph.declaration as? FirFunction<*>) ?: return
         if (function !is FirContractDescriptionOwner) return
         if (function.contractDescription.coneEffects?.any { it is ConeCallsEffectDeclaration } != true) return
@@ -51,13 +52,13 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
         val functionalTypeEffects = mutableMapOf<AbstractFirBasedSymbol<*>, ConeCallsEffectDeclaration>()
 
         function.valueParameters.forEachIndexed { index, parameter ->
-            if (parameter.returnTypeRef.isFunctionalTypeRef(function.declarationSiteSession)) {
+            if (parameter.returnTypeRef.isFunctionalTypeRef(session)) {
                 val effectDeclaration = function.contractDescription.getParameterCallsEffectDeclaration(index)
                 if (effectDeclaration != null) functionalTypeEffects[parameter.symbol] = effectDeclaration
             }
         }
 
-        if (function.receiverTypeRef.isFunctionalTypeRef(function.declarationSiteSession)) {
+        if (function.receiverTypeRef.isFunctionalTypeRef(session)) {
             val effectDeclaration = function.contractDescription.getParameterCallsEffectDeclaration(-1)
             if (effectDeclaration != null) functionalTypeEffects[function.symbol] = effectDeclaration
         }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt

@@ -33,8 +33,6 @@ import org.jetbrains.kotlin.fir.types.intersectTypesOrNull
 import org.jetbrains.kotlin.fir.types.isNullable
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 import org.jetbrains.kotlin.types.ConstantValueKind
-import org.jetbrains.kotlin.types.model.KotlinTypeMarker
-import org.jetbrains.kotlin.types.model.TypeCheckerProviderContext
 import org.jetbrains.kotlin.utils.addIfNotNull
 
 object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
@@ -50,7 +48,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
 
         if (effects.isNullOrEmpty()) return
 
-        val logicSystem = object : PersistentLogicSystem(function.declarationSiteSession.typeContext) {
+        val logicSystem = object : PersistentLogicSystem(context.session.typeContext) {
             override fun processUpdatedReceiverVariable(flow: PersistentFlow, variable: RealVariable) =
                 throw IllegalStateException("Receiver variable update is not possible for this logic system")
 
@@ -84,8 +82,8 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
         context: CheckerContext
     ): Boolean {
         val effect = effectDeclaration.effect as ConeReturnsEffectDeclaration
-        val builtinTypes = function.declarationSiteSession.builtinTypes
+        val builtinTypes = context.session.builtinTypes
-        val typeContext = function.declarationSiteSession.typeContext
+        val typeContext = context.session.typeContext
         val flow = dataFlowInfo.flowOnNodes.getValue(node) as PersistentFlow
 
         val isReturn = node is JumpNode && node.fir is FirReturnExpression
@@ -104,7 +102,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
 
         if (effect.value != ConeConstantReference.WILDCARD) {
             val operation = effect.value.toOperation()
-            if (expressionType != null && expressionType.isInapplicableWith(operation, function.declarationSiteSession)) return false
+            if (expressionType != null && expressionType.isInapplicableWith(operation, context.session)) return false
 
             if (resultExpression is FirConstExpression<*>) {
                 if (!resultExpression.isApplicableWith(operation)) return false
@@ -179,7 +177,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
         is ConeIsNullPredicate -> {
             val fir = function.getParameterSymbol(arg.parameterIndex, context).fir
             val realVar = variableStorage.getOrCreateRealVariable(flow, fir.symbol, fir)
-            realVar?.to(simpleTypeStatement(realVar, isNegated, function.declarationSiteSession.builtinTypes.anyType.type))?.let { mutableMapOf(it) }
+            realVar?.to(simpleTypeStatement(realVar, isNegated, context.session.builtinTypes.anyType.type))?.let { mutableMapOf(it) }
         }
         is ConeLogicalNot -> arg.buildTypeStatements(function, logicSystem, variableStorage, flow, context)
             ?.mapValuesTo(mutableMapOf()) { (_, value) -> value.invert() }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt

@@ -53,51 +53,17 @@ private val INLINE_ONLY_ANNOTATION_CLASS_ID = ClassId.topLevel(FqName("kotlin.in
 internal fun FirClass<*>.unsubstitutedScope(context: CheckerContext) =
     this.unsubstitutedScope(context.sessionHolder.session, context.sessionHolder.scopeSession, withForcedTypeCalculator = false)
 
-/**
- * Returns true if this is a superclass of other.
- */
-fun FirClass<*>.isSuperclassOf(other: FirClass<*>): Boolean {
-    /**
-     * Hides additional parameters.
-     */
-    fun FirClass<*>.isSuperclassOf(other: FirClass<*>, exclude: MutableSet<FirClass<*>>): Boolean {
-        for (it in other.superTypeRefs) {
-            val that = it.firClassLike(declarationSiteSession)
-                ?.followAllAlias(declarationSiteSession)
-                ?.safeAs<FirClass<*>>()
-                ?: continue
-
-            if (that in exclude) {
-                continue
-            }
-
-            if (that.classKind == ClassKind.CLASS) {
-                if (that == this) {
-                    return true
-                }
-
-                exclude.add(that)
-                return this.isSuperclassOf(that, exclude)
-            }
-        }
-
-        return false
-    }
-
-    return isSuperclassOf(other, mutableSetOf())
-}
-
 /**
  * Returns true if this is a supertype of other.
  */
-fun FirClass<*>.isSupertypeOf(other: FirClass<*>): Boolean {
+fun FirClass<*>.isSupertypeOf(other: FirClass<*>, session: FirSession): Boolean {
     /**
      * Hides additional parameters.
      */
     fun FirClass<*>.isSupertypeOf(other: FirClass<*>, exclude: MutableSet<FirClass<*>>): Boolean {
         for (it in other.superTypeRefs) {
-            val candidate = it.firClassLike(declarationSiteSession)
+            val candidate = it.firClassLike(session)
-                ?.followAllAlias(declarationSiteSession)
+                ?.followAllAlias(session)
                 ?.safeAs<FirClass<*>>()
                 ?: continue
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt

@@ -44,7 +44,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
         val isInterface = declaration.classKind == ClassKind.INTERFACE
         for (supertypeRef in supertypes) {
             val supertype = supertypeRef.coneTypeSafe<ConeClassLikeType>() ?: continue
-            val clazz = supertype.toRegularClass(declaration.declarationSiteSession) ?: continue
+            val clazz = supertype.toRegularClass(context.session) ?: continue
             val superIsInterface = clazz.classKind == ClassKind.INTERFACE
             if (superIsInterface != isInterface) {
                 continue

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt

@@ -50,7 +50,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
             }
         }
 
-        if (declaration.isSubtypeOfCloneable()) {
+        if (declaration.isSubtypeOfCloneable(context.session)) {
             reporter.reportOn(declaration.source, FirErrors.VALUE_CLASS_CANNOT_BE_CLONEABLE, context)
         }
 
@@ -210,7 +210,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
                     ?.isRecursiveInlineClassType(visited, session) == true
     }
 
-    private fun FirRegularClass.isSubtypeOfCloneable(): Boolean {
+    private fun FirRegularClass.isSubtypeOfCloneable(session: FirSession): Boolean {
         if (classId.isCloneableId()) return true
 
         return lookupSuperTypes(this, lookupInterfaces = true, deep = true, session).any { superType ->

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt

@@ -59,6 +59,7 @@ object FirOverrideChecker : FirClassChecker() {
     private fun ConeKotlinType.substituteAllTypeParameters(
         overrideDeclaration: FirCallableMemberDeclaration<*>,
         baseDeclaration: FirCallableDeclaration<*>,
+        context: CheckerContext
     ): ConeKotlinType {
         if (overrideDeclaration.typeParameters.isEmpty()) {
             return this
@@ -77,7 +78,7 @@ object FirOverrideChecker : FirClassChecker() {
             map[from.symbol] = to.toConeType()
         }
 
-        return substitutorByMap(map).substituteOrSelf(this)
+        return substitutorByMap(map, context.session).substituteOrSelf(this)
     }
 
     private fun checkModality(
@@ -144,7 +145,7 @@ object FirOverrideChecker : FirClassChecker() {
         for (it in bounds.indices) {
             val overriddenDeclaration = overriddenSymbols[it].fir
 
-            val overriddenReturnType = bounds[it].substituteAllTypeParameters(this, overriddenDeclaration)
+            val overriddenReturnType = bounds[it].substituteAllTypeParameters(this, overriddenDeclaration, context)
 
             val isReturnTypeOkForOverride =
                 if (overriddenDeclaration is FirProperty && overriddenDeclaration.isVar)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
 import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.resolve.containingClass
+import org.jetbrains.kotlin.fir.resolve.getContainingClass
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 
 object FirCallableReferenceChecker : FirQualifiedAccessChecker() {
@@ -43,7 +43,7 @@ object FirCallableReferenceChecker : FirQualifiedAccessChecker() {
         if (source.kind is FirFakeSourceElementKind) return
 
         val referredDeclaration = reference.resolvedSymbol.fir
-        if (referredDeclaration is FirConstructor && referredDeclaration.containingClass?.classKind == ClassKind.ANNOTATION_CLASS) {
+        if (referredDeclaration is FirConstructor && referredDeclaration.getContainingClass(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) {
             reporter.reportOn(source, FirErrors.CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, context)
         }
         if ((referredDeclaration as? FirCallableMemberDeclaration<*>)?.isExtensionMember == true &&

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt

@@ -28,7 +28,7 @@ object FirNotASupertypeChecker : FirQualifiedAccessChecker() {
             ?: return
 
         val surrounding = context.findClosestClass(superReference.labelName) ?: return
-        if (!targetClass.isSupertypeOf(surrounding)) {
+        if (!targetClass.isSupertypeOf(surrounding, context.session)) {
             reporter.reportOn(expression.source, FirErrors.NOT_A_SUPERTYPE, context)
         }
     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt

@@ -44,7 +44,7 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess
                 ?.followAllAlias(context.session).safeAs<FirClass<*>>()
                 ?: continue
 
-            val isSupertype = explicitType.isSupertypeOf(that)
+            val isSupertype = explicitType.isSupertypeOf(that, context.session)
 
             if (explicitType == that || isSupertype) {
                 if (isSupertype) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedChecker.kt

@@ -59,7 +59,8 @@ object FirUpperBoundViolatedChecker : FirQualifiedAccessChecker() {
         // we substitute actual values to the
         // type parameters from the declaration
         val substitutor = substitutorByMap(
-            parameterPairs.mapValues { it.value.coneType }
+            parameterPairs.mapValues { it.value.coneType },
+            context.session
         )
 
         parameterPairs.forEach { (proto, actual) ->
@@ -147,7 +148,8 @@ object FirUpperBoundViolatedChecker : FirQualifiedAccessChecker() {
         // parameters to the ones used in the
         // typealias target
         val declarationSiteSubstitutor = substitutorByMap(
-            constructorsParameterPairs.toMap().mapValues { it.value.type }
+            constructorsParameterPairs.toMap().mapValues { it.value.type },
+            context.session
         )
 
         constructorsParameterPairs.forEach { (proto, actual) ->
@@ -209,7 +211,8 @@ object FirUpperBoundViolatedChecker : FirQualifiedAccessChecker() {
         }
 
         val substitutor = substitutorByMap(
-            parameterPairs.toMap().mapValues { it.value.type }
+            parameterPairs.toMap().mapValues { it.value.type },
+            context.session
         )
 
         parameterPairs.forEach { (proto, actual) ->

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt

@@ -40,7 +40,7 @@ fun FirSession.registerCommonComponents(languageVersionSettings: LanguageVersion
     register(FirLanguageSettingsComponent::class, FirLanguageSettingsComponent(languageVersionSettings))
     register(InferenceComponents::class, InferenceComponents(this))
 
-    register(FirDeclaredMemberScopeProvider::class, FirDeclaredMemberScopeProvider())
+    register(FirDeclaredMemberScopeProvider::class, FirDeclaredMemberScopeProvider(this))
     register(FirCorrespondingSupertypesCache::class, FirCorrespondingSupertypesCache(this))
     register(FirDefaultParametersResolver::class, FirDefaultParametersResolver())
 

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -200,7 +200,7 @@ class FirElementSerializer private constructor(
     @OptIn(ExperimentalStdlibApi::class)
     private fun FirClass<*>.declarations(): List<FirCallableMemberDeclaration<*>> = buildList {
         val memberScope =
-            defaultType().scope(declarationSiteSession, scopeSession, FakeOverrideTypeCalculator.DoNothing)
+            defaultType().scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)
                 ?: error("Null scope for $this")
 
         fun addDeclarationIfNeeded(symbol: FirCallableSymbol<*>) {
@@ -938,6 +938,7 @@ class FirElementSerializer private constructor(
 
         @JvmStatic
         fun create(
+            session: FirSession,
             scopeSession: ScopeSession,
             klass: FirClass<*>,
             extension: FirSerializerExtension,
@@ -946,17 +947,17 @@ class FirElementSerializer private constructor(
         ): FirElementSerializer {
             val parentClassId = klass.symbol.classId.outerClassId
             val parent = if (parentClassId != null && !parentClassId.isLocal) {
-                val parentClass = klass.declarationSiteSession.symbolProvider.getClassLikeSymbolByFqName(parentClassId)!!.fir as FirRegularClass
+                val parentClass = session.symbolProvider.getClassLikeSymbolByFqName(parentClassId)!!.fir as FirRegularClass
-                parentSerializer ?: create(scopeSession, parentClass, extension, null, typeApproximator)
+                parentSerializer ?: create(session, scopeSession, parentClass, extension, null, typeApproximator)
             } else {
-                createTopLevel(klass.declarationSiteSession, scopeSession, extension, typeApproximator)
+                createTopLevel(session, scopeSession, extension, typeApproximator)
             }
 
             // Calculate type parameter ids for the outer class beforehand, as it would've had happened if we were always
             // serializing outer classes before nested classes.
             // Otherwise our interner can get wrong ids because we may serialize classes in any order.
             val serializer = FirElementSerializer(
-                klass.declarationSiteSession,
+                session,
                 scopeSession,
                 klass,
                 Interner(parent.typeParameters),

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt

@@ -210,8 +210,8 @@ class FirJvmSerializerExtension(
     private fun FirFunction<*>.needsInlineParameterNullCheckRequirement(): Boolean =
         this is FirSimpleFunction && isInline && !isSuspend && !isParamAssertionsDisabled &&
                 !Visibilities.isPrivate(visibility) &&
-                (valueParameters.any { it.returnTypeRef.coneType.isBuiltinFunctionalType(declarationSiteSession) } ||
+                (valueParameters.any { it.returnTypeRef.coneType.isBuiltinFunctionalType(session) } ||
-                        receiverTypeRef?.coneType?.isBuiltinFunctionalType(declarationSiteSession) == true)
+                        receiverTypeRef?.coneType?.isBuiltinFunctionalType(session) == true)
 
     override fun serializeProperty(
         property: FirProperty,
@@ -256,7 +256,7 @@ class FirJvmSerializerExtension(
 
         val container =
             dispatchReceiverType?.classId?.let {
-                declarationSiteSession.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
+                session.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
             }
         if (container == null || !container.isCompanion) {
             return false
@@ -264,7 +264,7 @@ class FirJvmSerializerExtension(
 
         val grandParent =
             container.classId.outerClassId?.let {
-                declarationSiteSession.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
+                session.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
             }
         return grandParent != null &&
                 (grandParent.classKind == ClassKind.INTERFACE || grandParent.classKind == ClassKind.ANNOTATION_CLASS)

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt

@@ -155,17 +155,18 @@ class FirMetadataSerializer(
     private val serializer: FirElementSerializer? =
         when (val metadata = irClass.metadata) {
             is FirMetadataSource.Class -> FirElementSerializer.create(
+                components.session,
                 components.scopeSession,
                 metadata.fir, serializerExtension, (parent as? FirMetadataSerializer)?.serializer, approximator
             )
             is FirMetadataSource.File -> FirElementSerializer.createTopLevel(
-                metadata.session,
+                components.session,
                 components.scopeSession,
                 serializerExtension,
                 approximator
             )
             is FirMetadataSource.Function -> FirElementSerializer.createForLambda(
-                metadata.session,
+                components.session,
                 components.scopeSession,
                 serializerExtension,
                 approximator

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.name.Name
 sealed class FirMetadataSource : MetadataSource {
     abstract val fir: FirDeclaration
 
-    val session: FirSession
+    val declarationSiteSession: FirSession
         get() = fir.declarationSiteSession
 
     override val name: Name?

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt

@@ -470,7 +470,7 @@ class CallAndReferenceGenerator(
             val type = typeProjection.typeRef.coneTypeSafe<ConeKotlinType>() ?: continue
             map[typeParameter.symbol] = type
         }
-        return ConeSubstitutorByMap(map)
+        return ConeSubstitutorByMap(map, session)
     }
 
     internal fun IrExpression.applyCallArguments(call: FirCall?, annotationMode: Boolean): IrExpression {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt

@@ -63,12 +63,12 @@ class JavaScopeProvider(
         }
     }
 
-    private fun buildDeclaredMemberScope(regularClass: FirRegularClass): FirScope {
+    private fun buildDeclaredMemberScope(useSiteSession: FirSession, regularClass: FirRegularClass): FirScope {
-        return if (regularClass is FirJavaClass) declaredMemberScopeWithLazyNestedScope(
+        return if (regularClass is FirJavaClass) useSiteSession.declaredMemberScopeWithLazyNestedScope(
             regularClass,
             existingNames = regularClass.existingNestedClassifierNames,
             symbolProvider = symbolProvider
-        ) else declaredMemberScope(regularClass)
+        ) else useSiteSession.declaredMemberScope(regularClass)
     }
 
     private fun buildUseSiteMemberScopeWithJavaTypes(
@@ -77,7 +77,7 @@ class JavaScopeProvider(
         scopeSession: ScopeSession,
     ): JavaClassUseSiteMemberScope {
         return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
-            val declaredScope = buildDeclaredMemberScope(regularClass)
+            val declaredScope = buildDeclaredMemberScope(useSiteSession, regularClass)
             val superTypes =
                 if (regularClass.isThereLoopInSupertypes(useSiteSession))
                     listOf(StandardClassIds.Any.toConeKotlinType(emptyArray(), isNullable = false))
@@ -122,14 +122,14 @@ class JavaScopeProvider(
         if (!visitedClasses.add(klass)) return null
 
         return scopeSession.getOrBuild(klass.symbol, JAVA_ENHANCEMENT_FOR_STATIC) {
-            val declaredScope = buildDeclaredMemberScope(klass)
+            val declaredScope = buildDeclaredMemberScope(useSiteSession, klass)
 
-            val superClassScope = klass.findJavaSuperClass()?.let {
+            val superClassScope = klass.findJavaSuperClass(useSiteSession)?.let {
                 (it.scopeProvider as? JavaScopeProvider)
                     ?.getStaticMemberScopeForCallables(it, useSiteSession, scopeSession, visitedClasses)
             } ?: FirTypeScope.Empty
 
-            val superTypesScopes = klass.findClosestJavaSuperTypes().mapNotNull {
+            val superTypesScopes = klass.findClosestJavaSuperTypes(useSiteSession).mapNotNull {
                 (it.scopeProvider as? JavaScopeProvider)
                     ?.getStaticMemberScopeForCallables(it, useSiteSession, scopeSession, visitedClasses)
             }
@@ -149,24 +149,24 @@ class JavaScopeProvider(
         }
     }
 
-    private tailrec fun FirRegularClass.findJavaSuperClass(): FirRegularClass? {
+    private tailrec fun FirRegularClass.findJavaSuperClass(useSiteSession: FirSession): FirRegularClass? {
         val superClass = superConeTypes.firstNotNullResult {
-            (it.lookupTag.toSymbol(declarationSiteSession)?.fir as? FirRegularClass)?.takeIf { superClass ->
+            (it.lookupTag.toSymbol(useSiteSession)?.fir as? FirRegularClass)?.takeIf { superClass ->
                 superClass.classKind == ClassKind.CLASS
             }
         } ?: return null
 
         if (superClass.origin is FirDeclarationOrigin.Java) return superClass
 
-        return superClass.findJavaSuperClass()
+        return superClass.findJavaSuperClass(useSiteSession)
     }
 
-    private fun FirRegularClass.findClosestJavaSuperTypes(): Collection<FirRegularClass> {
+    private fun FirRegularClass.findClosestJavaSuperTypes(useSiteSession: FirSession): Collection<FirRegularClass> {
         val result = mutableListOf<FirRegularClass>()
         DFS.dfs(listOf(this),
                 { regularClass ->
                     regularClass.superConeTypes.mapNotNull {
-                        it.lookupTag.toSymbol(declarationSiteSession)?.fir as? FirRegularClass
+                        it.lookupTag.toSymbol(useSiteSession)?.fir as? FirRegularClass
                     }
                 },
                 object : DFS.AbstractNodeHandler<FirRegularClass, Unit>() {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -213,7 +213,7 @@ class JavaSymbolProvider(
     ) {
         replaceSuperTypeRefs(
             javaClass.supertypes.map { supertype ->
-                supertype.toFirResolvedTypeRef(declarationSiteSession, javaTypeParameterStack, isForSupertypes = true, forTypeParameterBounds = false)
+                supertype.toFirResolvedTypeRef(session, javaTypeParameterStack, isForSupertypes = true, forTypeParameterBounds = false)
             }
         )
     }
@@ -354,7 +354,7 @@ class JavaSymbolProvider(
                 valueParametersForAnnotationConstructor.forEach { javaMethod, firValueParameter ->
                     javaMethod.annotationParameterDefaultValue?.let { javaDefaultValue ->
                         firValueParameter.defaultValue =
-                            javaDefaultValue.toFirExpression(declarationSiteSession, javaTypeParameterStack, firValueParameter.returnTypeRef)
+                            javaDefaultValue.toFirExpression(session, javaTypeParameterStack, firValueParameter.returnTypeRef)
                     }
                 }
             }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -402,7 +402,7 @@ private fun JavaClassifierType.toConeKotlinTypeForFlexibleBound(
                 } else {
                     val position = if (isLowerBound) TypeComponentPosition.FLEXIBLE_LOWER else TypeComponentPosition.FLEXIBLE_UPPER
 
-                    classSymbol?.fir?.createRawArguments(defaultArgs, position) ?: defaultArgs
+                    classSymbol?.fir?.createRawArguments(session, defaultArgs, position) ?: defaultArgs
                 }
             } else {
                 val typeParameters = runIf(!forTypeParameterBounds && !isForSupertypes) { classSymbol?.fir?.typeParameters } ?: emptyList()
@@ -429,13 +429,14 @@ private fun JavaClassifierType.toConeKotlinTypeForFlexibleBound(
 }
 
 private fun FirRegularClass.createRawArguments(
+    session: FirSession,
     defaultArgs: List<ConeStarProjection>,
     position: TypeComponentPosition
-) = typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
+): List<ConeTypeProjection> = typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
     val erasedUpperBound = typeParameter.getErasedUpperBound {
         defaultType().withArguments(defaultArgs.toTypedArray())
     }
-    computeRawProjection(declarationSiteSession, typeParameter, position, erasedUpperBound)
+    computeRawProjection(session, typeParameter, position, erasedUpperBound)
 }
 
 private fun buildEnumCall(session: FirSession, classId: ClassId?, entryName: Name?) =

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt

@@ -382,13 +382,13 @@ class JavaClassUseSiteMemberScope(
     }
 
     private fun FirFunction<*>.computeJvmSignature(): String? {
-        return computeJvmSignature { it.toConeKotlinTypeProbablyFlexible(declarationSiteSession, typeParameterStack) }
+        return computeJvmSignature { it.toConeKotlinTypeProbablyFlexible(session, typeParameterStack) }
     }
 
     private fun FirFunction<*>.computeJvmDescriptor(customName: String? = null, includeReturnType: Boolean = false): String {
         return computeJvmDescriptor(customName, includeReturnType) {
             it.toConeKotlinTypeProbablyFlexible(
-                declarationSiteSession,
+                session,
                 typeParameterStack
             )
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt

@@ -134,14 +134,14 @@ class JavaOverrideChecker internal constructor(
     override fun buildTypeParametersSubstitutorIfCompatible(
         overrideCandidate: FirCallableMemberDeclaration<*>,
         baseDeclaration: FirCallableMemberDeclaration<*>
-    ): ConeSubstitutor? {
+    ): ConeSubstitutor {
         if (!overrideCandidate.isTypeParameterDependent() && !baseDeclaration.isTypeParameterDependent()) {
             return ConeSubstitutor.Empty
         }
         val typeParameters = linkedSetOf<FirTypeParameterRef>()
         overrideCandidate.extractTypeParametersTo(typeParameters)
         baseDeclaration.extractTypeParametersTo(typeParameters)
-        return substitutorByMap(typeParameters.buildErasure())
+        return substitutorByMap(typeParameters.buildErasure(), session)
     }
 
     override fun isOverriddenFunction(overrideCandidate: FirSimpleFunction, baseDeclaration: FirSimpleFunction): Boolean {

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt

@@ -35,7 +35,8 @@ class JvmMappedScope(
     private val substitutor = ConeSubstitutorByMap(
         firJavaClass.typeParameters.zip(firKotlinClass.typeParameters).map { (javaParameter, kotlinParameter) ->
             javaParameter.symbol to ConeTypeParameterTypeImpl(ConeTypeParameterLookupTag(kotlinParameter.symbol), isNullable = false)
-        }.toMap()
+        }.toMap(),
+        session
     )
     private val kotlinDispatchReceiverType = firKotlinClass.defaultType()
 

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

@@ -359,51 +359,49 @@ private fun initialTypeOfCandidate(candidate: Candidate, typeRef: FirResolvedTyp
     return candidate.substitutor.substituteOrSelf(typeRef.type)
 }
 
-inline val FirCallableDeclaration<*>.containingClass: FirRegularClass?
+fun FirCallableDeclaration<*>.getContainingClass(session: FirSession): FirRegularClass? = this.containingClassAttr?.let { lookupTag ->
-    get() = this.containingClassAttr?.let { lookupTag ->
+    session.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass
-        declarationSiteSession.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass
+}
-    }
 
-val FirFunction<*>.asForbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget?
+fun FirFunction<*>.getAsForbiddenNamedArgumentsTarget(session: FirSession): ForbiddenNamedArgumentsTarget? {
-    get() {
+    if (this is FirConstructor && this.isPrimary) {
-        if (this is FirConstructor && this.isPrimary) {
+        this.getContainingClass(session)?.let { containingClass ->
-            this.containingClass?.let { containingClass ->
+            if (containingClass.classKind == ClassKind.ANNOTATION_CLASS) {
-                if (containingClass.classKind == ClassKind.ANNOTATION_CLASS) {
+                // Java annotation classes allow (actually require) named parameters.
-                    // Java annotation classes allow (actually require) named parameters.
+                return null
-                    return null
-                }
             }
         }
-        if (this is FirMemberDeclaration && status.isExpect) {
-            return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
-        }
-        return when (origin) {
-            FirDeclarationOrigin.Source, FirDeclarationOrigin.Library -> null
-            FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.asForbiddenNamedArgumentsTarget
-            FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.asForbiddenNamedArgumentsTarget
-            // For intersection overrides, the logic in
-            // org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope#selectMostSpecificMember picks the most specific one and store
-            // it in originalForIntersectionOverrideAttr. This follows from FE1.0 behavior which selects the most specific function
-            // (org.jetbrains.kotlin.resolve.OverridingUtil#selectMostSpecificMember), from which the `hasStableParameterNames` status is
-            // copied.
-            FirDeclarationOrigin.IntersectionOverride -> originalForIntersectionOverrideAttr?.asForbiddenNamedArgumentsTarget
-            FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement -> ForbiddenNamedArgumentsTarget.NON_KOTLIN_FUNCTION
-            FirDeclarationOrigin.SamConstructor -> null
-            FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.asForbiddenNamedArgumentsTarget
-            // referenced function of a Kotlin function type
-            FirDeclarationOrigin.BuiltIns -> {
-                if (dispatchReceiverClassOrNull()?.isBuiltinFunctionalType() == true) {
-                    ForbiddenNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE
-                } else {
-                    null
-                }
-            }
-            FirDeclarationOrigin.Synthetic -> null
-            is FirDeclarationOrigin.Plugin -> null // TODO: figure out what to do with plugin generated functions
-        }
     }
+    if (this is FirMemberDeclaration && status.isExpect) {
+        return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
+    }
+    return when (origin) {
+        FirDeclarationOrigin.Source, FirDeclarationOrigin.Library -> null
+        FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.getAsForbiddenNamedArgumentsTarget(session)
+        FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.getAsForbiddenNamedArgumentsTarget(session)
+        // For intersection overrides, the logic in
+        // org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope#selectMostSpecificMember picks the most specific one and store
+        // it in originalForIntersectionOverrideAttr. This follows from FE1.0 behavior which selects the most specific function
+        // (org.jetbrains.kotlin.resolve.OverridingUtil#selectMostSpecificMember), from which the `hasStableParameterNames` status is
+        // copied.
+        FirDeclarationOrigin.IntersectionOverride -> originalForIntersectionOverrideAttr?.getAsForbiddenNamedArgumentsTarget(session)
+        FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement -> ForbiddenNamedArgumentsTarget.NON_KOTLIN_FUNCTION
+        FirDeclarationOrigin.SamConstructor -> null
+        FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.getAsForbiddenNamedArgumentsTarget(session)
+        // referenced function of a Kotlin function type
+        FirDeclarationOrigin.BuiltIns -> {
+            if (dispatchReceiverClassOrNull()?.isBuiltinFunctionalType() == true) {
+                ForbiddenNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE
+            } else {
+                null
+            }
+        }
+        FirDeclarationOrigin.Synthetic -> null
+        is FirDeclarationOrigin.Plugin -> null // TODO: figure out what to do with plugin generated functions
+    }
+}
 
 // TODO: handle functions with non-stable parameter names, see also
 //  org.jetbrains.kotlin.fir.serialization.FirElementSerializer.functionProto
 //  org.jetbrains.kotlin.fir.serialization.FirElementSerializer.constructorProto
-inline val FirFunction<*>.hasStableParameterNames: Boolean get() = asForbiddenNamedArgumentsTarget == null
+fun FirFunction<*>.getHasStableParameterNames(session: FirSession): Boolean = getAsForbiddenNamedArgumentsTarget(session) == null

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

@@ -94,6 +94,7 @@ class FirSamResolverImpl(
                         Pair(parameterSymbol, typeArgument)
                     }
                     .toMap(),
+                firSession
             )
 
         val result =
@@ -148,6 +149,7 @@ class FirSamResolverImpl(
             firRegularClass.typeParameters
                 .map { it.symbol }
                 .zip(newTypeParameterTypes).toMap(),
+            firSession
         )
 
         for ((newTypeParameter, oldTypeParameter) in newTypeParameters.zip(firRegularClass.typeParameters)) {

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

@@ -47,7 +47,7 @@ private fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: Scope
 
             val substitution = createSubstitution(fir.typeParameters, fullyExpandedType, useSiteSession)
 
-            fir.scopeForClass(substitutorByMap(substitution), useSiteSession, scopeSession)
+            fir.scopeForClass(substitutorByMap(substitution, useSiteSession), useSiteSession, scopeSession)
         }
         is ConeTypeParameterType -> {
             val symbol = lookupTag.symbol

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

@@ -143,9 +143,9 @@ fun ConeClassLikeType.wrapSubstitutionScopeIfNeed(
             // to determine parameter types properly (e.g. String, String instead of K, V)
             val platformTypeParameters = platformClass.typeParameters
             val platformSubstitution = createSubstitution(platformTypeParameters, this, session)
-            substitutorByMap(originalSubstitution + platformSubstitution)
+            substitutorByMap(originalSubstitution + platformSubstitution, session)
         } else {
-            substitutorByMap(originalSubstitution)
+            substitutorByMap(originalSubstitution, session)
         }
         FirClassSubstitutionScope(
             session, useSiteMemberScope, substitutor,

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

@@ -178,6 +178,6 @@ abstract class AbstractConeCallConflictResolver(
     }
 
     private fun createEmptyConstraintSystem(): SimpleConstraintSystem {
-        return ConeSimpleConstraintSystemImpl(inferenceComponents.createConstraintSystem())
+        return ConeSimpleConstraintSystemImpl(inferenceComponents.createConstraintSystem(), inferenceComponents.session)
     }
 }

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.render
@@ -196,7 +197,7 @@ class ConeOverloadConflictResolver(
 
 object NoSubstitutor : TypeSubstitutorMarker
 
-class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl) : SimpleConstraintSystem {
+class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl, val session: FirSession) : SimpleConstraintSystem {
     override fun registerTypeVariables(typeParameters: Collection<TypeParameterMarker>): TypeSubstitutorMarker = with(context) {
         val csBuilder = system.getBuilder()
         val substitutionMap = typeParameters.associateBy({ (it as ConeTypeParameterLookupTag).typeParameterSymbol }) {
@@ -206,7 +207,7 @@ class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl) : Simp
 
             variable.defaultType
         }
-        val substitutor = substitutorByMap(substitutionMap)
+        val substitutor = substitutorByMap(substitutionMap, session)
         for (typeParameter in typeParameters) {
             require(typeParameter is ConeTypeParameterLookupTag)
             for (upperBound in typeParameter.symbol.fir.bounds) {

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

@@ -156,7 +156,7 @@ private fun prepareSubstitutorForTypeAliasConstructors(
         it as? ConeKotlinType ?: return null
     }
     return substitutorByMap(
-        expandedClass.typeParameters.map { it.symbol }.zip(resultingTypeArguments).toMap()
+        expandedClass.typeParameters.map { it.symbol }.zip(resultingTypeArguments).toMap(), session
     )
 }
 

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
 import org.jetbrains.kotlin.fir.renderWithType
@@ -31,7 +32,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
         }
         val csBuilder = candidate.system.getBuilder()
         val (substitutor, freshVariables) =
-            createToFreshVariableSubstitutorAndAddInitialConstraints(declaration, csBuilder)
+            createToFreshVariableSubstitutorAndAddInitialConstraints(declaration, csBuilder, context.session)
         candidate.substitutor = substitutor
         candidate.freshVariables = freshVariables
 
@@ -110,14 +111,15 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
 
 private fun createToFreshVariableSubstitutorAndAddInitialConstraints(
     declaration: FirTypeParameterRefsOwner,
-    csBuilder: ConstraintSystemOperation
+    csBuilder: ConstraintSystemOperation,
+    session: FirSession
 ): Pair<ConeSubstitutor, List<ConeTypeVariable>> {
 
     val typeParameters = declaration.typeParameters
 
     val freshTypeVariables = typeParameters.map { ConeTypeParameterBasedTypeVariable(it.symbol) }
 
-    val toFreshVariables = substitutorByMap(freshTypeVariables.associate { it.typeParameterSymbol to it.defaultType })
+    val toFreshVariables = substitutorByMap(freshTypeVariables.associate { it.typeParameterSymbol to it.defaultType }, session)
 
     for (freshVariable in freshTypeVariables) {
         csBuilder.registerVariable(freshVariable)

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
@@ -16,7 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
 import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildNamedArgumentExpression
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
-import org.jetbrains.kotlin.fir.resolve.asForbiddenNamedArgumentsTarget
+import org.jetbrains.kotlin.fir.resolve.getAsForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.resolve.defaultParameterResolver
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.name.Name
@@ -85,7 +86,7 @@ fun BodyResolveComponents.mapArguments(
         }
     }
 
-    val processor = FirCallArgumentsProcessor(function, this, originScope)
+    val processor = FirCallArgumentsProcessor(session, function, this, originScope)
     processor.processArgumentsInParenthesis(argumentsInParenthesis)
     if (externalArgument != null) {
         processor.processExternalArgument(externalArgument)
@@ -96,6 +97,7 @@ fun BodyResolveComponents.mapArguments(
 }
 
 private class FirCallArgumentsProcessor(
+    private val useSiteSession: FirSession,
     private val function: FirFunction<*>,
     private val bodyResolveComponents: BodyResolveComponents,
     private val originScope: FirScope?,
@@ -109,7 +111,7 @@ private class FirCallArgumentsProcessor(
     val result: LinkedHashMap<FirValueParameter, ResolvedCallArgument> = LinkedHashMap(function.valueParameters.size)
 
     val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget? by lazy {
-        function.asForbiddenNamedArgumentsTarget
+        function.getAsForbiddenNamedArgumentsTarget(useSiteSession)
     }
 
     private enum class State {

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

@@ -195,7 +195,7 @@ internal object CheckVisibility : CheckerStage() {
 
         if (declaration is FirConstructor) {
             // TODO: Should be some other form
-            val classSymbol = declaration.returnTypeRef.coneTypeUnsafe<ConeClassLikeType>().lookupTag.toSymbol(declaration.declarationSiteSession)
+            val classSymbol = declaration.returnTypeRef.coneTypeUnsafe<ConeClassLikeType>().lookupTag.toSymbol(context.session)
 
             if (classSymbol is FirRegularClassSymbol) {
                 if (classSymbol.fir.classKind.isSingleton) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -875,7 +875,7 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
             val substitutionFromArguments = typeParameters.zip(qualifiedAccess.typeArguments).map { (typeParameterRef, typeArgument) ->
                 typeParameterRef.symbol to typeArgument.toConeTypeProjection().type
             }.filter { it.second != null }.toMap() as Map<FirTypeParameterSymbol, ConeKotlinType>
-            ConeSubstitutorByMap(substitutionFromArguments)
+            ConeSubstitutorByMap(substitutionFromArguments, components.session)
         } else {
             ConeSubstitutor.Empty
         }

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

@@ -77,7 +77,7 @@ private fun extraLambdaInfo(
             ?: expectedType?.typeArguments?.singleOrNull()?.safeAs<ConeKotlinTypeProjection>()?.type?.takeIf { isFunctionSupertype }
             ?: typeVariable.defaultType
 
-    val nothingType = argument.declarationSiteSession.builtinTypes.nothingType.type
+    val nothingType = session.builtinTypes.nothingType.type
     val parameters = argument.valueParameters.map {
         it.returnTypeRef.coneTypeSafe<ConeKotlinType>() ?: nothingType
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt

@@ -53,7 +53,7 @@ abstract class FirSymbolProvider(val session: FirSession) : FirSessionComponent
 
 fun FirSymbolProvider.getClassDeclaredPropertySymbols(classId: ClassId, name: Name): List<FirVariableSymbol<*>> {
     val classSymbol = getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol ?: return emptyList()
-    val declaredMemberScope = declaredMemberScope(classSymbol.fir)
+    val declaredMemberScope = session.declaredMemberScope(classSymbol.fir)
     val result = mutableListOf<FirVariableSymbol<*>>()
     declaredMemberScope.processPropertiesByName(name, result::add)
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.substitution
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -130,13 +131,13 @@ abstract class AbstractConeSubstitutor : ConeSubstitutor() {
 
 }
 
-fun substitutorByMap(substitution: Map<FirTypeParameterSymbol, ConeKotlinType>): ConeSubstitutor {
+fun substitutorByMap(substitution: Map<FirTypeParameterSymbol, ConeKotlinType>, useSiteSession: FirSession): ConeSubstitutor {
     // If all arguments match parameters, then substitutor isn't needed
     if (substitution.all { (parameterSymbol, argumentType) ->
             (argumentType as? ConeTypeParameterType)?.lookupTag?.typeParameterSymbol == parameterSymbol
         }
     ) return ConeSubstitutor.Empty
-    return ConeSubstitutorByMap(substitution)
+    return ConeSubstitutorByMap(substitution, useSiteSession)
 }
 
 data class ChainedSubstitutor(private val first: ConeSubstitutor, private val second: ConeSubstitutor) : ConeSubstitutor() {
@@ -152,13 +153,15 @@ fun ConeSubstitutor.chain(other: ConeSubstitutor): ConeSubstitutor {
     return ChainedSubstitutor(this, other)
 }
 
-data class ConeSubstitutorByMap(val substitution: Map<FirTypeParameterSymbol, ConeKotlinType>) : AbstractConeSubstitutor() {
+data class ConeSubstitutorByMap(
+    val substitution: Map<FirTypeParameterSymbol, ConeKotlinType>,
+    val useSiteSession: FirSession
+) : AbstractConeSubstitutor() {
     override fun substituteType(type: ConeKotlinType): ConeKotlinType? {
         if (type !is ConeTypeParameterType) return null
         val result = substitution[type.lookupTag.symbol].updateNullabilityIfNeeded(type) ?: return null
-        val session = type.lookupTag.symbol.fir.declarationSiteSession
+        if (type.isUnsafeVarianceType(useSiteSession)) {
-        if (type.isUnsafeVarianceType(session)) {
+            return useSiteSession.inferenceComponents.approximator.approximateToSuperType(
-            return session.inferenceComponents.approximator.approximateToSuperType(
                 result, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference
             ) ?: result
         }

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

@@ -75,11 +75,11 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
                 firClass.addTypeParametersScope()
                 val companionObject = firClass.companionObject
                 if (companionObject != null) {
-                    nestedClassifierScope(companionObject)?.let(scopes::add)
+                    session.nestedClassifierScope(companionObject)?.let(scopes::add)
                 }
             }
 
-            nestedClassifierScope(firClass)?.let(scopes::add)
+            session.nestedClassifierScope(firClass)?.let(scopes::add)
 
             // Note that annotations are still visited here
             // again, although there's no need in it
@@ -100,5 +100,5 @@ fun createSubstitutionForSupertype(superType: ConeLookupTagBasedType, session: F
         it as? ConeKotlinType ?: ConeClassErrorType(ConeSimpleDiagnostic("illegal projection usage", DiagnosticKind.IllegalProjectionUsage))
     }
     val mapping = klass.typeParameters.map { it.symbol }.zip(arguments).toMap()
-    return ConeSubstitutorByMap(mapping)
+    return ConeSubstitutorByMap(mapping, session)
 }

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
@@ -30,11 +29,12 @@ class FirSealedClassInheritorsProcessor(
 ) : FirGlobalResolveProcessor(session, scopeSession) {
     override fun process(files: Collection<FirFile>) {
         val sealedClassInheritorsMap = mutableMapOf<FirRegularClass, MutableList<ClassId>>()
-        files.forEach { it.accept(InheritorsCollector, sealedClassInheritorsMap) }
+        val inheritorsCollector = InheritorsCollector(session)
+        files.forEach { it.accept(inheritorsCollector, sealedClassInheritorsMap) }
         files.forEach { it.transformSingle(InheritorsTransformer(sealedClassInheritorsMap), null) }
     }
 
-    object InheritorsCollector : FirDefaultVisitor<Unit, MutableMap<FirRegularClass, MutableList<ClassId>>>() {
+    class InheritorsCollector(val session: FirSession) : FirDefaultVisitor<Unit, MutableMap<FirRegularClass, MutableList<ClassId>>>() {
         override fun visitElement(element: FirElement, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {}
 
         override fun visitFile(file: FirFile, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {
@@ -48,7 +48,7 @@ class FirSealedClassInheritorsProcessor(
                 data.computeIfAbsent(regularClass) { mutableListOf() }
             }
 
-            val symbolProvider = regularClass.declarationSiteSession.symbolProvider
+            val symbolProvider = session.symbolProvider
 
             for (typeRef in regularClass.superTypeRefs) {
                 val parent = extractClassFromTypeRef(symbolProvider, typeRef).takeIf { it?.modality == Modality.SEALED } ?: continue

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

@@ -390,7 +390,7 @@ abstract class AbstractFirStatusResolveTransformer(
             return
         }
         if (regularClass.resolvePhase > FirResolvePhase.STATUS) return
-        val firProvider = regularClass.declarationSiteSession.firProvider
+        val firProvider = session.firProvider
         val statusComputationStatus = statusComputationSession[regularClass]
         if (!statusComputationStatus.requiresComputation) return
 

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

@@ -160,9 +160,9 @@ private fun createScopesForNestedClasses(
         addIfNotNull(klass.typeParametersScope())
         val companionObjects = klass.declarations.filterIsInstance<FirRegularClass>().filter { it.isCompanion }
         for (companionObject in companionObjects) {
-            addIfNotNull(nestedClassifierScope(companionObject))
+            addIfNotNull(session.nestedClassifierScope(companionObject))
         }
-        addIfNotNull(nestedClassifierScope(klass))
+        addIfNotNull(session.nestedClassifierScope(klass))
     }
 
 fun FirRegularClass.resolveSupertypesInTheAir(session: FirSession): List<FirTypeRef> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt

@@ -43,7 +43,7 @@ class FirPluginAnnotationsResolveTransformer(
     override fun transformFile(file: FirFile, data: Any?): FirFile {
         checkSessionConsistency(file)
         if (!extensionService.hasPredicateBasedExtensions) return file
-        val registeredPluginAnnotations = file.declarationSiteSession.registeredPluginAnnotations
+        val registeredPluginAnnotations = session.registeredPluginAnnotations
         file.replaceResolvePhase(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS)
         val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations)
         if (!newAnnotations.isEmpty) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt

@@ -32,7 +32,7 @@ class KotlinScopeProvider(
         scopeSession: ScopeSession
     ): FirTypeScope {
         return scopeSession.getOrBuild(klass.symbol, USE_SITE) {
-            val declaredScope = declaredMemberScope(klass)
+            val declaredScope = useSiteSession.declaredMemberScope(klass)
             val decoratedDeclaredMemberScope =
                 declaredMemberScopeDecorator(klass, declaredScope, useSiteSession, scopeSession)
 
@@ -58,13 +58,13 @@ class KotlinScopeProvider(
         scopeSession: ScopeSession
     ): FirScope? {
         return when (klass.classKind) {
-            ClassKind.ENUM_CLASS -> FirOnlyCallablesScope(FirStaticScope(declaredMemberScope(klass)))
+            ClassKind.ENUM_CLASS -> FirOnlyCallablesScope(FirStaticScope(useSiteSession.declaredMemberScope(klass)))
             else -> null
         }
     }
 
     override fun getNestedClassifierScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
-        return nestedClassifierScope(klass)
+        return useSiteSession.nestedClassifierScope(klass)
     }
 }
 
@@ -125,7 +125,7 @@ fun ConeKotlinType.scopeForSupertype(
 private fun substitutor(symbol: FirRegularClassSymbol, type: ConeClassLikeType, useSiteSession: FirSession): ConeSubstitutor {
     if (type.typeArguments.isEmpty()) return ConeSubstitutor.Empty
     val originalSubstitution = createSubstitution(symbol.fir.typeParameters, type, useSiteSession)
-    return substitutorByMap(originalSubstitution)
+    return substitutorByMap(originalSubstitution, useSiteSession)
 }
 
 fun FirClass<*>.scopeForSupertype(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractOverrideChecker.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
@@ -22,7 +23,8 @@ abstract class FirAbstractOverrideChecker : FirOverrideChecker {
 
 fun buildSubstitutorForOverridesCheck(
     overrideCandidate: FirCallableMemberDeclaration<*>,
-    baseDeclaration: FirCallableMemberDeclaration<*>
+    baseDeclaration: FirCallableMemberDeclaration<*>,
+    useSiteSession: FirSession
 ): ConeSubstitutor? {
     if (overrideCandidate.typeParameters.size != baseDeclaration.typeParameters.size) return null
 
@@ -30,5 +32,5 @@ fun buildSubstitutorForOverridesCheck(
     val types = baseDeclaration.typeParameters.map {
         ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false)
     }
-    return substitutorByMap(overrideCandidate.typeParameters.map { it.symbol }.zip(types).toMap())
+    return substitutorByMap(overrideCandidate.typeParameters.map { it.symbol }.zip(types).toMap(), useSiteSession)
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -16,6 +17,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name
 
 class FirClassDeclaredMemberScope(
+    val useSiteSession: FirSession,
     klass: FirClass<*>,
     useLazyNestedClassifierScope: Boolean = false,
     existingNames: List<Name>? = null,
@@ -24,7 +26,7 @@ class FirClassDeclaredMemberScope(
     private val nestedClassifierScope: FirScope? = if (useLazyNestedClassifierScope) {
         lazyNestedClassifierScope(klass.symbol.classId, existingNames!!, symbolProvider!!)
     } else {
-        nestedClassifierScope(klass)
+        useSiteSession.nestedClassifierScope(klass)
     }
 
     private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
@@ -65,7 +67,7 @@ class FirClassDeclaredMemberScope(
         val symbols = callablesIndex[name] ?: emptyList()
         for (symbol in symbols) {
             if (symbol is D) {
-                symbol.ensureResolvedForCalls(symbol.fir.declarationSiteSession)
+                symbol.ensureResolvedForCalls(useSiteSession)
                 processor(symbol)
             }
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt

@@ -204,6 +204,7 @@ class FirClassSubstitutionScope(
 
     private fun createSubstitutedData(member: FirCallableMemberDeclaration<*>): SubstitutedData {
         val (newTypeParameters, substitutor) = FirFakeOverrideGenerator.createNewTypeParametersAndSubstitutor(
+            session,
             member as FirTypeParameterRefsOwner,
             substitutor,
             forceTypeParametersRecreation = dispatchReceiverTypeForSubstitutedMembers.lookupTag != member.dispatchReceiverClassOrNull()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
 import org.jetbrains.kotlin.fir.declarations.FirClass
@@ -17,7 +18,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.getOrPutNullable
 
 @ThreadSafeMutableState
-class FirDeclaredMemberScopeProvider : FirSessionComponent {
+class FirDeclaredMemberScopeProvider(val useSiteSession: FirSession) : FirSessionComponent {
     private val declaredMemberCache = mutableMapOf<FirClass<*>, FirClassDeclaredMemberScope>()
     private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope?>()
 
@@ -46,39 +47,33 @@ class FirDeclaredMemberScopeProvider : FirSessionComponent {
         symbolProvider: FirSymbolProvider?
     ): FirClassDeclaredMemberScope {
         return declaredMemberCache.getOrPut(klass) {
-            FirClassDeclaredMemberScope(klass, useLazyNestedClassifierScope, existingNames, symbolProvider)
+            FirClassDeclaredMemberScope(useSiteSession, klass, useLazyNestedClassifierScope, existingNames, symbolProvider)
         }
     }
 
     fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope? {
         return nestedClassifierCache.getOrPutNullable(klass) {
-            FirNestedClassifierScope(klass).takeUnless { it.isEmpty() }
+            FirNestedClassifierScope(klass, useSiteSession).takeUnless { it.isEmpty() }
         }
     }
 }
 
-fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
+fun FirSession.declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
-    return klass
+    return declaredMemberScopeProvider
-        .declarationSiteSession
-        .declaredMemberScopeProvider
         .declaredMemberScope(klass, useLazyNestedClassifierScope = false, existingNames = null, symbolProvider = null)
 }
 
-fun declaredMemberScopeWithLazyNestedScope(
+fun FirSession.declaredMemberScopeWithLazyNestedScope(
     klass: FirClass<*>,
     existingNames: List<Name>,
     symbolProvider: FirSymbolProvider
 ): FirScope {
-    return klass
+    return declaredMemberScopeProvider
-        .declarationSiteSession
-        .declaredMemberScopeProvider
         .declaredMemberScope(klass, useLazyNestedClassifierScope = true, existingNames = existingNames, symbolProvider = symbolProvider)
 }
 
-fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope? {
+fun FirSession.nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope? {
-    return klass
+    return declaredMemberScopeProvider
-        .declarationSiteSession
-        .declaredMemberScopeProvider
         .nestedClassifierScope(klass)
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt

@@ -111,7 +111,7 @@ object FirFakeOverrideGenerator {
             dispatchReceiverType = newDispatchReceiverType
             attributes = baseFunction.attributes.copy()
             typeParameters += configureAnnotationsTypeParametersAndSignature(
-                baseFunction, newParameterTypes, newTypeParameters, newReceiverType, newReturnType, fakeOverrideSubstitution
+                session, baseFunction, newParameterTypes, newTypeParameters, newReceiverType, newReturnType, fakeOverrideSubstitution
             ).filterIsInstance<FirTypeParameter>()
         }
     }
@@ -137,7 +137,7 @@ object FirFakeOverrideGenerator {
             symbol = fakeOverrideSymbol
 
             typeParameters += configureAnnotationsTypeParametersAndSignature(
-                baseConstructor, newParameterTypes, newTypeParameters, newReceiverType = null, newReturnType, fakeOverrideSubstitution
+                session, baseConstructor, newParameterTypes, newTypeParameters, newReceiverType = null, newReturnType, fakeOverrideSubstitution
             )
 
             dispatchReceiverType = newDispatchReceiverType
@@ -151,6 +151,7 @@ object FirFakeOverrideGenerator {
     }
 
     private fun FirFunctionBuilder.configureAnnotationsTypeParametersAndSignature(
+        useSiteSession: FirSession,
         baseFunction: FirFunction<*>,
         newParameterTypes: List<ConeKotlinType?>?,
         newTypeParameters: List<FirTypeParameterRef>?,
@@ -171,7 +172,7 @@ object FirFakeOverrideGenerator {
             }
             newTypeParameters == null -> {
                 val (copiedTypeParameters, substitutor) = createNewTypeParametersAndSubstitutor(
-                    baseFunction, ConeSubstitutor.Empty
+                    useSiteSession, baseFunction, ConeSubstitutor.Empty
                 )
                 val copiedParameterTypes = baseFunction.valueParameters.map {
                     substitutor.substituteOrNull(it.returnTypeRef.coneType)
@@ -294,6 +295,7 @@ object FirFakeOverrideGenerator {
             dispatchReceiverType = newDispatchReceiverType
             attributes = baseProperty.attributes.copy()
             typeParameters += configureAnnotationsTypeParametersAndSignature(
+                session,
                 baseProperty,
                 newTypeParameters,
                 newReceiverType,
@@ -304,6 +306,7 @@ object FirFakeOverrideGenerator {
     }
 
     private fun FirPropertyBuilder.configureAnnotationsTypeParametersAndSignature(
+        useSiteSession: FirSession,
         baseProperty: FirProperty,
         newTypeParameters: List<FirTypeParameter>?,
         newReceiverType: ConeKotlinType?,
@@ -317,7 +320,7 @@ object FirFakeOverrideGenerator {
             }
             newTypeParameters == null -> {
                 val (copiedTypeParameters, substitutor) = createNewTypeParametersAndSubstitutor(
-                    baseProperty, ConeSubstitutor.Empty
+                    useSiteSession, baseProperty, ConeSubstitutor.Empty
                 )
                 val (copiedReceiverType, possibleReturnType) = substituteReceiverAndReturnType(
                     baseProperty, newReceiverType, newReturnType, substitutor
@@ -456,6 +459,7 @@ object FirFakeOverrideGenerator {
 
     // Returns a list of type parameters, and a substitutor that should be used for all other types
     fun createNewTypeParametersAndSubstitutor(
+        useSiteSession: FirSession,
         member: FirTypeParameterRefsOwner,
         substitutor: ConeSubstitutor,
         forceTypeParametersRecreation: Boolean = true
@@ -481,7 +485,7 @@ object FirFakeOverrideGenerator {
             else null
         }.toMap()
 
-        val additionalSubstitutor = substitutorByMap(substitutionMapForNewParameters)
+        val additionalSubstitutor = substitutorByMap(substitutionMapForNewParameters, useSiteSession)
 
         var wereChangesInTypeParameters = forceTypeParametersRecreation
         for ((newTypeParameter, oldTypeParameter) in newTypeParameters.zip(member.typeParameters)) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
@@ -19,7 +20,7 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.name.Name
 
-class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope(), FirContainingNamesAwareScope {
+class FirNestedClassifierScope(val klass: FirClass<*>, val useSiteSession: FirSession) : FirScope(), FirContainingNamesAwareScope {
     private val classIndex: Map<Name, FirRegularClassSymbol> = run {
         val result = mutableMapOf<Name, FirRegularClassSymbol>()
         for (declaration in klass.declarations) {
@@ -40,7 +41,7 @@ class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope(), FirContaini
         val substitution = klass.typeParameters.associate {
             it.symbol to it.toConeType()
         }
-        processor(matchedClass, ConeSubstitutorByMap(substitution))
+        processor(matchedClass, ConeSubstitutorByMap(substitution, useSiteSession))
     }
 
     override fun getClassifierNames(): Set<Name> = classIndex.keys

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt

@@ -97,7 +97,7 @@ class FirStandardOverrideChecker(private val session: FirSession) : FirAbstractO
         overrideCandidate: FirCallableMemberDeclaration<*>,
         baseDeclaration: FirCallableMemberDeclaration<*>
     ): ConeSubstitutor? {
-        val substitutor = buildSubstitutorForOverridesCheck(overrideCandidate, baseDeclaration) ?: return null
+        val substitutor = buildSubstitutorForOverridesCheck(overrideCandidate, baseDeclaration, session) ?: return null
         if (
             overrideCandidate.typeParameters.isNotEmpty() &&
             overrideCandidate.typeParameters.zip(baseDeclaration.typeParameters).any { (override, base) ->

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt

@@ -396,7 +396,7 @@ class FirTypeIntersectionScope private constructor(
         val bFir = b.fir
         if (aFir !is FirCallableMemberDeclaration<*> || bFir !is FirCallableMemberDeclaration<*>) return false
 
-        val substitutor = buildSubstitutorForOverridesCheck(aFir, bFir) ?: return false
+        val substitutor = buildSubstitutorForOverridesCheck(aFir, bFir, session) ?: return false
         // NB: these lines throw CCE in modularized tests when changed to just .coneType (FirImplicitTypeRef)
         val aReturnType = a.fir.returnTypeRef.coneTypeSafe<ConeKotlinType>()?.let(substitutor::substituteOrSelf) ?: return false
         val bReturnType = b.fir.returnTypeRef.coneTypeSafe<ConeKotlinType>() ?: return false

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -565,7 +565,7 @@ class ConeTypeCheckerContext(
                     parameter.symbol to ((argument as? ConeKotlinTypeProjection)?.type
                         ?: session.builtinTypes.nullableAnyType.type)//StandardClassIds.Any(session.firSymbolProvider).constructType(emptyArray(), isNullable = true))
                 }
-            substitutorByMap(substitution)
+            substitutorByMap(substitution, session)
         } else {
             ConeSubstitutor.Empty
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt

@@ -344,9 +344,10 @@ private fun ConeTypeContext.captureArguments(type: ConeKotlinType, status: Captu
         ConeCapturedType(status, lowerType, argument, typeConstructor.getParameter(index))
     }
 
-    val substitutor = substitutorByMap((0 until argumentsCount).map { index ->
+    val substitution = (0 until argumentsCount).map { index ->
         (typeConstructor.getParameter(index) as ConeTypeParameterLookupTag).symbol to (newArguments[index] as ConeKotlinType)
-    }.toMap())
+    }.toMap()
+    val substitutor = substitutorByMap(substitution, session)
 
     for (index in 0 until argumentsCount) {
         val oldArgument = type.typeArguments[index]

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt

@@ -91,7 +91,7 @@ internal class KtFirScopeProvider(
     override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtDeclaredMemberScope = withValidityAssertion {
         declaredMemberScopeCache.getOrPut(classSymbol) {
             val firScope = classSymbol.withFirForScope {
-                declaredMemberScope(it)
+                analysisSession.rootModuleSession.declaredMemberScope(it)
             } ?: return@getOrPut KtFirEmptyMemberScope(classSymbol)
 
             firScopeStorage.register(firScope)