Function right_edge

src/sql-parser/src/ast/defs/expr.rs:738–772

The loosest precedence exposed on `expr`'s *right spine*, the precedence at which an operator printed immediately to its right would bind *into* it rather than wrap it. For a left operand / subject of a construct that prints to its right, this is what decides parenthesization (its mirror, [`left_edge`], decides right operands), because a prefix operator and the right operand of a binary/`BETWEEN`/

(expr: &Expr<T>)

/// is unary `-`. Forms that close with a bracket on the right (`(…)`, `[…]`,
/// `::type`, `IS NULL`) are `ATOM`.
fn right_edge<T: AstInfo>(expr: &Expr<T>) -> u8 {
    match expr {
        // Right-transparent binary infixes: an operator tighter than this one
        // binds into the right operand, which itself may expose a looser spine.
        Expr::Or { right, .. } => prec::OR.min(right_edge(right)),
        Expr::And { right, .. } => prec::AND.min(right_edge(right)),
        Expr::Op {
            op, expr2: Some(r), ..
        } => binary_op_precedence(op).min(right_edge(r)),
        // Prefix operators expose their operand's right spine.
        Expr::Op {
            op,
            expr1,
            expr2: None,
        } => unary_prec(op).min(right_edge(expr1)),
        Expr::Not { expr } => prec::NOT.min(right_edge(expr)),
        // `IS DISTINCT FROM x` exposes `x`, while `IS NULL`/`TRUE`/… close.
        Expr::IsExpr {
            construct: IsExprConstruct::DistinctFrom(x),
            ..
        } => prec::IS.min(right_edge(x)),
        // `… BETWEEN low AND high` exposes `high`. `… [I]LIKE pat [ESCAPE esc]`
        // exposes the rightmost of `esc`/`pat`.
        Expr::Between { high, .. } => prec::LIKE.min(right_edge(high)),
        Expr::Like {
            pattern, escape, ..
        } => {
            let rightmost = escape.as_deref().unwrap_or_else(|| pattern.as_ref());
            prec::LIKE.min(right_edge(rightmost))
        }
        // Everything else closes on the right (a bracket, a keyword, a literal,
        // or `IS NULL`-style), so nothing binds into it.
        _ => prec::ATOM,
    }
}

/// 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