[ty] defer inference of legacy TypeVar bound/constraints/defaults

Author: carljm

crates/ty_ide/src/goto_type_definition.rs

@@ -308,26 +308,8 @@ mod tests {
             "#,
         );
 
-        assert_snapshot!(test.goto_type_definition(), @r#"
-        info[goto-type-definition]: Type definition
-         --> main.py:4:1
-          |
-        2 | from typing_extensions import TypeAliasType
-        3 |
-        4 | Alias = TypeAliasType("Alias", tuple[int, int])
-          | ^^^^^
-        5 |
-        6 | Alias
-          |
-        info: Source
-         --> main.py:6:1
-          |
-        4 | Alias = TypeAliasType("Alias", tuple[int, int])
-        5 |
-        6 | Alias
-          | ^^^^^
-          |
-        "#);
+        // TODO: This should jump to the definition of `Alias` above.
+        assert_snapshot!(test.goto_type_definition(), @"No type definitions found");
     }
 
     #[test]

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

@@ -1,5 +1,12 @@
 # Generic classes: Legacy syntax
 
+We use TypeVar defaults here, which was added in Python 3.13 for legacy typevars.
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
 ## Defining a generic class
 
 At its simplest, to define a generic class using the legacy syntax, you inherit from the

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

@@ -33,13 +33,12 @@ reveal_type(T.__name__)  # revealed: Literal["T"]
 from typing import TypeVar
 
 T = TypeVar("T")
-# TODO: no error
 # error: [invalid-legacy-type-variable]
 U: TypeVar = TypeVar("U")
 
-# error: [invalid-legacy-type-variable] "A legacy `typing.TypeVar` must be immediately assigned to a variable"
-# error: [invalid-type-form] "Function calls are not allowed in type expressions"
-TestList = list[TypeVar("W")]
+# error: [invalid-legacy-type-variable]
+tuple_with_typevar = ("foo", TypeVar("W"))
+reveal_type(tuple_with_typevar[1])  # revealed: TypeVar
 ```
 
 ### `TypeVar` parameter must match variable name
@@ -49,7 +48,7 @@ TestList = list[TypeVar("W")]
 ```py
 from typing import TypeVar
 
-# error: [invalid-legacy-type-variable] "The name of a legacy `typing.TypeVar` (`Q`) must match the name of the variable it is assigned to (`T`)"
+# error: [invalid-legacy-type-variable]
 T = TypeVar("Q")
 ```
 
@@ -66,6 +65,22 @@ T = TypeVar("T")
 T = TypeVar("T")
 ```
 
+### No variadic arguments
+
+```py
+from typing import TypeVar
+
+types = (int, str)
+
+# error: [invalid-legacy-type-variable]
+T = TypeVar("T", *types)
+reveal_type(T)  # revealed: TypeVar
+
+# error: [invalid-legacy-type-variable]
+S = TypeVar("S", **{"bound": int})
+reveal_type(S)  # revealed: TypeVar
+```
+
 ### Type variables with a default
 
 Note that the `__default__` property is only available in Python ≥3.13.
@@ -91,6 +106,11 @@ reveal_type(S.__default__)  # revealed: NoDefault
 
 ### Using other typevars as a default
 
+```toml
+[environment]
+python-version = "3.13"
+```
+
 ```py
 from typing import Generic, TypeVar, Union
 
@@ -122,6 +142,20 @@ reveal_type(T.__constraints__)  # revealed: tuple[()]
 
 S = TypeVar("S")
 reveal_type(S.__bound__)  # revealed: None
+
+from typing import TypedDict
+
+# error: [invalid-type-form]
+T = TypeVar("T", bound=TypedDict)
+```
+
+The upper bound must be a valid type expression:
+
+```py
+from typing import TypedDict
+
+# error: [invalid-type-form]
+T = TypeVar("T", bound=TypedDict)
 ```
 
 ### Type variables with constraints
@@ -138,6 +172,16 @@ S = TypeVar("S")
 reveal_type(S.__constraints__)  # revealed: tuple[()]
 ```
 
+Constraints are not simplified relative to each other, even if one is a subtype of the other:
+
+```py
+T = TypeVar("T", int, bool)
+reveal_type(T.__constraints__)  # revealed: tuple[int, bool]
+
+S = TypeVar("S", float, str)
+reveal_type(S.__constraints__)  # revealed: tuple[int | float, str]
+```
+
 ### Cannot have only one constraint
 
 > `TypeVar` supports constraining parametric types to a fixed set of possible types...There should
@@ -146,10 +190,19 @@ reveal_type(S.__constraints__)  # revealed: tuple[()]
 ```py
 from typing import TypeVar
 
-# TODO: error: [invalid-type-variable-constraints]
+# error: [invalid-legacy-type-variable]
 T = TypeVar("T", int)
 ```
 
+### Cannot have both bound and constraint
+
+```py
+from typing import TypeVar
+
+# error: [invalid-legacy-type-variable]
+T = TypeVar("T", int, str, bound=bytes)
+```
+
 ### Cannot be both covariant and contravariant
 
 > To facilitate the declaration of container types where covariant or contravariant type checking is
@@ -178,6 +231,66 @@ T = TypeVar("T", covariant=cond())
 U = TypeVar("U", contravariant=cond())
 ```
 
+### Invalid keyword arguments
+
+```py
+from typing import TypeVar
+
+# error: [invalid-legacy-type-variable]
+T = TypeVar("T", invalid_keyword=True)
+```
+
+```pyi
+from typing import TypeVar
+
+# error: [invalid-legacy-type-variable]
+T = TypeVar("T", invalid_keyword=True)
+
+```
+
+### Constructor signature versioning
+
+#### For `typing.TypeVar`
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+In a stub file, features from the latest supported Python version can be used on any version:
+
+```pyi
+from typing import TypeVar
+T = TypeVar("T", default=int)
+```
+
+But this raises an error in a non-stub file:
+
+```py
+from typing import TypeVar
+
+# error: [invalid-legacy-type-variable]
+T = TypeVar("T", default=int)
+```
+
+#### For `typing_extensions.TypeVar`
+
+`typing_extensions.TypeVar` always supports the latest features, on any Python version.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+from typing_extensions import TypeVar
+
+T = TypeVar("T", default=int)
+# TODO: should not error, should reveal `int`
+# error: [unresolved-attribute]
+reveal_type(T.__default__)  # revealed: Unknown
+```
+
 ## Callability
 
 A typevar bound to a Callable type is callable:
@@ -231,4 +344,71 @@ def constrained(x: T_constrained):
     reveal_type(type(x))  # revealed: type[int] | type[str]
 ```
 
+## Cycles
+
+### Bounds and constraints
+
+A typevar's bounds and constraints cannot be generic, cyclic or otherwise:
+
+```py
+from typing import Any, TypeVar
+
+S = TypeVar("S")
+
+# TODO: error
+T = TypeVar("T", bound=list[S])
+
+# TODO: error
+U = TypeVar("U", list["T"], str)
+
+# TODO: error
+V = TypeVar("V", list["V"], str)
+```
+
+However, they are lazily evaluated and can cyclically refer to their own type:
+
+```py
+from typing import TypeVar, Generic
+
+T = TypeVar("T", bound=list["G"])
+
+class G(Generic[T]):
+    x: T
+
+reveal_type(G[list[G]]().x)  # revealed: list[G[Unknown]]
+```
+
+### Defaults
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+Defaults can be generic, but can only refer to earlier typevars:
+
+```py
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+U = TypeVar("U", default=T)
+
+class C(Generic[T, U]):
+    x: T
+    y: U
+
+reveal_type(C[int, str]().x)  # revealed: int
+reveal_type(C[int, str]().y)  # revealed: str
+reveal_type(C[int]().x)  # revealed: int
+reveal_type(C[int]().y)  # revealed: int
+
+# TODO: error
+V = TypeVar("V", default="V")
+
+class D(Generic[V]):
+    x: V
+
+reveal_type(D().x)  # revealed: V@D
+```
+
 [generics]: https://typing.python.org/en/latest/spec/generics.html

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -197,9 +197,9 @@ from typing_extensions import TypeAliasType, TypeVar
 
 T = TypeVar("T")
 
-IntAnd = TypeAliasType("IntAndT", tuple[int, T], type_params=(T,))
+IntAndT = TypeAliasType("IntAndT", tuple[int, T], type_params=(T,))
 
-def f(x: IntAnd[str]) -> None:
+def f(x: IntAndT[str]) -> None:
     reveal_type(x)  # revealed: @Todo(Generic manual PEP-695 type alias)
 ```
 

crates/ty_python_semantic/src/ast_node_ref.rs

@@ -30,7 +30,7 @@ use ruff_text_size::Ranged;
 /// This means that changes to expressions in other scopes don't invalidate the expression's id, giving
 /// us some form of scope-stable identity for expressions. Only queries accessing the node field
 /// run on every AST change. All other queries only run when the expression's identity changes.
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct AstNodeRef<T> {
     /// The index of the node in the AST.
     index: NodeIndex,
@@ -40,15 +40,14 @@ pub struct AstNodeRef<T> {
     kind: ruff_python_ast::NodeKind,
     #[cfg(debug_assertions)]
     range: ruff_text_size::TextRange,
-    // Note that because the module address is not stored in release builds, `AstNodeRef`
-    // cannot implement `Eq`, as indices are only unique within a given instance of the
-    // AST.
     #[cfg(debug_assertions)]
     module_addr: usize,
 
     _node: PhantomData<T>,
 }
 
+impl<T> Eq for AstNodeRef<T> where T: PartialEq {}
+
 impl<T> AstNodeRef<T> {
     pub(crate) fn index(&self) -> NodeIndex {
         self.index

crates/ty_python_semantic/src/semantic_index/builder.rs

@@ -1165,10 +1165,6 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> {
         target: &'ast ast::Expr,
         value: Expression<'db>,
     ) {
-        // We only handle assignments to names and unpackings here, other targets like
-        // attribute and subscript are handled separately as they don't create a new
-        // definition.
-
         let current_assignment = match target {
             ast::Expr::List(_) | ast::Expr::Tuple(_) => {
                 if matches!(unpackable, Unpackable::Comprehension { .. }) {
@@ -1628,10 +1624,22 @@ impl<'ast> Visitor<'ast> for SemanticIndexBuilder<'_, 'ast> {
                 debug_assert_eq!(&self.current_assignments, &[]);
 
                 self.visit_expr(&node.value);
-                let value = self.add_standalone_assigned_expression(&node.value, node);
 
-                for target in &node.targets {
-                    self.add_unpackable_assignment(&Unpackable::Assign(node), target, value);
+                // Optimization for the common case: if there's just one target, and it's not an
+                // unpacking, and the target is a simple name, we don't need the RHS to be a
+                // standalone expression at all.
+                if let [target] = &node.targets[..]
+                    && target.is_name_expr()
+                {
+                    self.push_assignment(CurrentAssignment::Assign { node, unpack: None });
+                    self.visit_expr(target);
+                    self.pop_assignment();
+                } else {
+                    let value = self.add_standalone_assigned_expression(&node.value, node);
+
+                    for target in &node.targets {
+                        self.add_unpackable_assignment(&Unpackable::Assign(node), target, value);
+                    }
                 }
             }
             ast::Stmt::AnnAssign(node) => {

crates/ty_python_semantic/src/semantic_index/definition.rs

@@ -706,13 +706,6 @@ impl DefinitionKind<'_> {
         matches!(self, DefinitionKind::Assignment(_))
     }
 
-    pub(crate) fn as_typevar(&self) -> Option<&AstNodeRef<ast::TypeParamTypeVar>> {
-        match self {
-            DefinitionKind::TypeVar(type_var) => Some(type_var),
-            _ => None,
-        }
-    }
-
     /// Returns the [`TextRange`] of the definition target.
     ///
     /// A definition target would mainly be the node representing the place being defined i.e.,