[low level api] remove unused code

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

@@ -73,13 +73,6 @@ internal class FirModuleResolveStateDepended(
         originalState.resolveFirToPhase(declaration, toPhase)
     }
 
-    override fun tryGetCachedFirFile(declaration: FirDeclaration, cache: ModuleFileCache): FirFile? {
-        val ktFile = declaration.containingKtFileIfAny ?: return null
-        cache.getCachedFirFile(ktFile)?.let { return it }
-        ktFile.originalKtFile?.let(cache::getCachedFirFile)?.let { return it }
-        return null
-    }
-
     override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> =
         TODO("Diagnostics are not implemented for depended state")
 

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

@@ -51,11 +51,6 @@ abstract class LLFirModuleResolveState {
      */
     internal abstract fun getOrBuildFirFile(ktFile: KtFile): FirFile
 
-    /**
-     * Try get [FirFile] from the cache in undefined phase
-     */
-    internal abstract fun tryGetCachedFirFile(declaration: FirDeclaration, cache: ModuleFileCache): FirFile?
-
     internal abstract fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic>
 
     internal abstract fun collectDiagnosticsForFile(ktFile: KtFile, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic>

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/LLFirLibraryResolveModuleFileCache.kt

@@ -1,77 +0,0 @@
-/*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder
-
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
-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
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibraryOrLibrarySourceResolvableModuleSession
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.psi.KtFile
-import java.util.*
-import java.util.concurrent.ConcurrentHashMap
-
-internal class LLFirLibraryResolveModuleFileCache: ModuleFileCache() {
-
-    private val kfFileToFirCache = ConcurrentHashMap<KtFile, ResolvedFile>()
-
-    override val classifierByClassId: ConcurrentHashMap<ClassId, Optional<FirClassLikeDeclaration>> get() = error("Should not be called")
-    override val callableByCallableId: ConcurrentHashMap<CallableId, List<FirCallableSymbol<*>>> get() = error("Should not be called")
-
-    override fun fileCached(file: KtFile, createValue: () -> FirFile): FirFile {
-        return getResolvedFile(file) { createValue() }.firFile
-    }
-
-    override fun getContainerFirFile(declaration: FirDeclaration): FirFile? {
-        val ktFile = declaration.psi?.containingFile as? KtFile ?: return null
-        return getCachedFirFile(ktFile)
-    }
-
-    override fun getCachedFirFile(ktFile: KtFile): FirFile? {
-        return kfFileToFirCache[ktFile]?.firFile
-    }
-
-    override val firFileLockProvider: LockProvider<FirFile> = LockProvider()
-
-    fun getResolvedFile(
-        ktFile: KtFile,
-        createKtFile: (KtFile) -> FirFile
-    ): ResolvedFile = kfFileToFirCache.computeIfAbsent(ktFile) {
-        val collector = FirTowerDataContextAllElementsCollector()
-
-        val scopeSession = moduleComponents.scopeSessionProvider.getScopeSession()
-
-        val firFile = createKtFile(ktFile)
-
-        moduleComponents.lazyFirDeclarationsResolver.lazyResolveFileDeclaration(
-            firFile,
-            FirResolvePhase.BODY_RESOLVE,
-            scopeSession,
-            collector,
-            checkPCE = true
-        )
-
-        ResolvedFile(
-            firFile,
-            KtToFirMapping(firFile, FirElementsRecorder()),
-            collector
-        )
-    }
-
-    class ResolvedFile(
-        val firFile: FirFile,
-        val mapping: KtToFirMapping,
-        val collector: FirTowerDataContextAllElementsCollector,
-    )
-}

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

@@ -1,57 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure
-
-import org.jetbrains.kotlin.fir.containingClass
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.declarationCanBeLazilyResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.replaceFirst
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
-
-internal object FileStructureUtil {
-    fun isStructureElementContainer(ktDeclaration: KtDeclaration): Boolean = when {
-        ktDeclaration !is KtClassOrObject && ktDeclaration !is KtDeclarationWithBody && ktDeclaration !is KtProperty && ktDeclaration !is KtTypeAlias -> false
-        ktDeclaration is KtEnumEntry -> false
-        ktDeclaration.containingClassOrObject is KtEnumEntry -> false
-        ktDeclaration is KtNamedDeclaration -> !declarationCanBeLazilyResolved(ktDeclaration)
-        else -> false
-    }
-
-    fun replaceDeclaration(firFile: FirFile, from: FirCallableDeclaration, to: FirCallableDeclaration) {
-        val declarations = if (from.symbol.callableId.className == null) {
-            firFile.declarations as MutableList<FirDeclaration>
-        } else {
-            val classLikeLookupTag = from.containingClass()
-                ?: error("Class name should not be null for non-top-level & non-local declarations, but was null for\n${from.render()}")
-            val containingClass = classLikeLookupTag.toSymbol(firFile.moduleData.session)?.fir as FirRegularClass
-            containingClass.declarations as MutableList<FirDeclaration>
-        }
-        declarations.replaceFirst(from, to)
-    }
-
-    inline fun <R> withDeclarationReplaced(
-        firFile: FirFile,
-        cache: ModuleFileCache,
-        from: FirCallableDeclaration,
-        to: FirCallableDeclaration,
-        action: () -> R,
-    ): R {
-        cache.firFileLockProvider.withWriteLock(firFile) { replaceDeclaration(firFile, from, to) }
-        return try {
-            action()
-        } catch (e: Throwable) {
-            cache.firFileLockProvider.withWriteLock(firFile) { replaceDeclaration(firFile, to, from) }
-            throw e
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-/*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
-
-import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLibraryResolveModuleFileCache
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.java.deserialization.JvmClassFileBasedSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-
-internal class LLFirLibraryResolvableProvider(
-    override val symbolProvider: JvmClassFileBasedSymbolProvider,
-    private val cache: LLFirLibraryResolveModuleFileCache,
-) : FirProvider() {
-
-    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
-        symbolProvider.getClassLikeSymbolByClassId(classId)?.fir
-
-    override fun getFirClassifierContainerFile(fqName: ClassId): FirFile =
-        getFirClassifierContainerFileIfAny(fqName)!!
-
-    override fun getFirClassifierContainerFileIfAny(fqName: ClassId): FirFile? = null
-    override fun getFirCallableContainerFile(symbol: FirCallableSymbol<*>): FirFile? = null
-    override fun getFirFilesByPackage(fqName: FqName): List<FirFile> = emptyList()
-
-    override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()
-
-    private fun shouldNotBeCalled(): Nothing = error("Should not be called for LLFirLibrariesSessionProvider")
-}

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

@@ -59,9 +59,6 @@ internal abstract class LLFirResolvableModuleResolveState(
         return moduleComponents.firFileBuilder.buildRawFirFileWithCaching(ktFile)
     }
 
-    override fun tryGetCachedFirFile(declaration: FirDeclaration, cache: ModuleFileCache): FirFile? =
-        cache.getContainerFirFile(declaration)
-
     protected fun getModuleComponentsForElement(element: KtElement): LLFirModuleResolveComponents {
         val ktModule = element.getKtModule()
         return sessionProvider.getSession(ktModule).moduleComponents