Compare type ranges using is_same_type_ranges

Author: George-Ogden

mypy/checker.py

@@ -167,6 +167,7 @@
     is_more_precise,
     is_proper_subtype,
     is_same_type,
+    is_same_type_ranges,
     is_subtype,
     restrict_subtype_away,
     unify_generic_callable,
@@ -6252,9 +6253,12 @@ def is_type_call(expr: CallExpr) -> bool:
                 current_type = self.get_isinstance_type(expr)
                 if current_type is None:
                     continue
-                if type_being_compared is not None and type_being_compared != current_type:
+                if type_being_compared is not None and not is_same_type_ranges(
+                    type_being_compared, current_type
+                ):
                     # It doesn't really make sense to have several types being
                     # compared to the output of type (like type(x) == int == str)
+                    # unless they are the same (like type(x) == float == float)
                     # because whether that's true is solely dependent on what the
                     # types being compared are, so we don't try to narrow types any
                     # further because we can't really get any information about the
@@ -6269,11 +6273,10 @@ def is_type_call(expr: CallExpr) -> bool:
             return {}, {}
 
         if type_being_compared is None:
-            # TODO: use more accurate lower bound analysis
-            least_type = self.least_type([self.lookup_type(expr) for expr in exprs_in_type_calls])
-            type_being_compared = (
-                None if least_type is None else [TypeRange(least_type, is_upper_bound=True)]
+            least_type = reduce(
+                meet_types, (self.lookup_type(expr) for expr in exprs_in_type_calls)
             )
+            type_being_compared = [TypeRange(least_type, is_upper_bound=True)]
 
         if_maps: list[TypeMap] = []
         else_maps: list[TypeMap] = []
@@ -6308,28 +6311,6 @@ def combine_maps(list_maps: list[TypeMap]) -> TypeMap:
             else_map = {}
         return if_map, else_map
 
-    def least_type(self, types: list[Type]) -> Type | None:
-        """Find the type of which all other types are supertypes.
-        `Any` types are i
-        For example, `least_type([dict, defaultdict, object]) => dict`.
-        However, `least_type[int, str]) => None`.
-
-        It would be better if we could represent an intersection of types.
-
-        For example, consider `s: str` and `i: int`.
-        `type(s) == type(i)` implies `s: str & int` and `i: str & int`,
-        even though `s: object` and `i: object` also hold.
-        """
-        types = [typ for typ in types if not isinstance(typ, AnyType)]
-        if not types:
-            return None
-        least_type = reduce(lambda t1, t2: t1 if is_subtype(t1, t2) else t2, types)
-
-        if all(typ is least_type or is_subtype(least_type, typ) for typ in types):
-            # Ensure that this is a least type
-            return least_type
-        return None
-
     def find_isinstance_check(
         self, node: Expression, *, in_boolean_context: bool = True
     ) -> tuple[TypeMap, TypeMap]:

mypy/subtypes.py

@@ -8,6 +8,7 @@
 import mypy.applytype
 import mypy.constraints
 import mypy.typeops
+from mypy.checker_shared import TypeRange
 from mypy.checker_state import checker_state
 from mypy.erasetype import erase_type
 from mypy.expandtype import (
@@ -255,6 +256,29 @@ def is_equivalent(
     )
 
 
+def is_same_type_ranges(
+    a: list[TypeRange],
+    b: list[TypeRange],
+    ignore_promotions: bool = True,
+    subtype_context: SubtypeContext | None = None,
+) -> bool:
+    return len(a) == len(b) and all(
+        is_same_type_range(a, b, ignore_promotions, subtype_context)
+        for a, b in zip(a, b, strict=True)
+    )
+
+
+def is_same_type_range(
+    a: list[TypeRange],
+    b: list[TypeRange],
+    ignore_promotions: bool = True,
+    subtype_context: SubtypeContext | None = None,
+) -> bool:
+    return a.is_upper_bound == b.is_upper_bound and is_same_type(
+        a.item, b.item, ignore_promotions, subtype_context
+    )
+
+
 def is_same_type(
     a: Type, b: Type, ignore_promotions: bool = True, subtype_context: SubtypeContext | None = None
 ) -> bool: