[ty] Track when type variables are inferable or not (#19786)

`Type::TypeVar` now distinguishes whether the typevar in question is
inferable or not.

A typevar is _not inferable_ inside the body of the generic class or
function that binds it:

```py
def f[T](t: T) -> T:
    return t
```

The infered type of `t` in the function body is `TypeVar(T,
NotInferable)`. This represents how e.g. assignability checks need to be
valid for all possible specializations of the typevar. Most of the
existing assignability/etc logic only applies to non-inferable typevars.

Outside of the function body, the typevar is _inferable_:

```py
f(4)
```

Here, the parameter type of `f` is `TypeVar(T, Inferable)`. This
represents how e.g. assignability doesn't need to hold for _all_
specializations; instead, we need to find the constraints under which
this specific assignability check holds.

This is in support of starting to perform specialization inference _as
part of_ performing the assignability check at the call site.

In the [[POPL2015][]] paper, this concept is called _monomorphic_ /
_polymorphic_, but I thought _non-inferable_ / _inferable_ would be
clearer for us.

Depends on #19784 

[POPL2015]: https://doi.org/10.1145/2676726.2676991

---------

Co-authored-by: Carl Meyer <[email protected]>

Author: dcreager

crates/ty_ide/src/completion.rs

@@ -1247,7 +1247,7 @@ quux.<CURSOR>
         __init_subclass__ :: bound method Quux.__init_subclass__() -> None
         __module__ :: str
         __ne__ :: bound method Quux.__ne__(value: object, /) -> bool
-        __new__ :: bound method Quux.__new__() -> Self@__new__
+        __new__ :: bound method Quux.__new__() -> Quux
         __reduce__ :: bound method Quux.__reduce__() -> str | tuple[Any, ...]
         __reduce_ex__ :: bound method Quux.__reduce_ex__(protocol: SupportsIndex, /) -> str | tuple[Any, ...]
         __repr__ :: bound method Quux.__repr__() -> str
@@ -1292,7 +1292,7 @@ quux.b<CURSOR>
         __init_subclass__ :: bound method Quux.__init_subclass__() -> None
         __module__ :: str
         __ne__ :: bound method Quux.__ne__(value: object, /) -> bool
-        __new__ :: bound method Quux.__new__() -> Self@__new__
+        __new__ :: bound method Quux.__new__() -> Quux
         __reduce__ :: bound method Quux.__reduce__() -> str | tuple[Any, ...]
         __reduce_ex__ :: bound method Quux.__reduce_ex__(protocol: SupportsIndex, /) -> str | tuple[Any, ...]
         __repr__ :: bound method Quux.__repr__() -> str

crates/ty_ide/src/semantic_tokens.rs

@@ -337,7 +337,9 @@ impl<'db> SemanticTokenVisitor<'db> {
 
         match ty {
             Type::ClassLiteral(_) => (SemanticTokenType::Class, modifiers),
-            Type::TypeVar(_) => (SemanticTokenType::TypeParameter, modifiers),
+            Type::NonInferableTypeVar(_) | Type::TypeVar(_) => {
+                (SemanticTokenType::TypeParameter, modifiers)
+            }
             Type::FunctionLiteral(_) => {
                 // Check if this is a method based on current scope
                 if self.in_class_scope {

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -1,16 +1,16 @@
 # Self
 
+```toml
+[environment]
+python-version = "3.11"
+```
+
 `Self` is treated as if it were a `TypeVar` bound to the class it's being used on.
 
 `typing.Self` is only available in Python 3.11 and later.
 
 ## Methods
 
-```toml
-[environment]
-python-version = "3.11"
-```
-
 ```py
 from typing import Self
 
@@ -74,11 +74,6 @@ reveal_type(C().method())  # revealed: C
 
 ## Class Methods
 
-```toml
-[environment]
-python-version = "3.11"
-```
-
 ```py
 from typing import Self, TypeVar
 
@@ -101,11 +96,6 @@ reveal_type(Shape.bar())  # revealed: Unknown
 
 ## Attributes
 
-```toml
-[environment]
-python-version = "3.11"
-```
-
 TODO: The use of `Self` to annotate the `next_node` attribute should be
 [modeled as a property][self attribute], using `Self` in its parameter and return type.
 
@@ -127,11 +117,6 @@ reveal_type(LinkedList().next())  # revealed: LinkedList
 
 ## Generic Classes
 
-```toml
-[environment]
-python-version = "3.11"
-```
-
 ```py
 from typing import Self, Generic, TypeVar
 
@@ -153,11 +138,6 @@ TODO: <https://typing.python.org/en/latest/spec/generics.html#use-in-protocols>
 
 ## Annotations
 
-```toml
-[environment]
-python-version = "3.11"
-```
-
 ```py
 from typing import Self
 
@@ -171,11 +151,6 @@ class Shape:
 
 `Self` cannot be used in the signature of a function or variable.
 
-```toml
-[environment]
-python-version = "3.11"
-```
-
 ```py
 from typing import Self, Generic, TypeVar
 
@@ -218,4 +193,33 @@ class MyMetaclass(type):
         return super().__new__(cls)
 ```
 
+## Binding a method fixes `Self`
+
+When a method is bound, any instances of `Self` in its signature are "fixed", since we now know the
+specific type of the bound parameter.
+
+```py
+from typing import Self
+
+class C:
+    def instance_method(self, other: Self) -> Self:
+        return self
+
+    @classmethod
+    def class_method(cls) -> Self:
+        return cls()
+
+# revealed: bound method C.instance_method(other: C) -> C
+reveal_type(C().instance_method)
+# revealed: bound method <class 'C'>.class_method() -> C
+reveal_type(C.class_method)
+
+class D(C): ...
+
+# revealed: bound method D.instance_method(other: D) -> D
+reveal_type(D().instance_method)
+# revealed: bound method <class 'D'>.class_method() -> D
+reveal_type(D.class_method)
+```
+
 [self attribute]: https://typing.python.org/en/latest/spec/generics.html#use-in-attribute-annotations

crates/ty_python_semantic/resources/mdtest/generics/legacy/classes.md

@@ -491,6 +491,24 @@ class A(Generic[T]):
 reveal_type(A(x=1))  # revealed: A[int]
 ```
 
+### Class typevar has another typevar as a default
+
+```py
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+U = TypeVar("U", default=T)
+
+class C(Generic[T, U]): ...
+
+reveal_type(C())  # revealed: C[Unknown, Unknown]
+
+class D(Generic[T, U]):
+    def __init__(self) -> None: ...
+
+reveal_type(D())  # revealed: D[Unknown, Unknown]
+```
+
 ## Generic subclass
 
 When a generic subclass fills its superclass's type parameter with one of its own, the actual types

crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md

@@ -438,6 +438,19 @@ class A[T]:
 reveal_type(A(x=1))  # revealed: A[int]
 ```
 
+### Class typevar has another typevar as a default
+
+```py
+class C[T, U = T]: ...
+
+reveal_type(C())  # revealed: C[Unknown, Unknown]
+
+class D[T, U = T]:
+    def __init__(self) -> None: ...
+
+reveal_type(D())  # revealed: D[Unknown, Unknown]
+```
+
 ## Generic subclass
 
 When a generic subclass fills its superclass's type parameter with one of its own, the actual types

crates/ty_python_semantic/resources/mdtest/named_tuple.md

@@ -243,7 +243,7 @@ class Person(NamedTuple):
 
 reveal_type(Person._field_defaults)  # revealed: dict[str, Any]
 reveal_type(Person._fields)  # revealed: tuple[str, ...]
-reveal_type(Person._make)  # revealed: bound method <class 'Person'>._make(iterable: Iterable[Any]) -> Self@_make
+reveal_type(Person._make)  # revealed: bound method <class 'Person'>._make(iterable: Iterable[Any]) -> Person
 reveal_type(Person._asdict)  # revealed: def _asdict(self) -> dict[str, Any]
 reveal_type(Person._replace)  # revealed: def _replace(self, **kwargs: Any) -> Self@_replace
 
@@ -304,8 +304,8 @@ satisfy:
 ```py
 def expects_named_tuple(x: typing.NamedTuple):
     reveal_type(x)  # revealed: tuple[object, ...] & NamedTupleLike
-    reveal_type(x._make)  # revealed: bound method type[NamedTupleLike]._make(iterable: Iterable[Any]) -> Self@_make
-    reveal_type(x._replace)  # revealed: bound method NamedTupleLike._replace(**kwargs) -> Self@_replace
+    reveal_type(x._make)  # revealed: bound method type[NamedTupleLike]._make(iterable: Iterable[Any]) -> NamedTupleLike
+    reveal_type(x._replace)  # revealed: bound method NamedTupleLike._replace(**kwargs) -> NamedTupleLike
     # revealed: Overload[(value: tuple[object, ...], /) -> tuple[object, ...], (value: tuple[_T@__add__, ...], /) -> tuple[object, ...]]
     reveal_type(x.__add__)
     reveal_type(x.__iter__)  # revealed: bound method tuple[object, ...].__iter__() -> Iterator[object]
@@ -328,7 +328,7 @@ class Point(NamedTuple):
     x: int
     y: int
 
-reveal_type(Point._make)  # revealed: bound method <class 'Point'>._make(iterable: Iterable[Any]) -> Self@_make
+reveal_type(Point._make)  # revealed: bound method <class 'Point'>._make(iterable: Iterable[Any]) -> Point
 reveal_type(Point._asdict)  # revealed: def _asdict(self) -> dict[str, Any]
 reveal_type(Point._replace)  # revealed: def _replace(self, **kwargs: Any) -> Self@_replace
 

crates/ty_python_semantic/src/semantic_model.rs

@@ -232,7 +232,7 @@ impl<'db> Completion<'db> {
                 | Type::BytesLiteral(_) => CompletionKind::Value,
                 Type::EnumLiteral(_) => CompletionKind::Enum,
                 Type::ProtocolInstance(_) => CompletionKind::Interface,
-                Type::TypeVar(_) => CompletionKind::TypeParameter,
+                Type::NonInferableTypeVar(_) | Type::TypeVar(_) => CompletionKind::TypeParameter,
                 Type::Union(union) => union.elements(db).iter().find_map(|&ty| imp(db, ty))?,
                 Type::Intersection(intersection) => {
                     intersection.iter_positive(db).find_map(|ty| imp(db, ty))?