false
            is KtTypeParameter ->
                false
            is KtLambdaExpression ->
                false
            is KtScriptInitializer ->
                false

            // The last expression of a block is considered used iff the block itself is used.
            is KtBlockExpression ->
                parent.statements.lastOrNull() == child && isUsed(parent)

    return when (this) {
        is KaFe10PsiSymbol<*, *> -> descriptor
        is KaFe10DescSymbol<*> -> descriptor
        is KaFe10DescSyntheticFieldSymbol -> descriptor
        is KaFe10PsiDefaultPropertyGetterSymbol -> descriptor
        is KaFe10PsiDefaultPropertySetterSymbol -> descriptor
        is KaFe10PsiDefaultSetterParameterSymbol -> descriptor
        is KaFe10DescDefaultPropertySetterSymbol -> null

        is KaSubstitutor -> "<complex substitutor>"
        is KaDiagnostic -> "$severity<$factoryName: $defaultMessage>"
        is KaType -> render()
        is Enum<*> -> name
        is Name -> asString()
        is CallableId -> toString()
        is KaCallableSignature<*> -> stringRepresentation(this)
        else -> buildString {
            val clazz = this@with::class

                is KaReceiverParameterSymbol -> true
                !is KaCallableSymbol -> return
                is KaAnonymousFunctionSymbol -> true
                is KaConstructorSymbol -> true
                is KaFunctionSymbol -> true
                is KaPropertyGetterSymbol -> annotation.useSiteTarget != AnnotationUseSiteTarget.PROPERTY_GETTER

            }
        }

        when (symbol) {
            is KaLocalVariableSymbol,
            is KaAnonymousFunctionSymbol,
            is KaAnonymousObjectSymbol,
            is KaDestructuringDeclarationSymbol -> {
                return getContainingDeclarationByPsi(symbol)
            }

            is KaClassInitializerSymbol -> {

  repositories are "really" offline, since offline mode is more of a behavior,
  and this will lead to counter-intuitive results. A different feature may exist
  unimplemented, which is to detect when the network is down and provide better
  feedback for that case. However, when offline mode is declared, nothing
  earmarked as remote should be accessed, regardless of whether it is actually
  a physically local resource.

        require(callableSymbol is KaFirSymbol<*>)
        if (callableSymbol is KaFirBackingFieldSymbol) return emptyList()
        if (callableSymbol is KaValueParameterSymbol) {
            return callableSymbol.getDirectlyOverriddenSymbols()
        }
        if (callableSymbol is KaCallableSymbol && callableSymbol.firSymbol is FirIntersectionCallableSymbol) {

            }
        }

        private fun isNullabilityFlexibleType(lower: KaType, upper: KaType): Boolean {
            val isTheSameType = lower is KaNonErrorClassType && upper is KaNonErrorClassType && lower.classId == upper.classId ||
                    lower is KaTypeParameterType && upper is KaTypeParameterType && lower.symbol == upper.symbol
            if (isTheSameType &&
                lower.nullability == KaTypeNullability.NON_NULLABLE

            }
            is KaContractReturnsContractEffectDeclaration -> {
                when (value) {
                    is KaContractReturnsNotNullEffectDeclaration, is KaContractReturnsSuccessfullyEffectDeclaration -> Unit
                    is KaContractReturnsSpecificValueEffectDeclaration ->

    /**
     * Returns true if the [candidate] is in the final set of candidates that the call is actually resolved to. There can be multiple
     * candidates if the call is ambiguous.
     */
    public val isInBestCandidates: Boolean by validityAsserted(isInBestCandidates)
}

public typealias KtCallCandidateInfo = KaCallCandidateInfo

/**