sql: parenthesize BETWEEN bounds by their left edge, not right edge

`Parser::parse_between` parses both bounds with
`parse_subexpr(Precedence::Like)`, starting fresh with nothing to the
bound's left. It therefore walks the bound's *left* spine and stops at the
first operator binding at or below `Like`, leaving that operator outside the
bound: `x BETWEEN 1 IS NULL AND y` parses `1` as the low bound and then
expects `AND` but finds `IS`.

`write_between_bound` decided parenthesization with `right_edge`, which
ranks the right-closing forms (`IS NULL`, `= ANY (…)`, `IN (…)`,
`a <op> ANY/ALL`) as `ATOM` because nothing binds into them *from the
right* — exactly the forms whose looseness lives on the left spine. So the
printer emitted them bare and the round trip broke (or silently
re-associated, e.g. a comparison bound rebinding the whole `BETWEEN` as its
left operand).

Switch the bound to `left_edge`, the mirror that walks the left spine, which
is the edge the parser actually consumes here. The `BETWEEN` subject keeps
`right_edge` (the `BETWEEN` keyword prints to its right). As with the rest of
the precedence model, parser-produced bounds are wrapped in `Expr::Nested`
(ranked `ATOM` on both edges), so the parser and pretty-printer datadriven
suites are unchanged — the new parens only appear for ASTs that lost their
`Nested`.

Tests: extends `between_bound_reparenthesized_after_nested_stripped` in
`sqlparser_common.rs` with the right-closing bound forms (`IS NULL`,
`= ANY`, `IN`, a boolean bound, and a left-spine operator buried under a
tighter top).

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

Author: def-

src/sql-parser/src/ast/defs/expr.rs

@@ -607,16 +607,19 @@ fn write_quantified_left<W: fmt::Write, T: AstInfo>(f: &mut AstFormatter<W>, exp
     }
 }
 
-/// Write `bound` as a `BETWEEN … AND …` bound. The parser parses both bounds at
-/// `Precedence::Like`, so a bound exposing a spine at or below `Like` on its
-/// right would re-associate out of the `BETWEEN` on reparse (`x BETWEEN a AND b =
-/// c` parses as `(x BETWEEN a AND b) = c`); such a bound must be parenthesized.
-/// Use [`right_edge`] so the decision follows right-transparent prefixes and
-/// nested infixes, not just the top operator. The parser wraps these bounds in
+/// Write `bound` as a `BETWEEN … AND …` bound. The parser parses both bounds with
+/// `parse_subexpr(Precedence::Like)` (see `Parser::parse_between`), starting fresh
+/// with nothing to the bound's left, so it walks the bound's *left spine* and
+/// stops at the first operator binding at or below `Like` — leaving that operator
+/// outside the bound (`x BETWEEN 1 IS NULL AND y` parses `1` as the bound, then
+/// expects `AND` but finds `IS`). A bound is therefore safe bare only when its
+/// left edge binds strictly above `Like`; use [`left_edge`] (not [`right_edge`],
+/// which closes at `ATOM` for the right-closing `IS NULL`/`= ANY (…)`/`IN (…)`
+/// forms whose looseness is on the left). The parser wraps these bounds in
 /// `Expr::Nested` (which is `ATOM`, so it prints bare); this re-adds the parens
 /// for ASTs where that wrapper is absent.
 fn write_between_bound<W: fmt::Write, T: AstInfo>(f: &mut AstFormatter<W>, bound: &Expr<T>) {
-    let needs_parens = right_edge(bound) <= prec::LIKE;
+    let needs_parens = left_edge(bound) <= prec::LIKE;
     if needs_parens {
         f.write_str("(");
         f.write_node(bound);

src/sql-parser/tests/sqlparser_common.rs

@@ -796,26 +796,41 @@ fn between_bound_reparenthesized_after_nested_stripped() {
         }
     }
 
-    // `false BETWEEN x AND (0 = a)` parses with the comparison high bound wrapped
-    // in `Expr::Nested` (the bound parses at `Like`, above the comparison's
-    // `Cmp`). Once the `Nested` is stripped, the printer must re-add the parens —
-    // otherwise it prints `... AND 0 = a`, which reparses as
-    // `(false BETWEEN x AND 0) = a`.
-    let mut ast = mz_sql_parser::parser::parse_statements("SELECT false BETWEEN x AND (0 = a)")
-        .unwrap()
-        .remove(0)
-        .ast;
-    StripNested.visit_statement_mut(&mut ast);
-    let displayed = ast.to_ast_string_simple();
-    let mut reparsed = mz_sql_parser::parser::parse_statements(&displayed)
-        .unwrap()
-        .remove(0)
-        .ast;
-    StripNested.visit_statement_mut(&mut reparsed);
-    assert_eq!(
-        ast, reparsed,
-        "BETWEEN bound display did not round-trip after Nested was stripped; displayed = {displayed:?}"
-    );
+    // A `BETWEEN` bound parses with `parse_subexpr(Precedence::Like)`, so a bound
+    // whose left spine binds at or below `Like` is wrapped in `Expr::Nested` by
+    // the parser. Once the `Nested` is stripped, the printer must re-add the
+    // parens, or the bound's leading operator re-associates out of the `BETWEEN`
+    // (`... AND 0 = a` reparses as `(... BETWEEN ... AND 0) = a`, and
+    // `... 1 IS NULL AND ...` makes the parser expect `AND` but find `IS`). The
+    // right-closing forms (`IS NULL`, `= ANY (…)`, `IN (…)`) are the interesting
+    // cases: their looseness is on the *left* spine, so the decision must use the
+    // left edge, not the right edge (which closes at `ATOM`).
+    for sql in [
+        "SELECT false BETWEEN x AND (0 = a)",
+        "SELECT y BETWEEN (1 IS NULL) AND z",
+        "SELECT y BETWEEN x AND (1 IS NULL)",
+        "SELECT y BETWEEN (a = ANY (ARRAY[b])) AND z",
+        "SELECT y BETWEEN (a IN (SELECT c FROM t)) AND z",
+        "SELECT y BETWEEN (a OR b) AND z",
+        // The left-spine operator is buried under a tighter top (`IN`, `Like`).
+        "SELECT y BETWEEN (a = ANY (ARRAY[b]) IN (SELECT c FROM t)) AND z",
+    ] {
+        let mut ast = mz_sql_parser::parser::parse_statements(sql)
+            .unwrap()
+            .remove(0)
+            .ast;
+        StripNested.visit_statement_mut(&mut ast);
+        let displayed = ast.to_ast_string_simple();
+        let mut reparsed = mz_sql_parser::parser::parse_statements(&displayed)
+            .unwrap()
+            .remove(0)
+            .ast;
+        StripNested.visit_statement_mut(&mut reparsed);
+        assert_eq!(
+            ast, reparsed,
+            "BETWEEN bound display did not round-trip after Nested was stripped: {sql:?} -> {displayed:?}"
+        );
+    }
 }
 
 #[mz_ore::test]