[red-knot] Add Type::TypeVar variant

crates/red_knot_python_semantic/resources/mdtest/generics/functions.md

@@ -108,7 +108,6 @@ def good_return[T: int](x: T) -> T:
 
 def bad_return[T: int](x: T) -> T:
     # TODO: error: int is not assignable to T
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `T` and `Literal[1]`"
     return x + 1
 ```
 
@@ -138,8 +137,6 @@ methods that are compatible with the return type, so the `return` expression is
 
 ```py
 def same_constrained_types[T: (int, str)](t1: T, t2: T) -> T:
-    # TODO: no error
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `T` and `T`"
     return t1 + t2
 ```
 

crates/red_knot_python_semantic/resources/mdtest/generics/pep695.md

@@ -48,4 +48,120 @@ class C[T]:
         reveal_type(x)  # revealed: T
 ```
 
+## Subtyping and assignability
+
+An unbounded, unconstrained typevar is assignable to itself, but is not a subtype of itself (or any
+other type), since it might be specialized to `Any`, which does not participate in the subtyping
+relationship.
+
+It is neither assignable to or a subtype of any other type (including other typevars), since we can
+make no assumption about what type it will be specialized to.
+
+```py
+from knot_extensions import is_assignable_to, is_subtype_of, static_assert
+
+def unbounded_unconstrained[T, U](t: T, u: U) -> None:
+    static_assert(is_assignable_to(T, T))
+    static_assert(is_assignable_to(U, U))
+    static_assert(not is_assignable_to(T, U))
+    static_assert(not is_assignable_to(U, T))
+
+    static_assert(not is_subtype_of(T, T))
+    static_assert(not is_subtype_of(U, U))
+    static_assert(not is_subtype_of(T, U))
+    static_assert(not is_subtype_of(U, T))
+```
+
+A bounded typevar is assignable to its bound, but the bound is not assignable to the typevar (since
+the typevar might be specialized to a smaller type). (TODO: Unless the bound is final, in which case
+the final class is also assignable to the typevar.)
+
+```py
+from typing_extensions import final
+
+def bounded[T: int](t: T) -> None:
+    static_assert(is_assignable_to(T, int))
+    static_assert(not is_assignable_to(int, T))
+
+    static_assert(not is_subtype_of(T, int))
+    static_assert(not is_subtype_of(int, T))
+
+@final
+class FinalClass: ...
+
+def bounded_final[T: FinalClass](t: T) -> None:
+    static_assert(is_assignable_to(T, FinalClass))
+    # TODO: is_assignable_to
+    static_assert(not is_assignable_to(FinalClass, T))
+
+    static_assert(not is_subtype_of(T, FinalClass))
+    static_assert(not is_subtype_of(FinalClass, T))
+```
+
+Two distinct typevars are not assignable to each other, even if they have the same bounds, since
+there is (still) no guarantee that they will be specialized to the same type. (TODO: Unless the
+bound is final, in which case we _can_ assume that the two typevars must always be specialized to
+that final class.)
+
+```py
+def two_bounded[T: int, U: int](t: T, u: U) -> None:
+    static_assert(not is_assignable_to(T, U))
+    static_assert(not is_assignable_to(U, T))
+
+    static_assert(not is_subtype_of(T, U))
+    static_assert(not is_subtype_of(U, T))
+
+def two_final_bounded[T: FinalClass, U: FinalClass](t: T, u: U) -> None:
+    # TODO: is_assignable_to
+    static_assert(not is_assignable_to(T, U))
+    # TODO: is_assignable_to
+    static_assert(not is_assignable_to(U, T))
+
+    static_assert(not is_subtype_of(T, U))
+    static_assert(not is_subtype_of(U, T))
+```
+
+A constrained typevar is assignable to the union of its constraints, but not to any of the
+constraints individually. None of the constraints are assignable to the typevar.
+
+```py
+def constrained[T: (int, str)](t: T) -> None:
+    static_assert(not is_assignable_to(T, int))
+    static_assert(not is_assignable_to(T, str))
+    static_assert(is_assignable_to(T, int | str))
+    static_assert(not is_assignable_to(int, T))
+    static_assert(not is_assignable_to(str, T))
+    static_assert(not is_assignable_to(int | str, T))
+
+    static_assert(not is_subtype_of(T, int))
+    static_assert(not is_subtype_of(T, str))
+    static_assert(not is_subtype_of(T, int | str))
+    static_assert(not is_subtype_of(int, T))
+    static_assert(not is_subtype_of(str, T))
+    static_assert(not is_subtype_of(int | str, T))
+```
+
+Two distinct typevars are not assignable to each other, even if they have the same constraints, and
+even if any of the constraints are final. There must always be at least two distinct constraints,
+meaning that there is (still) no guarantee that they will be specialized to the same type.
+
+```py
+def two_constrainted[T: (int, str), U: (int, str)](t: T, u: U) -> None:
+    static_assert(not is_assignable_to(T, U))
+    static_assert(not is_assignable_to(U, T))
+
+    static_assert(not is_subtype_of(T, U))
+    static_assert(not is_subtype_of(U, T))
+
+@final
+class AnotherFinalClass: ...
+
+def two_final_constrainted[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: T, u: U) -> None:
+    static_assert(not is_assignable_to(T, U))
+    static_assert(not is_assignable_to(U, T))
+
+    static_assert(not is_subtype_of(T, U))
+    static_assert(not is_subtype_of(U, T))
+```
+
 [pep 695]: https://peps.python.org/pep-0695/