A modern programming language that makes developers happier.

kotlinlang

image.png

If I do a guard first, then compiler is not enforcing exhaustiveness on `when` . Is that a bug?

```override fun onHandleDeeplink(result: DeeplinkResult) {
    val deeplink = result.deeplink
    if (deeplink !is SubscriberRootDeeplink) return

    when (deeplink) {
        is SubscriberRootDeeplink.SmartId -> {
            ...
        }
        ...
    }
}```

<https://youtrack.jetbrains.com/issue/KT-8781/Consider-making-smart-casts-smart-enough-to-handle-exhaustive-value-sets>

I believe that's <https://kotlinlang.org/docs/whatsnew2220.html#data-flow-based-exhaustiveness-checks-for-when-expressions|this> actually.

Marat is right.
It works by default since 2.3: <https://pl.kotl.in/ZUEa1EecZ>

but what's supposed to work? should my code not compile?

It's hard to judge your case without seeing the `DeeplinkResult` hierarchy.

```fun UserRootDeeplinkHandler.onHandleDeeplink(result: DeeplinkResult) {
    val deeplink = result.deeplink
    if (deeplink !is UserRootDeeplink) return

    when (deeplink) {
        is UserRootDeeplink.SmartId -> ...
        is MultiRootDeeplink.ResolveRemotely -> ...
    }
}


data class DeeplinkResult(val deeplink: Deeplink, val rawDeeplink: Url)

sealed interface Deeplink

sealed interface LoggedOutRootDeeplink : Deeplink {
    data class Login(val code: OAuthCode, val deeplinkToReplay: Url?) : LoggedOutRootDeeplink
}

sealed interface UserRootDeeplink : Deeplink {
    data class SmartId(val code: OAuthCode) : UserRootDeeplink
}

sealed interface OnboardingRootDeeplink : Deeplink

sealed interface MultiRootDeeplink : Deeplink {
    data class ResolveRemotely(
        val urlToResolve: Url
    ) : MultiRootDeeplink, LoggedOutRootDeeplink, UserRootDeeplink, OnboardingRootDeeplink
}```
okay I normalized it a bit

the idea is to have typed deeplinks based on root they belong to so they won't mix on accident - but certain deeplinks can be applied everywhere, so such types extend all of the root interfaces they need to

and then in each handler I have to filter away cases it's not interested in

and if I add

```data class ResolveRemotely2(
        val urlToResolve: Url
    ) : MultiRootDeeplink, LoggedOutRootDeeplink, UserRootDeeplink, OnboardingRootDeeplink```
then I'd expect the `when` in the snippet to blow up due to not being exhaustive, but it does not

right, but add new multiroot deeplink type

if I just extract the `when` into a function, it goes red right away (sorry for different types, it's my domain, in the snippet I generalized it for simplicity)

btw now I'm noticing, if I add `data class SmartId2(val code: OAuthCode) : UserRootDeeplink` then it complains about exhaustiveness

so it's the `MultiRootDeeplink` that confuses it

There is actually an issue, which was fixed quite recently: <https://youtrack.jetbrains.com/issue/KT-87189|KT-87189>.
The fix will be delivered in 2.5.0.

I checked, your code (correctly) fails to compile using recent dev version of the compiler.