introduced helper function to map type to protocol

Author: randolf-scholz

mypy/checkexpr.py

@@ -19,7 +19,7 @@
 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, SUPERTYPE_OF, Constraint, infer_constraints
+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 +31,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 map_instance_to_supertype, map_type_to_instance
+from mypy.maptype import as_type, 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
@@ -119,7 +119,6 @@
     Plugin,
 )
 from mypy.semanal_enum import ENUM_BASES
-from mypy.solve import solve_constraints
 from mypy.state import state
 from mypy.subtypes import (
     covers_at_runtime,
@@ -6165,24 +6164,7 @@ def is_valid_keyword_var_arg(self, typ: Type) -> bool:
             "_typeshed.SupportsKeysAndGetItem", [T, AnyType(TypeOfAny.special_form)]
         )
 
-        return map_type_to_instance(typ, template) is not None
-
-        # infer constraints and solve
-        constraints: list[Constraint] = [
-            # solve_constraints seems to completely ignore upper bounds.
-            # So we need to include it manually.
-            Constraint(T, SUBTYPE_OF, T.upper_bound),
-            *infer_constraints(template, typ, SUPERTYPE_OF),
-        ]
-        solution, _ = solve_constraints([T], constraints)
-        assert len(solution) == 1
-
-        return solution[0] is not None and is_subtype(
-            typ,
-            self.chk.named_generic_type(
-                "_typeshed.SupportsKeysAndGetItem", [solution[0], AnyType(TypeOfAny.special_form)]
-            ),
-        )
+        return as_type(typ, SUBTYPE_OF, 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,43 +1,49 @@
 from __future__ import annotations
 
+from typing import cast
+
 from mypy.expandtype import expand_type, expand_type_by_instance
 from mypy.nodes import TypeInfo
 from mypy.types import AnyType, Instance, TupleType, Type, TypeOfAny, has_type_vars
 
 
-def map_type_to_instance(typ: Type, target: Instance) -> Instance | None:
-    """Attempt to map `typ` to an Instance of the same class as `target`
-
-    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
+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.
-        Instance: the mapped instance type if the mapping is 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,
+    # 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, SUPERTYPE_OF, Constraint, infer_constraints
+    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, SUPERTYPE_OF)
+    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
@@ -46,8 +52,8 @@ def map_type_to_instance(typ: Type, target: Instance) -> Instance | None:
     if None in solution:
         return None
 
-    # 4. build resulting Instance by substituting typevars with solution
-    env = {tvar.id: sol for tvar, sol in zip(tvars, solution)}
+    # 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