private val analysisContext: Fe10AnalysisContext,
    private val analyzeOnlyReifiedInlineFunctions: Boolean,
) {
    private val analyzedElements: MutableSet<KtElement> = mutableSetOf()
    private val inlineFunctionsWithBody: MutableSet<KtDeclarationWithBody> = mutableSetOf()

    /**
     * Collects all inline function calls in an [element] (usually a file) and follows each transitively.
     */
    fun analyze(element: KtElement) {

        }
    }

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        tools.flatMapTo(mutableSetOf()) { it.declarationProvider.getTopLevelCallableNames() }
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        tools.flatMapTo(mutableSetOf()) { it.declarationProvider.getTopLevelClassifierNames() }
    }

        _callableNames + _classifierNames
    }

    override fun getAllPossibleNames(): Set<Name> = withValidityAssertion { allNamesCached }

    private val _callableNames: Set<Name> by cached {
        val result = mutableSetOf<Name>()
        owner.firSymbol.fir.declarations
            .mapNotNullTo(result) { firDeclaration ->
                when (firDeclaration) {
                    is FirSimpleFunction -> firDeclaration.name

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        return getCallableSymbols().mapNotNullTo(mutableSetOf()) { (it as? KtPossiblyNamedSymbol)?.name }
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        return getClassifierSymbols().mapNotNullTo(mutableSetOf()) { (it as? KtPossiblyNamedSymbol)?.name }
    }

                getAllOverriddenSymbols(analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it))
            }
        }

        val overriddenElement = mutableSetOf<FirCallableSymbol<*>>()
        processOverrides(callableSymbol) { firTypeScope, firCallableDeclaration ->
            firTypeScope.processAllOverriddenDeclarations(firCallableDeclaration) { overriddenDeclaration ->

        val inlineObjectDeclarations = inlineAnalyzer.inlineObjectDeclarations()
        val inlineObjectDeclarationFiles = inlineObjectDeclarations.mapTo(mutableSetOf()) { it.containingKtFile }

        class GenerateClassFilter : GenerationState.GenerateClassFilter() {
            override fun shouldGeneratePackagePart(ktFile: KtFile): Boolean {

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        ktFile.declarations.mapNotNullTo(mutableSetOf()) { (it as? KtCallableDeclaration)?.nameAsName }
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        ktFile.declarations.mapNotNullTo(mutableSetOf()) { (it as? KtClassLikeDeclaration)?.nameAsName }
    }

        }
    }
}

@OptIn(KtAnalysisNonPublicApi::class)
fun List<KtFile>.collectReachableInlineDelegatedPropertyAccessors(): List<KtFile> {
    if (isEmpty()) return this

    val allFiles = mutableSetOf<KtFile>()
    allFiles.addAll(this)
    allFiles.collectReachableInlineDelegatedPropertyAccessors()
    return allFiles.toList()
}

internal class InlineDelegatedPropertyAccessorsAnalyzer(