prettyplease/
precedence.rs

Help
1use syn::{
2    AttrStyle, Attribute, BinOp, Expr, ExprArray, ExprAsync, ExprAwait, ExprBlock, ExprBreak,
3    ExprCall, ExprConst, ExprContinue, ExprField, ExprForLoop, ExprIf, ExprIndex, ExprInfer,
4    ExprLit, ExprLoop, ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRepeat,
5    ExprReturn, ExprStruct, ExprTry, ExprTryBlock, ExprTuple, ExprUnsafe, ExprWhile, ExprYield,
6    ReturnType,
7};
8
9// Reference: https://doc.rust-lang.org/reference/expressions.html#expression-precedence
10#[derive(Copy, Clone, PartialEq, PartialOrd)]
11pub enum Precedence {
12    // return, break, closures
13    Jump,
14    // = += -= *= /= %= &= |= ^= <<= >>=
15    Assign,
16    // .. ..=
17    Range,
18    // ||
19    Or,
20    // &&
21    And,
22    // let
23    Let,
24    // == != < > <= >=
25    Compare,
26    // |
27    BitOr,
28    // ^
29    BitXor,
30    // &
31    BitAnd,
32    // << >>
33    Shift,
34    // + -
35    Sum,
36    // * / %
37    Product,
38    // as
39    Cast,
40    // unary - * ! & &mut
41    Prefix,
42    // paths, loops, function calls, array indexing, field expressions, method calls
43    Unambiguous,
44}
45
46impl Precedence {
47    pub(crate) const MIN: Self = Precedence::Jump;
48
49    pub(crate) fn of_binop(op: &BinOp) -> Self {
50        match op {
51            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
52            BinOp::Add(_) | BinOp::Sub(_) => Precedence::Sum,
53            BinOp::Mul(_) | BinOp::Div(_) | BinOp::Rem(_) => Precedence::Product,
54            BinOp::And(_) => Precedence::And,
55            BinOp::Or(_) => Precedence::Or,
56            BinOp::BitXor(_) => Precedence::BitXor,
57            BinOp::BitAnd(_) => Precedence::BitAnd,
58            BinOp::BitOr(_) => Precedence::BitOr,
59            BinOp::Shl(_) | BinOp::Shr(_) => Precedence::Shift,
60
61            BinOp::Eq(_)
62            | BinOp::Lt(_)
63            | BinOp::Le(_)
64            | BinOp::Ne(_)
65            | BinOp::Ge(_)
66            | BinOp::Gt(_) => Precedence::Compare,
67
68            BinOp::AddAssign(_)
69            | BinOp::SubAssign(_)
70            | BinOp::MulAssign(_)
71            | BinOp::DivAssign(_)
72            | BinOp::RemAssign(_)
73            | BinOp::BitXorAssign(_)
74            | BinOp::BitAndAssign(_)
75            | BinOp::BitOrAssign(_)
76            | BinOp::ShlAssign(_)
77            | BinOp::ShrAssign(_) => Precedence::Assign,
78
79            _ => Precedence::MIN,
80        }
81    }
82
83    pub(crate) fn of(e: &Expr) -> Self {
84        fn prefix_attrs(attrs: &[Attribute]) -> Precedence {
85            for attr in attrs {
86                if let AttrStyle::Outer = attr.style {
87                    return Precedence::Prefix;
88                }
89            }
90            Precedence::Unambiguous
91        }
92
93        match e {
94            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
95            Expr::Closure(e) => match e.output {
96                ReturnType::Default => Precedence::Jump,
97                ReturnType::Type(..) => prefix_attrs(&e.attrs),
98            },
99
100            Expr::Break(ExprBreak { expr, .. })
101            | Expr::Return(ExprReturn { expr, .. })
102            | Expr::Yield(ExprYield { expr, .. }) => match expr {
103                Some(_) => Precedence::Jump,
104                None => Precedence::Unambiguous,
105            },
106
107            Expr::Assign(_) => Precedence::Assign,
108            Expr::Range(_) => Precedence::Range,
109            Expr::Binary(e) => Precedence::of_binop(&e.op),
110            Expr::Let(_) => Precedence::Let,
111            Expr::Cast(_) => Precedence::Cast,
112            Expr::RawAddr(_) | Expr::Reference(_) | Expr::Unary(_) => Precedence::Prefix,
113
114            Expr::Array(ExprArray { attrs, .. })
115            | Expr::Async(ExprAsync { attrs, .. })
116            | Expr::Await(ExprAwait { attrs, .. })
117            | Expr::Block(ExprBlock { attrs, .. })
118            | Expr::Call(ExprCall { attrs, .. })
119            | Expr::Const(ExprConst { attrs, .. })
120            | Expr::Continue(ExprContinue { attrs, .. })
121            | Expr::Field(ExprField { attrs, .. })
122            | Expr::ForLoop(ExprForLoop { attrs, .. })
123            | Expr::If(ExprIf { attrs, .. })
124            | Expr::Index(ExprIndex { attrs, .. })
125            | Expr::Infer(ExprInfer { attrs, .. })
126            | Expr::Lit(ExprLit { attrs, .. })
127            | Expr::Loop(ExprLoop { attrs, .. })
128            | Expr::Macro(ExprMacro { attrs, .. })
129            | Expr::Match(ExprMatch { attrs, .. })
130            | Expr::MethodCall(ExprMethodCall { attrs, .. })
131            | Expr::Paren(ExprParen { attrs, .. })
132            | Expr::Path(ExprPath { attrs, .. })
133            | Expr::Repeat(ExprRepeat { attrs, .. })
134            | Expr::Struct(ExprStruct { attrs, .. })
135            | Expr::Try(ExprTry { attrs, .. })
136            | Expr::TryBlock(ExprTryBlock { attrs, .. })
137            | Expr::Tuple(ExprTuple { attrs, .. })
138            | Expr::Unsafe(ExprUnsafe { attrs, .. })
139            | Expr::While(ExprWhile { attrs, .. }) => prefix_attrs(attrs),
140
141            Expr::Group(e) => Precedence::of(&e.expr),
142
143            Expr::Verbatim(_) => Precedence::Unambiguous,
144
145            _ => Precedence::Unambiguous,
146        }
147    }
148}
prettyplease/precedence.rs

prettyplease/
precedence.rs
