[LL FIR] drop ScopeSession parameter from LLFirModuleLazyDeclarationResolver

This parameter was required for on-air analysis
to avoid garbage in the original scope session.
Now we can drop it, and it will be less error-prone

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir
 
-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.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
 import org.jetbrains.kotlin.fir.declarations.FirClass
@@ -19,35 +19,26 @@ internal class LLFirLazyDeclarationResolver : FirLazyDeclarationResolver() {
     override fun finishResolvingPhase(phase: FirResolvePhase) {}
 
     override fun lazyResolveToPhase(element: FirElementWithResolveState, toPhase: FirResolvePhase) {
-        val session = element.moduleData.session
+        val session = element.llFirResolvableSession ?: return
-        if (session !is LLFirResolvableModuleSession) return
+        session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolve(
-        val moduleComponents = session.moduleComponents
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolve(
             target = element,
-            scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
             toPhase = toPhase,
         )
     }
 
     override fun lazyResolveToPhaseWithCallableMembers(clazz: FirClass, toPhase: FirResolvePhase) {
         val fir = clazz as? FirRegularClass ?: return
-        val session = fir.moduleData.session
+        val session = fir.llFirResolvableSession ?: return
-        if (session !is LLFirResolvableModuleSession) return
+        session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolveWithCallableMembers(
-        val moduleComponents = session.moduleComponents
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolveWithCallableMembers(
             target = fir,
-            scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
             toPhase = toPhase,
         )
     }
 
     override fun lazyResolveToPhaseRecursively(element: FirElementWithResolveState, toPhase: FirResolvePhase) {
-        val session = element.moduleData.session
+        val session = element.llFirResolvableSession ?: return
-        if (session !is LLFirResolvableModuleSession) return
+        session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolveRecursively(
-        val moduleComponents = session.moduleComponents
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolveRecursively(
             target = element,
-            scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
             toPhase = toPhase,
         )
     }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
 import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry
 import org.jetbrains.kotlin.fir.visitors.transformSingle
@@ -28,13 +27,10 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
      *
      * Resolution is performed under the lock specific to each declaration that is going to be resolved.
      */
-    fun lazyResolve(
+    fun lazyResolve(target: FirElementWithResolveState, toPhase: FirResolvePhase) {
-        target: FirElementWithResolveState,
-        scopeSession: ScopeSession,
-        toPhase: FirResolvePhase,
-    ) {
         if (target.resolvePhase >= toPhase) return
-        lazyResolve(target, scopeSession, toPhase, LLFirResolveDesignationCollector::getDesignationToResolve)
+
+        lazyResolve(target, toPhase, LLFirResolveDesignationCollector::getDesignationToResolve)
     }
 
     /**
@@ -44,12 +40,8 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
      *
      * Resolution is performed under the lock specific to each declaration that is going to be resolved.
      */
-    fun lazyResolveWithCallableMembers(
+    fun lazyResolveWithCallableMembers(target: FirRegularClass, toPhase: FirResolvePhase) {
-        target: FirRegularClass,
+        lazyResolve(target, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveWithCallableMembers)
-        scopeSession: ScopeSession,
-        toPhase: FirResolvePhase,
-    ) {
-        lazyResolve(target, scopeSession, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveWithCallableMembers)
     }
 
     /**
@@ -59,17 +51,12 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
      *
      * Resolution is performed under the lock specific to each declaration that is going to be resolved.
      */
-    fun lazyResolveRecursively(
+    fun lazyResolveRecursively(target: FirElementWithResolveState, toPhase: FirResolvePhase) {
-        target: FirElementWithResolveState,
+        lazyResolve(target, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveRecursively)
-        scopeSession: ScopeSession,
-        toPhase: FirResolvePhase,
-    ) {
-        lazyResolve(target, scopeSession, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveRecursively)
     }
 
     private inline fun <T : FirElementWithResolveState> lazyResolve(
         targetElement: T,
-        scopeSession: ScopeSession,
         toPhase: FirResolvePhase,
         resolveTarget: (T) -> LLFirResolveTarget?,
     ) {
@@ -79,11 +66,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
             if (toPhase == FirResolvePhase.IMPORTS) return
 
             val target = resolveTarget(targetElement) ?: return
-            lazyResolveTargets(
+            lazyResolveTargets(target, toPhase)
-                target,
-                scopeSession,
-                toPhase,
-            )
         } catch (e: Exception) {
             handleExceptionFromResolve(e, targetElement, fromPhase, toPhase)
         }
@@ -105,11 +88,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
             target.firFile?.let(::resolveFileToImportsWithLock)
             if (toPhase == FirResolvePhase.IMPORTS) return
 
-            lazyResolveTargets(
+            lazyResolveTargets(target, toPhase)
-                target,
-                moduleComponents.scopeSessionProvider.getScopeSession(),
-                toPhase,
-            )
         } catch (e: Exception) {
             handleExceptionFromResolve(e, target, toPhase)
         }
@@ -127,28 +106,20 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         }
     }
 
-    private fun lazyResolveTargets(
+    private fun lazyResolveTargets(target: LLFirResolveTarget, toPhase: FirResolvePhase) {
-        target: LLFirResolveTarget,
-        scopeSession: ScopeSession,
-        toPhase: FirResolvePhase,
-    ) {
         var currentPhase = getMinResolvePhase(target).coerceAtLeast(FirResolvePhase.IMPORTS)
         if (currentPhase >= toPhase) return
 
-        val lockProvider = moduleComponents.globalResolveComponents.lockProvider
-
         // to catch a contract violation for jumping phases
-        lockProvider.checkContractViolations(toPhase)
+        moduleComponents.globalResolveComponents.lockProvider.checkContractViolations(toPhase)
 
         while (currentPhase < toPhase) {
             currentPhase = currentPhase.next
             checkCanceled()
 
             LLFirLazyResolverRunner.runLazyResolverByPhase(
-                currentPhase,
+                phase = currentPhase,
-                target,
+                target = target,
-                scopeSession,
-                lockProvider,
             )
         }
     }

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.*
@@ -21,11 +22,8 @@ import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment
  * @see LLFirTargetResolver
  */
 internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) {
-    fun resolve(
+    fun resolve(target: LLFirResolveTarget, lockProvider: LLFirLockProvider) {
-        target: LLFirResolveTarget,
+        val scopeSession = target.target.llFirSession.getScopeSession()
-        lockProvider: LLFirLockProvider,
-        scopeSession: ScopeSession,
-    ) {
         val resolver = createTargetResolver(target, lockProvider, scopeSession)
         requireWithAttachment(
             resolverPhase == resolver.resolverPhase,

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

@@ -5,22 +5,21 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
-import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.session
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
 
 internal object LLFirLazyResolverRunner {
     fun runLazyResolverByPhase(
         phase: FirResolvePhase,
         target: LLFirResolveTarget,
-        scopeSession: ScopeSession,
-        lockProvider: LLFirLockProvider,
     ) {
         val lazyResolver = LLFirLazyPhaseResolverByPhase.getByPhase(phase)
+        val lockProvider = LLFirGlobalResolveComponents.getInstance(target.session).lockProvider
         lockProvider.withGlobalLock {
             lockProvider.withGlobalPhaseLock(phase) {
-                lazyResolver.resolve(target, lockProvider, scopeSession)
+                lazyResolver.resolve(target, lockProvider)
             }
         }