Some tweaks

python · ilevkivskyi · Jun 18, 2023 · May 17, 2023 · May 19, 2023 · May 22, 2023
commit 4c41c67bfc17baf5cc9cfdd0c8a25a3de4850eb4
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -5387,7 +5387,7 @@ def replace_callable_return_type(c: CallableType, new_ret_type: Type) -> Callabl
 def apply_poly(tp: CallableType, poly_tvars: Sequence[TypeVarLikeType]) -> Optional[CallableType]:
     """Make free type variables generic in the type if possible.
 
-    This will analyze the type `tp` while trying to create valid bindings for
+    This will translate the type `tp` while trying to create valid bindings for
     type variables `poly_tvars` while traversing the type. This follows the same rules
     as we do during semantic analysis phase, examples:
       * Callable[Callable[[T], T], T] -> def [T] (def (T) -> T) -> T
@@ -5413,6 +5413,7 @@ class PolyTranslator(TypeTranslator):
 
     See docstring for apply_poly() for details.
     """
+
     def __init__(self, poly_tvars: Sequence[TypeVarLikeType]) -> None:
         self.poly_tvars = set(poly_tvars)
         # This is a simplified version of TypeVarScope used during semantic analysis.
@@ -5422,14 +5423,14 @@ def __init__(self, poly_tvars: Sequence[TypeVarLikeType]) -> None:
     def visit_callable_type(self, t: CallableType) -> Type:
         found_vars = set()
         for arg in t.arg_types:
-            found_vars |= set(get_type_vars(arg))
-        found_vars &= self.poly_tvars
+            found_vars |= set(get_type_vars(arg)) & self.poly_tvars
+
         found_vars -= self.bound_tvars
         self.bound_tvars |= found_vars
         result = super().visit_callable_type(t)
         self.bound_tvars -= found_vars
-        assert isinstance(result, ProperType)
-        assert isinstance(result, CallableType)
+
+        assert isinstance(result, ProperType) and isinstance(result, CallableType)
         result.variables = list(result.variables) + list(found_vars)
         return result
 

diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -888,9 +888,9 @@ def visit_callable_type(self, template: CallableType) -> list[Constraint]:
                 # FIX verify argument counts
                 # TODO: Erase template variables if it is generic?
                 if cactual.variables and cactual.param_spec() is None:
-                    # If template is generic, unify it with template. Note: this is
+                    # If actual is generic, unify it with template. Note: this is
                     # not an ideal solution (which would be adding the generic variables
-                    # to the constraint inference set), but is a good first approximation,
+                    # to the constraint inference set), but it's a good first approximation,
                     # and this will prevent leaking these variables in the solutions.
                     # Note: this may infer constraints like T <: S or T <: List[S]
                     # that contain variables in the target.

diff --git a/mypy/solve.py b/mypy/solve.py
@@ -148,6 +148,8 @@ def solve_iteratively(
                 c.target = expand_type(
                     c.target, {k: v for (k, v) in tmap.items() if v is not None}
                 )
+        # TODO: support backtracking lower/upper bound choices
+        # (will require switching this function from iterative to recursive).
         solutions.update(tmap)
     return solutions
 
@@ -213,10 +215,10 @@ def normalize_constraints(
 ) -> list[Constraint]:
     """Normalize list of constraints (to simplify life for the non-linear solver).
 
-     This includes two things currently:
-       * Complement T :> S by S <: T
-       * Remove strict duplicates
-     """
+    This includes two things currently:
+      * Complement T :> S by S <: T
+      * Remove strict duplicates
+    """
     res = constraints.copy()
     for c in constraints:
         if isinstance(c.target, TypeVarType):