// Here we explicitly #[cfg]-out this whole crate when testing. If we don't do
// this, both the generated test artifact and the linked libtest (which
// transitively includes libcore) will both define the same set of lang items,
-// and this will cause the E0152 "duplicate lang item found" error. See
+// and this will cause the E0152 "found duplicate lang item" error. See
// discussion in #50466 for details.
//
// This cfg won't affect doc tests.
self.tcx.sess,
span,
E0152,
- "duplicate lang item found: `{}`.",
+ "found duplicate lang item `{}`",
name
),
None => {
},
};
if let Some(span) = self.tcx.hir().span_if_local(original_def_id) {
- err.span_note(span, "first defined here.");
+ err.span_note(span, "first defined here");
} else {
match self.tcx.extern_crate(original_def_id) {
Some(ExternCrate {dependency_of, ..}) => {
err.note(&format!(
- "first defined in crate `{}` (which `{}` depends on).",
+ "first defined in crate `{}` (which `{}` depends on)",
self.tcx.crate_name(original_def_id.krate),
self.tcx.crate_name(*dependency_of)));
},
err.span_help(impl_span, "trait impl with same name found");
let trait_crate = self.tcx.crate_name(trait_with_same_path.krate);
let crate_msg = format!(
- "Perhaps two different versions of crate `{}` are being used?",
+ "perhaps two different versions of crate `{}` are being used?",
trait_crate
);
err.note(&crate_msg);
self.check_extern(bare_fn_ty.ext);
}
ast::TyKind::Never => {
- gate_feature_post!(&self, never_type, ty.span, "The `!` type is experimental");
+ gate_feature_post!(&self, never_type, ty.span, "the `!` type is experimental");
}
_ => {}
}
`expected = \"error message\"`",
)
.note(
- "Errors in this attribute were erroneously \
+ "errors in this attribute were erroneously \
allowed and will become a hard error in a \
future release.",
)
)
.span_suggestion(
arg.pat.span,
- "Try naming the parameter or explicitly \
+ "try naming the parameter or explicitly \
ignoring it",
format!("_: {}", ty_snip),
appl,
use rustc::ty::TyKind::*;
match ty.kind {
// Primitive types that don't like 0 as a value.
- Ref(..) => Some((format!("References must be non-null"), None)),
+ Ref(..) => Some((format!("references must be non-null"), None)),
Adt(..) if ty.is_box() => Some((format!("`Box` must be non-null"), None)),
- FnPtr(..) => Some((format!("Function pointers must be non-null"), None)),
- Never => Some((format!("The never type (`!`) has no valid value"), None)),
+ FnPtr(..) => Some((format!("function pointers must be non-null"), None)),
+ Never => Some((format!("the `!` type has no valid value"), None)),
RawPtr(tm) if matches!(tm.ty.kind, Dynamic(..)) =>
// raw ptr to dyn Trait
{
- Some((format!("The vtable of a wide raw pointer must be non-null"), None))
+ Some((format!("the vtable of a wide raw pointer must be non-null"), None))
}
// Primitive types with other constraints.
Bool if init == InitKind::Uninit => {
- Some((format!("Booleans must be `true` or `false`"), None))
+ Some((format!("booleans must be either `true` or `false`"), None))
}
Char if init == InitKind::Uninit => {
- Some((format!("Characters must be a valid unicode codepoint"), None))
+ Some((format!("characters must be a valid Unicode codepoint"), None))
}
// Recurse and checks for some compound types.
Adt(adt_def, substs) if !adt_def.is_union() => {
// return `Bound::Excluded`. (And we have tests checking that we
// handle the attribute correctly.)
(Bound::Included(lo), _) if lo > 0 => {
- return Some((format!("{} must be non-null", ty), None));
+ return Some((format!("`{}` must be non-null", ty), None));
}
(Bound::Included(_), _) | (_, Bound::Included(_))
if init == InitKind::Uninit =>
{
return Some((
- format!("{} must be initialized inside its custom valid range", ty),
+ format!(
+ "`{}` must be initialized inside its custom valid range",
+ ty,
+ ),
None,
));
}
}
// Now, recurse.
match adt_def.variants.len() {
- 0 => Some((format!("0-variant enums have no valid value"), None)),
+ 0 => Some((format!("enums with no variants have no valid value"), None)),
1 => {
// Struct, or enum with exactly one variant.
// Proceed recursively, check all fields.
// better.
if let Some(closure_region_requirements) = closure_region_requirements {
- let mut err = tcx.sess.diagnostic().span_note_diag(body.span, "External requirements");
+ let mut err = tcx.sess.diagnostic().span_note_diag(body.span, "external requirements");
regioncx.annotate(tcx, &mut err);
err.buffer(errors_buffer);
} else {
- let mut err = tcx.sess.diagnostic().span_note_diag(body.span, "No external requirements");
+ let mut err = tcx.sess.diagnostic().span_note_diag(body.span, "no external requirements");
regioncx.annotate(tcx, &mut err);
err.buffer(errors_buffer);
self.struct_span_err(lit.span, msg)
.help(
"instead of using a suffixed literal \
- (1u8, 1.0f32, etc.), use an unsuffixed version \
- (1, 1.0, etc.).",
+ (`1u8`, `1.0f32`, etc.), use an unsuffixed version \
+ (`1`, `1.0`, etc.)",
)
.emit()
}
if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
err.span_suggestion(
seq_span,
- "try adding parentheses to match on a tuple..",
+ "try adding parentheses to match on a tuple...",
format!("({})", seq_snippet),
Applicability::MachineApplicable,
)
.span_suggestion(
seq_span,
- "..or a vertical bar to match on multiple alternatives",
+ "...or a vertical bar to match on multiple alternatives",
format!("{}", seq_snippet.replace(",", " |")),
Applicability::MachineApplicable,
);
)),
};
if let Some(span) = tcx.hir().span_if_local(original_def_id) {
- err.span_note(span, "first defined here.");
+ err.span_note(span, "first defined here");
} else {
err.note(&format!(
"first defined in crate `{}`.",
.session
.struct_span_err(
attr.span,
- "`macro_use` is not supported on `extern crate self`",
+ "`#[macro_use]` is not supported on `extern crate self`",
)
.emit();
}
fn contains_macro_use(&mut self, attrs: &[ast::Attribute]) -> bool {
for attr in attrs {
if attr.check_name(sym::macro_escape) {
- let msg = "macro_escape is a deprecated synonym for macro_use";
+ let msg = "`#[macro_escape]` is a deprecated synonym for `#[macro_use]`";
let mut err = self.r.session.struct_span_warn(attr.span, msg);
if let ast::AttrStyle::Inner = attr.style {
- err.help("consider an outer attribute, `#[macro_use]` mod ...").emit();
+ err.help("try an outer attribute: `#[macro_use]`").emit();
} else {
err.emit();
}
}
if !attr.is_word() {
- self.r.session.span_err(attr.span, "arguments to macro_use are not allowed here");
+ self.r.session.span_err(attr.span, "arguments to `macro_use` are not allowed here");
}
return true;
}
continue;
}
}
- let msg = "there are too many initial `super`s.".to_string();
+ let msg = "there are too many leading `super` keywords".to_string();
return PathResult::Failed {
span: ident.span,
label: msg,
if unknown_cast_to { "to" } else { "from" }
);
err.note(
- "The type information given here is insufficient to check whether \
+ "the type information given here is insufficient to check whether \
the pointer cast is valid",
);
if unknown_cast_to {
macro_rules! report_function {
($span:expr, $name:expr) => {
err.note(&format!(
- "{} is a function, perhaps you wish to call it",
+ "`{}` is a function, perhaps you wish to call it",
$name
));
};
if let hir::OpaqueTyOrigin::AsyncFn = origin {
struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing",)
.span_label(span, "recursive `async fn`")
- .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
+ .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`")
.emit();
} else {
let mut err =
let _ = writeln!(
err,
"note: run with `RUST_BACKTRACE=1` \
- environment variable to display a backtrace."
+ environment variable to display a backtrace"
);
}
}
#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
- //~^ error duplicate lang item found: `panic_impl`
+ //~^ ERROR found duplicate lang item `panic_impl`
loop {}
}
{ "type": "test", "event": "started", "name": "a" }
{ "type": "test", "name": "a", "event": "ok" }
{ "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:9:5\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:9:5\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
{ "type": "test", "event": "started", "name": "c" }
{ "type": "test", "name": "c", "event": "ok" }
{ "type": "test", "event": "started", "name": "d" }
{ "type": "test", "event": "started", "name": "a" }
{ "type": "test", "name": "a", "event": "ok", "stdout": "print from successful test\n" }
{ "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:9:5\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:9:5\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
{ "type": "test", "event": "started", "name": "c" }
{ "type": "test", "name": "c", "event": "ok", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:15:5\n" }
{ "type": "test", "event": "started", "name": "d" }
stderr 1
stderr 2
thread 'main' panicked at 'oh no', $DIR/failed-doctest-output.rs:7:1
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
--> $DIR/anon-params-deprecated.rs:9:12
|
LL | fn foo(i32);
- | ^^^ help: Try naming the parameter or explicitly ignoring it: `_: i32`
+ | ^^^ help: try naming the parameter or explicitly ignoring it: `_: i32`
|
note: lint level defined here
--> $DIR/anon-params-deprecated.rs:1:9
--> $DIR/anon-params-deprecated.rs:12:30
|
LL | fn bar_with_default_impl(String, String) {}
- | ^^^^^^ help: Try naming the parameter or explicitly ignoring it: `_: String`
+ | ^^^^^^ help: try naming the parameter or explicitly ignoring it: `_: String`
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
= note: for more information, see issue #41686 <https://github.com/rust-lang/rust/issues/41686>
--> $DIR/anon-params-deprecated.rs:12:38
|
LL | fn bar_with_default_impl(String, String) {}
- | ^^^^^^ help: Try naming the parameter or explicitly ignoring it: `_: String`
+ | ^^^^^^ help: try naming the parameter or explicitly ignoring it: `_: String`
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
= note: for more information, see issue #41686 <https://github.com/rust-lang/rust/issues/41686>
LL | async fn rec_1() {
| ^ recursive `async fn`
|
- = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`.
+ = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`
error[E0733]: recursion in an `async fn` requires boxing
--> $DIR/mutually-recursive-async-impl-trait-type.rs:9:18
LL | async fn rec_2() {
| ^ recursive `async fn`
|
- = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`.
+ = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`
error: aborting due to 2 previous errors
LL | async fn recursive_async_function() -> () {
| ^^ recursive `async fn`
|
- = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`.
+ = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`
error: aborting due to previous error
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
= note: `#[warn(invalid_value)]` on by default
- = note: The never type (`!`) has no valid value
+ = note: the `!` type has no valid value
warning: the type `Empty` does not permit zero-initialization
--> $DIR/validate_uninhabited_zsts.rs:17:35
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: 0-variant enums have no valid value
+ = note: enums with no variants have no valid value
error: aborting due to previous error
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
thread 'rustc' panicked at 'no errors encountered even though `delay_span_bug` issued', src/librustc_errors/lib.rs:346:17
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: internal compiler error: unexpected panic
thread 'rustc' panicked at 'assertion failed: `(left != right)`
left: `Const`,
right: `Const`: UnsafeCells are not allowed behind references in constants. This should have been prevented statically by const qualification. If this were allowed one would be able to change a constant at one use site and other use sites could observe that mutation.', src/librustc_mir/interpret/intern.rs:LL:CC
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: internal compiler error: unexpected panic
// run-pass
mod foo {
- #![macro_escape] //~ WARNING macro_escape is a deprecated synonym for macro_use
+ #![macro_escape] //~ WARN `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
}
fn main() {
-warning: macro_escape is a deprecated synonym for macro_use
+warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
--> $DIR/deprecated-macro_escape-inner.rs:4:5
|
LL | #![macro_escape]
| ^^^^^^^^^^^^^^^^
|
- = help: consider an outer attribute, `#[macro_use]` mod ...
+ = help: try an outer attribute: `#[macro_use]`
// run-pass
-#[macro_escape] //~ WARNING macro_escape is a deprecated synonym for macro_use
-mod foo {
-}
+#[macro_escape] //~ WARNING `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
+mod foo {}
-fn main() {
-}
+fn main() {}
-warning: macro_escape is a deprecated synonym for macro_use
+warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
--> $DIR/deprecated-macro_escape.rs:3:1
|
LL | #[macro_escape]
LL | while let b1, b2, b3 = reading_frame.next().expect("there should be a start codon") {
| ^
|
-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
+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") {
| ^^^^^^^^^^^^
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
+help: ...or a vertical bar to match on multiple alternatives
|
LL | if let b1 | b2 | b3 = reading_frame.next().unwrap() {
| ^^^^^^^^^^^^
LL | Nucleotide::Adenine, Nucleotide::Cytosine, _ => true
| ^
|
-help: try adding parentheses to match on a tuple..
+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
+help: ...or a vertical bar to match on multiple alternatives
|
LL | Nucleotide::Adenine | Nucleotide::Cytosine | _ => true
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
+help: ...or a vertical bar to match on multiple alternatives
|
LL | for x | _barr_body in women.iter().map(|woman| woman.allosomes.clone()) {
| ^^^^^^^^^^^^^^
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
+help: ...or a vertical bar to match on multiple alternatives
|
LL | for x | y @ Allosome::Y(_) in men.iter().map(|man| man.allosomes.clone()) {
| ^^^^^^^^^^^^^^^^^^^^^^
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
+help: ...or a vertical bar to match on multiple alternatives
|
LL | let women | men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
| ^^^^^^^^^^^
#[lang = "panic_impl"]
fn panic_impl(info: &PanicInfo) -> ! {
-//~^ ERROR: duplicate lang item found: `panic_impl`.
+//~^ ERROR: found duplicate lang item `panic_impl`
loop {}
}
-error[E0152]: duplicate lang item found: `panic_impl`.
+error[E0152]: found duplicate lang item `panic_impl`
--> $DIR/duplicate_entry_error.rs:10:1
|
LL | / fn panic_impl(info: &PanicInfo) -> ! {
LL | | }
| |_^
|
- = note: first defined in crate `std` (which `duplicate_entry_error` depends on).
+ = note: first defined in crate `std` (which `duplicate_entry_error` depends on)
error: aborting due to previous error
-error[E0152]: duplicate lang item found: `arc`.
+error[E0152]: found duplicate lang item `arc`
--> $DIR/E0152.rs:4:1
|
LL | struct Foo;
| ^^^^^^^^^^^
|
- = note: first defined in crate `alloc` (which `std` depends on).
+ = note: first defined in crate `alloc` (which `std` depends on)
error: aborting due to previous error
// Cannot feed "2700" to `#[macro_escape]` without signaling an error.
#[macro_escape]
-//~^ WARN macro_escape is a deprecated synonym for macro_use
+//~^ WARN `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
mod macro_escape {
mod inner { #![macro_escape] }
- //~^ WARN macro_escape is a deprecated synonym for macro_use
+ //~^ WARN `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
#[macro_escape] fn f() { }
//~^ WARN unused attribute
LL | #[deny(x5100)] impl S { }
| ^^^^^
-warning: macro_escape is a deprecated synonym for macro_use
+warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:466:1
|
LL | #[macro_escape]
| ^^^^^^^^^^^^^^^
-warning: macro_escape is a deprecated synonym for macro_use
+warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:469:17
|
LL | mod inner { #![macro_escape] }
| ^^^^^^^^^^^^^^^^
|
- = help: consider an outer attribute, `#[macro_use]` mod ...
+ = help: try an outer attribute: `#[macro_use]`
warning: use of deprecated attribute `plugin_registrar`: compiler plugins are deprecated. See https://github.com/rust-lang/rust/pull/64675
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:221:17
// check-pass
#![macro_escape]
-//~^ WARN macro_escape is a deprecated synonym for macro_use
+//~^ WARN `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
fn main() {}
-warning: macro_escape is a deprecated synonym for macro_use
+warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
--> $DIR/issue-43106-gating-of-macro_escape.rs:8:1
|
LL | #![macro_escape]
| ^^^^^^^^^^^^^^^^
|
- = help: consider an outer attribute, `#[macro_use]` mod ...
+ = help: try an outer attribute: `#[macro_use]`
// get that warning; see issue-43106-gating-of-builtin-attrs.rs
#![macro_use(my_macro)]
-//~^ ERROR arguments to macro_use are not allowed here
+//~^ ERROR arguments to `macro_use` are not allowed here
#[macro_use(my_macro)]
-//~^ ERROR arguments to macro_use are not allowed here
+//~^ ERROR arguments to `macro_use` are not allowed here
mod macro_escape {
mod inner { #![macro_use(my_macro)] }
- //~^ ERROR arguments to macro_use are not allowed here
+ //~^ ERROR arguments to `macro_use` are not allowed here
#[macro_use = "2700"] struct S;
//~^ ERROR malformed `macro_use` attribute
-error: arguments to macro_use are not allowed here
+error: arguments to `macro_use` are not allowed here
--> $DIR/issue-43106-gating-of-macro_use.rs:6:1
|
LL | #![macro_use(my_macro)]
| ^^^^^^^^^^^^^^^^^^^^^^^
-error: arguments to macro_use are not allowed here
+error: arguments to `macro_use` are not allowed here
--> $DIR/issue-43106-gating-of-macro_use.rs:9:1
|
LL | #[macro_use(my_macro)]
| ^^^^^^^^^^^^^^^^^^^^^^
-error: arguments to macro_use are not allowed here
+error: arguments to `macro_use` are not allowed here
--> $DIR/issue-43106-gating-of-macro_use.rs:12:17
|
LL | mod inner { #![macro_use(my_macro)] }
-error[E0658]: The `!` type is experimental
+error[E0658]: the `!` type is experimental
--> $DIR/feature-gate-never_type.rs:7:17
|
LL | type Ma = (u32, !, i32);
= note: for more information, see https://github.com/rust-lang/rust/issues/35121
= help: add `#![feature(never_type)]` to the crate attributes to enable
-error[E0658]: The `!` type is experimental
+error[E0658]: the `!` type is experimental
--> $DIR/feature-gate-never_type.rs:8:20
|
LL | type Meeshka = Vec<!>;
= note: for more information, see https://github.com/rust-lang/rust/issues/35121
= help: add `#![feature(never_type)]` to the crate attributes to enable
-error[E0658]: The `!` type is experimental
+error[E0658]: the `!` type is experimental
--> $DIR/feature-gate-never_type.rs:9:24
|
LL | type Mow = &'static fn(!) -> !;
= note: for more information, see https://github.com/rust-lang/rust/issues/35121
= help: add `#![feature(never_type)]` to the crate attributes to enable
-error[E0658]: The `!` type is experimental
+error[E0658]: the `!` type is experimental
--> $DIR/feature-gate-never_type.rs:10:27
|
LL | type Skwoz = &'static mut !;
= note: for more information, see https://github.com/rust-lang/rust/issues/35121
= help: add `#![feature(never_type)]` to the crate attributes to enable
-error[E0658]: The `!` type is experimental
+error[E0658]: the `!` type is experimental
--> $DIR/feature-gate-never_type.rs:13:16
|
LL | type Wub = !;
--> $DIR/future-incompatible-lint-group.rs:4:10
|
LL | fn f(u8) {}
- | ^^ help: Try naming the parameter or explicitly ignoring it: `_: u8`
+ | ^^ help: try naming the parameter or explicitly ignoring it: `_: u8`
|
note: lint level defined here
--> $DIR/future-incompatible-lint-group.rs:1:9
extern crate self; //~ ERROR `extern crate self;` requires renaming
-#[macro_use] //~ ERROR `macro_use` is not supported on `extern crate self`
+#[macro_use] //~ ERROR `#[macro_use]` is not supported on `extern crate self`
extern crate self as foo;
fn main() {}
LL | extern crate self;
| ^^^^^^^^^^^^^^^^^^ help: try: `extern crate self as name;`
-error: `macro_use` is not supported on `extern crate self`
+error: `#[macro_use]` is not supported on `extern crate self`
--> $DIR/extern-crate-self-fail.rs:3:1
|
LL | #[macro_use]
LL | Obj::func.x();
| ^ method not found in `fn() -> Ret {Obj::func}`
|
- = note: Obj::func is a function, perhaps you wish to call it
+ = note: `Obj::func` is a function, perhaps you wish to call it
error[E0599]: no method named `x` found for fn item `fn() -> Ret {func}` in the current scope
--> $DIR/issue-29124.rs:17:10
LL | func.x();
| ^ method not found in `fn() -> Ret {func}`
|
- = note: func is a function, perhaps you wish to call it
+ = note: `func` is a function, perhaps you wish to call it
error: aborting due to 2 previous errors
| |
| help: consider giving more type information
|
- = note: The type information given here is insufficient to check whether the pointer cast is valid
+ = note: the type information given here is insufficient to check whether the pointer cast is valid
error[E0641]: cannot cast to a pointer of an unknown kind
--> $DIR/issue-45730.rs:5:23
| |
| help: consider giving more type information
|
- = note: The type information given here is insufficient to check whether the pointer cast is valid
+ = note: the type information given here is insufficient to check whether the pointer cast is valid
error[E0641]: cannot cast to a pointer of an unknown kind
--> $DIR/issue-45730.rs:8:13
| |
| help: consider giving more type information
|
- = note: The type information given here is insufficient to check whether the pointer cast is valid
+ = note: the type information given here is insufficient to check whether the pointer cast is valid
error: aborting due to 3 previous errors
LL | a.f();
| ^ method not found in `fn(&u8)`
|
- = note: a is a function, perhaps you wish to call it
+ = note: `a` is a function, perhaps you wish to call it
= help: items from traits can only be used if the trait is implemented and in scope
= note: the following trait defines an item `f`, perhaps you need to implement it:
candidate #1: `Trait`
fn main() {
- let super = 22; //~ ERROR failed to resolve: there are too many initial `super`s
+ let super = 22; //~ ERROR failed to resolve: there are too many leading `super` keywords
}
-error[E0433]: failed to resolve: there are too many initial `super`s.
+error[E0433]: failed to resolve: there are too many leading `super` keywords
--> $DIR/keyword-super-as-identifier.rs:2:9
|
LL | let super = 22;
- | ^^^^^ there are too many initial `super`s.
+ | ^^^^^ there are too many leading `super` keywords
error: aborting due to previous error
fn main() {
- let super: isize; //~ ERROR failed to resolve: there are too many initial `super`s
+ let super: isize; //~ ERROR failed to resolve: there are too many leading `super` keywords
}
-error[E0433]: failed to resolve: there are too many initial `super`s.
+error[E0433]: failed to resolve: there are too many leading `super` keywords
--> $DIR/keyword-super.rs:2:9
|
LL | let super: isize;
- | ^^^^^ there are too many initial `super`s.
+ | ^^^^^ there are too many leading `super` keywords
error: aborting due to previous error
|
LL | #![deny(invalid_value)]
| ^^^^^^^^^^^^^
- = note: References must be non-null
+ = note: references must be non-null
error: the type `&'static T` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:30:32
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: References must be non-null
+ = note: references must be non-null
error: the type `Wrap<&'static T>` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:32:38
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: References must be non-null (in this struct field)
+note: references must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:18:18
|
LL | struct Wrap<T> { wrapped: T }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: References must be non-null (in this struct field)
+note: references must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:18:18
|
LL | struct Wrap<T> { wrapped: T }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: The never type (`!`) has no valid value
+ = note: the `!` type has no valid value
error: the type `!` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:41:23
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: The never type (`!`) has no valid value
+ = note: the `!` type has no valid value
error: the type `(i32, !)` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:43:30
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: The never type (`!`) has no valid value
+ = note: the `!` type has no valid value
error: the type `(i32, !)` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:44:30
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: The never type (`!`) has no valid value
+ = note: the `!` type has no valid value
error: the type `Void` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:46:26
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: 0-variant enums have no valid value
+ = note: enums with no variants have no valid value
error: the type `Void` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:47:26
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: 0-variant enums have no valid value
+ = note: enums with no variants have no valid value
error: the type `&'static i32` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:49:34
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: References must be non-null
+ = note: references must be non-null
error: the type `&'static i32` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:50:34
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: References must be non-null
+ = note: references must be non-null
error: the type `Ref` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:52:25
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: References must be non-null (in this struct field)
+note: references must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:15:12
|
LL | struct Ref(&'static i32);
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: References must be non-null (in this struct field)
+note: references must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:15:12
|
LL | struct Ref(&'static i32);
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: Function pointers must be non-null
+ = note: function pointers must be non-null
error: the type `fn()` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:56:26
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: Function pointers must be non-null
+ = note: function pointers must be non-null
error: the type `Wrap<fn()>` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:58:32
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: Function pointers must be non-null (in this struct field)
+note: function pointers must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:18:18
|
LL | struct Wrap<T> { wrapped: T }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: Function pointers must be non-null (in this struct field)
+note: function pointers must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:18:18
|
LL | struct Wrap<T> { wrapped: T }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: Function pointers must be non-null (in this enum field)
+note: function pointers must be non-null (in this enum field)
--> $DIR/uninitialized-zeroed.rs:19:28
|
LL | enum WrapEnum<T> { Wrapped(T) }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: Function pointers must be non-null (in this enum field)
+note: function pointers must be non-null (in this enum field)
--> $DIR/uninitialized-zeroed.rs:19:28
|
LL | enum WrapEnum<T> { Wrapped(T) }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: References must be non-null (in this struct field)
+note: references must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:16:16
|
LL | struct RefPair((&'static i32, i32));
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: References must be non-null (in this struct field)
+note: references must be non-null (in this struct field)
--> $DIR/uninitialized-zeroed.rs:16:16
|
LL | struct RefPair((&'static i32, i32));
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: std::ptr::NonNull<i32> must be non-null
+ = note: `std::ptr::NonNull<i32>` must be non-null
error: the type `std::ptr::NonNull<i32>` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:68:34
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: std::ptr::NonNull<i32> must be non-null
+ = note: `std::ptr::NonNull<i32>` must be non-null
error: the type `*const dyn std::marker::Send` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:70:37
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: The vtable of a wide raw pointer must be non-null
+ = note: the vtable of a wide raw pointer must be non-null
error: the type `*const dyn std::marker::Send` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:71:37
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: The vtable of a wide raw pointer must be non-null
+ = note: the vtable of a wide raw pointer must be non-null
error: the type `bool` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:75:26
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: Booleans must be `true` or `false`
+ = note: booleans must be either `true` or `false`
error: the type `Wrap<char>` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:78:32
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
-note: Characters must be a valid unicode codepoint (in this struct field)
+note: characters must be a valid Unicode codepoint (in this struct field)
--> $DIR/uninitialized-zeroed.rs:18:18
|
LL | struct Wrap<T> { wrapped: T }
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: NonBig must be initialized inside its custom valid range
+ = note: `NonBig` must be initialized inside its custom valid range
error: the type `&'static i32` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:84:34
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: References must be non-null
+ = note: references must be non-null
error: the type `&'static [i32]` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:85:36
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: References must be non-null
+ = note: references must be non-null
error: the type `std::num::NonZeroU32` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:86:32
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: std::num::NonZeroU32 must be non-null
+ = note: `std::num::NonZeroU32` must be non-null
error: the type `std::ptr::NonNull<i32>` does not permit zero-initialization
--> $DIR/uninitialized-zeroed.rs:89:34
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: std::ptr::NonNull<i32> must be non-null
+ = note: `std::ptr::NonNull<i32>` must be non-null
error: the type `std::ptr::NonNull<i32>` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:90:34
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: std::ptr::NonNull<i32> must be non-null
+ = note: `std::ptr::NonNull<i32>` must be non-null
error: the type `bool` does not permit being left uninitialized
--> $DIR/uninitialized-zeroed.rs:91:26
| this code causes undefined behavior when executed
| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
|
- = note: Booleans must be `true` or `false`
+ = note: booleans must be either `true` or `false`
error: aborting due to 35 previous errors
LL | check!(0u8);
| ^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: unexpected token: `-0`
--> $DIR/malformed-interpolated.rs:5:25
-#[macro_use(foo, bar)] //~ ERROR arguments to macro_use are not allowed here
+#[macro_use(foo, bar)] //~ ERROR arguments to `macro_use` are not allowed here
mod foo {
}
-error: arguments to macro_use are not allowed here
+error: arguments to `macro_use` are not allowed here
--> $DIR/module-macro_use-arguments.rs:1:1
|
LL | #[macro_use(foo, bar)]
assert_eq!(it.next().map(|l| l.starts_with("thread '<unnamed>' panicked at")), Some(true));
assert_eq!(it.next(), Some("note: run with `RUST_BACKTRACE=1` \
- environment variable to display a backtrace."));
+ environment variable to display a backtrace"));
assert_eq!(it.next().map(|l| l.starts_with("thread 'main' panicked at")), Some(true));
assert_eq!(it.next(), None);
}
-note: No external requirements
+note: no external requirements
--> $DIR/escape-argument-callee.rs:26:38
|
LL | let mut closure = expect_sig(|p, y| *p = y);
| | has type `&'1 i32`
| has type `&'_#2r mut &'2 i32`
-note: No external requirements
+note: no external requirements
--> $DIR/escape-argument-callee.rs:20:1
|
LL | / fn test() {
-note: No external requirements
+note: no external requirements
--> $DIR/escape-argument.rs:26:38
|
LL | let mut closure = expect_sig(|p, y| *p = y);
for<'r, 's> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed('r)) mut &ReLateBound(DebruijnIndex(0), BrNamed('s)) i32, &ReLateBound(DebruijnIndex(0), BrNamed('s)) i32)),
]
-note: No external requirements
+note: no external requirements
--> $DIR/escape-argument.rs:20:1
|
LL | / fn test() {
-note: External requirements
+note: external requirements
--> $DIR/escape-upvar-nested.rs:21:32
|
LL | let mut closure1 = || p = &y;
= note: number of external vids: 4
= note: where '_#1r: '_#3r
-note: External requirements
+note: external requirements
--> $DIR/escape-upvar-nested.rs:20:27
|
LL | let mut closure = || {
= note: number of external vids: 4
= note: where '_#1r: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/escape-upvar-nested.rs:13:1
|
LL | / fn test() {
-note: External requirements
+note: external requirements
--> $DIR/escape-upvar-ref.rs:23:27
|
LL | let mut closure = || p = &y;
= note: number of external vids: 4
= note: where '_#1r: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/escape-upvar-ref.rs:17:1
|
LL | / fn test() {
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-fail-no-postdom.rs:43:9
|
LL | / |_outlives1, _outlives2, _outlives3, x, y| {
LL | demand_y(x, y, p)
| ^^^^^^^^^^^^^^^^^ argument requires that `'1` must outlive `'2`
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-fail-no-postdom.rs:38:1
|
LL | / fn supply<'a, 'b, 'c>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>, cell_c: Cell<&'c u32>) {
-note: External requirements
+note: external requirements
--> $DIR/propagate-approximated-ref.rs:43:47
|
LL | establish_relationships(&cell_a, &cell_b, |_outlives1, _outlives2, x, y| {
= note: number of external vids: 5
= note: where '_#1r: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-ref.rs:42:1
|
LL | / fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:21:15
|
LL | foo(cell, |cell_a, cell_x| {
LL | cell_a.set(cell_x.get()); // forces 'x: 'a, error in closure
| ^^^^^^^^^^^^^^^^^^^^^^^^ `cell_x` escapes the closure body here
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:18:1
|
LL | / fn case1() {
|
= note: defining type: case1
-note: External requirements
+note: external requirements
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:35:15
|
LL | foo(cell, |cell_a, cell_x| {
= note: number of external vids: 2
= note: where '_#1r: '_#0r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:28:1
|
LL | / fn case2() {
-note: External requirements
+note: external requirements
--> $DIR/propagate-approximated-shorter-to-static-no-bound.rs:32:47
|
LL | establish_relationships(&cell_a, &cell_b, |_outlives, x, y| {
= note: number of external vids: 4
= note: where '_#1r: '_#0r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-shorter-to-static-no-bound.rs:31:1
|
LL | / fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-note: External requirements
+note: external requirements
--> $DIR/propagate-approximated-shorter-to-static-wrong-bound.rs:35:47
|
LL | establish_relationships(&cell_a, &cell_b, |_outlives1, _outlives2, x, y| {
= note: number of external vids: 5
= note: where '_#1r: '_#0r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-shorter-to-static-wrong-bound.rs:34:1
|
LL | / fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-note: External requirements
+note: external requirements
--> $DIR/propagate-approximated-val.rs:36:45
|
LL | establish_relationships(cell_a, cell_b, |outlives1, outlives2, x, y| {
= note: number of external vids: 5
= note: where '_#1r: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-approximated-val.rs:35:1
|
LL | / fn test<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-note: External requirements
+note: external requirements
--> $DIR/propagate-despite-same-free-region.rs:42:9
|
LL | / |_outlives1, _outlives2, x, y| {
= note: number of external vids: 4
= note: where '_#1r: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-despite-same-free-region.rs:39:1
|
LL | / fn supply<'a>(cell_a: Cell<&'a u32>) {
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-fail-to-approximate-longer-no-bounds.rs:35:47
|
LL | establish_relationships(&cell_a, &cell_b, |_outlives, x, y| {
LL | demand_y(x, y, x.get())
| ^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'1` must outlive `'2`
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-fail-to-approximate-longer-no-bounds.rs:34:1
|
LL | / fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-fail-to-approximate-longer-wrong-bounds.rs:39:47
|
LL | establish_relationships(&cell_a, &cell_b, |_outlives1, _outlives2, x, y| {
LL | demand_y(x, y, x.get())
| ^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'1` must outlive `'2`
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-fail-to-approximate-longer-wrong-bounds.rs:38:1
|
LL | / fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-note: External requirements
+note: external requirements
--> $DIR/propagate-from-trait-match.rs:32:36
|
LL | establish_relationships(value, |value| {
= note: number of external vids: 2
= note: where T: '_#1r
-note: No external requirements
+note: no external requirements
--> $DIR/propagate-from-trait-match.rs:28:1
|
LL | / fn supply<'a, T>(value: T)
-note: No external requirements
+note: no external requirements
--> $DIR/return-wrong-bound-region.rs:11:16
|
LL | expect_sig(|a, b| b); // ought to return `a`
| | has type `&'1 i32`
| has type `&'2 i32`
-note: No external requirements
+note: no external requirements
--> $DIR/return-wrong-bound-region.rs:10:1
|
LL | / fn test() {
-note: External requirements
+note: external requirements
--> $DIR/projection-no-regions-closure.rs:25:23
|
LL | with_signature(x, |mut y| Box::new(y.next()))
= note: number of external vids: 3
= note: where <T as std::iter::Iterator>::Item: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-no-regions-closure.rs:21:1
|
LL | / fn no_region<'a, T>(x: Box<T>) -> Box<dyn Anything + 'a>
|
= help: consider adding an explicit lifetime bound `<T as std::iter::Iterator>::Item: ReEarlyBound(0, 'a)`...
-note: External requirements
+note: external requirements
--> $DIR/projection-no-regions-closure.rs:34:23
|
LL | with_signature(x, |mut y| Box::new(y.next()))
= note: number of external vids: 3
= note: where <T as std::iter::Iterator>::Item: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-no-regions-closure.rs:30:1
|
LL | / fn correct_region<'a, T>(x: Box<T>) -> Box<dyn Anything + 'a>
|
= note: defining type: correct_region::<'_#1r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-no-regions-closure.rs:42:23
|
LL | with_signature(x, |mut y| Box::new(y.next()))
= note: number of external vids: 4
= note: where <T as std::iter::Iterator>::Item: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-no-regions-closure.rs:38:1
|
LL | / fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<dyn Anything + 'a>
|
= help: consider adding an explicit lifetime bound `<T as std::iter::Iterator>::Item: ReEarlyBound(0, 'a)`...
-note: External requirements
+note: external requirements
--> $DIR/projection-no-regions-closure.rs:52:23
|
LL | with_signature(x, |mut y| Box::new(y.next()))
= note: number of external vids: 4
= note: where <T as std::iter::Iterator>::Item: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-no-regions-closure.rs:47:1
|
LL | / fn outlives_region<'a, 'b, T>(x: Box<T>) -> Box<dyn Anything + 'a>
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-closure.rs:45:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: where T: '_#2r
= note: where '_#1r: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-closure.rs:41:1
|
LL | / fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding the following bound: `'b: 'a`
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-closure.rs:56:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: where T: '_#3r
= note: where '_#2r: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-closure.rs:51:1
|
LL | / fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding the following bound: `'b: 'a`
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-closure.rs:70:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where <T as Anything<ReClosureBound('_#2r)>>::AssocType: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-closure.rs:62:1
|
LL | / fn projection_outlives<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: projection_outlives::<'_#1r, '_#2r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-closure.rs:80:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: where T: '_#3r
= note: where '_#2r: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-closure.rs:74:1
|
LL | / fn elements_outlive<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:37:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where '_#1r: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:33:1
|
LL | / fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding the following bound: `'b: 'a`
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:47:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where '_#2r: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:42:1
|
LL | / fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding the following bound: `'b: 'a`
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:60:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where <T as Anything<ReClosureBound('_#2r)>>::AssocType: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:52:1
|
LL | / fn projection_outlives<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: projection_outlives::<'_#1r, '_#2r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:69:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where '_#2r: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:64:1
|
LL | / fn elements_outlive<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: elements_outlive::<'_#1r, '_#2r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:81:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 3
= note: where '_#1r: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-closure.rs:73:1
|
LL | / fn one_region<'a, T>(cell: Cell<&'a ()>, t: T)
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:36:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
]
= note: late-bound region is '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:32:1
|
LL | / fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: no_relationships_late::<'_#1r, T>
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:45:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
extern "rust-call" fn((std::cell::Cell<&'_#3r ()>, T)),
]
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:40:1
|
LL | / fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: no_relationships_early::<'_#1r, '_#2r, T>
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:64:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
extern "rust-call" fn((std::cell::Cell<&'_#3r ()>, T)),
]
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:49:1
|
LL | / fn projection_outlives<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: projection_outlives::<'_#1r, '_#2r, T>
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:73:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
extern "rust-call" fn((std::cell::Cell<&'_#3r ()>, T)),
]
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:68:1
|
LL | / fn elements_outlive<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: elements_outlive::<'_#1r, '_#2r, T>
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:85:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
extern "rust-call" fn((std::cell::Cell<&'_#2r ()>, T)),
]
-note: No external requirements
+note: no external requirements
--> $DIR/projection-one-region-trait-bound-static-closure.rs:77:1
|
LL | / fn one_region<'a, T>(cell: Cell<&'a ()>, t: T)
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:38:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 5
= note: where <T as Anything<ReClosureBound('_#1r), ReClosureBound('_#2r)>>::AssocType: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:34:1
|
LL | / fn no_relationships_late<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding an explicit lifetime bound `<T as Anything<'_#5r, '_#6r>>::AssocType: ReFree(DefId(0:17 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]), BrNamed(DefId(0:18 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]::'a[0]), 'a))`...
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:48:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 5
= note: where <T as Anything<ReClosureBound('_#2r), ReClosureBound('_#3r)>>::AssocType: '_#4r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:43:1
|
LL | / fn no_relationships_early<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding an explicit lifetime bound `<T as Anything<'_#6r, '_#7r>>::AssocType: ReEarlyBound(0, 'a)`...
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:61:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 5
= note: where <T as Anything<ReClosureBound('_#2r), ReClosureBound('_#3r)>>::AssocType: '_#4r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:53:1
|
LL | / fn projection_outlives<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: projection_outlives::<'_#1r, '_#2r, '_#3r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:70:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 5
= note: where <T as Anything<ReClosureBound('_#2r), ReClosureBound('_#3r)>>::AssocType: '_#4r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:65:1
|
LL | / fn elements_outlive1<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: elements_outlive1::<'_#1r, '_#2r, '_#3r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:79:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 5
= note: where <T as Anything<ReClosureBound('_#2r), ReClosureBound('_#3r)>>::AssocType: '_#4r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:74:1
|
LL | / fn elements_outlive2<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: elements_outlive2::<'_#1r, '_#2r, '_#3r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:87:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where <T as Anything<ReClosureBound('_#1r), ReClosureBound('_#1r)>>::AssocType: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:83:1
|
LL | / fn two_regions<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= help: consider adding the following bound: `'b: 'a`
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:97:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 4
= note: where <T as Anything<ReClosureBound('_#2r), ReClosureBound('_#2r)>>::AssocType: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:92:1
|
LL | / fn two_regions_outlive<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
|
= note: defining type: two_regions_outlive::<'_#1r, '_#2r, T>
-note: External requirements
+note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:109:29
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
= note: number of external vids: 3
= note: where <T as Anything<ReClosureBound('_#1r), ReClosureBound('_#1r)>>::AssocType: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:101:1
|
LL | / fn one_region<'a, T>(cell: Cell<&'a ()>, t: T)
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-approximate-lower-bound.rs:24:24
|
LL | twice(cell, value, |a, b| invoke(a, b));
= note: number of external vids: 2
= note: where T: '_#1r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-approximate-lower-bound.rs:22:1
|
LL | / fn generic<T>(value: T) {
|
= note: defining type: generic::<T>
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-approximate-lower-bound.rs:29:24
|
LL | twice(cell, value, |a, b| invoke(a, b));
= note: number of external vids: 3
= note: where T: '_#1r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-approximate-lower-bound.rs:28:1
|
LL | / fn generic_fail<'a, T>(cell: Cell<&'a ()>, value: T) {
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-outlives-from-return-type.rs:26:23
|
LL | with_signature(x, |y| y)
= note: number of external vids: 3
= note: where T: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-outlives-from-return-type.rs:15:1
|
LL | / fn no_region<'a, T>(x: Box<T>) -> Box<dyn Debug + 'a>
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:27:26
|
LL | with_signature(a, b, |x, y| {
= note: number of external vids: 3
= note: where T: '_#1r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:26:1
|
LL | / fn no_region<'a, T>(a: Cell<&'a ()>, b: T) {
|
= help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:11 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]), BrNamed(DefId(0:12 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]::'a[0]), 'a))`...
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:43:26
|
LL | with_signature(a, b, |x, y| {
= note: number of external vids: 3
= note: where T: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:39:1
|
LL | / fn correct_region<'a, T>(a: Cell<&'a ()>, b: T)
|
= note: defining type: correct_region::<'_#1r, T>
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:64:26
|
LL | with_signature(a, b, |x, y| {
= note: number of external vids: 4
= note: where T: '_#2r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:60:1
|
LL | / fn wrong_region<'a, 'b, T>(a: Cell<&'a ()>, b: T)
|
= help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:19 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]), BrNamed(DefId(0:20 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]::'a[0]), 'a))`...
-note: External requirements
+note: external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:77:26
|
LL | with_signature(a, b, |x, y| {
= note: number of external vids: 4
= note: where T: '_#3r
-note: No external requirements
+note: no external requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:72:1
|
LL | / fn outlives_region<'a, 'b, T>(a: Cell<&'a ()>, b: T)
| |
| help: consider giving more type information
|
- = note: The type information given here is insufficient to check whether the pointer cast is valid
+ = note: the type information given here is insufficient to check whether the pointer cast is valid
error: aborting due to previous error
}
#[lang = "panic_impl"]
-fn panic2(info: &PanicInfo) -> ! { //~ ERROR duplicate lang item found: `panic_impl`.
+fn panic2(info: &PanicInfo) -> ! { //~ ERROR found duplicate lang item `panic_impl`
loop {}
}
-error[E0152]: duplicate lang item found: `panic_impl`.
+error[E0152]: found duplicate lang item `panic_impl`
--> $DIR/panic-handler-duplicate.rs:15:1
|
LL | / fn panic2(info: &PanicInfo) -> ! {
LL | | }
| |_^
|
-note: first defined here.
+note: first defined here
--> $DIR/panic-handler-duplicate.rs:10:1
|
LL | / fn panic(info: &PanicInfo) -> ! {
-// error-pattern: duplicate lang item found: `panic_impl`.
+// error-pattern: found duplicate lang item `panic_impl`
use std::panic::PanicInfo;
-error[E0152]: duplicate lang item found: `panic_impl`.
+error[E0152]: found duplicate lang item `panic_impl`
--> $DIR/panic-handler-std.rs:7:1
|
LL | / fn panic(info: PanicInfo) -> ! {
LL | | }
| |_^
|
- = note: first defined in crate `std` (which `panic_handler_std` depends on).
+ = note: first defined in crate `std` (which `panic_handler_std` depends on)
error: argument should be `&PanicInfo`
--> $DIR/panic-handler-std.rs:7:16
thread 'rustc' panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())', src/librustc_mir_build/hair/pattern/_match.rs:LL:CC
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: internal compiler error: unexpected panic
pub struct RawFloatState;
impl RawFloatState {
perftools_inline! {
- pub(super) fn new() {} //~ ERROR failed to resolve: there are too many initial `super`s
+ pub(super) fn new() {}
+ //~^ ERROR failed to resolve: there are too many leading `super` keywords
}
}
-error[E0433]: failed to resolve: there are too many initial `super`s.
+error[E0433]: failed to resolve: there are too many leading `super` keywords
--> $DIR/impl-items-vis-unresolved.rs:21:13
|
LL | pub(super) fn new() {}
- | ^^^^^ there are too many initial `super`s.
+ | ^^^^^ there are too many leading `super` keywords
error: aborting due to previous error
LL | #[rustc_dummy = 1usize]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:5:17
LL | #[rustc_dummy = 1u8]
| ^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:7:17
LL | #[rustc_dummy = 1u16]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:9:17
LL | #[rustc_dummy = 1u32]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:11:17
LL | #[rustc_dummy = 1u64]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:13:17
LL | #[rustc_dummy = 1isize]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:15:17
LL | #[rustc_dummy = 1i8]
| ^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:17:17
LL | #[rustc_dummy = 1i16]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:19:17
LL | #[rustc_dummy = 1i32]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:21:17
LL | #[rustc_dummy = 1i64]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:23:17
LL | #[rustc_dummy = 1.0f32]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:25:17
LL | #[rustc_dummy = 1.0f64]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:3:17
LL | #[rustc_dummy = 1usize]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:5:17
LL | #[rustc_dummy = 1u8]
| ^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:7:17
LL | #[rustc_dummy = 1u16]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:9:17
LL | #[rustc_dummy = 1u32]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:11:17
LL | #[rustc_dummy = 1u64]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:13:17
LL | #[rustc_dummy = 1isize]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:15:17
LL | #[rustc_dummy = 1i8]
| ^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:17:17
LL | #[rustc_dummy = 1i16]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:19:17
LL | #[rustc_dummy = 1i32]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:21:17
LL | #[rustc_dummy = 1i64]
| ^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:23:17
LL | #[rustc_dummy = 1.0f32]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: suffixed literals are not allowed in attributes
--> $DIR/suffixed-literal-meta.rs:25:17
LL | #[rustc_dummy = 1.0f64]
| ^^^^^^
|
- = help: instead of using a suffixed literal (1u8, 1.0f32, etc.), use an unsuffixed version (1, 1.0, etc.).
+ = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
error: aborting due to 24 previous errors
-use super::f; //~ ERROR there are too many initial `super`s
+use super::f; //~ ERROR there are too many leading `super` keywords
fn main() {
}
-error[E0433]: failed to resolve: there are too many initial `super`s.
+error[E0433]: failed to resolve: there are too many leading `super` keywords
--> $DIR/super-at-top-level.rs:1:5
|
LL | use super::f;
- | ^^^^^ there are too many initial `super`s.
+ | ^^^^^ there are too many leading `super` keywords
error: aborting due to previous error
LL | #[should_panic(expected)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: Errors in this attribute were erroneously allowed and will become a hard error in a future release.
+ = note: errors in this attribute were erroneously allowed and will become a hard error in a future release.
warning: argument must be of the form: `expected = "error message"`
--> $DIR/test-should-panic-attr.rs:18:1
LL | #[should_panic(expect)]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: Errors in this attribute were erroneously allowed and will become a hard error in a future release.
+ = note: errors in this attribute were erroneously allowed and will become a hard error in a future release.
warning: argument must be of the form: `expected = "error message"`
--> $DIR/test-should-panic-attr.rs:25:1
LL | #[should_panic(expected(foo, bar))]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: Errors in this attribute were erroneously allowed and will become a hard error in a future release.
+ = note: errors in this attribute were erroneously allowed and will become a hard error in a future release.
warning: argument must be of the form: `expected = "error message"`
--> $DIR/test-should-panic-attr.rs:32:1
LL | #[should_panic(expected = "foo", bar)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: Errors in this attribute were erroneously allowed and will become a hard error in a future release.
+ = note: errors in this attribute were erroneously allowed and will become a hard error in a future release.
thread 'main' panicked at 'assertion failed: `(left == right)`
left: `2`,
right: `5`', $DIR/test-panic-abort.rs:31:5
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
a::try_foo(foo);
//~^ ERROR E0277
//~| trait impl with same name found
- //~| Perhaps two different versions of crate `crate_a2`
+ //~| perhaps two different versions of crate `crate_a2`
// We don't want to see the "version mismatch" help message here
// because `implements_no_traits` has no impl for `Foo`
|
LL | impl Bar for Foo {}
| ^^^^^^^^^^^^^^^^^^^
- = note: Perhaps two different versions of crate `crate_a2` are being used?
+ = note: perhaps two different versions of crate `crate_a2` are being used?
error[E0277]: the trait bound `main::a::DoesNotImplementTrait: main::a::Bar` is not satisfied
--> $DIR/trait-bounds-same-crate-name.rs:38:20
|
LL | impl Bar for ImplementsWrongTraitConditionally<isize> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: Perhaps two different versions of crate `crate_a2` are being used?
+ = note: perhaps two different versions of crate `crate_a2` are being used?
error[E0277]: the trait bound `main::a::ImplementsTraitForUsize<isize>: main::a::Bar` is not satisfied
--> $DIR/trait-bounds-same-crate-name.rs:51:20
LL | mut_.call((0, ));
| ^^^^ method not found in `[closure@$DIR/unboxed-closures-static-call-wrong-trait.rs:6:26: 6:31]`
|
- = note: mut_ is a function, perhaps you wish to call it
+ = note: `mut_` is a function, perhaps you wish to call it
error: aborting due to previous error