FIR IDE: make FirModuleResolveState functions to be internal

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/FirModuleResolveState.kt

@@ -21,39 +21,34 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 
 abstract class FirModuleResolveState {
-    abstract val moduleInfo: IdeaModuleInfo
     abstract val rootModuleSession: FirSession
 
+    internal abstract val moduleInfo: IdeaModuleInfo
+
     abstract val firTransformerProvider: FirTransformerProvider
 
-    abstract fun getSessionFor(moduleInfo: IdeaModuleInfo): FirSession
+    internal abstract fun getSessionFor(moduleInfo: IdeaModuleInfo): FirSession
 
-    abstract fun getOrBuildFirFor(element: KtElement): FirElement
+    internal abstract fun getOrBuildFirFor(element: KtElement): FirElement
 
-    abstract fun getFirFile(ktFile: KtFile): FirFile
+    internal abstract fun getFirFile(ktFile: KtFile): FirFile
 
-    abstract fun getDiagnostics(element: KtElement): List<Diagnostic>
+    internal abstract fun getDiagnostics(element: KtElement): List<Diagnostic>
 
-    abstract fun collectDiagnosticsForFile(ktFile: KtFile): Collection<Diagnostic>
+    internal abstract fun collectDiagnosticsForFile(ktFile: KtFile): Collection<Diagnostic>
 
     // todo temporary, used only in completion
-    abstract fun recordPsiToFirMappingsForCompletionFrom(fir: FirDeclaration, firFile: FirFile, ktFile: KtFile)
+    internal abstract fun recordPsiToFirMappingsForCompletionFrom(fir: FirDeclaration, firFile: FirFile, ktFile: KtFile)
 
-    abstract fun <D : FirDeclaration> resolvedFirToPhase(declaration: D, toPhase: FirResolvePhase): D
+    internal abstract fun <D : FirDeclaration> resolvedFirToPhase(declaration: D, toPhase: FirResolvePhase): D
 
     // todo temporary, used only in completion
-    abstract fun lazyResolveDeclarationForCompletion(
+    internal abstract fun lazyResolveDeclarationForCompletion(
         firFunction: FirDeclaration,
         containerFirFile: FirFile,
         firIdeProvider: FirProvider,
         toPhase: FirResolvePhase,
         towerDataContextCollector: FirTowerDataContextCollector
     )
-
 }
 
-
-internal fun KtElement.firResolveState(): FirModuleResolveState =
-    FirIdeResolveStateService.getInstance(project).getResolveState(getModuleInfo())
-
-

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

@@ -8,12 +8,20 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.api
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
+import org.jetbrains.kotlin.idea.fir.low.level.api.FirIdeResolveStateService
 import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 
 object LowLevelFirApiFacade {
     fun getResolveStateFor(element: KtElement): FirModuleResolveState =
-        element.firResolveState()
+        getResolveStateFor(element.getModuleInfo())
+
+    fun getResolveStateFor(moduleInfo: IdeaModuleInfo): FirModuleResolveState =
+        FirIdeResolveStateService.getInstance(moduleInfo.project!!).getResolveState(moduleInfo)
 
     fun getSessionFor(element: KtElement): FirSession =
         getResolveStateFor(element).getSessionFor(element.getModuleInfo())
@@ -21,7 +29,20 @@ object LowLevelFirApiFacade {
     fun getOrBuildFirFor(element: KtElement, resolveState: FirModuleResolveState): FirElement =
         resolveState.getOrBuildFirFor(element)
 
-    fun getDiagnosticsFor(element: KtElement, resolveState: FirModuleResolveState): Collection<Diagnostic> {
-        return resolveState.getDiagnostics(element)
-    }
+    fun getFirFile(ktFile: KtFile, resolveState: FirModuleResolveState) =
+        resolveState.getFirFile(ktFile)
+
+    fun getDiagnosticsFor(element: KtElement, resolveState: FirModuleResolveState): Collection<Diagnostic> =
+        resolveState.getDiagnostics(element)
+
+    fun collectDiagnosticsForFile(ktFile: KtFile, resolveState: FirModuleResolveState): Collection<Diagnostic> =
+        resolveState.collectDiagnosticsForFile(ktFile)
+
+    fun <D : FirDeclaration> resolvedFirToPhase(
+        firDeclaration: D,
+        phase: FirResolvePhase,
+        resolveState: FirModuleResolveState
+    ): D =
+        resolveState.resolvedFirToPhase(firDeclaration, phase)
+
 }

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
 import org.jetbrains.kotlin.idea.fir.getOrBuildFirOfType
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacadeForCompletion
 import org.jetbrains.kotlin.idea.fir.low.level.api.resolver.ResolutionParameters
 import org.jetbrains.kotlin.idea.fir.low.level.api.resolver.SingleCandidateResolutionMode
 import org.jetbrains.kotlin.idea.fir.low.level.api.resolver.SingleCandidateResolver
@@ -67,7 +68,7 @@ internal class KtFirCompletionCandidateChecker(
         nameExpression: KtSimpleNameExpression,
         possibleExplicitReceiver: KtExpression?,
     ): Boolean {
-        val file = firResolveState.getFirFile(originalFile)
+        val file = LowLevelFirApiFacade.getFirFile(originalFile, firResolveState)
         val explicitReceiverExpression = possibleExplicitReceiver?.getOrBuildFirOfType<FirExpression>(firResolveState)
         val resolver = SingleCandidateResolver(firResolveState.rootModuleSession, file)
         val implicitReceivers = getImplicitReceivers(originalFile, file, nameExpression)

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

@@ -23,5 +23,5 @@ internal class KtFirDiagnosticProvider(
     }
 
     override fun collectDiagnosticsForFile(ktFile: KtFile): Collection<Diagnostic> =
-        firResolveState.collectDiagnosticsForFile(ktFile)
+        LowLevelFirApiFacade.getDiagnosticsFor(ktFile, firResolveState)
 }

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

@@ -128,7 +128,7 @@ internal class KtFirScopeProvider(
         originalFile: KtFile,
         positionInFakeFile: KtElement
     ): LowLevelFirApiFacadeForCompletion.FirCompletionContext {
-        val originalFirFile = firResolveState.getFirFile(originalFile)
+        val originalFirFile = LowLevelFirApiFacade.getFirFile(originalFile, firResolveState)
         val declarationContext = EnclosingDeclarationContext.detect(originalFile, positionInFakeFile)
 
         return declarationContext.buildCompletionContext(originalFirFile, firResolveState)

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRef.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.utils
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner
 import org.jetbrains.kotlin.idea.frontend.api.assertIsValid
@@ -22,7 +23,7 @@ internal class FirRef<D : FirDeclaration>(fir: D, resolveState: FirModuleResolve
         val fir = firWeakRef.get() ?: error("FirElement was garbage collected while analysis session is still valid")
         val resolveState =
             resolveStateWeakRef.get() ?: error("FirModuleResolveState was garbage collected while analysis session is still valid")
-        return action(resolveState.resolvedFirToPhase(fir, phase))
+        return action(LowLevelFirApiFacade.resolvedFirToPhase(fir, phase, resolveState))
     }
 
     inline fun <R> withFirAndCache(phase: FirResolvePhase = FirResolvePhase.RAW_FIR, crossinline createValue: (fir: D) -> R) =