sql: parenthesize quantified-subquery receivers of .field/.*

`write_dot_receiver` listed `AnySubquery`/`AllSubquery` as safe `.` receivers,
but they print as `<expr> <op> ANY/ALL (<query>)` — the trailing `(<query>)`
is only a sub-part of the expression, so a following `.x`/`.*` binds to that
inner subquery rather than the whole quantified comparison. Printed bare, a
`Nested`-stripped `FieldAccess`/`WildcardAccess` over one of these re-associated
on reparse (`(a = ANY (SELECT b FROM t)).c` -> `a = ANY (SELECT b FROM t).c`),
which also surfaced inside `BETWEEN` bounds as an `Expected AND` parse error.

Drop both from the safe set so they are parenthesized. The single-primary
subquery forms (`Subquery`, `ArraySubquery`, `ListSubquery`, `MapSubquery`)
stay safe: they are one `(…)`/`ARRAY(…)` token sequence, so a trailing dot
attaches to the whole thing. The parser only builds these accesses over a
parenthesized receiver (wrapped in `Expr::Nested`), so the change is
churn-free and the datadriven suites are unchanged.

Tests: extends `postfix_access_receiver_reparenthesized_after_nested_stripped`
with the quantified-subquery receiver cases (incl. one inside a `BETWEEN`
bound).

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

Author: def-

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

@@ -572,6 +572,13 @@ impl_display_t!(Expr);
 /// is a `Nested`-stripped AST and must be re-parenthesized. A `FieldAccess` /
 /// `WildcardAccess` receiver *is* safe, because its own printing already
 /// parenthesizes a bare-name base (`(a).b.c`), so the chain stays self-delimiting.
+///
+/// The quantified-subquery forms (`AnySubquery`/`AllSubquery`, printed
+/// `<expr> <op> ANY (<query>)`) are likewise *not* safe: they end in a `(query)`
+/// that is only a sub-part, so a trailing `.x`/`.*` binds to that inner subquery
+/// rather than the whole expression. (Contrast `Subquery`/`ArraySubquery`/… which
+/// are a single `(…)`/`ARRAY(…)` primary, so a trailing dot attaches to the whole
+/// thing.)
 fn write_dot_receiver<W: fmt::Write, T: AstInfo>(f: &mut AstFormatter<W>, expr: &Expr<T>) {
     let safe = matches!(
         expr,
@@ -584,8 +591,6 @@ fn write_dot_receiver<W: fmt::Write, T: AstInfo>(f: &mut AstFormatter<W>, expr:
             | Expr::Case { .. }
             | Expr::Exists(_)
             | Expr::Subquery(_)
-            | Expr::AnySubquery { .. }
-            | Expr::AllSubquery { .. }
             | Expr::Array(_)
             | Expr::ArraySubquery(_)
             | Expr::List(_)

src/sql-parser/tests/sqlparser_common.rs

@@ -1027,6 +1027,12 @@ fn postfix_access_receiver_reparenthesized_after_nested_stripped() {
         "SELECT (CAST(a AS int4))[1]",
         "SELECT (a[1])[2]",
         "SELECT (a + b)[1]",
+        // quantified-subquery dot receiver: the trailing `(query)` is a sub-part,
+        // so `.x`/`.*` would bind to it rather than the whole quantified expr.
+        "SELECT (a = ANY (SELECT b FROM t)).c",
+        "SELECT (a = ANY (SELECT b FROM t)).*",
+        "SELECT (a = ALL (SELECT b FROM t)).c",
+        "SELECT x BETWEEN (0 = ANY (SELECT b FROM t)).c AND y",
         // these are parser-shaped and must remain stable (no spurious parens)
         "SELECT (x).a.b",
         "SELECT a.b[1]",