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 {

    /**
     * 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
     */

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,

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.symbols.markers.KaNamedSymbol
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.renderer.render

public interface KaConstructorSymbolRenderer {
    public fun renderSymbol(
        analysisSession: KaSession,
        symbol: KaConstructorSymbol,
        declarationRenderer: KaDeclarationRenderer,

func (m *Map[K, V]) InOrder() *Iterator[K, V] {
	sender, receiver := chans_Ranger[keyValue[K, V]]()
	var f func(*node[K, V]) bool
	f = func(n *node[K, V]) bool {
		if n == nil {
			return true
		}
		// Stop sending values if sender.Send returns false,
		// meaning that nothing is listening at the receiver end.
		return f(n.left) &&
			sender.Send(keyValue[K, V]{n.key, n.val}) &&
			f(n.right)
	}
	go func() {

                appendLine("${KaType::class.simpleName}: ${type.render(position = Variance.INVARIANT)}")
                appendLine("substitutor.substitute: ${substituted.render(position = Variance.INVARIANT)}")
                appendLine("substitutor.substituteOrNull: ${substitutedOrNull?.render(position = Variance.INVARIANT)}")
            }
        }

                    { declarationRenderer.annotationRenderer.renderAnnotations(analysisSession, symbol, printer) },
                    {
                        // do not render (val a: Int, val b: Int), render `(a: Int, b: Int)` instead
                        val rendererWithoutValVar = declarationRenderer.with {
                            keywordsRenderer = keywordsRenderer.with {

                            .sortedBy { it.render() }
                    }
                }
            }
        }

        val actual = executeOnPooledThreadInReadAction {
            buildString {
                mainFile.declarations.forEach { declaration ->
                    analyseForTest(declaration) {
                        append(declaration.getSymbol().render(renderer))
                        appendLine()

    def "render introduction without type"() {
        given:
        def data = DefaultTypeValidationData.builder()
            .typeName("foo")
            .propertyName("bar")
            .build()

        expect:
        DefaultTypeAwareProblemBuilder.introductionFor(Optional.of(data), true) == "Property 'bar' "
    }

    def "render introduction with type"() {
        given: