[syntax-errors] Type parameter lists before Python 3.12 (#16479)

Summary
--

Another simple one, just detect type parameter lists in functions
and classes. Like pyright, we don't emit a second diagnostic for
`type` alias statements, which were also introduced in 3.12.

Test Plan
--
Inline tests.

crates/ruff_python_parser/src/error.rs

@@ -449,6 +449,34 @@ pub enum UnsupportedSyntaxErrorKind {
     Match,
     Walrus,
     ExceptStar,
+    /// Represents the use of a [type parameter list] before Python 3.12.
+    ///
+    /// ## Examples
+    ///
+    /// Before Python 3.12, generic parameters had to be declared separately using a class like
+    /// [`typing.TypeVar`], which could then be used in a function or class definition:
+    ///
+    /// ```python
+    /// from typing import Generic, TypeVar
+    ///
+    /// T = TypeVar("T")
+    ///
+    /// def f(t: T): ...
+    /// class C(Generic[T]): ...
+    /// ```
+    ///
+    /// [PEP 695], included in Python 3.12, introduced the new type parameter syntax, which allows
+    /// these to be written more compactly and without a separate type variable:
+    ///
+    /// ```python
+    /// def f[T](t: T): ...
+    /// class C[T]: ...
+    /// ```
+    ///
+    /// [type parameter list]: https://docs.python.org/3/reference/compound_stmts.html#type-parameter-lists
+    /// [PEP 695]: https://peps.python.org/pep-0695/
+    /// [`typing.TypeVar`]: https://docs.python.org/3/library/typing.html#typevar
+    TypeParameterList,
     TypeAliasStatement,
     TypeParamDefault,
 }
@@ -459,6 +487,7 @@ impl Display for UnsupportedSyntaxError {
             UnsupportedSyntaxErrorKind::Match => "Cannot use `match` statement",
             UnsupportedSyntaxErrorKind::Walrus => "Cannot use named assignment expression (`:=`)",
             UnsupportedSyntaxErrorKind::ExceptStar => "Cannot use `except*`",
+            UnsupportedSyntaxErrorKind::TypeParameterList => "Cannot use type parameter lists",
             UnsupportedSyntaxErrorKind::TypeAliasStatement => "Cannot use `type` alias statement",
             UnsupportedSyntaxErrorKind::TypeParamDefault => {
                 "Cannot set default type for a type parameter"
@@ -480,6 +509,7 @@ impl UnsupportedSyntaxErrorKind {
             UnsupportedSyntaxErrorKind::Match => PythonVersion::PY310,
             UnsupportedSyntaxErrorKind::Walrus => PythonVersion::PY38,
             UnsupportedSyntaxErrorKind::ExceptStar => PythonVersion::PY311,
+            UnsupportedSyntaxErrorKind::TypeParameterList => PythonVersion::PY312,
             UnsupportedSyntaxErrorKind::TypeAliasStatement => PythonVersion::PY312,
             UnsupportedSyntaxErrorKind::TypeParamDefault => PythonVersion::PY313,
         }

crates/ruff_python_parser/src/parser/statement.rs

@@ -1786,6 +1786,21 @@ impl<'src> Parser<'src> {
         // x = 10
         let type_params = self.try_parse_type_params();
 
+        // test_ok function_type_params_py312
+        // # parse_options: {"target-version": "3.12"}
+        // def foo[T](): ...
+
+        // test_err function_type_params_py311
+        // # parse_options: {"target-version": "3.11"}
+        // def foo[T](): ...
+        // def foo[](): ...
+        if let Some(ast::TypeParams { range, .. }) = &type_params {
+            self.add_unsupported_syntax_error(
+                UnsupportedSyntaxErrorKind::TypeParameterList,
+                *range,
+            );
+        }
+
         // test_ok function_def_parameter_range
         // def foo(
         //     first: int,
@@ -1900,6 +1915,21 @@ impl<'src> Parser<'src> {
         // x = 10
         let type_params = self.try_parse_type_params();
 
+        // test_ok class_type_params_py312
+        // # parse_options: {"target-version": "3.12"}
+        // class Foo[S: (str, bytes), T: float, *Ts, **P]: ...
+
+        // test_err class_type_params_py311
+        // # parse_options: {"target-version": "3.11"}
+        // class Foo[S: (str, bytes), T: float, *Ts, **P]: ...
+        // class Foo[]: ...
+        if let Some(ast::TypeParams { range, .. }) = &type_params {
+            self.add_unsupported_syntax_error(
+                UnsupportedSyntaxErrorKind::TypeParameterList,
+                *range,
+            );
+        }
+
         // test_ok class_def_arguments
         // class Foo: ...
         // class Foo(): ...