internal class KaFe10FunctionalType(
    override val fe10Type: SimpleType,
    private val descriptor: FunctionClassDescriptor,
    override val analysisContext: Fe10AnalysisContext
) : KaFunctionalType(), KaFe10Type {
    override val nullability: KaTypeNullability
        get() = withValidityAssertion { fe10Type.ktNullability }

    override val abbreviatedType: KaUsualClassType?

internal class KaFirDynamicType(
    override val coneType: ConeDynamicType,
    private val builder: KaSymbolByFirBuilder,
) : KaDynamicType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token
    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

    override fun getImplicitReceiverTypesAtPosition(position: KtElement): List<KaType> {
        val ktFile = position.containingKtFile
        val firFile = ktFile.getOrBuildFirFile(firResolveSession)

        val fileSession = firFile.llFirSession
        val sessionHolder = SessionHolderImpl(fileSession, fileSession.getScopeSession())

        val context = ContextCollector.process(firFile, sessionHolder, position)

internal class KaFe10DescPropertySetterSymbol(
    override val descriptor: PropertySetterDescriptor,
    override val analysisContext: Fe10AnalysisContext
) : KaPropertySetterSymbol(), KaFe10DescMemberSymbol<PropertySetterDescriptor> {
    override val returnType: KaType
        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtType(analysisContext) }

    override val isDefault: Boolean

internal interface KaFirSessionComponent {
    val analysisSession: KaFirSession

    val project: Project get() = analysisSession.project
    val rootModuleSession: FirSession get() = analysisSession.firResolveSession.useSiteFirSession
    val typeContext: ConeInferenceContext get() = rootModuleSession.typeContext
    val firSymbolBuilder get() = analysisSession.firSymbolBuilder
    val firResolveSession get() = analysisSession.firResolveSession

import org.jetbrains.kotlin.fir.types.renderForDebugging

internal class KaFirClassErrorType(
    override val coneType: ConeClassLikeType,
    private val coneDiagnostic: ConeDiagnostic,
    private val builder: KaSymbolByFirBuilder,
) : KaClassErrorType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token

    override val qualifiers: List<KaClassTypeQualifier> by cached {
        when (coneDiagnostic) {

    private val firDiagnostic: KtPsiDiagnostic,
    override val token: KaLifetimeToken,
) : KaDiagnosticWithPsi<PSI>, KaLifetimeOwner {

    override val factoryName: String
        get() = withValidityAssertion { firDiagnostic.factory.name }

    override val defaultMessage: String
        get() = withValidityAssertion {
            val diagnostic = firDiagnostic as KtDiagnostic

import org.jetbrains.kotlin.resolve.BindingContext

internal class KaFe10PsiConstructorSymbol(
    override val psi: KtConstructor<*>,
    override val analysisContext: Fe10AnalysisContext
) : KaConstructorSymbol(), KaFe10PsiSymbol<KtConstructor<*>, ConstructorDescriptor> {
    override val descriptor: ConstructorDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)

import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis

internal class KaFirSmartcastProvider(
    override val analysisSession: KaFirSession,
    override val token: KaLifetimeToken,
) : KaSmartCastProvider(), KaFirSessionComponent {

    private val KtExpression.isExplicitSmartCastInfoTarget: Boolean
        get() {
            // we want to handle only most top-level parenthesised expressions

internal class KaFirBackingFieldSymbol(
    override val firSymbol: FirBackingFieldSymbol,
    override val analysisSession: KaFirSession,
) : KaBackingFieldSymbol(), KaFirSymbol<FirBackingFieldSymbol> {
    override val origin: KaSymbolOrigin get() = withValidityAssertion { super<KaBackingFieldSymbol>.origin }

    override val annotations: KaAnnotationList
        get() = withValidityAssertion {