LL API: refactoring: replace FirIDE prefixes with LLFir prefixes

2022-01-31 16:26:11 +01:00
parent 4530041cbb
commit 6e999f6e84
94 changed files with 346 additions and 365 deletions
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.KtFakeSourceElement
 import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtRealPsiSourceElement
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.KtDeclarationAndFirDeclarationEqualityChecker
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
 import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
@@ -163,7 +163,7 @@ fun FirBasedSymbol<*>.findPsi(): PsiElement? =
    fir.findPsi(fir.moduleData.session)

 fun FirElement.findPsi(session: FirSession): PsiElement? =
-    findPsi((session as FirIdeSession).project)
+    findPsi((session as LLFirSession).project)

 /**
 * Finds [PsiElement] which will be used as go-to referenced element for [KtPsiReference]
@@ -171,4 +171,4 @@ fun FirElement.findPsi(session: FirSession): PsiElement? =
 * Otherwise, behaves the same way as [findPsi] returns exact PSI declaration corresponding to passed [FirDeclaration]
 */
 fun FirDeclaration.findReferencePsi(): PsiElement? =
-    psi ?: FirIdeDeserializedDeclarationSourceProvider.findPsi(this, (moduleData.session as FirIdeSession).project)
+    psi ?: FirIdeDeserializedDeclarationSourceProvider.findPsi(this, (moduleData.session as LLFirSession).project)
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirOverrideInfoProvider
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbolProvider
 import org.jetbrains.kotlin.analysis.api.fir.utils.threadLocal
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.moduleData
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.KtFile
 internal class KtFirAnalysisSession
 private constructor(
    private val project: Project,
-    val firResolveState: FirModuleResolveState,
+    val firResolveState: LLFirModuleResolveState,
    internal val firSymbolBuilder: KtSymbolByFirBuilder,
    token: ValidityToken,
    private val mode: AnalysisSessionMode,
@@ -119,7 +119,7 @@ private constructor(
    companion object {
        @InvalidWayOfUsingAnalysisSession
        internal fun createAnalysisSessionByResolveState(
-            firResolveState: FirModuleResolveState,
+            firResolveState: LLFirModuleResolveState,
            token: ValidityToken,
        ): KtFirAnalysisSession {
            val project = firResolveState.project
@@ -13,17 +13,17 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
 import org.jetbrains.kotlin.psi.KtElement

@OptIn(InvalidWayOfUsingAnalysisSession::class)
-class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<FirModuleResolveState>(project) {
-    override fun getResolveState(contextElement: KtElement): FirModuleResolveState {
+class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<LLFirModuleResolveState>(project) {
+    override fun getResolveState(contextElement: KtElement): LLFirModuleResolveState {
        return contextElement.getResolveState()
    }

-    override fun getResolveState(contextSymbol: KtSymbol): FirModuleResolveState {
+    override fun getResolveState(contextSymbol: KtSymbol): LLFirModuleResolveState {
        return when (contextSymbol) {
            is KtFirSymbol<*> -> contextSymbol.resolveState
            is KtFirBackingFieldSymbol -> contextSymbol.resolveState
@@ -32,7 +32,7 @@ class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionP
    }

    override fun createAnalysisSession(
-        resolveState: FirModuleResolveState,
+        resolveState: LLFirModuleResolveState,
        validityToken: ValidityToken,
    ): KtAnalysisSession {
        @Suppress("DEPRECATION")
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.providers.createPackageProvider
 import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.fir.*
@@ -53,7 +53,7 @@ import kotlin.contracts.contract
 */
 internal class KtSymbolByFirBuilder private constructor(
    private val project: Project,
-    resolveState: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    val withReadOnlyCaching: Boolean,
    private val symbolsCache: BuilderCache<FirBasedSymbol<*>, KtSymbol>,
@@ -74,7 +74,7 @@ internal class KtSymbolByFirBuilder private constructor(
    val typeBuilder = TypeBuilder()

    constructor(
-        resolveState: FirModuleResolveState,
+        resolveState: LLFirModuleResolveState,
        project: Project,
        token: ValidityToken
    ) : this(
@@ -88,7 +88,7 @@ internal class KtSymbolByFirBuilder private constructor(
        filesCache = BuilderCache(),
    )

-    fun createReadOnlyCopy(newResolveState: FirModuleResolveState): KtSymbolByFirBuilder {
+    fun createReadOnlyCopy(newResolveState: LLFirModuleResolveState): KtSymbolByFirBuilder {
        check(!withReadOnlyCaching) { "Cannot create readOnly KtSymbolByFirBuilder from a readonly one" }
        return KtSymbolByFirBuilder(
            project,
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
 import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
 import org.jetbrains.kotlin.analysis.api.fir.utils.computeImportableName
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions

 internal class KtFirImportOptimizer(
    override val token: ValidityToken,
-    private val firResolveState: FirModuleResolveState
+    private val firResolveState: LLFirModuleResolveState
 ) : KtImportOptimizer() {
    private val firSession: FirSession
        get() = firResolveState.rootModuleSession
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
@@ -64,7 +64,7 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 internal class KtFirReferenceShortener(
    override val analysisSession: KtFirAnalysisSession,
    override val token: ValidityToken,
-    override val firResolveState: FirModuleResolveState,
+    override val firResolveState: LLFirModuleResolveState,
 ) : KtReferenceShortener(), KtFirAnalysisSessionComponent {
    private val context = FirShorteningContext(firResolveState)

@@ -163,7 +163,7 @@ private data class AvailableSymbol<out T>(
    val importKind: ImportKind,
 )

-private class FirShorteningContext(val firResolveState: FirModuleResolveState) {
+private class FirShorteningContext(val firResolveState: LLFirModuleResolveState) {

    private val firSession: FirSession
        get() = firResolveState.rootModuleSession
@@ -281,7 +281,7 @@ private class ElementsToShortenCollector(
    private val selection: TextRange,
    private val classShortenOption: (FirClassLikeSymbol<*>) -> ShortenOption,
    private val callableShortenOption: (FirCallableSymbol<*>) -> ShortenOption,
-    private val firResolveState: FirModuleResolveState,
+    private val firResolveState: LLFirModuleResolveState,
 ) :
    FirVisitorVoid() {
    val namesToImport: MutableList<FqName> = mutableListOf()
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
@@ -50,7 +50,7 @@ internal class KtFirScopeProvider(
    analysisSession: KtFirAnalysisSession,
    builder: KtSymbolByFirBuilder,
    private val project: Project,
-    firResolveState: FirModuleResolveState,
+    firResolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
 ) : KtScopeProvider(), ValidityTokenOwner {
    override val analysisSession: KtFirAnalysisSession by weakRef(analysisSession)
@@ -16,14 +16,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isExtension

 internal class KtFirAnonymousFunctionSymbol(
    override val firSymbol: FirAnonymousFunctionSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> {
@@ -16,12 +16,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol

 internal class KtFirAnonymousObjectSymbol(
    override val firSymbol: FirAnonymousObjectSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> {
@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol

 internal class KtFirBackingFieldSymbol(
    override val firSymbol: FirBackingFieldSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingFieldSymbol> {
@@ -13,12 +13,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol

 internal class KtFirClassInitializerSymbol(
    override val firSymbol: FirAnonymousInitializerSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
 ) : KtClassInitializerSymbol(), KtFirSymbol<FirAnonymousInitializerSymbol> {
    override val psi: PsiElement? by cached { firSymbol.findPsi() }
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.name.ClassId

 internal class KtFirConstructorSymbol(
    override val firSymbol: FirConstructorSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtConstructorSymbol(), KtFirSymbol<FirConstructorSymbol> {
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
 import org.jetbrains.kotlin.name.CallableId
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirEnumEntrySymbol(
    override val firSymbol: FirEnumEntrySymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntrySymbol> {
@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithDeclaration
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol

 internal class KtFirFileSymbol(
    override val firSymbol: FirFileSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
 ) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol<FirFileSymbol> {
    override val psi: PsiElement? by cached { firSymbol.findPsi() }
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConst
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirFunctionSymbol(
    override val firSymbol: FirNamedFunctionSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtFunctionSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirJavaFieldSymbol(
    override val firSymbol: FirFieldSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtJavaFieldSymbol(), KtFirSymbol<FirFieldSymbol> {
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConst
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirKotlinPropertySymbol(
    override val firSymbol: FirPropertySymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtKotlinPropertySymbol(), KtFirSymbol<FirPropertySymbol> {
@@ -17,13 +17,13 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name

 internal class KtFirLocalVariableSymbol(
    override val firSymbol: FirPropertySymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtLocalVariableSymbol(),
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirNamedClassOrObjectSymbol(
    override val firSymbol: FirRegularClassSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClassSymbol> {
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.CallableId

 internal class KtFirPropertyGetterSymbol(
    override val firSymbol: FirPropertyAccessorSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.CallableId

 internal class KtFirPropertySetterSymbol(
    override val firSymbol: FirPropertyAccessorSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
@@ -17,13 +17,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.fir.originalOrSelf
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol

 internal class KtFirReceiverParameterSymbol(
    val firSymbol: FirCallableSymbol<*>,
-    val resolveState: FirModuleResolveState,
+    val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    _builder: KtSymbolByFirBuilder
 ) : KtReceiverParameterSymbol(), ValidityTokenOwner {
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isExtension
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirSamConstructorSymbol(
    override val firSymbol: FirNamedFunctionSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtSamConstructorSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 internal interface KtFirSymbol<out S : FirBasedSymbol<*>> : KtSymbol, ValidityTokenOwner {
    val firSymbol: S

-    abstract val resolveState: FirModuleResolveState
+    abstract val resolveState: LLFirModuleResolveState

    override val origin: KtSymbolOrigin get() = firSymbol.fir.ktSymbolOrigin()
 }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfType
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.psi.*
 internal class KtFirSymbolProvider(
    override val analysisSession: KtAnalysisSession,
    firSymbolProvider: FirSymbolProvider,
-    private val resolveState: FirModuleResolveState,
+    private val resolveState: LLFirModuleResolveState,
    private val firSymbolBuilder: KtSymbolByFirBuilder,
    override val token: ValidityToken,
 ) : KtSymbolProvider(), ValidityTokenOwner {
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirSyntheticJavaPropertySymbol(
    override val firSymbol: FirSyntheticPropertySymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticPropertySymbol> {
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirTypeAliasSymbol(
    override val firSymbol: FirTypeAliasSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAliasSymbol> {
@@ -15,14 +15,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance

 internal class KtFirTypeParameterSymbol(
    override val firSymbol: FirTypeParameterSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameterSymbol> {
@@ -15,30 +15,15 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
-import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.getAnnotationsByClassId
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
-import org.jetbrains.kotlin.fir.expressions.unwrapArgument
-import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.renderWithType
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.types.arrayElementType
-import org.jetbrains.kotlin.fir.types.customAnnotations
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs

 internal class KtFirValueParameterSymbol(
    override val firSymbol: FirValueParameterSymbol,
-    override val resolveState: FirModuleResolveState,
+    override val resolveState: LLFirModuleResolveState,
    override val token: ValidityToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameterSymbol> {
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -29,7 +29,7 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
 ) {
    val analysisSession: KtAnalysisSession get() = firAnalysisSession

-    val firResolveState: FirModuleResolveState get() = firAnalysisSession.firResolveState
+    val firResolveState: LLFirModuleResolveState get() = firAnalysisSession.firResolveState

    fun buildClassLikeSymbol(fir: FirClassLikeDeclaration): KtClassLikeSymbol =
        firAnalysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir.symbol)
@@ -47,7 +47,7 @@ class KtAnalysisSessionFe10BindingHolder private constructor(

    companion object {
        @InvalidWayOfUsingAnalysisSession
-        fun create(firResolveState: FirModuleResolveState, token: ValidityToken, @Suppress("UNUSED_PARAMETER") ktElement: KtElement): KtAnalysisSessionFe10BindingHolder {
+        fun create(firResolveState: LLFirModuleResolveState, token: ValidityToken, @Suppress("UNUSED_PARAMETER") ktElement: KtElement): KtAnalysisSessionFe10BindingHolder {
            @Suppress("DEPRECATION")
            val firAnalysisSession = KtFirAnalysisSession.createAnalysisSessionByResolveState(firResolveState, token)
            return KtAnalysisSessionFe10BindingHolder(firAnalysisSession)
@@ -9,13 +9,13 @@ 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.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSessionProviderStorage
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSourcesSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProviderStorage
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSourcesSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibraryOrLibrarySourceResolvableModuleSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.FirSourceModuleResolveState
+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.project.structure.KtLibraryModule
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModifi
 import org.jetbrains.kotlin.analysis.utils.caches.strongCachedValue
 import java.util.concurrent.ConcurrentHashMap

-internal class FirIdeResolveStateService(project: Project) {
-    private val sessionProviderStorage = FirIdeSessionProviderStorage(project)
+internal class LLFirResolveStateService(project: Project) {
+    private val sessionProviderStorage = LLFirSessionProviderStorage(project)

    private val stateCache by strongCachedValue(
        project.createProjectWideOutOfBlockModificationTracker(),
@@ -40,19 +40,19 @@ internal class FirIdeResolveStateService(project: Project) {
        stateCache.computeIfAbsent(module) { createResolveStateFor(module, sessionProviderStorage) }

    companion object {
-        fun getInstance(project: Project): FirIdeResolveStateService =
-            ServiceManager.getService(project, FirIdeResolveStateService::class.java)
+        fun getInstance(project: Project): LLFirResolveStateService =
+            ServiceManager.getService(project, LLFirResolveStateService::class.java)

        internal fun createResolveStateFor(
            module: KtModule,
-            sessionProviderStorage: FirIdeSessionProviderStorage,
-            configureSession: (FirIdeSession.() -> Unit)? = null,
+            sessionProviderStorage: LLFirSessionProviderStorage,
+            configureSession: (LLFirSession.() -> Unit)? = null,
        ): LLFirResolvableModuleResolveState {
            val sessionProvider = sessionProviderStorage.getSessionProvider(module, configureSession)
            return when (module) {
                is KtSourceModule -> {
-                    val firFileBuilder = (sessionProvider.rootModuleSession as FirIdeSourcesSession).firFileBuilder
-                    FirSourceModuleResolveState(
+                    val firFileBuilder = (sessionProvider.rootModuleSession as LLFirSourcesSession).firFileBuilder
+                    LLFirSourceModuleResolveState(
                        sessionProviderStorage.project,
                        module,
                        sessionProvider,
@@ -83,11 +83,11 @@ internal class FirIdeResolveStateService(project: Project) {
 fun createResolveStateForNoCaching(
    module: KtModule,
    project: Project,
-    configureSession: (FirIdeSession.() -> Unit)? = null,
-): FirModuleResolveState =
-    FirIdeResolveStateService.createResolveStateFor(
+    configureSession: (LLFirSession.() -> Unit)? = null,
+): LLFirModuleResolveState =
+    LLFirResolveStateService.createResolveStateFor(
        module = module,
-        sessionProviderStorage = FirIdeSessionProviderStorage(project),
+        sessionProviderStorage = LLFirSessionProviderStorage(project),
        configureSession = configureSession
    )

@@ -7,12 +7,11 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir

 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 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.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMapping
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.FirSourceModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.state.TowerProviderForElementForState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.containingKtFileIfAny
@@ -28,13 +27,12 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.KtLambdaExpression

 internal class FirModuleResolveStateDepended(
    val originalState: LLFirResolvableModuleResolveState,
    val towerProviderBuiltUponElement: FirTowerContextProvider,
    private val ktToFirMapping: KtToFirMapping?,
-) : FirModuleResolveState() {
+) : LLFirModuleResolveState() {
    override val project: Project get() = originalState.project
    override val module: KtModule get() = originalState.module
    override val rootModuleSession get() = originalState.rootModuleSession
@@ -6,20 +6,19 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir

 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirSessionInvalidator
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionInvalidator

@ThreadSafeMutableState
-internal class IdeFirPhaseManager(
+internal class LLFirPhaseManager(
    private val lazyDeclarationResolver: FirLazyDeclarationResolver,
    private val cache: ModuleFileCache,
-    private val sessionInvalidator: FirSessionInvalidator,
+    private val sessionInvalidator: LLFirSessionInvalidator,
 ) : FirPhaseManager() {
    override fun ensureResolved(
        symbol: FirBasedSymbol<*>,
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.executeWithoutPCE

-internal class FirPhaseRunner {
+internal class LLFirPhaseRunner {
    /**
     * We temporary disable multi-locks to fix deadlocks problem
     * @see org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LockProvider
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtLambdaExpression

-abstract class FirModuleResolveState {
+abstract class LLFirModuleResolveState {
    abstract val project: Project

    abstract val rootModuleSession: FirSession
@@ -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.FirIdeResolveStateService
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService
 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 [FirModuleResolveState] which corresponds to containing module
+ * Returns [LLFirModuleResolveState] which corresponds to containing module
 */
-fun KtElement.getResolveState(): FirModuleResolveState {
+fun KtElement.getResolveState(): LLFirModuleResolveState {
    val project = project
    return getKtModule(project).getResolveState(project)
 }

 /**
- * Returns [FirModuleResolveState] which corresponds to containing module
+ * Returns [LLFirModuleResolveState] which corresponds to containing module
 */
-fun KtModule.getResolveState(project: Project): FirModuleResolveState =
-    FirIdeResolveStateService.getInstance(project).getResolveState(this)
+fun KtModule.getResolveState(project: Project): LLFirModuleResolveState =
+    LLFirResolveStateService.getInstance(project).getResolveState(this)


 /**
@@ -40,7 +40,7 @@ fun KtModule.getResolveState(project: Project): FirModuleResolveState =
 *
 */
 fun KtDeclaration.resolveToFirSymbol(
-    resolveState: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
    phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
 ): FirBasedSymbol<*> {
    return resolveState.resolveToFirSymbol(this, phase)
@@ -54,7 +54,7 @@ fun KtDeclaration.resolveToFirSymbol(
 */
@Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
 inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfType(
-    resolveState: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
    phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
 ): @kotlin.internal.NoInfer S {
    val symbol = resolveToFirSymbol(resolveState, phase)
@@ -72,7 +72,7 @@ inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTyp
 */
@Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
 inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTypeSafe(
-    resolveState: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
    phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
 ): @kotlin.internal.NoInfer S? {
    return resolveToFirSymbol(resolveState, phase) as? S
@@ -83,7 +83,7 @@ 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: FirModuleResolveState, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic> =
+fun KtElement.getDiagnostics(resolveState: LLFirModuleResolveState, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic> =
    resolveState.getDiagnostics(this, filter)

 /**
@@ -91,7 +91,7 @@ fun KtElement.getDiagnostics(resolveState: FirModuleResolveState, filter: Diagno
 * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
 */
 fun KtFile.collectDiagnosticsForFile(
-    resolveState: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
    filter: DiagnosticCheckerFilter
 ): Collection<KtPsiDiagnostic> =
    resolveState.collectDiagnosticsForFile(this, filter)
@@ -104,7 +104,7 @@ fun KtFile.collectDiagnosticsForFile(
 * The `null` value is returned iff FIR tree does not have corresponding element
 */
 fun KtElement.getOrBuildFir(
-    resolveState: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
 ): FirElement? = resolveState.getOrBuildFirFor(this)

 /**
@@ -113,7 +113,7 @@ 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: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
 ) = getOrBuildFir(resolveState) as? E

 /**
@@ -122,7 +122,7 @@ 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: FirModuleResolveState,
+    resolveState: LLFirModuleResolveState,
 ): E {
    val fir = this.getOrBuildFir(resolveState)
    if (fir is E) return fir
@@ -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: FirModuleResolveState): FirFile =
+fun KtFile.getOrBuildFirFile(resolveState: LLFirModuleResolveState): FirFile =
    resolveState.getOrBuildFirFile(this)
@@ -63,7 +63,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
    }

    fun <T : KtElement> onAirResolveElement(
-        state: FirModuleResolveState,
+        state: LLFirModuleResolveState,
        place: T,
        elementToResolve: T,
    ): FirElement {
@@ -92,7 +92,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
    }

    fun onAirGetTowerContextProvider(
-        state: FirModuleResolveState,
+        state: LLFirModuleResolveState,
        place: KtElement,
    ): FirTowerContextProvider {
        require(state is LLFirResolvableModuleResolveState)
@@ -140,10 +140,10 @@ object LowLevelFirApiFacadeForResolveOnAir {
    }

    fun getResolveStateForDependentCopy(
-        originalState: FirModuleResolveState,
+        originalState: LLFirModuleResolveState,
        originalKtFile: KtFile,
        elementToAnalyze: KtElement
-    ): FirModuleResolveState {
+    ): LLFirModuleResolveState {
        require(originalState is LLFirResolvableModuleResolveState)
        require(elementToAnalyze !is KtFile) { "KtFile for dependency element not supported" }
        require(!elementToAnalyze.isPhysical) { "Depended state should be build only for non-physical elements" }
@@ -299,7 +299,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
    fun onAirResolveTypeInPlace(
        place: KtElement,
        typeReference: KtTypeReference,
-        state: FirModuleResolveState,
+        state: LLFirModuleResolveState,
    ): FirResolvedTypeRef {
        val context = state.getTowerContextProvider(place.containingKtFile).getClosestAvailableParentContext(place)
            ?: error("TowerContext not found for ${place.getElementTextInContext()}")
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.platform.SimplePlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatform

-internal abstract class AbstractFirIdeDiagnosticsCollector(
+internal abstract class AbstractLLFirDiagnosticsCollector(
    session: FirSession,
    useExtendedCheckers: Boolean,
 ) : AbstractDiagnosticCollector(
@@ -44,7 +44,7 @@ internal class SingleNonLocalDeclarationDiagnosticRetriever(
        private val structureElementDeclaration: FirDeclaration,
        context: CheckerContext,
        components: List<AbstractDiagnosticCollectorComponent>
-    ) : FirIdeDiagnosticVisitor(context, components) {
+    ) : LLFirDiagnosticVisitor(context, components) {
        private var insideAlwaysVisitableDeclarations = 0

        override fun shouldVisitDeclaration(declaration: FirDeclaration): Boolean {
@@ -104,7 +104,7 @@ internal object FileDiagnosticRetriever : FileStructureElementDiagnosticRetrieve
    private class Visitor(
        firFile: FirFile,
        components: List<AbstractDiagnosticCollectorComponent>
-    ) : FirIdeDiagnosticVisitor(
+    ) : LLFirDiagnosticVisitor(
        PersistentCheckerContextFactory.createEmptyPersistenceCheckerContext(SessionHolderImpl.createWithEmptyScopeSession(firFile.moduleData.session)),
        components,
    ) {
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics
 import org.jetbrains.kotlin.fir.analysis.collectors.CheckerRunningDiagnosticCollectorVisitor
 import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.FirIdeStructureElementDiagnosticsCollector
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.LLFirStructureElementDiagnosticsCollector

 internal class FileStructureElementDiagnosticsCollector private constructor(private val useExtendedCheckers: Boolean) {
    companion object {
@@ -20,8 +20,8 @@ internal class FileStructureElementDiagnosticsCollector private constructor(priv
        firDeclaration: FirDeclaration,
        createVisitor: (components: List<AbstractDiagnosticCollectorComponent>) -> CheckerRunningDiagnosticCollectorVisitor,
    ): FileStructureElementDiagnosticList {
-        val reporter = FirIdeDiagnosticReporter()
-        val collector = FirIdeStructureElementDiagnosticsCollector(
+        val reporter = LLFirDiagnosticReporter()
+        val collector = LLFirStructureElementDiagnosticsCollector(
            firDeclaration.moduleData.session,
            createVisitor,
            useExtendedCheckers,
@@ -9,7 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.addValueFor
 import org.jetbrains.kotlin.diagnostics.*

-internal class FirIdeDiagnosticReporter : DiagnosticReporter() {
+internal class LLFirDiagnosticReporter : DiagnosticReporter() {
    val diagnostics = mutableMapOf<PsiElement, MutableList<KtPsiDiagnostic>>()

    override fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) {
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosti
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled

-internal open class FirIdeDiagnosticVisitor(
+internal open class LLFirDiagnosticVisitor(
    context: CheckerContext,
    components: List<AbstractDiagnosticCollectorComponent>,
 ) : CheckerRunningDiagnosticCollectorVisitor(context, components) {
@@ -8,13 +8,13 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.collectors.CheckerRunningDiagnosticCollectorVisitor
 import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.AbstractFirIdeDiagnosticsCollector
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.AbstractLLFirDiagnosticsCollector

-internal class FirIdeStructureElementDiagnosticsCollector(
+internal class LLFirStructureElementDiagnosticsCollector(
    session: FirSession,
    private val doCreateVisitor: (components: List<AbstractDiagnosticCollectorComponent>) -> CheckerRunningDiagnosticCollectorVisitor,
    useExtendedCheckers: Boolean,
-) : AbstractFirIdeDiagnosticsCollector(
+) : AbstractLLFirDiagnosticsCollector(
    session,
    useExtendedCheckers,
 ) {
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolder
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator

 internal object PersistentCheckerContextFactory {
    fun createEmptyPersistenceCheckerContext(sessionHolder: SessionHolder): PersistentCheckerContext {
@@ -18,7 +18,7 @@ internal object PersistentCheckerContextFactory {
            sessionHolder.session,
            ScopeSession(),
            ImplicitBodyResolveComputationSession(),
-            ::FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+            ::LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
        )
        return PersistentCheckerContext(sessionHolder, returnTypeCalculator)
    }
@@ -12,7 +12,7 @@ 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.resolve.ScopeSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureCache
@@ -69,7 +69,7 @@ internal class FirElementBuilder {
        moduleFileCache: ModuleFileCache,
        fileStructureCache: FileStructureCache,
        firLazyDeclarationResolver: FirLazyDeclarationResolver,
-        state: FirModuleResolveState,
+        state: LLFirModuleResolveState,
    ): FirElement? = when (element) {
        is KtFile -> getOrBuildFirForKtFile(element, firFileBuilder, moduleFileCache, firLazyDeclarationResolver)
        else -> getOrBuildFirForNonKtFileElement(element, fileStructureCache, moduleFileCache, state)
@@ -96,7 +96,7 @@ internal class FirElementBuilder {
        element: KtElement,
        fileStructureCache: FileStructureCache,
        moduleFileCache: ModuleFileCache,
-        state: FirModuleResolveState,
+        state: LLFirModuleResolveState,
    ): FirElement? {
        require(element !is KtFile)

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesigna
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder

-fun FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
+fun LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
    designation: Iterator<FirElement>,
    session: FirSession,
    scopeSession: ScopeSession,
@@ -34,7 +34,7 @@ fun FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
    designation.forEachRemaining(designationList::add)
    require(designationList.isNotEmpty()) { "Designation should not be empty" }

-    return FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
+    return LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
        designationList,
        session,
        scopeSession,
@@ -44,7 +44,7 @@ fun FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
    )
 }

-private class FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
+private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
    private val designation: List<FirElement>,
    session: FirSession,
    scopeSession: ScopeSession,
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef

-fun FirIdeEnsureBasedTransformerForReturnTypeCalculator(
+fun LLFirEnsureBasedTransformerForReturnTypeCalculator(
    designation: Iterator<FirElement>,
    session: FirSession,
    scopeSession: ScopeSession,
@@ -31,7 +31,7 @@ fun FirIdeEnsureBasedTransformerForReturnTypeCalculator(
    designation.forEachRemaining(designationList::add)
    require(designationList.isNotEmpty()) { "Designation should not be empty" }

-    return FirIdeEnsureBasedTransformerForReturnTypeCalculatorImpl(
+    return LLFirEnsureBasedTransformerForReturnTypeCalculatorImpl(
        designationList,
        session,
        scopeSession,
@@ -42,7 +42,7 @@ fun FirIdeEnsureBasedTransformerForReturnTypeCalculator(
 }


-private class FirIdeEnsureBasedTransformerForReturnTypeCalculatorImpl(
+private class LLFirEnsureBasedTransformerForReturnTypeCalculatorImpl(
    designation: List<FirElement>,
    session: FirSession,
    scopeSession: ScopeSession,
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.psi.KtFile

 /**
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.psi.KtFile
@ThreadSafe
 internal class FirFileBuilder(
    private val scopeProvider: FirScopeProvider,
-    val firPhaseRunner: FirPhaseRunner
+    val firPhaseRunner: LLFirPhaseRunner
 ) {
    /**
     * Builds a [FirFile] by given [ktFile] and records it's parenting info if it not present in [cache]
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder

-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerDataContextAllElementsCollector
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FirElementsRecorder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMapping
@@ -29,7 +29,7 @@ internal class LLFirLibraryResolveModuleFileCache(
    val kotlinScopeProvider: FirScopeProvider,
    override val session: LLFirLibraryOrLibrarySourceResolvableModuleSession
 ) : ModuleFileCache() {
-    private val firFileBuilder = FirFileBuilder(kotlinScopeProvider, FirPhaseRunner())
+    private val firFileBuilder = FirFileBuilder(kotlinScopeProvider, LLFirPhaseRunner())

    private val firLazyDeclarationResolver = FirLazyDeclarationResolver(firFileBuilder)

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLoc
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.FirIdeProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.findSourceNonLocalFirDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import java.util.concurrent.ConcurrentHashMap

 /**
- * Belongs to a [org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState]
+ * Belongs to a [org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState]
 */
 internal class FileStructureCache(
    private val fileBuilder: FirFileBuilder,
@@ -6,7 +6,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.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 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
@@ -17,8 +17,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCa
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirNonLocalDeclarationBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.declarationCanBeLazilyResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.FirIdeProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
@@ -40,7 +38,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: FirModuleResolveState): FirElement? {
+    fun getElement(ktElement: KtElement, state: LLFirModuleResolveState): FirElement? {
        mapping[ktElement]?.let { return it }

        val userType = when (ktElement) {
@@ -58,7 +56,7 @@ internal class KtToFirMapping(firElement: FirElement, recorder: FirElementsRecor
        }
    }

-    fun getFirOfClosestParent(element: KtElement, state: FirModuleResolveState): FirElement? {
+    fun getFirOfClosestParent(element: KtElement, state: LLFirModuleResolveState): FirElement? {
        var current: PsiElement? = element
        while (current != null && current !is KtFile) {
            if (current is KtElement) {
@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLoc
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.runCustomResolveUnderLock
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirFileAnnotationsResolveTransformer
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirProviderInterceptorForIDE
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirFileAnnotationsResolveTransformer
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirFirProviderInterceptor
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LazyTransformerFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.findSourceNonLocalFirDeclaration
@@ -69,7 +69,7 @@ internal class FirLazyDeclarationResolver(private val firFileBuilder: FirFileBui
        }

        if (!annotations.all { it.resolved }) {
-            FirFileAnnotationsResolveTransformer(
+            LLFirFileAnnotationsResolveTransformer(
                firFile = firFile,
                annotations = annotations,
                session = firFile.moduleData.session,
@@ -387,7 +387,7 @@ internal class FirLazyDeclarationResolver(private val firFileBuilder: FirFileBui
        val scopeSession = ScopeSession()

        val firProviderInterceptor = if (onAirCreatedDeclaration) {
-            FirProviderInterceptorForIDE.createForFirElement(
+            LLFirFirProviderInterceptor.createForFirElement(
                session = designation.firFile.moduleData.session,
                firFile = designation.firFile,
                element = designation.declaration
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

-class FirIdeBuiltinSymbolProvider(
+class LLFirBuiltinSymbolProvider(
    session: FirSession,
    moduleData: FirModuleData,
    kotlinScopeProvider: FirKotlinScopeProvider
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

-internal class FirIdeBuiltinsAndCloneableSessionProvider(override val symbolProvider: FirSymbolProvider) : FirProvider() {
+internal class LLFirBuiltinsAndCloneableSessionProvider(override val symbolProvider: FirSymbolProvider) : FirProvider() {
    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
        symbolProvider.getClassLikeSymbolByClassId(classId)?.fir

@@ -26,5 +26,5 @@ internal class FirIdeBuiltinsAndCloneableSessionProvider(override val symbolProv

    override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()

-    private fun shouldNotBeCalled(): Nothing = error("Should not be called for FirIdeBuiltinsAndCloneableSession")
+    private fun shouldNotBeCalled(): Nothing = error("Should not be called for LLFirBuiltinsAndCloneableSession")
 }
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

-internal class FirIdeLibrariesSessionProvider(
+internal class LLFirLibrariesSessionProvider(
    override val symbolProvider: FirSymbolProvider
 ) : FirProvider() {
    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
@@ -28,6 +28,6 @@ internal class FirIdeLibrariesSessionProvider(

    override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()

-    private fun shouldNotBeCalled(): Nothing = error("Should not be called for FirIdeLibrariesSessionProvider")
+    private fun shouldNotBeCalled(): Nothing = error("Should not be called for LLFirLibrariesSessionProvider")
 }

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

@ThreadSafeMutableState
-internal class FirIdeProvider(
+internal class LLFirProvider(
    @Suppress("UNUSED_PARAMETER") project: Project,
    val session: FirSession,
    @Suppress("UNUSED_PARAMETER") module: KtModule,
@@ -40,7 +40,7 @@ internal class FirIdeProvider(
 ) : FirProvider() {
    override val symbolProvider: FirSymbolProvider = SymbolProvider()

-    private val providerHelper = FirProviderHelper(
+    private val providerHelper = LLFirProviderHelper(
        cache,
        firFileBuilder,
        declarationProvider,
@@ -32,5 +32,5 @@ internal class LLFirLibraryResolvableProvider(

    override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()

-    private fun shouldNotBeCalled(): Nothing = error("Should not be called for FirIdeLibrariesSessionProvider")
+    private fun shouldNotBeCalled(): Nothing = error("Should not be called for LLFirLibrariesSessionProvider")
 }
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

-internal class FirModuleWithDependenciesSymbolProvider(
+internal class LLFirModuleWithDependenciesSymbolProvider(
    session: FirSession,
    private val providers: List<FirSymbolProvider>,
    val dependencyProvider: DependentModuleProviders
@@ -81,7 +81,7 @@ internal class DependentModuleProviders(session: FirSession, private val provide
    override fun getClassLikeSymbolByClassId(classId: ClassId): FirClassLikeSymbol<*>? =
        providers.firstNotNullOfOrNull { provider ->
            when (provider) {
-                is FirModuleWithDependenciesSymbolProvider -> provider.getClassLikeSymbolByFqNameWithoutDependencies(classId)
+                is LLFirModuleWithDependenciesSymbolProvider -> provider.getClassLikeSymbolByFqNameWithoutDependencies(classId)
                else -> provider.getClassLikeSymbolByClassId(classId)
            }
        }
@@ -91,7 +91,7 @@ internal class DependentModuleProviders(session: FirSession, private val provide
    override fun getTopLevelCallableSymbolsTo(destination: MutableList<FirCallableSymbol<*>>, packageFqName: FqName, name: Name) {
        providers.forEach { provider ->
            when (provider) {
-                is FirModuleWithDependenciesSymbolProvider ->
+                is LLFirModuleWithDependenciesSymbolProvider ->
                    provider.getTopLevelCallableSymbolsToWithoutDependencies(destination, packageFqName, name)
                else -> provider.getTopLevelCallableSymbolsTo(destination, packageFqName, name)
            }
@@ -102,7 +102,7 @@ internal class DependentModuleProviders(session: FirSession, private val provide
    override fun getTopLevelFunctionSymbolsTo(destination: MutableList<FirNamedFunctionSymbol>, packageFqName: FqName, name: Name) {
        providers.forEach { provider ->
            when (provider) {
-                is FirModuleWithDependenciesSymbolProvider ->
+                is LLFirModuleWithDependenciesSymbolProvider ->
                    provider.getTopLevelFunctionSymbolsToWithoutDependencies(destination, packageFqName, name)
                else -> provider.getTopLevelFunctionSymbolsTo(destination, packageFqName, name)
            }
@@ -113,7 +113,7 @@ internal class DependentModuleProviders(session: FirSession, private val provide
    override fun getTopLevelPropertySymbolsTo(destination: MutableList<FirPropertySymbol>, packageFqName: FqName, name: Name) {
        providers.forEach { provider ->
            when (provider) {
-                is FirModuleWithDependenciesSymbolProvider ->
+                is LLFirModuleWithDependenciesSymbolProvider ->
                    provider.getTopLevelPropertySymbolsToWithoutDependencies(destination, packageFqName, name)
                else -> provider.getTopLevelPropertySymbolsTo(destination, packageFqName, name)
            }
@@ -123,7 +123,7 @@ internal class DependentModuleProviders(session: FirSession, private val provide
    override fun getPackage(fqName: FqName): FqName? =
        providers.firstNotNullOfOrNull { provider ->
            when (provider) {
-                is FirModuleWithDependenciesSymbolProvider -> provider.getPackageWithoutDependencies(fqName)
+                is LLFirModuleWithDependenciesSymbolProvider -> provider.getPackageWithoutDependencies(fqName)
                else -> provider.getPackage(fqName)
            }
        }
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import java.util.*

-internal class FirProviderHelper(
+internal class LLFirProviderHelper(
    private val cache: ModuleFileCache,
    private val firFileBuilder: FirFileBuilder,
    private val declarationProvider: KotlinDeclarationProvider,
@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions

 import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor

@@ -14,7 +13,7 @@ import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 * [org.jetbrains.kotlin.fir.FirSession] responsible for all libraries analysing module transitively depends on
 */
@OptIn(PrivateSessionConstructor::class)
-internal class FirIdeLibrariesSession @PrivateSessionConstructor constructor(
+internal class LLFirLibrariesSession @PrivateSessionConstructor constructor(
    override val project: Project,
    builtinTypes: BuiltinTypes,
-) : FirIdeSession(builtinTypes, Kind.Library)
+) : LLFirSession(builtinTypes, Kind.Library)
@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.ProjectScope
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
-import org.jetbrains.kotlin.analysis.low.level.api.fir.IdeFirPhaseManager
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseManager
 import org.jetbrains.kotlin.analysis.low.level.api.fir.IdeSessionComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.createPackagePartProviderForLibrary
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.createSealedInheritorsProvider
@@ -54,26 +54,26 @@ import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import java.nio.file.Path

@OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
-internal object FirIdeSessionFactory {
+internal object LLFirSessionFactory {
    fun createSourcesSession(
        project: Project,
        module: KtSourceModule,
-        builtinsAndCloneableSession: FirIdeBuiltinsAndCloneableSession,
-        firPhaseRunner: FirPhaseRunner,
-        sessionInvalidator: FirSessionInvalidator,
+        builtinsAndCloneableSession: LLFirBuiltinsAndCloneableSession,
+        firPhaseRunner: LLFirPhaseRunner,
+        sessionInvalidator: LLFirSessionInvalidator,
        builtinTypes: BuiltinTypes,
        sessionsCache: MutableMap<KtModule, LLFirResolvableModuleSession>,
        isRootModule: Boolean,
        librariesCache: LibrariesCache,
-        configureSession: (FirIdeSession.() -> Unit)? = null
-    ): FirIdeSourcesSession {
-        sessionsCache[module]?.let { return it as FirIdeSourcesSession }
+        configureSession: (LLFirSession.() -> Unit)? = null
+    ): LLFirSourcesSession {
+        sessionsCache[module]?.let { return it as LLFirSourcesSession }
        val languageVersionSettings = module.languageVersionSettings
        val scopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
        val firBuilder = FirFileBuilder(scopeProvider, firPhaseRunner)
        val contentScope = module.contentScope
        val dependentModules = module.directRegularDependenciesOfType<KtSourceModule>()
-        val session = FirIdeSourcesSession(module, project, firBuilder, builtinTypes)
+        val session = LLFirSourcesSession(module, project, firBuilder, builtinTypes)
        sessionsCache[module] = session

        return session.apply session@{
@@ -82,14 +82,14 @@ internal object FirIdeSessionFactory {
            register(FirKotlinScopeProvider::class, scopeProvider)

            val cache = ModuleFileCacheImpl(this)
-            val firPhaseManager = IdeFirPhaseManager(FirLazyDeclarationResolver(firFileBuilder), cache, sessionInvalidator)
+            val firPhaseManager = LLFirPhaseManager(FirLazyDeclarationResolver(firFileBuilder), cache, sessionInvalidator)

            registerIdeComponents(project)
            registerCommonComponents(languageVersionSettings)
            registerCommonJavaComponents(JavaModuleResolver.getInstance(project))
            registerResolveComponents()

-            val provider = FirIdeProvider(
+            val provider = LLFirProvider(
                project,
                this,
                module,
@@ -101,7 +101,7 @@ internal object FirIdeSessionFactory {
            )

            register(FirProvider::class, provider)
-            register(FirIdeProvider::class, provider)
+            register(LLFirProvider::class, provider)

            register(FirPhaseManager::class, firPhaseManager)

@@ -139,7 +139,7 @@ internal object FirIdeSessionFactory {

            register(
                FirSymbolProvider::class,
-                FirModuleWithDependenciesSymbolProvider(
+                LLFirModuleWithDependenciesSymbolProvider(
                    this,
                    providers = listOf(
                        provider.symbolProvider,
@@ -173,15 +173,15 @@ internal object FirIdeSessionFactory {
    private fun createModuleLibrariesSession(
        sourceModule: KtSourceModule,
        project: Project,
-        builtinsAndCloneableSession: FirIdeBuiltinsAndCloneableSession,
+        builtinsAndCloneableSession: LLFirBuiltinsAndCloneableSession,
        builtinTypes: BuiltinTypes,
        librariesCache: LibrariesCache,
        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-        configureSession: (FirIdeSession.() -> Unit)?,
-    ): FirIdeLibrariesSession = librariesCache.cached(sourceModule) {
+        configureSession: (LLFirSession.() -> Unit)?,
+    ): LLFirLibrariesSession = librariesCache.cached(sourceModule) {
        checkCanceled()
        val searchScope = project.moduleScopeProvider.getModuleLibrariesScope(sourceModule)
-        FirIdeLibrariesSession(project, builtinTypes).apply session@{
+        LLFirLibrariesSession(project, builtinTypes).apply session@{
            registerModuleData(KtModuleBasedModuleData(sourceModule).apply { bindSession(this@session) })
            registerIdeComponents(project)
            register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
@@ -206,14 +206,14 @@ internal object FirIdeSessionFactory {
            )
            val symbolProvider =
                FirCompositeSymbolProvider(this, listOf(classFileBasedSymbolProvider, builtinsAndCloneableSession.symbolProvider))
-            register(FirProvider::class, FirIdeLibrariesSessionProvider(symbolProvider))
+            register(FirProvider::class, LLFirLibrariesSessionProvider(symbolProvider))
            register(FirSymbolProvider::class, symbolProvider)
            register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
            configureSession?.invoke(this)
        }
    }

-    private fun createModuleDataProvider(sourceModule: KtModule, session: FirIdeSession): ModuleDataProvider {
+    private fun createModuleDataProvider(sourceModule: KtModule, session: LLFirSession): ModuleDataProvider {
        val dependencyList = DependencyListForCliModule.build(
            Name.special("<${sourceModule.moduleDescription}>"),
            sourceModule.platform,
@@ -232,9 +232,9 @@ internal object FirIdeSessionFactory {
        project: Project,
        builtinTypes: BuiltinTypes,
        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-        configureSession: (FirIdeSession.() -> Unit)? = null,
-    ): FirIdeBuiltinsAndCloneableSession {
-        return FirIdeBuiltinsAndCloneableSession(project, builtinTypes).apply session@{
+        configureSession: (LLFirSession.() -> Unit)? = null,
+    ): LLFirBuiltinsAndCloneableSession {
+        return LLFirBuiltinsAndCloneableSession(project, builtinTypes).apply session@{
            val moduleData = FirModuleDataImpl(
                Name.special("<builtins module>"),
                emptyList(),
@@ -255,12 +255,12 @@ internal object FirIdeSessionFactory {
            val symbolProvider = FirCompositeSymbolProvider(
                this,
                listOf(
-                    FirIdeBuiltinSymbolProvider(this, moduleData, kotlinScopeProvider),
+                    LLFirBuiltinSymbolProvider(this, moduleData, kotlinScopeProvider),
                    FirCloneableSymbolProvider(this, moduleData, kotlinScopeProvider),
                )
            )
            register(FirSymbolProvider::class, symbolProvider)
-            register(FirProvider::class, FirIdeBuiltinsAndCloneableSessionProvider(symbolProvider))
+            register(FirProvider::class, LLFirBuiltinsAndCloneableSessionProvider(symbolProvider))
            register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
            configureSession?.invoke(this)
        }
@@ -269,13 +269,13 @@ internal object FirIdeSessionFactory {
    fun creatLibraryOrLibrarySourceResolvableSession(
        project: Project,
        module: KtModule,
-        builtinsAndCloneableSession: FirIdeBuiltinsAndCloneableSession,
-        firPhaseRunner: FirPhaseRunner,
-        sessionInvalidator: FirSessionInvalidator,
+        builtinsAndCloneableSession: LLFirBuiltinsAndCloneableSession,
+        firPhaseRunner: LLFirPhaseRunner,
+        sessionInvalidator: LLFirSessionInvalidator,
        builtinTypes: BuiltinTypes,
        sessionsCache: MutableMap<KtModule, LLFirResolvableModuleSession>,
        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-        configureSession: (FirIdeSession.() -> Unit)? = null
+        configureSession: (LLFirSession.() -> Unit)? = null
    ): LLFirLibraryOrLibrarySourceResolvableModuleSession {
        LLFirLibraryOrLibrarySourceResolvableModuleSession.checkIsValidKtModule(module)
        sessionsCache[module]?.let { return it as LLFirLibraryOrLibrarySourceResolvableModuleSession }
@@ -300,14 +300,14 @@ internal object FirIdeSessionFactory {
            register(FirKotlinScopeProvider::class, scopeProvider)

            val cache = ModuleFileCacheImpl(this)
-            val firPhaseManager = IdeFirPhaseManager(FirLazyDeclarationResolver(firFileBuilder), cache, sessionInvalidator)
+            val firPhaseManager = LLFirPhaseManager(FirLazyDeclarationResolver(firFileBuilder), cache, sessionInvalidator)

            registerIdeComponents(project)
            registerCommonComponents(languageVersionSettings)
            registerCommonJavaComponents(JavaModuleResolver.getInstance(project))
            registerResolveComponents()

-            val provider = FirIdeProvider(
+            val provider = LLFirProvider(
                project,
                this,
                module,
@@ -319,7 +319,7 @@ internal object FirIdeSessionFactory {
            )

            register(FirProvider::class, provider)
-            register(FirIdeProvider::class, provider)
+            register(LLFirProvider::class, provider)

            register(FirPhaseManager::class, firPhaseManager)
            val dependentProviders = buildList {
@@ -344,7 +344,7 @@ internal object FirIdeSessionFactory {

            register(
                FirSymbolProvider::class,
-                FirModuleWithDependenciesSymbolProvider(
+                LLFirModuleWithDependenciesSymbolProvider(
                    this,
                    providers = listOf(
                        provider.symbolProvider,
@@ -373,7 +373,7 @@ internal object FirIdeSessionFactory {

    }

-    private fun FirIdeSession.registerIdeComponents(project: Project) {
+    private fun LLFirSession.registerIdeComponents(project: Project) {
        register(IdeSessionComponents::class, IdeSessionComponents.create(this))
        register(FirCachesFactory::class, FirThreadSafeCachesFactory)
        register(SealedClassInheritorsProvider::class, project.createSealedInheritorsProvider())
@@ -9,23 +9,25 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.Immutable
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionProvider

@Immutable
-class FirIdeSessionProvider internal constructor(
+class LLFirSessionProvider internal constructor(
    val project: Project,
    internal val rootModuleSession: LLFirResolvableModuleSession,
-    val sessions: Map<KtModule, LLFirResolvableModuleSession>
+    private val moduleToSession: Map<KtModule, LLFirResolvableModuleSession>
 ) : FirSessionProvider() {
    override fun getSession(moduleData: FirModuleData): FirSession? =
-        sessions[moduleData.module]
+        moduleToSession[moduleData.module]

    fun getSession(module: KtModule): FirSession? =
-        sessions[module]
+        moduleToSession[module]

    internal fun getModuleCache(module: KtModule): ModuleFileCache =
-        sessions.getValue(module).cache
+        moduleToSession.getValue(module).cache
+
+    val allSessions: Collection<LLFirModuleSession>
+        get() = moduleToSession.values
 }
@@ -10,7 +10,7 @@ import com.intellij.openapi.util.ModificationTracker
 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.persistentMapOf
 import kotlinx.collections.immutable.toPersistentMap
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.addValueFor
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.executeWithoutPCE
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
@@ -26,26 +26,26 @@ import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.moduleData
 import java.util.concurrent.ConcurrentHashMap

-class FirIdeSessionProviderStorage(val project: Project) {
+class LLFirSessionProviderStorage(val project: Project) {
    private val sessionsCache = ConcurrentHashMap<KtModule, FromModuleViewSessionCache>()

    private val librariesCache by softCachedValue(project, project.createLibrariesModificationTracker()) { LibrariesCache() }

    fun getSessionProvider(
        rootModule: KtModule,
-        configureSession: (FirIdeSession.() -> Unit)? = null
-    ): FirIdeSessionProvider {
-        val firPhaseRunner = FirPhaseRunner()
+        configureSession: (LLFirSession.() -> Unit)? = null
+    ): LLFirSessionProvider {
+        val firPhaseRunner = LLFirPhaseRunner()

        val builtinTypes = BuiltinTypes()
-        val builtinsAndCloneableSession = FirIdeSessionFactory.createBuiltinsAndCloneableSession(project, builtinTypes)
+        val builtinsAndCloneableSession = LLFirSessionFactory.createBuiltinsAndCloneableSession(project, builtinTypes)
        val cache = sessionsCache.getOrPut(rootModule) { FromModuleViewSessionCache() }
        val (sessions, session) = cache.withMappings(project) { mappings ->
            val sessions = mutableMapOf<KtModule, LLFirResolvableModuleSession>().apply { putAll(mappings) }
            val session = executeWithoutPCE {
                when (rootModule) {
                    is KtSourceModule -> {
-                        FirIdeSessionFactory.createSourcesSession(
+                        LLFirSessionFactory.createSourcesSession(
                            project,
                            rootModule,
                            builtinsAndCloneableSession,
@@ -58,7 +58,7 @@ class FirIdeSessionProviderStorage(val project: Project) {
                            configureSession = configureSession,
                        )
                    }
-                    is KtLibraryModule, is KtLibrarySourceModule -> FirIdeSessionFactory.creatLibraryOrLibrarySourceResolvableSession(
+                    is KtLibraryModule, is KtLibrarySourceModule -> LLFirSessionFactory.creatLibraryOrLibrarySourceResolvableSession(
                        project,
                        rootModule,
                        builtinsAndCloneableSession,
@@ -75,7 +75,7 @@ class FirIdeSessionProviderStorage(val project: Project) {
            sessions to session
        }

-        return FirIdeSessionProvider(project, session, sessions)
+        return LLFirSessionProvider(project, session, sessions)
    }
 }

@@ -83,7 +83,7 @@ private class FromModuleViewSessionCache {
    @Volatile
    private var mappings: PersistentMap<KtModule, FirSessionWithModificationTracker> = persistentMapOf()

-    val sessionInvalidator: FirSessionInvalidator = FirSessionInvalidator { session ->
+    val sessionInvalidator: LLFirSessionInvalidator = LLFirSessionInvalidator { session ->
        mappings[session.moduleData.module]?.invalidate()
    }

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor

@OptIn(PrivateSessionConstructor::class)
-class FirIdeBuiltinsAndCloneableSession @PrivateSessionConstructor constructor(
+class LLFirBuiltinsAndCloneableSession @PrivateSessionConstructor constructor(
    override val project: Project,
    builtinTypes: BuiltinTypes,
-) : FirIdeSession(builtinTypes, Kind.Library)
+) : LLFirSession(builtinTypes, Kind.Library)
@@ -7,13 +7,13 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions

 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.FirIdeProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirProvider
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider

 internal abstract class LLFirResolvableModuleSession(
    builtinTypes: BuiltinTypes,
-) : FirIdeModuleSession(builtinTypes, Kind.Source) {
-    internal val cache: ModuleFileCache get() = (firProvider as FirIdeProvider).cache
+) : LLFirModuleSession(builtinTypes, Kind.Source) {
+    internal val cache: ModuleFileCache get() = (firProvider as LLFirProvider).cache
    abstract val firFileBuilder: FirFileBuilder
 }
@@ -6,18 +6,17 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions

 import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor

@OptIn(PrivateSessionConstructor::class)
-abstract class FirIdeSession(override val builtinTypes: BuiltinTypes, kind: Kind) : FirSession(sessionProvider = null, kind) {
+abstract class LLFirSession(override val builtinTypes: BuiltinTypes, kind: Kind) : FirSession(sessionProvider = null, kind) {
    abstract val project: Project
 }

@OptIn(PrivateSessionConstructor::class)
-abstract class FirIdeModuleSession(builtinTypes: BuiltinTypes, kind: Kind) : FirIdeSession(builtinTypes, kind) {
+abstract class LLFirModuleSession(builtinTypes: BuiltinTypes, kind: Kind) : LLFirSession(builtinTypes, kind) {
    abstract val module: KtModule
 }
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions

 import org.jetbrains.kotlin.fir.FirSession

-internal class FirSessionInvalidator(private val invalidateSourcesSession: (LLFirResolvableModuleSession) -> Unit) {
+internal class LLFirSessionInvalidator(private val invalidateSourcesSession: (LLFirResolvableModuleSession) -> Unit) {
    fun invalidate(session: FirSession) {
        require(session is LLFirResolvableModuleSession)
        invalidateSourcesSession(session)
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor

-internal class FirIdeSourcesSession @PrivateSessionConstructor constructor(
+internal class LLFirSourcesSession @PrivateSessionConstructor constructor(
    override val module: KtSourceModule,
    override val project: Project,
    override val firFileBuilder: FirFileBuilder,
@@ -6,16 +6,15 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions

 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import java.util.concurrent.ConcurrentHashMap

@JvmInline
 internal value class LibrariesCache(
-    private val cache: ConcurrentHashMap<KtModule, FirIdeLibrariesSession> = ConcurrentHashMap()
+    private val cache: ConcurrentHashMap<KtModule, LLFirLibrariesSession> = ConcurrentHashMap()
 ) {
    fun cached(
        module: KtModule,
-        create: (KtModule) -> FirIdeLibrariesSession
-    ): FirIdeLibrariesSession =
+        create: (KtModule) -> LLFirLibrariesSession
+    ): LLFirLibrariesSession =
        cache.computeIfAbsent(module, create)
 }
@@ -9,7 +9,7 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSessionProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibraryOrLibrarySourceResolvableModuleSession
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.psi.KtFile
 internal class LLFirLibraryOrLibrarySourceResolvableModuleResolveState(
    override val project: Project,
    override val module: KtModule,
-    sessionProvider: FirIdeSessionProvider,
+    sessionProvider: LLFirSessionProvider,
    firFileBuilder: FirFileBuilder,
    firLazyDeclarationResolver: FirLazyDeclarationResolver,
 ) : LLFirResolvableModuleResolveState(sessionProvider, firFileBuilder, firLazyDeclarationResolver) {
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.state

-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 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.element.builder.getNonLocalContainingOrThisDeclaration
@@ -13,9 +13,9 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuild
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.FirIdeProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSessionProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSourcesSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSourcesSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.FirDeclarationForCompiledElementSearcher
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.findSourceNonLocalFirDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
@@ -36,12 +36,12 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.psi.*

 internal abstract class LLFirResolvableModuleResolveState(
-    protected val sessionProvider: FirIdeSessionProvider,
+    protected val sessionProvider: LLFirSessionProvider,
    val firFileBuilder: FirFileBuilder,
    val firLazyDeclarationResolver: FirLazyDeclarationResolver,
-) : FirModuleResolveState() {
+) : LLFirModuleResolveState() {
    final override val rootModuleSession = sessionProvider.rootModuleSession
-    val cache = (rootModuleSession.firProvider as FirIdeProvider).cache
+    val cache = (rootModuleSession.firProvider as LLFirProvider).cache

    val fileStructureCache = FileStructureCache(firFileBuilder, firLazyDeclarationResolver)
    val elementBuilder = FirElementBuilder()
@@ -127,7 +127,7 @@ internal abstract class LLFirResolvableModuleResolveState(
    override fun resolveFirToPhase(declaration: FirDeclaration, toPhase: FirResolvePhase) {
        if (toPhase == FirResolvePhase.RAW_FIR) return
        val fileCache = when (val session = declaration.moduleData.session) {
-            is FirIdeSourcesSession -> session.cache
+            is LLFirSourcesSession -> session.cache
            else -> return
        }
        firLazyDeclarationResolver.lazyResolveDeclaration(
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilt
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.DiagnosticsCollector
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSessionProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProvider
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
@@ -19,10 +19,10 @@ import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile

-internal class FirSourceModuleResolveState(
+internal class LLFirSourceModuleResolveState(
    override val project: Project,
    override val module: KtModule,
-    sessionProvider: FirIdeSessionProvider,
+    sessionProvider: LLFirSessionProvider,
    firFileBuilder: FirFileBuilder,
    firLazyDeclarationResolver: FirLazyDeclarationResolver,
 ) : LLFirResolvableModuleResolveState(sessionProvider, firFileBuilder, firLazyDeclarationResolver) {
@@ -6,20 +6,25 @@
 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.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 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: FirModuleResolveState) : FirTowerContextProvider {
+internal class TowerProviderForElementForState(private val state: LLFirModuleResolveState) : FirTowerContextProvider {
    override fun getClosestAvailableParentContext(ktElement: KtElement): FirTowerDataContext? {
-        return if (state is FirModuleResolveStateDepended) {
-            state.towerProviderBuiltUponElement.getClosestAvailableParentContext(ktElement)
-                ?: LowLevelFirApiFacadeForResolveOnAir.onAirGetTowerContextProvider(state.originalState, ktElement)
-                    .getClosestAvailableParentContext(ktElement)
-        } else {
-            LowLevelFirApiFacadeForResolveOnAir.onAirGetTowerContextProvider(state, ktElement).getClosestAvailableParentContext(ktElement)
+        if (state is FirModuleResolveStateDepended) {
+            state.towerProviderBuiltUponElement
+                .getClosestAvailableParentContext(ktElement)
+                ?.let { return it }
+
+            return LowLevelFirApiFacadeForResolveOnAir
+                .onAirGetTowerContextProvider(state.originalState, ktElement)
+                .getClosestAvailableParentContext(ktElement)
        }
+        return LowLevelFirApiFacadeForResolveOnAir
+            .onAirGetTowerContextProvider(state, ktElement)
+            .getClosestAvailableParentContext(ktElement)
    }
 }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation

-internal class IDEDeclarationTransformer(private val designation: FirDeclarationDesignation) {
+internal class LLFirDeclarationTransformer(private val designation: FirDeclarationDesignation) {
    private val designationWithoutTargetIterator = designation.toSequence(includeTarget = false).iterator()
    private var isInsideTargetDeclaration: Boolean = false
    private var designationPassed: Boolean = false
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers

-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
@@ -16,11 +16,11 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumentsResolveTransformer
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef

-internal class FirDesignatedAnnotationArgumentsResolveTransformerForIDE(
+internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    session: FirSession,
    scopeSession: ScopeSession,
-) : FirLazyTransformerForIDE, FirAnnotationArgumentsResolveTransformer(session, scopeSession) {
+) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession) {

    private fun moveNextDeclaration(designationIterator: Iterator<FirDeclaration>) {
        if (!designationIterator.hasNext()) {
@@ -47,7 +47,7 @@ internal class FirDesignatedAnnotationArgumentsResolveTransformerForIDE(
        }
    }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) return
        designation.declaration.ensurePhase(FirResolvePhase.STATUS)

@@ -59,7 +59,7 @@ internal class FirDesignatedAnnotationArgumentsResolveTransformerForIDE(
            }
        }

-        FirLazyTransformerForIDE.updatePhaseDeep(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+        LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
        ensureResolved(designation.declaration)
        ensureResolvedDeep(designation.declaration)
    }
@@ -14,23 +14,23 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolve
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirIdeEnsureBasedTransformerForReturnTypeCalculator
+import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirEnsureBasedTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase

 /**
 * Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children
 */
-internal class FirDesignatedBodyResolveTransformerForIDE(
+internal class LLFirDesignatedBodyResolveTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    session: FirSession,
    scopeSession: ScopeSession,
    towerDataContextCollector: FirTowerDataContextCollector?,
    firProviderInterceptor: FirProviderInterceptor?,
-) : FirLazyTransformerForIDE, FirBodyResolveTransformer(
+) : LLFirLazyTransformer, FirBodyResolveTransformer(
    session,
    phase = FirResolvePhase.BODY_RESOLVE,
    implicitTypeOnly = false,
@@ -39,19 +39,19 @@ internal class FirDesignatedBodyResolveTransformerForIDE(
        session,
        scopeSession,
        ImplicitBodyResolveComputationSession(),
-        ::FirIdeEnsureBasedTransformerForReturnTypeCalculator
+        ::LLFirEnsureBasedTransformerForReturnTypeCalculator
    ),
    firTowerDataContextCollector = towerDataContextCollector,
    firProviderInterceptor = firProviderInterceptor,
 ) {
-    private val ideDeclarationTransformer = IDEDeclarationTransformer(designation)
+    private val ideDeclarationTransformer = LLFirDeclarationTransformer(designation)

    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
        ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) {
            super.transformDeclarationContent(declaration, data)
        }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return
        designation.declaration.ensurePhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)

@@ -11,23 +11,23 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase

 /**
 * Transform designation into CONTRACTS declaration. Affects only for target declaration and it's children
 */
-internal class FirDesignatedContractsResolveTransformerForIDE(
+internal class LLFirDesignatedContractsResolveTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    session: FirSession,
    scopeSession: ScopeSession,
-) : FirLazyTransformerForIDE, FirContractResolveTransformer(session, scopeSession) {
+) : LLFirLazyTransformer, FirContractResolveTransformer(session, scopeSession) {

-    private val ideDeclarationTransformer = IDEDeclarationTransformer(designation)
+    private val ideDeclarationTransformer = LLFirDeclarationTransformer(designation)

    override val declarationsTransformer: FirDeclarationsResolveTransformer = object : FirDeclarationsContractResolveTransformer(this) {
        override fun transformDeclarationContent(firClass: FirClass, data: ResolutionMode) {
@@ -43,7 +43,7 @@ internal class FirDesignatedContractsResolveTransformerForIDE(
            super.transformDeclarationContent(declaration, data)
        }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.CONTRACTS) return
        designation.declaration.ensurePhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)

@@ -14,23 +14,23 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase

 /**
 * Transform designation into IMPLICIT_TYPES_BODY_RESOLVE declaration. Affects only for target declaration, it's children and dependents
 */
-internal class FirDesignatedImplicitTypesTransformerForIDE(
+internal class LLFirDesignatedImplicitTypesTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    session: FirSession,
    scopeSession: ScopeSession,
    towerDataContextCollector: FirTowerDataContextCollector?,
    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession(),
-) : FirLazyTransformerForIDE, FirImplicitAwareBodyResolveTransformer(
+) : LLFirLazyTransformer, FirImplicitAwareBodyResolveTransformer(
    session,
    implicitBodyResolveComputationSession = implicitBodyResolveComputationSession,
    phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE,
@@ -41,17 +41,17 @@ internal class FirDesignatedImplicitTypesTransformerForIDE(
        session,
        scopeSession,
        implicitBodyResolveComputationSession,
-        ::FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+        ::LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
    )
 ) {
-    private val ideDeclarationTransformer = IDEDeclarationTransformer(designation)
+    private val ideDeclarationTransformer = LLFirDeclarationTransformer(designation)

    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
        ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) {
            super.transformDeclarationContent(declaration, data)
        }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return
        designation.declaration.ensurePhase(FirResolvePhase.CONTRACTS)

@@ -11,24 +11,24 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase

 /**
 * Transform designation into STATUS phase. Affects only for designation, target declaration, it's children and dependents
 */
-internal class FirDesignatedStatusResolveTransformerForIDE(
+internal class LLFirDesignatedStatusResolveTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    private val session: FirSession,
    private val scopeSession: ScopeSession,
-) : FirLazyTransformerForIDE {
+) : LLFirLazyTransformer {
    private inner class FirDesignatedStatusResolveTransformerForIDE :
        FirStatusResolveTransformer(session, scopeSession, StatusComputationSession.Regular()) {

-        val designationTransformer = IDEDeclarationTransformer(designation)
+        val designationTransformer = LLFirDeclarationTransformer(designation)

        override fun transformDeclarationContent(declaration: FirDeclaration, data: FirResolvedDeclarationStatus?): FirDeclaration =
            designationTransformer.transformDeclarationContent(this, declaration, data) {
@@ -36,7 +36,7 @@ internal class FirDesignatedStatusResolveTransformerForIDE(
            }
    }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.STATUS) return
        designation.declaration.ensurePhase(FirResolvePhase.TYPES)

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.toSymbol
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
@@ -21,14 +21,14 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCa
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.runCustomResolveUnderLock
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE.Companion.updatePhaseDeep
+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.ensurePhase

 /**
 * Transform designation into SUPER_TYPES phase. Affects only for designation, target declaration, it's children and dependents
 */
-internal class FirDesignatedSupertypeResolverTransformerForIDE(
+internal class LLFirDesignatedSupertypeResolverTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    private val session: FirSession,
    private val scopeSession: ScopeSession,
@@ -36,7 +36,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
    private val firLazyDeclarationResolver: FirLazyDeclarationResolver,
    private val firProviderInterceptor: FirProviderInterceptor?,
    private val checkPCE: Boolean,
-) : FirLazyTransformerForIDE {
+) : LLFirLazyTransformer {

    private val supertypeComputationSession = SupertypeComputationSession()

@@ -49,7 +49,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
            localClassesNavigationInfo = null,
            firProviderInterceptor = firProviderInterceptor,
        ) {
-        val declarationTransformer = IDEDeclarationTransformer(classDesignation)
+        val declarationTransformer = LLFirDeclarationTransformer(classDesignation)

        override fun visitDeclarationContent(declaration: FirDeclaration, data: Any?) {
            declarationTransformer.visitDeclarationContent(this, declaration, data) {
@@ -62,7 +62,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
    private inner class DesignatedFirApplySupertypesTransformer(classDesignation: FirDeclarationDesignation) :
        FirApplySupertypesTransformer(supertypeComputationSession) {

-        val declarationTransformer = IDEDeclarationTransformer(classDesignation)
+        val declarationTransformer = LLFirDeclarationTransformer(classDesignation)

        override fun transformDeclarationContent(declaration: FirDeclaration, data: Any?): FirDeclaration {
            return declarationTransformer.transformDeclarationContent(this, declaration, data) {
@@ -129,7 +129,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
        }
    }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.SUPER_TYPES) return
        designation.firFile.ensurePhase(FirResolvePhase.IMPORTS)

@@ -12,22 +12,22 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase

 /**
 * Transform designation into TYPES phase. Affects only for designation, target declaration and it's children
 */
-internal class FirDesignatedTypeResolverTransformerForIDE(
+internal class LLFirDesignatedTypeResolverTransformer(
    private val designation: FirDeclarationDesignationWithFile,
    session: FirSession,
    scopeSession: ScopeSession,
-) : FirLazyTransformerForIDE, FirTypeResolveTransformer(session, scopeSession) {
+) : LLFirLazyTransformer, FirTypeResolveTransformer(session, scopeSession) {

-    private val declarationTransformer = IDEDeclarationTransformer(designation)
+    private val declarationTransformer = LLFirDeclarationTransformer(designation)

    override fun <E : FirElement> transformElement(element: E, data: Any?): E {
        return if (element is FirDeclaration && (element is FirRegularClass || element is FirFile)) {
@@ -40,7 +40,7 @@ internal class FirDesignatedTypeResolverTransformerForIDE(
        }
    }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (designation.declaration.resolvePhase >= FirResolvePhase.TYPES) return
        designation.declaration.ensurePhase(FirResolvePhase.SUPER_TYPES)

@@ -12,10 +12,10 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolve
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
+import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator

-internal class FirFileAnnotationsResolveTransformer(
+internal class LLFirFileAnnotationsResolveTransformer(
    private val firFile: FirFile,
    private val annotations: List<FirAnnotation>,
    session: FirSession,
@@ -31,10 +31,10 @@ internal class FirFileAnnotationsResolveTransformer(
        session,
        scopeSession,
        implicitBodyResolveComputationSession,
-        ::FirIdeDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+        ::LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
    ),
    firTowerDataContextCollector = firTowerDataContextCollector
-), FirLazyTransformerForIDE {
+), LLFirLazyTransformer {

    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration {
        require(declaration is FirFile) { "Unexpected declaration ${declaration::class.simpleName}" }
@@ -46,7 +46,7 @@ internal class FirFileAnnotationsResolveTransformer(
        return declaration
    }

-    override fun transformDeclaration(phaseRunner: FirPhaseRunner) {
+    override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
        if (annotations.all { it.resolved }) return
        check(firFile.resolvePhase >= FirResolvePhase.IMPORTS) { "Invalid file resolve phase ${firFile.resolvePhase}" }

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.ClassId

-internal class FirProviderInterceptorForIDE private constructor(
+internal class LLFirFirProviderInterceptor private constructor(
    private val firFile: FirFile,
    private val session: FirSession,
    private val symbolSet: Set<FirClassLikeSymbol<*>>,
@@ -43,7 +43,7 @@ internal class FirProviderInterceptorForIDE private constructor(
            }
            nodeInfoCollector.visitElement(element)

-            return FirProviderInterceptorForIDE(firFile, session, nodeInfoCollector.symbolSet, nodeInfoCollector.classIdToElementMap)
+            return LLFirFirProviderInterceptor(firFile, session, nodeInfoCollector.symbolSet, nodeInfoCollector.classIdToElementMap)
        }
    }
 }
@@ -10,11 +10,10 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner

-internal interface FirLazyTransformerForIDE {
-    fun transformDeclaration(phaseRunner: FirPhaseRunner)
+internal interface LLFirLazyTransformer {
+    fun transformDeclaration(phaseRunner: LLFirPhaseRunner)
    fun ensureResolved(declaration: FirDeclaration)
    fun ensureResolvedDeep(declaration: FirDeclaration) {
        if (!enableDeepEnsure) return
@@ -64,8 +63,8 @@ internal interface FirLazyTransformerForIDE {
        internal var enableDeepEnsure: Boolean = false
            @TestOnly set

-        val DUMMY = object : FirLazyTransformerForIDE {
-            override fun transformDeclaration(phaseRunner: FirPhaseRunner) = Unit
+        val DUMMY = object : LLFirLazyTransformer {
+            override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) = Unit
            override fun ensureResolved(declaration: FirDeclaration) = error("Not implemented")
        }
    }
@@ -23,9 +23,9 @@ internal object LazyTransformerFactory {
        towerDataContextCollector: FirTowerDataContextCollector?,
        firProviderInterceptor: FirProviderInterceptor?,
        checkPCE: Boolean,
-    ): FirLazyTransformerForIDE = when (phase) {
-        FirResolvePhase.SEALED_CLASS_INHERITORS -> FirLazyTransformerForIDE.DUMMY
-        FirResolvePhase.SUPER_TYPES -> FirDesignatedSupertypeResolverTransformerForIDE(
+    ): LLFirLazyTransformer = when (phase) {
+        FirResolvePhase.SEALED_CLASS_INHERITORS -> LLFirLazyTransformer.DUMMY
+        FirResolvePhase.SUPER_TYPES -> LLFirDesignatedSupertypeResolverTransformer(
            designation = designation,
            session = designation.firFile.moduleData.session,
            scopeSession = scopeSession,
@@ -34,33 +34,33 @@ internal object LazyTransformerFactory {
            firProviderInterceptor = firProviderInterceptor,
            checkPCE = checkPCE,
        )
-        FirResolvePhase.TYPES -> FirDesignatedTypeResolverTransformerForIDE(
+        FirResolvePhase.TYPES -> LLFirDesignatedTypeResolverTransformer(
            designation,
            designation.firFile.moduleData.session,
            scopeSession,
        )
-        FirResolvePhase.STATUS -> FirDesignatedStatusResolveTransformerForIDE(
+        FirResolvePhase.STATUS -> LLFirDesignatedStatusResolveTransformer(
            designation,
            designation.firFile.moduleData.session,
            scopeSession,
        )
-        FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS -> FirDesignatedAnnotationArgumentsResolveTransformerForIDE(
+        FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS -> LLFirDesignatedAnnotationArgumentsResolveTransformer(
            designation,
            designation.firFile.moduleData.session,
            scopeSession,
        )
-        FirResolvePhase.CONTRACTS -> FirDesignatedContractsResolveTransformerForIDE(
+        FirResolvePhase.CONTRACTS -> LLFirDesignatedContractsResolveTransformer(
            designation,
            designation.firFile.moduleData.session,
            scopeSession,
        )
-        FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> FirDesignatedImplicitTypesTransformerForIDE(
+        FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> LLFirDesignatedImplicitTypesTransformer(
            designation,
            designation.firFile.moduleData.session,
            scopeSession,
            towerDataContextCollector
        )
-        FirResolvePhase.BODY_RESOLVE -> FirDesignatedBodyResolveTransformerForIDE(
+        FirResolvePhase.BODY_RESOLVE -> LLFirDesignatedBodyResolveTransformer(
            designation,
            designation.firFile.moduleData.session,
            scopeSession,
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir

-import org.jetbrains.kotlin.analysis.low.level.api.fir.state.FirSourceModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirRenderer
@@ -54,7 +54,7 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
        val rendererOption = FirRenderer.RenderMode.WithDeclarationAttributes.copy(renderDeclarationResolvePhase = true)
        val resultBuilder = StringBuilder()
        resolveWithClearCaches(ktFile) { firModuleResolveState ->
-            check(firModuleResolveState is FirSourceModuleResolveState)
+            check(firModuleResolveState is LLFirSourceModuleResolveState)
            val declarationToResolve = firModuleResolveState
                .getOrBuildFirFile(ktFile)
                .findResolveMe()
@@ -68,7 +68,7 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
        }

        resolveWithClearCaches(ktFile) { firModuleResolveState ->
-            check(firModuleResolveState is FirSourceModuleResolveState)
+            check(firModuleResolveState is LLFirSourceModuleResolveState)
            val firFile = firModuleResolveState.getOrBuildFirFile(ktFile)
            firFile.ensureResolved(FirResolvePhase.BODY_RESOLVE)
            resultBuilder.append("\nFILE RAW TO BODY:\n")
@@ -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.FirSourceModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.render
@@ -33,7 +33,7 @@ abstract class AbstractFirOnAirResolveTest : AbstractLowLevelApiSingleFileTest()
        check(place::class == onAir::class)

        resolveWithClearCaches(ktFile) { resolveState ->
-            check(resolveState is FirSourceModuleResolveState)
+            check(resolveState is LLFirSourceModuleResolveState)
            val firElement = LowLevelFirApiFacadeForResolveOnAir.onAirResolveElement(resolveState, place, onAir)
            val rendered = firElement.render(FirRenderer.RenderMode.WithResolvePhases)
            testServices.assertions.assertEqualsToTestDataFileSibling(rendered)
@@ -12,8 +12,7 @@ import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvide
 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.transformers.FirLazyTransformerForIDE
-import org.jetbrains.kotlin.analysis.project.structure.KtModule
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
@@ -82,12 +81,12 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() {
        if (ignoreTest(filePath, configuration)) {
            return
        }
-        val oldEnableDeepEnsure = FirLazyTransformerForIDE.enableDeepEnsure
+        val oldEnableDeepEnsure = LLFirLazyTransformer.enableDeepEnsure
        try {
-            FirLazyTransformerForIDE.enableDeepEnsure = true
+            LLFirLazyTransformer.enableDeepEnsure = true
            super.runTest(filePath)
        } finally {
-            FirLazyTransformerForIDE.enableDeepEnsure = oldEnableDeepEnsure
+            LLFirLazyTransformer.enableDeepEnsure = oldEnableDeepEnsure
        }
    }
 }
@@ -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.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
 import org.jetbrains.kotlin.fir.analysis.AbstractFirAnalyzerFacade
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.test.model.TestFile

 class LowLevelFirAnalyzerFacade(
-    val resolveState: FirModuleResolveState,
+    val resolveState: LLFirModuleResolveState,
    val allFirFiles: Map<TestFile, FirFile>,
    private val diagnosticCheckerFilter: DiagnosticCheckerFilter,
 ) : AbstractFirAnalyzerFacade() {
@@ -14,7 +14,7 @@ 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.api.impl.barebone.test.projectModuleProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.FirIdeResolveStateService
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService
 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.test.base.SealedClassInheritorsProviderTestImpl
@@ -53,7 +53,7 @@ fun MockProject.registerTestServices(
        FirSealedClassInheritorsProcessorFactoryTestImpl()
    )
    registerService(KtModuleScopeProvider::class.java, KtModuleScopeProviderImpl())
-    registerService(FirIdeResolveStateService::class.java)
+    registerService(LLFirResolveStateService::class.java)
    registerService(
        KotlinModificationTrackerFactory::class.java,
        KotlinStaticModificationTrackerFactory::class.java
@@ -11,7 +11,7 @@ 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.FirSourceModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState
 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
@@ -41,7 +41,7 @@ abstract class AbstractFirContextCollectionTest : AbstractLowLevelApiSingleFileT
                register(BeforeElementDiagnosticCollectionHandler::class, handler)
            }
        ) { resolveState ->
-            check(resolveState is FirSourceModuleResolveState)
+            check(resolveState is LLFirSourceModuleResolveState)

            val fileStructure = resolveState.fileStructureCache.getFileStructure(ktFile, resolveState.cache)
            val allStructureElements = fileStructure.getAllStructureElements()
@@ -9,7 +9,7 @@ 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.FirSourceModuleResolveState
+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.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.psi.*
@@ -85,7 +85,7 @@ abstract class AbstractFileStructureTest : AbstractLowLevelApiSingleFileTest() {
    }

    private fun KtFile.getFileStructure(): FileStructure {
-        val moduleResolveState = getResolveState() as FirSourceModuleResolveState
+        val moduleResolveState = getResolveState() as LLFirSourceModuleResolveState
        return moduleResolveState.fileStructureCache.getFileStructure(
            ktFile = this,
            moduleFileCache = moduleResolveState.cache
@@ -14,8 +14,8 @@ 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.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState
+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

@@ -36,8 +36,8 @@ internal fun FirDeclaration.name(): String = symbol.name()

 internal inline fun <R> resolveWithClearCaches(
    context: KtElement,
-    noinline configureSession: FirIdeSession.() -> Unit = {},
-    action: (FirModuleResolveState) -> R,
+    noinline configureSession: LLFirSession.() -> Unit = {},
+    action: (LLFirModuleResolveState) -> R,
 ): R {
    val project = context.project
    val resolveState = createResolveStateForNoCaching(context.getKtModule(project), project, configureSession)