Code clean-up

Author: kreathon

mypy/subtypes.py

@@ -90,7 +90,6 @@ def __init__(
         ignore_promotions: bool = False,
         ignore_uninhabited: bool = False,
         # Proper subtype flags
-        erase_instances: bool = False,
         keep_erased_types: bool = False,
         options: Options | None = None,
     ) -> None:
@@ -99,7 +98,6 @@ def __init__(
         self.ignore_declared_variance = ignore_declared_variance
         self.ignore_promotions = ignore_promotions
         self.ignore_uninhabited = ignore_uninhabited
-        self.erase_instances = erase_instances
         self.keep_erased_types = keep_erased_types
         self.options = options
 
@@ -109,7 +107,7 @@ def check_context(self, proper_subtype: bool) -> None:
         if proper_subtype:
             assert not self.ignore_pos_arg_names and not self.ignore_declared_variance
         else:
-            assert not self.erase_instances and not self.keep_erased_types
+            assert not self.keep_erased_types
 
 
 def is_subtype(
@@ -187,34 +185,25 @@ def is_proper_subtype(
     subtype_context: SubtypeContext | None = None,
     ignore_promotions: bool = False,
     ignore_uninhabited: bool = False,
-    erase_instances: bool = False,
     keep_erased_types: bool = False,
 ) -> bool:
     """Is left a proper subtype of right?
 
     For proper subtypes, there's no need to rely on compatibility due to
     Any types. Every usable type is a proper subtype of itself.
 
-    If erase_instances is True, erase left instance *after* mapping it to supertype
-    (this is useful for runtime isinstance() checks). If keep_erased_types is True,
-    do not consider ErasedType a subtype of all types (used by type inference against unions).
+    If keep_erased_types is True, do not consider ErasedType a subtype
+    of all types (used by type inference against unions).
     """
     if subtype_context is None:
         subtype_context = SubtypeContext(
             ignore_promotions=ignore_promotions,
             ignore_uninhabited=ignore_uninhabited,
-            erase_instances=erase_instances,
             keep_erased_types=keep_erased_types,
         )
     else:
         assert not any(
-            {
-                ignore_promotions,
-                ignore_uninhabited,
-                erase_instances,
-                keep_erased_types,
-                ignore_uninhabited,
-            }
+            {ignore_promotions, ignore_uninhabited, keep_erased_types, ignore_uninhabited}
         ), "Don't pass both context and individual flags"
     if type_state.is_assumed_proper_subtype(left, right):
         return True
@@ -405,7 +394,6 @@ def build_subtype_kind(subtype_context: SubtypeContext, proper_subtype: bool) ->
             subtype_context.ignore_pos_arg_names,
             subtype_context.ignore_declared_variance,
             subtype_context.ignore_promotions,
-            subtype_context.erase_instances,
             subtype_context.keep_erased_types,
         )
 
@@ -533,10 +521,6 @@ def visit_instance(self, left: Instance) -> bool:
             ) and not self.subtype_context.ignore_declared_variance:
                 # Map left type to corresponding right instances.
                 t = map_instance_to_supertype(left, right.type)
-                if self.subtype_context.erase_instances:
-                    erased = erase_type(t)
-                    assert isinstance(erased, Instance)
-                    t = erased
                 nominal = True
                 if right.type.has_type_var_tuple_type:
                     # For variadic instances we simply find the correct type argument mappings,
@@ -1947,56 +1931,52 @@ def restrict_subtype_away(t: Type, s: Type) -> Type:
 def covers_type(item: Type, supertype: Type) -> bool:
     """Returns if item is covered by supertype.
 
-    Assumes that item is not a Union type.
     Any types (or fallbacks to any) should never cover or be covered.
-    Examples:
 
-    int            covered by int
-    List[int]      covered by List[Any]
-    A              covered by Union[A, Any]
-    Any            NOT covered by int
-    int            NOT covered by Any
+    Assumes that item is not a Union type.
+
+    Examples:
+        int            covered by int
+        List[int]      covered by List[Any]
+        A              covered by Union[A, Any]
+        Any            NOT covered by int
+        int            NOT covered by Any
     """
     item = get_proper_type(item)
     supertype = get_proper_type(supertype)
 
-    if isinstance(item, UnionType):
-        return False
+    assert not isinstance(item, UnionType)
 
     # Handle possible Any types that should not be covered:
-    if isinstance(item, AnyType):
-        return False
-    if isinstance(supertype, AnyType):
+    if isinstance(item, AnyType) or isinstance(supertype, AnyType):
         return False
-    if (isinstance(item, Instance) and item.type.fallback_to_any) or (
+    elif (isinstance(item, Instance) and item.type.fallback_to_any) or (
         isinstance(supertype, Instance) and supertype.type.fallback_to_any
     ):
         return is_same_type(item, supertype)
 
     if isinstance(supertype, UnionType):
-        return any(covers_type(item, t) for t in supertype.items)
-
-    if is_subtype(item, supertype, ignore_promotions=True):
-        return True
-
-    if isinstance(supertype, Instance):
+        # Special case that cannot be handled by is_subtype, because it would
+        # not ignore the Any types:
+        return any(covers_type(item, t) for t in supertype.relevant_items())
+    elif isinstance(supertype, Instance):
         if supertype.type.is_protocol:
             # TODO: Implement more robust support for runtime isinstance() checks, see issue #3827.
-            if is_proper_subtype(item, supertype, ignore_promotions=True):
+            if is_proper_subtype(item, erase_type(supertype), ignore_promotions=True):
                 return True
         if isinstance(item, TypedDictType):
             # Special case useful for selecting TypedDicts from unions using isinstance(x, dict).
             if supertype.type.fullname == "builtins.dict":
                 return True
         elif isinstance(item, TypeVarType):
-            if is_proper_subtype(item.upper_bound, supertype, ignore_promotions=True):
+            if is_proper_subtype(item.upper_bound, erase_type(supertype), ignore_promotions=True):
                 return True
         elif isinstance(item, Instance) and supertype.type.fullname == "builtins.int":
             # "int" covers all native int types
             if item.type.fullname in MYPYC_NATIVE_INT_NAMES:
                 return True
-    # TODO: Add more special cases.
-    return False
+
+    return is_subtype(item, supertype, ignore_promotions=True)
 
 
 def is_more_precise(left: Type, right: Type, *, ignore_promotions: bool = False) -> bool: