}
        }
    }

    public object ALL_DECLARED : KaRendererBodyMemberScopeProvider {
        override fun getMemberScope(analysisSession: KaSession, symbol: KaSymbolWithMembers): List<KaDeclarationSymbol> {
            with(analysisSession) {
                return symbol.getCombinedDeclaredMemberScope().getAllSymbols()
                    .filter { member ->

        buildSet {
            subScopes.flatMapTo(this) { it.getPossibleClassifierNames() }
        }
    }

    override fun getAllSymbols(): Sequence<KaDeclarationSymbol> = withValidityAssertion {
        sequence {
            subScopes.forEach { yieldAll(it.getAllSymbols()) }
        }
    }

    override fun getCallableSymbols(nameFilter: KaScopeNameFilter): Sequence<KaCallableSymbol> = withValidityAssertion {

        val classSymbolUnderCaret = declarationUnderCaret.getSymbol() as KaClassLikeSymbol

        require(classSymbolUnderCaret is KaSymbolWithMembers)

        return SymbolsData(classSymbolUnderCaret.getMemberScope().getAllSymbols().toList())
    }

    override fun KaSession.renderSymbolForComparison(symbol: KaSymbol, directives: RegisteredDirectives): String {

    protected abstract fun KaSession.getScope(mainFile: KtFile, testServices: TestServices): KaScope

    protected open fun KaSession.getSymbolsFromScope(scope: KaScope): Sequence<KaDeclarationSymbol> = scope.getAllSymbols()

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        super.doTestByMainFile(mainFile, mainModule, testServices)

        analyseForTest(mainFile) {

        return emptySet()
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        return emptySet()
    }

    override fun getAllSymbols(): Sequence<KaDeclarationSymbol> = withValidityAssertion {
        return emptySequence()
    }

    override fun getCallableSymbols(nameFilter: KaScopeNameFilter): Sequence<KaCallableSymbol> = withValidityAssertion {

            prettyPrint {
                appendLine("Substitutor: ${stringRepresentation(substitutor)}")
                if (substitutor != null) {
                    val functions = superClassSymbol.getDeclaredMemberScope().getAllSymbols()
                        .filterIsInstance<KaFunctionSymbol>()
                        .toList()
                    if (functions.isNotEmpty()) {
                        appendLine("Substituted callables:")

import org.jetbrains.kotlin.name.Name


public interface KaScope : KaScopeLike {
    /**
     * Return a sequence of all [KaDeclarationSymbol] which current scope contain
     */
    public fun getAllSymbols(): Sequence<KaDeclarationSymbol> = withValidityAssertion {
        sequence {
            yieldAll(getCallableSymbols())
            yieldAll(getClassifierSymbols())
            yieldAll(getConstructors())
        }

        modifiersRenderer = modifiersRenderer.with {
            keywordsRenderer = keywordsRenderer.with { keywordFilter = KaRendererKeywordFilter.NONE }
        }
    }

    printCollection(scope.getAllSymbols().toList(), separator = "\n\n") { symbol ->
        val containingDeclaration = symbol.getContainingSymbol() as KaClassLikeSymbol
        append(symbol.render(renderer))
        append(" fromClass ")

                            is KaDeclarationSymbol -> symbol.render(prettyRenderer)
                            is KaFileSymbol -> prettyPrint {
                                printCollection(symbol.getFileScope().getAllSymbols().asIterable(), separator = "\n\n") {
                                    append(it.render(prettyRenderer))
                                }
                            }