[syntax-errors] Star expression in index before Python 3.11 (#16544)

Summary
--

This PR detects tuple unpacking expressions in index/subscript
expressions before Python 3.11.

Test Plan
--

New inline tests

Author: ntBre

crates/ruff_python_parser/resources/inline/err/star_index_py310.py

@@ -0,0 +1,7 @@
+# parse_options: {"target-version": "3.10"}
+lst[*index]  # simple index
+class Array(Generic[DType, *Shape]): ...  # motivating example from the PEP
+lst[a, *b, c]  # different positions
+lst[a, b, *c]  # different positions
+lst[*a, *b]  # multiple unpacks
+array[3:5, *idxs]  # mixed with slices

crates/ruff_python_parser/resources/inline/err/star_slices.py

@@ -0,0 +1 @@
+array[*start:*end]

crates/ruff_python_parser/resources/inline/ok/star_index_py311.py

@@ -0,0 +1,7 @@
+# parse_options: {"target-version": "3.11"}
+lst[*index]  # simple index
+class Array(Generic[DType, *Shape]): ...  # motivating example from the PEP
+lst[a, *b, c]  # different positions
+lst[a, b, *c]  # different positions
+lst[*a, *b]  # multiple unpacks
+array[3:5, *idxs]  # mixed with slices

crates/ruff_python_parser/src/error.rs

@@ -617,6 +617,33 @@ pub enum UnsupportedSyntaxErrorKind {
     TypeAliasStatement,
     TypeParamDefault,
 
+    /// Represents the use of a [PEP 646] star expression in an index.
+    ///
+    /// ## Examples
+    ///
+    /// Before Python 3.11, star expressions were not allowed in index/subscript operations (within
+    /// square brackets). This restriction was lifted in [PEP 646] to allow for star-unpacking of
+    /// `typing.TypeVarTuple`s, also added in Python 3.11. As such, this is the primary motivating
+    /// example from the PEP:
+    ///
+    /// ```python
+    /// from typing import TypeVar, TypeVarTuple
+    ///
+    /// DType = TypeVar('DType')
+    /// Shape = TypeVarTuple('Shape')
+    ///
+    /// class Array(Generic[DType, *Shape]): ...
+    /// ```
+    ///
+    /// But it applies to simple indexing as well:
+    ///
+    /// ```python
+    /// vector[*x]
+    /// array[a, *b]
+    /// ```
+    ///
+    /// [PEP 646]: https://peps.python.org/pep-0646/#change-1-star-expressions-in-indexes
+    StarExpressionInIndex,
     /// Represents the use of tuple unpacking in a `for` statement iterator clause before Python
     /// 3.9.
     ///
@@ -669,6 +696,9 @@ impl Display for UnsupportedSyntaxError {
             UnsupportedSyntaxErrorKind::TypeParamDefault => {
                 "Cannot set default type for a type parameter"
             }
+            UnsupportedSyntaxErrorKind::StarExpressionInIndex => {
+                "Cannot use star expression in index"
+            }
             UnsupportedSyntaxErrorKind::UnparenthesizedUnpackInFor => {
                 "Cannot use iterable unpacking in `for` statements"
             }
@@ -717,6 +747,9 @@ impl UnsupportedSyntaxErrorKind {
             UnsupportedSyntaxErrorKind::TypeParameterList => Change::Added(PythonVersion::PY312),
             UnsupportedSyntaxErrorKind::TypeAliasStatement => Change::Added(PythonVersion::PY312),
             UnsupportedSyntaxErrorKind::TypeParamDefault => Change::Added(PythonVersion::PY313),
+            UnsupportedSyntaxErrorKind::StarExpressionInIndex => {
+                Change::Added(PythonVersion::PY311)
+            }
             UnsupportedSyntaxErrorKind::UnparenthesizedUnpackInFor => {
                 Change::Added(PythonVersion::PY39)
             }

crates/ruff_python_parser/src/parser/expression.rs

@@ -853,6 +853,35 @@ impl<'src> Parser<'src> {
 
         self.expect(TokenKind::Rsqb);
 
+        // test_ok star_index_py311
+        // # parse_options: {"target-version": "3.11"}
+        // lst[*index]  # simple index
+        // class Array(Generic[DType, *Shape]): ...  # motivating example from the PEP
+        // lst[a, *b, c]  # different positions
+        // lst[a, b, *c]  # different positions
+        // lst[*a, *b]  # multiple unpacks
+        // array[3:5, *idxs]  # mixed with slices
+
+        // test_err star_index_py310
+        // # parse_options: {"target-version": "3.10"}
+        // lst[*index]  # simple index
+        // class Array(Generic[DType, *Shape]): ...  # motivating example from the PEP
+        // lst[a, *b, c]  # different positions
+        // lst[a, b, *c]  # different positions
+        // lst[*a, *b]  # multiple unpacks
+        // array[3:5, *idxs]  # mixed with slices
+
+        // test_err star_slices
+        // array[*start:*end]
+        if let Expr::Tuple(ast::ExprTuple { elts, .. }) = &slice {
+            for elt in elts.iter().filter(|elt| elt.is_starred_expr()) {
+                self.add_unsupported_syntax_error(
+                    UnsupportedSyntaxErrorKind::StarExpressionInIndex,
+                    elt.range(),
+                );
+            }
+        };
+
         ast::ExprSubscript {
             value: Box::new(value),
             slice: Box::new(slice),