[pyupgrade] Fix false negative for TypeVar with default argument in non-pep695-generic-class (UP046)

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP046_0.py

@@ -130,6 +130,14 @@ class DefaultTypeVar(Generic[V]):  # -> [V: str = Any]
     var: V
 
 
+# Test case for TypeVar with default but no bound
+W = TypeVar("W", default=int)
+
+
+class DefaultOnlyTypeVar(Generic[W]):  # -> [W = int]
+    var: W
+
+
 # nested classes and functions are skipped
 class Outer:
     class Inner(Generic[T]):

crates/ruff_linter/src/rules/pyupgrade/rules/pep695/mod.rs

@@ -122,6 +122,10 @@ impl Display for DisplayTypeVar<'_> {
                 }
             }
         }
+        if let Some(default) = self.type_var.default {
+            f.write_str(" = ")?;
+            f.write_str(&self.source[default.range()])?;
+        }
 
         Ok(())
     }
@@ -133,66 +137,62 @@ impl<'a> From<&'a TypeVar<'a>> for TypeParam {
             name,
             restriction,
             kind,
-            default: _, // TODO(brent) see below
+            default,
         }: &'a TypeVar<'a>,
     ) -> Self {
         match kind {
-            TypeParamKind::TypeVar => {
-                TypeParam::TypeVar(TypeParamTypeVar {
-                    range: TextRange::default(),
-                    node_index: ruff_python_ast::AtomicNodeIndex::NONE,
-                    name: Identifier::new(*name, TextRange::default()),
-                    bound: match restriction {
-                        Some(TypeVarRestriction::Bound(bound)) => Some(Box::new((*bound).clone())),
-                        Some(TypeVarRestriction::Constraint(constraints)) => {
-                            Some(Box::new(Expr::Tuple(ast::ExprTuple {
-                                range: TextRange::default(),
-                                node_index: ruff_python_ast::AtomicNodeIndex::NONE,
-                                elts: constraints.iter().map(|expr| (*expr).clone()).collect(),
-                                ctx: ast::ExprContext::Load,
-                                parenthesized: true,
-                            })))
-                        }
-                        Some(TypeVarRestriction::AnyStr) => {
-                            Some(Box::new(Expr::Tuple(ast::ExprTuple {
-                                range: TextRange::default(),
-                                node_index: ruff_python_ast::AtomicNodeIndex::NONE,
-                                elts: vec![
-                                    Expr::Name(ExprName {
-                                        range: TextRange::default(),
-                                        node_index: ruff_python_ast::AtomicNodeIndex::NONE,
-                                        id: Name::from("str"),
-                                        ctx: ast::ExprContext::Load,
-                                    }),
-                                    Expr::Name(ExprName {
-                                        range: TextRange::default(),
-                                        node_index: ruff_python_ast::AtomicNodeIndex::NONE,
-                                        id: Name::from("bytes"),
-                                        ctx: ast::ExprContext::Load,
-                                    }),
-                                ],
-                                ctx: ast::ExprContext::Load,
-                                parenthesized: true,
-                            })))
-                        }
-                        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,
-                })
-            }
+            TypeParamKind::TypeVar => TypeParam::TypeVar(TypeParamTypeVar {
+                range: TextRange::default(),
+                node_index: ruff_python_ast::AtomicNodeIndex::NONE,
+                name: Identifier::new(*name, TextRange::default()),
+                bound: match restriction {
+                    Some(TypeVarRestriction::Bound(bound)) => Some(Box::new((*bound).clone())),
+                    Some(TypeVarRestriction::Constraint(constraints)) => {
+                        Some(Box::new(Expr::Tuple(ast::ExprTuple {
+                            range: TextRange::default(),
+                            node_index: ruff_python_ast::AtomicNodeIndex::NONE,
+                            elts: constraints.iter().map(|expr| (*expr).clone()).collect(),
+                            ctx: ast::ExprContext::Load,
+                            parenthesized: true,
+                        })))
+                    }
+                    Some(TypeVarRestriction::AnyStr) => {
+                        Some(Box::new(Expr::Tuple(ast::ExprTuple {
+                            range: TextRange::default(),
+                            node_index: ruff_python_ast::AtomicNodeIndex::NONE,
+                            elts: vec![
+                                Expr::Name(ExprName {
+                                    range: TextRange::default(),
+                                    node_index: ruff_python_ast::AtomicNodeIndex::NONE,
+                                    id: Name::from("str"),
+                                    ctx: ast::ExprContext::Load,
+                                }),
+                                Expr::Name(ExprName {
+                                    range: TextRange::default(),
+                                    node_index: ruff_python_ast::AtomicNodeIndex::NONE,
+                                    id: Name::from("bytes"),
+                                    ctx: ast::ExprContext::Load,
+                                }),
+                            ],
+                            ctx: ast::ExprContext::Load,
+                            parenthesized: true,
+                        })))
+                    }
+                    None => None,
+                },
+                default: default.map(|expr| Box::new((*expr).clone())),
+            }),
             TypeParamKind::TypeVarTuple => TypeParam::TypeVarTuple(TypeParamTypeVarTuple {
                 range: TextRange::default(),
                 node_index: ruff_python_ast::AtomicNodeIndex::NONE,
                 name: Identifier::new(*name, TextRange::default()),
-                default: None,
+                default: default.map(|expr| Box::new((*expr).clone())),
             }),
             TypeParamKind::ParamSpec => TypeParam::ParamSpec(TypeParamParamSpec {
                 range: TextRange::default(),
                 node_index: ruff_python_ast::AtomicNodeIndex::NONE,
                 name: Identifier::new(*name, TextRange::default()),
-                default: None,
+                default: default.map(|expr| Box::new((*expr).clone())),
             }),
         }
     }
@@ -318,8 +318,8 @@ pub(crate) fn expr_name_to_type_var<'a>(
                 .first()
                 .is_some_and(Expr::is_string_literal_expr)
             {
-                // TODO(brent) `default` was added in PEP 696 and Python 3.13 but can't be used in
-                // generic type parameters before that
+                // `default` was added in PEP 696 and Python 3.13. We now support converting
+                // TypeVars with defaults to PEP 695 type parameters.
                 //
                 // ```python
                 // T = TypeVar("T", default=Any, bound=str)
@@ -373,15 +373,8 @@ fn check_type_vars(vars: Vec<TypeVar<'_>>) -> Option<Vec<TypeVar<'_>>> {
     }
 
     // If any type variables were not unique, just bail out here. this is a runtime error and we
-    // can't predict what the user wanted. also bail out if any Python 3.13+ default values are
-    // found on the type parameters
-    (vars
-        .iter()
-        .unique_by(|tvar| tvar.name)
-        .filter(|tvar| tvar.default.is_none())
-        .count()
-        == vars.len())
-    .then_some(vars)
+    // can't predict what the user wanted.
+    (vars.iter().unique_by(|tvar| tvar.name).count() == vars.len()).then_some(vars)
 }
 
 /// Search `class_bases` for a `typing.Generic` base class. Returns the `Generic` expression (if

crates/ruff_linter/src/rules/pyupgrade/snapshots/ruff_linter__rules__pyupgrade__tests__UP046_0.py.snap

@@ -280,3 +280,39 @@ UP046 Generic class `TooManyGenerics` uses `Generic` subclass instead of type pa
 100 |     var: S
     |
 help: Use type parameters
+
+UP046 [*] Generic class `DefaultTypeVar` uses `Generic` subclass instead of type parameters
+   --> UP046_0.py:129:22
+    |
+129 | class DefaultTypeVar(Generic[V]):  # -> [V: str = Any]
+    |                      ^^^^^^^^^^
+130 |     var: V
+    |
+help: Use type parameters
+126 | V = TypeVar("V", default=Any, bound=str)
+127 | 
+128 | 
+    - class DefaultTypeVar(Generic[V]):  # -> [V: str = Any]
+129 + class DefaultTypeVar[V: str = Any]:  # -> [V: str = Any]
+130 |     var: V
+131 | 
+132 | 
+note: This is an unsafe fix and may change runtime behavior
+
+UP046 [*] Generic class `DefaultOnlyTypeVar` uses `Generic` subclass instead of type parameters
+   --> UP046_0.py:137:26
+    |
+137 | class DefaultOnlyTypeVar(Generic[W]):  # -> [W = int]
+    |                          ^^^^^^^^^^
+138 |     var: W
+    |
+help: Use type parameters
+134 | W = TypeVar("W", default=int)
+135 | 
+136 | 
+    - class DefaultOnlyTypeVar(Generic[W]):  # -> [W = int]
+137 + class DefaultOnlyTypeVar[W = int]:  # -> [W = int]
+138 |     var: W
+139 | 
+140 | 
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/pyupgrade/snapshots/ruff_linter__rules__pyupgrade__tests__UP047.py.snap

@@ -116,3 +116,21 @@ help: Use type parameters
 45 | 
 46 | 
 note: This is an unsafe fix and may change runtime behavior
+
+UP047 [*] Generic function `default_var` should use type parameters
+  --> UP047.py:53:5
+   |
+53 | def default_var(v: V) -> V:
+   |     ^^^^^^^^^^^^^^^^^
+54 |     return v
+   |
+help: Use type parameters
+50 | V = TypeVar("V", default=Any, bound=str)
+51 | 
+52 | 
+   - def default_var(v: V) -> V:
+53 + def default_var[V: str = Any](v: V) -> V:
+54 |     return v
+55 | 
+56 | 
+note: This is an unsafe fix and may change runtime behavior