*   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)
}

/**

        receiverCastRequired: Boolean,
        override val token: KaLifetimeToken
    ) : Applicable() {
        override val substitutor: KaSubstitutor by validityAsserted(substitutor)
        override val receiverCastRequired: Boolean by validityAsserted(receiverCastRequired)
    }

    public class ApplicableAsFunctionalVariableCall(
        substitutor: KaSubstitutor,
        receiverCastRequired: Boolean,

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)

import org.jetbrains.kotlin.analysis.api.lifetime.validityAsserted
import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.name.Name

@KaAnalysisApiInternals
class KaContextReceiverImpl(
    type: KaType,
    label: Name?,
    override val token: KaLifetimeToken
) : KaContextReceiver() {
    override val label: Name? by validityAsserted(label)
    override val type: KaType by validityAsserted(type)

    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)

    type: KaType,
    ownerSymbol: KaSymbol,
    scopeIndexInTower: Int
) : KaLifetimeOwner {
    public val ownerSymbol: KaSymbol by validityAsserted(ownerSymbol)
    public val type: KaType by validityAsserted(type)
    public val scopeIndexInTower: Int by validityAsserted(scopeIndexInTower)
}

public typealias KtImplicitReceiver = KaImplicitReceiver

public sealed class KaScopeKind {
    /**

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.
 */