support nested TypeVars

Author: KotlinIsland

CHANGELOG.md

@@ -1,6 +1,8 @@
 # Basedmypy Changelog
 
 ## [Unreleased]
+### Added
+- Support using `TypeVar`s in the bounds of other `TypeVar`s
 ### Enhancements
 - Similar errors on the same line will now not be removed
 - Render generic upper bound with `: ` instead of ` <: `

mypy/applytype.py

@@ -95,6 +95,9 @@ def apply_generic_arguments(
         if type is None:
             continue
 
+        # apply concrete bounds
+        tvar.upper_bound = expand_type(tvar.upper_bound, id_to_type)
+
         target_type = get_target_type(
             tvar, type, callable, report_incompatible_typevar_value, context, skip_unsatisfied
         )

mypy/checker.py

@@ -6617,6 +6617,7 @@ def __init__(self) -> None:
         self.arg_types: set[TypeVarType] = set()
 
     def visit_type_var(self, t: TypeVarType) -> None:
+        t.upper_bound.accept(self)
         self.arg_types.add(t)
 
 

mypy/constraints.py

@@ -192,7 +192,9 @@ def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Con
     #     T :> U2", but they are not equivalent to the constraint solver,
     #     which never introduces new Union types (it uses join() instead).
     if isinstance(template, TypeVarType):
-        return [Constraint(template, direction, actual)]
+        return _infer_constraints(template.upper_bound, actual, direction) + [
+            Constraint(template, direction, actual)
+        ]
 
     # Now handle the case of either template or actual being a Union.
     # For a Union to be a subtype of another type, every item of the Union

mypy/expandtype.py

@@ -107,6 +107,7 @@ def freshen_function_type_vars(callee: F) -> F:
         for v in callee.variables:
             if isinstance(v, TypeVarType):
                 tv: TypeVarLikeType = TypeVarType.new_unification_variable(v)
+                tv.upper_bound = expand_type(tv.upper_bound, tvmap)
             elif isinstance(v, TypeVarTupleType):
                 assert isinstance(v, TypeVarTupleType)
                 tv = TypeVarTupleType.new_unification_variable(v)

mypy/semanal.py

@@ -3856,7 +3856,10 @@ def process_typevar_parameters(
                     # We want to use our custom error message below, so we suppress
                     # the default error message for invalid types here.
                     analyzed = self.expr_to_analyzed_type(
-                        param_value, allow_placeholder=True, report_invalid_types=False
+                        param_value,
+                        allow_placeholder=True,
+                        report_invalid_types=False,
+                        allow_unbound_tvars=True,
                     )
                     if analyzed is None:
                         # Type variables are special: we need to place them in the symbol table
@@ -6040,7 +6043,11 @@ def accept(self, node: Node) -> None:
             report_internal_error(err, self.errors.file, node.line, self.errors, self.options)
 
     def expr_to_analyzed_type(
-        self, expr: Expression, report_invalid_types: bool = True, allow_placeholder: bool = False
+        self,
+        expr: Expression,
+        report_invalid_types: bool = True,
+        allow_placeholder: bool = False,
+        allow_unbound_tvars=False,
     ) -> Type | None:
         if isinstance(expr, CallExpr):
             # This is a legacy syntax intended mostly for Python 2, we keep it for
@@ -6065,7 +6072,10 @@ def expr_to_analyzed_type(
             return TupleType(info.tuple_type.items, fallback=fallback)
         typ = self.expr_to_unanalyzed_type(expr)
         return self.anal_type(
-            typ, report_invalid_types=report_invalid_types, allow_placeholder=allow_placeholder
+            typ,
+            report_invalid_types=report_invalid_types,
+            allow_placeholder=allow_placeholder,
+            allow_unbound_tvars=allow_unbound_tvars,
         )
 
     def analyze_type_expr(self, expr: Expression) -> None:

mypy/typeanal.py

@@ -1394,11 +1394,16 @@ def bind_function_type_variables(
                     defn,
                     code=codes.VALID_TYPE,
                 )
+            # update inner type vars
+            typ = get_proper_type(tvar.upper_bound)
+            if isinstance(typ, Instance):
+                typ.args = tuple(it.accept(self) for it in typ.args)
+            if isinstance(typ, UnboundType):
+                tvar.upper_bound = tvar.upper_bound.accept(self)
             self.tvar_scope.bind_new(name, tvar, scopename=defn.name)
             binding = self.tvar_scope.get_binding(tvar.fullname)
             assert binding is not None
             defs.append(binding)
-
         return defs
 
     def is_defined_type_var(self, tvar: str, context: Context) -> bool:
@@ -1755,6 +1760,9 @@ def visit_unbound_type(self, t: UnboundType) -> TypeVarLikeList:
             and (self.include_bound_tvars or self.scope.get_binding(node) is None)
         ):
             assert isinstance(node.node, TypeVarLikeExpr)
+            upper_bound = get_proper_type(node.node.upper_bound)
+            if isinstance(upper_bound, (Instance, UnboundType)):
+                return upper_bound.accept(self) + [(name, node.node)]
             return [(name, node.node)]
         elif not self.include_callables and self._seems_like_callable(t):
             return []

test-data/unit/check-based-nested-typevar.test

@@ -0,0 +1,43 @@
+[case testNestedTypeVarBound]
+from typing import TypeVar, List
+
+T = TypeVar("T", bound=int)
+L = TypeVar("L", bound=List[T])
+
+def foo(l: L) -> T:
+    return l[0]
+
+reveal_type(foo([True]))  # N: Revealed type is "bool"
+foo([""])  # E: Value of type variable "T" of "foo" cannot be "str"  [type-var]
+
+
+[case testNestedTypeVarConstraint-xfail]
+from typing import TypeVar, Iterable
+
+E = TypeVar("E", int, str)
+I = TypeVar("I", bound=Iterable[T])
+
+def foo(i: I, e: E) -> I:
+    assert i[0] == e
+    return i
+
+reveal_type(foo([True], True))  # N: Revealed type is "list[int]"
+reveal_type(foo(["my"], "py"))  # N: Revealed type is "list[str]"
+reveal_type(foo(["my"], 10))  # E: argument 2 is bad
+reveal_type(foo([None], None))  # E: "I of foo" cannot be "list[None]"
+
+
+[case testNestedTypeVarConstraint2-xfail]
+from typing import TypeVar, Iterable, Set
+
+T = TypeVar("T", bound=int)
+C = TypeVar("L", Sequence[T], Mapping[T, T])
+
+def foo(c: C, t: T) -> C:
+    assert c[0] == t
+    return c
+
+reveal_type(foo([True], True))  # N: Revealed type is "Sequence[bool]"
+reveal_type(foo(["my"], "py"))  # E: "T of foo" can't be "str"
+reveal_type(foo({1: 1}, "10"))  # E: bad arg 2
+reveal_type(foo({True: True}, True))  # N: Mapping[bool]

test-data/unit/lib-stub/basedtyping.pyi

@@ -4,4 +4,4 @@
 # DO NOT ADD TO THIS FILE UNLESS YOU HAVE A GOOD REASON! Additional definitions
 # will slow down tests.
 
-Untyped = 0
+Untyped = 0