isinstance(instance, SubClass) loses generic type instead of narrowing

[marcin-serwin]

Describe the bug
When performing an isinstance check on object with generic type, the type information of variable type is lost.

To Reproduce
Standard pyright configuration with strict mode enabled.

# pyright: strict
from typing import Generic, TypeVar

T = TypeVar("T")


class A(Generic[T]):
    pass


class B(A[T]):
    pass


def f(a: A[T]) -> B[T]:
    assert isinstance(a, B)
    return a

Expected behavior
No errors. After assert type of a is B[T].

Actual behavior
17:12 - error: Return type, "B[Unknown]", is partially unknown
After assert type of a is B[Unknown]

[erictraut]

This is the correct behavior. The assert statement validates that a is of type B, but there is not type argument specified. PEP 484 indicates that when type arguments to a generic class are omitted, the type checker should assume Any. Pyright uses a special form of Any that it calls Unknown so it can track cases where types are omitted. Since you have indicated strict typing mode, Pyright is reporting that you have a partially-unknown type.

If you change your code as follows, it should work as you expect:

    assert isinstance(a, B[T])

[marcin-serwin]

If we change the last lines to:

def f(a: A[T]) -> B[T]:
    assert isinstance(a, B[T])
    return a

f(B())

the code will produce TypeError at runtime:

TypeError: Subscripted generics cannot be used with class and instance checks

As per documentation this construction is not valid Python code since isinstance should not be used with types.

[marcin-serwin]

Also, if this helps, I think this is the analogous bug in MyPy: python/mypy#949

[erictraut]

Yes, you are correct. My proposed workaround unfortunately won't work.

It might seem straightforward to simply assume that isinstance(a, B) implies that a is narrowed to type B[T], but this is an unsafe assumption. Consider the following class hierarchy:

class A(Generic[T]):
    pass


class B(A[str], Generic[T]):
    pass

Let's assume in this case that a value of type A[str] is passed to f. There's no way for the type checker to determine that it's of type B[str] after the assert statement. The only safe assumption at this point is that it's type B[Unknown]. That is consistent with mypy's behavior (although mypy doesn't have the notion of "unknown" or a strict mode, so it uses B[Any] in this case).

Here are some additional workarounds (none of which are very elegant):

1. Use a cast operator:

def f(a: A[T]) -> B[T]:
    assert isinstance(a, B)
    b = cast(B[T], a)
    return b

2. Suppress the warning using a # type: ignore comment.

def f(a: A[T]) -> B[T]:
    assert isinstance(a, B)
    return a  # type: ignore

3. Disable the reportUnknownVariableType diagnostic rule for this file.

# pyright: strict, reportUnkownVariableType=false

[marcin-serwin]

Thanks for the clarification. On a related note I think it would be nice if pyright warned about the usage of isinstance(a, B[T]) and such as erroneous code.

[erictraut]

That's a good suggestion.

[erictraut]

Your suggestion is now implemented in Pyright 1.1.52, which I just published. It will be included in the next published version of Pylance.