`isinstance` check in function call is not recognized in call-site scope

[wbadart]

Describe the bug
Hey team- sorry, I wasn't sure how best to phrase the title. Essentially, when I have a subclass that adds properties to a parent, an if isinstance(thing, Child): ... check makes pyright narrow the type and accept me accessing the extra properties in the body of the if. However, I've noticed that if the isinstance check happens inside a function call, pyright no longer recognizes that I should be able to access the extra properties.

To Reproduce

class Empty:
    def has_foo(self) -> bool:
        return isinstance(self, HasFoo)


class HasFoo(Empty):
    foo = None


def go(x: Empty) -> None:
    if isinstance(x, HasFoo):
        print(x.foo)  # ✅ 

    if x.has_foo():
        print(x.foo)  # ❌ Cannot access member "foo" for type "Empty"    Member "foo" is unknown

Expected behavior
I expected that abstracting the instance check into a function would not prevent the gained type information from propagating to the calling scope (that being said, I can imagine how this might be a can of worms; mypy exhibits the same behavior).

VS Code extension or command-line

$ ~/.local/share/nvim/mason/bin/pyright --version
pyright 1.1.280
$ nvim --version
NVIM v0.9.0-dev-1279-g26c653718-dirty
Build type: Release
LuaJIT 2.1.0-beta3
Features: +acl +iconv +tui

Additional context
Please let me know if this is the intended behavior! (And if so, would greatly appreciate any input on workarounds [if there is in fact anything to be done short of bringing isinstance back into the calling scope].)

I also wanted to ask a tangentially related question: would it be possible to implement some kind of narrowing with hasattr when the second argument is a Literal? I.e., making this implementation of go from above acceptable:

def go(x: Empty) -> None:
    if hasattr(x, "foo"):
        print(x.foo)  # ❌ Cannot access member "foo" for type "Empty"    Member "foo" is unknown

Many thanks!

[erictraut]

It's generally a bad design pattern for a parent class to have knowledge of its subclasses, so you might want to rethink your approach.

Type narrowing applies only within a function, so adding an isinstance check in a different function will not apply type narrowing to callers. You might be interested in the idea of a "user-defined type guard" as defined in PEP 647. Here's what that would look like:

from typing import TypeGuard


class Empty:
    ...

class HasFoo(Empty):
    foo = None

def has_foo(x: Empty) -> TypeGuard[HasFoo]:
    return isinstance(x, HasFoo)

def go(x: Empty) -> None:
    if has_foo(x):
        print(x.foo)

For more details about type narrowing, check out this documentation.

[wbadart]

Thanks for the info! I didn't know about TypeGuards before. Following your primary suggestion, I shuffled things around in the code I was working on to deal directly with the child class instead of a hacked up version of the parent.