Kotlin smart cast with nullable variable

Question

When I'm trying to create the following code:

class SmartCast {
    var array: MutableList<Int>? = null

    fun processArray() {
        if (array != null && !array.isEmpty()) {
            // process
        }
    }
}

this error is shown:

Smart cast to 'MutableList' is impossible, because 'array' is a mutable property that could have been changed by this time

It's clear that the array variable can be changed to null in case of multi-threading. But if I use @Synchronized annotation, there is no way to mutate the variable in between array != null and !array.isEmpty().

@Synchronized
fun processArray() {

I'm wonder, why the compiler doesn't allow smart cast in synchronized blocks or maybe it's possible to specify somehow that my application is designed only for single-threaded mode?

UPDATE: According to the answers, I changed the code in the following way:

fun processArray() {
    array?.takeUnless { it.isEmpty() }?.also {
        for (elem in it)
            // process elements
    }
}

Instead of `also { for(elem in it) ... }` you could directly use `forEach { ... }`. — tynn, Jun 16 '18 at 08:51

score 6 · Answer 1 · answered Jun 16 '18 at 07:01

6

Save the list to a local variable, and use that local variable. An elegant way to do that is to use the let function, and to combine it with the null-safe operator:

array?.let { 
    if (!it.isEmpty()) {
        // process it
    }
}

This is described in the idioms section of the getting started guide, BTW.

answered Jun 16 '18 at 07:01

JB Nizet

678,734
91
1,224
1,255

thx. so there are just alternate idiomatic ways of doing what I want – Maxim Jun 16 '18 at 07:11
doesn't it better to use `also {}` in this case as the one returns `Void`? – Maxim Jun 16 '18 at 07:26
also doesn't return Void (which is named Unit in Kotlin). It returns `this`, i.e. the array. – JB Nizet Jun 16 '18 at 07:30

score 6 · Accepted Answer · answered Jun 16 '18 at 10:24

why the compiler doesn't allow smart cast in synchronized blocks

Because this

But if I use @Synchronized annotation, there is no way to mutate the variable in between array != null and !array.isEmpty().

is wrong. @Synchronized means this method can't be called by two threads at the same time, but another thread which has access to the same instance is perfectly free to reassign array.

You also need to mark the setter as @Synchronized, in which case it really can't be changed at the moment. But trying to figure out exactly when smart casts are safe would lead to very complex rules, and minor changes in one method suddenly breaking smart casts in others. So the rules are conservative instead.

score 1 · Answer 3 · edited Jul 03 '23 at 23:54

1

Kotlin 1.3 introduced a function for that:

fun <T> Collection<T>?.isNullOrEmpty(): Boolean

So,

class SmartCast {
    var array: MutableList<Int>? = null

    fun processArray() {
        
        if(!array.isNullOrEmpty()){
            // processs
        }
    }
}

will compile.

edited Jul 03 '23 at 23:54

kikon

3,670
3
5
20

answered Dec 29 '18 at 22:20

Willi Mentzel

27,862
20
113
121

Kotlin smart cast with nullable variable

3 Answers3

Linked