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

            val firDiagnosticRenderer = RootDiagnosticRendererFactory(diagnostic)
            return firDiagnosticRenderer.render(diagnostic)
        }

    override val textRanges: Collection<TextRange>
        get() = withValidityAssertion { firDiagnostic.textRanges }

    @Suppress("UNCHECKED_CAST")
    override val psi: PSI
        get() = withValidityAssertion { firDiagnostic.psiElement as PSI }

    override val severity: KaSeverity

                    this += "default settings" to collectPossibleReferenceShortenings(mainFile, mainFile.textRange)

                    this += ShortenStrategy.entries.associateWith { option ->
                        val shorteningsForOption = collectPossibleReferenceShortenings(
                            mainFile,
                            mainFile.textRange,
                            classShortenStrategy = { option },

    private fun findStatements(mainFile: KtFile, textRange: TextRange): List<KtExpression> {
        var candidate = PsiTreeUtil.findElementOfClassAtOffset(mainFile, textRange.startOffset, KtExpression::class.java, true)
            ?: error("Cannot find a starting element in range $textRange")

        while (true) {
            val parent = candidate.parent

public interface KaDiagnosticWithPsi<out PSI : PsiElement> : KaDiagnostic {
    public override val diagnosticClass: KClass<out KaDiagnosticWithPsi<PSI>>

    public val psi: PSI
    public val textRanges: Collection<TextRange>
}

public typealias KtDiagnosticWithPsi<PSI> = KaDiagnosticWithPsi<PSI>

public fun KaDiagnostic.getDefaultMessageWithFactoryName(): String {
    return "[$factoryName] $defaultMessage"

                ?: ""
        }

    override val psi: PsiElement
        get() = withValidityAssertion { diagnostic.psiElement }

    override val textRanges: Collection<TextRange>
        get() = withValidityAssertion { diagnostic.textRanges }

    override val diagnosticClass: KClass<out KaDiagnosticWithPsi<PsiElement>>
        get() = withValidityAssertion { KaFe10Diagnostic::class }

 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

package org.jetbrains.kotlin.analysis.api.descriptors.components

import com.intellij.openapi.util.TextRange
import com.intellij.psi.SmartPointerManager
import com.intellij.psi.SmartPsiElementPointer
import org.jetbrains.kotlin.analysis.api.components.*
import org.jetbrains.kotlin.analysis.api.descriptors.KaFe10Session

        val expression = testServices.expressionMarkerProvider.getSelectedElementOfType<KtExpression>(mainFile).let {
            if (it is KtBlockExpression && it.statements.size == 1 && it.textRange == it.statements.single().textRange) {
                it.statements.single()
            } else {
                it
            }
        }
        val actual = StringBuilder()

        analyseForTest(expression) {

     * Also see [org.jetbrains.kotlin.idea.base.analysis.api.utils.shortenReferences] and functions around it.
     */
    public fun collectPossibleReferenceShortenings(
        file: KtFile,
        selection: TextRange = file.textRange,
        shortenOptions: ShortenOptions = ShortenOptions.DEFAULT,
        classShortenStrategy: (KaClassLikeSymbol) -> ShortenStrategy = defaultClassShortenStrategy,

        val selected = testServices.expressionMarkerProvider.getSelectedElementOfTypeByDirective(mainFile, mainModule).let {
            if (it is KtBlockExpression && it.statements.size == 1 && it.textRange == it.statements.single().textRange) {
                it.statements.single()
            } else {
                it
            }
        }
        val expression = when (selected) {
            is KtExpression -> selected