[fir low level, refactoring] rename LLFirModuleResolveState -> LLFirResolveSession

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbolProvider
 import org.jetbrains.kotlin.analysis.api.fir.utils.threadLocal
 import org.jetbrains.kotlin.analysis.api.impl.base.components.KtAnalysisScopeProviderImpl
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.fir.FirSession
@@ -30,13 +30,13 @@ import org.jetbrains.kotlin.psi.KtFile
 internal class KtFirAnalysisSession
 private constructor(
     private val project: Project,
-    val firResolveState: LLFirModuleResolveState,
+    val firResolveSession: LLFirResolveSession,
     internal val firSymbolBuilder: KtSymbolByFirBuilder,
     token: ValidityToken,
     private val mode: AnalysisSessionMode,
 ) : KtAnalysisSession(token) {
 
-    override val useSiteModule: KtModule get() = firResolveState.useSiteKtModule
+    override val useSiteModule: KtModule get() = firResolveSession.useSiteKtModule
 
     private enum class AnalysisSessionMode {
         REGULAR,
@@ -55,19 +55,19 @@ private constructor(
 
     override val samResolverImpl = KtFirSamResolver(this, token)
 
-    override val scopeProviderImpl by threadLocal { KtFirScopeProvider(this, firSymbolBuilder, project, firResolveState, token) }
+    override val scopeProviderImpl by threadLocal { KtFirScopeProvider(this, firSymbolBuilder, project, firResolveSession, token) }
 
     override val symbolProviderImpl =
-        KtFirSymbolProvider(this, firResolveState.useSiteFirSession.symbolProvider, firResolveState, firSymbolBuilder, token)
+        KtFirSymbolProvider(this, firResolveSession.useSiteFirSession.symbolProvider, firResolveSession, firSymbolBuilder, token)
 
     override val completionCandidateCheckerImpl = KtFirCompletionCandidateChecker(this, token)
 
     override val symbolDeclarationOverridesProviderImpl =
         KtFirSymbolDeclarationOverridesProvider(this, token)
 
-    override val referenceShortenerImpl = KtFirReferenceShortener(this, token, firResolveState)
+    override val referenceShortenerImpl = KtFirReferenceShortener(this, token, firResolveSession)
 
-    override val importOptimizerImpl: KtImportOptimizer = KtFirImportOptimizer(token, firResolveState)
+    override val importOptimizerImpl: KtImportOptimizer = KtFirImportOptimizer(token, firResolveSession)
 
     override val symbolDeclarationRendererProviderImpl: KtSymbolDeclarationRendererProvider =
         KtFirSymbolDeclarationRendererProvider(this, token)
@@ -104,42 +104,42 @@ private constructor(
         }
         require(!elementToReanalyze.isPhysical) { "Depended context should be build only for non-physical elements" }
 
-        val contextResolveState = LowLevelFirApiFacadeForResolveOnAir.getResolveStateForDependentCopy(
-            originalState = firResolveState,
+        val contextFirResolveSession = LowLevelFirApiFacadeForResolveOnAir.getFirResolveSessionForDependentCopy(
+            originalFirResolveSession = firResolveSession,
             originalKtFile = originalKtFile,
             elementToAnalyze = elementToReanalyze
         )
 
         return KtFirAnalysisSession(
             project,
-            contextResolveState,
-            firSymbolBuilder.createReadOnlyCopy(contextResolveState),
+            contextFirResolveSession,
+            firSymbolBuilder.createReadOnlyCopy(contextFirResolveSession),
             token,
             AnalysisSessionMode.DEPENDENT_COPY
         )
     }
 
-    val useSiteSession: FirSession get() = firResolveState.useSiteFirSession
+    val useSiteSession: FirSession get() = firResolveSession.useSiteFirSession
     val firSymbolProvider: FirSymbolProvider get() = useSiteSession.symbolProvider
     val targetPlatform: TargetPlatform get() = useSiteSession.moduleData.platform
 
-    fun getScopeSessionFor(session: FirSession): ScopeSession = firResolveState.getScopeSessionFor(session)
+    fun getScopeSessionFor(session: FirSession): ScopeSession = firResolveSession.getScopeSessionFor(session)
 
     companion object {
         @InvalidWayOfUsingAnalysisSession
-        internal fun createAnalysisSessionByResolveState(
-            firResolveState: LLFirModuleResolveState,
+        internal fun createAnalysisSessionByFirResolveSession(
+            firResolveSession: LLFirResolveSession,
             token: ValidityToken,
         ): KtFirAnalysisSession {
-            val project = firResolveState.project
+            val project = firResolveSession.project
             val firSymbolBuilder = KtSymbolByFirBuilder(
-                firResolveState,
+                firResolveSession,
                 project,
                 token
             )
             return KtFirAnalysisSession(
                 project,
-                firResolveState,
+                firResolveSession,
                 firSymbolBuilder,
                 token,
                 AnalysisSessionMode.REGULAR,

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt

@@ -8,34 +8,33 @@ package org.jetbrains.kotlin.analysis.api.fir
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
 import org.jetbrains.kotlin.psi.KtElement
 
 @OptIn(InvalidWayOfUsingAnalysisSession::class)
-class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<LLFirModuleResolveState>(project) {
-    override fun getResolveState(contextElement: KtElement): LLFirModuleResolveState {
-        return contextElement.getResolveState()
+class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<LLFirResolveSession>(project) {
+    override fun getFirResolveSession(contextElement: KtElement): LLFirResolveSession {
+        return contextElement.getFirResolveSession()
     }
 
-    override fun getResolveState(contextSymbol: KtSymbol): LLFirModuleResolveState {
+    override fun getFirResolveSession(contextSymbol: KtSymbol): LLFirResolveSession {
         return when (contextSymbol) {
-            is KtFirSymbol<*> -> contextSymbol.resolveState
+            is KtFirSymbol<*> -> contextSymbol.firResolveSession
             else -> error("Invalid symbol ${contextSymbol::class}")
         }
     }
 
     override fun createAnalysisSession(
-        resolveState: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
         validityToken: ValidityToken,
     ): KtAnalysisSession {
         @Suppress("DEPRECATION")
-        return KtFirAnalysisSession.createAnalysisSessionByResolveState(resolveState, validityToken)
+        return KtFirAnalysisSession.createAnalysisSessionByFirResolveSession(firResolveSession, validityToken)
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.providers.createPackageProvider
 import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.fir.*
@@ -53,7 +53,7 @@ import kotlin.contracts.contract
  */
 internal class KtSymbolByFirBuilder private constructor(
     private val project: Project,
-    resolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     val withReadOnlyCaching: Boolean,
     private val symbolsCache: BuilderCache<FirBasedSymbol<*>, KtSymbol>,
@@ -61,10 +61,10 @@ internal class KtSymbolByFirBuilder private constructor(
     private val filesCache: BuilderCache<FirFileSymbol, KtFileSymbol>,
     private val backingFieldCache: BuilderCache<FirBackingFieldSymbol, KtBackingFieldSymbol>,
 ) : ValidityTokenOwner {
-    private val resolveState by weakRef(resolveState)
+    private val firResolveSession by weakRef(firResolveSession)
 
-    private val firProvider get() = resolveState.useSiteFirSession.symbolProvider
-    val rootSession: FirSession = resolveState.useSiteFirSession
+    private val firProvider get() = firResolveSession.useSiteFirSession.symbolProvider
+    val rootSession: FirSession = firResolveSession.useSiteFirSession
 
     val classifierBuilder = ClassifierSymbolBuilder()
     val functionLikeBuilder = FunctionLikeSymbolBuilder()
@@ -74,13 +74,13 @@ internal class KtSymbolByFirBuilder private constructor(
     val typeBuilder = TypeBuilder()
 
     constructor(
-        resolveState: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
         project: Project,
         token: ValidityToken
     ) : this(
         project = project,
         token = token,
-        resolveState = resolveState,
+        firResolveSession = firResolveSession,
         withReadOnlyCaching = false,
         symbolsCache = BuilderCache(),
         extensionReceiverSymbolsCache = BuilderCache(),
@@ -88,12 +88,12 @@ internal class KtSymbolByFirBuilder private constructor(
         filesCache = BuilderCache(),
     )
 
-    fun createReadOnlyCopy(newResolveState: LLFirModuleResolveState): KtSymbolByFirBuilder {
+    fun createReadOnlyCopy(newFirResolveSession: LLFirResolveSession): KtSymbolByFirBuilder {
         check(!withReadOnlyCaching) { "Cannot create readOnly KtSymbolByFirBuilder from a readonly one" }
         return KtSymbolByFirBuilder(
             project,
             token = token,
-            resolveState = newResolveState,
+            firResolveSession = newFirResolveSession,
             withReadOnlyCaching = true,
             symbolsCache = symbolsCache.createReadOnlyCopy(),
             extensionReceiverSymbolsCache = extensionReceiverSymbolsCache.createReadOnlyCopy(),
@@ -118,9 +118,9 @@ internal class KtSymbolByFirBuilder private constructor(
     }
 
     fun buildEnumEntrySymbol(firSymbol: FirEnumEntrySymbol) =
-        symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, resolveState, token, this) }
+        symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, firResolveSession, token, this) }
 
-    fun buildFileSymbol(firSymbol: FirFileSymbol) = filesCache.cache(firSymbol) { KtFirFileSymbol(firSymbol, resolveState, token) }
+    fun buildFileSymbol(firSymbol: FirFileSymbol) = filesCache.cache(firSymbol) { KtFirFileSymbol(firSymbol, firResolveSession, token) }
 
     private val packageProvider = project.createPackageProvider(GlobalSearchScope.allScope(project))//todo scope
 
@@ -165,19 +165,19 @@ internal class KtSymbolByFirBuilder private constructor(
         }
 
         fun buildNamedClassOrObjectSymbol(symbol: FirRegularClassSymbol): KtFirNamedClassOrObjectSymbol {
-            return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol {
-            return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildTypeAliasSymbol(symbol: FirTypeAliasSymbol): KtFirTypeAliasSymbol {
-            return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildTypeParameterSymbol(firSymbol: FirTypeParameterSymbol): KtFirTypeParameterSymbol {
-            return symbolsCache.cache(firSymbol) { KtFirTypeParameterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirTypeParameterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildTypeParameterSymbolByLookupTag(lookupTag: ConeTypeParameterLookupTag): KtTypeParameterSymbol? {
@@ -228,7 +228,7 @@ internal class KtSymbolByFirBuilder private constructor(
             }
 
             check(firSymbol.origin != FirDeclarationOrigin.SamConstructor)
-            return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildFunctionSignature(firSymbol: FirNamedFunctionSymbol): KtFunctionLikeSignature<KtFirFunctionSymbol> {
@@ -249,27 +249,27 @@ internal class KtSymbolByFirBuilder private constructor(
         }
 
         fun buildAnonymousFunctionSymbol(firSymbol: FirAnonymousFunctionSymbol): KtFirAnonymousFunctionSymbol {
-            return symbolsCache.cache(firSymbol) { KtFirAnonymousFunctionSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirAnonymousFunctionSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildConstructorSymbol(firSymbol: FirConstructorSymbol): KtFirConstructorSymbol {
             val originalFirSymbol = firSymbol.fir.originalConstructorIfTypeAlias?.symbol ?: firSymbol
             return symbolsCache.cache(originalFirSymbol) {
-                KtFirConstructorSymbol(originalFirSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirConstructorSymbol(originalFirSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
 
         fun buildSamConstructorSymbol(firSymbol: FirNamedFunctionSymbol): KtFirSamConstructorSymbol {
             check(firSymbol.origin == FirDeclarationOrigin.SamConstructor)
-            return symbolsCache.cache(firSymbol) { KtFirSamConstructorSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirSamConstructorSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildPropertyAccessorSymbol(firSymbol: FirPropertyAccessorSymbol): KtFunctionLikeSymbol {
             return symbolsCache.cache(firSymbol) {
                 if (firSymbol.isGetter) {
-                    KtFirPropertyGetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                    KtFirPropertyGetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
                 } else {
-                    KtFirPropertySetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                    KtFirPropertySetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
                 }
             }
         }
@@ -314,7 +314,7 @@ internal class KtSymbolByFirBuilder private constructor(
             }
 
             return symbolsCache.cache(firSymbol) {
-                KtFirKotlinPropertySymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirKotlinPropertySymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
 
@@ -330,31 +330,31 @@ internal class KtSymbolByFirBuilder private constructor(
         fun buildLocalVariableSymbol(firSymbol: FirPropertySymbol): KtFirLocalVariableSymbol {
             checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(firSymbol, firSymbol.isLocal)
             return symbolsCache.cache(firSymbol) {
-                KtFirLocalVariableSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirLocalVariableSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
 
         fun buildSyntheticJavaPropertySymbol(firSymbol: FirSyntheticPropertySymbol): KtFirSyntheticJavaPropertySymbol {
             return symbolsCache.cache(firSymbol) {
-                KtFirSyntheticJavaPropertySymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirSyntheticJavaPropertySymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
 
         fun buildValueParameterSymbol(firSymbol: FirValueParameterSymbol): KtValueParameterSymbol {
             return symbolsCache.cache(firSymbol) {
-                KtFirValueParameterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirValueParameterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
 
 
         fun buildFieldSymbol(firSymbol: FirFieldSymbol): KtFirJavaFieldSymbol {
             checkRequirementForBuildingSymbol<KtFirJavaFieldSymbol>(firSymbol, firSymbol.fir.isJavaFieldOrSubstitutionOverrideOfJavaField())
-            return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildBackingFieldSymbol(firSymbol: FirBackingFieldSymbol): KtFirBackingFieldSymbol {
             return backingFieldCache.cache(firSymbol) {
-                KtFirBackingFieldSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirBackingFieldSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
 
@@ -400,25 +400,25 @@ internal class KtSymbolByFirBuilder private constructor(
 
         fun buildGetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertyGetterSymbol {
             checkRequirementForBuildingSymbol<KtFirPropertyGetterSymbol>(firSymbol, firSymbol.isGetter)
-            return symbolsCache.cache(firSymbol) { KtFirPropertyGetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirPropertyGetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildSetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertySetterSymbol {
             checkRequirementForBuildingSymbol<KtFirPropertySetterSymbol>(firSymbol, firSymbol.isSetter)
-            return symbolsCache.cache(firSymbol) { KtFirPropertySetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirPropertySetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildExtensionReceiverSymbol(firCallableSymbol: FirCallableSymbol<*>): KtReceiverParameterSymbol? {
             if (firCallableSymbol.fir.receiverTypeRef == null) return null
             return extensionReceiverSymbolsCache.cache(firCallableSymbol) {
-                KtFirReceiverParameterSymbol(firCallableSymbol, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirReceiverParameterSymbol(firCallableSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
             }
         }
     }
 
     inner class AnonymousInitializerBuilder {
         fun buildClassInitializer(firSymbol: FirAnonymousInitializerSymbol): KtClassInitializerSymbol {
-            return symbolsCache.cache(firSymbol) { KtFirClassInitializerSymbol(firSymbol, resolveState, token) }
+            return symbolsCache.cache(firSymbol) { KtFirClassInitializerSymbol(firSymbol, firResolveSession, token) }
         }
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirAnalysisSessionComponent.kt

@@ -39,10 +39,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 internal interface KtFirAnalysisSessionComponent {
     val analysisSession: KtFirAnalysisSession
 
-    val rootModuleSession: FirSession get() = analysisSession.firResolveState.useSiteFirSession
+    val rootModuleSession: FirSession get() = analysisSession.firResolveSession.useSiteFirSession
     val typeContext: ConeInferenceContext get() = rootModuleSession.typeContext
     val firSymbolBuilder get() = analysisSession.firSymbolBuilder
-    val firResolveState get() = analysisSession.firResolveState
+    val firResolveSession get() = analysisSession.firResolveSession
 
     fun ConeKotlinType.asKtType() = analysisSession.firSymbolBuilder.typeBuilder.buildKtType(this)
 
@@ -76,7 +76,7 @@ internal interface KtFirAnalysisSessionComponent {
 
     fun createTypeCheckerContext(): TypeCheckerState {
         // TODO use correct session here,
-        return analysisSession.firResolveState.useSiteFirSession.typeContext.newTypeCheckerState(
+        return analysisSession.firResolveSession.useSiteFirSession.typeContext.newTypeCheckerState(
             errorTypesEqualToAnything = true,
             stubTypesEqualToAnything = true
         )

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt

@@ -110,7 +110,7 @@ internal class KtFirCallResolver(
             ?: containingBinaryExpressionForLhs
             ?: containingUnaryExpressionForIncOrDec
             ?: psi
-        val fir = psiToResolve.getOrBuildFir(analysisSession.firResolveState) ?: return emptyList()
+        val fir = psiToResolve.getOrBuildFir(analysisSession.firResolveSession) ?: return emptyList()
         return fir.getCallInfo(
             psiToResolve,
             psiToResolve == containingCallExpressionForCalleeExpression,
@@ -225,7 +225,7 @@ internal class KtFirCallResolver(
         val lhs = deparenthesize(this)
         val binaryExpression = parentOfType<KtBinaryExpression>() ?: return null
         if (deparenthesize(binaryExpression.left) != lhs || binaryExpression.operationToken !in KtTokens.ALL_ASSIGNMENTS) return null
-        val firBinaryExpression = binaryExpression.getOrBuildFir(analysisSession.firResolveState)
+        val firBinaryExpression = binaryExpression.getOrBuildFir(analysisSession.firResolveSession)
         if (firBinaryExpression is FirFunctionCall) {
             if (firBinaryExpression.origin == FirFunctionCallOrigin.Operator &&
                 firBinaryExpression.calleeReference.name in OperatorNameConventions.ASSIGNMENT_OPERATIONS
@@ -772,7 +772,7 @@ internal class KtFirCallResolver(
 
         val calleeName = originalFunctionCall.calleeOrCandidateName ?: return emptyList()
         val candidates = AllCandidatesResolver(analysisSession.useSiteSession).getAllCandidates(
-            analysisSession.firResolveState,
+            analysisSession.firResolveSession,
             originalFunctionCall,
             calleeName,
             psi

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt

@@ -30,7 +30,7 @@ internal class KtFirCompileTimeConstantProvider(
         expression: KtExpression,
         mode: KtConstantEvaluationMode,
     ): KtConstantValue? = withValidityAssertion {
-        evaluateFir(expression.getOrBuildFir(firResolveState), expression, mode)
+        evaluateFir(expression.getOrBuildFir(firResolveSession), expression, mode)
     }
 
     private fun evaluateFir(

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt

@@ -60,9 +60,9 @@ internal class KtFirCompletionCandidateChecker(
         nameExpression: KtSimpleNameExpression,
         possibleExplicitReceiver: KtExpression?,
     ): KtExtensionApplicabilityResult {
-        val file = originalFile.getOrBuildFirFile(firResolveState)
+        val file = originalFile.getOrBuildFirFile(firResolveSession)
         val explicitReceiverExpression = possibleExplicitReceiver?.getMatchingFirExpressionForCallReceiver()
-        val resolver = SingleCandidateResolver(firResolveState.useSiteFirSession, file)
+        val resolver = SingleCandidateResolver(firResolveSession.useSiteFirSession, file)
         val implicitReceivers = getImplicitReceivers(originalFile, nameExpression)
         for (implicitReceiverValue in implicitReceivers) {
             val resolutionParameters = ResolutionParameters(
@@ -90,7 +90,7 @@ internal class KtFirCompletionCandidateChecker(
         originalFile: KtFile,
         fakeNameExpression: KtSimpleNameExpression
     ): Sequence<ImplicitReceiverValue<*>?> {
-        val towerDataContext = analysisSession.firResolveState.getTowerContextProvider(originalFile)
+        val towerDataContext = analysisSession.firResolveSession.getTowerContextProvider(originalFile)
             .getClosestAvailableParentContext(fakeNameExpression)
             ?: error("Cannot find enclosing declaration for ${fakeNameExpression.getElementTextInContext()}")
 
@@ -110,9 +110,9 @@ internal class KtFirCompletionCandidateChecker(
      */
     private fun KtExpression.getMatchingFirExpressionForCallReceiver(): FirExpression {
         val psiWholeCall = this.getQualifiedExpressionForReceiver()
-        if (psiWholeCall !is KtSafeQualifiedExpression) return this.getOrBuildFirOfType<FirExpression>(firResolveState)
+        if (psiWholeCall !is KtSafeQualifiedExpression) return this.getOrBuildFirOfType<FirExpression>(firResolveSession)
 
-        val firSafeCall = psiWholeCall.getOrBuildFirOfType<FirSafeCallExpression>(firResolveState)
+        val firSafeCall = psiWholeCall.getOrBuildFirOfType<FirSafeCallExpression>(firResolveSession)
         return firSafeCall.checkedSubjectRef.value
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirDiagnosticProvider.kt

@@ -26,11 +26,11 @@ internal class KtFirDiagnosticProvider(
         element: KtElement,
         filter: KtDiagnosticCheckerFilter
     ): Collection<KtDiagnosticWithPsi<*>> = withValidityAssertion {
-        element.getDiagnostics(firResolveState, filter.asLLFilter()).map { it.asKtDiagnostic() }
+        element.getDiagnostics(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
     }
 
     override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> =
-        ktFile.collectDiagnosticsForFile(firResolveState, filter.asLLFilter()).map { it.asKtDiagnostic() }
+        ktFile.collectDiagnosticsForFile(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
 
 
     private fun KtDiagnosticCheckerFilter.asLLFilter() = when (this) {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionInfoProvider.kt

@@ -23,14 +23,14 @@ internal class KtFirExpressionInfoProvider(
     override val token: ValidityToken,
 ) : KtExpressionInfoProvider(), KtFirAnalysisSessionComponent {
     override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? {
-        val fir = returnExpression.getOrBuildFirSafe<FirReturnExpression>(firResolveState) ?: return null
+        val fir = returnExpression.getOrBuildFirSafe<FirReturnExpression>(firResolveSession) ?: return null
         val firTargetSymbol = fir.target.labeledElement
         if (firTargetSymbol is FirErrorFunction) return null
         return firSymbolBuilder.callableBuilder.buildCallableSymbol(firTargetSymbol.symbol)
     }
 
     override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> {
-        val firWhenExpression = whenExpression.getOrBuildFirSafe<FirWhenExpression>(analysisSession.firResolveState) ?: return emptyList()
-        return FirWhenExhaustivenessTransformer.computeAllMissingCases(analysisSession.firResolveState.useSiteFirSession, firWhenExpression)
+        val firWhenExpression = whenExpression.getOrBuildFirSafe<FirWhenExpression>(analysisSession.firResolveSession) ?: return emptyList()
+        return FirWhenExhaustivenessTransformer.computeAllMissingCases(analysisSession.firResolveSession.useSiteFirSession, firWhenExpression)
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt

@@ -38,7 +38,7 @@ internal class KtFirExpressionTypeProvider(
 ) : KtExpressionTypeProvider(), KtFirAnalysisSessionComponent {
 
     override fun getKtExpressionType(expression: KtExpression): KtType? = withValidityAssertion {
-        when (val fir = expression.unwrap().getOrBuildFir(firResolveState)) {
+        when (val fir = expression.unwrap().getOrBuildFir(firResolveSession)) {
             is FirFunctionCall -> {
                 getReturnTypeForArrayStyleAssignmentTarget(expression, fir)
                     ?: fir.typeRef.coneType.asKtType()
@@ -95,12 +95,12 @@ internal class KtFirExpressionTypeProvider(
     }
 
     override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion {
-        val firDeclaration = declaration.getOrBuildFirOfType<FirCallableDeclaration>(firResolveState)
+        val firDeclaration = declaration.getOrBuildFirOfType<FirCallableDeclaration>(firResolveSession)
         firDeclaration.returnTypeRef.coneType.asKtType()
     }
 
     override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType = withValidityAssertion {
-        val firFunction = declaration.getOrBuildFirOfType<FirFunction>(firResolveState)
+        val firFunction = declaration.getOrBuildFirOfType<FirFunction>(firResolveSession)
         firFunction.constructFunctionalType(firFunction.isSuspend).asKtType()
     }
 
@@ -127,7 +127,7 @@ internal class KtFirExpressionTypeProvider(
 
     private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? {
         val (ktCallExpression, argumentExpression) = expression.getFunctionCallAsWithThisAsParameter() ?: return null
-        val firCall = ktCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveState) ?: return null
+        val firCall = ktCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return null
 
         val callee = (firCall.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol
         if (callee?.fir?.origin == FirDeclarationOrigin.SamConstructor) {
@@ -161,7 +161,7 @@ internal class KtFirExpressionTypeProvider(
     private fun getExpectedTypeOfInfixFunctionParameter(expression: PsiElement): KtType? {
         val infixCallExpression =
             expression.unwrapQualified<KtBinaryExpression> { binaryExpr, expr -> binaryExpr.right == expr } ?: return null
-        val firCall = infixCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveState) ?: return null
+        val firCall = infixCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return null
 
         // There is only one parameter for infix functions; get its type
         val arguments = firCall.argumentMapping ?: return null
@@ -229,7 +229,7 @@ internal class KtFirExpressionTypeProvider(
             !typeRef.coneType.isNullableType()
         }
 
-        when (val fir = expression.getOrBuildFir(analysisSession.firResolveState)) {
+        when (val fir = expression.getOrBuildFir(analysisSession.firResolveSession)) {
             is FirExpressionWithSmartcastToNull -> if (fir.isStable) {
                 return DefiniteNullability.DEFINITELY_NULL
             }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
 import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
 import org.jetbrains.kotlin.analysis.api.fir.utils.computeImportableName
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
@@ -41,15 +41,15 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 
 internal class KtFirImportOptimizer(
     override val token: ValidityToken,
-    private val firResolveState: LLFirModuleResolveState
+    private val firResolveSession: LLFirResolveSession
 ) : KtImportOptimizer() {
     private val firSession: FirSession
-        get() = firResolveState.useSiteFirSession
+        get() = firResolveSession.useSiteFirSession
 
     override fun analyseImports(file: KtFile): KtImportOptimizerResult {
         assertIsValidAndAccessible()
 
-        val firFile = file.getOrBuildFirFile(firResolveState).apply { ensureResolved(FirResolvePhase.BODY_RESOLVE) }
+        val firFile = file.getOrBuildFirFile(firResolveSession).apply { ensureResolved(FirResolvePhase.BODY_RESOLVE) }
 
         val existingImports = file.importDirectives
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
@@ -64,7 +64,7 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 internal class KtFirReferenceShortener(
     override val analysisSession: KtFirAnalysisSession,
     override val token: ValidityToken,
-    override val firResolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
 ) : KtReferenceShortener(), KtFirAnalysisSessionComponent {
     private val context = FirShorteningContext(analysisSession)
 
@@ -77,10 +77,10 @@ internal class KtFirReferenceShortener(
         val declarationToVisit = file.findSmallestDeclarationContainingSelection(selection)
             ?: file.withDeclarationsResolvedToBodyResolve()
 
-        val firDeclaration = declarationToVisit.getOrBuildFirOfType<FirDeclaration>(firResolveState)
+        val firDeclaration = declarationToVisit.getOrBuildFirOfType<FirDeclaration>(firResolveSession)
 
         val towerContext =
-            LowLevelFirApiFacadeForResolveOnAir.onAirGetTowerContextProvider(firResolveState, declarationToVisit)
+            LowLevelFirApiFacadeForResolveOnAir.onAirGetTowerContextProvider(firResolveSession, declarationToVisit)
 
         //TODO: collect all usages of available symbols in the file and prevent importing symbols that could introduce name clashes, which
         // may alter the meaning of existing code.
@@ -90,7 +90,7 @@ internal class KtFirReferenceShortener(
             selection,
             classShortenOption = { classShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtClassLikeSymbol) },
             callableShortenOption = { callableShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtCallableSymbol) },
-            firResolveState,
+            firResolveSession,
         )
         firDeclaration.accept(collector)
 
@@ -105,7 +105,7 @@ internal class KtFirReferenceShortener(
 
     private fun KtFile.withDeclarationsResolvedToBodyResolve(): KtFile {
         for (declaration in declarations) {
-            declaration.getOrBuildFir(firResolveState) // temporary hack, resolves declaration to BODY_RESOLVE stage
+            declaration.getOrBuildFir(firResolveSession) // temporary hack, resolves declaration to BODY_RESOLVE stage
         }
 
         return this
@@ -164,10 +164,10 @@ private data class AvailableSymbol<out T>(
 )
 
 private class FirShorteningContext(val analysisSession: KtFirAnalysisSession) {
-    private val firResolveState = analysisSession.firResolveState
+    private val firResolveSession = analysisSession.firResolveSession
 
     private val firSession: FirSession
-        get() = firResolveState.useSiteFirSession
+        get() = firResolveSession.useSiteFirSession
 
     fun findFirstClassifierInScopesByName(positionScopes: List<FirScope>, targetClassName: Name): AvailableSymbol<ClassId>? {
         for (scope in positionScopes) {
@@ -286,7 +286,7 @@ private class ElementsToShortenCollector(
     private val selection: TextRange,
     private val classShortenOption: (FirClassLikeSymbol<*>) -> ShortenOption,
     private val callableShortenOption: (FirCallableSymbol<*>) -> ShortenOption,
-    private val firResolveState: LLFirModuleResolveState,
+    private val firResolveSession: LLFirResolveSession,
 ) :
     FirVisitorVoid() {
     val namesToImport: MutableList<FqName> = mutableListOf()

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

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
@@ -49,7 +49,7 @@ internal class KtFirScopeProvider(
     analysisSession: KtFirAnalysisSession,
     builder: KtSymbolByFirBuilder,
     private val project: Project,
-    firResolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
 ) : KtScopeProvider(), ValidityTokenOwner {
     // KtFirScopeProvider is thread local, so it's okay to use the same session here
@@ -58,7 +58,7 @@ internal class KtFirScopeProvider(
 
     override val analysisSession: KtFirAnalysisSession by weakRef(analysisSession)
     private val builder by weakRef(builder)
-    private val firResolveState by weakRef(firResolveState)
+    private val firResolveSession by weakRef(firResolveSession)
 
     private val memberScopeCache = IdentityHashMap<KtSymbolWithMembers, KtScope>()
     private val declaredMemberScopeCache = IdentityHashMap<KtSymbolWithMembers, KtScope>()
@@ -176,7 +176,7 @@ internal class KtFirScopeProvider(
 
     override fun getTypeScope(type: KtType): KtScope? {
         check(type is KtFirType) { "KtFirScopeProvider can only work with KtFirType, but ${type::class} was provided" }
-        val firSession = firResolveState.useSiteFirSession
+        val firSession = firResolveSession.useSiteFirSession
         val firTypeScope = type.coneType.scope(
             firSession,
             scopeSession,
@@ -198,7 +198,7 @@ internal class KtFirScopeProvider(
         positionInFakeFile: KtElement
     ): KtScopeContext = withValidityAssertion {
         val towerDataContext =
-            analysisSession.firResolveState.getTowerContextProvider(originalFile).getClosestAvailableParentContext(positionInFakeFile)
+            analysisSession.firResolveSession.getTowerContextProvider(originalFile).getClosestAvailableParentContext(positionInFakeFile)
                 ?: error("Cannot find enclosing declaration for ${positionInFakeFile.getElementTextInContext()}")
 
         val implicitReceivers = towerDataContext.nonLocalTowerDataElements.mapNotNull { it.implicitReceiver }.distinct()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSmartcastProvider.kt

@@ -51,7 +51,7 @@ internal class KtFirSmartcastProvider(
 
         val possibleFunctionCall = expression.getPossiblyQualifiedCallExpressionForCallee() ?: expression
 
-        return when (val firExpression = possibleFunctionCall.getOrBuildFir(analysisSession.firResolveState)) {
+        return when (val firExpression = possibleFunctionCall.getOrBuildFir(analysisSession.firResolveSession)) {
             is FirExpressionWithSmartcast -> firExpression
             is FirSafeCallExpression -> firExpression.selector as? FirExpressionWithSmartcast
             is FirImplicitInvokeCall -> firExpression.explicitReceiver as? FirExpressionWithSmartcast
@@ -80,7 +80,7 @@ internal class KtFirSmartcastProvider(
             ?: expression.getQualifiedExpressionForSelector()
             ?: expression
 
-        return when (val firExpression = wholeExpression.getOrBuildFir(analysisSession.firResolveState)) {
+        return when (val firExpression = wholeExpression.getOrBuildFir(analysisSession.firResolveSession)) {
             is FirQualifiedAccessExpression -> firExpression
             is FirSafeCallExpression -> firExpression.selector as? FirQualifiedAccessExpression
             else -> null

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt

@@ -65,7 +65,7 @@ internal class KtFirSymbolContainingDeclarationProvider(
     }
 
     override fun getContainingModule(symbol: KtSymbol): KtModule {
-       return symbol.getContainingKtModule(analysisSession.firResolveState)
+       return symbol.getContainingKtModule(analysisSession.firResolveSession)
     }
 
     private fun getContainingDeclarationForBackingFieldSymbol(symbol: KtSymbolWithKind): KtSymbolWithKind {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt

@@ -26,7 +26,7 @@ internal class KtFirSymbolDeclarationRendererProvider(
 
     override fun render(type: KtType, options: KtTypeRendererOptions): String {
         require(type is KtFirType)
-        return ConeTypeIdeRenderer(analysisSession.firResolveState.useSiteFirSession, options).renderType(type.coneType)
+        return ConeTypeIdeRenderer(analysisSession.firResolveSession.useSiteFirSession, options).renderType(type.coneType)
     }
 
     override fun renderDeclaration(symbol: KtDeclarationSymbol, options: KtDeclarationRendererOptions): String {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt

@@ -86,7 +86,7 @@ internal class KtFirTypeProvider(
     }
 
     override fun getKtType(ktTypeReference: KtTypeReference): KtType = withValidityAssertion {
-        when (val fir = ktTypeReference.getOrBuildFir(firResolveState)) {
+        when (val fir = ktTypeReference.getOrBuildFir(firResolveSession)) {
             is FirResolvedTypeRef -> fir.coneType.asKtType()
             is FirDelegatedConstructorCall -> fir.constructedTypeRef.coneType.asKtType()
             else -> throwUnexpectedFirElementError(fir, ktTypeReference)
@@ -94,7 +94,7 @@ internal class KtFirTypeProvider(
     }
 
     override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? = withValidityAssertion {
-        when (val fir = expression.getOrBuildFir(firResolveState)) {
+        when (val fir = expression.getOrBuildFir(firResolveSession)) {
             is FirGetClassCall ->
                 fir.typeRef.coneType.getReceiverOfReflectionType()?.asKtType()
             is FirCallableReferenceAccess ->
@@ -122,7 +122,7 @@ internal class KtFirTypeProvider(
     }
 
     override fun getImplicitReceiverTypesAtPosition(position: KtElement): List<KtType> {
-        return analysisSession.firResolveState.getTowerContextProvider(position.containingKtFile)
+        return analysisSession.firResolveSession.getTowerContextProvider(position.containingKtFile)
             .getClosestAvailableParentContext(position)?.implicitReceiverStack?.map { it.type.asKtType() } ?: emptyList()
     }
 
@@ -146,7 +146,7 @@ internal class KtFirTypeProvider(
     }
 
     private fun ConeLookupTagBasedType.getSubstitutedSuperTypes(shouldApproximate: Boolean): Sequence<ConeKotlinType> {
-        val session = analysisSession.firResolveState.useSiteFirSession
+        val session = analysisSession.firResolveSession.useSiteFirSession
         val symbol = lookupTag.toSymbol(session)
         val superTypes = when (symbol) {
             is FirAnonymousObjectSymbol -> symbol.superConeTypes

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt

@@ -44,13 +44,13 @@ internal class KtFirVisibilityChecker(
         val nonLocalContainingDeclaration = findContainingNonLocalDeclaration(position)
         val useSiteFirFile = useSiteFile.firSymbol.fir
         val containers = nonLocalContainingDeclaration
-            ?.getOrBuildFirSafe<FirCallableDeclaration>(analysisSession.firResolveState)
+            ?.getOrBuildFirSafe<FirCallableDeclaration>(analysisSession.firResolveSession)
             ?.collectDesignation()
             ?.path
             .orEmpty()
 
         val explicitDispatchReceiver = receiverExpression
-            ?.getOrBuildFirSafe<FirExpression>(analysisSession.firResolveState)
+            ?.getOrBuildFirSafe<FirExpression>(analysisSession.firResolveSession)
             ?.let { ExpressionReceiverValue(it) }
 
         val candidateFirSymbol = candidateSymbol.firSymbol.fir as FirMemberDeclaration

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt

@@ -188,8 +188,8 @@ internal object FirReferenceResolveHelper {
         if (expression.isSyntheticOperatorReference()) return emptyList()
         val symbolBuilder = analysisSession.firSymbolBuilder
         val adjustedResolutionExpression = adjustResolutionExpression(expression)
-        val fir = adjustedResolutionExpression.getOrBuildFir(analysisSession.firResolveState)
-        val session = analysisSession.firResolveState.useSiteFirSession
+        val fir = adjustedResolutionExpression.getOrBuildFir(analysisSession.firResolveSession)
+        val session = analysisSession.firResolveSession.useSiteFirSession
         return when (fir) {
             is FirResolvedTypeRef -> getSymbolsForResolvedTypeRef(fir, expression, session, symbolBuilder)
             is FirResolvedQualifier ->
@@ -258,7 +258,7 @@ internal object FirReferenceResolveHelper {
     ): Collection<KtSymbol> {
         val parentAsCall = expression.parent as? KtCallExpression
         if (parentAsCall != null) {
-            val firResolvable = parentAsCall.getOrBuildFirSafe<FirResolvable>(analysisSession.firResolveState)
+            val firResolvable = parentAsCall.getOrBuildFirSafe<FirResolvable>(analysisSession.firResolveSession)
             if (firResolvable != null) {
                 return getSymbolsByResolvable(firResolvable, expression, session, symbolBuilder)
             }
@@ -305,7 +305,7 @@ internal object FirReferenceResolveHelper {
         val ktValueArgumentList = ktValueArgument.parent as? KtValueArgumentList ?: return emptyList()
         val ktCallExpression = ktValueArgumentList.parent as? KtCallElement ?: return emptyList()
 
-        val firCall = ktCallExpression.getOrBuildFirSafe<FirCall>(analysisSession.firResolveState) ?: return emptyList()
+        val firCall = ktCallExpression.getOrBuildFirSafe<FirCall>(analysisSession.firResolveSession) ?: return emptyList()
         val parameter = firCall.findCorrespondingParameter(ktValueArgument) ?: return emptyList()
         return listOfNotNull(parameter.buildSymbol(symbolBuilder))
     }
@@ -333,7 +333,7 @@ internal object FirReferenceResolveHelper {
                 parent = parent.parent as? KtDotQualifiedExpression
                 continue
             }
-            val parentFir = selectorExpression.getOrBuildFir(analysisSession.firResolveState)
+            val parentFir = selectorExpression.getOrBuildFir(analysisSession.firResolveSession)
             if (parentFir is FirResolvedQualifier) {
                 var classId = parentFir.classId
                 while (unresolvedCounter > 0) {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirArrayAccessReference.kt

@@ -20,7 +20,7 @@ class KtFirArrayAccessReference(
 ) : KtArrayAccessReference(expression), KtFirReference {
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFirAnalysisSession)
-        val fir = element.getOrBuildFirSafe<FirFunctionCall>(firResolveState) ?: return emptyList()
+        val fir = element.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return emptyList()
         return fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) }
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirCollectionLiteralReference.kt

@@ -23,7 +23,7 @@ class KtFirCollectionLiteralReference(
 ) : KtCollectionLiteralReference(expression), KtFirReference {
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFirAnalysisSession)
-        val fir = element.getOrBuildFirSafe<FirArrayOfCall>(firResolveState) ?: return emptyList()
+        val fir = element.getOrBuildFirSafe<FirArrayOfCall>(firResolveSession) ?: return emptyList()
         val type = fir.typeRef.coneTypeSafe<ConeClassLikeType>() ?: return listOfNotNull(arrayOfSymbol(arrayOf))
         val call = arrayTypeToArrayOfCall[type.lookupTag.classId] ?: arrayOf
         return listOfNotNull(arrayOfSymbol(call))

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirConstructorDelegationReference.kt

@@ -19,7 +19,7 @@ class KtFirConstructorDelegationReference(
 
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFirAnalysisSession)
-        val fir = expression.getOrBuildFirSafe<FirDelegatedConstructorCall>(firResolveState) ?: return emptyList()
+        val fir = expression.getOrBuildFirSafe<FirDelegatedConstructorCall>(firResolveSession) ?: return emptyList()
         return listOfNotNull(fir.calleeReference.getResolvedKtSymbolOfNameReference(firSymbolBuilder))
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirDestructuringDeclarationReference.kt

@@ -22,7 +22,7 @@ class KtFirDestructuringDeclarationReference(
 
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFirAnalysisSession)
-        val fir = expression.getOrBuildFirSafe<FirProperty>(firResolveState) ?: return emptyList()
+        val fir = expression.getOrBuildFirSafe<FirProperty>(firResolveSession) ?: return emptyList()
         return listOfNotNull(
             fir.buildSymbol(firSymbolBuilder),
             getComponentNSymbol(fir)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirForLoopInReference.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.psi.KtForExpression
 open class KtFirForLoopInReference(expression: KtForExpression) : KtForLoopInReference(expression), KtFirReference {
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFirAnalysisSession)
-        val firLoop = expression.getOrBuildFirSafe<FirWhileLoop>(firResolveState) ?: return emptyList()
+        val firLoop = expression.getOrBuildFirSafe<FirWhileLoop>(firResolveSession) ?: return emptyList()
         val condition = firLoop.condition as? FirFunctionCall
         val iterator = this@KtFirForLoopInReference.run {
             val callee = (condition?.explicitReceiver as? FirQualifiedAccessExpression)?.calleeReference

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirPropertyDelegationMethodsReference.kt

@@ -24,7 +24,7 @@ class KtFirPropertyDelegationMethodsReference(
 ) : KtPropertyDelegationMethodsReference(element), KtFirReference {
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFirAnalysisSession)
-        val property = (expression.parent as? KtElement)?.getOrBuildFirSafe<FirProperty>(firResolveState) ?: return emptyList()
+        val property = (expression.parent as? KtElement)?.getOrBuildFirSafe<FirProperty>(firResolveSession) ?: return emptyList()
         if (property.delegate == null) return emptyList()
         val getValueSymbol = (property.getter?.singleStatementOfType<FirReturnExpression>()?.result as? FirFunctionCall)?.getCalleeSymbol()
         val setValueSymbol = property.setter?.singleStatementOfType<FirFunctionCall>()?.getCalleeSymbol()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt

@@ -16,14 +16,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 
 internal class KtFirAnonymousFunctionSymbol(
     override val firSymbol: FirAnonymousFunctionSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
 ) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirAnonymousObjectSymbol.kt

@@ -16,18 +16,18 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 
 internal class KtFirAnonymousObjectSymbol(
     override val firSymbol: FirAnonymousObjectSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
 ) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> {
     override val psi: PsiElement? by cached { firSymbol.findPsi() }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val superTypes: List<KtType> by cached { firSymbol.superTypesList(builder) }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirArrayOfSymbolProvider.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.name.StandardClassIds
 
 object KtFirArrayOfSymbolProvider {
     internal fun KtFirAnalysisSession.arrayOfSymbol(identifier: Name): KtFirFunctionSymbol? {
-        val firSymbol = firResolveState.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
+        val firSymbol = firResolveSession.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
             /* choose (for byte array)
              * public fun byteArrayOf(vararg elements: kotlin.Byte): kotlin.ByteArray
              */

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirBackingFieldSymbol.kt

@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 
 internal class KtFirBackingFieldSymbol(
     override val firSymbol: FirBackingFieldSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingFieldSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirClassInitializerSymbol.kt

@@ -13,12 +13,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
 
 internal class KtFirClassInitializerSymbol(
     override val firSymbol: FirAnonymousInitializerSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
 ) : KtClassInitializerSymbol(), KtFirSymbol<FirAnonymousInitializerSymbol> {
     override val psi: PsiElement? by cached { firSymbol.findPsi() }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirConstructorSymbol.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirConstructorSymbol(
     override val firSymbol: FirConstructorSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtConstructorSymbol(), KtFirSymbol<FirConstructorSymbol> {
@@ -48,7 +48,7 @@ internal class KtFirConstructorSymbol(
 
     override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val containingClassIdIfNonLocal: ClassId?
         get() = withValidityAssertion { firSymbol.containingClass()?.classId?.takeUnless { it.isLocal } }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirEnumEntrySymbol.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
 import org.jetbrains.kotlin.name.CallableId
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirEnumEntrySymbol(
     override val firSymbol: FirEnumEntrySymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntrySymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFileSymbol.kt

@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithDeclaration
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
 
 internal class KtFirFileSymbol(
     override val firSymbol: FirFileSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
 ) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol<FirFileSymbol> {
     override val psi: PsiElement? by cached { firSymbol.findPsi() }
@@ -29,7 +29,7 @@ internal class KtFirFileSymbol(
         TODO("Creating pointers for files from library is not supported yet")
     }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override fun equals(other: Any?): Boolean = symbolEquals(other)
     override fun hashCode(): Int = symbolHashCode()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFunctionSymbol.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConst
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirFunctionSymbol(
     override val firSymbol: FirNamedFunctionSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtFunctionSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
@@ -57,7 +57,7 @@ internal class KtFirFunctionSymbol(
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session) }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val isSuspend: Boolean get() = withValidityAssertion { firSymbol.isSuspend }
     override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirJavaFieldSymbol.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirJavaFieldSymbol(
     override val firSymbol: FirFieldSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtJavaFieldSymbol(), KtFirSymbol<FirFieldSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConst
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirKotlinPropertySymbol(
     override val firSymbol: FirPropertySymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtKotlinPropertySymbol(), KtFirSymbol<FirPropertySymbol> {
@@ -78,7 +78,7 @@ internal class KtFirKotlinPropertySymbol(
     override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
     override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirLocalVariableSymbol.kt

@@ -17,13 +17,13 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirLocalVariableSymbol(
     override val firSymbol: FirPropertySymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtLocalVariableSymbol(),

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirNamedClassOrObjectSymbol.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirNamedClassOrObjectSymbol(
     override val firSymbol: FirRegularClassSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClassSymbol> {
@@ -65,7 +65,7 @@ internal class KtFirNamedClassOrObjectSymbol(
             else -> possiblyRawVisibility
         }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val isInner: Boolean get() = withValidityAssertion { firSymbol.isInner }
     override val isData: Boolean get() = withValidityAssertion { firSymbol.isData }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPropertyGetterSymbol.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.CallableId
 
 internal class KtFirPropertyGetterSymbol(
     override val firSymbol: FirPropertyAccessorSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
 ) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
@@ -54,7 +54,7 @@ internal class KtFirPropertyGetterSymbol(
     override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
     override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
     
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     /**
      * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPropertySetterSymbol.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.CallableId
 
 internal class KtFirPropertySetterSymbol(
     override val firSymbol: FirPropertyAccessorSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
 ) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
@@ -51,7 +51,7 @@ internal class KtFirPropertySetterSymbol(
     override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
     override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     /**
      * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirReceiverParameterSymbol.kt

@@ -17,12 +17,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 
 internal class KtFirReceiverParameterSymbol(
     val firSymbol: FirCallableSymbol<*>,
-    val resolveState: LLFirModuleResolveState,
+    val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     _builder: KtSymbolByFirBuilder
 ) : KtReceiverParameterSymbol(), ValidityTokenOwner {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSamConstructorSymbol.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isExtension
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirSamConstructorSymbol(
     override val firSymbol: FirNamedFunctionSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtSamConstructorSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbol.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 internal interface KtFirSymbol<out S : FirBasedSymbol<*>> : KtSymbol, ValidityTokenOwner {
     val firSymbol: S
 
-    abstract val resolveState: LLFirModuleResolveState
+    val firResolveSession: LLFirResolveSession
 
     override val origin: KtSymbolOrigin get() = firSymbol.fir.ktSymbolOrigin()
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbolProvider.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfType
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.psi.*
 internal class KtFirSymbolProvider(
     override val analysisSession: KtAnalysisSession,
     firSymbolProvider: FirSymbolProvider,
-    private val resolveState: LLFirModuleResolveState,
+    private val firResolveSession: LLFirResolveSession,
     private val firSymbolBuilder: KtSymbolByFirBuilder,
     override val token: ValidityToken,
 ) : KtSymbolProvider(), ValidityTokenOwner {
@@ -41,23 +41,23 @@ internal class KtFirSymbolProvider(
             )
 
             psi.isLoopParameter -> {
-                firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(resolveState))
+                firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(firResolveSession))
             }
 
             else -> {
                 firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(
-                    psi.resolveToFirSymbolOfType<FirValueParameterSymbol>(resolveState)
+                    psi.resolveToFirSymbolOfType<FirValueParameterSymbol>(firResolveSession)
                 )
             }
         }
     }
 
     override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion {
-        firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(resolveState).symbol)
+        firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(firResolveSession).symbol)
     }
 
     override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
-        when (val firSymbol = psi.resolveToFirSymbolOfType<FirFunctionSymbol<*>>(resolveState)) {
+        when (val firSymbol = psi.resolveToFirSymbolOfType<FirFunctionSymbol<*>>(firResolveSession)) {
             is FirNamedFunctionSymbol -> {
                 if (firSymbol.origin == FirDeclarationOrigin.SamConstructor) {
                     firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(firSymbol)
@@ -72,60 +72,60 @@ internal class KtFirSymbolProvider(
 
     override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
 
-        firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(psi.resolveToFirSymbolOfType<FirConstructorSymbol>(resolveState))
+        firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(psi.resolveToFirSymbolOfType<FirConstructorSymbol>(firResolveSession))
 
     }
 
     override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
-        firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(psi.resolveToFirSymbolOfType<FirTypeParameterSymbol>(resolveState))
+        firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(psi.resolveToFirSymbolOfType<FirTypeParameterSymbol>(firResolveSession))
     }
 
     override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
-        firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(psi.resolveToFirSymbolOfType<FirTypeAliasSymbol>(resolveState))
+        firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(psi.resolveToFirSymbolOfType<FirTypeAliasSymbol>(firResolveSession))
     }
 
     override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
-        firSymbolBuilder.buildEnumEntrySymbol(psi.resolveToFirSymbolOfType<FirEnumEntrySymbol>(resolveState))
+        firSymbolBuilder.buildEnumEntrySymbol(psi.resolveToFirSymbolOfType<FirEnumEntrySymbol>(firResolveSession))
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
-        firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(resolveState))
+        firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(firResolveSession))
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
         firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(
-            psi.resolveToFirSymbolOfType<FirAnonymousFunctionSymbol>(resolveState)
+            psi.resolveToFirSymbolOfType<FirAnonymousFunctionSymbol>(firResolveSession)
         )
     }
 
     override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
-        firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(resolveState))
+        firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(firResolveSession))
     }
 
     override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
         firSymbolBuilder.classifierBuilder.buildAnonymousObjectSymbol(
-            psi.objectDeclaration.resolveToFirSymbolOfType<FirAnonymousObjectSymbol>(resolveState)
+            psi.objectDeclaration.resolveToFirSymbolOfType<FirAnonymousObjectSymbol>(firResolveSession)
         )
     }
 
     override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
-        firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirClassSymbol<*>>(resolveState))
+        firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirClassSymbol<*>>(firResolveSession))
     }
 
     override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? = withValidityAssertion {
         require(psi !is KtObjectDeclaration || psi.parent !is KtObjectLiteralExpression)
         // A KtClassOrObject may also map to an FirEnumEntry. Hence, we need to return null in this case.
         if (psi is KtEnumEntry) return null
-        firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirRegularClassSymbol>(resolveState))
+        firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirRegularClassSymbol>(firResolveSession))
     }
 
     override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
-        firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(psi.resolveToFirSymbolOfType<FirPropertyAccessorSymbol>(resolveState))
+        firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(psi.resolveToFirSymbolOfType<FirPropertyAccessorSymbol>(firResolveSession))
     }
 
     override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
         firSymbolBuilder.anonymousInitializerBuilder.buildClassInitializer(
-            psi.resolveToFirSymbolOfType<FirAnonymousInitializerSymbol>(resolveState)
+            psi.resolveToFirSymbolOfType<FirAnonymousInitializerSymbol>(firResolveSession)
         )
     }
 
@@ -139,5 +139,5 @@ internal class KtFirSymbolProvider(
         return firs.asSequence().map { firSymbol -> firSymbolBuilder.buildSymbol(firSymbol) }
     }
 
-    override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol = KtFirPackageSymbol(FqName.ROOT, resolveState.project, token)
+    override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol = KtFirPackageSymbol(FqName.ROOT, firResolveSession.project, token)
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirSyntheticJavaPropertySymbol(
     override val firSymbol: FirSyntheticPropertySymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticPropertySymbol> {
@@ -56,7 +56,7 @@ internal class KtFirSyntheticJavaPropertySymbol(
     override val modality: Modality get() = withValidityAssertion { firSymbol.modality ?: firSymbol.invalidModalityError() }
     override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeAliasSymbol.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirTypeAliasSymbol(
     override val firSymbol: FirTypeAliasSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
 ) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAliasSymbol> {
@@ -49,7 +49,7 @@ internal class KtFirTypeAliasSymbol(
     override val expandedType: KtType by cached { builder.typeBuilder.buildKtType(firSymbol.resolvedExpandedTypeRef) }
 
     override val annotationsList: KtAnnotationsList by cached {
-        KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token)
+        KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token)
     }
 
     override fun createPointer(): KtSymbolPointer<KtTypeAliasSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeParameterSymbol.kt

@@ -15,14 +15,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
 
 internal class KtFirTypeParameterSymbol(
     override val firSymbol: FirTypeParameterSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameterSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirValueParameterSymbol.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.types.arrayElementType
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFirValueParameterSymbol(
     override val firSymbol: FirValueParameterSymbol,
-    override val resolveState: LLFirModuleResolveState,
+    override val firResolveSession: LLFirResolveSession,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameterSymbol> {
@@ -53,7 +53,7 @@ internal class KtFirValueParameterSymbol(
 
     override val hasDefaultValue: Boolean get() = withValidityAssertion { firSymbol.hasDefaultValue }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirTopLevelCallableSymbolPointer.kt

@@ -33,5 +33,5 @@ internal abstract class KtTopLevelCallableSymbolPointer<S : KtCallableSymbol>(
 }
 
 private fun KtFirAnalysisSession.getCallableSymbols(callableId: CallableId) =
-    firResolveState.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(callableId.packageName, callableId.callableName)
+    firResolveSession.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(callableId.packageName, callableId.callableName)
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/pointerUtils.kt

@@ -58,4 +58,4 @@ internal fun FirDeclaration.createSignature(): IdSignature {
 }
 
 internal fun KtFirAnalysisSession.getClassLikeSymbol(classId: ClassId) =
-    firResolveState.useSiteFirSession.symbolProvider.getClassLikeSymbolByClassId(classId)?.fir
+    firResolveSession.useSiteFirSession.symbolProvider.getClassLikeSymbolByClassId(classId)?.fir

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -29,7 +29,7 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
 ) {
     val analysisSession: KtAnalysisSession get() = firAnalysisSession
 
-    val firResolveState: LLFirModuleResolveState get() = firAnalysisSession.firResolveState
+    val firResolveSession: LLFirResolveSession get() = firAnalysisSession.firResolveSession
 
     fun buildClassLikeSymbol(fir: FirClassLikeDeclaration): KtClassLikeSymbol =
         firAnalysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir.symbol)
@@ -47,9 +47,9 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
 
     companion object {
         @InvalidWayOfUsingAnalysisSession
-        fun create(firResolveState: LLFirModuleResolveState, token: ValidityToken, @Suppress("UNUSED_PARAMETER") ktElement: KtElement): KtAnalysisSessionFe10BindingHolder {
+        fun create(firResolveSession: LLFirResolveSession, token: ValidityToken, @Suppress("UNUSED_PARAMETER") ktElement: KtElement): KtAnalysisSessionFe10BindingHolder {
             @Suppress("DEPRECATION")
-            val firAnalysisSession = KtFirAnalysisSession.createAnalysisSessionByResolveState(firResolveState, token)
+            val firAnalysisSession = KtFirAnalysisSession.createAnalysisSessionByFirResolveSession(firResolveSession, token)
             return KtAnalysisSessionFe10BindingHolder(firAnalysisSession)
         }
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ktSymbolUtils.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.api.fir.utils
 
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirBuiltinsModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirKtModuleBasedModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firModuleData
@@ -25,20 +25,20 @@ val KtSymbol.firSymbol: FirBasedSymbol<*>
     }
 
 
-fun FirBasedSymbol<*>.getContainingKtModule(resolveState: LLFirModuleResolveState): KtModule {
+fun FirBasedSymbol<*>.getContainingKtModule(firResolveSession: LLFirResolveSession): KtModule {
     val target = when (this) {
         is FirCallableSymbol -> {
             // callable fake overrides have use-site FirModuleData
-            dispatchReceiverClassOrNull()?.toFirRegularClassSymbol(resolveState.useSiteFirSession) ?: this
+            dispatchReceiverClassOrNull()?.toFirRegularClassSymbol(firResolveSession.useSiteFirSession) ?: this
         }
         else -> this
     }
     return when (val moduleData = target.firModuleData) {
         is LLFirKtModuleBasedModuleData -> moduleData.ktModule
-        is LLFirBuiltinsModuleData -> resolveState.project.getService(ProjectStructureProvider::class.java).getStdlibWithBuiltinsModule(moduleData.useSiteKtModule)
+        is LLFirBuiltinsModuleData -> firResolveSession.project.getService(ProjectStructureProvider::class.java).getStdlibWithBuiltinsModule(moduleData.useSiteKtModule)
             ?: error("Builtins not found for the ${moduleData.useSiteKtModule.moduleDescription}")
     }
 }
 
-fun KtSymbol.getContainingKtModule(resolveState: LLFirModuleResolveState): KtModule =
-    firSymbol.getContainingKtModule(resolveState)
+fun KtSymbol.getContainingKtModule(firResolveSession: LLFirResolveSession): KtModule =
+    firSymbol.getContainingKtModule(firResolveSession)

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/CachingKtAnalysisSessionProvider.kt

@@ -27,32 +27,32 @@ import kotlin.reflect.KClass
 abstract class CachingKtAnalysisSessionProvider<State : Any>(private val project: Project) : KtAnalysisSessionProvider() {
     private val cache = KtAnalysisSessionCache<Pair<State, KClass<out ValidityToken>>>(project)
 
-    protected abstract fun getResolveState(contextElement: KtElement): State
-    protected abstract fun getResolveState(contextSymbol: KtSymbol): State
+    protected abstract fun getFirResolveSession(contextElement: KtElement): State
+    protected abstract fun getFirResolveSession(contextSymbol: KtSymbol): State
 
     protected abstract fun createAnalysisSession(
-        resolveState: State,
+        firResolveSession: State,
         validityToken: ValidityToken,
     ): KtAnalysisSession
 
     @InvalidWayOfUsingAnalysisSession
     final override fun getAnalysisSession(contextElement: KtElement, factory: ValidityTokenFactory): KtAnalysisSession {
-        val resolveState = getResolveState(contextElement)
-        return cache.getAnalysisSession(resolveState to factory.identifier) {
+        val firResolveSession = getFirResolveSession(contextElement)
+        return cache.getAnalysisSession(firResolveSession to factory.identifier) {
             val validityToken = factory.create(project)
-            createAnalysisSession(resolveState, validityToken)
+            createAnalysisSession(firResolveSession, validityToken)
         }
     }
 
     final override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession {
-        val resolveState = getResolveState(contextSymbol)
+        val firResolveSession = getFirResolveSession(contextSymbol)
         val token = contextSymbol.token
-        return getCachedAnalysisSession(resolveState, token)
-            ?: createAnalysisSession(resolveState, contextSymbol.token)
+        return getCachedAnalysisSession(firResolveSession, token)
+            ?: createAnalysisSession(firResolveSession, contextSymbol.token)
     }
 
-    private fun getCachedAnalysisSession(resolveState: State, token: ValidityToken): KtAnalysisSession? {
-        return cache.getCachedAnalysisSession(resolveState to token::class)
+    private fun getCachedAnalysisSession(firResolveSession: State, token: ValidityToken): KtAnalysisSession? {
+        return cache.getCachedAnalysisSession(firResolveSession to token::class)
     }
 
     @TestOnly

analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/RegisterComponentService.java

@@ -6,13 +6,13 @@
 package org.jetbrains.kotlin.analysis.api.standalone;
 
 import com.intellij.mock.MockProject;
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService;
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService;
 
 class RegisterComponentService {
-    static void registerLLFirResolveStateService(MockProject project) {
+    static void registerLLFirResolveSessionService(MockProject project) {
         project.registerService(
-                LLFirResolveStateService.class,
-                new LLFirResolveStateService(project)
+                LLFirResolveSessionService.class,
+                new LLFirResolveSessionService(project)
         );
     }
 }

analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeUtils.kt

@@ -74,7 +74,7 @@ public fun configureApplicationEnvironment(app: MockApplication) {
  *   * [ClsJavaStubByVirtualFileCache]
  *   * [KotlinModificationTrackerFactory]
  *   * [KotlinAnnotationsResolverFactory]
- *   * [LLFirResolveStateService]
+ *   * [LLfirResolveSessionService]
  *   * [FirSealedClassInheritorsProcessorFactory]
  *   * [KtModuleScopeProvider]
  *   * [ProjectStructureProvider]
@@ -161,7 +161,7 @@ internal fun configureProjectEnvironment(
         KotlinStaticAnnotationsResolverFactory(ktFiles)
     )
 
-    RegisterComponentService.registerLLFirResolveStateService(project)
+    RegisterComponentService.registerLLFirResolveSessionService(project)
     project.picoContainer.registerComponentInstance(
         FirSealedClassInheritorsProcessorFactory::class.qualifiedName,
         object : FirSealedClassInheritorsProcessorFactory() {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveSessionDepended.kt

@@ -9,11 +9,11 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ProjectRootModificationTracker
 import com.intellij.psi.util.PsiModificationTracker
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirElementBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMapping
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.state.TowerProviderForElementForState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.LLFirScopeSessionProvider
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -31,14 +31,14 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import java.util.concurrent.ConcurrentHashMap
 
-internal class FirModuleResolveStateDepended(
-    val originalState: LLFirResolvableModuleResolveState,
+internal class LLFirResolveSessionDepended(
+    val originalFirResolveSession: LLFirResolvableResolveSession,
     val towerProviderBuiltUponElement: FirTowerContextProvider,
     private val ktToFirMapping: KtToFirMapping?,
-) : LLFirModuleResolveState() {
-    override val project: Project get() = originalState.project
-    override val useSiteKtModule: KtModule get() = originalState.useSiteKtModule
-    override val useSiteFirSession get() = originalState.useSiteFirSession
+) : LLFirResolveSession() {
+    override val project: Project get() = originalFirResolveSession.project
+    override val useSiteKtModule: KtModule get() = originalFirResolveSession.useSiteKtModule
+    override val useSiteFirSession get() = originalFirResolveSession.useSiteFirSession
 
     private val scopeSessionProviderCache by softCachedValue(
         project,
@@ -55,19 +55,19 @@ internal class FirModuleResolveStateDepended(
     }
 
     override fun getSessionFor(module: KtModule): FirSession =
-        originalState.getSessionFor(module)
+        originalFirResolveSession.getSessionFor(module)
 
     override fun getOrBuildFirFor(element: KtElement): FirElement? {
         val psi = FirElementBuilder.getPsiAsFirElementSource(element) ?: return null
         ktToFirMapping?.getFirOfClosestParent(psi, this)?.let { return it }
-        return originalState.getOrBuildFirFor(element = element)
+        return originalFirResolveSession.getOrBuildFirFor(element = element)
     }
 
     override fun getOrBuildFirFile(ktFile: KtFile): FirFile =
-        originalState.getOrBuildFirFile(ktFile)
+        originalFirResolveSession.getOrBuildFirFile(ktFile)
 
     override fun resolveFirToPhase(declaration: FirDeclaration, toPhase: FirResolvePhase) {
-        originalState.resolveFirToPhase(declaration, toPhase)
+        originalFirResolveSession.resolveFirToPhase(declaration, toPhase)
     }
 
     override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> =
@@ -77,7 +77,7 @@ internal class FirModuleResolveStateDepended(
         TODO("Diagnostics are not implemented for depended state")
 
     override fun resolveToFirSymbol(ktDeclaration: KtDeclaration, phase: FirResolvePhase): FirBasedSymbol<*> {
-        return originalState.resolveToFirSymbol(ktDeclaration, phase)
+        return originalFirResolveSession.resolveToFirSymbol(ktDeclaration, phase)
     }
 
     override fun getTowerContextProvider(ktFile: KtFile): FirTowerContextProvider =

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt

@@ -9,12 +9,12 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ProjectRootModificationTracker
 import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProviderStorage
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirLibraryOrLibrarySourceResolvableModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirLibraryOrLibrarySourceResolvableResolveSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -23,33 +23,33 @@ import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModifi
 import org.jetbrains.kotlin.analysis.utils.caches.strongCachedValue
 import java.util.concurrent.ConcurrentHashMap
 
-internal class LLFirResolveStateService(project: Project) {
+internal class LLFirResolveSessionService(project: Project) {
     private val sessionProviderStorage = LLFirSessionProviderStorage(project)
 
     private val stateCache by strongCachedValue(
         project.createProjectWideOutOfBlockModificationTracker(),
         ProjectRootModificationTracker.getInstance(project),
     ) {
-        ConcurrentHashMap<KtModule, LLFirResolvableModuleResolveState>()
+        ConcurrentHashMap<KtModule, LLFirResolvableResolveSession>()
     }
 
-    fun getResolveState(module: KtModule): LLFirResolvableModuleResolveState =
-        stateCache.computeIfAbsent(module) { createResolveStateFor(module, sessionProviderStorage) }
+    fun getFirResolveSession(module: KtModule): LLFirResolvableResolveSession =
+        stateCache.computeIfAbsent(module) { createFirResolveSessionFor(module, sessionProviderStorage) }
 
     companion object {
-        fun getInstance(project: Project): LLFirResolveStateService =
-            ServiceManager.getService(project, LLFirResolveStateService::class.java)
+        fun getInstance(project: Project): LLFirResolveSessionService =
+            ServiceManager.getService(project, LLFirResolveSessionService::class.java)
 
-        internal fun createResolveStateFor(
+        internal fun createFirResolveSessionFor(
             useSiteKtModule: KtModule,
             sessionProviderStorage: LLFirSessionProviderStorage,
             configureSession: (LLFirSession.() -> Unit)? = null,
-        ): LLFirResolvableModuleResolveState {
+        ): LLFirResolvableResolveSession {
             val sessionProvider = sessionProviderStorage.getSessionProvider(useSiteKtModule, configureSession)
             val useSiteSession = sessionProvider.rootModuleSession
             return when (useSiteKtModule) {
                 is KtSourceModule -> {
-                    LLFirSourceModuleResolveState(
+                    LLFirSourceResolveSession(
                         useSiteSession.moduleComponents.globalResolveComponents,
                         sessionProviderStorage.project,
                         useSiteKtModule,
@@ -57,7 +57,7 @@ internal class LLFirResolveStateService(project: Project) {
                     )
                 }
                 is KtLibraryModule, is KtLibrarySourceModule -> {
-                    LLFirLibraryOrLibrarySourceResolvableModuleResolveState(
+                    LLFirLibraryOrLibrarySourceResolvableResolveSession(
                         useSiteSession.moduleComponents.globalResolveComponents,
                         sessionProviderStorage.project,
                         useSiteKtModule,
@@ -74,12 +74,12 @@ internal class LLFirResolveStateService(project: Project) {
 }
 
 @TestOnly
-fun createResolveStateForNoCaching(
+fun createFirResolveSessionForNoCaching(
     useSiteKtModule: KtModule,
     project: Project,
     configureSession: (LLFirSession.() -> Unit)? = null,
-): LLFirModuleResolveState =
-    LLFirResolveStateService.createResolveStateFor(
+): LLFirResolveSession =
+    LLFirResolveSessionService.createFirResolveSessionFor(
         useSiteKtModule = useSiteKtModule,
         sessionProviderStorage = LLFirSessionProviderStorage(project),
         configureSession = configureSession

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirResolveSession.kt

@@ -20,7 +20,10 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 
-abstract class LLFirModuleResolveState {
+/**
+ * An entry point for a FIR Low Level API resolution. Represents a project view from a use-site [KtModule].
+ */
+abstract class LLFirResolveSession {
     abstract val project: Project
 
     abstract val useSiteFirSession: FirSession

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacade.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
@@ -20,18 +20,18 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 
 /**
- * Returns [LLFirModuleResolveState] which corresponds to containing module
+ * Returns [LLFirResolveSession] which corresponds to containing module
  */
-fun KtElement.getResolveState(): LLFirModuleResolveState {
+fun KtElement.getFirResolveSession(): LLFirResolveSession {
     val project = project
-    return getKtModule(project).getResolveState(project)
+    return getKtModule(project).getFirResolveSession(project)
 }
 
 /**
- * Returns [LLFirModuleResolveState] which corresponds to containing module
+ * Returns [LLFirResolveSession] which corresponds to containing module
  */
-fun KtModule.getResolveState(project: Project): LLFirModuleResolveState =
-    LLFirResolveStateService.getInstance(project).getResolveState(this)
+fun KtModule.getFirResolveSession(project: Project): LLFirResolveSession =
+    LLFirResolveSessionService.getInstance(project).getFirResolveSession(this)
 
 
 /**
@@ -40,10 +40,10 @@ fun KtModule.getResolveState(project: Project): LLFirModuleResolveState =
  *
  */
 fun KtDeclaration.resolveToFirSymbol(
-    resolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
     phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
 ): FirBasedSymbol<*> {
-    return resolveState.resolveToFirSymbol(this, phase)
+    return firResolveSession.resolveToFirSymbol(this, phase)
 }
 
 /**
@@ -54,10 +54,10 @@ fun KtDeclaration.resolveToFirSymbol(
  */
 @Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
 inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfType(
-    resolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
     phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
 ): @kotlin.internal.NoInfer S {
-    val symbol = resolveToFirSymbol(resolveState, phase)
+    val symbol = resolveToFirSymbol(firResolveSession, phase)
     if (symbol !is S) {
         throwUnexpectedFirElementError(symbol, this, S::class)
     }
@@ -72,10 +72,10 @@ inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTyp
  */
 @Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
 inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTypeSafe(
-    resolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
     phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
 ): @kotlin.internal.NoInfer S? {
-    return resolveToFirSymbol(resolveState, phase) as? S
+    return resolveToFirSymbol(firResolveSession, phase) as? S
 }
 
 
@@ -83,18 +83,18 @@ inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTyp
  * Returns a list of Diagnostics compiler finds for given [KtElement]
  * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
-fun KtElement.getDiagnostics(resolveState: LLFirModuleResolveState, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic> =
-    resolveState.getDiagnostics(this, filter)
+fun KtElement.getDiagnostics(firResolveSession: LLFirResolveSession, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic> =
+    firResolveSession.getDiagnostics(this, filter)
 
 /**
  * Returns a list of Diagnostics compiler finds for given [KtFile]
  * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 fun KtFile.collectDiagnosticsForFile(
-    resolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
     filter: DiagnosticCheckerFilter
 ): Collection<KtPsiDiagnostic> =
-    resolveState.collectDiagnosticsForFile(this, filter)
+    firResolveSession.collectDiagnosticsForFile(this, filter)
 
 /**
  * Get a [FirElement] which was created by [KtElement]
@@ -104,8 +104,8 @@ fun KtFile.collectDiagnosticsForFile(
  * The `null` value is returned iff FIR tree does not have corresponding element
  */
 fun KtElement.getOrBuildFir(
-    resolveState: LLFirModuleResolveState,
-): FirElement? = resolveState.getOrBuildFirFor(this)
+    firResolveSession: LLFirResolveSession,
+): FirElement? = firResolveSession.getOrBuildFirFor(this)
 
 /**
  * Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], `null` otherwise
@@ -113,8 +113,8 @@ fun KtElement.getOrBuildFir(
  * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
-    resolveState: LLFirModuleResolveState,
-) = getOrBuildFir(resolveState) as? E
+    firResolveSession: LLFirResolveSession,
+) = getOrBuildFir(firResolveSession) as? E
 
 /**
  * Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], throws [InvalidFirElementTypeException] otherwise
@@ -122,9 +122,9 @@ inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
  * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType(
-    resolveState: LLFirModuleResolveState,
+    firResolveSession: LLFirResolveSession,
 ): E {
-    val fir = this.getOrBuildFir(resolveState)
+    val fir = getOrBuildFir(firResolveSession)
     if (fir is E) return fir
     throwUnexpectedFirElementError(fir, this, E::class)
 }
@@ -133,5 +133,5 @@ inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType(
  * Get a [FirFile] which was created by [KtElement]
  * Returned [FirFile] can be resolved to any phase from [FirResolvePhase.RAW_FIR] to [FirResolvePhase.BODY_RESOLVE]
  */
-fun KtFile.getOrBuildFirFile(resolveState: LLFirModuleResolveState): FirFile =
-    resolveState.getOrBuildFirFile(this)
+fun KtFile.getOrBuildFirFile(firResolveSession: LLFirResolveSession): FirFile =
+    firResolveSession.getOrBuildFirFile(this)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt

@@ -9,7 +9,8 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
 import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.DeclarationCopyBuilder.withBodyFrom
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateDepended
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionDepended
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FileTowerProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerDataContextAllElementsCollector
@@ -19,7 +20,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMap
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
@@ -64,15 +64,15 @@ object LowLevelFirApiFacadeForResolveOnAir {
     }
 
     fun <T : KtElement> onAirResolveElement(
-        state: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
         place: T,
         elementToResolve: T,
     ): FirElement {
-        require(state is LLFirResolvableModuleResolveState)
+        require(firResolveSession is LLFirResolvableResolveSession)
         require(place.isPhysical)
 
         val declaration = runBodyResolveOnAir(
-            state = state,
+            firResolveSession = firResolveSession,
             replacement = RawFirReplacement(place, elementToResolve),
             onAirCreatedDeclaration = true
         )
@@ -93,13 +93,13 @@ object LowLevelFirApiFacadeForResolveOnAir {
     }
 
     fun onAirGetTowerContextProvider(
-        state: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
         place: KtElement,
     ): FirTowerContextProvider {
-        require(state is LLFirResolvableModuleResolveState)
+        require(firResolveSession is LLFirResolvableResolveSession)
 
         return if (place is KtFile) {
-            FileTowerProvider(place, onAirGetTowerContextForFile(state, place))
+            FileTowerProvider(place, onAirGetTowerContextForFile(firResolveSession, place))
         } else {
             val validPlace = PsiTreeUtil.findFirstParent(place, false) {
                 RawFirReplacement.isApplicableForReplacement(it as KtElement)
@@ -107,7 +107,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
 
             FirTowerDataContextAllElementsCollector().also {
                 runBodyResolveOnAir(
-                    state = state,
+                    firResolveSession = firResolveSession,
                     collector = it,
                     onAirCreatedDeclaration = false,
                     replacement = RawFirReplacement(validPlace, validPlace),
@@ -117,16 +117,16 @@ object LowLevelFirApiFacadeForResolveOnAir {
     }
 
     private fun onAirGetTowerContextForFile(
-        state: LLFirResolvableModuleResolveState,
+        firResolveSession: LLFirResolvableResolveSession,
         file: KtFile,
     ): FirTowerDataContext {
         require(file.isPhysical)
-        val session = state.getSessionFor(file.getKtModule(state.project)) as LLFirResolvableModuleSession
+        val session = firResolveSession.getSessionFor(file.getKtModule(firResolveSession.project)) as LLFirResolvableModuleSession
         val moduleComponents = session.moduleComponents
 
         val firFile = moduleComponents.firFileBuilder.buildRawFirFileWithCaching(file)
 
-        val scopeSession = state.getScopeSessionFor(session)
+        val scopeSession = firResolveSession.getScopeSessionFor(session)
         moduleComponents.lazyFirDeclarationsResolver.lazyResolveFileDeclaration(
             firFile = firFile,
             scopeSession = scopeSession,
@@ -138,19 +138,19 @@ object LowLevelFirApiFacadeForResolveOnAir {
         return FirTowerDataContext().addNonLocalTowerDataElements(fileScopeElements)
     }
 
-    fun getResolveStateForDependentCopy(
-        originalState: LLFirModuleResolveState,
+    fun getFirResolveSessionForDependentCopy(
+        originalFirResolveSession: LLFirResolveSession,
         originalKtFile: KtFile,
         elementToAnalyze: KtElement
-    ): LLFirModuleResolveState {
-        require(originalState is LLFirResolvableModuleResolveState)
+    ): LLFirResolveSession {
+        require(originalFirResolveSession is LLFirResolvableResolveSession)
         require(elementToAnalyze !is KtFile) { "KtFile for dependency element not supported" }
-        require(!elementToAnalyze.isPhysical) { "Depended state should be build only for non-physical elements" }
+        require(!elementToAnalyze.isPhysical) { "Depended session should be build only for non-physical elements" }
 
         val dependencyNonLocalDeclaration = findEnclosingNonLocalDeclaration(elementToAnalyze)
-            ?: return FirModuleResolveStateDepended(
-                originalState,
-                FileTowerProvider(elementToAnalyze.containingKtFile, onAirGetTowerContextForFile(originalState, originalKtFile)),
+            ?: return LLFirResolveSessionDepended(
+                originalFirResolveSession,
+                FileTowerProvider(elementToAnalyze.containingKtFile, onAirGetTowerContextForFile(originalFirResolveSession, originalKtFile)),
                 ktToFirMapping = null
             )
 
@@ -165,14 +165,14 @@ object LowLevelFirApiFacadeForResolveOnAir {
 
         val collector = FirTowerDataContextAllElementsCollector()
         val copiedFirDeclaration = runBodyResolveOnAir(
-            originalState,
+            originalFirResolveSession,
             replacement = RawFirReplacement(sameDeclarationInOriginalFile, dependencyNonLocalDeclaration),
             onAirCreatedDeclaration = true,
             collector = collector,
         )
 
         val mapping = KtToFirMapping(copiedFirDeclaration, FirElementsRecorder())
-        return FirModuleResolveStateDepended(originalState, collector, mapping)
+        return LLFirResolveSessionDepended(originalFirResolveSession, collector, mapping)
     }
 
     private fun tryResolveAsFileAnnotation(
@@ -202,13 +202,13 @@ object LowLevelFirApiFacadeForResolveOnAir {
     }
 
     private fun runBodyResolveOnAir(
-        state: LLFirResolvableModuleResolveState,
+        firResolveSession: LLFirResolvableResolveSession,
         replacement: RawFirReplacement,
         onAirCreatedDeclaration: Boolean,
         collector: FirTowerDataContextCollector? = null,
     ): FirElement {
         val nonLocalDeclaration = findEnclosingNonLocalDeclaration(replacement.from)
-        val originalFirFile = state.getOrBuildFirFile(replacement.from.containingKtFile)
+        val originalFirFile = firResolveSession.getOrBuildFirFile(replacement.from.containingKtFile)
 
         if (nonLocalDeclaration == null) {
             //It is possible that it is file annotation is going to resolve
@@ -225,7 +225,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
             }
         }
 
-        val originalDeclaration = nonLocalDeclaration.getOrBuildFirOfType<FirDeclaration>(state)
+        val originalDeclaration = nonLocalDeclaration.getOrBuildFirOfType<FirDeclaration>(firResolveSession)
 
         val originalDesignation = originalDeclaration.collectDesignation()
 
@@ -239,7 +239,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
 
         val isInBodyReplacement = isInBodyReplacement(nonLocalDeclaration, replacement)
 
-        return state.globalComponents.lockProvider.runCustomResolveUnderLock(originalFirFile, true) {
+        return firResolveSession.globalComponents.lockProvider.runCustomResolveUnderLock(originalFirFile, true) {
             val copiedFirDeclaration = if (isInBodyReplacement) {
                 when (originalDeclaration) {
                     is FirSimpleFunction ->
@@ -299,12 +299,12 @@ object LowLevelFirApiFacadeForResolveOnAir {
     fun onAirResolveTypeInPlace(
         place: KtElement,
         typeReference: KtTypeReference,
-        state: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
     ): FirResolvedTypeRef {
-        val context = state.getTowerContextProvider(place.containingKtFile).getClosestAvailableParentContext(place)
+        val context = firResolveSession.getTowerContextProvider(place.containingKtFile).getClosestAvailableParentContext(place)
             ?: error("TowerContext not found for ${place.getElementTextInContext()}")
 
-        val session = state.useSiteFirSession
+        val session = firResolveSession.useSiteFirSession
         val firTypeReference = buildFirUserTypeRef(
             typeReference = typeReference,
             session = session,

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/FirElementBuilder.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveCompone
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureElement
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.declarationCanBeLazilyResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
@@ -60,10 +60,10 @@ internal class FirElementBuilder(
 
     fun getOrBuildFirFor(
         element: KtElement,
-        state: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
     ): FirElement? = when (element) {
         is KtFile -> getOrBuildFirForKtFile(element)
-        else -> getOrBuildFirForNonKtFileElement(element, state)
+        else -> getOrBuildFirForNonKtFileElement(element, firResolveSession)
     }
 
     private fun getOrBuildFirForKtFile(ktFile: KtFile): FirFile {
@@ -79,7 +79,7 @@ internal class FirElementBuilder(
 
     private fun getOrBuildFirForNonKtFileElement(
         element: KtElement,
-        state: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
     ): FirElement? {
         require(element !is KtFile)
 
@@ -92,8 +92,8 @@ internal class FirElementBuilder(
 
         val mappings = fileStructure.getStructureElementFor(element).mappings
         val psi = getPsiAsFirElementSource(element) ?: return null
-        return mappings.getFirOfClosestParent(psi, state)
-            ?: state.getOrBuildFirFile(firFile)
+        return mappings.getFirOfClosestParent(psi, firResolveSession)
+            ?: firResolveSession.getOrBuildFirFile(firFile)
     }
 
     @TestOnly

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FileStructureCache.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import java.util.concurrent.ConcurrentHashMap
 
 /**
- * Belongs to a [org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState]
+ * Belongs to a [org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession]
  */
 internal class FileStructureCache(private val moduleResolveComponents: LLFirModuleResolveComponents) {
     private val cache = ConcurrentHashMap<KtFile, FileStructure>()

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FileStructureElement.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.FileDiagnosticRetriever
@@ -35,7 +35,7 @@ internal class KtToFirMapping(firElement: FirElement, recorder: FirElementsRecor
     private val mapping = FirElementsRecorder.recordElementsFrom(firElement, recorder)
     private val userTypeMapping = ConcurrentHashMap<KtUserType, FirElement>()
 
-    fun getElement(ktElement: KtElement, state: LLFirModuleResolveState): FirElement? {
+    fun getElement(ktElement: KtElement, firResolveSession: LLFirResolveSession): FirElement? {
         mapping[ktElement]?.let { return it }
 
         val userType = when (ktElement) {
@@ -49,15 +49,15 @@ internal class KtToFirMapping(firElement: FirElement, recorder: FirElementsRecor
 
         return userTypeMapping.getOrPut(userType) {
             val typeReference = KtPsiFactory(ktElement.project).createType(userType.text)
-            LowLevelFirApiFacadeForResolveOnAir.onAirResolveTypeInPlace(ktElement, typeReference, state)
+            LowLevelFirApiFacadeForResolveOnAir.onAirResolveTypeInPlace(ktElement, typeReference, firResolveSession)
         }
     }
 
-    fun getFirOfClosestParent(element: KtElement, state: LLFirModuleResolveState): FirElement? {
+    fun getFirOfClosestParent(element: KtElement, firResolveSession: LLFirResolveSession): FirElement? {
         var current: PsiElement? = element
         while (current != null && current !is KtFile) {
             if (current is KtElement) {
-                getElement(current, state)?.let { return it }
+                getElement(current, firResolveSession)?.let { return it }
             }
             current = current.parent
         }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
 
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.persistentListOf
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
 import org.jetbrains.kotlin.analysis.providers.KotlinAnnotationsResolver
@@ -72,8 +72,8 @@ internal class LLFirIdePredicateBasedProvider(
             this !is KtProperty
         ) return null
 
-        val resolveState = this.getResolveState()
-        return this.resolveToFirSymbol(resolveState).fir
+        val firResolveSession = this.getFirResolveSession()
+        return this.resolveToFirSymbol(firResolveSession).fir
     }
 
     override fun getOwnersOfDeclaration(declaration: FirDeclaration): List<FirBasedSymbol<*>>? {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.resolver
 
 import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol
 import org.jetbrains.kotlin.fir.FirSession
@@ -24,14 +24,14 @@ class AllCandidatesResolver(firSession: FirSession) {
     private val resolutionContext = ResolutionContext(firSession, bodyResolveComponents, bodyResolveComponents.transformer.context)
 
     fun getAllCandidates(
-        resolveState: LLFirModuleResolveState,
+        firResolveSession: LLFirResolveSession,
         functionCall: FirFunctionCall,
         calleeName: Name,
         element: KtElement
     ): List<OverloadCandidate> {
-        initializeBodyResolveContext(resolveState, element)
+        initializeBodyResolveContext(firResolveSession, element)
 
-        val firFile = element.containingKtFile.getOrBuildFirFile(resolveState)
+        val firFile = element.containingKtFile.getOrBuildFirFile(firResolveSession)
         return bodyResolveComponents.context.withFile(firFile, bodyResolveComponents) {
             bodyResolveComponents.callResolver.collectAllCandidates(
                 functionCall,
@@ -43,12 +43,12 @@ class AllCandidatesResolver(firSession: FirSession) {
     }
 
     @OptIn(PrivateForInline::class, SymbolInternals::class)
-    private fun initializeBodyResolveContext(resolveState: LLFirModuleResolveState, element: KtElement) {
+    private fun initializeBodyResolveContext(firResolveSession: LLFirResolveSession, element: KtElement) {
         // Set up needed context to get all candidates.
-        val towerContext = resolveState.getTowerContextProvider(element.containingKtFile).getClosestAvailableParentContext(element)
+        val towerContext = firResolveSession.getTowerContextProvider(element.containingKtFile).getClosestAvailableParentContext(element)
         towerContext?.let { bodyResolveComponents.context.replaceTowerDataContext(it) }
         val containingDeclarations =
-            element.parentsOfType<KtDeclaration>().map { it.resolveToFirSymbol(resolveState).fir }.toList().asReversed()
+            element.parentsOfType<KtDeclaration>().map { it.resolveToFirSymbol(firResolveSession).fir }.toList().asReversed()
         bodyResolveComponents.context.containers.addAll(containingDeclarations)
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirLibraryOrLibrarySourceResolvableResolveSession.kt

@@ -16,12 +16,12 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 
 
-internal class LLFirLibraryOrLibrarySourceResolvableModuleResolveState(
+internal class LLFirLibraryOrLibrarySourceResolvableResolveSession(
     override val globalComponents: LLFirGlobalResolveComponents,
     override val project: Project,
     override val useSiteKtModule: KtModule,
     sessionProvider: LLFirSessionProvider,
-) : LLFirResolvableModuleResolveState(sessionProvider) {
+) : LLFirResolvableResolveSession(sessionProvider) {
     override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> =
         emptyList()
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.state
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLocalContainingOrThisDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firModuleData
@@ -34,9 +34,9 @@ import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.psi.*
 
-internal abstract class LLFirResolvableModuleResolveState(
+internal abstract class LLFirResolvableResolveSession(
     private val sessionProvider: LLFirSessionProvider,
-) : LLFirModuleResolveState() {
+) : LLFirResolveSession() {
     abstract val globalComponents: LLFirGlobalResolveComponents
 
     final override val useSiteFirSession = sessionProvider.rootModuleSession

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirSourceResolveSession.kt

@@ -20,12 +20,12 @@ import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 
-internal class LLFirSourceModuleResolveState(
+internal class LLFirSourceResolveSession(
     override val globalComponents: LLFirGlobalResolveComponents,
     override val project: Project,
     override val useSiteKtModule: KtModule,
     sessionProvider: LLFirSessionProvider,
-) : LLFirResolvableModuleResolveState(sessionProvider) {
+) : LLFirResolvableResolveSession(sessionProvider) {
     override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> {
         val moduleComponents = getModuleComponentsForElement(element)
         return moduleComponents.diagnosticsCollector.getDiagnosticsFor(element, filter)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/TowerProviderForElementForState.kt

@@ -5,26 +5,26 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.state
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateDepended
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionDepended
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider
 import org.jetbrains.kotlin.fir.declarations.FirTowerDataContext
 import org.jetbrains.kotlin.psi.KtElement
 
-internal class TowerProviderForElementForState(private val state: LLFirModuleResolveState) : FirTowerContextProvider {
+internal class TowerProviderForElementForState(private val firResolveSession: LLFirResolveSession) : FirTowerContextProvider {
     override fun getClosestAvailableParentContext(ktElement: KtElement): FirTowerDataContext? {
-        if (state is FirModuleResolveStateDepended) {
-            state.towerProviderBuiltUponElement
+        if (firResolveSession is LLFirResolveSessionDepended) {
+            firResolveSession.towerProviderBuiltUponElement
                 .getClosestAvailableParentContext(ktElement)
                 ?.let { return it }
 
             return LowLevelFirApiFacadeForResolveOnAir
-                .onAirGetTowerContextProvider(state.originalState, ktElement)
+                .onAirGetTowerContextProvider(firResolveSession.originalFirResolveSession, ktElement)
                 .getClosestAvailableParentContext(ktElement)
         }
         return LowLevelFirApiFacadeForResolveOnAir
-            .onAirGetTowerContextProvider(state, ktElement)
+            .onAirGetTowerContextProvider(firResolveSession, ktElement)
             .getClosestAvailableParentContext(ktElement)
     }
 }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyBodiesCalculatorTest.kt

@@ -31,8 +31,8 @@ abstract class AbstractFirLazyBodiesCalculatorTest : AbstractLowLevelApiSingleFi
     }
 
     override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) {
-        resolveWithClearCaches(ktFile) { resolveState ->
-            val session = resolveState.useSiteFirSession
+        resolveWithClearCaches(ktFile) { firResolveSession ->
+            val session = firResolveSession.useSiteFirSession
             val provider = session.kotlinScopeProvider
 
             val laziedFirFile = RawFirBuilder(

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyDeclarationResolveTest.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirRenderer
@@ -53,23 +53,23 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
     override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) {
         val rendererOption = FirRenderer.RenderMode.WithDeclarationAttributes.copy(renderDeclarationResolvePhase = true)
         val resultBuilder = StringBuilder()
-        resolveWithClearCaches(ktFile) { firModuleResolveState ->
-            check(firModuleResolveState is LLFirSourceModuleResolveState)
-            val declarationToResolve = firModuleResolveState
+        resolveWithClearCaches(ktFile) { firResolveSession ->
+            check(firResolveSession is LLFirSourceResolveSession)
+            val declarationToResolve = firResolveSession
                 .getOrBuildFirFile(ktFile)
                 .findResolveMe()
             for (currentPhase in FirResolvePhase.values()) {
                 if (currentPhase == FirResolvePhase.SEALED_CLASS_INHERITORS) continue
                 declarationToResolve.ensureResolved(currentPhase)
-                val firFile = firModuleResolveState.getOrBuildFirFile(ktFile)
+                val firFile = firResolveSession.getOrBuildFirFile(ktFile)
                 resultBuilder.append("\n${currentPhase.name}:\n")
                 resultBuilder.append(firFile.render(rendererOption))
             }
         }
 
-        resolveWithClearCaches(ktFile) { firModuleResolveState ->
-            check(firModuleResolveState is LLFirSourceModuleResolveState)
-            val firFile = firModuleResolveState.getOrBuildFirFile(ktFile)
+        resolveWithClearCaches(ktFile) { firResolveSession ->
+            check(firResolveSession is LLFirSourceResolveSession)
+            val firFile = firResolveSession.getOrBuildFirFile(ktFile)
             firFile.ensureResolved(FirResolvePhase.BODY_RESOLVE)
             resultBuilder.append("\nFILE RAW TO BODY:\n")
             resultBuilder.append(firFile.render(rendererOption))

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirOnAirResolveTest.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.render
@@ -32,9 +32,9 @@ abstract class AbstractFirOnAirResolveTest : AbstractLowLevelApiSingleFileTest()
 
         check(place::class == onAir::class)
 
-        resolveWithClearCaches(ktFile) { resolveState ->
-            check(resolveState is LLFirSourceModuleResolveState)
-            val firElement = LowLevelFirApiFacadeForResolveOnAir.onAirResolveElement(resolveState, place, onAir)
+        resolveWithClearCaches(ktFile) { firResolveSession ->
+            check(firResolveSession is LLFirSourceResolveSession)
+            val firElement = LowLevelFirApiFacadeForResolveOnAir.onAirResolveElement(firResolveSession, place, onAir)
             val rendered = firElement.render(FirRenderer.RenderMode.WithResolvePhases)
             testServices.assertions.assertEqualsToTestDataFileSibling(rendered)
         }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.createResolveStateForNoCaching
+import org.jetbrains.kotlin.analysis.low.level.api.fir.createFirResolveSessionForNoCaching
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer
 import org.jetbrains.kotlin.analysis.test.framework.AbstractCompilerBasedTest
 import org.jetbrains.kotlin.analysis.test.framework.base.registerAnalysisApiBaseTestServices
@@ -67,21 +67,21 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() {
             val ktModule = moduleInfoProvider.getModule(module.name) as KtSourceModuleByCompilerConfiguration
 
             val project = testServices.compilerConfigurationProvider.getProject(module)
-            val resolveState = createResolveStateForNoCaching(ktModule, project)
+            val firResolveSession = createFirResolveSessionForNoCaching(ktModule, project)
 
             val allFirFiles =
                 module.files.filter { it.isKtFile }.zip(
                     ktModule.psiFiles
                         .filterIsInstance<KtFile>()
-                        .map { psiFile -> psiFile.getOrBuildFirFile(resolveState) }
+                        .map { psiFile -> psiFile.getOrBuildFirFile(firResolveSession) }
                 )
 
             val diagnosticCheckerFilter = if (FirDiagnosticsDirectives.WITH_EXTENDED_CHECKERS in module.directives) {
                 DiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS
             } else DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS
 
-            val analyzerFacade = LowLevelFirAnalyzerFacade(resolveState, allFirFiles.toMap(), diagnosticCheckerFilter)
-            return LowLevelFirOutputArtifact(resolveState.useSiteFirSession, analyzerFacade)
+            val analyzerFacade = LowLevelFirAnalyzerFacade(firResolveSession, allFirFiles.toMap(), diagnosticCheckerFilter)
+            return LowLevelFirOutputArtifact(firResolveSession.useSiteFirSession, analyzerFacade)
         }
     }
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.test.model.TestFile
 
 class LowLevelFirAnalyzerFacade(
-    val resolveState: LLFirModuleResolveState,
+    val firResolveSession: LLFirResolveSession,
     val allFirFiles: Map<TestFile, FirFile>,
     private val diagnosticCheckerFilter: DiagnosticCheckerFilter,
 ) : AbstractFirAnalyzerFacade() {
@@ -33,7 +33,7 @@ class LowLevelFirAnalyzerFacade(
         findSealedInheritors()
         return allFirFiles.values.associateWith { firFile ->
             val ktFile = firFile.psi as KtFile
-            val diagnostics = ktFile.collectDiagnosticsForFile(resolveState, diagnosticCheckerFilter)
+            val diagnostics = ktFile.collectDiagnosticsForFile(firResolveSession, diagnosticCheckerFilter)
             @Suppress("UNCHECKED_CAST")
             diagnostics.toList() as List<KtDiagnostic>
         }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/SealedClassesInheritorsCaclulatorPreAnalysisHandler.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
 import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
 import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -41,8 +41,8 @@ class SealedClassesInheritorsCaclulatorPreAnalysisHandler(
             val allFirFiles = mutableListOf<FirFile>()
             ktFiles.forEach { ktFile ->
                 val ktModule = ktModuleProvider.getKtModuleForKtElement(ktFile)
-                val resolveState = ktModule.getResolveState(project)
-                allFirFiles.add(ktFile.getOrBuildFirFile(resolveState))
+                val firResolveSession = ktModule.getFirResolveSession(project)
+                allFirFiles.add(ktFile.getOrBuildFirFile(firResolveSession))
             }
             allFirFiles.groupBy { it.moduleData.session }.forEach { (session, firFiles) ->
                 for (firFile in firFiles) {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/AbstractDiagnosticTraversalCounterTest.kt

@@ -41,11 +41,11 @@ abstract class AbstractDiagnosticTraversalCounterTest  : AbstractLowLevelApiSing
                 @OptIn(SessionConfiguration::class)
                 register(BeforeElementDiagnosticCollectionHandler::class, handler)
             }
-        ) { resolveState ->
+        ) { firResolveSession ->
             // we should get diagnostics before we resolve the whole file by  ktFile.getOrBuildFir
-            ktFile.collectDiagnosticsForFile(resolveState, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS)
+            ktFile.collectDiagnosticsForFile(firResolveSession, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS)
 
-            val firFile = ktFile.getOrBuildFirOfType<FirFile>(resolveState)
+            val firFile = ktFile.getOrBuildFirOfType<FirFile>(firResolveSession)
 
             val errorElements = collectErrorElements(firFile, handler)
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/AbstractFirContextCollectionTest.kt

@@ -11,11 +11,10 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStack
 import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getDiagnostics
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.BeforeElementDiagnosticCollectionHandler
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistenceContextCollector
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureElement
@@ -43,19 +42,19 @@ abstract class AbstractFirContextCollectionTest : AbstractLowLevelApiSingleFileT
                 @OptIn(SessionConfiguration::class)
                 register(BeforeElementDiagnosticCollectionHandler::class, handler)
             }
-        ) { resolveState ->
-            check(resolveState is LLFirSourceModuleResolveState)
+        ) { firResolveSession ->
+            check(firResolveSession is LLFirSourceResolveSession)
 
-            val session = resolveState.getSessionFor(ktFile.getKtModule()) as LLFirResolvableModuleSession
+            val session = firResolveSession.getSessionFor(ktFile.getKtModule()) as LLFirResolvableModuleSession
             val fileStructureCache = session.moduleComponents.fileStructureCache
 
             val fileStructure = fileStructureCache.getFileStructure(ktFile)
             val allStructureElements = fileStructure.getAllStructureElements()
 
             handler.elementsToCheckContext = allStructureElements.map { it.getFirDeclaration() }
-            handler.firFile = ktFile.getOrBuildFirFile(resolveState)
+            handler.firFile = ktFile.getOrBuildFirFile(firResolveSession)
 
-            ktFile.getDiagnostics(resolveState, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS)
+            ktFile.getDiagnostics(firResolveSession, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS)
         }
     }
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/AbstractFileStructureTest.kt

@@ -9,8 +9,8 @@ import com.intellij.psi.PsiComment
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.impl.source.tree.LeafPsiElement
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
@@ -87,8 +87,8 @@ abstract class AbstractFileStructureTest : AbstractLowLevelApiSingleFileTest() {
     }
 
     private fun KtFile.getFileStructure(): FileStructure {
-        val moduleResolveState = getResolveState() as LLFirSourceModuleResolveState
-        val session = moduleResolveState.getSessionFor(getKtModule()) as LLFirResolvableModuleSession
+        val moduleFirResolveSession = getFirResolveSession() as LLFirSourceResolveSession
+        val session = moduleFirResolveSession.getSessionFor(getKtModule()) as LLFirResolvableModuleSession
         return session.moduleComponents.fileStructureCache.getFileStructure(this)
     }
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/firTestUtils.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
 import org.jetbrains.kotlin.psi.KtElement
@@ -37,9 +37,9 @@ internal fun FirDeclaration.name(): String = symbol.name()
 internal inline fun <R> resolveWithClearCaches(
     context: KtElement,
     noinline configureSession: LLFirSession.() -> Unit = {},
-    action: (LLFirModuleResolveState) -> R,
+    action: (LLFirResolveSession) -> R,
 ): R {
     val project = context.project
-    val resolveState = createResolveStateForNoCaching(context.getKtModule(project), project, configureSession)
-    return action(resolveState)
+    val firResolveSession = createFirResolveSessionForNoCaching(context.getKtModule(project), project, configureSession)
+    return action(firResolveSession)
 }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/resolve/AbstractInnerDeclarationsResolvePhaseTest.kt

@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.test.services.assertions
 
 abstract class AbstractInnerDeclarationsResolvePhaseTest : AbstractLowLevelApiSingleFileTest() {
     override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) {
-        resolveWithClearCaches(ktFile) { resolveState ->
-            val firFile = ktFile.getOrBuildFirOfType<FirFile>(resolveState)
+        resolveWithClearCaches(ktFile) { firResolveSession ->
+            val firFile = ktFile.getOrBuildFirOfType<FirFile>(firResolveSession)
             val actual = firFile.render(FirRenderer.RenderMode.WithResolvePhases)
             testServices.assertions.assertEqualsToTestDataFileSibling(actual, extension = ".fir.txt")
         }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/AnalysisApiFirTestServiceRegistrar.kt

@@ -12,7 +12,7 @@ import com.intellij.psi.impl.PsiElementFinderImpl
 import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.LLFirSealedClassInheritorsProcessorFactoryForTests
@@ -41,7 +41,7 @@ object AnalysisApiFirTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
         project.apply {
             registerService(KtAnalysisSessionProvider::class.java, KtFirAnalysisSessionProvider(this))
             registerService(FirSealedClassInheritorsProcessorFactory::class.java, LLFirSealedClassInheritorsProcessorFactoryForTests())
-            registerService(LLFirResolveStateService::class.java)
+            registerService(LLFirResolveSessionService::class.java)
             registerService(PackagePartProviderFactory::class.java, PackagePartProviderTestImpl(testServices))
 
             registerService(SymbolLightClassFacadeCache::class.java)