protected abstract fun getSessionKtModule(session: SESSION): KtModule

    protected abstract fun isSessionValid(session: SESSION): Boolean

    /**
     * In some cases, it might be legal for a session cache to evict sessions which are still valid. Such sessions would fail the validity
     * check (see [checkSessionsMarkedInvalid]) and should be skipped.
     */

            }
        }
    }
}

private class BuilderCache<From, To : KaSymbol> {
    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<From, To>()

    inline fun <reified S : To> cache(key: From, calculation: () -> S): S {
        val value = cache.getOrPut(key, calculation)
        return value as? S
            ?: errorWithAttachment("Cannot cast ${value::class} to ${S::class}") {

    override fun isSessionValid(session: KaSession): Boolean = session.isValid()

    /**
     * The analysis session cache disregards whether libraries were invalidated during global invalidation, so some valid library analysis
     * sessions may have been evicted from the cache and should not be checked for validity.
     */
    override fun shouldSkipValidityCheck(session: KaSession): Boolean =

                import.resolvedParentClassId
            )
        }
    }

    override fun getConstructors(): Sequence<KaConstructorSymbol> = withValidityAssertion { emptySequence() }

    // todo cache?
    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        imports.flatMapTo(hashSetOf()) { import: Import ->
            if (import.relativeClassName == null) { // top level callable

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.psi.KtClassOrObject

//todo introduce LibraryModificationTracker based cache?
internal object FirSyntheticFunctionInterfaceSourceProvider {
    fun findPsi(fir: FirDeclaration): PsiElement? {
        return when (fir) {
            is FirSimpleFunction -> provideSourceForInvokeFunction(fir)

import org.jetbrains.kotlin.psi.*

/**
 * A declaration provider for a given scope. It can be created via [KotlinDeclarationProviderFactory].
 *
 * It may be called frequently, so implementations should cache the results.
 */
public abstract class KotlinDeclarationProvider : KotlinComposableProvider {
    public abstract fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration?

- [`KT-61331`](https://youtrack.jetbrains.com/issue/KT-61331) K2: add cache restoring in case of existing context
- [`KT-61408`](https://youtrack.jetbrains.com/issue/KT-61408) K2: IDE K2: "Inconsistency in the cache. Someone without context put a null value in the cache"

### Analysis. Light Classes

#### Performance Improvements

         * with [getCompositeScope]) avoids duplicate inner classes, as they are contained in non-static and static scopes.
         *
         * A proper combined declared member scope kind also makes it easier to cache combined scopes directly (if needed).
         */
        COMBINED,
    }

    private fun getDeclaredMemberScope(classSymbol: KaSymbolWithMembers, kind: DeclaredMemberScopeKind): KaScope {

            modules.forEach { analysisSessionProvider.cache.remove(it) }
        }

        override fun afterGlobalInvalidation() {
            // Session invalidation events currently don't report whether library modules were included in the global invalidation. This is
            // by design to avoid iterating through the whole analysis session cache and to simplify the global session invalidation event.

) : KotlinPackagePartProviderFactory() {
    private val cache = ContainerUtil.createConcurrentSoftMap<GlobalSearchScope, PackagePartProvider>()

    override fun createPackagePartProvider(scope: GlobalSearchScope): PackagePartProvider {
        return cache.getOrPut(scope) {
            packagePartProvider(scope)
        }
    }