}


fun prettyPrintLanguageResult(languageResult: LanguageResult<*>, startDepth: Int = 0): String {
    fun StringBuilder.recurse(current: LanguageResult<*>, depth: Int) {
        fun indent() = "    ".repeat(depth)
        fun nextIndent() = "    ".repeat(depth + 1)
        fun appendIndented(value: Any) {
            append(indent())
            append(value)
        }
        fun appendNextIndented(value: Any) {
            append(nextIndent())

    require(lineNumber >= 1) { "Line numbers are 1-based" }
    return fragment(identifier, body, prefix = String(repeat('\n', lineNumber - 1)))
}


private
fun repeat(char: Char, times: Int) =
    CharArray(times).also { fill(it, char) }


internal
fun fragment(identifier: String, body: String, prefix: String = ""): ProgramSourceFragment {

                kotlin.kclass.get
                kotlin.configure
                """.trimIndent()
            )
        )

        // Deprecation warnings assertion
        repeat(5) {
            executer.expectDocumentedDeprecationWarning(
                "The org.gradle.api.plugins.Convention type has been deprecated. " +
                    "This is scheduled to be removed in Gradle 9.0. " +

internal
class ParserDebugger<T>(val parserBuilder: () -> Parser<T>) {

    companion object {
        var level = 0

        fun <T> debug(name: String, parser: Parser<T>): Parser<T> = {
            val levelString = "\t".repeat(level)
            println("${levelString}Parsing with $name @ ${this.currentPosition.offset} ...")
            level++
            val result = parser()
            level--

                    override fun execute() {
                        URL("${server.uri("blockStart")}").readText()
                        repeat($repeatOutput) {
                            Thread.sleep(25)
                            println("STDOUT from concurrent task ${'$'}it")
                            System.err.println("STDERR from concurrent task ${'$'}it")

                "api"("other:thing") {
                    version { strictly("1.0") }
                }
            }
        }

        inOrder(constraintHandler) {
            repeat(3) {
                verify(constraintHandler).add(eq("api"), eq("some:thing:1.0"))
                verify(constraintHandler).add(eq("api"), eq("other:thing"), any())
            }
            verifyNoMoreInteractions()

            errorAt(location, error.message)
        } ?: error.message

    private
    fun errorAt(location: CompilerMessageSourceLocation, message: String): String {
        val columnIndent = " ".repeat(5 + maxLineNumberStringLength + 1 + location.column)
        return "Line ${lineNumber(location)}: ${location.lineContent}\n" +
            "^ $message".lines().joinToString(
                prefix = columnIndent,

    if (value.arrayDimensions > 0) {
        val arrayDescriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(StandardClassIds.Array)
            ?: return null

        repeat(value.arrayDimensions) {
            type = TypeUtils.substituteParameters(arrayDescriptor, listOf(type))
        }

        classId = StandardClassIds.Array
    }

     */
    private fun KaSession.goToNthParent(symbol: KaDeclarationSymbol, steps: Int): KaDeclarationSymbol? {
        var currentSymbol = symbol

        repeat(steps) {
            currentSymbol = currentSymbol.getContainingSymbol() as? KaClassOrObjectSymbol ?: return null
        }

        return currentSymbol
    }

    private fun KaSession.resolveKdocFqName(

        val classifiersToSkip = expression.parents.takeWhile { it != ktTypeElementFromFirType }.count()
        var classifier: FirClassLikeSymbol<*>? = fir.type.toRegularClassSymbol(session)
        repeat(classifiersToSkip) {
            classifier = classifier?.getContainingClassSymbol(session)
        }

        val firClassSymbol = classifier