Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
65 changes: 42 additions & 23 deletions mypy/meet.py
Original file line number Diff line number Diff line change
Expand Up @@ -134,30 +134,49 @@ def narrow_declared_type(declared: Type, narrowed: Type) -> Type:
return original_declared
if isinstance(declared, UnionType):
declared_items = declared.relevant_items()
if isinstance(narrowed, UnionType):
narrowed_items = narrowed.relevant_items()
else:
narrowed_items = [narrowed]
return make_simplified_union(
[
narrow_declared_type(d, n)
for d in declared_items
for n in narrowed_items
# This (ugly) special-casing is needed to support checking
# branches like this:
# x: Union[float, complex]
# if isinstance(x, int):
# ...
# And assignments like this:
# x: float | None
# y: int | None
# x = y
if (
is_overlapping_types(d, n, ignore_promotions=True)
or is_subtype(n, d, ignore_promotions=False)
)
]
narrowed_items = (
narrowed.relevant_items() if isinstance(narrowed, UnionType) else [narrowed]
)
shared_items = {get_proper_type(item) for item in narrowed_items}
can_reuse_common_items = isinstance(narrowed, UnionType) and shared_items.issubset(
get_proper_types(declared.items)
)

def _is_overlapping_type(item: Type, narrowed_item: Type) -> bool:
# Overlap alone is insufficient when numeric promotions are involved:
# a declared float | complex may narrow to int even though the runtime
# classes don't overlap. Check each narrowed item independently, so
# promotions also work for assignments such as float | None = int | None.
return is_overlapping_types(item, narrowed_item, ignore_promotions=True) or is_subtype(
narrowed_item, item, ignore_promotions=False
)

def _can_reuse_type(item: Type) -> bool:
proper_item = get_proper_type(item)
# Literal values and restricted truthiness still need recursive narrowing.
return (
isinstance(proper_item, Instance)
and proper_item in shared_items
and proper_item.last_known_value is None
and proper_item.can_be_true
and proper_item.can_be_false
)

# Require exact membership, not subtyping. New members such as int
# alongside float, or T[int] alongside T[Any], need recursive narrowing
# to preserve the additional type information.
result_items: list[Type] = []
for item in declared_items:
if can_reuse_common_items and _can_reuse_type(item):
# Narrowing only removes items, so reuse unchanged instances.
result_items.append(item)
else:
result_items.extend(
narrow_declared_type(item, narrowed_item)
for narrowed_item in narrowed_items
if _is_overlapping_type(item, narrowed_item)
)
return make_simplified_union(result_items)
if is_enum_overlapping_union(declared, narrowed):
# Quick check before reaching `is_overlapping_types`. If it's enum/literal overlap,
# avoid full expansion and make it faster.
Expand Down
58 changes: 58 additions & 0 deletions mypy/test/testtypes.py
Original file line number Diff line number Diff line change
Expand Up @@ -1212,6 +1212,64 @@ def test_trivial_cases(self) -> None:
for simple in self.fx.a, self.fx.o, self.fx.b:
self.assert_meet(simple, simple, simple)

def test_narrow_large_union_of_instances(self) -> None:
fx = self.fx
items = [Instance(fx.make_type_info(f"T{i}", mro=[fx.oi]), []) for i in range(300)]
declared = UnionType(items)
# The instances may be distinct objects after expanding a type alias.
narrowed = UnionType([Instance(item.type, []) for item in items[1:]])
with state.strict_optional_set(True):
assert_equal(narrow_declared_type(declared, narrowed), narrowed)

def test_narrow_union_preserves_truthiness(self) -> None:
fx = self.fx
for strict_optional in (False, True):
with state.strict_optional_set(strict_optional):
truthy_a = true_only(fx.a)
declared = UnionType([fx.d, fx.o, truthy_a])
narrowed = UnionType([fx.d, truthy_a])
result = get_proper_type(narrow_declared_type(declared, narrowed))
assert isinstance(result, UnionType)
assert_equal(result, UnionType([fx.d, fx.a]))
result_a = next(item for item in result.items if item == fx.a)
assert result_a.can_be_true
assert not result_a.can_be_false

def test_narrow_union_with_shared_instance_and_subclass(self) -> None:
fx = self.fx
with state.strict_optional_set(True):
assert_equal(
narrow_declared_type(UnionType([fx.a, fx.b, fx.d]), UnionType([fx.b, fx.d])),
UnionType([fx.b, fx.d]),
)
assert_equal(
narrow_declared_type(UnionType([fx.a, fx.d]), UnionType([fx.b, fx.d])),
UnionType([fx.b, fx.d]),
)

def test_narrow_union_with_literal_instances(self) -> None:
fx = self.fx
declared = UnionType([fx.lit1_inst, fx.a, fx.lit2, fx.lit1])
narrowed = UnionType([fx.lit1_inst, fx.lit2])
for strict_optional in (False, True):
with state.strict_optional_set(strict_optional):
assert_equal(
narrow_declared_type(declared, narrowed), UnionType([fx.a, fx.lit1, fx.lit2])
)

def test_narrow_union_preserves_new_generic_members(self) -> None:
fx = self.fx
info = fx.make_type_info("T", mro=[fx.oi], typevars=["S"], variances=[INVARIANT])
generic_any = Instance(info, [fx.anyt])
generic_a = Instance(info, [fx.a])
declared = UnionType([generic_any, fx.d])
with state.strict_optional_set(True):
for items in ([generic_any, generic_a, fx.d], [generic_a, generic_any, fx.d]):
narrowed = UnionType(items)
result = narrow_declared_type(declared, narrowed)
assert_equal(result, narrowed)
assert_equal(str(result), str(narrowed))

def test_class_subtyping(self) -> None:
self.assert_meet(self.fx.a, self.fx.o, self.fx.a)
self.assert_meet(self.fx.a, self.fx.b, self.fx.b)
Expand Down
Loading
Loading