Function left_edge

src/sql-parser/src/ast/defs/expr.rs:786–812

The loosest precedence exposed on `expr`'s *left spine*, the mirror of [`right_edge`]. For a *right* operand (an operator on its left), this is what decides parenthesization: a left-associative operator printed to its left reaches into the left spine and re-associates if that spine exposes a precedence at or below the operator's. The top operator alone is not enough, because a left-nested chain ca

(expr: &Expr<T>)

/// own token on the left (a prefix operator, a keyword, `(…)`, a literal) are
/// `ATOM`.
fn left_edge<T: AstInfo>(expr: &Expr<T>) -> u8 {
    match expr {
        // Left-transparent infixes / postfix-keyword constructs: the subject (or
        // left operand) sits on the left spine, so descend into it.
        Expr::Or { left, .. } => prec::OR.min(left_edge(left)),
        Expr::And { left, .. } => prec::AND.min(left_edge(left)),
        Expr::Op {
            op,
            expr1,
            expr2: Some(_),
        } => binary_op_precedence(op).min(left_edge(expr1)),
        Expr::IsExpr { expr, .. } => prec::IS.min(left_edge(expr)),
        Expr::AnyExpr { left, .. }
        | Expr::AllExpr { left, .. }
        | Expr::AnySubquery { left, .. }
        | Expr::AllSubquery { left, .. } => prec::CMP.min(left_edge(left)),
        Expr::Like { expr, .. }
        | Expr::Between { expr, .. }
        | Expr::InList { expr, .. }
        | Expr::InSubquery { expr, .. } => prec::LIKE.min(left_edge(expr)),
        // Everything else leads with its own token on the left: a prefix
        // operator (`-`/`+`/`~`/`NOT`), a keyword, `(…)`, `ARRAY[…]`, a literal,
        // or a `COLLATE`/`::`/`[…]` whose own operand the printer parenthesizes
        // when it isn't self-delimiting. Nothing to the left binds into it.
        _ => prec::ATOM,
    }
}

/// Write `operand` for a binary operator, parenthesizing it iff `needs_parens`.
fn write_binary_operand<W: fmt::Write, T: AstInfo>(