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>")

                it
            }
        }
        val actual = StringBuilder()

        analyseForTest(expression) {
            actual.appendLine("expression: $expression")
            actual.appendLine("text: ${expression.text}")
            actual.appendLine("isUsedAsExpression: ${expression.isUsedAsExpression()}")
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual.toString())
    }

                    appendLine("$indentString  text ranges: $textRanges")
                    appendLine("$indentString  PSI: ${psi::class.simpleName} at ${psi.textRange.asLineColumnRange()}")
                }
                appendLine("Diagnostics from elements:")
                for ((element, diagnostic) in diagnosticsFromElements) {

    fun StringBuilder.renderShorteningResults(shortening: ShortenCommand) {
        if (shortening.isEmpty) {
            appendLine("EMPTY_SHORTENINGS")
            return
        }

        shortening.listOfTypeToShortenInfo.forEach { (userType, shortenedRef) ->
            userType.element?.text?.let {
                appendLine("[type] $it${shortenedRef?.let { ref -> " -> $ref" } ?: ""}")
            }
        }

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

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

                appendLine()

                appendLine("Signature:")
                appendLine(stringRepresentation(signature))
            }
        }

                is StageFailure.NoSchemaAvailable -> appendLine("No associated schema for ${stageFailure.scriptContext}")
                is StageFailure.AssignmentErrors -> {
                    appendLine("Failures in assignments:".indent(1))
                    stageFailure.usages.forEach { unassigned ->

            val type = getType(analysisSession, mainFile, mainModule, testServices)

            buildString {
                appendLine(DebugSymbolRenderer(renderTypeByProperties = true).renderType(analysisSession, type))

                appendLine()
                appendLine("Rendered type:")
                appendLine(type.render(position = Variance.INVARIANT))
            }
        }

            analyseForTest(expression) {
                val smartCastInfo = expression.getSmartCastInfo()
                buildString {
                    appendLine("expression: ${expression.text}")
                    appendLine("isStable: ${smartCastInfo?.isStable}")
                    appendLine("smartCastType: ${smartCastInfo?.smartCastType?.render(position = Variance.INVARIANT)}")

    if (endWithNewLine) printer.appendLine(renderedValue) else printer.append(renderedValue)
}

internal data class Context(val session: KaSession, val printer: PrettyPrinter, val symbolRenderer: DebugSymbolRenderer)

private fun PrettyPrinter.appendHeader(clazz: KClass<*>, body: PrettyPrinter.() -> Unit) {
    append(clazz.simpleName)
    appendLine(":")
    withIndent { body() }
}