fix union simplification

Author: michaelm-openai

mypy/typeops.py

@@ -636,7 +636,15 @@ def make_simplified_union(
 
 
 def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[Type]:
-    from mypy.subtypes import is_proper_subtype
+    from mypy.subtypes import SubtypeContext, is_proper_subtype
+
+    subtype_context = SubtypeContext(
+        ignore_promotions=True,
+        keep_erased_types=keep_erased,
+        options=(
+            checker_state.type_checker.options if checker_state.type_checker is not None else None
+        ),
+    )
 
     # The first pass through this loop, we check if later items are subtypes of earlier items.
     # The second pass through this loop, we check if earlier items are subtypes of later items
@@ -685,9 +693,7 @@ def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[
                     ):
                         continue
 
-                    if is_proper_subtype(
-                        ti, tj, keep_erased_types=keep_erased, ignore_promotions=True
-                    ):
+                    if is_proper_subtype(ti, tj, subtype_context=subtype_context):
                         duplicate_index = j
                         break
             if duplicate_index != -1:

test-data/unit/check-flags.test

@@ -2454,7 +2454,7 @@ f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview
 [case testDisallowStrIteration]
 # flags: --disallow-str-iteration
 from abc import abstractmethod
-from typing import Collection, Container, Iterable, Protocol, Sequence, TypeVar
+from typing import Collection, Container, Iterable, Mapping, Protocol, Sequence, TypeVar, Union
 
 def takes_str(x: str):
     for ch in x:  # E: Iterating over "str" is disallowed  # N: This is because --disallow-str-iteration is enabled
@@ -2508,6 +2508,9 @@ takes_collection_subclass(StrSubclass())  # E: Argument 1 to "takes_collection_s
                                           # N: "StrSubclass" is missing following "CollectionSubclass" protocol member: \
                                           # N:     __missing_impl__
 
+def repro(x: Mapping[str, Union[str, Sequence[str]]]) -> None:
+    x = {**x}
+
 [builtins fixtures/str-iter.pyi]
 [typing fixtures/typing-str-iter.pyi]
 

test-data/unit/fixtures/str-iter.pyi

@@ -1,9 +1,11 @@
 # Builtins stub used in disallow-str-iteration tests.
 
 
-from typing import Generic, Iterator, Sequence, TypeVar, overload
+from typing import Generic, Iterator, Mapping, Sequence, TypeVar, overload
 
 _T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
 
 class object:
     def __init__(self) -> None: pass
@@ -14,11 +16,14 @@ class bool(int): pass
 class ellipsis: pass
 class slice: pass
 
-class str:
+class str(Sequence[str]):
     def __iter__(self) -> Iterator[str]: pass
     def __len__(self) -> int: pass
     def __contains__(self, item: object) -> bool: pass
-    def __getitem__(self, i: int) -> str: pass
+    @overload
+    def __getitem__(self, i: int, /) -> str: ...
+    @overload
+    def __getitem__(self, s: slice, /) -> Sequence[str]: ...
 
 class list(Sequence[_T], Generic[_T]):
     def __iter__(self) -> Iterator[_T]: pass
@@ -38,4 +43,8 @@ class tuple(Sequence[_T], Generic[_T]):
     @overload
     def __getitem__(self, s: slice, /) -> list[_T]: ...
 
-class dict: pass
+class dict(Mapping[_KT, _VT], Generic[_KT, _VT]):
+    def __iter__(self) -> Iterator[_KT]: pass
+    def __len__(self) -> int: pass
+    def __contains__(self, item: object) -> bool: pass
+    def __getitem__(self, key: _KT) -> _VT: pass

test-data/unit/fixtures/typing-str-iter.pyi

@@ -1,16 +1,19 @@
 # Minimal typing fixture for disallow-str-iteration tests.
 
+import _typeshed
 from abc import ABCMeta, abstractmethod
 
 Any = object()
 TypeVar = 0
 Generic = 0
 Protocol = 0
+Union = 0
 overload = 0
 
 _T = TypeVar("_T")
 _KT = TypeVar("_KT")
 _T_co = TypeVar("_T_co", covariant=True)
+_KT_co = TypeVar("_KT_co", covariant=True)  # Key type covariant containers.
 _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 _TC = TypeVar("_TC", bound=type[object])
 
@@ -47,10 +50,14 @@ class Sequence(Collection[_T_co]):
     def __contains__(self, value: object) -> bool: ...
     def __iter__(self) -> Iterator[_T_co]: ...
 
+class KeysView(Protocol[_KT_co]):
+    def __iter__(self) -> Iterator[_KT_co]: ...
+
 class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
     @abstractmethod
     def __getitem__(self, key: _KT, /) -> _VT_co: ...
     def __contains__(self, key: object, /) -> bool: ...
+    def keys(self) -> KeysView[_KT]: ...
 
 def runtime_checkable(cls: _TC) -> _TC:
     return cls