}
        }
    }

    private fun isValidInheritor(
        candidate: KtClassOrObject,
        baseFirClass: FirClass,
        scope: GlobalSearchScope,
        includeLocalInheritors: Boolean,
    ): Boolean {
        if (!includeLocalInheritors && candidate.isLocal) {
            return false
        }

        if (!scope.contains(candidate)) {
            return false
        }

fun test(b: Boolean) {
    run {
        5
        <expr>5</expr>
    }

fun test(b: Boolean = <expr>true</expr>): Int {
    return 54

fun test(b: Boolean) {
    when(<expr>b</expr>) {
        true -> 5
        else -> {}
    }

fun test(b: Boolean) {
    when(b) {
        true -> <expr>5</expr>
        else -> 0
    }

fun test(b: Boolean) {
    while (true) {
        if (b) {
            break
        } else {
            <expr>continue</expr>
        }
    }

fun test(b: Boolean) {
    val x = when(b) {
        true -> <expr>5</expr>
        else -> 0
    }

                    }
                }
            }
        }

        private fun isNullabilityFlexibleType(lower: KaType, upper: KaType): Boolean {
            val isTheSameType = lower is KaNonErrorClassType && upper is KaNonErrorClassType && lower.classId == upper.classId ||

 * ```
 *   "".length // explicit receiver `""`
 * ```
 */
public class KaExplicitReceiverValue(
    expression: KtExpression,
    type: KaType,
    isSafeNavigation: Boolean,
    override val token: KaLifetimeToken,
) : KaReceiverValue() {
    public val expression: KtExpression by validityAsserted(expression)

    /**
     * Whether safe navigation is used on this receiver. For example

    public abstract fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase>
    public abstract fun isUsedAsExpression(expression: KtExpression): Boolean
}

public typealias KtExpressionInfoProvider = KaExpressionInfoProvider

public interface KaExpressionInfoProviderMixIn : KaSessionMixIn {
    public fun KtReturnExpression.getReturnTargetSymbol(): KaCallableSymbol? =