refactor disallow_str_iteration checks and add check to is_overlapping_types

Author: michaelm-openai

mypy/checker.py

@@ -155,6 +155,7 @@
 from mypy.semanal_enum import ENUM_BASES, ENUM_SPECIAL_PROPS
 from mypy.semanal_shared import SemanticAnalyzerCoreInterface
 from mypy.sharedparse import BINARY_MAGIC_METHODS
+from mypy.disallow_str_iteration_state import disallow_str_iteration_state
 from mypy.state import state
 from mypy.subtypes import (
     find_member,
@@ -514,7 +515,11 @@ def check_first_pass(self) -> None:
         Deferred functions will be processed by check_second_pass().
         """
         self.recurse_into_functions = True
-        with state.strict_optional_set(self.options.strict_optional), checker_state.set(self):
+        with (
+            state.strict_optional_set(self.options.strict_optional),
+            disallow_str_iteration_state.set(self.options.disallow_str_iteration),
+            checker_state.set(self),
+        ):
             self.errors.set_file(
                 self.path, self.tree.fullname, scope=self.tscope, options=self.options
             )
@@ -559,7 +564,11 @@ def check_second_pass(
         """
         self.allow_constructor_cache = allow_constructor_cache
         self.recurse_into_functions = True
-        with state.strict_optional_set(self.options.strict_optional), checker_state.set(self):
+        with (
+            state.strict_optional_set(self.options.strict_optional),
+            disallow_str_iteration_state.set(self.options.disallow_str_iteration),
+            checker_state.set(self),
+        ):
             if not todo and not self.deferred_nodes:
                 return False
             self.errors.set_file(
@@ -5382,7 +5391,9 @@ def analyze_iterable_item_type_without_expression(
         iterable: Type
         iterable = get_proper_type(type)
 
-        if self.options.disallow_str_iteration and self.is_str_iteration_type(iterable):
+        if disallow_str_iteration_state.disallow_str_iteration and self.is_str_iteration_type(
+            iterable
+        ):
             self.msg.str_iteration_disallowed(context, iterable)
 
         iterator = echk.check_method_call_by_name("__iter__", iterable, [], [], context)[0]

mypy/disallow_str_iteration_state.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Final
+
+
+class DisallowStrIterationState:
+    # Wrap this in a class since it's faster that using a module-level attribute.
+
+    def __init__(self, disallow_str_iteration: bool) -> None:
+        # Value varies by file being processed
+        self.disallow_str_iteration = disallow_str_iteration
+
+    @contextmanager
+    def set(self, value: bool) -> Iterator[None]:
+        saved = self.disallow_str_iteration
+        self.disallow_str_iteration = value
+        try:
+            yield
+        finally:
+            self.disallow_str_iteration = saved
+
+
+disallow_str_iteration_state: Final = DisallowStrIterationState(disallow_str_iteration=False)

mypy/meet.py

@@ -5,6 +5,7 @@
 from mypy import join
 from mypy.erasetype import erase_type
 from mypy.maptype import map_instance_to_supertype
+from mypy.disallow_str_iteration_state import disallow_str_iteration_state
 from mypy.state import state
 from mypy.subtypes import (
     are_parameters_compatible,
@@ -14,6 +15,7 @@
     is_proper_subtype,
     is_same_type,
     is_subtype,
+    is_subtype_relation_ignored_to_disallow_str_iteration,
 )
 from mypy.typeops import is_recursive_pair, make_simplified_union, tuple_fallback
 from mypy.types import (
@@ -596,6 +598,12 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
         if right.type.fullname == "builtins.int" and left.type.fullname in MYPYC_NATIVE_INT_NAMES:
             return True
 
+        if disallow_str_iteration_state.disallow_str_iteration:
+            if is_subtype_relation_ignored_to_disallow_str_iteration(left, right):
+                return False
+            elif is_subtype_relation_ignored_to_disallow_str_iteration(right, left):
+                return False
+
         # Two unrelated types cannot be partially overlapping: they're disjoint.
         if left.type.has_base(right.type.fullname):
             left = map_instance_to_supertype(left, right.type)

mypy/subtypes.py

@@ -34,6 +34,7 @@
     Var,
 )
 from mypy.options import Options
+from mypy.disallow_str_iteration_state import disallow_str_iteration_state
 from mypy.state import state
 from mypy.types import (
     MYPYC_NATIVE_INT_NAMES,
@@ -481,22 +482,9 @@ def visit_instance(self, left: Instance) -> bool:
         right = self.right
 
         if (
-            self.options
-            and self.options.disallow_str_iteration
-            and left.type.has_base("builtins.str")
+            disallow_str_iteration_state.disallow_str_iteration
             and isinstance(right, Instance)
-            and not right.type.has_base("builtins.str")
-            and any(
-                right.type.has_base(base)
-                for base in (
-                    "collections.abc.Collection",
-                    "collections.abc.Iterable",
-                    "collections.abc.Sequence",
-                    "typing.Collection",
-                    "typing.Iterable",
-                    "typing.Sequence",
-                )
-            )
+            and is_subtype_relation_ignored_to_disallow_str_iteration(left, right)
         ):
             return False
         if isinstance(right, TupleType) and right.partial_fallback.type.is_enum:
@@ -2331,3 +2319,21 @@ def is_erased_instance(t: Instance) -> bool:
         elif not isinstance(get_proper_type(arg), AnyType):
             return False
     return True
+
+
+def is_subtype_relation_ignored_to_disallow_str_iteration(left: Instance, right: Instance) -> bool:
+    return (
+        left.type.has_base("builtins.str")
+        and not right.type.has_base("builtins.str")
+        and any(
+            right.type.has_base(base)
+            for base in (
+                "collections.abc.Collection",
+                "collections.abc.Iterable",
+                "collections.abc.Sequence",
+                "typing.Collection",
+                "typing.Iterable",
+                "typing.Sequence",
+            )
+        )
+    )

mypy/typeops.py

@@ -638,15 +638,7 @@ def make_simplified_union(
 
 
 def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[Type]:
-    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
-        ),
-    )
+    from mypy.subtypes import is_proper_subtype
 
     # 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
@@ -695,7 +687,9 @@ def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[
                     ):
                         continue
 
-                    if is_proper_subtype(ti, tj, subtype_context=subtype_context):
+                    if is_proper_subtype(
+                        ti, tj, keep_erased_types=keep_erased, ignore_promotions=True
+                    ):
                         duplicate_index = j
                         break
             if duplicate_index != -1:

test-data/unit/check-flags.test

@@ -2508,9 +2508,15 @@ 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:
+def dict_unpacking_unaffected_by_union_simplification(x: Mapping[str, Union[str, Sequence[str]]]) -> None:
     x = {**x}
 
+def narrowing(x: "str | Sequence[str]"):
+    if isinstance(x, str):
+        reveal_type(x)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(x)  # N: Revealed type is "typing.Sequence[builtins.str]"
+
 [builtins fixtures/str-iter.pyi]
 [typing fixtures/typing-str-iter.pyi]
 

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

@@ -48,3 +48,5 @@ class dict(Mapping[_KT, _VT], Generic[_KT, _VT]):
     def __len__(self) -> int: pass
     def __contains__(self, item: object) -> bool: pass
     def __getitem__(self, key: _KT) -> _VT: pass
+
+def isinstance(x: object, t: type) -> bool: pass