Java – IntelliJ displays the “always true” prompt, but not “always false”

Therefore, I use IntelliJ idea to program in Java. I'm trying to use the keyword instanceof. My code looks like this in the end:

public class Main {

    public static void main(String args[])
    {
        One one = new One();
        One two = new Two();

        if (one instanceof Two) 
        {
            System.out.println(one);
        }

        if (two instanceof Two) 
        {
            System.out.println(one);
        }

    }
}

class One { }

class Two extends One { }

IntelliJ gave me two lines of hints "[...] is always true" in two instances, but for one instance, two IntelliJ did not give me a hint "[...] is always false" Who knows why?

Solution

Update: fixed in idea 2018.3

(Disclaimer: IntelliJ idea developers here are responsible for this function)

Short answer: because it is not implemented

When we track variables of actual type in data flow analysis, we use the model described by typeconstraint class It allows us to track two facts: 1) if the actual type of the variable is an instance of something, and 2) if the actual type of the variable is not an instance of something With these facts, we can infer real / always wrong examples in many cases

void test(Object foo) {
  if (foo instanceof String) {
    if (foo instanceof Integer) { 
      // always false: "instanceof String" fact is not compatible 
      // with "instanceof Integer"
    }
  }
}

or

void test(Object foo) {
  if (!(foo instanceof Number)) {
    if (foo instanceof Integer) { 
      // always false: "not instanceof Number" fact is not compatible 
      // with "instanceof Integer"
    }
  }
}

But for your case, this model is not enough We need to extend it to track the exact type of variable In your code, we track an instance of instanceof (which is compatible with both instances of instanceof), although we can know more precise type information from the new expression. One is one This is not commonly used, because in most cases (variables are method parameters, variables are returned from methods, variables are allocated from fields, array elements, cast expressions, etc.) we cannot know whether the type is accurate or subtype, so the current model is completely satisfactory I can only imagine two situations, of which only one fact tracking is useful: a new expression (as in your case) and a comparison like obj getClass()== Xyz. class.

I think it is a reasonable function to implement it I've thought about it, but other people besides me also care. I submitted an issue, so you can track it