Kotlin Condition is always true if val used

Question

If I used a variable to check for boolean, the "!isNumber" is highlighted with the warning "Condition '!isNumber' is always true":

    val isNumber = bind.number.isChecked


     when (array) {
         "A" -> {
             if (isNumber) {
                 return "number"
             } else if (!isNumber) {
                 return "letter"
             }
        }

However if I used the view directly to check for boolean, there is no warning:

        when (acArray) {
            "A" -> {
                if (bind.number.isChecked) {
                 return "number"
                } else if (!bind.number.isChecked) {
                 return "letter"
                }
        }

Where do u have `val isNumber = bind.number.isChecked` exactly? can u add whole code block with question — ADM, Oct 26 '22 at 11:31
@SarthakMittal because there are multiple variables being checked in each `if` separated by `&&`, sorry for not being clear. However `z.y` already answered it. Thanks anyways. — Kellin Strook, Oct 26 '22 at 11:55
@KellinStrook no worries, m glad to know that u got your fixed :) — Sarthak Mittal, Oct 26 '22 at 20:29

z.g.y · Accepted Answer · 2022-10-27T01:06:15.930

Your if is already checking for the true value of isNumber, you don't need to explicitly check isNumber in else block if its false, because the opposite of true is false that's why you get that warning.

Imagine the compiler talking to you:

Compiler:

Don't tell my else to check if its false because my if block is already checking if its true, let my if do the heavy lifting and leave my else to just wake up when isNumber becomes false, no need to remind my poor else, leave him be...

Edit: Sample scenarios below, class vs local vs top level file scope

Both classLevelScope and localLevelScope will give you a warning.

class MyClass {

    val classLevelScope = false

    fun function() {

        if (classLevelScope) {

        } else if (!classLevelScope) { // you'll get a warning here

        }
    }
}


class MyClass {

    fun function() {

        val localScope = false

        if (localScope) {

        } else if (!localScope) { // you'll get a warning here

        }
    }
}

But a Top level file scope will not

var isChecked = false // top level file scope, inside MyClass.kt

class MyClass {

    fun function() {

        if (isChecked) {

        } else if (!isChecked) { // No warning here

        }
    }
}

My assumption for the top level scoped variable is that the compiler cannot determine who would change its value in what thread, class, instance of a class or from any other place because a top level scoped variable can be accessed anywhere unlike the classLevelScope or the localLevelScope which are only accessible outside using their enclosing scope. Your bind.number.isChecked might be a top level scoped variable.

If the warning bothers you, you can remove it from your A.S settings

Inspections -> Kotlin -> Probable bugs -> Constant Condition -> Uncheck the box

Thanks and sorry for the dumb question. I got confused because my second code block does not give the same error. — Kellin Strook, Oct 26 '22 at 11:56

score 1 · Answer 2 · answered Oct 26 '22 at 11:33

That because if the isNumber != true than it always will be false edit your code to be like this:

 when (array) {
         "A" -> {
             if (isNumber) {
                 return "number"
             } else {
                 return "letter"
             }
        }

score 1 · Answer 3 · answered Oct 26 '22 at 12:01

It doesn’t give you a warning in the second case because the two branches are not necessarily mutually exclusive when the value isn’t coming from a local variable. It’s possible some other thread changes the value in between the if check and the else-if check. Or it’s possible the property in the other class is set up to return a different value on each subsequent call— the compiler doesn’t check to rule out the possibility of that behavior for classes outside the module.

In the first case, you have copied the Boolean value to a local variable so the compiler can easily see that it’s impossible for the value to change right before the else-if.

Kotlin Condition is always true if val used

3 Answers3