declarationRenderer: KaDeclarationRenderer,
            printer: PrettyPrinter,
        ) {
            declarationRenderer.callableSignatureRenderer
                .renderCallableSignature(analysisSession, symbol, KtTokens.CONSTRUCTOR_KEYWORD, declarationRenderer, printer)

            declarationRenderer.functionLikeBodyRenderer.renderBody(analysisSession, symbol, printer)
        }
    }

            is KaAnnotation -> renderAnnotationApplication(value, printer)
            is KaAnnotationList -> renderAnnotationsList(value, printer)
            is KtModule -> renderKtModule(value, printer)
            // Other custom values
            is Name -> printer.append(value.asString())
            is FqName -> printer.append(value.asString())
            is ClassId -> printer.append(value.asString())

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.lexer.KtTokens

public interface KaNamedClassOrObjectSymbolRenderer {
    public fun renderSymbol(
        analysisSession: KaSession,
        symbol: KaNamedClassOrObjectSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

					t.Errorf("%s: compare(%v,%v)=%d; expect %d", v0.Type(), v0, v1, c, expect)
				}
			}
		}
	}
}

type sortTest struct {
	data  any    // Always a map.
	print string // Printed result using our custom printer.
}

var sortTests = []sortTest{
	{
		map[int]string{7: "bar", -3: "foo"},
		"-3:foo 7:bar",
	},
	{
		map[uint8]string{7: "bar", 3: "foo"},
		"3:foo 7:bar",
	},
	{

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull

public interface KaPropertyAccessorsRenderer {
    public fun renderAccessors(
        analysisSession: KaSession,
        symbol: KaPropertySymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

            qualifiers: List<KaClassTypeQualifier>,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                printCollection(qualifiers, separator = ".") { qualifier ->
                    qualifier.render(analysisSession, type, typeRenderer, printer)
                }
            }
        }
    }

            analysisSession: KaSession,
            type: KaErrorType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            type.presentableText?.let {
                printer.append(it)
                return
            }
            printer.append("ERROR")
        }
    }

    public object AS_ERROR_WORD : KaErrorTypeRenderer {
        override fun renderType(

		In: `package main

import "go/printer"

func f() printer.Config {
	b := printer.Config{0, 8}
	c := &printer.Config{0}
	d := &printer.Config{Tabwidth: 8, Mode: 0}
	return printer.Config{0, 8}
}
`,
		Out: `package main

import "go/printer"

func f() printer.Config {
	b := printer.Config{Mode: 0, Tabwidth: 8}
	c := &printer.Config{Mode: 0}
	d := &printer.Config{Tabwidth: 8, Mode: 0}

                            if (it is KaFunctionalType) printer.append("(")
                            typeRenderer.renderType(analysisSession, it, printer)
                            if (it is KaFunctionalType) printer.append(")")
                            printer.append('.')
                        }
                        printCollection(type.parameterTypes, prefix = "(", postfix = ")") {

            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                when (projection) {
                    is KaStarTypeProjection -> printer.append('*')
                    is KaTypeArgumentWithVariance -> {
                        " ".separated(
                            { printer.append(projection.variance.label) },