case *md.Code:
		return in.Text
	default:
		return ""
	}
}

// symbolLink converts s into a Link and returns it and true, or nil and false if
// s is not a valid link or is surrounded by runes that disqualify it from being
// converted to a link.
//
// The argument s is the text between '[' and ']'.
func symbolLink(s, defaultPackage string) (md.Inline, bool) {
	pkg, sym, ok := splitRef(s)
	if !ok {

}

public typealias KtFunctionLikeSymbol = KaFunctionLikeSymbol

public abstract class KaAnonymousFunctionSymbol : KaFunctionLikeSymbol() {
    final override val symbolKind: KaSymbolKind get() = withValidityAssertion { KaSymbolKind.LOCAL }
    final override val callableId: CallableId? get() = withValidityAssertion { null }

    final override val typeParameters: List<KaTypeParameterSymbol>

    override fun createPointer(): KaSymbolPointer<KaTypeAliasSymbol> = withValidityAssertion {
        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaTypeAliasSymbol>(this)?.let { return it }

        when (val symbolKind = symbolKind) {
            KaSymbolKind.LOCAL ->
                throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(classId?.asString() ?: name.asString())

        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaNamedClassOrObjectSymbol>(this)?.let { return it }

        return when (val symbolKind = symbolKind) {
            KaSymbolKind.LOCAL ->
                throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(classId?.asString() ?: name.asString())

    final override val name: Name get() = withValidityAssertion { fieldName }
    final override val psi: PsiElement? get() = withValidityAssertion { null }
    final override val symbolKind: KaSymbolKind get() = withValidityAssertion { KaSymbolKind.LOCAL }
    override val origin: KaSymbolOrigin get() = withValidityAssertion { KaSymbolOrigin.PROPERTY_BACKING_FIELD }

 */

package org.jetbrains.kotlin.analysis.api.symbols.markers

import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol


public interface KaSymbolWithKind : KaSymbol {
    public val symbolKind: KaSymbolKind
}

public typealias KtSymbolWithKind = KaSymbolWithKind

public enum class KaSymbolKind {
    TOP_LEVEL,
    CLASS_MEMBER,
    LOCAL,
    ACCESSOR,
    SAM_CONSTRUCTOR,
}

    override val isExpect: Boolean get() = withValidityAssertion { firSymbol.isExpect }

    override val callableId: CallableId? get() = withValidityAssertion { firSymbol.getCallableId() }

    override val symbolKind: KaSymbolKind
        get() = withValidityAssertion {
            when {
                firSymbol.origin == FirDeclarationOrigin.DynamicScope -> KaSymbolKind.CLASS_MEMBER
                firSymbol.isLocal -> KaSymbolKind.LOCAL

    public abstract val isDefault: Boolean
    public abstract val isInline: Boolean
    public abstract val isOverride: Boolean
    public abstract val hasBody: Boolean

    final override val symbolKind: KaSymbolKind get() = withValidityAssertion { KaSymbolKind.ACCESSOR }

    abstract override fun createPointer(): KaSymbolPointer<KaPropertyAccessorSymbol>
}

    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }
    override val initializer: KaInitializerValue? by cached { firSymbol.getKtConstantInitializer(builder) }

    override val symbolKind: KaSymbolKind
        get() = withValidityAssertion {
            if (firSymbol.origin == FirDeclarationOrigin.DynamicScope) {
                return@withValidityAssertion KaSymbolKind.CLASS_MEMBER
            }

        additionalSymbolInfo: KaSession.(KaSymbol) -> String?,
    ) {
        fun <T : KaSymbol> List<T>.renderAll(
            symbolKind: String,
            renderPrettySymbol: KaSession.(T) -> String,
        ) = with(printer) {
            appendLine("$symbolKind: $size")
            withIndent {
                forEach {
                    appendLine(
                        if (printPretty) {