*   s2.length // explicit receiver `s2` has `isSafeNavigation = false`
     * }
     * ```
     */
    public val isSafeNavigation: Boolean by validityAsserted(isSafeNavigation)

    override val type: KaType by validityAsserted(type)
}

/**
 * An implicit receiver. For example
 * ```
 * class A {
 *   val i: Int = 1
 *   fun test() {
 *     i // implicit receiver bound to class `A`
 *   }
 * }
 *

    /**
     * Whether this function call is an implicit invoke call on a value that has an `invoke` member function. See
     * https://kotlinlang.org/docs/operator-overloading.html#invoke-operator for more details.
     */
    public val isImplicitInvoke: Boolean by validityAsserted(isImplicitInvoke)
}

/**

public class KaTypeArgumentWithVariance(
    type: KaType,
    variance: Variance,
    override val token: KaLifetimeToken,
) : KaTypeProjection() {
    override val type: KaType by validityAsserted(type)
    public val variance: Variance by validityAsserted(variance)

        kind: Kind,
        operand: KtExpression,
    ) : KaCompoundAccess(operationPartiallyAppliedSymbol) {
        public val kind: Kind by validityAsserted(kind)
        public val operand: KtExpression by validityAsserted(operand)

        public enum class Kind {
            PLUS_ASSIGN, MINUS_ASSIGN, TIMES_ASSIGN, DIV_ASSIGN, REM_ASSIGN
        }

    }

    /**

        override val typeArguments: List<KaTypeProjection> by validityAsserted(typeArguments)
    }

    public class KaUnresolvedClassTypeQualifier(
        name: Name,
        typeArguments: List<KaTypeProjection>,
        override val token: KaLifetimeToken
    ) : KaClassTypeQualifier {
        override val name: Name by validityAsserted(name)

    candidateCalls: List<KaCall>,
    diagnostic: KaDiagnostic,
    override val token: KaLifetimeToken,
) : KaCallInfo() {
    public val candidateCalls: List<KaCall> by validityAsserted(candidateCalls)
    public val diagnostic: KaDiagnostic by validityAsserted(diagnostic)
}

public val KaCallInfo.calls: List<KaCall>
    get() = when (this) {
        is KaErrorCallInfo -> candidateCalls
        is KaSuccessCallInfo -> listOf(call)

import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeOwner
import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken
import org.jetbrains.kotlin.analysis.api.lifetime.validityAsserted
import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion

/**
 * A candidate considered for a call. I.e., one of the overload candidates in scope at the call site.
 */

        public val classId: ClassId by validityAsserted(classId)
    }

    public class BySymbol(symbol: KaClassLikeSymbol, override val token: KaLifetimeToken) : KaClassTypeBuilder() {
        public val symbol: KaClassLikeSymbol by validityAsserted(symbol)
    }
}

public typealias KtClassTypeBuilder = KaClassTypeBuilder

     */
    public val dispatchReceiver: KaReceiverValue? by validityAsserted(dispatchReceiver)

    /**
     * The extension receiver for this symbol access. Extension receiver is available if the symbol is declared with an extension receiver.
     */
    public val extensionReceiver: KaReceiverValue? by validityAsserted(extensionReceiver)
}

import com.intellij.psi.PsiTypeParameter
import org.jetbrains.kotlin.analysis.api.fir.KaFirSession
import org.jetbrains.kotlin.analysis.api.fir.utils.cached
import org.jetbrains.kotlin.analysis.api.lifetime.validityAsserted
import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.analysis.api.symbols.KaSymbolOrigin
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol