};
let mut err = self.fatal(&msg_exp);
if self.token.is_ident_named("and") {
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
self.span,
"use `&&` instead of `and` for the boolean operator",
"&&".to_string(),
);
}
if self.token.is_ident_named("or") {
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
self.span,
"use `||` instead of `or` for the boolean operator",
"||".to_string(),
if ident.is_reserved() && !ident.is_path_segment_keyword() &&
ident.name != keywords::Underscore.name()
{
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
self.span,
"you can escape reserved keywords to use them as identifiers",
format!("r#{}", ident),
} else {
err.span_label(self.span, "expected identifier");
if self.token == token::Comma && self.look_ahead(1, |t| t.is_ident()) {
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
self.span,
"remove this comma",
String::new(),
if !allow_plus && impl_dyn_multi {
let sum_with_parens = format!("({})", pprust::ty_to_string(&ty));
self.struct_span_err(ty.span, "ambiguous `+` in a type")
- .span_suggestion_with_applicability(
+ .span_suggestion(
ty.span,
"use parentheses to disambiguate",
sum_with_parens,
s.print_type_bounds(" +", &bounds)?;
s.pclose()
});
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
sum_span,
"try adding parentheses",
sum_with_parens,
self.diagnostic()
.struct_span_err(span, "missing angle brackets in associated item path")
- .span_suggestion_with_applicability( // this is a best-effort recovery
+ .span_suggestion( // this is a best-effort recovery
span, "try", recovered.to_string(), Applicability::MaybeIncorrect
).emit();
let ident = self.parse_ident().unwrap();
let span = pat.span.with_hi(ident.span.hi());
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
span,
"declare the type after the parameter binding",
String::from("<identifier>: <type>"),
);
} else if require_name && is_trait_item {
if let PatKind::Ident(_, ident, _) = pat.node {
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
pat.span,
"explicitly ignore parameter",
format!("_: {}", ident),
"patterns aren't allowed in methods without bodies",
DiagnosticId::Error("E0642".into()),
);
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
pat.span,
"give this argument a name or use an underscore to ignore it",
"_".to_owned(),
let sp = lo.to(self.prev_span);
let mut err = self.diagnostic()
.struct_span_err(sp, "float literals must have an integer part");
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
sp,
"must have an integer part",
format!("0.{}{}", val, suffix),
if self.token == token::Eq {
self.diagnostic()
.struct_span_err(self.span, "expected `:`, found `=`")
- .span_suggestion_with_applicability(
+ .span_suggestion(
fieldname.span.shrink_to_hi().to(self.span),
"replace equals symbol with a colon",
":".to_string(),
exp_span.to(self.prev_span),
"cannot use a comma after the base struct",
);
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
self.span,
"remove this comma",
String::new(),
span,
&format!("unmatched angle bracket{}", if plural { "s" } else { "" }),
)
- .span_suggestion_with_applicability(
+ .span_suggestion(
span,
&format!("remove extra angle bracket{}", if plural { "s" } else { "" }),
String::new(),
s.s.word(".")?;
s.s.word(fstr.splitn(2, ".").last().unwrap().to_string())
});
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
lo.to(self.prev_span),
"try parenthesizing the first index",
sugg,
let span_of_tilde = lo;
let mut err = self.diagnostic()
.struct_span_err(span_of_tilde, "`~` cannot be used as a unary operator");
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
span_of_tilde,
"use `!` to perform bitwise negation",
"!".to_owned(),
// trailing whitespace after the `!` in our suggestion
let to_replace = self.sess.source_map()
.span_until_non_whitespace(lo.to(self.span));
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
to_replace,
"use `!` to perform logical negation",
"!".to_owned(),
let cur_pos = cm.lookup_char_pos(self.span.lo());
let op_pos = cm.lookup_char_pos(cur_op_span.hi());
if cur_pos.line != op_pos.line {
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
cur_op_span,
"try using a semicolon",
";".to_string(),
let expr_str = self.sess.source_map().span_to_snippet(expr.span)
.unwrap_or_else(|_| pprust::expr_to_string(&expr));
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
expr.span,
&format!("try {} the cast value", op_verb),
format!("({})", expr_str),
let in_span = self.prev_span.between(self.span);
let mut err = self.sess.span_diagnostic
.struct_span_err(in_span, "missing `in` in `for` loop");
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
in_span, "try adding `in` here", " in ".into(),
// has been misleading, at least in the past (closed Issue #48492)
Applicability::MaybeIncorrect
self.prev_span,
"expected iterable, found keyword `in`",
);
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
in_span.until(self.prev_span),
"remove the duplicated `in`",
String::new(),
None)?;
if let Err(mut e) = self.expect(&token::OpenDelim(token::Brace)) {
if self.token == token::Token::Semi {
- e.span_suggestion_short_with_applicability(
+ e.span_suggestion_short(
match_span,
"try removing this `match`",
String::new(),
// | - ^^ self.span
// | |
// | parsed until here as `"y" & X`
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
cm.next_point(arm_start_span),
"missing a comma here to end this `match` arm",
",".to_owned(),
if self.token == token::OrOr {
let mut err = self.struct_span_err(self.span,
"unexpected token `||` after pattern");
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
self.span,
"use a single `|` to specify multiple patterns",
"|".to_owned(),
// Accept `...` as if it were `..` to avoid further errors
let mut err = self.struct_span_err(self.span,
"expected field pattern, found `...`");
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
self.span,
"to omit remaining fields, use one fewer `.`",
"..".to_owned(),
if self.token == token::CloseDelim(token::Brace) {
// If the struct looks otherwise well formed, recover and continue.
if let Some(sp) = comma_sp {
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
sp,
"remove this comma",
String::new(),
if let Some(mut err) = delayed_err {
if let Some(etc_span) = etc_span {
- err.multipart_suggestion_with_applicability(
+ err.multipart_suggestion(
"move the `..` to the end of the field list",
vec![
(etc_span, String::new()),
let mut err = self.struct_span_err(comma_span,
"unexpected `,` in pattern");
if let Ok(seq_snippet) = self.sess.source_map().span_to_snippet(seq_span) {
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
seq_span,
"try adding parentheses",
format!("({})", seq_snippet),
let binding_mode = if self.eat_keyword(keywords::Ref) {
self.diagnostic()
.struct_span_err(mutref_span, "the order of `mut` and `ref` is incorrect")
- .span_suggestion_with_applicability(
+ .span_suggestion(
mutref_span,
"try switching the order",
"ref mut".into(),
pat.span,
"the range pattern here has ambiguous interpretation",
);
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
pat.span,
"add parentheses to clarify the precedence",
format!("({})", pprust::pat_to_string(&pat)),
(Ok(init), Some((_, colon_sp, mut err))) => { // init parsed, ty error
// Could parse the type as if it were the initializer, it is likely there was a
// typo in the code: `:` instead of `=`. Add suggestion and emit the error.
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
colon_sp,
"use `=` if you meant to assign",
"=".to_string(),
self.token.is_keyword(keywords::In) || self.token == token::Colon;
if self.token.is_ident_named("and") {
- e.span_suggestion_short_with_applicability(
+ e.span_suggestion_short(
self.span,
"use `&&` instead of `and` for the boolean operator",
"&&".to_string(),
);
}
if self.token.is_ident_named("or") {
- e.span_suggestion_short_with_applicability(
+ e.span_suggestion_short(
self.span,
"use `||` instead of `or` for the boolean operator",
"||".to_string(),
s.print_stmt(&stmt)?;
s.bclose_maybe_open(stmt.span, INDENT_UNIT, false)
});
- e.span_suggestion_with_applicability(
+ e.span_suggestion(
stmt_span,
"try placing this code inside a block",
sugg,
fn err_dotdotdot_syntax(&self, span: Span) {
self.diagnostic().struct_span_err(span, {
"unexpected token: `...`"
- }).span_suggestion_with_applicability(
+ }).span_suggestion(
span, "use `..` for an exclusive range", "..".to_owned(),
Applicability::MaybeIncorrect
- ).span_suggestion_with_applicability(
+ ).span_suggestion(
span, "or `..=` for an inclusive range", "..=".to_owned(),
Applicability::MaybeIncorrect
).emit();
"lifetime parameters must be declared prior to type parameters",
);
if !suggestions.is_empty() {
- err.multipart_suggestion_with_applicability(
+ err.multipart_suggestion(
"move the lifetime parameter prior to the first type parameter",
suggestions,
Applicability::MachineApplicable,
if plural { "s" } else { "" }
),
)
- .span_suggestion_with_applicability(
+ .span_suggestion(
span,
&format!(
"remove extra angle bracket{}",
suggestions.extend_from_slice(&type_suggestions);
let plural = bad_lifetime_pos.len() + bad_type_pos.len() > 1;
- err.multipart_suggestion_with_applicability(
+ err.multipart_suggestion(
&format!(
"move the parameter{}",
if plural { "s" } else { "" },
Applicability::MachineApplicable,
);
} else if !lifetime_suggestions.is_empty() {
- err.multipart_suggestion_with_applicability(
+ err.multipart_suggestion(
&format!(
"move the lifetime parameter{} prior to the first type parameter",
if bad_lifetime_pos.len() > 1 { "s" } else { "" },
Applicability::MachineApplicable,
);
} else if !type_suggestions.is_empty() {
- err.multipart_suggestion_with_applicability(
+ err.multipart_suggestion(
&format!(
"move the type parameter{} prior to the first associated type binding",
if bad_type_pos.len() > 1 { "s" } else { "" },
let mut err = if is_macro_rules {
let mut err = self.diagnostic()
.struct_span_err(sp, "can't qualify macro_rules invocation with `pub`");
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
sp,
"try exporting the macro",
"#[macro_export]".to_owned(),
// impl Trait for Type
if !has_for {
self.struct_span_err(missing_for_span, "missing `for` in a trait impl")
- .span_suggestion_short_with_applicability(
+ .span_suggestion_short(
missing_for_span,
"add `for` here",
" for ".to_string(),
} else {
if seen_comma == false {
let sp = self.sess.source_map().next_point(previous_span);
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
sp,
"missing comma here",
",".into(),
self.this_token_descr()));
if self.token.is_ident() {
// This is likely another field; emit the diagnostic and keep going
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
sp,
"try adding a comma",
",".into(),
self.expect(&token::CloseDelim(token::Paren))?; // `)`
let mut err = struct_span_err!(self.sess.span_diagnostic, sp, E0704, "{}", msg);
err.help(suggestion);
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
sp, &help_msg, format!("in {}", path), Applicability::MachineApplicable
);
err.emit(); // emit diagnostic, but continue with public visibility
fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool {
if self.eat(&token::Semi) {
let mut err = self.struct_span_err(self.prev_span, "expected item, found `;`");
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
self.prev_span,
"remove this semicolon",
String::new(),
let mut err = self.struct_span_err(fixed_name_sp, error_msg);
err.span_label(fixed_name_sp, "dash-separated idents are not valid");
- err.multipart_suggestion_with_applicability(
+ err.multipart_suggestion(
suggestion_msg,
replacement,
Applicability::MachineApplicable,
let mut err = self.diagnostic()
.struct_span_err(prev_span, "const globals cannot be mutable");
err.span_label(prev_span, "cannot be mutable");
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
const_span,
"you might want to declare a static instead",
"static".to_owned(),
ident);
let mut err = self.diagnostic()
.struct_span_err(sp, "missing `struct` for struct definition");
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
sp, &msg, " struct ".into(), Applicability::MaybeIncorrect // speculative
);
return Err(err);
kw,
ident,
kw_name);
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
sp, &suggestion, format!(" {} ", kw), Applicability::MachineApplicable
);
} else {
if let Ok(snippet) = self.sess.source_map().span_to_snippet(ident_sp) {
- err.span_suggestion_with_applicability(
+ err.span_suggestion(
full_sp,
"if you meant to call a macro, try",
format!("{}!", snippet),
let msg = format!("missing `{}` for {} definition", kw, kw_name);
let mut err = self.diagnostic().struct_span_err(sp, &msg);
if !ambiguous {
- err.span_suggestion_short_with_applicability(
+ err.span_suggestion_short(
sp,
&format!("add `{}` here to parse `{}` as a public {}", kw, ident, kw_name),
format!(" {} ", kw),
if self.token.is_keyword(keywords::Const) {
self.diagnostic()
.struct_span_err(self.span, "extern items cannot be `const`")
- .span_suggestion_with_applicability(
+ .span_suggestion(
self.span,
"try using a static value",
"static".to_owned(),
projects / rust.git / blobdiff