`bool` and `TypeGuard` incorrect match in `@overload` method

[sobolevn]

While working on python/typeshed#6140 I've noticed that there's a problem with how TypeGuard and bool types match in overload method. Here's a simplified example:

from typing import Callable, TypeVar, Generic, TypeGuard, Any, List, Optional, overload

_T = TypeVar('_T')

class filter(Generic[_T]):
 @overload
 def __init__(self, __function: Callable[[object], TypeGuard[_T]]) -> None: ...
 @overload
 def __init__(self, __function: Callable[[_T], Any]) -> None: ...

# Demo:

a: List[Optional[int]]
def is_int_typeguard(a: object) -> TypeGuard[int]: pass
def returns_bool(a: object) -> bool: pass

# Ok:
reveal_type(filter(is_int_typeguard)) # N: Revealed type is "ex.filter[builtins.int*]"

# Not ok:
reveal_type(filter(returns_bool)) # N: Revealed type is "ex.filter[builtins.bool*]"
# Expected: Revealed type is "ex.filter[builtins.object*]"

For some reason bool matches TypeGuard[_T] and infers _T to be bool. I think that TypeGuard here is more specific type than just bool and this match should not happen.

[hauntsaninja]

Try playing with this line:

mypy/mypy/typeanal.py

Line 359 in 1b6f63b

return self.named_type('builtins.bool')

[sobolevn]

Looks like that the problem is more likely here:

mypy/mypy/constraints.py

Lines 475 to 478 in eeafe6b

	if template.type_guard is not None:
	template_ret_type = template.type_guard
	if cactual.type_guard is not None:
	cactual_ret_type = cactual.type_guard

[sobolevn]

One more weird case:

from typing import Callable
from typing_extensions import TypeGuard

def different_typeguard(f: Callable[[object], TypeGuard[str]]): pass
def with_typeguard(o: object) -> TypeGuard[bool]: pass

different_typeguard(with_typeguard)

I don't think that this should be allowed. But, right now it is: no errors are shown.