is FirCompositeScope -> firScope.scopes.flatMap { flattenFirScope(it) }
        is FirNameAwareCompositeScope -> firScope.scopes.flatMap { flattenFirScope(it) }
        else -> listOf(firScope)
    }

    private fun convertToKtScope(firScope: FirScope): KtScope {
        return when (firScope) {

import org.jetbrains.kotlin.name.Name

internal class KtFirStarImportingScope(
    firScope: FirAbstractStarImportingScope,
    private val analysisSession: KtFirAnalysisSession,
) : KtFirBasedScope<FirAbstractStarImportingScope>(firScope, analysisSession.firSymbolBuilder) {

    private val imports: List<StarImport> by cached {
        firScope.starImports.map { import ->
            StarImport(
                import.packageFqName,

internal class KtFirDefaultStarImportingScope(
    firScope: FirDefaultStarImportingScope,
    analysisSession: KtFirAnalysisSession,
) : KtFirBasedScope<FirDefaultStarImportingScope>(firScope, analysisSession.firSymbolBuilder) {

    private val firstWrappedScope = KtFirStarImportingScope(firScope.first, analysisSession)
    private val secondWrappedScope = KtFirStarImportingScope(firScope.second, analysisSession)

import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.name.Name

internal abstract class KtFirBasedScope<S : FirScope>(
    internal val firScope: S,
    protected val builder: KtSymbolByFirBuilder,
) : KtScope {
    final override val token: KtLifetimeToken get() = builder.token

        firScope.getCallableSymbols(getPossibleCallableNames().filter(nameFilter), analysisSession.firSymbolBuilder)
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KtCallableSymbol> = withValidityAssertion {
        firScope.getCallableSymbols(names, analysisSession.firSymbolBuilder)
    }

        firScope.getCallableNames()
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        firScope.getClassifierNames()
    }

    override fun getCallableSignatures(nameFilter: KtScopeNameFilter): Sequence<KtCallableSignature<*>> = withValidityAssertion {
        firScope.getCallableSignatures(getPossibleCallableNames().filter(nameFilter), builder)

import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
import org.jetbrains.kotlin.name.Name

internal open class KtFirDelegatingNamesAwareScope(
    firScope: FirContainingNamesAwareScope,
    builder: KtSymbolByFirBuilder,
) : KtFirBasedScope<FirContainingNamesAwareScope>(firScope, builder) {
    private val allNamesCached by cached {
        getPossibleCallableNames() + getPossibleClassifierNames()
    }

import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
import org.jetbrains.kotlin.name.Name


internal fun FirScope.getCallableSymbols(
    callableNames: Collection<Name>,
    builder: KtSymbolByFirBuilder
): Sequence<KtCallableSymbol> = sequence {

        }
    }

    /**
     * Returns whether this [FirScope] is a scope wider than [another] based on the above [PartialOrderOfScope] or not.
     */
    private fun FirScope.isWiderThan(another: FirScope): Boolean =
        toPartialOrder().scopeDistanceLevel > another.toPartialOrder().scopeDistanceLevel

    /**
     * Assuming that all scopes in this List<FirScope> and [base] are surrounding [from], returns whether an element of

import org.jetbrains.kotlin.name.Name

internal class KtFirNonStarImportingScope(
    firScope: FirAbstractSimpleImportingScope,
    builder: KtSymbolByFirBuilder,
) : KtFirBasedScope<FirAbstractSimpleImportingScope>(firScope, builder) {

    private val imports: List<NonStarImport> by cached {
        buildList {
            firScope.simpleImports.values.forEach { imports ->
                imports.forEach { import ->