| use rustc_ast::util::classify; | |
| use rustc_ast::util::parser::{self, ExprPrecedence}; | |
| use rustc_ast::{Expr, ExprKind, YieldKind}; | |
| // The default amount of fixing is minimal fixing, so all fixups are set to `false` by `Default`. | |
| // Fixups should be turned on in a targeted fashion where needed. | |
| #[derive(Copy, Clone, Debug, Default)] | |
| pub(crate) struct FixupContext { | |
| /// Print expression such that it can be parsed back as a statement | |
| /// consisting of the original expression. | |
| /// | |
| /// The effect of this is for binary operators in statement position to set | |
| /// `leftmost_subexpression_in_stmt` when printing their left-hand operand. | |
| /// | |
| /// ```ignore (illustrative) | |
| /// (match x {}) - 1; // match needs parens when LHS of binary operator | |
| /// | |
| /// match x {}; // not when its own statement | |
| /// ``` | |
| stmt: bool, | |
| /// This is the difference between: | |
| /// | |
| /// ```ignore (illustrative) | |
| /// (match x {}) - 1; // subexpression needs parens | |
| /// | |
| /// let _ = match x {} - 1; // no parens | |
| /// ``` | |
| /// | |
| /// There are 3 distinguishable contexts in which `print_expr` might be | |
| /// called with the expression `$match` as its argument, where `$match` | |
| /// represents an expression of kind `ExprKind::Match`: | |
| /// | |
| /// - stmt=false leftmost_subexpression_in_stmt=false | |
| /// | |
| /// Example: `let _ = $match - 1;` | |
| /// | |
| /// No parentheses required. | |
| /// | |
| /// - stmt=false leftmost_subexpression_in_stmt=true | |
| /// | |
| /// Example: `$match - 1;` | |
| /// | |
| /// Must parenthesize `($match)`, otherwise parsing back the output as a | |
| /// statement would terminate the statement after the closing brace of | |
| /// the match, parsing `-1;` as a separate statement. | |
| /// | |
| /// - stmt=true leftmost_subexpression_in_stmt=false | |
| /// | |
| /// Example: `$match;` | |
| /// | |
| /// No parentheses required. | |
| leftmost_subexpression_in_stmt: bool, | |
| /// Print expression such that it can be parsed as a match arm. | |
| /// | |
| /// This is almost equivalent to `stmt`, but the grammar diverges a tiny bit | |
| /// between statements and match arms when it comes to braced macro calls. | |
| /// Macro calls with brace delimiter terminate a statement without a | |
| /// semicolon, but do not terminate a match-arm without comma. | |
| /// | |
| /// ```ignore (illustrative) | |
| /// m! {} - 1; // two statements: a macro call followed by -1 literal | |
| /// | |
| /// match () { | |
| /// _ => m! {} - 1, // binary subtraction operator | |
| /// } | |
| /// ``` | |
| match_arm: bool, | |
| /// This is almost equivalent to `leftmost_subexpression_in_stmt`, other | |
| /// than for braced macro calls. | |
| /// | |
| /// If we have `m! {} - 1` as an expression, the leftmost subexpression | |
| /// `m! {}` will need to be parenthesized in the statement case but not the | |
| /// match-arm case. | |
| /// | |
| /// ```ignore (illustrative) | |
| /// (m! {}) - 1; // subexpression needs parens | |
| /// | |
| /// match () { | |
| /// _ => m! {} - 1, // no parens | |
| /// } | |
| /// ``` | |
| leftmost_subexpression_in_match_arm: bool, | |
| /// This is the difference between: | |
| /// | |
| /// ```ignore (illustrative) | |
| /// if let _ = (Struct {}) {} // needs parens | |
| /// | |
| /// match () { | |
| /// () if let _ = Struct {} => {} // no parens | |
| /// } | |
| /// ``` | |
| parenthesize_exterior_struct_lit: bool, | |
| /// This is the difference between: | |
| /// | |
| /// ```ignore (illustrative) | |
| /// let _ = (return) - 1; // without paren, this would return -1 | |
| /// | |
| /// let _ = return + 1; // no paren because '+' cannot begin expr | |
| /// ``` | |
| next_operator_can_begin_expr: bool, | |
| /// This is the difference between: | |
| /// | |
| /// ```ignore (illustrative) | |
| /// let _ = 1 + return 1; // no parens if rightmost subexpression | |
| /// | |
| /// let _ = 1 + (return 1) + 1; // needs parens | |
| /// ``` | |
| next_operator_can_continue_expr: bool, | |
| } | |
| impl FixupContext { | |
| /// Create the initial fixup for printing an expression in statement | |
| /// position. | |
| pub(crate) fn new_stmt() -> Self { | |
| FixupContext { stmt: true, ..FixupContext::default() } | |
| } | |
| /// Create the initial fixup for printing an expression as the right-hand | |
| /// side of a match arm. | |
| pub(crate) fn new_match_arm() -> Self { | |
| FixupContext { match_arm: true, ..FixupContext::default() } | |
| } | |
| /// Create the initial fixup for printing an expression as the "condition" | |
| /// of an `if` or `while`. There are a few other positions which are | |
| /// grammatically equivalent and also use this, such as the iterator | |
| /// expression in `for` and the scrutinee in `match`. | |
| pub(crate) fn new_cond() -> Self { | |
| FixupContext { parenthesize_exterior_struct_lit: true, ..FixupContext::default() } | |
| } | |
| /// Transform this fixup into the one that should apply when printing the | |
| /// leftmost subexpression of the current expression. | |
| /// | |
| /// The leftmost subexpression is any subexpression that has the same first | |
| /// token as the current expression, but has a different last token. | |
| /// | |
| /// For example in `$a + $b` and `$a.method()`, the subexpression `$a` is a | |
| /// leftmost subexpression. | |
| /// | |
| /// Not every expression has a leftmost subexpression. For example neither | |
| /// `-$a` nor `[$a]` have one. | |
| pub(crate) fn leftmost_subexpression(self) -> Self { | |
| FixupContext { | |
| stmt: false, | |
| leftmost_subexpression_in_stmt: self.stmt || self.leftmost_subexpression_in_stmt, | |
| match_arm: false, | |
| leftmost_subexpression_in_match_arm: self.match_arm | |
| || self.leftmost_subexpression_in_match_arm, | |
| next_operator_can_begin_expr: false, | |
| next_operator_can_continue_expr: true, | |
| ..self | |
| } | |
| } | |
| /// Transform this fixup into the one that should apply when printing a | |
| /// leftmost subexpression followed by a `.` or `?` token, which confer | |
| /// different statement boundary rules compared to other leftmost | |
| /// subexpressions. | |
| pub(crate) fn leftmost_subexpression_with_dot(self) -> Self { | |
| FixupContext { | |
| stmt: self.stmt || self.leftmost_subexpression_in_stmt, | |
| leftmost_subexpression_in_stmt: false, | |
| match_arm: self.match_arm || self.leftmost_subexpression_in_match_arm, | |
| leftmost_subexpression_in_match_arm: false, | |
| next_operator_can_begin_expr: false, | |
| next_operator_can_continue_expr: true, | |
| ..self | |
| } | |
| } | |
| /// Transform this fixup into the one that should apply when printing a | |
| /// leftmost subexpression followed by punctuation that is legal as the | |
| /// first token of an expression. | |
| pub(crate) fn leftmost_subexpression_with_operator( | |
| self, | |
| next_operator_can_begin_expr: bool, | |
| ) -> Self { | |
| FixupContext { next_operator_can_begin_expr, ..self.leftmost_subexpression() } | |
| } | |
| /// Transform this fixup into the one that should apply when printing the | |
| /// rightmost subexpression of the current expression. | |
| /// | |
| /// The rightmost subexpression is any subexpression that has a different | |
| /// first token than the current expression, but has the same last token. | |
| /// | |
| /// For example in `$a + $b` and `-$b`, the subexpression `$b` is a | |
| /// rightmost subexpression. | |
| /// | |
| /// Not every expression has a rightmost subexpression. For example neither | |
| /// `[$b]` nor `$a.f($b)` have one. | |
| pub(crate) fn rightmost_subexpression(self) -> Self { | |
| FixupContext { | |
| stmt: false, | |
| leftmost_subexpression_in_stmt: false, | |
| match_arm: false, | |
| leftmost_subexpression_in_match_arm: false, | |
| ..self | |
| } | |
| } | |
| /// Determine whether parentheses are needed around the given expression to | |
| /// head off an unintended statement boundary. | |
| /// | |
| /// The documentation on `FixupContext::leftmost_subexpression_in_stmt` has | |
| /// examples. | |
| pub(crate) fn would_cause_statement_boundary(self, expr: &Expr) -> bool { | |
| (self.leftmost_subexpression_in_stmt && !classify::expr_requires_semi_to_be_stmt(expr)) | |
| || (self.leftmost_subexpression_in_match_arm && classify::expr_is_complete(expr)) | |
| } | |
| /// Determine whether parentheses are needed around the given `let` | |
| /// scrutinee. | |
| /// | |
| /// In `if let _ = $e {}`, some examples of `$e` that would need parentheses | |
| /// are: | |
| /// | |
| /// - `Struct {}.f()`, because otherwise the `{` would be misinterpreted | |
| /// as the opening of the if's then-block. | |
| /// | |
| /// - `true && false`, because otherwise this would be misinterpreted as a | |
| /// "let chain". | |
| pub(crate) fn needs_par_as_let_scrutinee(self, expr: &Expr) -> bool { | |
| self.parenthesize_exterior_struct_lit && parser::contains_exterior_struct_lit(expr) | |
| || parser::needs_par_as_let_scrutinee(self.precedence(expr)) | |
| } | |
| /// Determines the effective precedence of a subexpression. Some expressions | |
| /// have higher or lower precedence when adjacent to particular operators. | |
| pub(crate) fn precedence(self, expr: &Expr) -> ExprPrecedence { | |
| if self.next_operator_can_begin_expr { | |
| // Decrease precedence of value-less jumps when followed by an | |
| // operator that would otherwise get interpreted as beginning a | |
| // value for the jump. | |
| if let ExprKind::Break(..) | |
| | ExprKind::Ret(..) | |
| | ExprKind::Yeet(..) | |
| | ExprKind::Yield(YieldKind::Prefix(..)) = expr.kind | |
| { | |
| return ExprPrecedence::Jump; | |
| } | |
| } | |
| if !self.next_operator_can_continue_expr { | |
| // Increase precedence of expressions that extend to the end of | |
| // current statement or group. | |
| if let ExprKind::Break(..) | |
| | ExprKind::Closure(..) | |
| | ExprKind::Ret(..) | |
| | ExprKind::Yeet(..) | |
| | ExprKind::Yield(YieldKind::Prefix(..)) | |
| | ExprKind::Range(None, ..) = expr.kind | |
| { | |
| return ExprPrecedence::Prefix; | |
| } | |
| } | |
| expr.precedence() | |
| } | |
| } |