mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #59981 - estebank:recover-struct-lit, r=petrochenkov

Browse Source 
Emit specific error for struct literal in conditions

Fix #59962, fix #51311.
This commit is contained in:
bors 2019-04-19 20:15:11 +00:00
commit 8aaae4294b
17 changed files with 353 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustc_borrowck/borrowck/mod.rs
View File

@ -897,8 +897,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
self.cannot_borrow_path_as_mutable(error_span, &descr, Origin::Ast)
}
BorrowViolation(euv::ClosureInvocation) => {
span_bug!(err.span,
"err_mutbl with a closure invocation");
span_bug!(err.span, "err_mutbl with a closure invocation");
}
};
@ -1096,7 +1095,6 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
BorrowViolation(euv::MatchDiscriminant) => {
"cannot borrow data mutably"
}
BorrowViolation(euv::ClosureInvocation) => {
is_closure = true;
"closure invocation"

161
src/librustc_resolve/diagnostics.rs
View File

@ -240,6 +240,56 @@ impl<'a> Resolver<'a> {
(err, candidates)
}
fn followed_by_brace(&self, span: Span) -> (bool, Option<(Span, String)>) {
// HACK(estebank): find a better way to figure out that this was a
// parser issue where a struct literal is being used on an expression
// where a brace being opened means a block is being started. Look
// ahead for the next text to see if `span` is followed by a `{`.
let sm = self.session.source_map();
let mut sp = span;
loop {
sp = sm.next_point(sp);
match sm.span_to_snippet(sp) {
Ok(ref snippet) => {
if snippet.chars().any(|c| { !c.is_whitespace() }) {
break;
}
}
_ => break,
}
}
let followed_by_brace = match sm.span_to_snippet(sp) {
Ok(ref snippet) if snippet == "{" => true,
_ => false,
};
// In case this could be a struct literal that needs to be surrounded
// by parenthesis, find the appropriate span.
let mut i = 0;
let mut closing_brace = None;
loop {
sp = sm.next_point(sp);
match sm.span_to_snippet(sp) {
Ok(ref snippet) => {
if snippet == "}" {
let sp = span.to(sp);
if let Ok(snippet) = sm.span_to_snippet(sp) {
closing_brace = Some((sp, snippet));
}
break;
}
}
_ => break,
}
i += 1;
// The bigger the span, the more likely we're incorrect --
// bound it to 100 chars long.
if i > 100 {
break;
}
}
return (followed_by_brace, closing_brace)
}
/// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment`
/// function.
/// Returns `true` if able to provide context-dependent help.
@ -278,6 +328,39 @@ impl<'a> Resolver<'a> {
_ => false,
};
let mut bad_struct_syntax_suggestion = || {
let (followed_by_brace, closing_brace) = self.followed_by_brace(span);
let mut suggested = false;
match source {
PathSource::Expr(Some(parent)) => {
suggested = path_sep(err, &parent);
}
PathSource::Expr(None) if followed_by_brace == true => {
if let Some((sp, snippet)) = closing_brace {
err.span_suggestion(
sp,
"surround the struct literal with parenthesis",
format!("({})", snippet),
Applicability::MaybeIncorrect,
);
} else {
err.span_label(
span, // Note the parenthesis surrounding the suggestion below
format!("did you mean `({} {{ /* fields */ }})`?", path_str),
);
}
suggested = true;
},
_ => {}
}
if !suggested {
err.span_label(
span,
format!("did you mean `{} {{ /* fields */ }}`?", path_str),
);
}
};
match (def, source) {
(Def::Macro(..), _) => {
err.span_suggestion(
@ -331,87 +414,13 @@ impl<'a> Resolver<'a> {
);
}
} else {
// HACK(estebank): find a better way to figure out that this was a
// parser issue where a struct literal is being used on an expression
// where a brace being opened means a block is being started. Look
// ahead for the next text to see if `span` is followed by a `{`.
let sm = self.session.source_map();
let mut sp = span;
loop {
sp = sm.next_point(sp);
match sm.span_to_snippet(sp) {
Ok(ref snippet) => {
if snippet.chars().any(|c| { !c.is_whitespace() }) {
break;
}
}
_ => break,
}
}
let followed_by_brace = match sm.span_to_snippet(sp) {
Ok(ref snippet) if snippet == "{" => true,
_ => false,
};
// In case this could be a struct literal that needs to be surrounded
// by parenthesis, find the appropriate span.
let mut i = 0;
let mut closing_brace = None;
loop {
sp = sm.next_point(sp);
match sm.span_to_snippet(sp) {
Ok(ref snippet) => {
if snippet == "}" {
let sp = span.to(sp);
if let Ok(snippet) = sm.span_to_snippet(sp) {
closing_brace = Some((sp, snippet));
}
break;
}
}
_ => break,
}
i += 1;
// The bigger the span, the more likely we're incorrect --
// bound it to 100 chars long.
if i > 100 {
break;
}
}
match source {
PathSource::Expr(Some(parent)) => if !path_sep(err, &parent) {
err.span_label(
span,
format!("did you mean `{} {{ /* fields */ }}`?", path_str),
);
}
PathSource::Expr(None) if followed_by_brace == true => {
if let Some((sp, snippet)) = closing_brace {
err.span_suggestion(
sp,
"surround the struct literal with parenthesis",
format!("({})", snippet),
Applicability::MaybeIncorrect,
);
} else {
err.span_label(
span,
format!("did you mean `({} {{ /* fields */ }})`?", path_str),
);
}
},
_ => {
err.span_label(
span,
format!("did you mean `{} {{ /* fields */ }}`?", path_str),
);
},
}
bad_struct_syntax_suggestion();
}
}
(Def::Union(..), _) |
(Def::Variant(..), _) |
(Def::Ctor(_, _, CtorKind::Fictive), _) if ns == ValueNS => {
err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", path_str));
bad_struct_syntax_suggestion();
}
(Def::SelfTy(..), _) if ns == ValueNS => {
err.span_label(span, fallback_label);

53
src/libsyntax/parse/parser.rs
View File

@ -2855,11 +2855,13 @@ impl<'a> Parser<'a> {
let (delim, tts) = self.expect_delimited_token_tree()?;
hi = self.prev_span;
ex = ExprKind::Mac(respan(lo.to(hi), Mac_ { path, tts, delim }));
} else if self.check(&token::OpenDelim(token::Brace)) &&
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) {
// This is a struct literal, unless we're prohibited
// from parsing struct literals here.
return self.parse_struct_expr(lo, path, attrs);
} else if self.check(&token::OpenDelim(token::Brace)) {
if let Some(expr) = self.maybe_parse_struct_expr(lo, &path, &attrs) {
return expr;
} else {
hi = path.span;
ex = ExprKind::Path(None, path);
}
} else {
hi = path.span;
ex = ExprKind::Path(None, path);
@ -2902,6 +2904,47 @@ impl<'a> Parser<'a> {
self.maybe_recover_from_bad_qpath(expr, true)
}
fn maybe_parse_struct_expr(
&mut self,
lo: Span,
path: &ast::Path,
attrs: &ThinVec<Attribute>,
) -> Option<PResult<'a, P<Expr>>> {
let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
let certainly_not_a_block = || self.look_ahead(1, |t| t.is_ident()) && (
// `{ ident, ` cannot start a block
self.look_ahead(2, |t| t == &token::Comma) ||
self.look_ahead(2, |t| t == &token::Colon) && (
// `{ ident: token, ` cannot start a block
self.look_ahead(4, |t| t == &token::Comma) ||
// `{ ident: ` cannot start a block unless it's a type ascription `ident: Type`
self.look_ahead(3, |t| !t.can_begin_type())
)
);
if struct_allowed || certainly_not_a_block() {
// This is a struct literal, but we don't can't accept them here
let expr = self.parse_struct_expr(lo, path.clone(), attrs.clone());
if let (Ok(expr), false) = (&expr, struct_allowed) {
let mut err = self.diagnostic().struct_span_err(
expr.span,
"struct literals are not allowed here",
);
err.multipart_suggestion(
"surround the struct literal with parenthesis",
vec![
(lo.shrink_to_lo(), "(".to_string()),
(expr.span.shrink_to_hi(), ")".to_string()),
],
Applicability::MachineApplicable,
);
err.emit();
}
return Some(expr);
}
None
}
fn parse_struct_expr(&mut self, lo: Span, pth: ast::Path, mut attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>> {
let struct_sp = lo.to(self.prev_span);

6
src/test/ui/error-codes/E0423.rs
View File

@ -10,8 +10,7 @@ fn bar() {
struct T {}
if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
//~^ ERROR E0423
//~| expected type, found `1`
//~^ ERROR struct literals are not allowed here
if T {} == T {} { println!("Ok"); }
//~^ ERROR E0423
//~| ERROR expected expression, found `==`
@ -19,6 +18,5 @@ fn bar() {
fn foo() {
for _ in std::ops::Range { start: 0, end: 10 } {}
//~^ ERROR E0423
//~| ERROR expected type, found `0`
//~^ ERROR struct literals are not allowed here
}

54
src/test/ui/error-codes/E0423.stderr
View File

@ -1,36 +1,28 @@
error: expected type, found `1`
--> $DIR/E0423.rs:12:39
error: struct literals are not allowed here
--> $DIR/E0423.rs:12:32
|
LL | if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
| ^ expecting a type here because of type ascription
| ^^^^^^^^^^^^^^^^
help: surround the struct literal with parenthesis
|
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
note: this expression expects an ascribed type after the colon
--> $DIR/E0423.rs:12:36
|
LL | if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
| ^
= help: this might be indicative of a syntax error elsewhere
LL | if let S { x: _x, y: 2 } = (S { x: 1, y: 2 }) { println!("Ok"); }
| ^ ^
error: expected expression, found `==`
--> $DIR/E0423.rs:15:13
--> $DIR/E0423.rs:14:13
|
LL | if T {} == T {} { println!("Ok"); }
| ^^ expected expression
error: expected type, found `0`
--> $DIR/E0423.rs:21:39
error: struct literals are not allowed here
--> $DIR/E0423.rs:20:14
|
LL | for _ in std::ops::Range { start: 0, end: 10 } {}
| ^ expecting a type here because of type ascription
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: surround the struct literal with parenthesis
|
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
note: this expression expects an ascribed type after the colon
--> $DIR/E0423.rs:21:32
|
LL | for _ in std::ops::Range { start: 0, end: 10 } {}
| ^^^^^
= help: this might be indicative of a syntax error elsewhere
LL | for _ in (std::ops::Range { start: 0, end: 10 }) {}
| ^ ^
error[E0423]: expected function, found struct `Foo`
--> $DIR/E0423.rs:4:13
@ -41,30 +33,14 @@ LL | let f = Foo();
| did you mean `Foo { /* fields */ }`?
| help: a function with a similar name exists: `foo`
error[E0423]: expected value, found struct `S`
--> $DIR/E0423.rs:12:32
|
LL | if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
| ^---------------
| |
| help: surround the struct literal with parenthesis: `(S { x: 1, y: 2 })`
error[E0423]: expected value, found struct `T`
--> $DIR/E0423.rs:15:8
--> $DIR/E0423.rs:14:8
|
LL | if T {} == T {} { println!("Ok"); }
| ^---
| |
| help: surround the struct literal with parenthesis: `(T {})`
error[E0423]: expected value, found struct `std::ops::Range`
--> $DIR/E0423.rs:21:14
|
LL | for _ in std::ops::Range { start: 0, end: 10 } {}
| ^^^^^^^^^^^^^^^----------------------
| |
| help: surround the struct literal with parenthesis: `(std::ops::Range { start: 0, end: 10 })`
error: aborting due to 7 previous errors
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0423`.

6
src/test/ui/parser/struct-literal-in-for.rs
View File

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

51
src/test/ui/parser/struct-literal-in-for.stderr
View File

@ -1,29 +1,30 @@
error: expected type, found `3`
--> $DIR/struct-literal-in-for.rs:13:12
|
LL | x: 3
| ^ expecting a type here because of type ascription
|
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
note: this expression expects an ascribed type after the colon
--> $DIR/struct-literal-in-for.rs:13:9
|
LL | x: 3
| ^
= help: this might be indicative of a syntax error elsewhere
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
--> $DIR/struct-literal-in-for.rs:14:12
|
LL | }.hi() {
| ^ expected one of `.`, `;`, `?`, `}`, or an operator here
error[E0423]: expected value, found struct `Foo`
error: struct literals are not allowed here
--> $DIR/struct-literal-in-for.rs:12:14
|
LL | for x in Foo {
| ^^^ did you mean `(Foo { /* fields */ })`?
LL | for x in Foo {
| ______________^
LL | | x: 3
LL | | }.hi() {
| |_____^
help: surround the struct literal with parenthesis
|
LL | for x in (Foo {
LL | x: 3
LL | }).hi() {
|
error: aborting due to 3 previous errors
error[E0277]: `bool` is not an iterator
--> $DIR/struct-literal-in-for.rs:12:14
|
LL | for x in Foo {
| ______________^
LL | | x: 3
LL | | }.hi() {
| |__________^ `bool` is not an iterator
|
= help: the trait `std::iter::Iterator` is not implemented for `bool`
= note: required by `std::iter::IntoIterator::into_iter`
For more information about this error, try `rustc --explain E0423`.
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

6
src/test/ui/parser/struct-literal-in-if.rs
View File

@ -9,9 +9,9 @@ impl Foo {
}
fn main() {
if Foo { //~ ERROR expected value, found struct `Foo`
x: 3 //~ ERROR expected type, found `3`
}.hi() { //~ ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
if Foo { //~ ERROR struct literals are not allowed here
x: 3
}.hi() {
println!("yo");
}
}

38
src/test/ui/parser/struct-literal-in-if.stderr
View File

@ -1,29 +1,17 @@
error: expected type, found `3`
--> $DIR/struct-literal-in-if.rs:13:12
|
LL | x: 3
| ^ expecting a type here because of type ascription
|
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
note: this expression expects an ascribed type after the colon
--> $DIR/struct-literal-in-if.rs:13:9
|
LL | x: 3
| ^
= help: this might be indicative of a syntax error elsewhere
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
--> $DIR/struct-literal-in-if.rs:14:12
|
LL | }.hi() {
| ^ expected one of `.`, `;`, `?`, `}`, or an operator here
error[E0423]: expected value, found struct `Foo`
error: struct literals are not allowed here
--> $DIR/struct-literal-in-if.rs:12:8
|
LL | if Foo {
| ^^^ did you mean `(Foo { /* fields */ })`?
LL | if Foo {
| ________^
LL | | x: 3
LL | | }.hi() {
| |_____^
help: surround the struct literal with parenthesis
|
LL | if (Foo {
LL | x: 3
LL | }).hi() {
|
error: aborting due to 3 previous errors
error: aborting due to previous error
For more information about this error, try `rustc --explain E0423`.

10
src/test/ui/parser/struct-literal-in-match-discriminant.rs
View File

@ -3,11 +3,11 @@ struct Foo {
}
fn main() {
match Foo { //~ ERROR expected value, found struct `Foo`
x: 3 //~ ERROR expected one of `=>`, `@`, `if`, or `|`, found `:`
match Foo { //~ ERROR struct literals are not allowed here
x: 3
} {
Foo { //~ ERROR mismatched types
x: x //~ ERROR cannot find value `x` in this scope
} => {} //~ ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `=>`
Foo {
x: x
} => {}
}
}

47
src/test/ui/parser/struct-literal-in-match-discriminant.stderr
View File

@ -1,42 +1,17 @@
error: expected one of `=>`, `@`, `if`, or `|`, found `:`
--> $DIR/struct-literal-in-match-discriminant.rs:7:10
|
LL | x: 3
| ^ expected one of `=>`, `@`, `if`, or `|` here
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `=>`
--> $DIR/struct-literal-in-match-discriminant.rs:11:11
|
LL | } => {}
| ^^ expected one of `.`, `;`, `?`, `}`, or an operator here
error[E0423]: expected value, found struct `Foo`
error: struct literals are not allowed here
--> $DIR/struct-literal-in-match-discriminant.rs:6:11
|
LL | match Foo {
| ^^^ did you mean `(Foo { /* fields */ })`?
error[E0425]: cannot find value `x` in this scope
--> $DIR/struct-literal-in-match-discriminant.rs:10:16
LL | match Foo {
| ___________^
LL | | x: 3
LL | | } {
| |_____^
help: surround the struct literal with parenthesis
|
LL | x: x
| ^ not found in this scope
error[E0308]: mismatched types
--> $DIR/struct-literal-in-match-discriminant.rs:9:9
LL | match (Foo {
LL | x: 3
LL | }) {
|
LL | fn main() {
| - expected `()` because of default return type
...
LL | / Foo {
LL | | x: x
LL | | } => {}
| |_________^ expected (), found struct `Foo`
|
= note: expected type `()`
found type `Foo`
error: aborting due to 5 previous errors
error: aborting due to previous error
Some errors have detailed explanations: E0308, E0423, E0425.
For more information about an error, try `rustc --explain E0308`.

7
src/test/ui/parser/struct-literal-in-while.rs
View File

@ -9,10 +9,9 @@ impl Foo {
}
fn main() {
while Foo { //~ ERROR expected value, found struct `Foo`
x: 3 //~ ERROR expected type, found `3`
}.hi() { //~ ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
//~| ERROR no method named `hi` found for type `()` in the current scope
while Foo { //~ ERROR struct literals are not allowed here
x: 3
}.hi() {
println!("yo");
}
}

43
src/test/ui/parser/struct-literal-in-while.stderr
View File

@ -1,36 +1,17 @@
error: expected type, found `3`
--> $DIR/struct-literal-in-while.rs:13:12
|
LL | x: 3
| ^ expecting a type here because of type ascription
|
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
note: this expression expects an ascribed type after the colon
--> $DIR/struct-literal-in-while.rs:13:9
|
LL | x: 3
| ^
= help: this might be indicative of a syntax error elsewhere
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
--> $DIR/struct-literal-in-while.rs:14:12
|
LL | }.hi() {
| ^ expected one of `.`, `;`, `?`, `}`, or an operator here
error[E0423]: expected value, found struct `Foo`
error: struct literals are not allowed here
--> $DIR/struct-literal-in-while.rs:12:11
|
LL | while Foo {
| ^^^ did you mean `(Foo { /* fields */ })`?
error[E0599]: no method named `hi` found for type `()` in the current scope
--> $DIR/struct-literal-in-while.rs:14:7
LL | while Foo {
| ___________^
LL | | x: 3
LL | | }.hi() {
| |_____^
help: surround the struct literal with parenthesis
|
LL | while (Foo {
LL | x: 3
LL | }).hi() {
|
LL | }.hi() {
| ^^
error: aborting due to 4 previous errors
error: aborting due to previous error
Some errors have detailed explanations: E0423, E0599.
For more information about an error, try `rustc --explain E0423`.

7
src/test/ui/parser/struct-literal-restrictions-in-lamda.rs
View File

@ -9,10 +9,9 @@ impl Foo {
}
fn main() {
while || Foo { //~ ERROR expected value, found struct `Foo`
x: 3 //~ ERROR expected type, found `3`
}.hi() { //~ ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
//~| ERROR no method named `hi` found for type `()` in the current scope
while || Foo { //~ ERROR struct literals are not allowed here
x: 3 //~^ ERROR mismatched types
}.hi() {
println!("yo");
}
}

56
src/test/ui/parser/struct-literal-restrictions-in-lamda.stderr
View File

@ -1,36 +1,30 @@
error: expected type, found `3`
--> $DIR/struct-literal-restrictions-in-lamda.rs:13:12
|
LL | x: 3
| ^ expecting a type here because of type ascription
|
= note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
note: this expression expects an ascribed type after the colon
--> $DIR/struct-literal-restrictions-in-lamda.rs:13:9
|
LL | x: 3
| ^
= help: this might be indicative of a syntax error elsewhere
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
--> $DIR/struct-literal-restrictions-in-lamda.rs:14:12
|
LL | }.hi() {
| ^ expected one of `.`, `;`, `?`, `}`, or an operator here
error[E0423]: expected value, found struct `Foo`
error: struct literals are not allowed here
--> $DIR/struct-literal-restrictions-in-lamda.rs:12:14
|
LL | while || Foo {
| ^^^ did you mean `(Foo { /* fields */ })`?
error[E0599]: no method named `hi` found for type `()` in the current scope
--> $DIR/struct-literal-restrictions-in-lamda.rs:14:7
LL | while || Foo {
| ______________^
LL | | x: 3
LL | | }.hi() {
| |_____^
help: surround the struct literal with parenthesis
|
LL | while || (Foo {
LL | x: 3
LL | }).hi() {
|
LL | }.hi() {
| ^^
error: aborting due to 4 previous errors
error[E0308]: mismatched types
--> $DIR/struct-literal-restrictions-in-lamda.rs:12:11
|
LL | while || Foo {
| ___________^
LL | | x: 3
LL | | }.hi() {
| |__________^ expected bool, found closure
|
= note: expected type `bool`
found type `[closure@$DIR/struct-literal-restrictions-in-lamda.rs:12:11: 14:11]`
Some errors have detailed explanations: E0423, E0599.
For more information about an error, try `rustc --explain E0423`.
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

25
src/test/ui/struct-literal-variant-in-if.rs Normal file
View File

@ -0,0 +1,25 @@
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
enum E {
V { field: bool },
I { field1: bool, field2: usize },
J { field: isize },
K { field: &'static str},
}
fn test_E(x: E) {
let field = true;
if x == E::V { field } {}
//~^ ERROR expected value, found struct variant `E::V`
//~| ERROR mismatched types
if x == E::I { field1: true, field2: 42 } {}
//~^ ERROR struct literals are not allowed here
if x == E::V { field: false } {}
//~^ ERROR struct literals are not allowed here
if x == E::J { field: -42 } {}
//~^ ERROR struct literals are not allowed here
if x == E::K { field: "" } {}
//~^ ERROR struct literals are not allowed here
let y: usize = ();
//~^ ERROR mismatched types
}
fn main() {}

73
src/test/ui/struct-literal-variant-in-if.stderr Normal file
View File

@ -0,0 +1,73 @@
error: struct literals are not allowed here
--> $DIR/struct-literal-variant-in-if.rs:13:13
|
LL | if x == E::I { field1: true, field2: 42 } {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: surround the struct literal with parenthesis
|
LL | if x == (E::I { field1: true, field2: 42 }) {}
| ^ ^
error: struct literals are not allowed here
--> $DIR/struct-literal-variant-in-if.rs:15:13
|
LL | if x == E::V { field: false } {}
| ^^^^^^^^^^^^^^^^^^^^^
help: surround the struct literal with parenthesis
|
LL | if x == (E::V { field: false }) {}
| ^ ^
error: struct literals are not allowed here
--> $DIR/struct-literal-variant-in-if.rs:17:13
|
LL | if x == E::J { field: -42 } {}
| ^^^^^^^^^^^^^^^^^^^
help: surround the struct literal with parenthesis
|
LL | if x == (E::J { field: -42 }) {}
| ^ ^
error: struct literals are not allowed here
--> $DIR/struct-literal-variant-in-if.rs:19:13
|
LL | if x == E::K { field: "" } {}
| ^^^^^^^^^^^^^^^^^^
help: surround the struct literal with parenthesis
|
LL | if x == (E::K { field: "" }) {}
| ^ ^
error[E0423]: expected value, found struct variant `E::V`
--> $DIR/struct-literal-variant-in-if.rs:10:13
|
LL | if x == E::V { field } {}
| ^^^^----------
| |
| help: surround the struct literal with parenthesis: `(E::V { field })`
error[E0308]: mismatched types
--> $DIR/struct-literal-variant-in-if.rs:10:20
|
LL | fn test_E(x: E) {
| - help: try adding a return type: `-> bool`
LL | let field = true;
LL | if x == E::V { field } {}
| ^^^^^ expected (), found bool
|
= note: expected type `()`
found type `bool`
error[E0308]: mismatched types
--> $DIR/struct-literal-variant-in-if.rs:21:20
|
LL | let y: usize = ();
| ^^ expected usize, found ()
|
= note: expected type `usize`
found type `()`
error: aborting due to 7 previous errors
Some errors have detailed explanations: E0308, E0423.
For more information about an error, try `rustc --explain E0308`.