Function write_subscript_receiver

src/sql-parser/src/ast/defs/expr.rs:908–956

Write `expr` as the receiver of a `[…]` subscript. An unparenthesized `Identifier(["map"])` reparses as `Token::Keyword(MAP)` followed by `[`, which dispatches to `parse_map` (the map-literal grammar) instead of a regular subscript. Parenthesize identifiers whose last component is a context-sensitive keyword so the round trip stays an identifier subscript.

(f: &mut AstFormatter<W>, expr: &Expr<T>)

/// regular subscript. Parenthesize identifiers whose last component is a
/// context-sensitive keyword so the round trip stays an identifier subscript.
fn write_subscript_receiver<W: fmt::Write, T: AstInfo>(f: &mut AstFormatter<W>, expr: &Expr<T>) {
    let needs_parens = match expr {
        // A bare keyword identifier (`map`, `list`, …) dispatches to the
        // map/list-literal grammar before `[`, so it needs parens even though
        // identifiers are otherwise safe receivers.
        Expr::Identifier(idents) => idents
            .last()
            .and_then(|id| id.as_keyword())
            .map(|kw| kw.is_context_sensitive_keyword())
            .unwrap_or(false),
        // Self-delimiting primaries, the bracketed collections, and the postfix
        // forms that end in an identifier or `)` are safe: a following `[…]`
        // attaches to the whole receiver as a fresh subscript.
        Expr::QualifiedWildcard(_)
        | Expr::Parameter(_)
        | Expr::Value(_)
        | Expr::Function(_)
        | Expr::HomogenizingFunction { .. }
        | Expr::NullIf { .. }
        | Expr::Nested(_)
        | Expr::Subquery(_)
        | Expr::Exists(_)
        | Expr::Case { .. }
        | Expr::Row { .. }
        | Expr::Array(_)
        | Expr::ArraySubquery(_)
        | Expr::List(_)
        | Expr::ListSubquery(_)
        | Expr::Map(_)
        | Expr::MapSubquery(_)
        | Expr::FieldAccess { .. }
        | Expr::WildcardAccess(_)
        | Expr::Collate { .. } => false,
        // `Cast`: the type parser swallows a following `[…]` as an array suffix
        // (`a::int4[1]` is `a` cast to `int4[]`, not a subscript of `a::int4`).
        // `Subscript`: consecutive `[…]` flatten into one node (`a[1][2]` is a
        // single subscript), so a nested subscript receiver must be parenthesized
        // to stay nested. Everything else (operators, `IS`/`LIKE`/… constructs)
        // binds looser than `[` and would re-associate, so parenthesize by default.
        _ => true,
    };
    if needs_parens {
        f.write_str("(");
        f.write_node(expr);
        f.write_str(")");
    } else {
        f.write_node(expr);
    }
}

impl<T: AstInfo> Expr<T> {
    pub fn null() -> Expr<T> {