Overloads not resolved correctly when argument is `Any` and return types use `TypeGuard` or `TypeIs`

[erictraut]

When overload matching is ambiguous due to an Any argument, mypy typically looks at the return types of the potential matches. If the return types differ, it evaluates the return type as Any to preserve the "gradual type guarantee". It apparently doesn't do this when the return types of the potential overload matches use TypeIs. See the example below, where mypy matches the first overload rather than detecting the ambiguity and evaluating Any.

from typing import Any, overload
from typing_extensions import TypeIs

@overload
def func1(x: str) -> TypeIs[str]:
    ...

@overload
def func1(x: int) -> TypeIs[int]:
    ...

def func1(x: Any) -> Any:
    return True

def func2(val: Any):
    if func1(val):
        reveal_type(val) # Should be Any

I discovered this problem because pyright has the same issue. I'm guessing that the underlying cause of the bug in mypy is similar. Pyright's logic was treating TypeIs[T] as equivalent to bool in this case, but TypeIs[T] should be treated as a subtype of bool. Also, TypeIs[X] is not equivalent to TypeIs[Y] unless X is equivalent to Y.

This bug affects a recent change in typeshed to the dataclasses.isdataclass function, as discussed here.

[sobolevn]

The same happens with TypeGuard as well:

from typing import Any, overload
from typing_extensions import TypeGuard

@overload
def func1(x: str) -> TypeGuard[str]:
    ...

@overload
def func1(x: int) -> TypeGuard[int]:
    ...

def func1(x: Any) -> Any:
    return True

def func2(val: Any):
    if func1(val):
        reveal_type(val) # Should be `Any`, but is `str`

[sobolevn]

The problem is that we don't check for overloads here:

mypy/mypy/checker.py

Lines 5873 to 5890 in db9837f

	if literal(expr) == LITERAL_TYPE:
	# Note: we wrap the target type, so that we can special case later.
	# Namely, for isinstance() we use a normal meet, while TypeGuard is
	# considered "always right" (i.e. even if the types are not overlapping).
	# Also note that a care must be taken to unwrap this back at read places
	# where we use this to narrow down declared type.
	if node.callee.type_guard is not None:
	return {expr: TypeGuardedType(node.callee.type_guard)}, {}
	else:
	assert node.callee.type_is is not None
	return conditional_types_to_typemaps(
	expr,
	*self.conditional_types_with_intersection(
	self.lookup_type(expr),
	[TypeRange(node.callee.type_is, is_upper_bound=False)],
	expr,
	),
	)

[erictraut]

The same happens if TypeGuard and TypeIs are both used in an overload. This is an edge case that's unlikely to ever be used in real-world code, but it might as well be fixed along with the other cases.

from typing import Any, overload
from typing_extensions import TypeGuard, TypeIs

@overload
def func1(x: int | str) -> TypeIs[int]:
    ...

@overload
def func1(x: list) -> TypeGuard[int]:
    ...

def func1(x: Any) -> Any:
    return True

def func2(val: Any):
    if func1(val):
        reveal_type(val) # Should be `Any`, but is `int`

[sobolevn]

I have a prototype implementation, will create a PR tomorrow 🎉