token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.Unsupported

internal class UnsupportedFeatureImpl(
    override val unsupportedFeature: Pair<LanguageFeature, LanguageVersionSettings>,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnsupportedFeature

        }

    fun getResolvedToPsi(analysisSession: KtAnalysisSession): Collection<PsiElement> =
        with(analysisSession) {
            getResolvedToPsi(analysisSession, resolveToSymbols())
        }

    override val resolver get() = KtFirReferenceResolver
}

internal fun KtAnalysisSession.getPsiDeclarations(symbol: KtFirSymbol<*>): Collection<PsiElement> {
    val intersectionOverriddenSymbolsOrSingle = when {

    else -> null
}

fun FirElement.findPsi(): PsiElement? =
    getAllowedPsi()

fun FirBasedSymbol<*>.findPsi(): PsiElement? {
    return if (this is FirCallableSymbol<*>) {
        fir.unwrapFakeOverridesOrDelegated().findPsi()
    } else {
        fir.findPsi()
    } ?: FirSyntheticFunctionInterfaceSourceProvider.findPsi(fir)
}

/**
 * Finds [PsiElement] which will be used as go-to referenced element for [KtPsiReference]

package org.jetbrains.kotlin.analysis.api.fir.diagnostics

import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
import org.jetbrains.kotlin.diagnostics.*

internal class KtCompilerPluginDiagnostic0Impl(
    firDiagnostic: KtPsiSimpleDiagnostic,
    token: KtLifetimeToken
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtCompilerPluginDiagnostic0

 */

package org.jetbrains.kotlin.analysis.api.fir.diagnostics

import com.intellij.psi.PsiElement

interface KtCompilerPluginDiagnostic0 : KtFirDiagnostic<PsiElement> {
    override val diagnosticClass
        get() = KtCompilerPluginDiagnostic0::class
}

interface KtCompilerPluginDiagnostic1 : KtFirDiagnostic<PsiElement> {
    val parameter1: Any?

    override val diagnosticClass

    }

    private fun getExpectedTypeByTypeCast(expression: PsiElement): KtType? {
        val typeCastExpression =
            expression.unwrapQualified<KtBinaryExpressionWithTypeRHS> { castExpr, expr -> castExpr.left == expr } ?: return null
        return getKtExpressionType(typeCastExpression)
    }

    private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? {

                ?: ""
        }

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

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

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

    fun findPsi(fir: FirDeclaration): PsiElement? {
        return when (fir) {
            is FirSimpleFunction -> provideSourceForInvokeFunction(fir)
            is FirClass -> provideSourceForFunctionClass(fir)
            else -> null
        }
    }

    private fun provideSourceForInvokeFunction(function: FirSimpleFunction): PsiElement? {

     */
    private fun isUsed(psiElement: PsiElement): Boolean {
        return when (psiElement) {
            /**
             * DECLARATIONS
             */
            // Inner PSI of KtLambdaExpressions. Used if the containing KtLambdaExpression is.
            is KtFunctionLiteral ->
                doesParentUseChild(psiElement.parent, psiElement)

 * DO NOT MODIFY IT MANUALLY
 */

sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
    interface Unsupported : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = Unsupported::class
        val unsupported: String
    }

    interface UnsupportedFeature : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = UnsupportedFeature::class