renamed and moved function to subtypes

Author: randolf-scholz

mypy/checkexpr.py

@@ -19,7 +19,6 @@
 from mypy.checkmember import analyze_member_access, has_operator
 from mypy.checkstrformat import StringFormatterChecker
 from mypy.constant_fold import constant_fold_expr
-from mypy.constraints import SUBTYPE_OF
 from mypy.erasetype import erase_type, remove_instance_last_known_values, replace_meta_vars
 from mypy.errors import ErrorInfo, ErrorWatcher, report_internal_error
 from mypy.expandtype import (
@@ -31,7 +30,7 @@
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
 from mypy.infer import ArgumentInferContext, infer_function_type_arguments, infer_type_arguments
 from mypy.literals import literal
-from mypy.maptype import as_type, map_instance_to_supertype
+from mypy.maptype import map_instance_to_supertype
 from mypy.meet import is_overlapping_types, narrow_declared_type
 from mypy.message_registry import ErrorMessage
 from mypy.messages import MessageBuilder, format_type
@@ -127,6 +126,7 @@
     is_same_type,
     is_subtype,
     non_method_protocol_members,
+    solve_as_subtype,
 )
 from mypy.traverser import (
     all_name_and_member_expressions,
@@ -6164,7 +6164,7 @@ def is_valid_keyword_var_arg(self, typ: Type) -> bool:
             "_typeshed.SupportsKeysAndGetItem", [T, AnyType(TypeOfAny.special_form)]
         )
 
-        return as_type(typ, SUBTYPE_OF, template) is not None
+        return solve_as_subtype(typ, template) is not None
 
     def not_ready_callback(self, name: str, context: Context) -> None:
         """Called when we can't infer the type of a variable because it's not ready yet.

mypy/maptype.py

@@ -1,61 +1,8 @@
 from __future__ import annotations
 
-from typing import cast
-
-from mypy.expandtype import expand_type, expand_type_by_instance
+from mypy.expandtype import expand_type_by_instance
 from mypy.nodes import TypeInfo
-from mypy.types import AnyType, Instance, TupleType, Type, TypeOfAny, has_type_vars
-
-
-def as_type(typ: Type, direction: int, target: Type) -> Type | None:
-    """Attempts to solve type variables in `target` so that `typ` is a subtype/supertype of
-    the resulting type.
-
-    Args:
-        typ: The type to map from.
-        direction: One of SUBTYPE_OF or SUPERTYPE_OF
-        target: The target instance type to map to.
-
-    Returns:
-        None: if the mapping is not possible.
-        Type: the mapped type if the mapping is possible.
-
-    Examples:
-        (list[int], Iterable[T]) -> Iterable[int]
-        (list[list[int]], Iterable[list[T]]) -> Iterable[list[int]]
-        (dict[str, int], Mapping[K, int]) -> Mapping[str, int]
-        (list[int], Mapping[K, V]) -> None
-    """
-    from mypy.subtypes import is_subtype
-    from mypy.typeops import get_all_type_vars
-
-    # 1. get type vars of target
-    tvars = get_all_type_vars(target)
-
-    # fast path: if no type vars, just check subtype
-    if not tvars:
-        return target if is_subtype(typ, target) else None
-
-    from mypy.constraints import SUBTYPE_OF, Constraint, infer_constraints
-    from mypy.solve import solve_constraints
-
-    # 2. determine constraints
-    constraints: list[Constraint] = infer_constraints(target, typ, not direction)
-    for tvar in tvars:
-        # need to manually include these because solve_constraints ignores them
-        # apparently
-        constraints.append(Constraint(tvar, SUBTYPE_OF, tvar.upper_bound))
-
-    # 3. solve constraints
-    solution, _ = solve_constraints(tvars, constraints)
-
-    if None in solution:
-        return None
-
-    # 4. build resulting Type by substituting type vars with solution
-    env = {tvar.id: s for tvar, s in zip(tvars, cast("list[Type]", solution))}
-    target = expand_type(target, env)
-    return target if is_subtype(typ, target) else None
+from mypy.types import AnyType, Instance, TupleType, TypeOfAny, has_type_vars
 
 
 def map_instance_to_supertype(instance: Instance, superclass: TypeInfo) -> Instance:

mypy/subtypes.py

@@ -8,6 +8,7 @@
 import mypy.constraints
 import mypy.typeops
 from mypy.checker_state import checker_state
+from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, infer_constraints
 from mypy.erasetype import erase_type
 from mypy.expandtype import (
     expand_self_type,
@@ -35,6 +36,7 @@
 )
 from mypy.options import Options
 from mypy.state import state
+from mypy.typeops import get_all_type_vars
 from mypy.types import (
     MYPYC_NATIVE_INT_NAMES,
     TUPLE_LIKE_INSTANCE_NAMES,
@@ -2311,3 +2313,45 @@ def is_erased_instance(t: Instance) -> bool:
         elif not isinstance(get_proper_type(arg), AnyType):
             return False
     return True
+
+
+def solve_as_subtype(typ: Type, target: Type) -> Type | None:
+    """Solves type variables in `target` so that `typ` becomes a subtype of `target`.
+
+    Returns:
+        None: if the mapping is not possible.
+        Type: the mapped type if the mapping is possible.
+
+    Examples:
+        (list[int], Iterable[T]) -> Iterable[int]
+        (list[list[int]], Iterable[list[T]]) -> Iterable[list[int]]
+        (dict[str, int], Mapping[K, int]) -> Mapping[str, int]
+        (list[int], Mapping[K, V]) -> None
+    """
+
+    # 1. get type vars of target
+    tvars = get_all_type_vars(target)
+
+    # fast path: if no type vars, just check subtype
+    if not tvars:
+        return target if is_subtype(typ, target) else None
+
+    from mypy.solve import solve_constraints
+
+    # 2. determine constraints
+    constraints: list[Constraint] = infer_constraints(target, typ, SUPERTYPE_OF)
+    for tvar in tvars:
+        # need to manually include these because solve_constraints ignores them
+        # apparently
+        constraints.append(Constraint(tvar, SUBTYPE_OF, tvar.upper_bound))
+
+    # 3. solve constraints
+    solution, _ = solve_constraints(tvars, constraints)
+
+    if None in solution:
+        return None
+
+    # 4. build resulting Type by substituting type vars with solution
+    env = {tvar.id: s for tvar, s in zip(tvars, cast("list[Type]", solution))}
+    target = expand_type(target, env)
+    return target if is_subtype(typ, target) else None