*   NORTH, SOUTH, WEST, EAST
     * }
     * foo = when(direction) {
     *   Direction.NORTH -> 1
     *   Direction.SOUTH -> 2
     *   else -> 3
     * }
     *
     * If when-expression has no subject, then else-branch would be reported as missing even if it is explicitly present:
     *
     * fun test() {
     *     when {
     *         true -> {}
     *         else -> {}
     *     }
     * }
     *

                if (whenExpression != null) {
                    val subject = whenExpression.subjectExpression ?: return with(analysisSession) { builtinTypes.boolean }
                    val kotlinType = analysisContext.analyze(subject).getType(subject)
                    return kotlinType?.toKtNonErrorType(analysisContext)
                }
            }

            // Parentheses are ignored for this analysis.
            is KtParenthesizedExpression ->
                doesParentUseChild(parent.parent, parent)

            // When expressions use the subject expression _unless_ the first branch in the
            // when is an `else`.
            is KtWhenExpression ->
                parent.subjectExpression == child && parent.entries.firstOrNull()?.isElse == false

        val whenExpression = (condition.parent as? KtWhenEntry)?.parent as? KtWhenExpression ?: return null
        val subject = whenExpression.subjectExpression ?: return with(analysisSession) { builtinTypes.boolean }
        return getKtExpressionNonErrorType(subject)
    }

    private fun getKtExpressionNonErrorType(expression: KtExpression): KaType? =
        getKtExpressionType(expression)?.nonErrorTypeOrNull()

) : KaAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KaFirDiagnostic.TypeVarianceConflictInExpandedType

internal class SmartcastImpossibleImpl(
    override val desiredType: KaType,
    override val subject: KtExpression,
    override val description: String,
    override val isCastToNotNull: Boolean,
    firDiagnostic: KtPsiDiagnostic,
    token: KaLifetimeToken,

            is FirWhenSubjectExpression ->
                // The subject variable is not processed here as we don't have KtExpression to represent it.
                // K1 creates a fake expression in this case.
                whenRef.value.subject?.findSourceKtExpressionForCallArgument()
            // FirBlock is a fake container for desugared expressions like `++index` or `++list[0]`

        val desiredType: KaType
        val subject: KtExpression
        val description: String
        val isCastToNotNull: Boolean
    }

    interface SmartcastImpossibleOnImplicitInvokeReceiver : KaFirDiagnostic<KtExpression> {
        override val diagnosticClass get() = SmartcastImpossibleOnImplicitInvokeReceiver::class
        val desiredType: KaType
        val subject: KtExpression
        val description: String

    public final static field INSTANCE: MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$1
    static method <clinit>(): void
    method <init>(): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

final class MainKt$ArticleScreenContent$2 {

    public object ALL : KaRendererBodyMemberScopeProvider {
        override fun getMemberScope(analysisSession: KaSession, symbol: KaSymbolWithMembers): List<KaDeclarationSymbol> {
            with(analysisSession) {
                return symbol.getCombinedDeclaredMemberScope().getAllSymbols().toList()
            }
        }
    }

    public object ALL_DECLARED : KaRendererBodyMemberScopeProvider {

        val self = this
        return object : KaRendererModalityModifierProvider {
            override fun getModalityModifier(analysisSession: KaSession, symbol: KaSymbolWithModality): KtModifierKeywordToken? =
                if (condition(analysisSession, symbol)) self.getModalityModifier(analysisSession, symbol)
                else null
        }
    }

    public object WITH_IMPLICIT_MODALITY : KaRendererModalityModifierProvider {