Unexpected behavior regarding variable that can contain instance of base class or subclass

[jrheard-seesaw]

Code sample in pyright playground

# pyright: strict

class BaseClass:
    pass

class SubClass(BaseClass):
    pass

foo = SubClass()

def fn(bar: BaseClass) -> None:
    baz: BaseClass = foo or bar
    reveal_type(baz)

    if isinstance(baz, SubClass):
        print("hello")

In the example above, reveal_type(baz) gives Type of "baz" is "SubClass", and on the isinstance line, pyright reports Unnecessary isinstance call; "SubClass" is always an instance of "SubClass" (reportUnnecessaryIsInstance).

I find this confusing, because when I see baz = foo or bar, I think "baz can be an instance of SubClass or an instance of BaseClass", and since BaseClass is more general, I'd expect baz to have type BaseClass. I'd expect that behavior by default even without the type annotation on the line defining baz (I'm also a little surprised that the type annotation on that line doesn't seem to do anything).

I'm trying to enable reportUnnecessaryIsInstance in a codebase I'm working on, and encountered this behavior in some preexisting code, and I'm not sure what to do about it. If pyright is behaving as expected, can you help me understand why baz should indeed have type SubClass instead of BaseClass? Thank you!

[jrheard-seesaw]

I think I figured it out - foo is truthy, and pyright knows that foo or bar will always evaluate to foo, which is an instance of SubClass. Whoops!

I think that the issue in my specific situation is that (in the version of the code I'm actually working on) foo can actually be SubClass | None in practice, and is mis-annotated as being SubClass because we don't have very many pyright checks set up yet. Updating its annotation to SubClass | None resolves the reportUnnecessaryIsInstance error :)