Why does Smartcast not work after nullcheck

Question

I'm attempting advent of code and wanted to create a class for day 10. I know that the values can be null, so I declared them as nullable. At some point, I need to check whether the value is assigned and do something with it. There comes the issue. I check beforehand via high != null, but in the line that follows, I have to use !! to convince the compiler that it actually is null.

It seems that it can't find the proper compareTo method, despite nullchecking it first. I guess, it didn't smartcast my variable

private class Bot(val number: Int, var low: Int?, var high: Int?) {

  fun acceptValue(value: Int) {
    if (low == null && high == null) {
      high = value
    } else {
      if (high != null) {
        if (high!! > value) { //it doesn't compile, because appareantly, high is still not considered nonnull at this point
          low = value
        } else {
          low = high
          high = value
        }
      }
    }
  }
}

the kotlin-version is use is 1.1.3-2

Is that a bug? Am I doing something wrong?

score 8 · Answer 1 · edited Jun 20 '20 at 09:12

Since you defind high as a var, it is mutable. You cannot guarantee the variable is not null even if you have an explicit null check before that.

Official explanation:

Note that smart casts do not work when the compiler cannot guarantee that the variable cannot change between the check and the usage. More specifically, smart casts are applicable according to the following rules:

val local variables - always;

val properties - if the property is private or internal or the check is performed in the same module where the property is declared. Smart casts aren't applicable to open properties or properties that have custom getters;

var local variables - if the variable is not modified between the check and the usage and is not captured in a lambda that modifies it;

var properties - never (because the variable can be modified at any time by other code).

In you case, you can use .let:

high?.let {
    if (it > value) {
        low = value
    } else {
      low = it
      high = value
    }
} ?: run {
    //high == null
}

Suggested reading: In Kotlin, what is the idiomatic way to deal with nullable values, referencing or converting them

sadly, let is not applicable to this scenario, since I need the else block aswell — TormundThunderfist, Aug 11 '17 at 09:11
I have updated my answer. You can handle it by using the Elvis operator `?:` and `run`. — BakaWaii, Aug 11 '17 at 09:27

score 3 · Accepted Answer · answered Aug 10 '17 at 08:19

3

Between high != null and high > value another thread could do high = null, invalidating the null check. So this is the expected behavior.

The way to solve this is to use a temporary variable which cannot be externally changed:

val cHigh = high
if (cHigh != null) {
    if (cHigh > value) {
        ....

answered Aug 10 '17 at 08:19

Kiskae

24,655
2
77
74

imho a better way would be using `let` (but it's essentially the same). – Lovis Aug 10 '17 at 08:30
1

gonna have to go with this one, since let is not applicable in my scenario – TormundThunderfist Aug 11 '17 at 09:12

score 1 · Answer 3 · answered Aug 11 '17 at 07:48

1

You can solve this issue if you declare the propertiries private:

private class Bot(val number: Int, 
                  private var low: Int?, 
                  private var high: Int?) {

    ...
}

answered Aug 11 '17 at 07:48

voddan

31,956
8
77
87

For those who voted down this answer: I presented a technically correct solution. If you think that this is a bad design choice - well, it is not much worse than having a public mutable nullable property :P – voddan Aug 12 '17 at 15:44

Why does Smartcast not work after nullcheck

3 Answers3

Linked

Related