Skip to content

Commit a0af655

Browse files
CentrilCentril
authored
Rollup merge of rust-lang#59981 - estebank:recover-struct-lit, r=petrochenkov
Emit specific error for struct literal in conditions Fix rust-lang#59962, fix rust-lang#51311.
2 parents 0895f9a + 9c42ec3 commit a0af655

17 files changed

+341
-282
lines changed

‎src/librustc_borrowck/borrowck/mod.rs

+1-3
Original file line numberDiff line numberDiff line change
@@ -897,8 +897,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
897897
self.cannot_borrow_path_as_mutable(error_span, &descr, Origin::Ast)
898898
}
899899
BorrowViolation(euv::ClosureInvocation) => {
900-
span_bug!(err.span,
901-
"err_mutbl with a closure invocation");
900+
span_bug!(err.span, "err_mutbl with a closure invocation");
902901
}
903902
};
904903

@@ -1096,7 +1095,6 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
10961095
BorrowViolation(euv::MatchDiscriminant) => {
10971096
"cannot borrow data mutably"
10981097
}
1099-
11001098
BorrowViolation(euv::ClosureInvocation) => {
11011099
is_closure = true;
11021100
"closure invocation"

‎src/librustc_resolve/diagnostics.rs

+85-76
Original file line numberDiff line numberDiff line change
@@ -238,6 +238,56 @@ impl<'a> Resolver<'a> {
238238
(err, candidates)
239239
}
240240

241+
fn followed_by_brace(&self, span: Span) -> (bool, Option<(Span, String)>) {
242+
// HACK(estebank): find a better way to figure out that this was a
243+
// parser issue where a struct literal is being used on an expression
244+
// where a brace being opened means a block is being started. Look
245+
// ahead for the next text to see if `span` is followed by a `{`.
246+
let sm = self.session.source_map();
247+
let mut sp = span;
248+
loop {
249+
sp = sm.next_point(sp);
250+
match sm.span_to_snippet(sp) {
251+
Ok(ref snippet) => {
252+
if snippet.chars().any(|c| { !c.is_whitespace() }) {
253+
break;
254+
}
255+
}
256+
_ => break,
257+
}
258+
}
259+
let followed_by_brace = match sm.span_to_snippet(sp) {
260+
Ok(ref snippet) if snippet == "{" => true,
261+
_ => false,
262+
};
263+
// In case this could be a struct literal that needs to be surrounded
264+
// by parenthesis, find the appropriate span.
265+
let mut i = 0;
266+
let mut closing_brace = None;
267+
loop {
268+
sp = sm.next_point(sp);
269+
match sm.span_to_snippet(sp) {
270+
Ok(ref snippet) => {
271+
if snippet == "}" {
272+
let sp = span.to(sp);
273+
if let Ok(snippet) = sm.span_to_snippet(sp) {
274+
closing_brace = Some((sp, snippet));
275+
}
276+
break;
277+
}
278+
}
279+
_ => break,
280+
}
281+
i += 1;
282+
// The bigger the span, the more likely we're incorrect --
283+
// bound it to 100 chars long.
284+
if i > 100 {
285+
break;
286+
}
287+
}
288+
return (followed_by_brace, closing_brace)
289+
}
290+
241291
/// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment`
242292
/// function.
243293
/// Returns `true` if able to provide context-dependent help.
@@ -276,6 +326,39 @@ impl<'a> Resolver<'a> {
276326
_ => false,
277327
};
278328

329+
let mut bad_struct_syntax_suggestion = || {
330+
let (followed_by_brace, closing_brace) = self.followed_by_brace(span);
331+
let mut suggested = false;
332+
match source {
333+
PathSource::Expr(Some(parent)) => {
334+
suggested = path_sep(err, &parent);
335+
}
336+
PathSource::Expr(None) if followed_by_brace == true => {
337+
if let Some((sp, snippet)) = closing_brace {
338+
err.span_suggestion(
339+
sp,
340+
"surround the struct literal with parenthesis",
341+
format!("({})", snippet),
342+
Applicability::MaybeIncorrect,
343+
);
344+
} else {
345+
err.span_label(
346+
span, // Note the parenthesis surrounding the suggestion below
347+
format!("did you mean `({} {{ /* fields */ }})`?", path_str),
348+
);
349+
}
350+
suggested = true;
351+
},
352+
_ => {}
353+
}
354+
if !suggested {
355+
err.span_label(
356+
span,
357+
format!("did you mean `{} {{ /* fields */ }}`?", path_str),
358+
);
359+
}
360+
};
361+
279362
match (def, source) {
280363
(Def::Macro(..), _) => {
281364
err.span_suggestion(
@@ -329,87 +412,13 @@ impl<'a> Resolver<'a> {
329412
);
330413
}
331414
} else {
332-
// HACK(estebank): find a better way to figure out that this was a
333-
// parser issue where a struct literal is being used on an expression
334-
// where a brace being opened means a block is being started. Look
335-
// ahead for the next text to see if `span` is followed by a `{`.
336-
let sm = self.session.source_map();
337-
let mut sp = span;
338-
loop {
339-
sp = sm.next_point(sp);
340-
match sm.span_to_snippet(sp) {
341-
Ok(ref snippet) => {
342-
if snippet.chars().any(|c| { !c.is_whitespace() }) {
343-
break;
344-
}
345-
}
346-
_ => break,
347-
}
348-
}
349-
let followed_by_brace = match sm.span_to_snippet(sp) {
350-
Ok(ref snippet) if snippet == "{" => true,
351-
_ => false,
352-
};
353-
// In case this could be a struct literal that needs to be surrounded
354-
// by parenthesis, find the appropriate span.
355-
let mut i = 0;
356-
let mut closing_brace = None;
357-
loop {
358-
sp = sm.next_point(sp);
359-
match sm.span_to_snippet(sp) {
360-
Ok(ref snippet) => {
361-
if snippet == "}" {
362-
let sp = span.to(sp);
363-
if let Ok(snippet) = sm.span_to_snippet(sp) {
364-
closing_brace = Some((sp, snippet));
365-
}
366-
break;
367-
}
368-
}
369-
_ => break,
370-
}
371-
i += 1;
372-
// The bigger the span, the more likely we're incorrect --
373-
// bound it to 100 chars long.
374-
if i > 100 {
375-
break;
376-
}
377-
}
378-
match source {
379-
PathSource::Expr(Some(parent)) => if !path_sep(err, &parent) {
380-
err.span_label(
381-
span,
382-
format!("did you mean `{} {{ /* fields */ }}`?", path_str),
383-
);
384-
}
385-
PathSource::Expr(None) if followed_by_brace == true => {
386-
if let Some((sp, snippet)) = closing_brace {
387-
err.span_suggestion(
388-
sp,
389-
"surround the struct literal with parenthesis",
390-
format!("({})", snippet),
391-
Applicability::MaybeIncorrect,
392-
);
393-
} else {
394-
err.span_label(
395-
span,
396-
format!("did you mean `({} {{ /* fields */ }})`?", path_str),
397-
);
398-
}
399-
},
400-
_ => {
401-
err.span_label(
402-
span,
403-
format!("did you mean `{} {{ /* fields */ }}`?", path_str),
404-
);
405-
},
406-
}
415+
bad_struct_syntax_suggestion();
407416
}
408417
}
409418
(Def::Union(..), _) |
410419
(Def::Variant(..), _) |
411420
(Def::Ctor(_, _, CtorKind::Fictive), _) if ns == ValueNS => {
412-
err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", path_str));
421+
bad_struct_syntax_suggestion();
413422
}
414423
(Def::SelfTy(..), _) if ns == ValueNS => {
415424
err.span_label(span, fallback_label);

‎src/libsyntax/parse/parser.rs

+48-5
Original file line numberDiff line numberDiff line change
@@ -2855,11 +2855,13 @@ impl<'a> Parser<'a> {
28552855
let (delim, tts) = self.expect_delimited_token_tree()?;
28562856
hi = self.prev_span;
28572857
ex = ExprKind::Mac(respan(lo.to(hi), Mac_ { path, tts, delim }));
2858-
} else if self.check(&token::OpenDelim(token::Brace)) &&
2859-
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) {
2860-
// This is a struct literal, unless we're prohibited
2861-
// from parsing struct literals here.
2862-
return self.parse_struct_expr(lo, path, attrs);
2858+
} else if self.check(&token::OpenDelim(token::Brace)) {
2859+
if let Some(expr) = self.maybe_parse_struct_expr(lo, &path, &attrs) {
2860+
return expr;
2861+
} else {
2862+
hi = path.span;
2863+
ex = ExprKind::Path(None, path);
2864+
}
28632865
} else {
28642866
hi = path.span;
28652867
ex = ExprKind::Path(None, path);
@@ -2902,6 +2904,47 @@ impl<'a> Parser<'a> {
29022904
self.maybe_recover_from_bad_qpath(expr, true)
29032905
}
29042906

2907+
fn maybe_parse_struct_expr(
2908+
&mut self,
2909+
lo: Span,
2910+
path: &ast::Path,
2911+
attrs: &ThinVec<Attribute>,
2912+
) -> Option<PResult<'a, P<Expr>>> {
2913+
let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
2914+
let certainly_not_a_block = || self.look_ahead(1, |t| t.is_ident()) && (
2915+
// `{ ident, ` cannot start a block
2916+
self.look_ahead(2, |t| t == &token::Comma) ||
2917+
self.look_ahead(2, |t| t == &token::Colon) && (
2918+
// `{ ident: token, ` cannot start a block
2919+
self.look_ahead(4, |t| t == &token::Comma) ||
2920+
// `{ ident: ` cannot start a block unless it's a type ascription `ident: Type`
2921+
self.look_ahead(3, |t| !t.can_begin_type())
2922+
)
2923+
);
2924+
2925+
if struct_allowed || certainly_not_a_block() {
2926+
// This is a struct literal, but we don't can't accept them here
2927+
let expr = self.parse_struct_expr(lo, path.clone(), attrs.clone());
2928+
if let (Ok(expr), false) = (&expr, struct_allowed) {
2929+
let mut err = self.diagnostic().struct_span_err(
2930+
expr.span,
2931+
"struct literals are not allowed here",
2932+
);
2933+
err.multipart_suggestion(
2934+
"surround the struct literal with parenthesis",
2935+
vec![
2936+
(lo.shrink_to_lo(), "(".to_string()),
2937+
(expr.span.shrink_to_hi(), ")".to_string()),
2938+
],
2939+
Applicability::MachineApplicable,
2940+
);
2941+
err.emit();
2942+
}
2943+
return Some(expr);
2944+
}
2945+
None
2946+
}
2947+
29052948
fn parse_struct_expr(&mut self, lo: Span, pth: ast::Path, mut attrs: ThinVec<Attribute>)
29062949
-> PResult<'a, P<Expr>> {
29072950
let struct_sp = lo.to(self.prev_span);

‎src/test/ui/error-codes/E0423.rs

+2-4
Original file line numberDiff line numberDiff line change
@@ -10,15 +10,13 @@ fn bar() {
1010
struct T {}
1111

1212
if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
13-
//~^ ERROR E0423
14-
//~| expected type, found `1`
13+
//~^ ERROR struct literals are not allowed here
1514
if T {} == T {} { println!("Ok"); }
1615
//~^ ERROR E0423
1716
//~| ERROR expected expression, found `==`
1817
}
1918

2019
fn foo() {
2120
for _ in std::ops::Range { start: 0, end: 10 } {}
22-
//~^ ERROR E0423
23-
//~| ERROR expected type, found `0`
21+
//~^ ERROR struct literals are not allowed here
2422
}

‎src/test/ui/error-codes/E0423.stderr

+15-39
Original file line numberDiff line numberDiff line change
@@ -1,36 +1,28 @@
1-
error: expected type, found `1`
2-
--> $DIR/E0423.rs:12:39
1+
error: struct literals are not allowed here
2+
--> $DIR/E0423.rs:12:32
33
|
44
LL | if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
5-
| ^ expecting a type here because of type ascription
6-
|
7-
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
8-
note: this expression expects an ascribed type after the colon
9-
--> $DIR/E0423.rs:12:36
5+
| ^^^^^^^^^^^^^^^^
6+
help: surround the struct literal with parenthesis
107
|
11-
LL | if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
12-
| ^
13-
= help: this might be indicative of a syntax error elsewhere
8+
LL | if let S { x: _x, y: 2 } = (S { x: 1, y: 2 }) { println!("Ok"); }
9+
| ^ ^
1410

1511
error: expected expression, found `==`
16-
--> $DIR/E0423.rs:15:13
12+
--> $DIR/E0423.rs:14:13
1713
|
1814
LL | if T {} == T {} { println!("Ok"); }
1915
| ^^ expected expression
2016

21-
error: expected type, found `0`
22-
--> $DIR/E0423.rs:21:39
17+
error: struct literals are not allowed here
18+
--> $DIR/E0423.rs:20:14
2319
|
2420
LL | for _ in std::ops::Range { start: 0, end: 10 } {}
25-
| ^ expecting a type here because of type ascription
21+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
22+
help: surround the struct literal with parenthesis
2623
|
27-
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
28-
note: this expression expects an ascribed type after the colon
29-
--> $DIR/E0423.rs:21:32
30-
|
31-
LL | for _ in std::ops::Range { start: 0, end: 10 } {}
32-
| ^^^^^
33-
= help: this might be indicative of a syntax error elsewhere
24+
LL | for _ in (std::ops::Range { start: 0, end: 10 }) {}
25+
| ^ ^
3426

3527
error[E0423]: expected function, found struct `Foo`
3628
--> $DIR/E0423.rs:4:13
@@ -41,30 +33,14 @@ LL | let f = Foo();
4133
| did you mean `Foo { /* fields */ }`?
4234
| help: a function with a similar name exists: `foo`
4335

44-
error[E0423]: expected value, found struct `S`
45-
--> $DIR/E0423.rs:12:32
46-
|
47-
LL | if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
48-
| ^---------------
49-
| |
50-
| help: surround the struct literal with parenthesis: `(S { x: 1, y: 2 })`
51-
5236
error[E0423]: expected value, found struct `T`
53-
--> $DIR/E0423.rs:15:8
37+
--> $DIR/E0423.rs:14:8
5438
|
5539
LL | if T {} == T {} { println!("Ok"); }
5640
| ^---
5741
| |
5842
| help: surround the struct literal with parenthesis: `(T {})`
5943

60-
error[E0423]: expected value, found struct `std::ops::Range`
61-
--> $DIR/E0423.rs:21:14
62-
|
63-
LL | for _ in std::ops::Range { start: 0, end: 10 } {}
64-
| ^^^^^^^^^^^^^^^----------------------
65-
| |
66-
| help: surround the struct literal with parenthesis: `(std::ops::Range { start: 0, end: 10 })`
67-
68-
error: aborting due to 7 previous errors
44+
error: aborting due to 5 previous errors
6945

7046
For more information about this error, try `rustc --explain E0423`.

‎src/test/ui/parser/struct-literal-in-for.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -9,9 +9,9 @@ impl Foo {
99
}
1010

1111
fn main() {
12-
for x in Foo { //~ ERROR expected value, found struct `Foo`
13-
x: 3 //~ ERROR expected type, found `3`
14-
}.hi() { //~ ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
12+
for x in Foo { //~ ERROR struct literals are not allowed here
13+
x: 3 //~^ ERROR `bool` is not an iterator
14+
}.hi() {
1515
println!("yo");
1616
}
1717
}

0 commit comments

Comments
 (0)