diff --git a/mypy/meet.py b/mypy/meet.py index cbe3e99cdcd8..ea2411b8ccc9 100644 --- a/mypy/meet.py +++ b/mypy/meet.py @@ -50,6 +50,7 @@ find_unpack_in_list, get_proper_type, get_proper_types, + is_named_instance, split_with_prefix_and_suffix, ) @@ -645,7 +646,16 @@ def are_tuples_overlapping( if len(left.items) != len(right.items): return False - return all(is_overlapping(l, r) for l, r in zip(left.items, right.items)) + if not all(is_overlapping(l, r) for l, r in zip(left.items, right.items)): + return False + + # Check that the tuples aren't from e.g. different NamedTuples. + if is_named_instance(right.partial_fallback, "builtins.tuple") or is_named_instance( + left.partial_fallback, "builtins.tuple" + ): + return True + else: + return is_overlapping(left.partial_fallback, right.partial_fallback) def expand_tuple_if_possible(tup: TupleType, target: int) -> TupleType: diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test index 172228820add..a65a99cc25d0 100644 --- a/test-data/unit/check-namedtuple.test +++ b/test-data/unit/check-namedtuple.test @@ -1474,3 +1474,35 @@ def main(n: NT[T]) -> None: [builtins fixtures/tuple.pyi] [typing fixtures/typing-namedtuple.pyi] + +[case testNamedTupleOverlappingCheck] +from typing import overload, NamedTuple, Union + +class AKey(NamedTuple): + k: str + +class A(NamedTuple): + key: AKey + + +class BKey(NamedTuple): + k: str + +class B(NamedTuple): + key: BKey + +@overload +def f(arg: A) -> A: ... +@overload +def f(arg: B) -> B: ... +def f(arg: Union[A, B]) -> Union[A, B]: ... + +def g(x: Union[A, B, str]) -> Union[A, B, str]: + if isinstance(x, str): + return x + else: + reveal_type(x) # N: Revealed type is "Union[Tuple[Tuple[builtins.str, fallback=__main__.AKey], fallback=__main__.A], Tuple[Tuple[builtins.str, fallback=__main__.BKey], fallback=__main__.B]]" + return x._replace() + +# no errors should be raised above. +[builtins fixtures/tuple.pyi]