Is this a type narrowing bug for callables?

[robert-bn]

Consider the following:

from typing import assert_type, Callable

def func1(x: object):
    if x is str:
        assert_type(x, type[str])

def func2(x: Callable[..., object]):
    if x is str:
        assert_type(x, type[str])

Analysing this file, Pyright 1.1.380 CLI produces the following output:

error: "assert_type" mismatch: expected "type[str]" but received "(...) -> object" (reportAssertTypeFailure)
1 error, 0 warnings, 0 informations

Pyright narrows the type in the first function, but not in the second function.
I'm not sure if it's a bug as it isn't technically incorrect: str is an instance of (...) -> object. I understand types can't be narrowed in every case, but this is surprising behaviour given the type is narrowed in the object case.

[robert-bn]

I notice also that both TypeIs and TypeGuard do narrow the type to type[str] in this example:

from typing import assert_type, Callable
from typing_extensions import TypeGuard

def is_str_cls(x: object) -> TypeGuard[type[str]]:
    ...

def func2(x: Callable[..., object]):
    if is_str_cls(x):
        assert_type(x, type[str])

[Daraan]

TypeGuard is more strict and explicit. How I see it is TypeGuard more like cast and less an actual narrowing, which in turn TypeIs does.

According the the pyright documentation I would say that this is not a bug, but rather an un-supported case hence no type narrowing takes place. In short you have to use TypeIs/TypeGuard here to actually narrow it. As for the reasons why pyright does not narrow some is cases I cannot tell adequately but there are some discussions about it.

[robert-bn]

@Daraan
I'm not sure I understand. The documentation lists

x is C and x is not C (where C is a class)

as a supported type guard.

What indicates it isn't a supported case?

[erictraut]

Pyright narrows the type in the first function, but not in the second function.

Pyright's narrowing logic for the x is y type guard pattern doesn't currently handle the case where y is a class object whose constructor matches the callable type of x. I don't consider this a bug, but it is a missing feature. I think this is a reasonable enhancement request if you'd like to file one.

For what it's worth, mypy doesn't handle type narrowing for either of the x is str code samples above.