use ty::error::TypeError;
use syntax::ast::DUMMY_NODE_ID;
use syntax_pos::{Pos, Span};
-use errors::{DiagnosticBuilder, DiagnosticStyledString};
+use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
use rustc_data_structures::indexed_vec::Idx;
if let Some((sp, has_lifetimes)) = type_param_span {
let tail = if has_lifetimes { " + " } else { "" };
let suggestion = format!("{}: {}{}", bound_kind, sub, tail);
- err.span_suggestion_short(sp, consider, suggestion);
+ err.span_suggestion_short_with_applicability(
+ sp, consider, suggestion,
+ Applicability::MaybeIncorrect // Issue #41966
+ );
} else {
err.help(consider);
}
use std::cmp;
-use errors::DiagnosticBuilder;
+use errors::{Applicability, DiagnosticBuilder};
use hir::HirId;
use ich::StableHashingContext;
use lint::builtin;
store.check_lint_name(&name_lower) {
db.emit();
} else {
- db.span_suggestion(
+ db.span_suggestion_with_applicability(
li.span,
"lowercase the lint name",
- name_lower
+ name_lower,
+ Applicability::MachineApplicable
).emit();
}
} else {
use hir::def::*;
use ty::{self, TyCtxt};
use lint;
+use errors::Applicability;
use util::nodemap::{NodeMap, NodeSet};
use std::collections::VecDeque;
let mut err = self.ir.tcx
.struct_span_lint_node(lint::builtin::UNUSED_VARIABLES, id, sp, &msg);
if self.ir.variable_is_shorthand(var) {
- err.span_suggestion(sp, "try ignoring the field",
- format!("{}: _", name));
+ err.span_suggestion_with_applicability(sp, "try ignoring the field",
+ format!("{}: _", name),
+ Applicability::MachineApplicable);
} else {
- err.span_suggestion_short(sp, &suggest_underscore_msg,
- format!("_{}", name));
+ err.span_suggestion_short_with_applicability(
+ sp, &suggest_underscore_msg,
+ format!("_{}", name),
+ Applicability::MachineApplicable,
+ );
}
err.emit()
}
Overflow,
};
-use errors::DiagnosticBuilder;
+use errors::{Applicability, DiagnosticBuilder};
use hir;
use hir::def_id::DefId;
use infer::{self, InferCtxt};
if let Some(ref expr) = local.init {
if let hir::ExprIndex(_, _) = expr.node {
if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(expr.span) {
- err.span_suggestion(expr.span,
- "consider borrowing here",
- format!("&{}", snippet));
+ err.span_suggestion_with_applicability(
+ expr.span,
+ "consider borrowing here",
+ format!("&{}", snippet),
+ Applicability::MachineApplicable
+ );
}
}
}
let format_str = format!("consider removing {} leading `&`-references",
remove_refs);
- err.span_suggestion_short(sp, &format_str, String::from(""));
+ err.span_suggestion_short_with_applicability(
+ sp, &format_str, String::from(""), Applicability::MachineApplicable
+ );
break;
}
} else {
let sugg = fields.iter()
.map(|(name, _)| name.to_owned())
.collect::<Vec<String>>().join(", ");
- err.span_suggestion(found_span,
- "change the closure to take multiple arguments instead of \
- a single tuple",
- format!("|{}|", sugg));
+ err.span_suggestion_with_applicability(found_span,
+ "change the closure to take multiple \
+ arguments instead of a single tuple",
+ format!("|{}|", sugg),
+ Applicability::MachineApplicable);
}
}
if let &[ArgKind::Tuple(_, ref fields)] = &expected_args[..] {
"".to_owned()
},
);
- err.span_suggestion(found_span,
- "change the closure to accept a tuple instead of \
- individual arguments",
- sugg);
+ err.span_suggestion_with_applicability(
+ found_span,
+ "change the closure to accept a tuple instead of \
+ individual arguments",
+ sugg,
+ Applicability::MachineApplicable
+ );
}
}
}
use ast::{Lit, LitKind, Expr, ExprKind, Item, Local, Stmt, StmtKind};
use codemap::{BytePos, Spanned, respan, dummy_spanned};
use syntax_pos::Span;
-use errors::Handler;
+use errors::{Applicability, Handler};
use feature_gate::{Features, GatedCfg};
use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
use parse::parser::Parser;
"incorrect `repr(align)` attribute format");
match value.node {
ast::LitKind::Int(int, ast::LitIntType::Unsuffixed) => {
- err.span_suggestion(item.span,
- "use parentheses instead",
- format!("align({})", int));
+ err.span_suggestion_with_applicability(
+ item.span,
+ "use parentheses instead",
+ format!("align({})", int),
+ Applicability::MachineApplicable
+ );
}
ast::LitKind::Str(s, _) => {
- err.span_suggestion(item.span,
- "use parentheses instead",
- format!("align({})", s));
+ err.span_suggestion_with_applicability(
+ item.span,
+ "use parentheses instead",
+ format!("align({})", s),
+ Applicability::MachineApplicable
+ );
}
_ => {}
}
use attr::{self, HasAttrs};
use codemap::{ExpnInfo, NameAndSpan, MacroBang, MacroAttribute, dummy_spanned, respan};
use config::{is_test_or_bench, StripUnconfigured};
-use errors::FatalError;
+use errors::{Applicability, FatalError};
use ext::base::*;
use ext::derive::{add_derived_markers, collect_derives};
use ext::hygiene::{self, Mark, SyntaxContext};
let trait_list = traits.iter()
.map(|t| format!("{}", t)).collect::<Vec<_>>();
let suggestion = format!("#[derive({})]", trait_list.join(", "));
- err.span_suggestion(span, "try an outer attribute", suggestion);
+ err.span_suggestion_with_applicability(
+ span, "try an outer attribute", suggestion,
+ // We don't 𝑘𝑛𝑜𝑤 that the following item is an ADT
+ Applicability::MaybeIncorrect
+ );
}
err.emit();
}
use ast::{self, Ident};
use syntax_pos::{self, BytePos, CharPos, Pos, Span, NO_EXPANSION};
use codemap::{CodeMap, FilePathMapping};
-use errors::{FatalError, DiagnosticBuilder};
+use errors::{Applicability, FatalError, DiagnosticBuilder};
use parse::{token, ParseSess};
use str::char_at;
use symbol::{Symbol, keywords};
self.sess.span_diagnostic
.struct_span_err(span,
"character literal may only contain one codepoint")
- .span_suggestion(span,
- "if you meant to write a `str` literal, \
- use double quotes",
- format!("\"{}\"", &self.src[start..end]))
- .emit();
+ .span_suggestion_with_applicability(
+ span,
+ "if you meant to write a `str` literal, use double quotes",
+ format!("\"{}\"", &self.src[start..end]),
+ Applicability::MachineApplicable
+ ).emit();
return Ok(token::Literal(token::Str_(Symbol::intern("??")), None))
}
if self.ch_is('\n') || self.is_eof() || self.ch_is('/') {
use {ast, attr};
use codemap::{self, CodeMap, Spanned, respan};
use syntax_pos::{self, Span, MultiSpan, BytePos, FileName, DUMMY_SP};
-use errors::{self, DiagnosticBuilder};
+use errors::{self, Applicability, DiagnosticBuilder};
use parse::{self, classify, token};
use parse::common::SeqSep;
use parse::lexer::TokenAndSpan;
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(ty.span, "use parentheses to disambiguate", sum_with_parens)
- .emit();
+ .span_suggestion_with_applicability(
+ ty.span,
+ "use parentheses to disambiguate",
+ sum_with_parens,
+ Applicability::MachineApplicable
+ ).emit();
}
}
s.print_bounds(" +", &bounds)?;
s.pclose()
});
- err.span_suggestion(sum_span, "try adding parentheses", sum_with_parens);
+ err.span_suggestion_with_applicability(
+ sum_span,
+ "try adding parentheses",
+ sum_with_parens,
+ Applicability::MachineApplicable
+ );
}
TyKind::Ptr(..) | TyKind::BareFn(..) => {
err.span_label(sum_span, "perhaps you forgot parentheses?");
self.diagnostic()
.struct_span_err(span, "missing angle brackets in associated item path")
- .span_suggestion(span, "try", recovered.to_string()).emit();
+ .span_suggestion_with_applicability( // this is a best-effort recovery
+ span, "try", recovered.to_string(), Applicability::MaybeIncorrect
+ ).emit();
Ok(recovered)
}
exp_span.to(self.prev_span),
"cannot use a comma after the base struct",
);
- err.span_suggestion_short(self.span, "remove this comma", "".to_owned());
+ err.span_suggestion_short_with_applicability(
+ self.span,
+ "remove this comma",
+ "".to_owned(),
+ Applicability::MachineApplicable
+ );
err.note("the base struct must always be the last field");
err.emit();
self.recover_stmt();
s.s.word(".")?;
s.s.word(fstr.splitn(2, ".").last().unwrap())
});
- err.span_suggestion(
+ err.span_suggestion_with_applicability(
lo.to(self.prev_span),
"try parenthesizing the first index",
- sugg);
+ sugg,
+ Applicability::MachineApplicable
+ );
}
return Err(err);
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(span_of_tilde,
- "use `!` to perform bitwise negation",
- "!".to_owned());
+ err.span_suggestion_short_with_applicability(
+ span_of_tilde,
+ "use `!` to perform bitwise negation",
+ "!".to_owned(),
+ Applicability::MachineApplicable
+ );
err.emit();
(lo.to(span), self.mk_unary(UnOp::Not, e))
}
// trailing whitespace after the `!` in our suggestion
let to_replace = self.sess.codemap()
.span_until_non_whitespace(lo.to(self.span));
- err.span_suggestion_short(to_replace,
- "use `!` to perform logical negation",
- "!".to_owned());
+ err.span_suggestion_short_with_applicability(
+ to_replace,
+ "use `!` to perform logical negation",
+ "!".to_owned(),
+ Applicability::MachineApplicable
+ );
err.emit();
// —and recover! (just as if we were in the block
// for the `token::Not` arm)
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_short(cur_op_span,
- "did you mean to use `;` here?",
- ";".to_string());
+ err.span_suggestion_with_applicability(
+ cur_op_span,
+ "try using a semicolon",
+ ";".to_string(),
+ Applicability::MaybeIncorrect // speculative
+ );
}
return Err(err);
}
let expr_str = self.sess.codemap().span_to_snippet(expr.span)
.unwrap_or(pprust::expr_to_string(&expr));
- err.span_suggestion(expr.span,
- &format!("try {} the cast value", op_verb),
- format!("({})", expr_str));
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("try {} the cast value", op_verb),
+ format!("({})", expr_str),
+ Applicability::MachineApplicable
+ );
err.emit();
Ok(expr)
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(in_span, "try adding `in` here", " in ".into());
+ err.span_suggestion_short_with_applicability(
+ in_span, "try adding `in` here", " in ".into(),
+ // has been misleading, at least in the past (closed Issue #48492)
+ Applicability::MaybeIncorrect
+ );
err.emit();
}
let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
None)?;
if let Err(mut e) = self.expect(&token::OpenDelim(token::Brace)) {
if self.token == token::Token::Semi {
- e.span_suggestion_short(match_span, "try removing this `match`", "".to_owned());
+ e.span_suggestion_short_with_applicability(
+ match_span,
+ "try removing this `match`",
+ "".to_owned(),
+ Applicability::MaybeIncorrect // speculative
+ );
}
return Err(e)
}
// | - ^^ self.span
// | |
// | parsed until here as `"y" & X`
- err.span_suggestion_short(
+ err.span_suggestion_short_with_applicability(
cm.next_point(arm_start_span),
"missing a comma here to end this `match` arm",
- ",".to_owned()
+ ",".to_owned(),
+ Applicability::MachineApplicable
);
}
_ => {
if self.token == token::OrOr {
let mut err = self.struct_span_err(self.span,
"unexpected token `||` after pattern");
- err.span_suggestion(self.span,
- "use a single `|` to specify multiple patterns",
- "|".to_owned());
+ err.span_suggestion_with_applicability(
+ self.span,
+ "use a single `|` to specify multiple patterns",
+ "|".to_owned(),
+ Applicability::MachineApplicable
+ );
err.emit();
self.bump();
} else if self.check(&token::BinOp(token::Or)) {
if self.token == token::DotDotDot { // Issue #46718
let mut err = self.struct_span_err(self.span,
"expected field pattern, found `...`");
- err.span_suggestion(self.span,
- "to omit remaining fields, use one fewer `.`",
- "..".to_owned());
+ err.span_suggestion_with_applicability(
+ self.span,
+ "to omit remaining fields, use one fewer `.`",
+ "..".to_owned(),
+ Applicability::MachineApplicable
+ );
err.emit();
}
let mut err = self.struct_span_err(comma_span,
"unexpected `,` in pattern");
if let Ok(seq_snippet) = self.sess.codemap().span_to_snippet(seq_span) {
- err.span_suggestion(seq_span, "try adding parentheses",
- format!("({})", seq_snippet));
+ err.span_suggestion_with_applicability(
+ seq_span,
+ "try adding parentheses",
+ format!("({})", seq_snippet),
+ Applicability::MachineApplicable
+ );
}
return Err(err);
}
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(mutref_span, "try switching the order", "ref mut".into())
- .emit();
+ .span_suggestion_with_applicability(
+ mutref_span,
+ "try switching the order",
+ "ref mut".into(),
+ Applicability::MachineApplicable
+ ).emit();
BindingMode::ByRef(Mutability::Mutable)
} else {
BindingMode::ByValue(Mutability::Mutable)
pat.span,
"the range pattern here has ambiguous interpretation",
);
- err.span_suggestion(
+ err.span_suggestion_with_applicability(
pat.span,
"add parentheses to clarify the precedence",
format!("({})", pprust::pat_to_string(&pat)),
+ // "ambiguous interpretation" implies that we have to be guessing
+ Applicability::MaybeIncorrect
);
return Err(err);
}
(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(colon_sp,
- "use `=` if you meant to assign",
- "=".to_string());
+ err.span_suggestion_short_with_applicability(
+ colon_sp,
+ "use `=` if you meant to assign",
+ "=".to_string(),
+ Applicability::MachineApplicable
+ );
err.emit();
// As this was parsed successfully, continue as if the code has been fixed for the
// rest of the file. It will still fail due to the emitted error, but we avoid
s.print_stmt(&stmt)?;
s.bclose_maybe_open(stmt.span, INDENT_UNIT, false)
});
- e.span_suggestion(stmt_span, "try placing this code inside a block", sugg);
+ e.span_suggestion_with_applicability(
+ stmt_span,
+ "try placing this code inside a block",
+ sugg,
+ // speculative, has been misleading in the past (closed Issue #46836)
+ Applicability::MaybeIncorrect
+ );
}
Err(mut e) => {
self.recover_stmt_(SemiColonMode::Break, BlockMode::Ignore);
if is_macro_rules {
let mut err = self.diagnostic()
.struct_span_err(sp, "can't qualify macro_rules invocation with `pub`");
- err.span_suggestion(sp,
- "try exporting the macro",
- "#[macro_export]".to_owned());
+ err.span_suggestion_with_applicability(
+ sp,
+ "try exporting the macro",
+ "#[macro_export]".to_owned(),
+ Applicability::MaybeIncorrect // speculative
+ );
Err(err)
} else {
let mut err = self.diagnostic()
} else {
if seen_comma == false {
let sp = self.sess.codemap().next_point(previous_span);
- err.span_suggestion(sp, "missing comma here", ",".into());
+ err.span_suggestion_with_applicability(
+ sp,
+ "missing comma here",
+ ",".into(),
+ Applicability::MachineApplicable
+ );
}
return Err(err);
}
let help_msg = format!("make this visible only to module `{}` with `in`", path);
self.expect(&token::CloseDelim(token::Paren))?; // `)`
let mut err = self.span_fatal_help(path_span, msg, suggestion);
- err.span_suggestion(path_span, &help_msg, format!("in {}", path));
+ err.span_suggestion_with_applicability(
+ path_span, &help_msg, format!("in {}", path), Applicability::MachineApplicable
+ );
err.emit(); // emit diagnostic, but continue with public visibility
}
}
let mut err = self.fatal(&format!("expected item, found `{}`", token_str));
if token_str == ";" {
let msg = "consider removing this semicolon";
- err.span_suggestion_short(self.span, msg, "".to_string());
+ err.span_suggestion_short_with_applicability(
+ self.span, msg, "".to_string(), Applicability::MachineApplicable
+ );
} else {
err.span_label(self.span, "expected item");
}
ident);
let mut err = self.diagnostic()
.struct_span_err(sp, "missing `struct` for struct definition");
- err.span_suggestion_short(sp, &msg, " struct ".into());
+ err.span_suggestion_short_with_applicability(
+ sp, &msg, " struct ".into(), Applicability::MaybeIncorrect // speculative
+ );
return Err(err);
} else if self.look_ahead(1, |t| *t == token::OpenDelim(token::Paren)) {
let ident = self.parse_ident().unwrap();
kw,
ident,
kw_name);
- err.span_suggestion_short(sp, &suggestion, format!(" {} ", kw));
+ err.span_suggestion_short_with_applicability(
+ sp, &suggestion, format!(" {} ", kw), Applicability::MachineApplicable
+ );
} else {
if let Ok(snippet) = self.sess.codemap().span_to_snippet(ident_sp) {
- err.span_suggestion(
+ err.span_suggestion_with_applicability(
full_sp,
- "if you meant to call a macro, write instead",
- format!("{}!", snippet));
+ "if you meant to call a macro, try",
+ format!("{}!", snippet),
+ // this is the `ambiguous` conditional branch
+ Applicability::MaybeIncorrect
+ );
} else {
err.help("if you meant to call a macro, remove the `pub` \
and add a trailing `!` after the identifier");
if self.token.is_keyword(keywords::Const) {
self.diagnostic()
.struct_span_err(self.span, "extern items cannot be `const`")
- .span_suggestion(self.span, "instead try using", "static".to_owned())
- .emit();
+ .span_suggestion_with_applicability(
+ self.span,
+ "try using a static value",
+ "static".to_owned(),
+ Applicability::MachineApplicable
+ ).emit();
}
self.bump(); // `static` or `const`
return Ok(Some(self.parse_item_foreign_static(visibility, lo, attrs)?));
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+// compile-flags: -Z continue-parse-after-error
+
+extern "C" {
+ static C: u8; //~ ERROR extern items cannot be `const`
+}
+
+fn main() {
+ // We suggest turning the (illegal) extern `const` into an extern `static`,
+ // but this also requires `unsafe` (a deny-by-default lint at comment time,
+ // future error; Issue #36247)
+ unsafe {
+ let _x = C;
+ }
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// run-rustfix
// compile-flags: -Z continue-parse-after-error
extern "C" {
}
fn main() {
- let x = C;
+ // We suggest turning the (illegal) extern `const` into an extern `static`,
+ // but this also requires `unsafe` (a deny-by-default lint at comment time,
+ // future error; Issue #36247)
+ unsafe {
+ let _x = C;
+ }
}
error: extern items cannot be `const`
- --> $DIR/extern-const.rs:14:5
+ --> $DIR/extern-const.rs:15:5
|
LL | const C: u8; //~ ERROR extern items cannot be `const`
- | ^^^^^ help: instead try using: `static`
+ | ^^^^^ help: try using a static value: `static`
error: aborting due to previous error
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(unused_must_use, unused_comparisons)]
+
+macro_rules! is_plainly_printable {
+ ($i: ident) => {
+ ($i as u32) < 0 //~ `<` is interpreted as a start of generic arguments
+ };
+}
+
+fn main() {
+ let c = 'a';
+ is_plainly_printable!(c);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// run-rustfix
+
+#![allow(unused_must_use, unused_comparisons)]
+
macro_rules! is_plainly_printable {
($i: ident) => {
$i as u32 < 0 //~ `<` is interpreted as a start of generic arguments
error: `<` is interpreted as a start of generic arguments for `u32`, not a comparison
- --> $DIR/issue-42954.rs:13:19
+ --> $DIR/issue-42954.rs:17:19
|
LL | $i as u32 < 0 //~ `<` is interpreted as a start of generic arguments
| --------- ^ - interpreted as generic arguments
--> $DIR/issue-44406.rs:18:10
|
LL | bar(baz: $rest)
- | - help: did you mean to use `;` here?
+ | - help: try using a semicolon: `;`
...
LL | foo!(true); //~ ERROR expected type, found keyword
| ^^^^ expecting a type here because of type ascription
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(dead_code)]
+
+struct S {
+ x: u8,
+ /// The id of the parent core
+ y: u8,
+}
+//~^^^ ERROR found a documentation comment that doesn't document anything
+fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// run-rustfix
+
+#![allow(dead_code)]
+
struct S {
x: u8
/// The id of the parent core
error[E0585]: found a documentation comment that doesn't document anything
- --> $DIR/issue-48636.rs:13:5
+ --> $DIR/issue-48636.rs:17:5
|
LL | x: u8
| - help: missing comma here: `,`
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Regression test for #47244: in this specific scenario, when the
+// expected type indicated 1 argument but the closure takes two, we
+// would (early on) create type variables for the type of `b`. If the
+// user then attempts to invoke a method on `b`, we would get an error
+// saying that the type of `b` must be known, which was not very
+// helpful.
+
+// run-rustfix
+
+use std::collections::HashMap;
+
+fn main() {
+ let mut m = HashMap::new();
+ m.insert("foo", "bar");
+
+ let _n = m.iter().map(|(_, b)| {
+ //~^ ERROR closure is expected to take a single 2-tuple
+ b.to_string()
+ });
+}
// saying that the type of `b` must be known, which was not very
// helpful.
+// run-rustfix
+
use std::collections::HashMap;
-fn main() {
- let m = HashMap::new();
- m.insert( "foo", "bar" );
+fn main() {
+ let mut m = HashMap::new();
+ m.insert("foo", "bar");
- m.iter().map( |_, b| {
+ let _n = m.iter().map(|_, b| {
//~^ ERROR closure is expected to take a single 2-tuple
-
b.to_string()
});
}
error[E0593]: closure is expected to take a single 2-tuple as argument, but it takes 2 distinct arguments
- --> $DIR/closure-arg-count-expected-type-issue-47244.rs:24:14
+ --> $DIR/closure-arg-count-expected-type-issue-47244.rs:26:23
|
-LL | m.iter().map( |_, b| {
- | ^^^ ------ takes 2 distinct arguments
- | |
- | expected closure that takes a single 2-tuple as argument
+LL | let _n = m.iter().map(|_, b| {
+ | ^^^ ------ takes 2 distinct arguments
+ | |
+ | expected closure that takes a single 2-tuple as argument
help: change the closure to accept a tuple instead of individual arguments
|
-LL | m.iter().map( |(_, b)| {
- | ^^^^^^^^
+LL | let _n = m.iter().map(|(_, b)| {
+ | ^^^^^^^^
error: aborting due to previous error
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(dead_code)]
+
+#[repr(align(8))] //~ ERROR incorrect `repr(align)` attribute format
+struct A(u64);
+
+#[repr(align(8))] //~ ERROR incorrect `repr(align)` attribute format
+struct B(u64);
+
+fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// run-rustfix
+
+#![allow(dead_code)]
+
#[repr(align=8)] //~ ERROR incorrect `repr(align)` attribute format
struct A(u64);
error[E0693]: incorrect `repr(align)` attribute format
- --> $DIR/repr-align-assign.rs:11:8
+ --> $DIR/repr-align-assign.rs:15:8
|
LL | #[repr(align=8)] //~ ERROR incorrect `repr(align)` attribute format
| ^^^^^^^ help: use parentheses instead: `align(8)`
error[E0693]: incorrect `repr(align)` attribute format
- --> $DIR/repr-align-assign.rs:14:8
+ --> $DIR/repr-align-assign.rs:18:8
|
LL | #[repr(align="8")] //~ ERROR incorrect `repr(align)` attribute format
| ^^^^^^^^^ help: use parentheses instead: `align(8)`
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(unused_imports)]
+
+pub mod extension1 {
+ pub trait ConstructorExtension {}
+}
+
+pub mod extension2 {
+ pub trait ConstructorExtension {}
+}
+
+use extension1::ConstructorExtension;
+use extension2::ConstructorExtension as OtherConstructorExtension; //~ ERROR is defined multiple times
+
+fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// run-rustfix
+
+#![allow(unused_imports)]
+
pub mod extension1 {
pub trait ConstructorExtension {}
}
error[E0252]: the name `ConstructorExtension` is defined multiple times
- --> $DIR/issue-32354-suggest-import-rename.rs:20:5
+ --> $DIR/issue-32354-suggest-import-rename.rs:24:5
|
LL | use extension1::ConstructorExtension;
| -------------------------------- previous import of the trait `ConstructorExtension` here
--> $DIR/pub-ident-fn-or-struct-2.rs:11:4
|
LL | pub S();
- | ---^- help: if you meant to call a macro, write instead: `S!`
+ | ---^- help: if you meant to call a macro, try: `S!`
error: aborting due to previous error
--> $DIR/pub-ident-fn-or-struct.rs:11:4
|
LL | pub S (foo) bar
- | ---^- help: if you meant to call a macro, write instead: `S!`
+ | ---^- help: if you meant to call a macro, try: `S!`
error: aborting due to previous error
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+pub fn foo(_s: usize) -> bool { true }
+//~^ ERROR missing `fn` for method definition
+
+fn main() {
+ foo(2);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub foo(s: usize) -> bool { true }
+// run-rustfix
+
+pub foo(_s: usize) -> bool { true }
//~^ ERROR missing `fn` for method definition
fn main() {
error: missing `fn` for method definition
- --> $DIR/pub-ident-fn.rs:11:4
+ --> $DIR/pub-ident-fn.rs:13:4
|
-LL | pub foo(s: usize) -> bool { true }
+LL | pub foo(_s: usize) -> bool { true }
| ^^^
help: add `fn` here to parse `foo` as a public method
|
-LL | pub fn foo(s: usize) -> bool { true }
+LL | pub fn foo(_s: usize) -> bool { true }
| ^^
error: aborting due to previous error
--> $DIR/type-ascription-instead-of-statement-end.rs:15:5
|
LL | println!("test"):
- | - help: did you mean to use `;` here?
+ | - help: try using a semicolon: `;`
LL | 0; //~ ERROR expected type, found `0`
| ^ expecting a type here because of type ascription
projects / rust.git / commitdiff