FIR IDE: get rid of LowLevelFirApiFacade object

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

@@ -15,6 +15,8 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
+import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.InternalForInline
+import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
@@ -92,14 +94,17 @@ internal class FirModuleResolveStateForCompletion(
         error("Diagnostics should not be retrieved in completion")
     }
 
+    @OptIn(InternalForInline::class)
     override fun findNonLocalSourceFirDeclaration(ktDeclaration: KtDeclaration): FirDeclaration {
         error("Should not be used in completion")
     }
 
+    @OptIn(InternalForInline::class)
     override fun findSourceFirDeclaration(ktDeclaration: KtDeclaration): FirDeclaration {
         error("Should not be used in completion")
     }
 
+    @OptIn(InternalForInline::class)
     override fun findSourceFirDeclaration(ktDeclaration: KtLambdaExpression): FirDeclaration {
         error("Should not be used in completion")
     }

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
+import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.InternalForInline
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.fir.low.level.api.diagnostics.DiagnosticsCollector
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirElementBuilder
@@ -71,6 +72,7 @@ internal class FirModuleResolveStateImpl(
         error("Should be called only from FirModuleResolveStateForCompletion")
     }
 
+    @OptIn(InternalForInline::class)
     override fun findNonLocalSourceFirDeclaration(
         ktDeclaration: KtDeclaration,
     ): FirDeclaration = ktDeclaration.findSourceNonLocalFirDeclaration(
@@ -79,9 +81,11 @@ internal class FirModuleResolveStateImpl(
         sessionProvider.getModuleCache(ktDeclaration.getModuleInfo() as ModuleSourceInfo)
     )
 
+    @OptIn(InternalForInline::class)
     override fun findSourceFirDeclaration(ktDeclaration: KtDeclaration): FirDeclaration =
         findSourceFirDeclarationByExpression(ktDeclaration)
 
+    @OptIn(InternalForInline::class)
     override fun findSourceFirDeclaration(ktDeclaration: KtLambdaExpression): FirDeclaration =
         findSourceFirDeclarationByExpression(ktDeclaration)
 

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

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.idea.fir.low.level.api.annotations
 
-@Target(AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.CLASS)
 @RequiresOptIn
-annotation class PrivateForInline
+annotation class PrivateForInline
+
+@RequiresOptIn
+annotation class InternalForInline

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

@@ -17,6 +17,8 @@ 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.idea.fir.low.level.api.FirTransformerProvider
+import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.InternalForInline
+import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
@@ -52,14 +54,17 @@ abstract class FirModuleResolveState {
     @TestOnly
     internal abstract fun getBuiltFirFileOrNull(ktFile: KtFile): FirFile?
 
+    @InternalForInline
     abstract fun findNonLocalSourceFirDeclaration(
         ktDeclaration: KtDeclaration,
     ): FirDeclaration
 
+    @InternalForInline
     abstract fun findSourceFirDeclaration(
         ktDeclaration: KtDeclaration,
     ): FirDeclaration
 
+    @InternalForInline
     abstract fun findSourceFirDeclaration(
         ktDeclaration: KtLambdaExpression,
     ): FirDeclaration

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

@@ -7,113 +7,92 @@ 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.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
-import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 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.idea.fir.low.level.api.sessions.FirIdeSourcesSession
+import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.InternalForInline
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtLambdaExpression
 import kotlin.reflect.KClass
 
-object LowLevelFirApiFacade {
+fun KtElement.getResolveState(): FirModuleResolveState =
-    fun getResolveStateFor(element: KtElement): FirModuleResolveState =
+    getModuleInfo().getResolveState()
-        getResolveStateFor(element.getModuleInfo())
 
-    fun getResolveStateFor(moduleInfo: IdeaModuleInfo): FirModuleResolveState =
+fun IdeaModuleInfo.getResolveState(): FirModuleResolveState =
-        FirIdeResolveStateService.getInstance(moduleInfo.project!!).getResolveState(moduleInfo)
+    FirIdeResolveStateService.getInstance(project!!).getResolveState(this)
 
-    fun getSessionFor(element: KtElement): FirSession =
+fun KtFile.getFirFile(resolveState: FirModuleResolveState) =
-        getResolveStateFor(element).getSessionFor(element.getModuleInfo())
+    resolveState.getFirFile(this)
 
-    fun getOrBuildFirFor(element: KtElement, resolveState: FirModuleResolveState): FirElement =
+/**
-        resolveState.getOrBuildFirFor(element)
+ * Creates [FirDeclaration] by [KtDeclaration] and runs an [action] with it
-
+ * [this@withFirDeclaration]
-    fun getFirFile(ktFile: KtFile, resolveState: FirModuleResolveState) =
+ * [FirDeclaration] passed to [action] should not be leaked outside [action] lambda
-        resolveState.getFirFile(ktFile)
+ * [FirDeclaration] passed to [action] will be resolved at least to [phase]
-
+ * Otherwise, some threading problems may arise,
-    /**
+ *
-     * Creates [FirDeclaration] by [KtDeclaration] and runs an [action] with it
+ * [this@withFirDeclaration] should be non-local declaration (should have fully qualified name)
-     * [ktDeclaration]
+ */
-     * [FirDeclaration] passed to [action] should not be leaked outside [action] lambda
+@OptIn(InternalForInline::class)
-     * [FirDeclaration] passed to [action] will be resolved at least to [phase]
+inline fun <R> KtDeclaration.withFirDeclaration(
-     * Otherwise, some threading problems may arise,
+    resolveState: FirModuleResolveState,
-     *
+    phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
-     * [ktDeclaration] should be non-local declaration (should have fully qualified name)
+    action: (FirDeclaration) -> R
-     */
+): R {
-    inline fun <R> withFirDeclaration(
+    val firDeclaration = resolveState.findSourceFirDeclaration(this)
-        ktDeclaration: KtDeclaration,
+    firDeclaration.resolvedFirToPhase(phase, resolveState)
-        resolveState: FirModuleResolveState,
+    return action(firDeclaration)
-        phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
-        action: (FirDeclaration) -> R
-    ): R {
-        val firDeclaration = resolveState.findSourceFirDeclaration(ktDeclaration)
-        resolvedFirToPhase(firDeclaration, phase, resolveState)
-        return action(firDeclaration)
-    }
-
-    inline fun <reified F : FirDeclaration, R> withFirDeclarationOfType(
-        ktDeclaration: KtDeclaration,
-        resolveState: FirModuleResolveState,
-        action: (F) -> R
-    ): R {
-        val firDeclaration = resolveState.findSourceFirDeclaration(ktDeclaration)
-        if (firDeclaration !is F) throw InvalidFirElementTypeException(ktDeclaration, F::class, firDeclaration::class)
-        return action(firDeclaration)
-    }
-
-    inline fun <reified F : FirDeclaration, R> withFirDeclarationOfType(
-        ktDeclaration: KtLambdaExpression,
-        resolveState: FirModuleResolveState,
-        action: (F) -> R
-    ): R {
-        val firDeclaration = resolveState.findSourceFirDeclaration(ktDeclaration)
-        if (firDeclaration !is F) throw InvalidFirElementTypeException(ktDeclaration, F::class, firDeclaration::class)
-        return action(firDeclaration)
-    }
-
-    inline fun <F : FirElement, R> withFir(fir: F, action: (F) -> R): R {
-        // TODO locking
-        return action(fir)
-    }
-
-    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)
 }
 
+@OptIn(InternalForInline::class)
+inline fun <reified F : FirDeclaration, R> KtDeclaration.withFirDeclarationOfType(
+    resolveState: FirModuleResolveState,
+    action: (F) -> R
+): R {
+    val firDeclaration = resolveState.findSourceFirDeclaration(this)
+    if (firDeclaration !is F) throw InvalidFirElementTypeException(this, F::class, firDeclaration::class)
+    return action(firDeclaration)
+}
+
+@OptIn(InternalForInline::class)
+inline fun <reified F : FirDeclaration, R> KtLambdaExpression.withFirDeclarationOfType(
+    resolveState: FirModuleResolveState,
+    action: (F) -> R
+): R {
+    val firDeclaration = resolveState.findSourceFirDeclaration(this)
+    if (firDeclaration !is F) throw InvalidFirElementTypeException(this, F::class, firDeclaration::class)
+    return action(firDeclaration)
+}
+
+fun getDiagnosticsFor(element: KtElement, resolveState: FirModuleResolveState): Collection<Diagnostic> =
+    resolveState.getDiagnostics(element)
+
+fun KtFile.collectDiagnosticsForFile(resolveState: FirModuleResolveState): Collection<Diagnostic> =
+    resolveState.collectDiagnosticsForFile(this)
+
+fun <D : FirDeclaration> D.resolvedFirToPhase(
+    phase: FirResolvePhase,
+    resolveState: FirModuleResolveState
+): D =
+    resolveState.resolvedFirToPhase(this, phase)
 
 
 fun KtElement.getOrBuildFir(
     resolveState: FirModuleResolveState,
-) = LowLevelFirApiFacade.getOrBuildFirFor(this, resolveState)
+) = resolveState.getOrBuildFirFor(this)
 
 inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
     resolveState: FirModuleResolveState,
-) = LowLevelFirApiFacade.getOrBuildFirFor(this, resolveState) as? E
+) = getOrBuildFir(resolveState) as? E
 
 inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType(
     resolveState: FirModuleResolveState,
 ): E {
-    val fir = LowLevelFirApiFacade.getOrBuildFirFor(this, resolveState)
+    val fir = this.getOrBuildFir(resolveState)
     if (fir is E) return fir
     throw InvalidFirElementTypeException(this, E::class, fir::class)
 }

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

@@ -1,69 +0,0 @@
-/*
- * Copyright 2010-2020 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.idea.fir.low.level.api.api
-
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
-import org.jetbrains.kotlin.psi.KtDeclaration
-import java.lang.ref.WeakReference
-import kotlin.reflect.KClass
-
-
-/**
- * Lazy [FirDeclaration] reference which allows to find corresponding non-local [FirDeclaration] by [KtDeclaration]
- * Builds declaration only when [withFir] is called or some other entity already built it
- * Allows approximately to check if we already have corresponding [FirDeclaration] built by [isFirDeclarationAlreadyBuilt]
- *
- * To create one consider using [weakByPsiRef]
- */
-class WeakFirByPsiRef<KT : KtDeclaration, FIR : FirDeclaration> @PrivateForInline constructor(
-    val ktDeclaration: KT,
-    @PrivateForInline val firClass: KClass<FIR>,
-    resolveState: FirModuleResolveState,
-) {
-    @PrivateForInline
-    val resolveStateWeakRef = WeakReference(resolveState)
-
-    /**
-     * Checks if corresponding [FirDeclaration] is available now
-     * If return true consequent call to [withFir] will not build new RAW_FIR as it is already built
-     * If return false consequent call to [withFir] will build new [FirDeclaration]
-     * if it was not build between [isFirDeclarationAlreadyBuilt] & [withFir] calls
-     *
-     * Should be used with caution as this is only approximation and may return inaccurate results
-     */
-    @OptIn(PrivateForInline::class)
-    fun isFirDeclarationAlreadyBuilt(): Boolean {
-        val resolveState = resolveStateWeakRef.get()
-            ?: error("FirModuleResolveState was garbage collected")
-        return resolveState.isFirFileBuilt(ktDeclaration.containingKtFile)
-    }
-
-    /**
-     * Creates [FirDeclaration] by [KtDeclaration] if it is not created previously and runs an [action] with it
-     * [FirDeclaration] passed to [action] should not be leaked outside [action] lambda
-     * Otherwise, some threading problems may arise.`
-     *
-     * [FirDeclaration] passed to [action] will be resolved at least to [phase]
-     **/
-    @OptIn(PrivateForInline::class)
-    inline fun <R> withFir(phase: FirResolvePhase = FirResolvePhase.RAW_FIR, action: (fir: FIR) -> R): R {
-        val resolveState = resolveStateWeakRef.get()
-            ?: error("FirModuleResolveState was garbage collected")
-        return LowLevelFirApiFacade.withFirDeclaration(ktDeclaration, resolveState, phase) { fir ->
-            if (!firClass.isInstance(fir)) throw InvalidFirElementTypeException(ktDeclaration, firClass, fir::class)
-            @Suppress("UNCHECKED_CAST")
-            action(fir as FIR)
-        }
-    }
-}
-
-@OptIn(PrivateForInline::class)
-inline fun <KT : KtDeclaration, reified FIR : FirDeclaration> weakByPsiRef(
-    ktDeclaration: KT,
-    resolveState: FirModuleResolveState,
-) = WeakFirByPsiRef(ktDeclaration, FIR::class, resolveState)

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

@@ -1,28 +0,0 @@
-/*
- * Copyright 2010-2020 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.idea.fir.low.level.api.api
-
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
-import java.lang.ref.WeakReference
-
-class WeakFirRef<D : FirDeclaration>(fir: D, resolveState: FirModuleResolveState) {
-    @PrivateForInline
-    val firWeakRef = WeakReference(fir)
-
-    @PrivateForInline
-    val resolveStateWeakRef = WeakReference(resolveState)
-
-    @OptIn(PrivateForInline::class)
-    inline fun <R> withFir(phase: FirResolvePhase = FirResolvePhase.RAW_FIR, action: (fir: D) -> R): R {
-        val fir = firWeakRef.get()
-            ?: error("FirElement was garbage collected")
-        val resolveState = resolveStateWeakRef.get()
-            ?: error("FirModuleResolveState was garbage collected")
-        return action(LowLevelFirApiFacade.resolvedFirToPhase(fir, phase, resolveState))
-    }
-}

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

@@ -10,7 +10,7 @@ import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.withFirDeclaration
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -34,8 +34,7 @@ abstract class AbstractFirLazyDeclarationResolveTest : KotlinLightCodeInsightFix
         val declarationToResolve = lazyDeclarations.firstOrNull { it.name?.toLowerCase() == "resolveme" }
             ?: error("declaration with name `resolveMe` was not found")
         resolveWithClearCaches(ktFile) { firModuleResolveState ->
-            val rendered = LowLevelFirApiFacade.withFirDeclaration(
+            val rendered = declarationToResolve.withFirDeclaration(
-                declarationToResolve,
                 firModuleResolveState,
                 FirResolvePhase.BODY_RESOLVE
             ) @Suppress("UNUSED_ANONYMOUS_PARAMETER") { firDeclaration ->

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirLazyResolveTest.kt

@@ -20,7 +20,8 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.productionSourceInfo
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFir
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.firIdeProvider
 import org.jetbrains.kotlin.idea.jsonUtils.getString
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
@@ -67,8 +68,8 @@ abstract class AbstractFirLazyResolveTest : KotlinLightCodeInsightFixtureTestCas
             else -> elementToResolve
         } as KtExpression
 
-        val resolveState = LowLevelFirApiFacade.getResolveStateFor(expressionToResolve)
+        val resolveState = expressionToResolve.getResolveState()
-        val resultsDump = when (val firElement = resolveState.getOrBuildFirFor(expressionToResolve)) {
+        val resultsDump = when (val firElement = expressionToResolve.getOrBuildFir(resolveState)) {
             is FirResolvedImport -> buildString {
                 append("import ")
                 append(firElement.packageFqName)

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirMultiModuleLazyResolveTest.kt

@@ -9,7 +9,8 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFir
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiModuleTest
 import org.jetbrains.kotlin.idea.util.sourceRoots
 import org.jetbrains.kotlin.psi.KtFile
@@ -38,12 +39,12 @@ abstract class AbstractFirMultiModuleLazyResolveTest : AbstractMultiModuleTest()
         val virtualFileToAnalyse = VirtualFileManager.getInstance().findFileByUrl(fileToAnalysePath)
             ?: error("File ${testStructure.fileToResolve.filePath} not found")
         val ktFileToAnalyse = PsiManager.getInstance(project).findFile(virtualFileToAnalyse) as KtFile
-        val resolveState = LowLevelFirApiFacade.getResolveStateFor(ktFileToAnalyse)
+        val resolveState = ktFileToAnalyse.getResolveState()
 
         val fails = testStructure.fails
 
         try {
-            val fir = LowLevelFirApiFacade.getOrBuildFirFor(ktFileToAnalyse, resolveState)
+            val fir = ktFileToAnalyse.getOrBuildFir(resolveState)
             KotlinTestUtils.assertEqualsToFile(File("$path/expected.txt"), fir.render())
         } catch (e: Throwable) {
             if (!fails) throw e

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirResolveStateTest.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.idea.fir.low.level.api
 
 import org.jetbrains.kotlin.idea.AbstractResolveElementCacheTest
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState
 
 class FirResolveStateTest : AbstractResolveElementCacheTest() {
     override fun isFirPlugin(): Boolean = true
@@ -15,7 +15,7 @@ class FirResolveStateTest : AbstractResolveElementCacheTest() {
         doTest {
             val firstStatement = statements[0]
             val secondStatement = statements[1]
-            assertSame(LowLevelFirApiFacade.getResolveStateFor(firstStatement), LowLevelFirApiFacade.getResolveStateFor(secondStatement))
+            assertSame(firstStatement.getResolveState(), secondStatement.getResolveState())
         }
     }
 }

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/AbstractFileStructureAndOutOfBlockModificationTrackerConsistencyTest.kt

@@ -11,7 +11,7 @@ import com.intellij.psi.util.parentOfType
 import junit.framework.Assert
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirModuleResolveStateImpl
 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.fir.low.level.api.api.getResolveState
 import org.jetbrains.kotlin.idea.fir.low.level.api.trackers.AbstractProjectWideOutOfBlockKotlinModificationTrackerTest
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.psi.KtElement
@@ -57,7 +57,7 @@ abstract class AbstractFileStructureAndOutOfBlockModificationTrackerConsistencyT
         findElementAt(myFixture.caretOffset)!!.parentOfType()!!
 
     private fun getStructureElementForKtElement(element: KtElement): Triple<FileStructureElement, FileStructure, FirModuleResolveState> {
-        val moduleResolveState = LowLevelFirApiFacade.getResolveStateFor(element) as FirModuleResolveStateImpl
+        val moduleResolveState = element.getResolveState() as FirModuleResolveStateImpl
         val fileStructure =
             moduleResolveState.fileStructureCache.getFileStructure(element.containingKtFile, moduleResolveState.rootModuleSession.cache)
         val fileStructureElement = fileStructure.getStructureElementFor(element)

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

@@ -15,7 +15,7 @@ import com.intellij.psi.util.parentOfType
 import junit.framework.Assert
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirModuleResolveStateImpl
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState
 import org.jetbrains.kotlin.idea.search.getKotlinFqName
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.util.getElementTextInContext
@@ -70,7 +70,7 @@ abstract class AbstractFileStructureTest : KotlinLightCodeInsightFixtureTestCase
     }
 
     private fun KtFile.getFileStructure(): FileStructure {
-        val moduleResolveState = LowLevelFirApiFacade.getResolveStateFor(this) as FirModuleResolveStateImpl
+        val moduleResolveState = getResolveState() as FirModuleResolveStateImpl
         return moduleResolveState.fileStructureCache.getFileStructure(
             ktFile = this,
             moduleFileCache = moduleResolveState.rootModuleSession.cache

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

@@ -9,8 +9,6 @@ import com.intellij.openapi.module.ModuleManager
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
 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.fir.low.level.api.sessions.FirIdeSessionProviderStorage
 import org.jetbrains.kotlin.psi.KtElement
 
 internal fun Project.allModules() = ModuleManager.getInstance(this).modules.toList()

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/class/FirLightClassForFacade.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.types.ConeNullability
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
 import org.jetbrains.kotlin.idea.frontend.api.analyze
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind

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

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.idea.frontend.api.fir
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 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.fir.low.level.api.api.LowLevelFirApiFacadeForCompletion
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState
 import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.ReadActionConfinementValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
@@ -60,7 +60,7 @@ private constructor(
     companion object {
         @Deprecated("Please use org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSessionProviderKt.analyze")
         internal fun createForElement(element: KtElement): KtFirAnalysisSession {
-            val firResolveState = LowLevelFirApiFacade.getResolveStateFor(element)
+            val firResolveState = element.getResolveState()
             return createAnalysisSessionByResolveState(firResolveState)
         }
 

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

@@ -9,8 +9,8 @@ import com.jetbrains.rd.util.getOrCreate
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
-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.api.getFirFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType
 import org.jetbrains.kotlin.idea.fir.low.level.api.resolver.ResolutionParameters
 import org.jetbrains.kotlin.idea.fir.low.level.api.resolver.SingleCandidateResolutionMode
@@ -69,7 +69,7 @@ internal class KtFirCompletionCandidateChecker(
         nameExpression: KtSimpleNameExpression,
         possibleExplicitReceiver: KtExpression?,
     ): Boolean {
-        val file = LowLevelFirApiFacade.getFirFile(originalFile, firResolveState)
+        val file = originalFile.getFirFile(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

@@ -6,7 +6,8 @@
 package org.jetbrains.kotlin.idea.frontend.api.fir.components
 
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.collectDiagnosticsForFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getDiagnosticsFor
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.components.KtDiagnosticProvider
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession
@@ -19,9 +20,9 @@ internal class KtFirDiagnosticProvider(
     override val token: ValidityToken,
 ) : KtDiagnosticProvider(), KtFirAnalysisSessionComponent {
     override fun getDiagnosticsForElement(element: KtElement): Collection<Diagnostic> = withValidityAssertion {
-        LowLevelFirApiFacade.getDiagnosticsFor(element, firResolveState)
+        getDiagnosticsFor(element, firResolveState)
     }
 
     override fun collectDiagnosticsForFile(ktFile: KtFile): Collection<Diagnostic> =
-        LowLevelFirApiFacade.collectDiagnosticsForFile(ktFile, firResolveState)
+        ktFile.collectDiagnosticsForFile(firResolveState)
 }

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

@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 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.fir.low.level.api.api.LowLevelFirApiFacadeForCompletion
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getFirFile
 import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner
@@ -137,7 +137,7 @@ internal class KtFirScopeProvider(
         ktFile: KtFile,
         positionInFakeFile: KtElement
     ): LowLevelFirApiFacadeForCompletion.FirCompletionContext {
-        val firFile = LowLevelFirApiFacade.getFirFile(ktFile, firResolveState)
+        val firFile = ktFile.getFirFile(firResolveState)
         val declarationContext = EnclosingDeclarationContext.detect(ktFile, positionInFakeFile)
 
         return declarationContext.buildCompletionContext(firFile, firResolveState)

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

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 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.fir.low.level.api.api.getOrBuildFirOfType
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.withFirDeclarationOfType
 import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
@@ -33,68 +33,68 @@ internal class KtFirSymbolProvider(
     private val firSymbolProvider by weakRef(firSymbolProvider)
 
     override fun getParameterSymbol(psi: KtParameter): KtParameterSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirValueParameter, KtParameterSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirValueParameter, KtParameterSymbol>(resolveState) {
             firSymbolBuilder.buildParameterSymbol(it)
         }
     }
 
     override fun getFunctionSymbol(psi: KtNamedFunction): KtFunctionSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirSimpleFunction, KtFunctionSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirSimpleFunction, KtFunctionSymbol>(resolveState) {
             firSymbolBuilder.buildFunctionSymbol(it)
         }
     }
 
     override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirConstructor, KtConstructorSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirConstructor, KtConstructorSymbol>(resolveState) {
             firSymbolBuilder.buildConstructorSymbol(it)
         }
     }
 
     override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirTypeParameter, KtTypeParameterSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirTypeParameter, KtTypeParameterSymbol>(resolveState) {
             firSymbolBuilder.buildTypeParameterSymbol(it)
         }
     }
 
     override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirTypeAlias, KtTypeAliasSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirTypeAlias, KtTypeAliasSymbol>(resolveState) {
             firSymbolBuilder.buildTypeAliasSymbol(it)
         }
     }
 
     override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirEnumEntry, KtEnumEntrySymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirEnumEntry, KtEnumEntrySymbol>(resolveState) {
             firSymbolBuilder.buildEnumEntrySymbol(it)
         }
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirSimpleFunction, KtFunctionSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirSimpleFunction, KtFunctionSymbol>(resolveState) {
             firSymbolBuilder.buildFunctionSymbol(it)
         }
         firSymbolBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(resolveState))
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtLambdaExpression): KtAnonymousFunctionSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirAnonymousFunction, KtAnonymousFunctionSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirAnonymousFunction, KtAnonymousFunctionSymbol>(resolveState) {
             firSymbolBuilder.buildAnonymousFunctionSymbol(it)
         }
     }
 
     override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirProperty, KtVariableSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirProperty, KtVariableSymbol>(resolveState) {
             firSymbolBuilder.buildVariableSymbol(it)
         }
     }
 
     override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirRegularClass, KtClassOrObjectSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirRegularClass, KtClassOrObjectSymbol>(resolveState) {
             firSymbolBuilder.buildClassSymbol(it)
         }
     }
 
     override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
-        LowLevelFirApiFacade.withFirDeclarationOfType<FirPropertyAccessor, KtPropertyAccessorSymbol>(psi, resolveState) {
+        psi.withFirDeclarationOfType<FirPropertyAccessor, KtPropertyAccessorSymbol>(resolveState) {
             firSymbolBuilder.buildPropertyAccessorSymbol(it)
         }
     }

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

@@ -8,7 +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.fir.low.level.api.api.resolvedFirToPhase
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner
 import org.jetbrains.kotlin.idea.frontend.api.assertIsValid
@@ -24,7 +24,7 @@ internal class FirRefWithValidityCheck<D : FirDeclaration>(fir: D, resolveState:
             ?: throw EntityWasGarbageCollectedException("FirElement")
         val resolveState = resolveStateWeakRef.get()
             ?: throw EntityWasGarbageCollectedException("FirModuleResolveState")
-        LowLevelFirApiFacade.resolvedFirToPhase(fir, phase, resolveState)
+        fir.resolvedFirToPhase(phase, resolveState)
         return resolveState.withFirDeclaration(fir) { action(it) }
     }
 
@@ -34,7 +34,7 @@ internal class FirRefWithValidityCheck<D : FirDeclaration>(fir: D, resolveState:
             ?: throw EntityWasGarbageCollectedException("FirElement")
         val resolveState = resolveStateWeakRef.get()
             ?: throw EntityWasGarbageCollectedException("FirModuleResolveState")
-        LowLevelFirApiFacade.resolvedFirToPhase(fir, FirResolvePhase.BODY_RESOLVE, resolveState)
+        fir.resolvedFirToPhase(FirResolvePhase.BODY_RESOLVE, resolveState)
         return action(resolveState.withFirDeclaration(fir) { it })
     }
 

idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/AbstractKtDeclarationAndFirDeclarationEqualityChecker.kt

@@ -8,7 +8,8 @@ package org.jetbrains.kotlin.idea.fir
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.rt.execution.junit.FileComparisonFailure
 import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtFunction
@@ -19,9 +20,9 @@ abstract class AbstractKtDeclarationAndFirDeclarationEqualityChecker : KotlinLig
     protected fun doTest(path: String) {
         val file = File(path)
         val ktFile = myFixture.configureByText(file.name, FileUtil.loadFile(file)) as KtFile
-        val resolveState = LowLevelFirApiFacade.getResolveStateFor(ktFile)
+        val resolveState = ktFile.getResolveState()
         ktFile.forEachDescendantOfType<KtFunction> { ktFunction ->
-            val firFunction = LowLevelFirApiFacade.getOrBuildFirFor(ktFunction, resolveState) as FirFunction<*>
+            val firFunction = ktFunction.getOrBuildFirOfType<FirFunction<*>>(resolveState)
             if (!KtDeclarationAndFirDeclarationEqualityChecker.representsTheSameDeclaration(ktFunction, firFunction)) {
                 throw FileComparisonFailure(
                     /* message= */          null,