Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 2d9f4ed

Browse files
dtolnaydtolnay
committedNov 17, 2024··
Inline ExprPrecedence::order into Expr::precedence
1 parent 23e7ecb commit 2d9f4ed

File tree

10 files changed

+135
-214
lines changed

10 files changed

+135
-214
lines changed
 

‎compiler/rustc_ast/src/ast.rs

Lines changed: 66 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,9 @@ pub use crate::format::*;
3939
use crate::ptr::P;
4040
use crate::token::{self, CommentKind, Delimiter};
4141
use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
42-
pub use crate::util::parser::ExprPrecedence;
42+
use crate::util::parser::{
43+
AssocOp, PREC_CLOSURE, PREC_JUMP, PREC_PREFIX, PREC_RANGE, PREC_UNAMBIGUOUS,
44+
};
4345

4446
/// A "Label" is an identifier of some point in sources,
4547
/// e.g. in the following code:
@@ -1319,53 +1321,71 @@ impl Expr {
13191321
Some(P(Ty { kind, id: self.id, span: self.span, tokens: None }))
13201322
}
13211323

1322-
pub fn precedence(&self) -> ExprPrecedence {
1324+
pub fn precedence(&self) -> i8 {
13231325
match self.kind {
1324-
ExprKind::Array(_) => ExprPrecedence::Array,
1325-
ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock,
1326-
ExprKind::Call(..) => ExprPrecedence::Call,
1327-
ExprKind::MethodCall(..) => ExprPrecedence::MethodCall,
1328-
ExprKind::Tup(_) => ExprPrecedence::Tup,
1329-
ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node),
1330-
ExprKind::Unary(..) => ExprPrecedence::Unary,
1331-
ExprKind::Lit(_) | ExprKind::IncludedBytes(..) => ExprPrecedence::Lit,
1332-
ExprKind::Cast(..) => ExprPrecedence::Cast,
1333-
ExprKind::Let(..) => ExprPrecedence::Let,
1334-
ExprKind::If(..) => ExprPrecedence::If,
1335-
ExprKind::While(..) => ExprPrecedence::While,
1336-
ExprKind::ForLoop { .. } => ExprPrecedence::ForLoop,
1337-
ExprKind::Loop(..) => ExprPrecedence::Loop,
1338-
ExprKind::Match(_, _, MatchKind::Prefix) => ExprPrecedence::Match,
1339-
ExprKind::Match(_, _, MatchKind::Postfix) => ExprPrecedence::PostfixMatch,
1340-
ExprKind::Closure(..) => ExprPrecedence::Closure,
1341-
ExprKind::Block(..) => ExprPrecedence::Block,
1342-
ExprKind::TryBlock(..) => ExprPrecedence::TryBlock,
1343-
ExprKind::Gen(..) => ExprPrecedence::Gen,
1344-
ExprKind::Await(..) => ExprPrecedence::Await,
1345-
ExprKind::Assign(..) => ExprPrecedence::Assign,
1346-
ExprKind::AssignOp(..) => ExprPrecedence::AssignOp,
1347-
ExprKind::Field(..) => ExprPrecedence::Field,
1348-
ExprKind::Index(..) => ExprPrecedence::Index,
1349-
ExprKind::Range(..) => ExprPrecedence::Range,
1350-
ExprKind::Underscore => ExprPrecedence::Path,
1351-
ExprKind::Path(..) => ExprPrecedence::Path,
1352-
ExprKind::AddrOf(..) => ExprPrecedence::AddrOf,
1353-
ExprKind::Break(..) => ExprPrecedence::Break,
1354-
ExprKind::Continue(..) => ExprPrecedence::Continue,
1355-
ExprKind::Ret(..) => ExprPrecedence::Ret,
1356-
ExprKind::Struct(..) => ExprPrecedence::Struct,
1357-
ExprKind::Repeat(..) => ExprPrecedence::Repeat,
1358-
ExprKind::Paren(..) => ExprPrecedence::Paren,
1359-
ExprKind::Try(..) => ExprPrecedence::Try,
1360-
ExprKind::Yield(..) => ExprPrecedence::Yield,
1361-
ExprKind::Yeet(..) => ExprPrecedence::Yeet,
1362-
ExprKind::Become(..) => ExprPrecedence::Become,
1363-
ExprKind::InlineAsm(..)
1364-
| ExprKind::Type(..)
1365-
| ExprKind::OffsetOf(..)
1326+
ExprKind::Closure(..) => PREC_CLOSURE,
1327+
1328+
ExprKind::Break(..)
1329+
| ExprKind::Continue(..)
1330+
| ExprKind::Ret(..)
1331+
| ExprKind::Yield(..)
1332+
| ExprKind::Yeet(..)
1333+
| ExprKind::Become(..) => PREC_JUMP,
1334+
1335+
// `Range` claims to have higher precedence than `Assign`, but `x .. x = x` fails to
1336+
// parse, instead of parsing as `(x .. x) = x`. Giving `Range` a lower precedence
1337+
// ensures that `pprust` will add parentheses in the right places to get the desired
1338+
// parse.
1339+
ExprKind::Range(..) => PREC_RANGE,
1340+
1341+
// Binop-like expr kinds, handled by `AssocOp`.
1342+
ExprKind::Binary(op, ..) => AssocOp::from_ast_binop(op.node).precedence() as i8,
1343+
ExprKind::Cast(..) => AssocOp::As.precedence() as i8,
1344+
1345+
ExprKind::Assign(..) |
1346+
ExprKind::AssignOp(..) => AssocOp::Assign.precedence() as i8,
1347+
1348+
// Unary, prefix
1349+
ExprKind::AddrOf(..)
1350+
// Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
1351+
// However, this is not exactly right. When `let _ = a` is the LHS of a binop we
1352+
// need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
1353+
// but we need to print `(let _ = a) < b` as-is with parens.
1354+
| ExprKind::Let(..)
1355+
| ExprKind::Unary(..) => PREC_PREFIX,
1356+
1357+
// Never need parens
1358+
ExprKind::Array(_)
1359+
| ExprKind::Await(..)
1360+
| ExprKind::Block(..)
1361+
| ExprKind::Call(..)
1362+
| ExprKind::ConstBlock(_)
1363+
| ExprKind::Field(..)
1364+
| ExprKind::ForLoop { .. }
13661365
| ExprKind::FormatArgs(..)
1367-
| ExprKind::MacCall(..) => ExprPrecedence::Mac,
1368-
ExprKind::Err(_) | ExprKind::Dummy => ExprPrecedence::Err,
1366+
| ExprKind::Gen(..)
1367+
| ExprKind::If(..)
1368+
| ExprKind::IncludedBytes(..)
1369+
| ExprKind::Index(..)
1370+
| ExprKind::InlineAsm(..)
1371+
| ExprKind::Lit(_)
1372+
| ExprKind::Loop(..)
1373+
| ExprKind::MacCall(..)
1374+
| ExprKind::Match(..)
1375+
| ExprKind::MethodCall(..)
1376+
| ExprKind::OffsetOf(..)
1377+
| ExprKind::Paren(..)
1378+
| ExprKind::Path(..)
1379+
| ExprKind::Repeat(..)
1380+
| ExprKind::Struct(..)
1381+
| ExprKind::Try(..)
1382+
| ExprKind::TryBlock(..)
1383+
| ExprKind::Tup(_)
1384+
| ExprKind::Type(..)
1385+
| ExprKind::Underscore
1386+
| ExprKind::While(..)
1387+
| ExprKind::Err(_)
1388+
| ExprKind::Dummy => PREC_UNAMBIGUOUS,
13691389
}
13701390
}
13711391

‎compiler/rustc_ast/src/util/parser.rs

Lines changed: 0 additions & 115 deletions
Original file line numberDiff line numberDiff line change
@@ -237,121 +237,6 @@ pub const PREC_PREFIX: i8 = 50;
237237
pub const PREC_UNAMBIGUOUS: i8 = 60;
238238
pub const PREC_FORCE_PAREN: i8 = 100;
239239

240-
#[derive(Debug, Clone, Copy)]
241-
pub enum ExprPrecedence {
242-
Closure,
243-
Break,
244-
Continue,
245-
Ret,
246-
Yield,
247-
Yeet,
248-
Become,
249-
250-
Range,
251-
252-
Binary(BinOpKind),
253-
254-
Cast,
255-
256-
Assign,
257-
AssignOp,
258-
259-
AddrOf,
260-
Let,
261-
Unary,
262-
263-
Call,
264-
MethodCall,
265-
Field,
266-
Index,
267-
Try,
268-
Mac,
269-
270-
Array,
271-
Repeat,
272-
Tup,
273-
Lit,
274-
Path,
275-
Paren,
276-
If,
277-
While,
278-
ForLoop,
279-
Loop,
280-
Match,
281-
PostfixMatch,
282-
ConstBlock,
283-
Block,
284-
TryBlock,
285-
Struct,
286-
Gen,
287-
Await,
288-
Err,
289-
}
290-
291-
impl ExprPrecedence {
292-
pub fn order(self) -> i8 {
293-
match self {
294-
ExprPrecedence::Closure => PREC_CLOSURE,
295-
296-
ExprPrecedence::Break
297-
| ExprPrecedence::Continue
298-
| ExprPrecedence::Ret
299-
| ExprPrecedence::Yield
300-
| ExprPrecedence::Yeet
301-
| ExprPrecedence::Become => PREC_JUMP,
302-
303-
// `Range` claims to have higher precedence than `Assign`, but `x .. x = x` fails to
304-
// parse, instead of parsing as `(x .. x) = x`. Giving `Range` a lower precedence
305-
// ensures that `pprust` will add parentheses in the right places to get the desired
306-
// parse.
307-
ExprPrecedence::Range => PREC_RANGE,
308-
309-
// Binop-like expr kinds, handled by `AssocOp`.
310-
ExprPrecedence::Binary(op) => AssocOp::from_ast_binop(op).precedence() as i8,
311-
ExprPrecedence::Cast => AssocOp::As.precedence() as i8,
312-
313-
ExprPrecedence::Assign |
314-
ExprPrecedence::AssignOp => AssocOp::Assign.precedence() as i8,
315-
316-
// Unary, prefix
317-
ExprPrecedence::AddrOf
318-
// Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
319-
// However, this is not exactly right. When `let _ = a` is the LHS of a binop we
320-
// need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
321-
// but we need to print `(let _ = a) < b` as-is with parens.
322-
| ExprPrecedence::Let
323-
| ExprPrecedence::Unary => PREC_PREFIX,
324-
325-
// Never need parens
326-
ExprPrecedence::Array
327-
| ExprPrecedence::Await
328-
| ExprPrecedence::Block
329-
| ExprPrecedence::Call
330-
| ExprPrecedence::ConstBlock
331-
| ExprPrecedence::Field
332-
| ExprPrecedence::ForLoop
333-
| ExprPrecedence::Gen
334-
| ExprPrecedence::If
335-
| ExprPrecedence::Index
336-
| ExprPrecedence::Lit
337-
| ExprPrecedence::Loop
338-
| ExprPrecedence::Mac
339-
| ExprPrecedence::Match
340-
| ExprPrecedence::MethodCall
341-
| ExprPrecedence::Paren
342-
| ExprPrecedence::Path
343-
| ExprPrecedence::PostfixMatch
344-
| ExprPrecedence::Repeat
345-
| ExprPrecedence::Struct
346-
| ExprPrecedence::Try
347-
| ExprPrecedence::TryBlock
348-
| ExprPrecedence::Tup
349-
| ExprPrecedence::While
350-
| ExprPrecedence::Err => PREC_UNAMBIGUOUS,
351-
}
352-
}
353-
}
354-
355240
/// In `let p = e`, operators with precedence `<=` this one requires parentheses in `e`.
356241
pub fn prec_let_scrutinee_needs_par() -> usize {
357242
AssocOp::LAnd.precedence()

‎compiler/rustc_ast_pretty/src/pprust/state/expr.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ impl<'a> State<'a> {
5959
}
6060

6161
fn print_expr_maybe_paren(&mut self, expr: &ast::Expr, prec: i8, fixup: FixupContext) {
62-
self.print_expr_cond_paren(expr, expr.precedence().order() < prec, fixup);
62+
self.print_expr_cond_paren(expr, expr.precedence() < prec, fixup);
6363
}
6464

6565
/// Prints an expr using syntax that's acceptable in a condition position, such as the `cond` in
@@ -615,7 +615,7 @@ impl<'a> State<'a> {
615615
expr,
616616
// Parenthesize if required by precedence, or in the
617617
// case of `break 'inner: loop { break 'inner 1 } + 1`
618-
expr.precedence().order() < parser::PREC_JUMP
618+
expr.precedence() < parser::PREC_JUMP
619619
|| (opt_label.is_none() && classify::leading_labeled_expr(expr)),
620620
fixup.subsequent_subexpression(),
621621
);

‎compiler/rustc_ast_pretty/src/pprust/state/fixup.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,6 @@ impl FixupContext {
191191
/// "let chain".
192192
pub(crate) fn needs_par_as_let_scrutinee(self, expr: &Expr) -> bool {
193193
self.parenthesize_exterior_struct_lit && parser::contains_exterior_struct_lit(expr)
194-
|| parser::needs_par_as_let_scrutinee(expr.precedence().order())
194+
|| parser::needs_par_as_let_scrutinee(expr.precedence())
195195
}
196196
}

‎compiler/rustc_hir/src/hir.rs

Lines changed: 47 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
use std::fmt;
22

33
use rustc_abi::ExternAbi;
4-
use rustc_ast::util::parser::ExprPrecedence;
4+
use rustc_ast::util::parser::{AssocOp, PREC_CLOSURE, PREC_JUMP, PREC_PREFIX, PREC_UNAMBIGUOUS};
55
use rustc_ast::{
66
self as ast, Attribute, FloatTy, InlineAsmOptions, InlineAsmTemplatePiece, IntTy, Label,
77
LitKind, TraitObjectSyntax, UintTy,
@@ -1719,41 +1719,54 @@ pub struct Expr<'hir> {
17191719
}
17201720

17211721
impl Expr<'_> {
1722-
pub fn precedence(&self) -> ExprPrecedence {
1722+
pub fn precedence(&self) -> i8 {
17231723
match self.kind {
1724-
ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock,
1725-
ExprKind::Array(_) => ExprPrecedence::Array,
1726-
ExprKind::Call(..) => ExprPrecedence::Call,
1727-
ExprKind::MethodCall(..) => ExprPrecedence::MethodCall,
1728-
ExprKind::Tup(_) => ExprPrecedence::Tup,
1729-
ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node),
1730-
ExprKind::Unary(..) => ExprPrecedence::Unary,
1731-
ExprKind::Lit(_) => ExprPrecedence::Lit,
1732-
ExprKind::Cast(..) => ExprPrecedence::Cast,
1724+
ExprKind::Closure { .. } => PREC_CLOSURE,
1725+
1726+
ExprKind::Break(..)
1727+
| ExprKind::Continue(..)
1728+
| ExprKind::Ret(..)
1729+
| ExprKind::Yield(..)
1730+
| ExprKind::Become(..) => PREC_JUMP,
1731+
1732+
// Binop-like expr kinds, handled by `AssocOp`.
1733+
ExprKind::Binary(op, ..) => AssocOp::from_ast_binop(op.node).precedence() as i8,
1734+
ExprKind::Cast(..) => AssocOp::As.precedence() as i8,
1735+
1736+
ExprKind::Assign(..) |
1737+
ExprKind::AssignOp(..) => AssocOp::Assign.precedence() as i8,
1738+
1739+
// Unary, prefix
1740+
ExprKind::AddrOf(..)
1741+
// Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
1742+
// However, this is not exactly right. When `let _ = a` is the LHS of a binop we
1743+
// need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
1744+
// but we need to print `(let _ = a) < b` as-is with parens.
1745+
| ExprKind::Let(..)
1746+
| ExprKind::Unary(..) => PREC_PREFIX,
1747+
1748+
// Never need parens
1749+
ExprKind::Array(_)
1750+
| ExprKind::Block(..)
1751+
| ExprKind::Call(..)
1752+
| ExprKind::ConstBlock(_)
1753+
| ExprKind::Field(..)
1754+
| ExprKind::If(..)
1755+
| ExprKind::Index(..)
1756+
| ExprKind::InlineAsm(..)
1757+
| ExprKind::Lit(_)
1758+
| ExprKind::Loop(..)
1759+
| ExprKind::Match(..)
1760+
| ExprKind::MethodCall(..)
1761+
| ExprKind::OffsetOf(..)
1762+
| ExprKind::Path(..)
1763+
| ExprKind::Repeat(..)
1764+
| ExprKind::Struct(..)
1765+
| ExprKind::Tup(_)
1766+
| ExprKind::Type(..)
1767+
| ExprKind::Err(_) => PREC_UNAMBIGUOUS,
1768+
17331769
ExprKind::DropTemps(ref expr, ..) => expr.precedence(),
1734-
ExprKind::If(..) => ExprPrecedence::If,
1735-
ExprKind::Let(..) => ExprPrecedence::Let,
1736-
ExprKind::Loop(..) => ExprPrecedence::Loop,
1737-
ExprKind::Match(..) => ExprPrecedence::Match,
1738-
ExprKind::Closure { .. } => ExprPrecedence::Closure,
1739-
ExprKind::Block(..) => ExprPrecedence::Block,
1740-
ExprKind::Assign(..) => ExprPrecedence::Assign,
1741-
ExprKind::AssignOp(..) => ExprPrecedence::AssignOp,
1742-
ExprKind::Field(..) => ExprPrecedence::Field,
1743-
ExprKind::Index(..) => ExprPrecedence::Index,
1744-
ExprKind::Path(..) => ExprPrecedence::Path,
1745-
ExprKind::AddrOf(..) => ExprPrecedence::AddrOf,
1746-
ExprKind::Break(..) => ExprPrecedence::Break,
1747-
ExprKind::Continue(..) => ExprPrecedence::Continue,
1748-
ExprKind::Ret(..) => ExprPrecedence::Ret,
1749-
ExprKind::Become(..) => ExprPrecedence::Become,
1750-
ExprKind::Struct(..) => ExprPrecedence::Struct,
1751-
ExprKind::Repeat(..) => ExprPrecedence::Repeat,
1752-
ExprKind::Yield(..) => ExprPrecedence::Yield,
1753-
ExprKind::Type(..) | ExprKind::InlineAsm(..) | ExprKind::OffsetOf(..) => {
1754-
ExprPrecedence::Mac
1755-
}
1756-
ExprKind::Err(_) => ExprPrecedence::Err,
17571770
}
17581771
}
17591772

‎compiler/rustc_hir_pretty/src/lib.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1015,7 +1015,7 @@ impl<'a> State<'a> {
10151015
}
10161016

10171017
fn print_expr_maybe_paren(&mut self, expr: &hir::Expr<'_>, prec: i8) {
1018-
self.print_expr_cond_paren(expr, expr.precedence().order() < prec)
1018+
self.print_expr_cond_paren(expr, expr.precedence() < prec)
10191019
}
10201020

10211021
/// Prints an expr using syntax that's acceptable in a condition position, such as the `cond` in
@@ -1049,7 +1049,7 @@ impl<'a> State<'a> {
10491049
}
10501050
self.space();
10511051
self.word_space("=");
1052-
let npals = || parser::needs_par_as_let_scrutinee(init.precedence().order());
1052+
let npals = || parser::needs_par_as_let_scrutinee(init.precedence());
10531053
self.print_expr_cond_paren(init, Self::cond_needs_par(init) || npals())
10541054
}
10551055

‎compiler/rustc_hir_typeck/src/callee.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -606,7 +606,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
606606
};
607607

608608
if let Ok(rest_snippet) = rest_snippet {
609-
let sugg = if callee_expr.precedence().order() >= PREC_UNAMBIGUOUS {
609+
let sugg = if callee_expr.precedence() >= PREC_UNAMBIGUOUS {
610610
vec![
611611
(up_to_rcvr_span, "".to_string()),
612612
(rest_span, format!(".{}({rest_snippet}", segment.ident)),

‎compiler/rustc_hir_typeck/src/cast.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1107,7 +1107,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
11071107
}
11081108

11091109
fn lossy_provenance_ptr2int_lint(&self, fcx: &FnCtxt<'a, 'tcx>, t_c: ty::cast::IntTy) {
1110-
let expr_prec = self.expr.precedence().order();
1110+
let expr_prec = self.expr.precedence();
11111111
let needs_parens = expr_prec < rustc_ast::util::parser::PREC_UNAMBIGUOUS;
11121112

11131113
let needs_cast = !matches!(t_c, ty::cast::IntTy::U(ty::UintTy::Usize));

‎compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use core::cmp::min;
22
use core::iter;
33

44
use hir::def_id::LocalDefId;
5-
use rustc_ast::util::parser::{ExprPrecedence, PREC_UNAMBIGUOUS};
5+
use rustc_ast::util::parser::PREC_UNAMBIGUOUS;
66
use rustc_data_structures::packed::Pu128;
77
use rustc_errors::{Applicability, Diag, MultiSpan};
88
use rustc_hir as hir;
@@ -398,7 +398,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
398398
// so we remove the user's `clone` call.
399399
{
400400
vec![(receiver_method.ident.span, conversion_method.name.to_string())]
401-
} else if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
401+
} else if expr.precedence() < PREC_UNAMBIGUOUS {
402402
vec![
403403
(expr.span.shrink_to_lo(), "(".to_string()),
404404
(expr.span.shrink_to_hi(), format!(").{}()", conversion_method.name)),
@@ -1376,7 +1376,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13761376
{
13771377
let span = expr.span.find_oldest_ancestor_in_same_ctxt();
13781378

1379-
let mut sugg = if expr.precedence().order() >= PREC_UNAMBIGUOUS {
1379+
let mut sugg = if expr.precedence() >= PREC_UNAMBIGUOUS {
13801380
vec![(span.shrink_to_hi(), ".into()".to_owned())]
13811381
} else {
13821382
vec![
@@ -2985,7 +2985,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
29852985
"change the type of the numeric literal from `{checked_ty}` to `{expected_ty}`",
29862986
);
29872987

2988-
let close_paren = if expr.precedence().order() < PREC_UNAMBIGUOUS {
2988+
let close_paren = if expr.precedence() < PREC_UNAMBIGUOUS {
29892989
sugg.push((expr.span.shrink_to_lo(), "(".to_string()));
29902990
")"
29912991
} else {
@@ -3010,7 +3010,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
30103010
let len = src.trim_end_matches(&checked_ty.to_string()).len();
30113011
expr.span.with_lo(expr.span.lo() + BytePos(len as u32))
30123012
},
3013-
if expr.precedence().order() < PREC_UNAMBIGUOUS {
3013+
if expr.precedence() < PREC_UNAMBIGUOUS {
30143014
// Readd `)`
30153015
format!("{expected_ty})")
30163016
} else {

‎compiler/rustc_parse/src/parser/pat.rs

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,12 @@
11
use rustc_ast::mut_visit::{self, MutVisitor};
22
use rustc_ast::ptr::P;
33
use rustc_ast::token::{self, BinOpToken, Delimiter, IdentIsRaw, Token};
4+
use rustc_ast::util::parser::AssocOp;
45
use rustc_ast::visit::{self, Visitor};
56
use rustc_ast::{
6-
self as ast, Arm, AttrVec, BinOpKind, BindingMode, ByRef, Expr, ExprKind, ExprPrecedence,
7-
LocalKind, MacCall, Mutability, Pat, PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd,
8-
RangeSyntax, Stmt, StmtKind,
7+
self as ast, Arm, AttrVec, BinOpKind, BindingMode, ByRef, Expr, ExprKind, LocalKind, MacCall,
8+
Mutability, Pat, PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax, Stmt,
9+
StmtKind,
910
};
1011
use rustc_ast_pretty::pprust;
1112
use rustc_errors::{Applicability, Diag, DiagArgValue, PResult, StashKey};
@@ -458,7 +459,7 @@ impl<'a> Parser<'a> {
458459
.create_err(UnexpectedExpressionInPattern {
459460
span,
460461
is_bound,
461-
expr_precedence: expr.precedence().order(),
462+
expr_precedence: expr.precedence(),
462463
})
463464
.stash(span, StashKey::ExprInPat)
464465
.unwrap(),
@@ -545,7 +546,8 @@ impl<'a> Parser<'a> {
545546
let expr = match &err.args["expr_precedence"] {
546547
DiagArgValue::Number(expr_precedence) => {
547548
if *expr_precedence
548-
<= ExprPrecedence::Binary(BinOpKind::Eq).order() as i32
549+
<= AssocOp::from_ast_binop(BinOpKind::Eq).precedence()
550+
as i32
549551
{
550552
format!("({expr})")
551553
} else {
@@ -568,8 +570,9 @@ impl<'a> Parser<'a> {
568570
}
569571
Some(guard) => {
570572
// Are parentheses required around the old guard?
571-
let wrap_guard = guard.precedence().order()
572-
<= ExprPrecedence::Binary(BinOpKind::And).order();
573+
let wrap_guard = guard.precedence()
574+
<= AssocOp::from_ast_binop(BinOpKind::And).precedence()
575+
as i8;
573576

574577
err.subdiagnostic(
575578
UnexpectedExpressionInPatternSugg::UpdateGuard {

0 commit comments

Comments
 (0)
Please sign in to comment.