Add support for PEP 696 syntax (#11120)

astral-sh · Apr 26, 2024 · cd3e319 · cd3e319
1 parent 45725d3
commit cd3e319
Show file tree

Hide file tree

Showing 49 changed files with 4,097 additions and 428 deletions.
diff --git a/crates/ruff_linter/resources/test/fixtures/pyflakes/F821_17.py b/crates/ruff_linter/resources/test/fixtures/pyflakes/F821_17.py
@@ -53,7 +53,7 @@ class WithinBody[T](list[T]):   # OK
 
     def foo(self, x: T) -> T:  # OK
         return x
-    
+
     def foo(self):
         T  # OK
 
@@ -76,28 +76,38 @@ class Foo[T: DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
 def foo[T: (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
 class Foo[T: (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
 
+# Same in defaults
+
+type Foo[T = DoesNotExist] = T  # F821: Undefined name `DoesNotExist`
+def foo[T = DoesNotExist](t: T) -> T: return t  # F821: Undefined name `DoesNotExist`
+class Foo[T = DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
+
+type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+
 # Type parameters in nested classes
 
 class Parent[T]:
     t = T   # OK
 
     def can_use_class_variable(self, x: t) -> t:  # OK
         return x
-    
+
     class Child:
         def can_access_parent_type_parameter(self, x: T) -> T:  # OK
             T  # OK
             return x
-        
+
         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
                 t # F821: Undefined name `t`
                 return x
-            
+
 # Type parameters in nested functions
 
 def can_access_inside_nested[T](t: T) -> T:  # OK
     def bar(x: T) -> T:  # OK
         T # OK
         return x
-    
+
     bar(t)
diff --git a/crates/ruff_linter/src/checkers/ast/mod.rs b/crates/ruff_linter/src/checkers/ast/mod.rs
@@ -1568,8 +1568,8 @@ impl<'a> Visitor<'a> for Checker<'a> {
         // Step 1: Binding
         match type_param {
             ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, range, .. })
-            | ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, range })
-            | ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, range }) => {
+            | ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, range, .. })
+            | ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, range, .. }) => {
                 self.add_binding(
                     name.as_str(),
                     *range,
@@ -1579,13 +1579,46 @@ impl<'a> Visitor<'a> for Checker<'a> {
             }
         }
         // Step 2: Traversal
-        if let ast::TypeParam::TypeVar(ast::TypeParamTypeVar {
-            bound: Some(bound), ..
-        }) = type_param
-        {
-            self.visit
-                .type_param_definitions
-                .push((bound, self.semantic.snapshot()));
+        match type_param {
+            ast::TypeParam::TypeVar(ast::TypeParamTypeVar {
+                bound,
+                default,
+                name: _,
+                range: _,
+            }) => {
+                if let Some(expr) = bound {
+                    self.visit
+                        .type_param_definitions
+                        .push((expr, self.semantic.snapshot()));
+                }
+                if let Some(expr) = default {
+                    self.visit
+                        .type_param_definitions
+                        .push((expr, self.semantic.snapshot()));
+                }
+            }
+            ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
+                default,
+                name: _,
+                range: _,
+            }) => {
+                if let Some(expr) = default {
+                    self.visit
+                        .type_param_definitions
+                        .push((expr, self.semantic.snapshot()));
+                }
+            }
+            ast::TypeParam::ParamSpec(ast::TypeParamParamSpec {
+                default,
+                name: _,
+                range: _,
+            }) => {
+                if let Some(expr) = default {
+                    self.visit
+                        .type_param_definitions
+                        .push((expr, self.semantic.snapshot()));
+                }
+            }
         }
     }
 

diff --git a/...er/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F821_F821_17.py.snap b/...er/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F821_F821_17.py.snap
@@ -134,7 +134,7 @@ F821_17.py:77:15: F821 Undefined name `DoesNotExist1`
 77 | class Foo[T: (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
    |               ^^^^^^^^^^^^^ F821
 78 | 
-79 | # Type parameters in nested classes
+79 | # Same in defaults
    |
 
 F821_17.py:77:30: F821 Undefined name `DoesNotExist2`
@@ -144,35 +144,117 @@ F821_17.py:77:30: F821 Undefined name `DoesNotExist2`
 77 | class Foo[T: (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
    |                              ^^^^^^^^^^^^^ F821
 78 | 
-79 | # Type parameters in nested classes
+79 | # Same in defaults
    |
 
-F821_17.py:92:52: F821 Undefined name `t`
+F821_17.py:81:14: F821 Undefined name `DoesNotExist`
    |
-90 |             return x
-91 |         
-92 |         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
-   |                                                    ^ F821
-93 |                 t # F821: Undefined name `t`
-94 |                 return x
+79 | # Same in defaults
+80 | 
+81 | type Foo[T = DoesNotExist] = T  # F821: Undefined name `DoesNotExist`
+   |              ^^^^^^^^^^^^ F821
+82 | def foo[T = DoesNotExist](t: T) -> T: return t  # F821: Undefined name `DoesNotExist`
+83 | class Foo[T = DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
    |
 
-F821_17.py:92:58: F821 Undefined name `t`
+F821_17.py:82:13: F821 Undefined name `DoesNotExist`
    |
-90 |             return x
-91 |         
-92 |         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
-   |                                                          ^ F821
-93 |                 t # F821: Undefined name `t`
-94 |                 return x
+81 | type Foo[T = DoesNotExist] = T  # F821: Undefined name `DoesNotExist`
+82 | def foo[T = DoesNotExist](t: T) -> T: return t  # F821: Undefined name `DoesNotExist`
+   |             ^^^^^^^^^^^^ F821
+83 | class Foo[T = DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
    |
 
-F821_17.py:93:17: F821 Undefined name `t`
+F821_17.py:83:15: F821 Undefined name `DoesNotExist`
    |
-92 |         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
-93 |                 t # F821: Undefined name `t`
-   |                 ^ F821
-94 |                 return x
+81 | type Foo[T = DoesNotExist] = T  # F821: Undefined name `DoesNotExist`
+82 | def foo[T = DoesNotExist](t: T) -> T: return t  # F821: Undefined name `DoesNotExist`
+83 | class Foo[T = DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
+   |               ^^^^^^^^^^^^ F821
+84 | 
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |
+
+F821_17.py:85:15: F821 Undefined name `DoesNotExist1`
+   |
+83 | class Foo[T = DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
+84 | 
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |               ^^^^^^^^^^^^^ F821
+86 | def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+87 | class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |
+
+F821_17.py:85:30: F821 Undefined name `DoesNotExist2`
+   |
+83 | class Foo[T = DoesNotExist](list[T]): ...  # F821: Undefined name `DoesNotExist`
+84 | 
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |                              ^^^^^^^^^^^^^ F821
+86 | def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+87 | class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |
+
+F821_17.py:86:14: F821 Undefined name `DoesNotExist1`
    |
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+86 | def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |              ^^^^^^^^^^^^^ F821
+87 | class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |
+
+F821_17.py:86:29: F821 Undefined name `DoesNotExist2`
+   |
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+86 | def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |                             ^^^^^^^^^^^^^ F821
+87 | class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |
+
+F821_17.py:87:16: F821 Undefined name `DoesNotExist1`
+   |
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+86 | def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+87 | class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |                ^^^^^^^^^^^^^ F821
+88 | 
+89 | # Type parameters in nested classes
+   |
+
+F821_17.py:87:31: F821 Undefined name `DoesNotExist2`
+   |
+85 | type Foo[T = (DoesNotExist1, DoesNotExist2)] = T  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+86 | def foo[T = (DoesNotExist1, DoesNotExist2)](t: T) -> T: return t  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+87 | class Foo[T = (DoesNotExist1, DoesNotExist2)](list[T]): ...  # F821: Undefined name `DoesNotExist1`, Undefined name `DoesNotExist2`
+   |                               ^^^^^^^^^^^^^ F821
+88 | 
+89 | # Type parameters in nested classes
+   |
+
+F821_17.py:102:52: F821 Undefined name `t`
+    |
+100 |             return x
+101 | 
+102 |         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
+    |                                                    ^ F821
+103 |                 t # F821: Undefined name `t`
+104 |                 return x
+    |
 
+F821_17.py:102:58: F821 Undefined name `t`
+    |
+100 |             return x
+101 | 
+102 |         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
+    |                                                          ^ F821
+103 |                 t # F821: Undefined name `t`
+104 |                 return x
+    |
 
+F821_17.py:103:17: F821 Undefined name `t`
+    |
+102 |         def cannot_access_parent_variable(self, x: t) -> t:  # F821: Undefined name `T`
+103 |                 t # F821: Undefined name `t`
+    |                 ^ F821
+104 |                 return x
+    |
diff --git a/crates/ruff_linter/src/rules/pyupgrade/rules/use_pep695_type_alias.rs b/crates/ruff_linter/src/rules/pyupgrade/rules/use_pep695_type_alias.rs
@@ -132,6 +132,9 @@ pub(crate) fn non_pep695_type_alias(checker: &mut Checker, stmt: &StmtAnnAssign)
                             }
                             None => None,
                         },
+                        // We don't handle defaults here yet. Should perhaps be a different rule since
+                        // defaults are only valid in 3.13+.
+                        default: None,
                     })
                 })
                 .collect(),

diff --git a/crates/ruff_python_ast/src/comparable.rs b/crates/ruff_python_ast/src/comparable.rs
@@ -1173,21 +1173,29 @@ impl<'a> From<&'a ast::TypeParam> for ComparableTypeParam<'a> {
             ast::TypeParam::TypeVar(ast::TypeParamTypeVar {
                 name,
                 bound,
+                default,
                 range: _,
             }) => Self::TypeVar(TypeParamTypeVar {
                 name: name.as_str(),
                 bound: bound.as_ref().map(Into::into),
+                default: default.as_ref().map(Into::into),
+            }),
+            ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
+                name,
+                default,
+                range: _,
+            }) => Self::TypeVarTuple(TypeParamTypeVarTuple {
+                name: name.as_str(),
+                default: default.as_ref().map(Into::into),
+            }),
+            ast::TypeParam::ParamSpec(ast::TypeParamParamSpec {
+                name,
+                default,
+                range: _,
+            }) => Self::ParamSpec(TypeParamParamSpec {
+                name: name.as_str(),
+                default: default.as_ref().map(Into::into),
             }),
-            ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, range: _ }) => {
-                Self::TypeVarTuple(TypeParamTypeVarTuple {
-                    name: name.as_str(),
-                })
-            }
-            ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, range: _ }) => {
-                Self::ParamSpec(TypeParamParamSpec {
-                    name: name.as_str(),
-                })
-            }
         }
     }
 }
@@ -1196,16 +1204,19 @@ impl<'a> From<&'a ast::TypeParam> for ComparableTypeParam<'a> {
 pub struct TypeParamTypeVar<'a> {
     pub name: &'a str,
     pub bound: Option<Box<ComparableExpr<'a>>>,
+    pub default: Option<Box<ComparableExpr<'a>>>,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct TypeParamParamSpec<'a> {
     pub name: &'a str,
+    pub default: Option<Box<ComparableExpr<'a>>>,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct TypeParamTypeVarTuple<'a> {
     pub name: &'a str,
+    pub default: Option<Box<ComparableExpr<'a>>>,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]