A modern programming language that makes developers happier.

kotlinlang

Anyone know why this doesn’t work
```val nullableFoo: Any? = null
val nonNullFoo = nullableFoo != null
if (nonNullFoo) {
   acceptsNonNullFoo(nullableFoo) // expected Any but is Any?
}```
but this works
```val nullableFoo: Any? = null
if (nullableFoo != null) {
   acceptsNonNullFoo(nullableFoo)
}```
:thinking_face:

The compiler doesn't analyze the program to this extent (as far as flow analysis is concerned), so it doesn't link the null check on `nonNullFoo` boolean variable to the fact that `nullableFoo` is not null when considering the `if` statement. In the second snippet, it is able to detect that because it's a direct null check on that variable, so smart casting can work.

I see. In actual `nonNullFoo` boolean has more conditions, but `nullableFoo != null` seems should be true 100% of the time.
Any tips how to handle this in code? It feels weird to have to do
```if (nonNullFoo &amp;&amp; nullableFoo != null)```
 again

^ that bit me in the a$$ too quickly. I removed `nonNullFoo` and got a crash because I forgot about the `!!` :smile:

have you looked at contracts? <https://www.baeldung.com/kotlin/contracts>
You can write a custom 'validate not null' method, which the compiler will understand

```@ExperimentalContracts
private fun validate(request: Request?) {
    contract {
        returns() implies (request != null)
    }
    if (request == null) {
        throw IllegalArgumentException("Undefined request")
    }
    if (request.arg.isBlank()) {
        throw IllegalArgumentException("No argument is provided")
    }
}```
