sql: parenthesize the IS DISTINCT FROM right-hand side by its left edge

`Parser::parse_is` parses the right-hand side of `IS DISTINCT FROM` with
`parse_subexpr(<IS precedence>)`, so a RHS whose left spine binds at or
below `IS` (`OR`/`AND`/another `IS`) re-associates out of the `IS` on
reparse: `a IS DISTINCT FROM b OR c` parses as `(a IS DISTINCT FROM b) OR c`.
The printer emitted the RHS bare through `IsExprConstruct`'s display, with no
precedence handling, so a `Nested`-stripped AST drifted.

This drift is invisible to a stable-string round trip — `IsExpr(a,
DistinctFrom(Or(b,c)))` and `Or(IsExpr(a, DistinctFrom(b)), c)` print to the
same string `a IS DISTINCT FROM b OR c` — which is why the round-trip fuzzer
never flagged it despite generating the construct. The bug is real: the two
ASTs are distinct and the first does not reparse to itself.

Handle `DistinctFrom` in the `IsExpr` print arm (where the precedence
helpers are in scope) and parenthesize its RHS with `left_edge` (the RHS is
parsed fresh at `IS`, walking its left spine), matching the rest of the
model. The bare-keyword constructs (`NULL`/`TRUE`/`FALSE`/`UNKNOWN`) still
go through `IsExprConstruct`'s display. Parser-produced RHSs are wrapped in
`Expr::Nested` (`ATOM`), so the datadriven suites are unchanged.

Tests: adds `is_distinct_from_rhs_reparenthesized_after_nested_stripped` to
`sqlparser_common.rs`, which checks the round trip structurally (the
stable-string collision makes a string check insufficient).

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

Author: def-

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

@@ -246,7 +246,17 @@ impl<T: AstInfo> AstDisplay for Expr<T> {
                 if *negated {
                     f.write_str("NOT ");
                 }
-                f.write_node(construct);
+                // `IS DISTINCT FROM <rhs>` parses the RHS at the `IS` precedence
+                // (see `Parser::parse_is`), so a RHS whose left spine binds at or
+                // below `IS` re-associates out of the `IS` unless parenthesized
+                // (`a IS DISTINCT FROM b OR c` is `(a IS DISTINCT FROM b) OR c`).
+                // The other constructs (`NULL`/`TRUE`/…) are bare keywords.
+                if let IsExprConstruct::DistinctFrom(rhs) = construct {
+                    f.write_str("DISTINCT FROM ");
+                    write_binary_operand(f, rhs, left_edge(rhs) <= prec::IS);
+                } else {
+                    f.write_node(construct);
+                }
             }
             Expr::InList {
                 expr,

src/sql-parser/tests/sqlparser_common.rs

@@ -891,3 +891,52 @@ fn binary_op_operand_reparenthesized_after_nested_stripped() {
         );
     }
 }
+
+#[mz_ore::test]
+fn is_distinct_from_rhs_reparenthesized_after_nested_stripped() {
+    use mz_sql_parser::ast::display::AstDisplay;
+    use mz_sql_parser::ast::visit_mut::{self, VisitMut};
+    use mz_sql_parser::ast::{AstInfo, Expr};
+
+    struct StripNested;
+    impl<'a, T: AstInfo> VisitMut<'a, T> for StripNested {
+        fn visit_expr_mut(&mut self, e: &'a mut Expr<T>) {
+            visit_mut::visit_expr_mut(self, e);
+            if let Expr::Nested(inner) = e {
+                *e = (**inner).clone();
+            }
+        }
+    }
+
+    // `IS DISTINCT FROM` parses its right-hand side at the `IS` precedence (see
+    // `Parser::parse_is`), so a RHS whose left spine binds at or below `IS`
+    // (`OR`/`AND`/`IS`) is wrapped in `Expr::Nested`. Once stripped, the printer
+    // must re-add the parens — otherwise `a IS DISTINCT FROM b OR c` reparses as
+    // `(a IS DISTINCT FROM b) OR c`. This drift is invisible to a stable-string
+    // round trip (both ASTs print to the same string), so it is checked
+    // structurally here.
+    for sql in [
+        "SELECT a IS DISTINCT FROM (b OR c)",
+        "SELECT a IS DISTINCT FROM (b AND c)",
+        "SELECT a IS DISTINCT FROM (b IS DISTINCT FROM c)",
+        "SELECT a IS DISTINCT FROM (b IS NULL)",
+        // A comparison RHS binds tighter than `IS`, so it stays bare.
+        "SELECT a IS DISTINCT FROM b = c",
+    ] {
+        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,
+            "IS DISTINCT FROM RHS display did not round-trip after Nested was stripped: {sql:?} -> {displayed:?}"
+        );
+    }
+}