[LL FIR] do not use LLFirModuleLazyDeclarationResolver directly

use lazyResolveToPhase instead for consistency

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

@@ -40,6 +40,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
 import org.jetbrains.kotlin.analysis.utils.errors.*
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 
@@ -126,11 +127,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
         val firFile = moduleComponents.firFileBuilder.buildRawFirFileWithCaching(file)
 
         val scopeSession = firResolveSession.getScopeSessionFor(session)
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolveFileDeclaration(
+        firFile.lazyResolveToPhase(FirResolvePhase.IMPORTS)
-            firFile = firFile,
-            scopeSession = scopeSession,
-            toPhase = FirResolvePhase.IMPORTS
-        )
 
         val importingScopes = createImportingScopes(firFile, firFile.moduleData.session, scopeSession, useCaching = false)
         val fileScopeElements = importingScopes.map { it.asTowerDataElement(isLocal = false) }

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

@@ -9,14 +9,15 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.ThreadSafe
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
-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.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.isNonAnonymousClassOrObject
 import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
@@ -67,12 +68,7 @@ internal class FirElementBuilder(
 
     private fun getOrBuildFirForKtFile(ktFile: KtFile): FirFile {
         val firFile = moduleComponents.firFileBuilder.buildRawFirFileWithCaching(ktFile)
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolveFileDeclaration(
+        firFile.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
-            firFile = firFile,
-            toPhase = FirResolvePhase.BODY_RESOLVE,
-            scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
-            checkPCE = true
-        )
         return firFile
     }
 

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.psi.*
 import java.util.concurrent.ConcurrentHashMap
 
@@ -102,12 +103,7 @@ internal class FileStructure private constructor(
             firProvider,
             firFile
         )
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolveDeclaration(
+        firDeclaration.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
-            firDeclarationToResolve = firDeclaration,
-            scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
-            toPhase = FirResolvePhase.BODY_RESOLVE,
-            checkPCE = true,
-        )
         return FileElementFactory.createFileStructureElement(
             firDeclaration = firDeclaration,
             ktDeclaration = declaration,

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.scopes.kotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.psi.*
 import java.util.concurrent.ConcurrentHashMap
 
@@ -125,12 +126,7 @@ internal class ReanalyzableFunctionStructureElement(
                 it.replaceResolvePhase(minOf(it.resolvePhase, upgradedPhase))
             }
 
-            moduleComponents.firModuleLazyDeclarationResolver.lazyResolveDeclaration(
+            originalFunction.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
-                firDeclarationToResolve = originalFunction,
-                scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
-                toPhase = FirResolvePhase.BODY_RESOLVE,
-                checkPCE = true,
-            )
 
             ReanalyzableFunctionStructureElement(
                 firFile,
@@ -179,13 +175,7 @@ internal class ReanalyzablePropertyStructureElement(
                 replaceBodyResolveState(FirPropertyBodyResolveState.NOTHING_RESOLVED)
             }
 
-            moduleComponents.firModuleLazyDeclarationResolver.lazyResolveDeclaration(
+            originalProperty.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
-                firDeclarationToResolve = originalProperty,
-                scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
-                toPhase = FirResolvePhase.BODY_RESOLVE,
-                checkPCE = true,
-            )
-
 
             ReanalyzablePropertyStructureElement(
                 firFile,

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

@@ -119,7 +119,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         }
     }
 
-    fun lazyResolveFileDeclaration(
+    private fun lazyResolveFileDeclaration(
         firFile: FirFile,
         toPhase: FirResolvePhase,
         scopeSession: ScopeSession,

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

@@ -10,9 +10,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveCompone
 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.llFirModuleData
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibrarySession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.FirDeclarationForCompiledElementSearcher
@@ -21,7 +18,9 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.findSourceNonLocalFi
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
 import org.jetbrains.kotlin.analysis.utils.errors.requireIsInstance
+import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
 import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
@@ -34,9 +33,11 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
-import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.analysis.utils.errors.*
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
 
 internal abstract class LLFirResolvableResolveSession(
     private val sessionProvider: LLFirSessionProvider,
@@ -133,16 +134,7 @@ internal abstract class LLFirResolvableResolveSession(
     }
 
     override fun resolveFirToPhase(declaration: FirDeclaration, toPhase: FirResolvePhase) {
-        if (toPhase == FirResolvePhase.RAW_FIR) return
+        declaration.lazyResolveToPhase(toPhase)
-        val llFirResolvableModuleSession = declaration.llFirModuleData.session as? LLFirResolvableModuleSession ?: return
-
-        val moduleComponents = llFirResolvableModuleSession.moduleComponents
-        moduleComponents.firModuleLazyDeclarationResolver.lazyResolveDeclaration(
-            firDeclarationToResolve = declaration,
-            scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
-            toPhase = toPhase,
-            checkPCE = true,
-        )
     }
 
     override fun getTowerContextProvider(ktFile: KtFile): FirTowerContextProvider {

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

@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.runCustomResolveUnderLock
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirModuleLazyDeclarationResolver
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.*
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.toSymbol
 
 /**
@@ -80,17 +81,9 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
             for (nowVisit in toVisit) {
                 if (checkPCE) checkCanceled()
                 val resolver = DesignatedFirSupertypeResolverVisitor(nowVisit)
-                val session = nowVisit.firFile.llFirResolvableSession
+                nowVisit.firFile.lazyResolveToPhase(FirResolvePhase.IMPORTS)
-                if (session != null) {
+                lockProvider.runCustomResolveUnderLock(nowVisit.firFile, checkPCE) {
-                    lockProvider.runCustomResolveUnderLock(nowVisit.firFile, checkPCE) {
+                    nowVisit.firFile.accept(resolver, null)
-                        session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolveFileDeclaration(
-                            firFile = nowVisit.firFile,
-                            toPhase = FirResolvePhase.IMPORTS,
-                            scopeSession = scopeSession,
-                            checkPCE = checkPCE,
-                        )
-                        nowVisit.firFile.accept(resolver, null)
-                    }
                 }
                 resolver.declarationTransformer.ensureDesignationPassed()
                 visited[nowVisit.declaration] = nowVisit