appendLine("PSI: ${ktElement?.getDescription()} [from ${containingVirtualFile?.name}]")
        if (ktElement == null || containingVirtualFile == null) {
            return@prettyPrint
        }

        withIndent {
            val isResolveExtensionFile = containingVirtualFile.isResolveExtensionFile
            appendLine("From resolve extension: $isResolveExtensionFile")

                    fun List<KaType>.print(name: String) {
                        appendLine(name)
                        for (type in this) {
                            appendLine(type.render(KaTypeRendererForDebug.WITH_QUALIFIED_NAMES, position = Variance.INVARIANT))
                        }
                        appendLine()
                    }
                    directSuperTypes.print("[direct super types]")

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

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

                    expectedSymbol.psi?.containingFile?.name + " : " + expectedSymbol.render(renderer)
                }
            }
        }

        val actual = buildString {
            appendLine("expected symbols:")
            appendLine(expectedSymbolText)
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

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

                        appendLine(declaration.getNameWithPositionString())
                    } else {
                        analyseForTest(declaration) {
                            val returnType = declaration.getReturnKaType()
                            append(declaration.getNameWithPositionString())
                            append(" : ")
                            appendLine(returnType.render(position = Variance.INVARIANT))

                                appendLine("asPsiType(allowErrorTypes=$allowErrorTypes, mode=$typeMappingMode, isAnnotationMethod=$isAnnotationMethod):")
                                withIndent {
                                    appendLine("PsiType: ${AnalysisApiPsiTypeProviderTestUtils.render(psiType)}")
                                }
                                appendLine()
                            }

                mainFile.declarations.forEach { declaration ->
                    analyseForTest(declaration) {
                        append(declaration.getSymbol().render(renderer))
                        appendLine()
                        appendLine()
                    }
                }
            }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual, extension = ".rendered")
    }

        val actual = analyseForTest(mainFile) {
            val ktType = TypeParser.parseTypeFromString(typeString, mainFile, mainFile)
            buildString {
                appendLine("OriginalTypeString: $typeString")
                appendLine(
                    "${KaType::class.simpleName}: ${
                        ktType.render(
                            renderer = KaTypeRendererForDebug.WITH_QUALIFIED_NAMES,