[pyupgrade] Add rules to use PEP 695 generics in classes and functions (UP046, UP047)

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

@@ -0,0 +1,80 @@
+from typing import Any, AnyStr, Generic, ParamSpec, TypeVar, TypeVarTuple
+
+S = TypeVar("S", str, bytes)  # constrained type variable
+T = TypeVar("T", bound=float)
+Ts = TypeVarTuple("Ts")
+P = ParamSpec("P")
+
+
+class A(Generic[T]):
+    # Comments in a class body are preserved
+    pass
+
+
+class B(Generic[*Ts]):
+    pass
+
+
+class C(Generic[P]):
+    pass
+
+
+class Constrained(Generic[S]):
+    pass
+
+
+# This case gets a diagnostic but not a fix because we can't look up the bounds
+# or constraints on the generic type from another module
+class ExternalType(Generic[T, SupportsRichComparisonT]):
+    pass
+
+
+# typing.AnyStr is a common external type variable, so treat it specially as a
+# known TypeVar
+class MyStr(Generic[AnyStr]):
+    pass
+
+
+class MultipleGenerics(Generic[S, T, Ts, P]):
+    pass
+
+
+# These cases are not handled
+class D(Generic[T, T]):  # duplicate generic variable, runtime error
+    pass
+
+
+# TODO(brent) we should also apply the fix to methods, but it will need a
+# little more work. these should be left alone for now but be fixed eventually.
+class NotGeneric:
+    # -> generic_method[T: float](t: T)
+    def generic_method(t: T):
+        pass
+
+
+# This one is strange in particular because of the mix of old- and new-style
+# generics, but according to the PEP, this is okay "if the class, function, or
+# type alias does not use the new syntax." `more_generic` doesn't use the new
+# syntax, so it can use T from the module and U from the class scope.
+class MixedGenerics[U]:
+    def more_generic(u: U, t: T):
+        pass
+
+
+# TODO(brent) we should also handle multiple base classes
+class Multiple(NotGeneric, Generic[T]):
+    pass
+
+
+# TODO(brent) default requires 3.13
+V = TypeVar("V", default=Any, bound=str)
+
+
+class DefaultTypeVar(Generic[V]):  # -> [V: str = Any]
+    pass
+
+
+# nested classes and functions are skipped
+class Outer:
+    class Inner(Generic[T]):
+        pass

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

@@ -0,0 +1,59 @@
+from collections.abc import Callable
+from typing import Any, AnyStr, ParamSpec, TypeVar, TypeVarTuple
+
+from somewhere import Something
+
+S = TypeVar("S", str, bytes)  # constrained type variable
+T = TypeVar("T", bound=float)
+Ts = TypeVarTuple("Ts")
+P = ParamSpec("P")
+
+
+def f(t: T):
+    pass
+
+
+def g(ts: tuple[*Ts]):
+    pass
+
+
+def h(
+    p: Callable[P, T],
+    # Comment in the middle of a parameter list should be preserved
+    another_param,
+    and_another,
+):
+    pass
+
+
+def i(s: S):
+    pass
+
+
+# NOTE this case is the reason the fix is marked unsafe. If we can't confirm
+# that one of the type parameters (`Something` in this case) is a TypeVar,
+# which we can't do across module boundaries, we will not convert it to a
+# generic type parameter. This leads to code that mixes old-style standalone
+# TypeVars with the new-style generic syntax and will be rejected by type
+# checkers
+def broken_fix(okay: T, bad: Something):
+    pass
+
+
+def any_str_param(s: AnyStr):
+    pass
+
+
+# these cases are not handled
+
+# TODO(brent) default requires 3.13
+V = TypeVar("V", default=Any, bound=str)
+
+
+def default_var(v: V):
+    pass
+
+
+def outer():
+    def inner(t: T):
+        pass

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -376,6 +376,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::PytestParameterWithDefaultArgument) {
                 flake8_pytest_style::rules::parameter_with_default_argument(checker, function_def);
             }
+            if checker.enabled(Rule::NonPEP695GenericFunction) {
+                pyupgrade::rules::non_pep695_generic_function(checker, function_def);
+            }
         }
         Stmt::Return(_) => {
             if checker.enabled(Rule::ReturnOutsideFunction) {
@@ -554,6 +557,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::DataclassEnum) {
                 ruff::rules::dataclass_enum(checker, class_def);
             }
+            if checker.enabled(Rule::NonPEP695GenericClass) {
+                pyupgrade::rules::non_pep695_generic_class(checker, class_def);
+            }
         }
         Stmt::Import(ast::StmtImport { names, range: _ }) => {
             if checker.enabled(Rule::MultipleImportsOnOneLine) {

crates/ruff_linter/src/codes.rs

@@ -540,6 +540,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pyupgrade, "043") => (RuleGroup::Stable, rules::pyupgrade::rules::UnnecessaryDefaultTypeArgs),
         (Pyupgrade, "044") => (RuleGroup::Preview, rules::pyupgrade::rules::NonPEP646Unpack),
         (Pyupgrade, "045") => (RuleGroup::Preview, rules::pyupgrade::rules::NonPEP604AnnotationOptional),
+        (Pyupgrade, "046") => (RuleGroup::Preview, rules::pyupgrade::rules::NonPEP695GenericClass),
+        (Pyupgrade, "047") => (RuleGroup::Preview, rules::pyupgrade::rules::NonPEP695GenericFunction),
 
         // pydocstyle
         (Pydocstyle, "100") => (RuleGroup::Stable, rules::pydocstyle::rules::UndocumentedPublicModule),

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

@@ -103,6 +103,8 @@ mod tests {
     #[test_case(Rule::YieldInForLoop, Path::new("UP028_1.py"))]
     #[test_case(Rule::NonPEP695TypeAlias, Path::new("UP040.py"))]
     #[test_case(Rule::NonPEP695TypeAlias, Path::new("UP040.pyi"))]
+    #[test_case(Rule::NonPEP695GenericClass, Path::new("UP046.py"))]
+    #[test_case(Rule::NonPEP695GenericFunction, Path::new("UP047.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = path.to_string_lossy().to_string();
         let diagnostics = test_path(

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

@@ -14,6 +14,7 @@ pub(crate) use native_literals::*;
 pub(crate) use open_alias::*;
 pub(crate) use os_error_alias::*;
 pub(crate) use outdated_version_block::*;
+pub(crate) use pep695::*;
 pub(crate) use printf_string_formatting::*;
 pub(crate) use quoted_annotation::*;
 pub(crate) use redundant_open_modes::*;
@@ -36,7 +37,6 @@ pub(crate) use use_pep585_annotation::*;
 pub(crate) use use_pep604_annotation::*;
 pub(crate) use use_pep604_isinstance::*;
 pub(crate) use use_pep646_unpack::*;
-pub(crate) use use_pep695_type_alias::*;
 pub(crate) use useless_metaclass_type::*;
 pub(crate) use useless_object_inheritance::*;
 pub(crate) use yield_in_for_loop::*;
@@ -57,6 +57,7 @@ mod native_literals;
 mod open_alias;
 mod os_error_alias;
 mod outdated_version_block;
+mod pep695;
 mod printf_string_formatting;
 mod quoted_annotation;
 mod redundant_open_modes;
@@ -79,7 +80,6 @@ mod use_pep585_annotation;
 mod use_pep604_annotation;
 mod use_pep604_isinstance;
 mod use_pep646_unpack;
-mod use_pep695_type_alias;
 mod useless_metaclass_type;
 mod useless_object_inheritance;
 mod yield_in_for_loop;