Skip to content

Commit ae494d1

Browse files
estebankestebank
committed
Detect match arm body without braces
Fix #82524.
1 parent 795a934 commit ae494d1

4 files changed

Lines changed: 334 additions & 1 deletion

File tree

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

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1973,6 +1973,102 @@ impl<'a> Parser<'a> {
19731973
Ok(self.mk_expr(lo.to(hi), ExprKind::Match(scrutinee, arms), attrs))
19741974
}
19751975

1976+
/// Attempt to recover from match arm body with statements and no surrounding braces.
1977+
fn parse_arm_body_missing_braces(
1978+
&mut self,
1979+
first_expr: &P<Expr>,
1980+
arrow_span: Span,
1981+
) -> Option<P<Expr>> {
1982+
if self.token.kind != token::Semi {
1983+
return None;
1984+
}
1985+
let start_snapshot = self.clone();
1986+
let semi_sp = self.token.span;
1987+
self.bump(); // `;`
1988+
let mut stmts =
1989+
vec![self.mk_stmt(first_expr.span, ast::StmtKind::Expr(first_expr.clone()))];
1990+
let err = |this: &mut Parser<'_>, stmts: Vec<ast::Stmt>| {
1991+
let span = stmts[0].span.to(stmts[stmts.len() - 1].span);
1992+
let mut err = this.struct_span_err(span, "`match` arm body without braces");
1993+
let (these, s, are) =
1994+
if stmts.len() > 1 { ("these", "s", "are") } else { ("this", "", "is") };
1995+
err.span_label(
1996+
span,
1997+
&format!(
1998+
"{these} statement{s} {are} not surrounded by a body",
1999+
these = these,
2000+
s = s,
2001+
are = are
2002+
),
2003+
);
2004+
err.span_label(arrow_span, "while parsing the `match` arm starting here");
2005+
if stmts.len() > 1 {
2006+
err.multipart_suggestion(
2007+
&format!("surround the statement{} with a body", s),
2008+
vec![
2009+
(span.shrink_to_lo(), "{ ".to_string()),
2010+
(span.shrink_to_hi(), " }".to_string()),
2011+
],
2012+
Applicability::MachineApplicable,
2013+
);
2014+
} else {
2015+
err.span_suggestion(
2016+
semi_sp,
2017+
"use a comma to end a `match` arm expression",
2018+
",".to_string(),
2019+
Applicability::MachineApplicable,
2020+
);
2021+
}
2022+
err.emit();
2023+
this.mk_expr_err(span)
2024+
};
2025+
// We might have either a `,` -> `;` typo, or a block without braces. We need
2026+
// a more subtle parsing strategy.
2027+
loop {
2028+
if self.token.kind == token::CloseDelim(token::Brace) {
2029+
// We have reached the closing brace of the `match` expression.
2030+
return Some(err(self, stmts));
2031+
}
2032+
if self.token.kind == token::Comma {
2033+
*self = start_snapshot;
2034+
return None;
2035+
}
2036+
let pre_pat_snapshot = self.clone();
2037+
match self.parse_pat_no_top_alt(None) {
2038+
Ok(_pat) => {
2039+
if self.token.kind == token::FatArrow {
2040+
// Reached arm end.
2041+
*self = pre_pat_snapshot;
2042+
return Some(err(self, stmts));
2043+
}
2044+
}
2045+
Err(mut err) => {
2046+
err.cancel();
2047+
}
2048+
}
2049+
2050+
*self = pre_pat_snapshot;
2051+
match self.parse_stmt_without_recovery(true, ForceCollect::No) {
2052+
// Consume statements for as long as possible.
2053+
Ok(Some(stmt)) => {
2054+
stmts.push(stmt);
2055+
}
2056+
Ok(None) => {
2057+
*self = start_snapshot;
2058+
break;
2059+
}
2060+
// We couldn't parse either yet another statement missing it's
2061+
// enclosing block nor the next arm's pattern or closing brace.
2062+
Err(mut stmt_err) => {
2063+
stmt_err.cancel();
2064+
*self = start_snapshot;
2065+
break;
2066+
}
2067+
}
2068+
}
2069+
None
2070+
}
2071+
19762072
pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm> {
19772073
let attrs = self.parse_outer_attributes()?;
19782074
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
@@ -2007,6 +2103,21 @@ impl<'a> Parser<'a> {
20072103

20082104
if require_comma {
20092105
let sm = this.sess.source_map();
2106+
if let Some(body) = this.parse_arm_body_missing_braces(&expr, arrow_span) {
2107+
let span = body.span;
2108+
return Ok((
2109+
ast::Arm {
2110+
attrs,
2111+
pat,
2112+
guard,
2113+
body,
2114+
span,
2115+
id: DUMMY_NODE_ID,
2116+
is_placeholder: false,
2117+
},
2118+
TrailingToken::None,
2119+
));
2120+
}
20102121
this.expect_one_of(&[token::Comma], &[token::CloseDelim(token::Brace)]).map_err(
20112122
|mut err| {
20122123
match (sm.span_to_lines(expr.span), sm.span_to_lines(arm_start_span)) {

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ impl<'a> Parser<'a> {
3434

3535
/// If `force_capture` is true, forces collection of tokens regardless of whether
3636
/// or not we have attributes
37-
fn parse_stmt_without_recovery(
37+
crate fn parse_stmt_without_recovery(
3838
&mut self,
3939
capture_semi: bool,
4040
force_collect: ForceCollect,

‎src/test/ui/parser/match-arm-without-braces.rs‎

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
struct S;
2+
3+
impl S {
4+
fn get<K, V: Default>(_: K) -> Option<V> {
5+
Default::default()
6+
}
7+
}
8+
9+
enum Val {
10+
Foo,
11+
Bar,
12+
}
13+
14+
impl Default for Val {
15+
fn default() -> Self {
16+
Val::Foo
17+
}
18+
}
19+
20+
fn main() {
21+
match S::get(1) {
22+
Some(Val::Foo) => {}
23+
_ => {}
24+
}
25+
match S::get(2) {
26+
Some(Val::Foo) => 3; //~ ERROR `match` arm body without braces
27+
_ => 4,
28+
}
29+
match S::get(5) {
30+
Some(Val::Foo) =>
31+
7; //~ ERROR `match` arm body without braces
32+
8;
33+
_ => 9,
34+
}
35+
match S::get(10) {
36+
Some(Val::Foo) =>
37+
11; //~ ERROR `match` arm body without braces
38+
12;
39+
_ => (),
40+
}
41+
match S::get(13) {
42+
None => {}
43+
Some(Val::Foo) =>
44+
14; //~ ERROR `match` arm body without braces
45+
15;
46+
}
47+
match S::get(16) {
48+
Some(Val::Foo) => 17
49+
_ => 18, //~ ERROR expected one of
50+
}
51+
match S::get(19) {
52+
Some(Val::Foo) =>
53+
20; //~ ERROR `match` arm body without braces
54+
21
55+
_ => 22,
56+
}
57+
match S::get(23) {
58+
Some(Val::Foo) =>
59+
24; //~ ERROR `match` arm body without braces
60+
25
61+
_ => (),
62+
}
63+
match S::get(26) {
64+
None => {}
65+
Some(Val::Foo) =>
66+
27; //~ ERROR `match` arm body without braces
67+
28
68+
}
69+
match S::get(29) {
70+
Some(Val::Foo) =>
71+
30; //~ ERROR expected one of
72+
31,
73+
_ => 32,
74+
}
75+
match S::get(33) {
76+
Some(Val::Foo) =>
77+
34; //~ ERROR expected one of
78+
35,
79+
_ => (),
80+
}
81+
match S::get(36) {
82+
None => {}
83+
Some(Val::Foo) =>
84+
37; //~ ERROR expected one of
85+
38,
86+
}
87+
}

‎src/test/ui/parser/match-arm-without-braces.stderr‎

Lines changed: 135 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,135 @@
1+
error: `match` arm body without braces
2+
--> $DIR/match-arm-without-braces.rs:26:27
3+
|
4+
LL | Some(Val::Foo) => 3;
5+
| -- ^- help: use a comma to end a `match` arm expression: `,`
6+
| | |
7+
| | this statement is not surrounded by a body
8+
| while parsing the `match` arm starting here
9+
10+
error: `match` arm body without braces
11+
--> $DIR/match-arm-without-braces.rs:31:11
12+
|
13+
LL | Some(Val::Foo) =>
14+
| -- while parsing the `match` arm starting here
15+
LL | / 7;
16+
LL | | 8;
17+
| |____________^ these statements are not surrounded by a body
18+
|
19+
help: surround the statements with a body
20+
|
21+
LL | { 7;
22+
LL | 8; }
23+
|
24+
25+
error: `match` arm body without braces
26+
--> $DIR/match-arm-without-braces.rs:37:11
27+
|
28+
LL | Some(Val::Foo) =>
29+
| -- while parsing the `match` arm starting here
30+
LL | / 11;
31+
LL | | 12;
32+
| |_____________^ these statements are not surrounded by a body
33+
|
34+
help: surround the statements with a body
35+
|
36+
LL | { 11;
37+
LL | 12; }
38+
|
39+
40+
error: `match` arm body without braces
41+
--> $DIR/match-arm-without-braces.rs:44:11
42+
|
43+
LL | Some(Val::Foo) =>
44+
| -- while parsing the `match` arm starting here
45+
LL | / 14;
46+
LL | | 15;
47+
| |_____________^ these statements are not surrounded by a body
48+
|
49+
help: surround the statements with a body
50+
|
51+
LL | { 14;
52+
LL | 15; }
53+
|
54+
55+
error: expected one of `,`, `.`, `?`, `}`, or an operator, found reserved identifier `_`
56+
--> $DIR/match-arm-without-braces.rs:49:9
57+
|
58+
LL | Some(Val::Foo) => 17
59+
| -- - expected one of `,`, `.`, `?`, `}`, or an operator
60+
| |
61+
| while parsing the `match` arm starting here
62+
LL | _ => 18,
63+
| ^ unexpected token
64+
65+
error: `match` arm body without braces
66+
--> $DIR/match-arm-without-braces.rs:53:11
67+
|
68+
LL | Some(Val::Foo) =>
69+
| -- while parsing the `match` arm starting here
70+
LL | / 20;
71+
LL | | 21
72+
| |____________^ these statements are not surrounded by a body
73+
|
74+
help: surround the statements with a body
75+
|
76+
LL | { 20;
77+
LL | 21 }
78+
|
79+
80+
error: `match` arm body without braces
81+
--> $DIR/match-arm-without-braces.rs:59:11
82+
|
83+
LL | Some(Val::Foo) =>
84+
| -- while parsing the `match` arm starting here
85+
LL | / 24;
86+
LL | | 25
87+
| |____________^ these statements are not surrounded by a body
88+
|
89+
help: surround the statements with a body
90+
|
91+
LL | { 24;
92+
LL | 25 }
93+
|
94+
95+
error: `match` arm body without braces
96+
--> $DIR/match-arm-without-braces.rs:66:11
97+
|
98+
LL | Some(Val::Foo) =>
99+
| -- while parsing the `match` arm starting here
100+
LL | / 27;
101+
LL | | 28
102+
| |____________^ these statements are not surrounded by a body
103+
|
104+
help: surround the statements with a body
105+
|
106+
LL | { 27;
107+
LL | 28 }
108+
|
109+
110+
error: expected one of `,`, `.`, `?`, `}`, or an operator, found `;`
111+
--> $DIR/match-arm-without-braces.rs:71:13
112+
|
113+
LL | Some(Val::Foo) =>
114+
| -- while parsing the `match` arm starting here
115+
LL | 30;
116+
| ^ expected one of `,`, `.`, `?`, `}`, or an operator
117+
118+
error: expected one of `,`, `.`, `?`, `}`, or an operator, found `;`
119+
--> $DIR/match-arm-without-braces.rs:77:13
120+
|
121+
LL | Some(Val::Foo) =>
122+
| -- while parsing the `match` arm starting here
123+
LL | 34;
124+
| ^ expected one of `,`, `.`, `?`, `}`, or an operator
125+
126+
error: expected one of `,`, `.`, `?`, `}`, or an operator, found `;`
127+
--> $DIR/match-arm-without-braces.rs:84:13
128+
|
129+
LL | Some(Val::Foo) =>
130+
| -- while parsing the `match` arm starting here
131+
LL | 37;
132+
| ^ expected one of `,`, `.`, `?`, `}`, or an operator
133+
134+
error: aborting due to 11 previous errors
135+

0 commit comments

Comments
 (0)