appendLine()
                        visitValue(value, indent + 1)
                    }
                    if (documentNode.content.isNotEmpty()) {
                        appendLine()
                        documentNode.content.forEach { visitDocumentNode(it, indent + 1) }
                    } else {
                        appendLine()
                    }
                }

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

        }

        val actualDebug = prettyPrint {
            appendLine("Inital from ${declarationModule.moduleDescription}:")
            appendLine(debugRendered)
            appendLine()
            appendLine("Restored in ${restoreAtModule.moduleDescription}:")
            appendLine(debugRenderedRestored ?: NOT_RESTORED)
        }

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

                appendLine("Expression: ${expression.text}")
                appendLine("${KaType::class.simpleName}: ${type.render(position = Variance.INVARIANT)}")
                appendLine()
                appendLine("${KaTypeScope::class.simpleName}:")
                appendLine(typeScope?.let { renderForTests(it) } ?: "NO_SCOPE")
                appendLine()

                appendLine("Declaration Scope:")

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

        logger.warn("Appending implementation to build cache key: {}",
            beforeExecutionState.getImplementation());
        beforeExecutionState.getImplementation().appendToHasher(cacheKeyHasher);

        beforeExecutionState.getAdditionalImplementations().forEach(additionalImplementation -> {
            logger.warn("Appending additional implementation to build cache key: {}",

                    debugPrinter.appendLine(debugRenderer.render(analysisSession, symbol))
                    debugPrinter.appendLine()

                    prettyPrinter.withIndents(indentCount = declaration.parentsOfType<KtDeclaration>(withSelf = false).count()) {
                        prettyPrinter.appendLine(symbol.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))

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