Function prints_self_delimiting

src/sql-parser/src/ast/defs/expr.rs:841–868

Whether `expr` prints in a *self-delimiting* form — atomic, or wrapped in its own brackets/parens (`name(...)`, `(…)`, `ARRAY[…]`, `CASE … END`, …) — so it is safe to print immediately to the left of a tight postfix operator (`::`, `COLLATE`, or the `IN` delimiter of the `position( IN …)` special form) without the operator re-associating into the expression's spine. Anything with an expos

(expr: &Expr<T>)

/// back for those. Postfix forms (`::`/`COLLATE`/`[…]`) are self-delimiting only
/// when their own inner operand is.
fn prints_self_delimiting<T: AstInfo>(expr: &Expr<T>) -> bool {
    match expr {
        Expr::Value(_)
        | Expr::Identifier(_)
        | Expr::QualifiedWildcard(_)
        | Expr::Parameter(_)
        | Expr::Function(_)
        | Expr::HomogenizingFunction { .. }
        | Expr::NullIf { .. }
        | Expr::Subquery(_)
        | Expr::Exists(_)
        | Expr::Nested(_)
        | Expr::Array(_)
        | Expr::ArraySubquery(_)
        | Expr::List(_)
        | Expr::ListSubquery(_)
        | Expr::Map(_)
        | Expr::MapSubquery(_)
        | Expr::Case { .. }
        | Expr::Row { .. } => true,
        // The postfix `::` / `COLLATE` / `[…]` forms print as `<inner><suffix>`,
        // so they are safe only when their inner operand is.
        Expr::Cast { expr, .. } | Expr::Collate { expr, .. } | Expr::Subscript { expr, .. } => {
            prints_self_delimiting(expr)
        }
        _ => false,
    }
}

/// Whether the operand of a prefix operator (`-`/`+`/`~`) must be parenthesized
/// to round-trip. A prefix op binds *tighter* than `COLLATE`/`AT TIME ZONE` and