Fix join_instances_via_supertype

Author: michaelm-openai

mypy/disallow_str_iteration_state.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from mypy.types import Instance
 
 from collections.abc import Iterator
 from contextlib import contextmanager
@@ -23,3 +24,23 @@ def set(self, value: bool) -> Iterator[None]:
 
 
 disallow_str_iteration_state: Final = DisallowStrIterationState(disallow_str_iteration=False)
+
+
+STR_ITERATION_PROTOCOL_BASES: Final = frozenset(
+    {
+        "collections.abc.Collection",
+        "collections.abc.Iterable",
+        "collections.abc.Sequence",
+        "typing.Collection",
+        "typing.Iterable",
+        "typing.Sequence",
+    }
+)
+
+
+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 STR_ITERATION_PROTOCOL_BASES)
+    )

mypy/join.py

@@ -9,6 +9,10 @@
 from mypy.expandtype import expand_type
 from mypy.maptype import map_instance_to_supertype
 from mypy.nodes import CONTRAVARIANT, COVARIANT, INVARIANT, VARIANCE_NOT_READY, TypeInfo
+from mypy.disallow_str_iteration_state import (
+    disallow_str_iteration_state,
+    STR_ITERATION_PROTOCOL_BASES,
+)
 from mypy.state import state
 from mypy.subtypes import (
     SubtypeContext,
@@ -169,12 +173,24 @@ def join_instances_via_supertype(self, t: Instance, s: Instance) -> ProperType:
         # The definition of "best" may evolve; for now it is the one with
         # the longest MRO.  Ties are broken by using the earlier base.
 
+        should_skip_str_iteration_protocol_bases = (
+            disallow_str_iteration_state.disallow_str_iteration and t.type.has_base("builtins.str")
+        )
+
         # Go over both sets of bases in case there's an explicit Protocol base. This is important
         # to ensure commutativity of join (although in cases where both classes have relevant
         # Protocol bases this maybe might still not be commutative)
         base_types: dict[TypeInfo, None] = {}  # dict to deduplicate but preserve order
         for base in t.type.bases:
+            if (
+                should_skip_str_iteration_protocol_bases
+                and base.type.fullname in STR_ITERATION_PROTOCOL_BASES
+            ):
+                base_types[object_from_instance(t).type] = None
+                continue
+
             base_types[base.type] = None
+
         for base in s.type.bases:
             if base.type.is_protocol and is_subtype(t, base):
                 base_types[base.type] = None

mypy/meet.py

@@ -5,7 +5,10 @@
 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.disallow_str_iteration_state import (
+    disallow_str_iteration_state,
+    is_subtype_relation_ignored_to_disallow_str_iteration,
+)
 from mypy.state import state
 from mypy.subtypes import (
     are_parameters_compatible,
@@ -15,7 +18,6 @@
     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 (

mypy/subtypes.py

@@ -34,7 +34,10 @@
     Var,
 )
 from mypy.options import Options
-from mypy.disallow_str_iteration_state import disallow_str_iteration_state
+from mypy.disallow_str_iteration_state import (
+    disallow_str_iteration_state,
+    is_subtype_relation_ignored_to_disallow_str_iteration,
+)
 from mypy.state import state
 from mypy.types import (
     MYPYC_NATIVE_INT_NAMES,
@@ -1200,6 +1203,11 @@ def f(self) -> A: ...
     as well.
     """
     assert right.type.is_protocol
+    if (
+        disallow_str_iteration_state.disallow_str_iteration
+        and is_subtype_relation_ignored_to_disallow_str_iteration(left, right)
+    ):
+        return False
     if skip is None:
         skip = []
     # We need to record this check to generate protocol fine-grained dependencies.
@@ -2319,21 +2327,3 @@ 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",
-            )
-        )
-    )

test-data/unit/check-flags.test

@@ -2517,6 +2517,11 @@ def narrowing(x: "str | Sequence[str]"):
     else:
         reveal_type(x)  # N: Revealed type is "typing.Sequence[builtins.str]"
 
+Item = TypeVar("Item")
+def takes_generic_list(x: list[Item]) -> None: ...
+takes_generic_list(reveal_type([s, seq]))  # N: Revealed type is "builtins.list[builtins.object]"
+takes_generic_list(reveal_type([seq, s]))  # N: Revealed type is "builtins.list[builtins.object]"
+
 [builtins fixtures/str-iter.pyi]
 [typing fixtures/typing-str-iter.pyi]