import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.renderer.render

public interface KaClassTypeQualifierRenderer {
    public fun renderClassTypeQualifier(
        analysisSession: KaSession,
        type: KaType,
        qualifiers: List<KaClassTypeQualifier>,

        analyseForTest(mainFile) {
            val ktScopeContext = mainFile.getImportingScopeContext()

            val scopeContextStringRepresentation = render(ktScopeContext, renderDefaultImportingScope)
            val scopeContextStringRepresentationPretty = render(ktScopeContext, renderDefaultImportingScope, printPretty = true)

            testServices.assertions.assertEqualsToTestDataFileSibling(scopeContextStringRepresentation)

import org.jetbrains.kotlin.analysis.api.renderer.base.annotations.KaAnnotationRenderer
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.renderer.render

public interface KaAnnotationQualifierRenderer {
    public fun renderQualifier(
        analysisSession: KaSession,
        annotation: KaAnnotation,
        owner: KaAnnotated,

            Triple(DebugSymbolRenderer().render(analysisSession, symbol), symbol.render(defaultRenderer), pointer)
        }
        configurator.doGlobalModuleStateModification(project)

        val (debugRenderedRestored, prettyRenderedRestored) = analyseForTest(restoreAt) {
            val symbol = pointer.restoreSymbol() as? KaDeclarationSymbol

import org.jetbrains.kotlin.analysis.api.types.KaStarTypeProjection
import org.jetbrains.kotlin.analysis.api.types.KaTypeArgumentWithVariance
import org.jetbrains.kotlin.renderer.render

internal object KaAnnotationValueRenderer {
    fun render(value: KaAnnotationValue): String = buildString {
        renderConstantValue(value)
    }

    private fun StringBuilder.renderConstantValue(value: KaAnnotationValue) {

            printer.printCollection(annotation.arguments, prefix = "(", postfix = ")") { argument ->
                append(argument.name.render())
                append(" = ")
                append(KaAnnotationValueRenderer.render(argument.expression))
            }
        }
    }
}

import org.jetbrains.kotlin.psi.KtParameter

public object TestPsiElementRenderer {
    public fun render(psiElement: PsiElement): String = when (psiElement) {
        is KtNamedFunction -> buildString {
            append("KtNamedFunction:")
            append(psiElement.name)
            append("(")
            psiElement.valueParameters.joinTo(this) { render(it) }
            append(")")
        }
        is KtParameter -> buildString {

import org.jetbrains.kotlin.analysis.api.renderer.base.contextReceivers.KaContextReceiversRenderer
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.renderer.render

public interface KaContextReceiverLabelRenderer {
    public fun renderLabel(
        analysisSession: KaSession,
        contextReceiver: KaContextReceiver,
        contextReceiversRenderer: KaContextReceiversRenderer,

import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.renderer.render

public interface KaTypeNameRenderer {
    public fun renderName(
        analysisSession: KaSession,
        name: Name,
        owner: KaType,
        typeRenderer: KaTypeRenderer,

    /**
     * Render symbol into the representable Kotlin string
     */
    public fun KaDeclarationSymbol.render(renderer: KaDeclarationRenderer = KaDeclarationRendererForSource.WITH_QUALIFIED_NAMES): String =
        withValidityAssertion { analysisSession.symbolDeclarationRendererProvider.renderDeclaration(this, renderer) }

    /**
     * Render kotlin type into the representable Kotlin type string
     */