nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 14:55:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Tweak diagnostics

Browse Source 
* Recover from invalid `'label: ` before block.
* Make suggestion to enclose statements in a block multipart.
* Point at `match`, `while`, `loop` and `unsafe` keywords when failing
  to parse their expression.
* Do not suggest `{ ; }`.
* Do not suggest `|` when very unlikely to be what was wanted (in `let`
  statements).
This commit is contained in:
Esteban Kuber 2022-01-12 20:43:24 +00:00
parent 97cde9fe08
commit f42b4f595e
26 changed files with 316 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_expand/src/expand.rs
View File

@ -20,7 +20,7 @@ use rustc_data_structures::sync::Lrc;
use rustc_errors::{Applicability, PResult};
use rustc_feature::Features;
use rustc_parse::parser::{
AttemptLocalParseRecovery, ForceCollect, Parser, RecoverColon, RecoverComma,
AttemptLocalParseRecovery, CommaRecoveryMode, ForceCollect, Parser, RecoverColon, RecoverComma,
};
use rustc_parse::validate_attr;
use rustc_session::lint::builtin::{UNUSED_ATTRIBUTES, UNUSED_DOC_COMMENTS};
@ -911,6 +911,7 @@ pub fn parse_ast_fragment<'a>(
None,
RecoverComma::No,
RecoverColon::Yes,
CommaRecoveryMode::LikelyTuple,
)?),
AstFragmentKind::Crate => AstFragment::Crate(this.parse_crate_mod()?),
AstFragmentKind::Arms

53
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -1,8 +1,8 @@
use super::pat::Expected;
use super::ty::{AllowPlus, IsAsCast};
use super::{
BlockMode, Parser, PathStyle, RecoverColon, RecoverComma, Restrictions, SemiColonMode, SeqSep,
TokenExpectType, TokenType,
BlockMode, CommaRecoveryMode, Parser, PathStyle, RecoverColon, RecoverComma, Restrictions,
SemiColonMode, SeqSep, TokenExpectType, TokenType,
};
use rustc_ast as ast;
@ -2245,12 +2245,32 @@ impl<'a> Parser<'a> {
first_pat
}
crate fn maybe_recover_unexpected_block_label(&mut self) -> bool {
let Some(label) = self.eat_label().filter(|_| {
self.eat(&token::Colon) && self.token.kind == token::OpenDelim(token::Brace)
}) else {
return false;
};
let span = label.ident.span.to(self.prev_token.span);
let mut err = self.struct_span_err(span, "block label not supported here");
err.span_label(span, "not supported here");
err.tool_only_span_suggestion(
label.ident.span.until(self.token.span),
"remove this block label",
String::new(),
Applicability::MachineApplicable,
);
err.emit();
true
}
/// Some special error handling for the "top-level" patterns in a match arm,
/// `for` loop, `let`, &c. (in contrast to subpatterns within such).
crate fn maybe_recover_unexpected_comma(
&mut self,
lo: Span,
rc: RecoverComma,
rt: CommaRecoveryMode,
) -> PResult<'a, ()> {
if rc == RecoverComma::No || self.token != token::Comma {
return Ok(());
@ -2270,20 +2290,25 @@ impl<'a> Parser<'a> {
let seq_span = lo.to(self.prev_token.span);
let mut err = self.struct_span_err(comma_span, "unexpected `,` in pattern");
if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
const MSG: &str = "try adding parentheses to match on a tuple...";
err.span_suggestion(
seq_span,
MSG,
format!("({})", seq_snippet),
Applicability::MachineApplicable,
);
err.span_suggestion(
seq_span,
"...or a vertical bar to match on multiple alternatives",
seq_snippet.replace(',', " |"),
err.multipart_suggestion(
&format!(
"try adding parentheses to match on a tuple{}",
if let CommaRecoveryMode::LikelyTuple = rt { "" } else { "..." },
),
vec![
(seq_span.shrink_to_lo(), "(".to_string()),
(seq_span.shrink_to_hi(), ")".to_string()),
],
Applicability::MachineApplicable,
);
if let CommaRecoveryMode::EitherTupleOrPipe = rt {
err.span_suggestion(
seq_span,
"...or a vertical bar to match on multiple alternatives",
seq_snippet.replace(',', " |"),
Applicability::MachineApplicable,
);
}
}
Err(err)
}

56
compiler/rustc_parse/src/parser/expr.rs
View File

@ -1,4 +1,4 @@
use super::pat::{RecoverColon, RecoverComma, PARAM_EXPECTED};
use super::pat::{CommaRecoveryMode, RecoverColon, RecoverComma, PARAM_EXPECTED};
use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
use super::{
AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Restrictions, TokenType,
@ -1286,18 +1286,27 @@ impl<'a> Parser<'a> {
} else if let Some(label) = self.eat_label() {
self.parse_labeled_expr(label, attrs, true)
} else if self.eat_keyword(kw::Loop) {
self.parse_loop_expr(None, self.prev_token.span, attrs)
let sp = self.prev_token.span;
self.parse_loop_expr(None, self.prev_token.span, attrs).map_err(|mut err| {
err.span_label(sp, "while parsing this `loop` expression");
err
})
} else if self.eat_keyword(kw::Continue) {
let kind = ExprKind::Continue(self.eat_label());
Ok(self.mk_expr(lo.to(self.prev_token.span), kind, attrs))
} else if self.eat_keyword(kw::Match) {
let match_sp = self.prev_token.span;
self.parse_match_expr(attrs).map_err(|mut err| {
err.span_label(match_sp, "while parsing this match expression");
err.span_label(match_sp, "while parsing this `match` expression");
err
})
} else if self.eat_keyword(kw::Unsafe) {
let sp = self.prev_token.span;
self.parse_block_expr(None, lo, BlockCheckMode::Unsafe(ast::UserProvided), attrs)
.map_err(|mut err| {
err.span_label(sp, "while parsing this `unsafe` expression");
err
})
} else if self.check_inline_const(0) {
self.parse_const_block(lo.to(self.token.span), false)
} else if self.is_do_catch_block() {
@ -2160,7 +2169,12 @@ impl<'a> Parser<'a> {
/// The `let` token has already been eaten.
fn parse_let_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>> {
let lo = self.prev_token.span;
let pat = self.parse_pat_allow_top_alt(None, RecoverComma::Yes, RecoverColon::Yes)?;
let pat = self.parse_pat_allow_top_alt(
None,
RecoverComma::Yes,
RecoverColon::Yes,
CommaRecoveryMode::LikelyTuple,
)?;
self.expect(&token::Eq)?;
let expr = self.with_res(self.restrictions | Restrictions::NO_STRUCT_LITERAL, |this| {
this.parse_assoc_expr_with(1 + prec_let_scrutinee_needs_par(), None.into())
@ -2223,7 +2237,12 @@ impl<'a> Parser<'a> {
_ => None,
};
let pat = self.parse_pat_allow_top_alt(None, RecoverComma::Yes, RecoverColon::Yes)?;
let pat = self.parse_pat_allow_top_alt(
None,
RecoverComma::Yes,
RecoverColon::Yes,
CommaRecoveryMode::LikelyTuple,
)?;
if !self.eat_keyword(kw::In) {
self.error_missing_in_for_loop();
}
@ -2266,8 +2285,15 @@ impl<'a> Parser<'a> {
lo: Span,
mut attrs: AttrVec,
) -> PResult<'a, P<Expr>> {
let cond = self.parse_cond_expr()?;
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
let cond = self.parse_cond_expr().map_err(|mut err| {
err.span_label(lo, "while parsing the condition of this `while` expression");
err
})?;
let (iattrs, body) = self.parse_inner_attrs_and_block().map_err(|mut err| {
err.span_label(lo, "while parsing the body of this `while` expression");
err.span_label(cond.span, "this `while` condition successfully parsed");
err
})?;
attrs.extend(iattrs);
Ok(self.mk_expr(lo.to(self.prev_token.span), ExprKind::While(cond, body, opt_label), attrs))
}
@ -2284,7 +2310,7 @@ impl<'a> Parser<'a> {
Ok(self.mk_expr(lo.to(self.prev_token.span), ExprKind::Loop(body, opt_label), attrs))
}
fn eat_label(&mut self) -> Option<Label> {
crate fn eat_label(&mut self) -> Option<Label> {
self.token.lifetime().map(|ident| {
self.bump();
Label { ident }
@ -2305,7 +2331,12 @@ impl<'a> Parser<'a> {
Applicability::MaybeIncorrect, // speculative
);
}
return Err(e);
if self.maybe_recover_unexpected_block_label() {
e.cancel();
self.bump();
} else {
return Err(e);
}
}
attrs.extend(self.parse_inner_attributes()?);
@ -2441,7 +2472,12 @@ impl<'a> Parser<'a> {
let attrs = self.parse_outer_attributes()?;
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
let lo = this.token.span;
let pat = this.parse_pat_allow_top_alt(None, RecoverComma::Yes, RecoverColon::Yes)?;
let pat = this.parse_pat_allow_top_alt(
None,
RecoverComma::Yes,
RecoverColon::Yes,
CommaRecoveryMode::EitherTupleOrPipe,
)?;
let guard = if this.eat_keyword(kw::If) {
let if_span = this.prev_token.span;
let cond = this.parse_expr()?;

2
compiler/rustc_parse/src/parser/mod.rs
View File

@ -15,7 +15,7 @@ pub use attr_wrapper::AttrWrapper;
pub use diagnostics::AttemptLocalParseRecovery;
use diagnostics::Error;
pub(crate) use item::FnParseMode;
pub use pat::{RecoverColon, RecoverComma};
pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
pub use path::PathStyle;
use rustc_ast::ptr::P;

4
compiler/rustc_parse/src/parser/nonterminal.rs
View File

@ -5,7 +5,7 @@ use rustc_ast_pretty::pprust;
use rustc_errors::PResult;
use rustc_span::symbol::{kw, Ident};
use crate::parser::pat::{RecoverColon, RecoverComma};
use crate::parser::pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
use crate::parser::{FollowedByType, ForceCollect, Parser, PathStyle};
impl<'a> Parser<'a> {
@ -125,7 +125,7 @@ impl<'a> Parser<'a> {
token::NtPat(self.collect_tokens_no_attrs(|this| match kind {
NonterminalKind::PatParam { .. } => this.parse_pat_no_top_alt(None),
NonterminalKind::PatWithOr { .. } => {
this.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No)
this.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No, CommaRecoveryMode::EitherTupleOrPipe)
}
_ => unreachable!(),
})?)

51
compiler/rustc_parse/src/parser/pat.rs
View File

@ -33,6 +33,13 @@ pub enum RecoverColon {
No,
}
/// Whether or not to recover a `a, b` when parsing patterns as `(a, b)` or that *and* `a | b`.
#[derive(PartialEq, Copy, Clone)]
pub enum CommaRecoveryMode {
LikelyTuple,
EitherTupleOrPipe,
}
/// The result of `eat_or_separator`. We want to distinguish which case we are in to avoid
/// emitting duplicate diagnostics.
#[derive(Debug, Clone, Copy)]
@ -68,8 +75,9 @@ impl<'a> Parser<'a> {
expected: Expected,
rc: RecoverComma,
ra: RecoverColon,
rt: CommaRecoveryMode,
) -> PResult<'a, P<Pat>> {
self.parse_pat_allow_top_alt_inner(expected, rc, ra).map(|(pat, _)| pat)
self.parse_pat_allow_top_alt_inner(expected, rc, ra, rt).map(|(pat, _)| pat)
}
/// Returns the pattern and a bool indicating whether we recovered from a trailing vert (true =
@ -79,6 +87,7 @@ impl<'a> Parser<'a> {
expected: Expected,
rc: RecoverComma,
ra: RecoverColon,
rt: CommaRecoveryMode,
) -> PResult<'a, (P<Pat>, bool)> {
// Keep track of whether we recovered from a trailing vert so that we can avoid duplicated
// suggestions (which bothers rustfix).
@ -92,7 +101,7 @@ impl<'a> Parser<'a> {
// Parse the first pattern (`p_0`).
let first_pat = self.parse_pat_no_top_alt(expected)?;
self.maybe_recover_unexpected_comma(first_pat.span, rc)?;
self.maybe_recover_unexpected_comma(first_pat.span, rc, rt)?;
// If the next token is not a `|`,
// this is not an or-pattern and we should exit here.
@ -130,7 +139,7 @@ impl<'a> Parser<'a> {
err.span_label(lo, WHILE_PARSING_OR_MSG);
err
})?;
self.maybe_recover_unexpected_comma(pat.span, rc)?;
self.maybe_recover_unexpected_comma(pat.span, rc, rt)?;
pats.push(pat);
}
let or_pattern_span = lo.to(self.prev_token.span);
@ -155,8 +164,12 @@ impl<'a> Parser<'a> {
// We use `parse_pat_allow_top_alt` regardless of whether we actually want top-level
// or-patterns so that we can detect when a user tries to use it. This allows us to print a
// better error message.
let (pat, trailing_vert) =
self.parse_pat_allow_top_alt_inner(expected, rc, RecoverColon::No)?;
let (pat, trailing_vert) = self.parse_pat_allow_top_alt_inner(
expected,
rc,
RecoverColon::No,
CommaRecoveryMode::LikelyTuple,
)?;
let colon = self.eat(&token::Colon);
if let PatKind::Or(pats) = &pat.kind {
@ -315,7 +328,12 @@ impl<'a> Parser<'a> {
} else if self.check(&token::OpenDelim(token::Bracket)) {
// Parse `[pat, pat,...]` as a slice pattern.
let (pats, _) = self.parse_delim_comma_seq(token::Bracket, |p| {
p.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No)
p.parse_pat_allow_top_alt(
None,
RecoverComma::No,
RecoverColon::No,
CommaRecoveryMode::EitherTupleOrPipe,
)
})?;
PatKind::Slice(pats)
} else if self.check(&token::DotDot) && !self.is_pat_range_end_start(1) {
@ -529,7 +547,12 @@ impl<'a> Parser<'a> {
/// Parse a tuple or parenthesis pattern.
fn parse_pat_tuple_or_parens(&mut self) -> PResult<'a, PatKind> {
let (fields, trailing_comma) = self.parse_paren_comma_seq(|p| {
p.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No)
p.parse_pat_allow_top_alt(
None,
RecoverComma::No,
RecoverColon::No,
CommaRecoveryMode::LikelyTuple,
)
})?;
// Here, `(pat,)` is a tuple pattern.
@ -873,7 +896,12 @@ impl<'a> Parser<'a> {
/// Parse tuple struct or tuple variant pattern (e.g. `Foo(...)` or `Foo::Bar(...)`).
fn parse_pat_tuple_struct(&mut self, qself: Option<QSelf>, path: Path) -> PResult<'a, PatKind> {
let (fields, _) = self.parse_paren_comma_seq(|p| {
p.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No)
p.parse_pat_allow_top_alt(
None,
RecoverComma::No,
RecoverColon::No,
CommaRecoveryMode::EitherTupleOrPipe,
)
})?;
if qself.is_some() {
self.sess.gated_spans.gate(sym::more_qualified_paths, path.span);
@ -1033,7 +1061,12 @@ impl<'a> Parser<'a> {
// Parsing a pattern of the form `fieldname: pat`.
let fieldname = self.parse_field_name()?;
self.bump();
let pat = self.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No)?;
let pat = self.parse_pat_allow_top_alt(
None,
RecoverComma::No,
RecoverColon::No,
CommaRecoveryMode::EitherTupleOrPipe,
)?;
hi = pat.span;
(pat, fieldname, false)
} else {

38
compiler/rustc_parse/src/parser/stmt.rs
View File

@ -434,6 +434,8 @@ impl<'a> Parser<'a> {
Ok(Some(_))
if self.look_ahead(1, |t| t == &token::OpenDelim(token::Brace))
|| do_not_suggest_help => {}
// Do not suggest `if foo println!("") {;}` (as would be seen in test for #46836).
Ok(Some(Stmt { kind: StmtKind::Empty, .. })) => {}
Ok(Some(stmt)) => {
let stmt_own_line = self.sess.source_map().is_line_before_span_empty(sp);
let stmt_span = if stmt_own_line && self.eat(&token::Semi) {
@ -442,15 +444,15 @@ impl<'a> Parser<'a> {
} else {
stmt.span
};
if let Ok(snippet) = self.span_to_snippet(stmt_span) {
e.span_suggestion(
stmt_span,
"try placing this code inside a block",
format!("{{ {} }}", snippet),
// Speculative; has been misleading in the past (#46836).
Applicability::MaybeIncorrect,
);
}
e.multipart_suggestion(
"try placing this code inside a block",
vec![
(stmt_span.shrink_to_lo(), "{ ".to_string()),
(stmt_span.shrink_to_hi(), " }".to_string()),
],
// Speculative; has been misleading in the past (#46836).
Applicability::MaybeIncorrect,
);
}
Err(e) => {
self.recover_stmt_(SemiColonMode::Break, BlockMode::Ignore);
@ -483,15 +485,15 @@ impl<'a> Parser<'a> {
) -> PResult<'a, (Vec<Attribute>, P<Block>)> {
maybe_whole!(self, NtBlock, |x| (Vec::new(), x));
self.maybe_recover_unexpected_block_label();
if !self.eat(&token::OpenDelim(token::Brace)) {
return self.error_block_no_opening_brace();
}
let attrs = self.parse_inner_attributes()?;
let tail = if let Some(tail) = self.maybe_suggest_struct_literal(lo, blk_mode) {
tail?
} else {
self.parse_block_tail(lo, blk_mode, AttemptLocalParseRecovery::Yes)?
let tail = match self.maybe_suggest_struct_literal(lo, blk_mode) {
Some(tail) => tail?,
None => self.parse_block_tail(lo, blk_mode, AttemptLocalParseRecovery::Yes)?,
};
Ok((attrs, tail))
}
@ -587,11 +589,11 @@ impl<'a> Parser<'a> {
// We might be at the `,` in `let x = foo<bar, baz>;`. Try to recover.
match &mut local.kind {
LocalKind::Init(expr) | LocalKind::InitElse(expr, _) => {
self.check_mistyped_turbofish_with_multiple_type_params(e, expr)?;
// We found `foo<bar, baz>`, have we fully recovered?
self.expect_semi()?;
}
LocalKind::Decl => return Err(e),
self.check_mistyped_turbofish_with_multiple_type_params(e, expr)?;
// We found `foo<bar, baz>`, have we fully recovered?
self.expect_semi()?;
}
LocalKind::Decl => return Err(e),
}
eat_semi = false;
}

2
src/test/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr
View File

@ -132,7 +132,7 @@ error: expected one of `.`, `?`, `{`, or an operator, found `}`
LL | match await { await => () }
| ----- - expected one of `.`, `?`, `{`, or an operator
| |
| while parsing this match expression
| while parsing this `match` expression
...
LL | }
| ^ unexpected token

5
src/test/ui/did_you_mean/issue-46836-identifier-not-instead-of-negation.stderr
View File

@ -28,10 +28,7 @@ error: expected `{`, found `;`
LL | if not // lack of braces is [sic]
| -- this `if` expression has a condition, but no block
LL | println!("Then when?");
| ^
| |
| expected `{`
| help: try placing this code inside a block: `{ ; }`
| ^ expected `{`
error: unexpected `2` after identifier
--> $DIR/issue-46836-identifier-not-instead-of-negation.rs:26:24

46
src/test/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
View File

@ -2,16 +2,14 @@ error: unexpected `,` in pattern
--> $DIR/issue-48492-tuple-destructure-missing-parens.rs:38:17
|
LL | while let b1, b2, b3 = reading_frame.next().expect("there should be a start codon") {
| ^
| ----- ^
| |
| while parsing the condition of this `while` expression
|
help: try adding parentheses to match on a tuple...
help: try adding parentheses to match on a tuple
|
LL | while let (b1, b2, b3) = reading_frame.next().expect("there should be a start codon") {
| ~~~~~~~~~~~~
help: ...or a vertical bar to match on multiple alternatives
|
LL | while let b1 | b2 | b3 = reading_frame.next().expect("there should be a start codon") {
| ~~~~~~~~~~~~
| + +
error: unexpected `,` in pattern
--> $DIR/issue-48492-tuple-destructure-missing-parens.rs:49:14
@ -19,14 +17,10 @@ error: unexpected `,` in pattern
LL | if let b1, b2, b3 = reading_frame.next().unwrap() {
| ^
|
help: try adding parentheses to match on a tuple...
help: try adding parentheses to match on a tuple
|
LL | if let (b1, b2, b3) = reading_frame.next().unwrap() {
| ~~~~~~~~~~~~
help: ...or a vertical bar to match on multiple alternatives
|
LL | if let b1 | b2 | b3 = reading_frame.next().unwrap() {
| ~~~~~~~~~~~~
| + +
error: unexpected `,` in pattern
--> $DIR/issue-48492-tuple-destructure-missing-parens.rs:59:28
@ -37,7 +31,7 @@ LL | Nucleotide::Adenine, Nucleotide::Cytosine, _ => true
help: try adding parentheses to match on a tuple...
|
LL | (Nucleotide::Adenine, Nucleotide::Cytosine, _) => true
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| + +
help: ...or a vertical bar to match on multiple alternatives
|
LL | Nucleotide::Adenine | Nucleotide::Cytosine | _ => true
@ -49,14 +43,10 @@ error: unexpected `,` in pattern
LL | for x, _barr_body in women.iter().map(|woman| woman.allosomes.clone()) {
| ^
|
help: try adding parentheses to match on a tuple...
help: try adding parentheses to match on a tuple
|
LL | for (x, _barr_body) in women.iter().map(|woman| woman.allosomes.clone()) {
| ~~~~~~~~~~~~~~~
help: ...or a vertical bar to match on multiple alternatives
|
LL | for x | _barr_body in women.iter().map(|woman| woman.allosomes.clone()) {
| ~~~~~~~~~~~~~~
| + +
error: unexpected `,` in pattern
--> $DIR/issue-48492-tuple-destructure-missing-parens.rs:75:10
@ -64,14 +54,10 @@ error: unexpected `,` in pattern
LL | for x, y @ Allosome::Y(_) in men.iter().map(|man| man.allosomes.clone()) {
| ^
|
help: try adding parentheses to match on a tuple...
help: try adding parentheses to match on a tuple
|
LL | for (x, y @ Allosome::Y(_)) in men.iter().map(|man| man.allosomes.clone()) {
| ~~~~~~~~~~~~~~~~~~~~~~~
help: ...or a vertical bar to match on multiple alternatives
|
LL | for x | y @ Allosome::Y(_) in men.iter().map(|man| man.allosomes.clone()) {
| ~~~~~~~~~~~~~~~~~~~~~~
| + +
error: unexpected `,` in pattern
--> $DIR/issue-48492-tuple-destructure-missing-parens.rs:84:14
@ -79,14 +65,10 @@ error: unexpected `,` in pattern
LL | let women, men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
| ^
|
help: try adding parentheses to match on a tuple...
help: try adding parentheses to match on a tuple
|
LL | let (women, men): (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
| ~~~~~~~~~~~~
help: ...or a vertical bar to match on multiple alternatives
|
LL | let women | men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
| ~~~~~~~~~~~
| + +
error: aborting due to 6 previous errors

10
src/test/ui/issues/issue-39848.stderr
View File

@ -2,16 +2,18 @@ error: expected `{`, found `foo`
--> $DIR/issue-39848.rs:3:21
|
LL | if $tgt.has_$field() {}
| -- ^^^^^^--
| | |
| | expected `{`
| | help: try placing this code inside a block: `{ $field() }`
| -- ^^^^^^ expected `{`
| |
| this `if` expression has a condition, but no block
...
LL | get_opt!(bar, foo);
| ------------------ in this macro invocation
|
= note: this error originates in the macro `get_opt` (in Nightly builds, run with -Z macro-backtrace for more info)
help: try placing this code inside a block
|
LL | if $tgt.has_{ $field() } {}
| + +
error: aborting due to previous error

30
src/test/ui/label/label_break_value_illegal_uses.fixed Normal file
View File

@ -0,0 +1,30 @@
// run-rustfix
#![feature(label_break_value)]
// These are forbidden occurrences of label-break-value
#[allow(unused_unsafe)]
fn labeled_unsafe() {
unsafe {} //~ ERROR block label not supported here
}
fn labeled_if() {
if true {} //~ ERROR block label not supported here
}
fn labeled_else() {
if true {} else {} //~ ERROR block label not supported here
}
fn labeled_match() {
match false { //~ ERROR block label not supported here
_ => {}
}
}
fn main() {
labeled_unsafe();
labeled_if();
labeled_else();
labeled_match();
}

19
src/test/ui/label/label_break_value_illegal_uses.rs
View File

@ -1,21 +1,30 @@
// run-rustfix
#![feature(label_break_value)]
// These are forbidden occurrences of label-break-value
#[allow(unused_unsafe)]
fn labeled_unsafe() {
unsafe 'b: {} //~ ERROR expected `{`, found `'b`
unsafe 'b: {} //~ ERROR block label not supported here
}
fn labeled_if() {
if true 'b: {} //~ ERROR expected `{`, found `'b`
if true 'b: {} //~ ERROR block label not supported here
}
fn labeled_else() {
if true {} else 'b: {} //~ ERROR expected `{`, found `'b`
if true {} else 'b: {} //~ ERROR block label not supported here
}
fn labeled_match() {
match false 'b: {} //~ ERROR expected one of `.`, `?`, `{`, or an operator
match false 'b: { //~ ERROR block label not supported here
_ => {}
}
}
pub fn main() {}
fn main() {
labeled_unsafe();
labeled_if();
labeled_else();
labeled_match();
}

38
src/test/ui/label/label_break_value_illegal_uses.stderr
View File

@ -1,38 +1,26 @@
error: expected `{`, found `'b`
--> $DIR/label_break_value_illegal_uses.rs:6:12
error: block label not supported here
--> $DIR/label_break_value_illegal_uses.rs:8:12
|
LL | unsafe 'b: {}
| ^^----
| |
| expected `{`
| help: try placing this code inside a block: `{ 'b: {} }`
| ^^^ not supported here
error: expected `{`, found `'b`
--> $DIR/label_break_value_illegal_uses.rs:10:13
error: block label not supported here
--> $DIR/label_break_value_illegal_uses.rs:12:13
|
LL | if true 'b: {}
| -- ^^----
| | |
| | expected `{`
| | help: try placing this code inside a block: `{ 'b: {} }`
| this `if` expression has a condition, but no block
| ^^^ not supported here
error: expected `{`, found `'b`
--> $DIR/label_break_value_illegal_uses.rs:14:21
error: block label not supported here
--> $DIR/label_break_value_illegal_uses.rs:16:21
|
LL | if true {} else 'b: {}
| ^^----
| |
| expected `{`
| help: try placing this code inside a block: `{ 'b: {} }`
| ^^^ not supported here
error: expected one of `.`, `?`, `{`, or an operator, found `'b`
--> $DIR/label_break_value_illegal_uses.rs:18:17
error: block label not supported here
--> $DIR/label_break_value_illegal_uses.rs:20:17
|
LL | match false 'b: {}
| ----- ^^ expected one of `.`, `?`, `{`, or an operator
| |
| while parsing this match expression
LL | match false 'b: {
| ^^^ not supported here
error: aborting due to 4 previous errors

8
src/test/ui/let-else/let-else-if.stderr
View File

@ -7,10 +7,10 @@ LL | let Some(_) = Some(()) else if true {
help: try placing this code inside a block
|
LL ~ let Some(_) = Some(()) else { if true {
LL +
LL + return;
LL + } else {
LL + return;
LL |
LL | return;
LL | } else {
LL | return;
LL ~ } };
|

10
src/test/ui/missing/missing-block-hint.stderr
View File

@ -12,10 +12,12 @@ error: expected `{`, found `bar`
LL | if (foo)
| -- this `if` expression has a condition, but no block
LL | bar;
| ^^^-
| |
| expected `{`
| help: try placing this code inside a block: `{ bar; }`
| ^^^ expected `{`
|
help: try placing this code inside a block
|
LL | { bar; }
| + +
error: aborting due to 2 previous errors

36
src/test/ui/parser/block-no-opening-brace.stderr
View File

@ -1,29 +1,41 @@
error: expected `{`, found keyword `let`
--> $DIR/block-no-opening-brace.rs:9:9
|
LL | loop
| ---- while parsing this `loop` expression
LL | let x = 0;
| ^^^-------
| |
| expected `{`
| help: try placing this code inside a block: `{ let x = 0; }`
| ^^^ expected `{`
|
help: try placing this code inside a block
|
LL | { let x = 0; }
| + +
error: expected `{`, found keyword `let`
--> $DIR/block-no-opening-brace.rs:15:9
|
LL | while true
| ----- ---- this `while` condition successfully parsed
| |
| while parsing the body of this `while` expression
LL | let x = 0;
| ^^^-------
| |
| expected `{`
| help: try placing this code inside a block: `{ let x = 0; }`
| ^^^ expected `{`
|
help: try placing this code inside a block
|
LL | { let x = 0; }
| + +
error: expected `{`, found keyword `let`
--> $DIR/block-no-opening-brace.rs:20:9
|
LL | let x = 0;
| ^^^-------
| |
| expected `{`
| help: try placing this code inside a block: `{ let x = 0; }`
| ^^^ expected `{`
|
help: try placing this code inside a block
|
LL | { let x = 0; }
| + +
error: expected expression, found reserved keyword `try`
--> $DIR/block-no-opening-brace.rs:24:5

10
src/test/ui/parser/closure-return-syntax.stderr
View File

@ -2,10 +2,12 @@ error: expected `{`, found `22`
--> $DIR/closure-return-syntax.rs:5:23
|
LL | let x = || -> i32 22;
| ^^
| |
| expected `{`
| help: try placing this code inside a block: `{ 22 }`
| ^^ expected `{`
|
help: try placing this code inside a block
|
LL | let x = || -> i32 { 22 };
| + +
error: aborting due to previous error

5
src/test/ui/parser/issues/issue-62554.stderr
View File

@ -63,9 +63,8 @@ LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s
|
help: try placing this code inside a block
|
LL ~ fn foo(u: u8) { if u8 { macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
LL + }
|
LL | fn foo(u: u8) { if u8 { macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 { }
| + +
error: aborting due to 6 previous errors

2
src/test/ui/parser/issues/issue-62973.stderr
View File

@ -50,7 +50,7 @@ error: expected one of `.`, `?`, `{`, or an operator, found `}`
--> $DIR/issue-62973.rs:8:2
|
LL | fn p() { match s { v, E { [) {) }
| ----- while parsing this match expression
| ----- while parsing this `match` expression
LL |
LL |
| ^ expected one of `.`, `?`, `{`, or an operator

2
src/test/ui/parser/match-refactor-to-expr.fixed
View File

@ -2,7 +2,7 @@
fn main() {
let foo =
//~ NOTE while parsing this match expression
//~ NOTE while parsing this `match` expression
Some(4).unwrap_or(5)
//~^ NOTE expected one of `.`, `?`, `{`, or an operator
; //~ NOTE unexpected token

2
src/test/ui/parser/match-refactor-to-expr.rs
View File

@ -2,7 +2,7 @@
fn main() {
let foo =
match //~ NOTE while parsing this match expression
match //~ NOTE while parsing this `match` expression
Some(4).unwrap_or(5)
//~^ NOTE expected one of `.`, `?`, `{`, or an operator
; //~ NOTE unexpected token

2
src/test/ui/parser/match-refactor-to-expr.stderr
View File

@ -4,7 +4,7 @@ error: expected one of `.`, `?`, `{`, or an operator, found `;`
LL | match
| -----
| |
| while parsing this match expression
| while parsing this `match` expression
| help: try removing this `match`
LL | Some(4).unwrap_or(5)
| - expected one of `.`, `?`, `{`, or an operator

13
src/test/ui/parser/while-if-let-without-body.rs Normal file
View File

@ -0,0 +1,13 @@
fn main() {
let container = vec![Some(1), Some(2), None];
let mut i = 0;
while if let Some(thing) = container.get(i) {
//~^ NOTE while parsing the body of this `while` expression
//~| NOTE this `while` condition successfully parsed
println!("{:?}", thing);
i += 1;
}
}
//~^ ERROR expected `{`, found `}`
//~| NOTE expected `{`

18
src/test/ui/parser/while-if-let-without-body.stderr Normal file
View File

@ -0,0 +1,18 @@
error: expected `{`, found `}`
--> $DIR/while-if-let-without-body.rs:11:1
|
LL | while if let Some(thing) = container.get(i) {
| _____-----_-
| | |
| | while parsing the body of this `while` expression
LL | |
LL | |
LL | | println!("{:?}", thing);
LL | | i += 1;
LL | | }
| |_____- this `while` condition successfully parsed
LL | }
| ^ expected `{`
error: aborting due to previous error

12
src/test/ui/unsafe/unsafe-block-without-braces.stderr
View File

@ -1,11 +1,15 @@
error: expected `{`, found `std`
--> $DIR/unsafe-block-without-braces.rs:3:9
|
LL | unsafe //{
| ------ while parsing this `unsafe` expression
LL | std::mem::transmute::<f32, u32>(1.0);
| ^^^----------------------------------
| |
| expected `{`
| help: try placing this code inside a block: `{ std::mem::transmute::<f32, u32>(1.0); }`
| ^^^ expected `{`
|
help: try placing this code inside a block
|
LL | { std::mem::transmute::<f32, u32>(1.0); }
| + +
error: aborting due to previous error