import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin

interface KtFirReference : KtReference, KtSymbolBasedReference {
    fun getResolvedToPsi(analysisSession: KtAnalysisSession, referenceTargetSymbols: Collection<KtSymbol>): Collection<PsiElement> =
        with(analysisSession) {

import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.types.TypeCheckerState
import org.jetbrains.kotlin.types.model.convertVariance

internal interface KtFirAnalysisSessionComponent {
    val analysisSession: KtFirAnalysisSession

    val project: Project get() = analysisSession.project

/*
 * This file was generated automatically
 * 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> {

            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.DELEGATION_IN_INTERFACE) { firDiagnostic ->
        DelegationInInterfaceImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.DELEGATION_NOT_TO_INTERFACE) { firDiagnostic ->
        DelegationNotToInterfaceImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,

    <extensionPoint
        qualifiedName="org.jetbrains.kotlin.declarationAttributeAltererExtension"
        interface="org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension"
        area="IDEA_PROJECT"
    />

    <extensionPoint
        qualifiedName="org.jetbrains.kotlin.syntheticScopeProviderExtension"
        interface="org.jetbrains.kotlin.synthetic.SyntheticScopeProviderExtension"
        area="IDEA_PROJECT"
    />

        return null
    }

    /**
     * Use-site substitution override happens in situations like this:
     *
     * ```
     * interface List<A> { fun get(i: Int): A }
     *
     * fun take(list: List<String>) {
     *   list.get(10) // this call
     * }
     * ```
     *

import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.UnwrappedType

internal interface KtFe10Type : KtLifetimeOwner, KtAnnotated {
    val fe10Type: UnwrappedType

    val analysisContext: Fe10AnalysisContext

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {

                    psi.isObjectLiteral() -> KtClassKind.ANONYMOUS_OBJECT
                    else -> KtClassKind.OBJECT
                }
                is KtClass -> when {
                    psi.isInterface() -> KtClassKind.INTERFACE
                    psi.isEnum() -> KtClassKind.ENUM_CLASS
                    psi.isAnnotation() -> KtClassKind.ANNOTATION_CLASS
                    else -> KtClassKind.CLASS
                }

            // Technically we should use JvmDefaultMode.ALL_INCOMPATIBLE because Kapt4 always uses `-Xjvm-default=all`, but it would make
            // the majority of tests fail because metadata of each interface will have a flag set, compared to Kapt3.
            jvmDefaultMode = JvmDefaultMode.DISABLE,
            stringTable,
            null,
            null
        )

}

/**
 * Helper abstraction to navigate through qualified FIR elements - we have to match [ClassId] and PSI qualifier pair
 * to correctly reason about long qualifiers.
 */
private sealed interface TypeQualifier {
    val referencedClassId: ClassId

    /**
     * Type can be imported with alias, and thus can be referenced by the name different from its actual name.
     *