Skip to content

Commit 6be7a87

Browse files
compiler-errorscompiler-errors
committed
Use expr parse restrictions for let expr parsing
1 parent 7cdd937 commit 6be7a87

File tree

6 files changed

+351
-292
lines changed

6 files changed

+351
-292
lines changed

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

Lines changed: 17 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -1391,8 +1391,6 @@ impl<'a> Parser<'a> {
13911391
} else if self.is_do_yeet() {
13921392
self.parse_yeet_expr(attrs)
13931393
} else if self.check_keyword(kw::Let) {
1394-
self.manage_let_chains_context();
1395-
self.bump();
13961394
self.parse_let_expr(attrs)
13971395
} else if self.eat_keyword(kw::Underscore) {
13981396
Ok(self.mk_expr(self.prev_token.span, ExprKind::Underscore, attrs))
@@ -2342,32 +2340,24 @@ impl<'a> Parser<'a> {
23422340

23432341
/// Parses the condition of a `if` or `while` expression.
23442342
fn parse_cond_expr(&mut self) -> PResult<'a, P<Expr>> {
2345-
self.with_let_management(true, |local_self| {
2346-
local_self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)
2347-
})
2343+
self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL | Restrictions::ALLOW_LET, None)
23482344
}
23492345

2350-
// Checks if `let` is in an invalid position like `let x = let y = 1;` or
2351-
// if the current `let` is in a let_chains context but nested in another
2352-
// expression like `if let Some(_) = _opt && [1, 2, 3][let _ = ()] = 1`.
2353-
//
2354-
// This method expects that the current token is `let`.
2355-
fn manage_let_chains_context(&mut self) {
2356-
debug_assert!(matches!(self.token.kind, TokenKind::Ident(kw::Let, _)));
2357-
let is_in_a_let_chains_context_but_nested_in_other_expr = self.let_expr_allowed
2358-
&& !matches!(
2359-
self.prev_token.kind,
2360-
TokenKind::AndAnd | TokenKind::Ident(kw::If, _) | TokenKind::Ident(kw::While, _)
2361-
);
2362-
if !self.let_expr_allowed || is_in_a_let_chains_context_but_nested_in_other_expr {
2346+
/// Parses a `let $pat = $expr` pseudo-expression.
2347+
fn parse_let_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>> {
2348+
// This is a *approximate* heuristic that detects if `let` chains are
2349+
// being parsed in the right position. It's approximate because it
2350+
// doesn't deny all invalid `let` expressions, just completely wrong usages.
2351+
let not_in_chain = !matches!(
2352+
self.prev_token.kind,
2353+
TokenKind::AndAnd | TokenKind::Ident(kw::If, _) | TokenKind::Ident(kw::While, _)
2354+
);
2355+
if !self.restrictions.contains(Restrictions::ALLOW_LET) || not_in_chain {
23632356
self.struct_span_err(self.token.span, "expected expression, found `let` statement")
23642357
.emit();
23652358
}
2366-
}
23672359

2368-
/// Parses a `let $pat = $expr` pseudo-expression.
2369-
/// The `let` token has already been eaten.
2370-
fn parse_let_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>> {
2360+
self.bump(); // Eat `let` token
23712361
let lo = self.prev_token.span;
23722362
let pat = self.parse_pat_allow_top_alt(
23732363
None,
@@ -2687,7 +2677,9 @@ impl<'a> Parser<'a> {
26872677
// `&&` tokens.
26882678
fn check_let_expr(expr: &Expr) -> bool {
26892679
match expr.kind {
2690-
ExprKind::Binary(_, ref lhs, ref rhs) => check_let_expr(lhs) || check_let_expr(rhs),
2680+
ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, ref lhs, ref rhs) => {
2681+
check_let_expr(lhs) || check_let_expr(rhs)
2682+
}
26912683
ExprKind::Let(..) => true,
26922684
_ => false,
26932685
}
@@ -2703,9 +2695,8 @@ impl<'a> Parser<'a> {
27032695
)?;
27042696
let guard = if this.eat_keyword(kw::If) {
27052697
let if_span = this.prev_token.span;
2706-
let cond = this.with_let_management(true, |local_this| local_this.parse_expr())?;
2707-
let has_let_expr = check_let_expr(&cond);
2708-
if has_let_expr {
2698+
let cond = this.parse_expr_res(Restrictions::ALLOW_LET, None)?;
2699+
if check_let_expr(&cond) {
27092700
let span = if_span.to(cond.span);
27102701
this.sess.gated_spans.gate(sym::if_let_guard, span);
27112702
}
@@ -3279,17 +3270,4 @@ impl<'a> Parser<'a> {
32793270
Ok((res, trailing))
32803271
})
32813272
}
3282-
3283-
// Calls `f` with the internal `let_expr_allowed` set to `let_expr_allowed` and then
3284-
// sets the internal `let_expr_allowed` back to its original value.
3285-
fn with_let_management<T>(
3286-
&mut self,
3287-
let_expr_allowed: bool,
3288-
f: impl FnOnce(&mut Self) -> T,
3289-
) -> T {
3290-
let last_let_expr_allowed = mem::replace(&mut self.let_expr_allowed, let_expr_allowed);
3291-
let rslt = f(self);
3292-
self.let_expr_allowed = last_let_expr_allowed;
3293-
rslt
3294-
}
32953273
}

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

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,7 @@ bitflags::bitflags! {
4747
const STMT_EXPR = 1 << 0;
4848
const NO_STRUCT_LITERAL = 1 << 1;
4949
const CONST_EXPR = 1 << 2;
50+
const ALLOW_LET = 1 << 3;
5051
}
5152
}
5253

@@ -147,15 +148,12 @@ pub struct Parser<'a> {
147148
/// This allows us to recover when the user forget to add braces around
148149
/// multiple statements in the closure body.
149150
pub current_closure: Option<ClosureSpans>,
150-
/// Used to track where `let`s are allowed. For example, `if true && let 1 = 1` is valid
151-
/// but `[1, 2, 3][let _ = ()]` is not.
152-
let_expr_allowed: bool,
153151
}
154152

155153
// This type is used a lot, e.g. it's cloned when matching many declarative macro rules. Make sure
156154
// it doesn't unintentionally get bigger.
157155
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
158-
rustc_data_structures::static_assert_size!(Parser<'_>, 336);
156+
rustc_data_structures::static_assert_size!(Parser<'_>, 328);
159157

160158
/// Stores span information about a closure.
161159
#[derive(Clone)]
@@ -458,7 +456,6 @@ impl<'a> Parser<'a> {
458456
inner_attr_ranges: Default::default(),
459457
},
460458
current_closure: None,
461-
let_expr_allowed: false,
462459
};
463460

464461
// Make parser point to the first token.

‎src/test/ui/rfc-2294-if-let-guard/feature-gate.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,8 @@ fn _if_let_guard() {
3232
() if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
3333
//~^ ERROR `if let` guards are experimental
3434
//~| ERROR expected expression, found `let` statement
35+
//~| ERROR expected expression, found `let` statement
36+
//~| ERROR expected expression, found `let` statement
3537

3638
() if let Range { start: _, end: _ } = (true..true) && false => {}
3739
//~^ ERROR `if let` guards are experimental

‎src/test/ui/rfc-2294-if-let-guard/feature-gate.stderr

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -41,19 +41,31 @@ LL | () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 =
4141
| ^^^
4242

4343
error: expected expression, found `let` statement
44-
--> $DIR/feature-gate.rs:52:16
44+
--> $DIR/feature-gate.rs:32:55
45+
|
46+
LL | () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
47+
| ^^^
48+
49+
error: expected expression, found `let` statement
50+
--> $DIR/feature-gate.rs:32:68
51+
|
52+
LL | () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
53+
| ^^^
54+
55+
error: expected expression, found `let` statement
56+
--> $DIR/feature-gate.rs:54:16
4557
|
4658
LL | use_expr!((let 0 = 1 && 0 == 0));
4759
| ^^^
4860

4961
error: expected expression, found `let` statement
50-
--> $DIR/feature-gate.rs:54:16
62+
--> $DIR/feature-gate.rs:56:16
5163
|
5264
LL | use_expr!((let 0 = 1));
5365
| ^^^
5466

5567
error: no rules expected the token `let`
56-
--> $DIR/feature-gate.rs:62:15
68+
--> $DIR/feature-gate.rs:64:15
5769
|
5870
LL | macro_rules! use_expr {
5971
| --------------------- when calling this macro
@@ -102,7 +114,7 @@ LL | () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 =
102114
= help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
103115

104116
error[E0658]: `if let` guards are experimental
105-
--> $DIR/feature-gate.rs:36:12
117+
--> $DIR/feature-gate.rs:38:12
106118
|
107119
LL | () if let Range { start: _, end: _ } = (true..true) && false => {}
108120
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +124,7 @@ LL | () if let Range { start: _, end: _ } = (true..true) && false => {}
112124
= help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
113125

114126
error[E0658]: `if let` guards are experimental
115-
--> $DIR/feature-gate.rs:58:12
127+
--> $DIR/feature-gate.rs:60:12
116128
|
117129
LL | () if let 0 = 1 => {}
118130
| ^^^^^^^^^^^^
@@ -121,6 +133,6 @@ LL | () if let 0 = 1 => {}
121133
= help: add `#![feature(if_let_guard)]` to the crate attributes to enable
122134
= help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
123135

124-
error: aborting due to 16 previous errors
136+
error: aborting due to 18 previous errors
125137

126138
For more information about this error, try `rustc --explain E0658`.

‎src/test/ui/rfc-2497-if-let-chains/disallowed-positions.rs

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,8 @@ fn _if() {
5151
//~| ERROR `let` expressions are not supported here
5252
//~| ERROR `let` expressions are not supported here
5353
//~| ERROR expected expression, found `let` statement
54+
//~| ERROR expected expression, found `let` statement
55+
//~| ERROR expected expression, found `let` statement
5456
}
5557

5658
fn _while() {
@@ -81,6 +83,8 @@ fn _while() {
8183
//~| ERROR `let` expressions are not supported here
8284
//~| ERROR `let` expressions are not supported here
8385
//~| ERROR expected expression, found `let` statement
86+
//~| ERROR expected expression, found `let` statement
87+
//~| ERROR expected expression, found `let` statement
8488
}
8589

8690
fn _macros() {
@@ -146,6 +150,7 @@ fn nested_within_if_expr() {
146150
//~| ERROR expected expression, found `let` statement
147151
if true || (true && let 0 = 0) {}
148152
//~^ ERROR `let` expressions are not supported here
153+
//~| ERROR expected expression, found `let` statement
149154

150155
let mut x = true;
151156
if x = let 0 = 0 {}
@@ -237,6 +242,7 @@ fn nested_within_while_expr() {
237242
//~| ERROR expected expression, found `let` statement
238243
while true || (true && let 0 = 0) {}
239244
//~^ ERROR `let` expressions are not supported here
245+
//~| ERROR expected expression, found `let` statement
240246

241247
let mut x = true;
242248
while x = let 0 = 0 {}
@@ -388,16 +394,19 @@ fn inside_const_generic_arguments() {
388394
if let A::<{
389395
true && let 1 = 1
390396
//~^ ERROR `let` expressions are not supported here
397+
//~| ERROR expected expression, found `let` statement
391398
}>::O = 5 {}
392399

393400
while let A::<{
394401
true && let 1 = 1
395402
//~^ ERROR `let` expressions are not supported here
403+
//~| ERROR expected expression, found `let` statement
396404
}>::O = 5 {}
397405

398406
if A::<{
399407
true && let 1 = 1
400408
//~^ ERROR `let` expressions are not supported here
409+
//~| ERROR expected expression, found `let` statement
401410
}>::O == 5 {}
402411

403412
// In the cases above we have `ExprKind::Block` to help us out.
@@ -409,7 +418,8 @@ fn inside_const_generic_arguments() {
409418
if A::<
410419
true && let 1 = 1
411420
//~^ ERROR `let` expressions are not supported here
412-
//~| ERROR expressions must be enclosed in braces
421+
//~| ERROR expressions must be enclosed in braces
422+
//~| ERROR expected expression, found `let` statement
413423
>::O == 5 {}
414424
}
415425

0 commit comments

Comments
 (0)