Move some utils that use get_proper_type away from types.py (#15204)

This is a pure refactor to improve code organization.

Author: ilevkivskyi

mypy/checker.py

@@ -212,11 +212,8 @@
     get_proper_types,
     is_literal_type,
     is_named_instance,
-    is_optional,
-    remove_optional,
-    store_argument_type,
-    strip_type,
 )
+from mypy.types_utils import is_optional, remove_optional, store_argument_type, strip_type
 from mypy.typetraverser import TypeTraverserVisitor
 from mypy.typevars import fill_typevars, fill_typevars_with_any, has_no_typevars
 from mypy.util import is_dunder, is_sunder, is_typeshed_file
@@ -1542,9 +1539,20 @@ def check_reverse_op_method(
                 opt_meta = item.type.metaclass_type
                 if opt_meta is not None:
                     forward_inst = opt_meta
+
+        def has_readable_member(typ: Union[UnionType, Instance], name: str) -> bool:
+            # TODO: Deal with attributes of TupleType etc.
+            if isinstance(typ, Instance):
+                return typ.type.has_readable_member(name)
+            return all(
+                (isinstance(x, UnionType) and has_readable_member(x, name))
+                or (isinstance(x, Instance) and x.type.has_readable_member(name))
+                for x in get_proper_types(typ.relevant_items())
+            )
+
         if not (
             isinstance(forward_inst, (Instance, UnionType))
-            and forward_inst.has_readable_member(forward_name)
+            and has_readable_member(forward_inst, forward_name)
         ):
             return
         forward_base = reverse_type.arg_types[1]

mypy/checkexpr.py

@@ -155,12 +155,9 @@
     get_proper_type,
     get_proper_types,
     has_recursive_types,
-    is_generic_instance,
     is_named_instance,
-    is_optional,
-    is_self_type_like,
-    remove_optional,
 )
+from mypy.types_utils import is_generic_instance, is_optional, is_self_type_like, remove_optional
 from mypy.typestate import type_state
 from mypy.typevars import fill_typevars
 from mypy.typevartuples import find_unpack_in_list

mypy/constraints.py

@@ -46,8 +46,8 @@
     has_recursive_types,
     has_type_vars,
     is_named_instance,
-    is_union_with_any,
 )
+from mypy.types_utils import is_union_with_any
 from mypy.typestate import type_state
 from mypy.typevartuples import (
     extract_unpack,

mypy/expandtype.py

@@ -4,6 +4,7 @@
 from typing_extensions import Final
 
 from mypy.nodes import ARG_POS, ARG_STAR, ArgKind, Var
+from mypy.state import state
 from mypy.type_visitor import TypeTranslator
 from mypy.types import (
     ANY_STRATEGY,
@@ -38,7 +39,6 @@
     expand_param_spec,
     flatten_nested_unions,
     get_proper_type,
-    remove_trivial,
 )
 from mypy.typevartuples import (
     find_unpack_in_list,
@@ -549,3 +549,33 @@ def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type:
     if var.info.self_type is not None and not var.is_property:
         return expand_type(typ, {var.info.self_type.id: replacement})
     return typ
+
+
+def remove_trivial(types: Iterable[Type]) -> list[Type]:
+    """Make trivial simplifications on a list of types without calling is_subtype().
+
+    This makes following simplifications:
+        * Remove bottom types (taking into account strict optional setting)
+        * Remove everything else if there is an `object`
+        * Remove strict duplicate types
+    """
+    removed_none = False
+    new_types = []
+    all_types = set()
+    for t in types:
+        p_t = get_proper_type(t)
+        if isinstance(p_t, UninhabitedType):
+            continue
+        if isinstance(p_t, NoneType) and not state.strict_optional:
+            removed_none = True
+            continue
+        if isinstance(p_t, Instance) and p_t.type.fullname == "builtins.object":
+            return [p_t]
+        if p_t not in all_types:
+            new_types.append(t)
+            all_types.add(p_t)
+    if new_types:
+        return new_types
+    if removed_none:
+        return [NoneType()]
+    return [UninhabitedType()]

mypy/plugins/common.py

@@ -44,8 +44,8 @@
     TypeVarType,
     deserialize_type,
     get_proper_type,
-    is_optional,
 )
+from mypy.types_utils import is_optional
 from mypy.typevars import fill_typevars
 from mypy.util import get_unique_redefinition_name
 

mypy/semanal.py

@@ -274,10 +274,9 @@
     UnpackType,
     get_proper_type,
     get_proper_types,
-    invalid_recursive_alias,
     is_named_instance,
-    store_argument_type,
 )
+from mypy.types_utils import is_invalid_recursive_alias, store_argument_type
 from mypy.typevars import fill_typevars
 from mypy.util import (
     correct_relative_import,
@@ -3605,7 +3604,7 @@ def disable_invalid_recursive_aliases(
     ) -> None:
         """Prohibit and fix recursive type aliases that are invalid/unsupported."""
         messages = []
-        if invalid_recursive_alias({current_node}, current_node.target):
+        if is_invalid_recursive_alias({current_node}, current_node.target):
             messages.append("Invalid recursive alias: a union item of itself")
         if detect_diverging_alias(
             current_node, current_node.target, self.lookup_qualified, self.tvar_scope

mypy/subtypes.py

@@ -58,10 +58,10 @@
     UninhabitedType,
     UnionType,
     UnpackType,
-    _flattened,
     get_proper_type,
     is_named_instance,
 )
+from mypy.types_utils import flatten_types
 from mypy.typestate import SubtypeKind, type_state
 from mypy.typevars import fill_typevars_with_any
 from mypy.typevartuples import extract_unpack, fully_split_with_mapped_and_template
@@ -913,7 +913,7 @@ def visit_union_type(self, left: UnionType) -> bool:
 
             fast_check: set[ProperType] = set()
 
-            for item in _flattened(self.right.relevant_items()):
+            for item in flatten_types(self.right.relevant_items()):
                 p_item = get_proper_type(item)
                 fast_check.add(p_item)
                 if isinstance(p_item, Instance) and p_item.last_known_value is not None:

mypy/suggestions.py

@@ -78,9 +78,8 @@
     UninhabitedType,
     UnionType,
     get_proper_type,
-    is_optional,
-    remove_optional,
 )
+from mypy.types_utils import is_optional, remove_optional
 from mypy.util import split_target
 
 

mypy/test/testtypes.py

@@ -1444,7 +1444,7 @@ def make_call(*items: tuple[str, str | None]) -> CallExpr:
 class TestExpandTypeLimitGetProperType(TestCase):
     # WARNING: do not increase this number unless absolutely necessary,
     # and you understand what you are doing.
-    ALLOWED_GET_PROPER_TYPES = 7
+    ALLOWED_GET_PROPER_TYPES = 8
 
     @skipUnless(mypy.expandtype.__file__.endswith(".py"), "Skip for compiled mypy")
     def test_count_get_proper_type(self) -> None:

mypy/typeanal.py

@@ -81,12 +81,12 @@
     UninhabitedType,
     UnionType,
     UnpackType,
-    bad_type_type_item,
     callable_with_ellipsis,
     flatten_nested_unions,
     get_proper_type,
     has_type_vars,
 )
+from mypy.types_utils import is_bad_type_type_item
 from mypy.typetraverser import TypeTraverserVisitor
 from mypy.typevars import fill_typevars
 
@@ -564,7 +564,7 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                     type_str + " must have exactly one type argument", t, code=codes.VALID_TYPE
                 )
             item = self.anal_type(t.args[0])
-            if bad_type_type_item(item):
+            if is_bad_type_type_item(item):
                 self.fail("Type[...] can't contain another Type[...]", t, code=codes.VALID_TYPE)
                 item = AnyType(TypeOfAny.from_error)
             return TypeType.make_normalized(item, line=t.line, column=t.column)