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

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)