stop the postfix !/^ operators from clobbering conversions and xor

in `.py` mode a glued `a^-b` parsed as the basedpython postfix propagate
operator rather than infix xor, and an f-string conversion after a ternary
(`f"{a if b else c!s}"`) lost the interpolation context so its `!` was eaten
as force-unwrap. both turned valid python into parse errors, which tipped the
formatter ecosystem check past its allowed input-error count.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: KotlinIsland

crates/ruff_python_parser/src/parser/expression.rs

@@ -289,7 +289,7 @@ impl<'src> Parser<'src> {
             let parsed_expr = self.parse_simple_expression(context);
 
             if self.at(TokenKind::If) {
-                Expr::If(self.parse_if_expression(parsed_expr.expr, start)).into()
+                Expr::If(self.parse_if_expression(parsed_expr.expr, start, context)).into()
             } else {
                 parsed_expr
             }
@@ -1108,15 +1108,18 @@ impl<'src> Parser<'src> {
                 // basedpython postfix `^` propagate. `^` is otherwise the infix
                 // bitwise-xor operator, so it is only postfix when no operand
                 // follows; an operand on the right means it is xor (left for the
-                // binary loop). exception: a `^` *glued* to its operand (no
-                // whitespace, as one writes `expr^`) followed by a unary-capable
-                // arithmetic token (`+ - ~ * **`) is postfix-then-binary
-                // (`p(a)^ + b` → `(p(a)^) + b`), not xor-of-unary — the spaced
-                // form `a ^ -b` stays xor.
+                // binary loop). exception: in basedpython a `^` *glued* to its
+                // operand (no whitespace, as one writes `expr^`) followed by a
+                // unary-capable arithmetic token (`+ - ~ * **`) is
+                // postfix-then-binary (`p(a)^ + b` → `(p(a)^) + b`), not
+                // xor-of-unary. that disambiguation must not apply in `.py` mode,
+                // where glued `a^-b` is plain `a ^ (-b)` — stealing it would make
+                // valid python a syntax error.
                 TokenKind::CircumFlex
                     if self.options.mode != Mode::Ipython
                         && (!(EXPR_SET.contains(self.peek()) || self.peek().is_soft_keyword())
-                            || (lhs.range().end() == self.current_token_range().start()
+                            || (self.options.is_basedpython
+                                && lhs.range().end() == self.current_token_range().start()
                                 && matches!(
                                     self.peek(),
                                     TokenKind::Plus
@@ -4342,18 +4345,34 @@ impl<'src> Parser<'src> {
     /// If the parser isn't positioned at an `if` token.
     ///
     /// See: <https://docs.python.org/3/reference/expressions.html#conditional-expressions>
-    pub(super) fn parse_if_expression(&mut self, body: Expr, start: TextSize) -> ast::ExprIf {
+    pub(super) fn parse_if_expression(
+        &mut self,
+        body: Expr,
+        start: TextSize,
+        context: ExpressionContext,
+    ) -> ast::ExprIf {
         self.bump(TokenKind::If);
 
         let test = self.parse_simple_expression(ExpressionContext::default());
 
         self.expect(TokenKind::Else);
 
+        // the `else` value is the tail of the conditional, so a trailing
+        // interpolation conversion (`f"{a if b else c!s}"`) lands here — carry
+        // only the interpolation flag so the `!` stays the conversion flag
+        // rather than being eaten as a postfix force-unwrap. the other context
+        // flags (excluded `in`/`for`, starred precedence, …) must not leak into
+        // the `else` value, which otherwise parses as an ordinary expression.
+        let orelse_context = if context.is_in_interpolation() {
+            ExpressionContext::default().with_in_interpolation()
+        } else {
+            ExpressionContext::default()
+        };
         // `a if b else a if b else ...` recurses through `orelse` at the
         // conditional layer, which is not covered by the `parse_lhs_expression`
         // guard (that scope is released once each atom is parsed). Guard here.
         let orelse = if let Some(orelse) =
-            self.with_recursion(Self::parse_conditional_expression_or_higher)
+            self.with_recursion(|p| p.parse_conditional_expression_or_higher_impl(orelse_context))
         {
             orelse
         } else {

crates/ruff_python_parser/src/parser/tests.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{ModModule, Stmt};
+use ruff_python_ast::{Expr, ModModule, Operator, Stmt, UnaryOp};
 
 use crate::{Mode, ParseErrorType, ParseOptions, Parsed, parse, parse_expression, parse_module};
 
@@ -414,6 +414,80 @@ fn test_top_star_subscript_in_py_errors() {
     );
 }
 
+#[test]
+fn glued_circumflex_before_unary_is_xor_in_py() {
+    // `a^-b`, `a^+b`, `a^~b` are valid standard Python — `a ^ (-b)` and friends.
+    // basedpython reads a glued `^` before a unary sign as the postfix propagate
+    // operator (`(a^) - b`), but that disambiguation must stay off in `.py`
+    // mode: stealing it turns valid python into a parse error, which the
+    // formatter ecosystem check (it parses `.py` with basedpython disabled)
+    // counts as a syntax error and trips over.
+    for source in ["a^-b\n", "a^+b\n", "a^~b\n"] {
+        let parsed = crate::parse_unchecked(source, ParseOptions::from(Mode::Module));
+        assert!(
+            parsed.errors().is_empty(),
+            "expected {source:?} to parse cleanly in .py mode, got: {:?}",
+            parsed.errors()
+        );
+        let module = parsed.try_into_module().unwrap();
+        let Some(Stmt::Expr(stmt)) = module.suite().first() else {
+            panic!("expected an expression statement for {source:?}");
+        };
+        let Expr::BinOp(binop) = &*stmt.value else {
+            panic!(
+                "expected `a ^ <unary>` for {source:?}, got {:?}",
+                stmt.value
+            );
+        };
+        assert_eq!(binop.op, Operator::BitXor, "operator for {source:?}");
+        assert!(
+            matches!(&*binop.right, Expr::UnaryOp(_)),
+            "rhs of {source:?} should be the unary operand, got {:?}",
+            binop.right
+        );
+    }
+
+    // the same glued source keeps its basedpython meaning in `.by`: a postfix
+    // propagate followed by a binary subtract, i.e. `(a^) - b`
+    let parsed = parse_basedpython_module("a^-b\n");
+    let Some(Stmt::Expr(stmt)) = parsed.syntax().body.first() else {
+        panic!("expected an expression statement");
+    };
+    let Expr::BinOp(binop) = &*stmt.value else {
+        panic!("expected a binary op, got {:?}", stmt.value);
+    };
+    assert_eq!(binop.op, Operator::Sub);
+    assert!(
+        matches!(&*binop.left, Expr::UnaryOp(unary) if unary.op == UnaryOp::Propagate),
+        "lhs should be the postfix propagate, got {:?}",
+        binop.left
+    );
+}
+
+#[test]
+fn fstring_conversion_after_ternary_is_not_force_unwrap() {
+    // the `!s` / `!r` in an interpolation is the conversion flag, not the
+    // basedpython postfix force-unwrap. for a conditional the conversion lands
+    // on the `else` tail, which must inherit the interpolation context so the
+    // `!` isn't eaten as force-unwrap. regression: poetry's
+    // `f"{p if not W else g(p)!s}"` became a spurious `.py` syntax error and
+    // tipped the formatter ecosystem check over its allowed error count.
+    for source in [
+        r#"f"{a if b else c!s}""#,
+        r#"f"{a if b else c!r:>{w}}""#,
+        r#"f"{a if b else c if d else e!s}""#,
+        r#"f"{x!r}""#,
+        r#"f"{a + b!s}""#,
+    ] {
+        let parsed = crate::parse_unchecked(source, ParseOptions::from(Mode::Module));
+        assert!(
+            parsed.errors().is_empty(),
+            "expected {source:?} to parse cleanly in .py mode, got: {:?}",
+            parsed.errors()
+        );
+    }
+}
+
 #[test]
 fn recursion_limit_nested_parens() {
     let src = format!("{}1{}", "(".repeat(1_000), ")".repeat(1_000));