}

    override val isLateInit: Boolean
        get() = withValidityAssertion { descriptor.isLateInit }

    override val isConst: Boolean
        get() = withValidityAssertion { descriptor.isConst }

    override val isVal: Boolean
        get() = withValidityAssertion { !descriptor.isVar }

    override val isExtension: Boolean
        get() = withValidityAssertion { descriptor.isExtension }

import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
import org.jetbrains.kotlin.resolve.DescriptorEquivalenceForOverrides

internal fun KtFe10Symbol.isEqualTo(other: Any?): Boolean {
    if (this === other) return true
    if (other !is KtFe10Symbol) return false
    return DescriptorEquivalenceForOverrides.areEquivalent(
        this.getDescriptor(),
        other.getDescriptor(),

        firScope.getCallableNames()
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        firScope.getClassifierNames()
    }

    override fun mayContainName(name: Name): Boolean = withValidityAssertion {
        name in getAllPossibleNames()
    }

        val property = with(analysisSession) { propertySymbolPointer.restoreSymbol() }
        return property?.backingFieldSymbol
    }

    override fun pointsToTheSameSymbolAs(other: KtSymbolPointer<KtSymbol>): Boolean = this === other ||
            other is KtFe10PsiDefaultBackingFieldSymbolPointer &&
            other.propertySymbolPointer.pointsToTheSameSymbolAs(propertySymbolPointer)

import org.jetbrains.kotlin.utils.SmartPrinter
import kotlin.reflect.KClass
import kotlin.reflect.KType

internal fun SmartPrinter.printTypeWithShortNames(type: KType, shouldRenderFqName: (KType) -> Boolean = { false }) {
    fun typeConversion(type: KType): String {
        val nullableSuffix = if (type.isMarkedNullable) "?" else ""
        val simpleName = if (shouldRenderFqName(type)) {
            type.qualifiedName

    override val isDefault: Boolean
        get() = withValidityAssertion { true }

    override val isInline: Boolean
        get() = withValidityAssertion { propertyPsi.hasModifier(KtTokens.OVERRIDE_KEYWORD) }

    override val isOverride: Boolean
        get() = withValidityAssertion { propertyPsi.hasModifier(KtTokens.OVERRIDE_KEYWORD) }

    override val hasBody: Boolean
        get() = withValidityAssertion { false }

  }

  @Test
  @TestMetadata("boolean_else.kt")
  public void testBoolean_else() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_else.kt");
  }

  @Test
  @TestMetadata("boolean_empty.kt")
  public void testBoolean_empty() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_empty.kt");
  }

  @Test

        throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(this::class)
    }

    override fun equals(other: Any?): Boolean = symbolEquals(other)
    override fun hashCode(): Int = symbolHashCode()

            symbol,
            substitutor.substitute(returnType),
            receiverType?.let { substitutor.substitute(it) },
        )
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as KtFe10VariableLikeSignature<*>

        if (backingSymbol != other.backingSymbol) return false

    override fun canBeNull(type: KtType): Boolean {
        require(type is KtFe10Type)
        return TypeUtils.isNullableType(type.fe10Type)
    }

    override fun isDenotable(type: KtType): Boolean {
        require(type is KtFe10Type)
        val kotlinType = type.fe10Type
        return kotlinType.isDenotable()
    }

    override fun isArrayOrPrimitiveArray(type: KtType): Boolean {
        require(type is KtFe10Type)