4 use crate::expr::Expr;
6 use crate::expr::{
228         expr: &Expr,  in leftmost_subexpression_with_operator()
255         (fixup.leftmost_subexpression_precedence(expr), fixup)  in leftmost_subexpression_with_operator()
262     pub fn leftmost_subexpression_with_dot(self, expr: &Expr) -> (Precedence, Self) {  in leftmost_subexpression_with_dot()
284         (fixup.leftmost_subexpression_precedence(expr), fixup)  in leftmost_subexpression_with_dot()
287     fn leftmost_subexpression_precedence(self, expr: &Expr) -> Precedence {  in leftmost_subexpression_precedence()
290             if let Scan::Bailout = scan_right(expr, self, Precedence::MIN, 0, 0) {  in leftmost_subexpression_precedence()
291                 if scan_left(expr, self) {  in leftmost_subexpression_precedence()
297         self.precedence(expr)  in leftmost_subexpression_precedence()
313         expr: &Expr,  in rightmost_subexpression()
324         (fixup.rightmost_subexpression_precedence(expr), fixup)  in rightmost_subexpression()
352     pub fn rightmost_subexpression_precedence(self, expr: &Expr) -> Precedence {  in rightmost_subexpression_precedence()
353         let default_prec = self.precedence(expr);  in rightmost_subexpression_precedence()
365             if let Scan::Bailout | Scan::Fail = scan_right(expr, self, self.previous_operator, 1, 0)  in rightmost_subexpression_precedence()
367                 if scan_left(expr, self) {  in rightmost_subexpression_precedence()
379     pub fn parenthesize(self, expr: &Expr) -> bool {  in parenthesize()
380         (self.leftmost_subexpression_in_stmt && !classify::requires_semi_to_be_stmt(expr))  in parenthesize()
381             || ((self.stmt || self.leftmost_subexpression_in_stmt) && matches!(expr, Expr::Let(_)))  in parenthesize()
383                 && !classify::requires_comma_to_be_match_arm(expr))  in parenthesize()
384             || (self.condition && matches!(expr, Expr::Struct(_)))  in parenthesize()
387                     expr,  in parenthesize()
388                     Expr::Return(ExprReturn { expr: None, .. })  in parenthesize()
389                         | Expr::Yield(ExprYield { expr: None, .. })  in parenthesize()
394                     expr,  in parenthesize()
395                     Expr::Break(ExprBreak { expr: None, .. })  in parenthesize()
400 …             && matches!(expr, Expr::Block(expr) if expr.attrs.is_empty() && expr.label.is_none()))  in parenthesize()
405     fn precedence(self, expr: &Expr) -> Precedence {  in precedence()
411             if let Expr::Break(ExprBreak { expr: None, .. })  in precedence()
412             | Expr::Return(ExprReturn { expr: None, .. })  in precedence()
413             | Expr::Yield(ExprYield { expr: None, .. }) = expr  in precedence()
421             match expr {  in precedence()
437             if let Expr::Cast(cast) = expr {  in precedence()
444         Precedence::of(expr)  in precedence()
481 fn scan_left(expr: &Expr, fixup: FixupContext) -> bool {  in scan_left()
482     match expr {  in scan_left()
496     expr: &Expr,  in scan_right()
511     if fixup.parenthesize(expr) {  in scan_right()
514     match expr {  in scan_right()
581         Expr::RawAddr(ExprRawAddr { expr, .. })  in scan_right()
582         | Expr::Reference(ExprReference { expr, .. })  in scan_right()
583         | Expr::Unary(ExprUnary { expr, .. }) => {  in scan_right()
595                 expr,  in scan_right()
609             if right_fixup.rightmost_subexpression_precedence(expr) < Precedence::Prefix {  in scan_right()
655         Expr::Break(e) => match &e.expr {  in scan_right()
671         Expr::Return(ExprReturn { expr, .. }) | Expr::Yield(ExprYield { expr, .. }) => match expr {  in scan_right()
711                 &e.expr,  in scan_right()
728             if right_fixup.rightmost_subexpression_precedence(&e.expr) < Precedence::Let {  in scan_right()