symbol: KaDeclarationSymbol,
            declarationModifiersRenderer: KaDeclarationModifiersRenderer,
        ): List<KtModifierKeywordToken> {
            return buildList {
                if (symbol is KaSymbolWithVisibility) {
                    declarationModifiersRenderer.visibilityProvider.getVisibilityModifier(analysisSession, symbol)?.let(::add)
                }

                if (symbol is KaSymbolWithModality) {

//
// The default output prints one line per symbol, with three space-separated
// fields giving the address (in hexadecimal), type (a character), and name of
// the symbol. The types are:
//
//	T	text (code) segment symbol
//	t	static text segment symbol
//	R	read-only data segment symbol
//	r	static read-only data segment symbol
//	D	data segment symbol
//	d	static data segment symbol
//	B	bss segment symbol

		{"TEXT", "", "expect two or three operands for TEXT"},
		{"TEXT", "%", "expect two or three operands for TEXT"},
		{"TEXT", "1, 1", "TEXT symbol \"<erroneous symbol>\" must be a symbol(SB)"},
		{"TEXT", "$\"foo\", 0, $1", "TEXT symbol \"<erroneous symbol>\" must be a symbol(SB)"},
		{"TEXT", "$0É:0, 0, $1", "expected end of operand, found É"}, // Issue #12467.
		{"TEXT", "$:0:(SB, 0, $1", "expected '(', found 0"},          // Issue 12468.

                classSymbol.toLookupTag()
            }
            is KaClassTypeBuilder.BySymbol -> {
                val symbol = builder.symbol
                check(symbol is KaFirSymbol<*>)
                (symbol.firSymbol as FirClassLikeSymbol<*>).toLookupTag()
            }
        }

        val typeContext = rootModuleSession.typeContext

}

abstract class AbstractCombinedDeclaredMemberScopeTest : AbstractMemberScopeTestBase() {
    override fun KaSession.getScope(symbol: KaSymbolWithMembers): KaScope = symbol.getCombinedDeclaredMemberScope()
}

abstract class AbstractDelegateMemberScopeTest : AbstractMemberScopeTestBase() {

        }
    }

    public object NO_IMPLICIT_VISIBILITY : KaRendererVisibilityModifierProvider {
        override fun getVisibilityModifier(
            analysisSession: KaSession,
            symbol: KaSymbolWithVisibility,
        ): KtModifierKeywordToken? {
            with(analysisSession) {
                when (symbol) {

                    { declarationRenderer.modifiersRenderer.renderDeclarationModifiers(analysisSession, symbol, printer) },
                    { declarationRenderer.nameRenderer.renderName(analysisSession, symbol,declarationRenderer, printer) },
                    {
                        if (symbol.upperBounds.isNotEmpty()) {
                            withPrefix(": ") {

            printer {
                val mutabilityKeyword = if (symbol.isVal) KtTokens.VAL_KEYWORD else KtTokens.VAR_KEYWORD
                declarationRenderer.callableSignatureRenderer
                    .renderCallableSignature(session, symbol, mutabilityKeyword, declarationRenderer, printer)

                declarationRenderer.variableInitializerRenderer.renderInitializer(session, symbol, printer)
            }
        }
    }
}

        ) {
            val mutabilityKeyword = if (symbol.isVal) KtTokens.VAL_KEYWORD else KtTokens.VAR_KEYWORD
            declarationRenderer.callableSignatureRenderer
                .renderCallableSignature(analysisSession, symbol, mutabilityKeyword, declarationRenderer, printer)

            declarationRenderer.variableInitializerRenderer.renderInitializer(analysisSession, symbol, printer)
        }
    }
}

    public open fun <S : KaCallableSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaCallableSignature<S> = when (symbol) {
        is KaFunctionLikeSymbol -> substitute(symbol, substitutor)
        is KaVariableLikeSymbol -> substitute(symbol, substitutor)
        else -> unexpectedElementError("symbol", symbol)
    }

    public abstract fun <S : KaFunctionLikeSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaFunctionLikeSignature<S>