prettyPrint {
                appendLine("${KtDeclaration::class.simpleName}: ${declaration::class.simpleName}")

                appendLine("Symbol:")
                appendLine(symbol.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))

                appendLine()

                appendLine("Substitutor:")
                appendLine(stringRepresentation(substitutor))

                appendLine()

            buildString {
                appendLine("${KtAnnotationEntry::class.simpleName}: ${annotationEntry.text}")
                appendLine()
                appendLine("Resolved annotation symbol:")
                appendLine(annotationClassSymbol.render(KtDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))
                appendLine()
                appendLine("Applicable targets: $applicableTargetsInOrder")
            }

            with(printer) {
                appendLine("implicit receivers:")

                withIndent {
                    for (implicitReceiver in scopeContext.implicitReceivers) {
                        val type = implicitReceiver.type
                        appendLine("type: ${renderType(type, printPretty)}")
                        append("owner symbol: ").appendLine(implicitReceiver.ownerSymbol::class.simpleName)

        analysisSession: KaSession,
        annotations: KaAnnotationList,
        currentMetaAnnotations: Set<ClassId>?,
        indent: Int
    ) {
        appendLine("annotations: [".indented(indent))
        for (annotation in annotations) {
            appendLine(DebugSymbolRenderer().renderAnnotationApplication(analysisSession, annotation).indented(indent = indent + 2))
            if (currentMetaAnnotations != null) {

            appendLine()
            appendSummaryHeader(cacheActionText, problemCount)
            appendLine()
            Ordering.from(consoleComparator()).leastOf(uniqueProblems, maxConsoleProblems).forEach { problem ->
                append("- ")
                append(problem.userCodeLocation.capitalized())
                append(": ")
                appendLine(problem.message)

        writer.run {
            appendLine("""<script type="text/javascript">""")
            appendLine("function configurationCacheProblems() { return (")
            appendLine("// begin-report-data")
        }
    }

    private
    fun endReportData() {
        writer.run {
            appendLine()
            appendLine("// end-report-data")
            appendLine(");}")
            appendLine("</script>")

                expression.evaluate()
            }
        }
        val actual = buildString {
            appendLine("expression: ${expression.text}")
            appendLine("constant: ${constantValue?.renderAsKotlinConstant() ?: "NOT_EVALUATED"}")
            appendLine("constantValueKind: ${constantValue?.constantValueKind ?: "NOT_EVALUATED"}")
        }

            .map { getSessionKtModule(it).toString() }
            .distinct()
            .sorted()

        val actualText = buildString {
            appendLine("Module names of invalidated sessions:")
            invalidatedModuleDescriptions.forEach { appendLine(it) }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(
            actualText,

                            append(renderFrontendIndependentKClassNameOf(contextTestCase.element))
                            appendLine(':')
                            withIndent {
                                append(output)
                            }
                        } else {
                            append(output)

            val classId = ClassId.fromString(classIdString)
            val renderer = DebugSymbolRenderer()
            fun renderAnnotation(application: KaAnnotation): String = buildString {
                appendLine("${KtDeclaration::class.simpleName}: ${ktDeclaration::class.simpleName} ${ktDeclaration.name}")
                append(renderer.renderAnnotationApplication(analysisSession, application))
            }