Complete PEP 798 unpacking operands and diagnostics

crates/ruff_python_parser/resources/invalid/expressions/pep798_boolean_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+(*x or y for x in z); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_call_conditional_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+f(*x if c else y for x in z); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_comparison_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+(*x < y for x in z); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_conditional_display.py

@@ -0,0 +1,5 @@
+# parse_options: {"target-version": "3.15"}
+[*x if x else y]
+{**x if x else y}
+[x if x else *y]
+{x if x else **y}

crates/ruff_python_parser/resources/invalid/expressions/pep798_conditional_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+(*x if c else y for x in z); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_dict_positions.py

@@ -0,0 +1,8 @@
+# parse_options: {"target-version": "3.15"}
+[**x for x in xs]
+(**x for x in xs)
+f(**x for x in xs)
+{*x: y for x in xs}
+{**x: y for x in xs}
+{x: *y for x in xs}
+{x: **y for x in xs}

crates/ruff_python_parser/resources/invalid/expressions/pep798_lambda_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+(*lambda: x for x in z); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_missing_operand.py

@@ -0,0 +1,5 @@
+# parse_options: {"target-version": "3.15"}
+[**]
+(**)
+[**, x]
+[** for x in z]

crates/ruff_python_parser/resources/invalid/expressions/pep798_nested_conditional_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+(*(*x if c else y for x in xs) if d else z for z in zs); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_nested_operand.py

@@ -0,0 +1,3 @@
+# parse_options: {"target-version": "3.15"}
+[**(x if x else *y) for x in z]
+(**(x if x else **y) for x in z)

crates/ruff_python_parser/resources/invalid/expressions/pep798_nested_then_error.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.15"}
+(*(*x or y for x in z) for z in zs); a =

crates/ruff_python_parser/resources/invalid/expressions/pep798_soft_keyword_operand.py

@@ -0,0 +1,4 @@
+# parse_options: {"target-version": "3.15"}
+[**match]
+[**case]
+[**type]

crates/ruff_python_parser/resources/valid/expressions/pep798_unpacking_operands.py

@@ -0,0 +1,16 @@
+# parse_options: {"target-version": "3.15"}
+{**x if c else y for x in xs}
+{**x or y for x in xs}
+{**x < y for x in xs}
+{**lambda: x for x in xs}
+(*x if c else y for x in xs)
+(*x or y for x in xs)
+(*x < y for x in xs)
+(*lambda: x for x in xs)
+f(*x if c else y for x in xs)
+f(*x if c else y)
+(*(*x or y for x in z) for z in zs)
+async def unpack(xs):
+    return {**x if c else y async for x in xs}
+async def iterate(xs):
+    return (*x if c else y async for x in xs)

crates/ruff_python_parser/src/error.rs

@@ -224,6 +224,18 @@ pub enum ParseErrorType {
     InvalidYieldExpressionUsage,
     /// An invalid usage of a starred expression was found.
     InvalidStarredExpressionUsage,
+    /// An unpacked conditional expression is missing parentheses.
+    InvalidConditionalUnpacking { double_starred: bool },
+    /// Only the else branch of a conditional expression is unpacked.
+    InvalidConditionalBranchUnpacking { double_starred: bool },
+    /// Dictionary unpacking is used in a list or generator comprehension.
+    InvalidComprehensionDictUnpacking { generator: bool },
+    /// An unpacked expression is used as a dictionary key.
+    InvalidDictKeyUnpacking { double_starred: bool },
+    /// An unpacked expression is used as a dictionary value.
+    InvalidDictValueUnpacking { double_starred: bool },
+    /// Dictionary unpacking is used outside a dictionary or call argument.
+    InvalidDictUnpacking,
     /// A star pattern was found outside a sequence pattern.
     InvalidStarPatternUsage,
     /// An underscore was used as a binding target in a match pattern.
@@ -538,6 +550,49 @@ impl std::fmt::Display for ParseErrorType {
             ParseErrorType::InvalidLambdaExpressionUsage => {
                 f.write_str("lambda expression cannot be used here")
             }
+            ParseErrorType::InvalidConditionalUnpacking { double_starred } => {
+                let kind = if *double_starred {
+                    "double starred"
+                } else {
+                    "starred"
+                };
+                write!(
+                    f,
+                    "invalid {kind} expression. Did you forget to wrap the conditional expression in parentheses?"
+                )
+            }
+            ParseErrorType::InvalidConditionalBranchUnpacking { double_starred } => {
+                if *double_starred {
+                    f.write_str(
+                        "cannot use dict unpacking on only part of a conditional expression",
+                    )
+                } else {
+                    f.write_str("cannot unpack only part of a conditional expression")
+                }
+            }
+            ParseErrorType::InvalidComprehensionDictUnpacking { generator } => {
+                let kind = if *generator {
+                    "generator expression"
+                } else {
+                    "list comprehension"
+                };
+                write!(f, "cannot use dict unpacking in {kind}")
+            }
+            ParseErrorType::InvalidDictKeyUnpacking { double_starred }
+            | ParseErrorType::InvalidDictValueUnpacking { double_starred } => {
+                let kind = if *double_starred {
+                    "dict unpacking"
+                } else {
+                    "a starred expression"
+                };
+                let position = if matches!(self, ParseErrorType::InvalidDictKeyUnpacking { .. }) {
+                    "key"
+                } else {
+                    "value"
+                };
+                write!(f, "cannot use {kind} in a dictionary {position}")
+            }
+            ParseErrorType::InvalidDictUnpacking => f.write_str("cannot use dict unpacking here"),
             ParseErrorType::InvalidStarredExpressionUsage => f.write_str("invalid syntax"),
             ParseErrorType::PositionalAfterKeywordArgument => {
                 f.write_str("positional argument follows keyword argument")