Consider binary expr for parenthesized with items parsing

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

@@ -0,0 +1,10 @@
+# It doesn't matter what's inside the parentheses, these tests need to make sure
+# all binary expressions parses correctly.
+with (a) and b: ...
+with (a) is not b: ...
+# Make sure precedence works
+with (a) or b and c: ...
+with (a) and b or c: ...
+with (a | b) << c | d: ...
+# Postfix should still be parsed first
+with (a)[0] + b * c: ...

crates/ruff_python_parser/src/parser/expression.rs

@@ -347,8 +347,18 @@ impl<'src> Parser<'src> {
     /// [Pratt parsing algorithm]: https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html
     fn parse_expression_with_precedence(&mut self, previous_precedence: Precedence) -> ParsedExpr {
         let start = self.node_start();
-        let mut lhs = self.parse_lhs_expression(previous_precedence);
+        let lhs = self.parse_lhs_expression(previous_precedence);
+        self.parse_expression_with_precedence_recursive(lhs, previous_precedence, start)
+    }
 
+    /// Parses an expression with binding power of at least `previous_precedence` given the
+    /// left-hand side expression.
+    pub(super) fn parse_expression_with_precedence_recursive(
+        &mut self,
+        mut lhs: ParsedExpr,
+        previous_precedence: Precedence,
+        start: TextSize,
+    ) -> ParsedExpr {
         let mut progress = ParserProgress::default();
 
         loop {
@@ -2498,7 +2508,7 @@ enum Associativity {
 ///
 /// See: <https://docs.python.org/3/reference/expressions.html#operator-precedence>
 #[derive(Debug, Ord, Eq, PartialEq, PartialOrd, Copy, Clone)]
-enum Precedence {
+pub(super) enum Precedence {
     /// Precedence for an unknown operator.
     Unknown,
     /// The initital precedence when parsing an expression.

crates/ruff_python_parser/src/parser/statement.rs

@@ -17,7 +17,7 @@ use crate::parser::{
 use crate::token_set::TokenSet;
 use crate::{Mode, ParseErrorType, Tok, TokenKind};
 
-use super::expression::{AllowNamedExpression, AllowStarredExpression};
+use super::expression::{AllowNamedExpression, AllowStarredExpression, Precedence};
 use super::Parenthesized;
 
 /// Tokens that represent compound statements.
@@ -2147,15 +2147,31 @@ impl<'src> Parser<'src> {
             // expressions.
             lhs = self.parse_postfix_expression(lhs, start);
 
-            // test_ok ambiguous_lpar_with_items_if_expr
-            // with (x) if True else y: ...
-            // with (x for x in iter) if True else y: ...
-            // with (x async for x in iter) if True else y: ...
-            // with (x)[0] if True else y: ...
             let context_expr = if self.at(TokenKind::If) {
+                // test_ok ambiguous_lpar_with_items_if_expr
+                // with (x) if True else y: ...
+                // with (x for x in iter) if True else y: ...
+                // with (x async for x in iter) if True else y: ...
+                // with (x)[0] if True else y: ...
                 Expr::If(self.parse_if_expression(lhs, start))
             } else {
-                lhs
+                // test_ok ambiguous_lpar_with_items_binary_expr
+                // # It doesn't matter what's inside the parentheses, these tests need to make sure
+                // # all binary expressions parses correctly.
+                // with (a) and b: ...
+                // with (a) is not b: ...
+                // # Make sure precedence works
+                // with (a) or b and c: ...
+                // with (a) and b or c: ...
+                // with (a | b) << c | d: ...
+                // # Postfix should still be parsed first
+                // with (a)[0] + b * c: ...
+                self.parse_expression_with_precedence_recursive(
+                    lhs.into(),
+                    Precedence::Initial,
+                    start,
+                )
+                .expr
             };
 
             let optional_vars = self