diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index c27ab810a4c60..e2424e7d7ad90 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -1211,6 +1211,8 @@ impl Expr {
}
}
+ ExprKind::Underscore => TyKind::Infer,
+
// This expression doesn't look like a type syntactically.
_ => return None,
};
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 24108f779c818..dea2a0e2a4399 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -590,7 +590,7 @@ impl<'a> AstValidator<'a> {
)
.span_label(self.current_extern_span(), "in this `extern` block")
.note(&format!(
- "This limitation may be lifted in the future; see issue #{} <https://github.com/rust-lang/rust/issues/{}> for more information",
+ "this limitation may be lifted in the future; see issue #{} <https://github.com/rust-lang/rust/issues/{}> for more information",
n, n,
))
.emit();
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 43032ae81cbbd..e6260157d11a7 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -2,7 +2,7 @@
#![feature(bool_to_option)]
#![feature(box_patterns)]
-#![feature(const_panic)]
+#![cfg_attr(bootstrap, feature(const_panic))]
#![feature(crate_visibility_modifier)]
#![feature(format_args_capture)]
#![feature(in_band_lifetimes)]
diff --git a/compiler/rustc_builtin_macros/src/concat_idents.rs b/compiler/rustc_builtin_macros/src/concat_idents.rs
index 209158ce39206..53a456b69acfd 100644
--- a/compiler/rustc_builtin_macros/src/concat_idents.rs
+++ b/compiler/rustc_builtin_macros/src/concat_idents.rs
@@ -12,7 +12,7 @@ pub fn expand_concat_idents<'cx>(
tts: TokenStream,
) -> Box<dyn base::MacResult + 'cx> {
if tts.is_empty() {
- cx.span_err(sp, "concat_idents! takes 1 or more arguments.");
+ cx.span_err(sp, "concat_idents! takes 1 or more arguments");
return DummyResult::any(sp);
}
@@ -22,7 +22,7 @@ pub fn expand_concat_idents<'cx>(
match e {
TokenTree::Token(Token { kind: token::Comma, .. }) => {}
_ => {
- cx.span_err(sp, "concat_idents! expecting comma.");
+ cx.span_err(sp, "concat_idents! expecting comma");
return DummyResult::any(sp);
}
}
@@ -34,7 +34,7 @@ pub fn expand_concat_idents<'cx>(
}
}
- cx.span_err(sp, "concat_idents! requires ident args.");
+ cx.span_err(sp, "concat_idents! requires ident args");
return DummyResult::any(sp);
}
}
diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index 99544ddb66e66..bbca07085ea36 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -382,7 +382,7 @@ fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
.note(
"errors in this attribute were erroneously \
allowed and will become a hard error in a \
- future release.",
+ future release",
)
.emit();
ShouldPanic::Yes(None)
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index c5deb11edd094..b15efcd0dc2b1 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -416,6 +416,11 @@ pub fn llvm_global_features(sess: &Session) -> Vec<String> {
// -Ctarget-features
features.extend(sess.opts.cg.target_feature.split(',').flat_map(&filter));
+ // FIXME: Move outline-atomics to target definition when earliest supported LLVM is 12.
+ if get_version() >= (12, 0, 0) && sess.target.llvm_target.contains("aarch64-unknown-linux") {
+ features.push("+outline-atomics".to_string());
+ }
+
features
}
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
index 57d92005a5649..fd5cd269a3a9e 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -887,8 +887,6 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
// At this point, we are calling a function, `callee`, whose `DefId` is known...
if is_lang_panic_fn(tcx, callee) {
- self.check_op(ops::Panic);
-
// `begin_panic` and `panic_display` are generic functions that accept
// types other than str. Check to enforce that only str can be used in
// const-eval.
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
index 1d0ee949a221b..f08f51ec6279a 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -368,23 +368,6 @@ impl NonConstOp for MutDeref {
}
}
-#[derive(Debug)]
-pub struct Panic;
-impl NonConstOp for Panic {
- fn status_in_item(&self, _: &ConstCx<'_, '_>) -> Status {
- Status::Unstable(sym::const_panic)
- }
-
- fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
- feature_err(
- &ccx.tcx.sess.parse_sess,
- sym::const_panic,
- span,
- &format!("panicking in {}s is unstable", ccx.const_kind()),
- )
- }
-}
-
/// A call to a `panic()` lang item where the first argument is _not_ a `&str`.
#[derive(Debug)]
pub struct PanicNonStr;
@@ -407,7 +390,7 @@ impl NonConstOp for RawPtrComparison {
let mut err = ccx
.tcx
.sess
- .struct_span_err(span, "pointers cannot be reliably compared during const eval.");
+ .struct_span_err(span, "pointers cannot be reliably compared during const eval");
err.note(
"see issue #53020 <https://github.com/rust-lang/rust/issues/53020> \
for more information",
@@ -443,7 +426,7 @@ impl NonConstOp for RawPtrToIntCast {
let mut err = ccx
.tcx
.sess
- .struct_span_err(span, "pointers cannot be cast to integers during const eval.");
+ .struct_span_err(span, "pointers cannot be cast to integers during const eval");
err.note("at compile-time, pointers do not have an integer value");
err.note(
"avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior",
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index 370e8ffed728b..94e115ed49856 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -11,7 +11,7 @@
#![feature(associated_type_bounds)]
#![feature(auto_traits)]
#![feature(bool_to_option)]
-#![feature(const_panic)]
+#![cfg_attr(bootstrap, feature(const_panic))]
#![feature(control_flow_enum)]
#![feature(core_intrinsics)]
#![feature(extend_one)]
diff --git a/compiler/rustc_driver/src/pretty.rs b/compiler/rustc_driver/src/pretty.rs
index e52eef0fcbd72..8e8bea9525dc9 100644
--- a/compiler/rustc_driver/src/pretty.rs
+++ b/compiler/rustc_driver/src/pretty.rs
@@ -88,7 +88,7 @@ trait PrinterSupport: pprust::PpAnn {
/// Produces the pretty-print annotation object.
///
/// (Rust does not yet support upcasting from a trait object to
- /// an object for one of its super-traits.)
+ /// an object for one of its supertraits.)
fn pp_ann(&self) -> &dyn pprust::PpAnn;
}
@@ -104,7 +104,7 @@ trait HirPrinterSupport<'hir>: pprust_hir::PpAnn {
/// Produces the pretty-print annotation object.
///
/// (Rust does not yet support upcasting from a trait object to
- /// an object for one of its super-traits.)
+ /// an object for one of its supertraits.)
fn pp_ann(&self) -> &dyn pprust_hir::PpAnn;
}
diff --git a/compiler/rustc_error_codes/src/error_codes/E0222.md b/compiler/rustc_error_codes/src/error_codes/E0222.md
index fbf1b8d703314..f929f219af4aa 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0222.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0222.md
@@ -16,9 +16,9 @@ pub trait BoxCar : Box + Vehicle {}
fn dent_object<COLOR>(c: dyn BoxCar<Color=COLOR>) {} // Invalid constraint
```
-In this example, `BoxCar` has two super-traits: `Vehicle` and `Box`. Both of
+In this example, `BoxCar` has two supertraits: `Vehicle` and `Box`. Both of
these traits define an associated type `Color`. `BoxCar` inherits two types
-with that name from both super-traits. Because of this, we need to use the
+with that name from both supertraits. Because of this, we need to use the
fully qualified path syntax to refer to the appropriate `Color` associated
type, either `<BoxCar as Vehicle>::Color` or `<BoxCar as Box>::Color`, but this
syntax is not allowed to be used in a function signature.
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 69e0e3a013667..2ef0e0f6b1e56 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -297,6 +297,8 @@ declare_features! (
(accepted, arbitrary_enum_discriminant, "1.56.0", Some(60553), None),
/// Allows macro attributes to observe output of `#[derive]`.
(accepted, macro_attributes_in_derive_output, "1.57.0", Some(81119), None),
+ /// Allows panicking during const eval (producing compile-time errors).
+ (accepted, const_panic, "1.57.0", Some(51999), None),
// -------------------------------------------------------------------------
// feature-group-end: accepted features
diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs
index f8b865e615c2e..eae7f7854ecb1 100644
--- a/compiler/rustc_feature/src/active.rs
+++ b/compiler/rustc_feature/src/active.rs
@@ -425,9 +425,6 @@ declare_features! (
/// Allows using the `amdgpu-kernel` ABI.
(active, abi_amdgpu_kernel, "1.29.0", Some(51575), None),
- /// Allows panicking during const eval (producing compile-time errors).
- (active, const_panic, "1.30.0", Some(51999), None),
-
/// Allows `#[marker]` on certain traits allowing overlapping implementations.
(active, marker_trait_attr, "1.30.0", Some(29864), None),
diff --git a/compiler/rustc_index/src/vec.rs b/compiler/rustc_index/src/vec.rs
index 56ea04539e57f..8831524683432 100644
--- a/compiler/rustc_index/src/vec.rs
+++ b/compiler/rustc_index/src/vec.rs
@@ -124,7 +124,9 @@ macro_rules! newtype_index {
#[inline]
$v const fn from_usize(value: usize) -> Self {
- // FIXME: replace with `assert!(value <= ($max as usize));` once `const_panic` is stable
+ #[cfg(not(bootstrap))]
+ assert!(value <= ($max as usize));
+ #[cfg(bootstrap)]
[()][(value > ($max as usize)) as usize];
unsafe {
Self::from_u32_unchecked(value as u32)
@@ -133,7 +135,9 @@ macro_rules! newtype_index {
#[inline]
$v const fn from_u32(value: u32) -> Self {
- // FIXME: replace with `assert!(value <= $max);` once `const_panic` is stable
+ #[cfg(not(bootstrap))]
+ assert!(value <= $max);
+ #[cfg(bootstrap)]
[()][(value > $max) as usize];
unsafe {
Self::from_u32_unchecked(value)
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index a221746f975ed..2d12ea94a0bbf 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -437,12 +437,18 @@ pub fn configure_and_expand(
});
// Add all buffered lints from the `ParseSess` to the `Session`.
- sess.parse_sess.buffered_lints.with_lock(|buffered_lints| {
- info!("{} parse sess buffered_lints", buffered_lints.len());
- for early_lint in buffered_lints.drain(..) {
- resolver.lint_buffer().add_early_lint(early_lint);
- }
- });
+ // The ReplaceBodyWithLoop pass may have deleted some AST nodes, potentially
+ // causing a delay_span_bug later if a buffered lint refers to such a deleted
+ // AST node (issue #87308). Since everybody_loops is for pretty-printing only,
+ // anyway, we simply skip all buffered lints here.
+ if !matches!(sess.opts.pretty, Some(PpMode::Source(PpSourceMode::EveryBodyLoops))) {
+ sess.parse_sess.buffered_lints.with_lock(|buffered_lints| {
+ info!("{} parse sess buffered_lints", buffered_lints.len());
+ for early_lint in buffered_lints.drain(..) {
+ resolver.lint_buffer().add_early_lint(early_lint);
+ }
+ });
+ }
Ok(krate)
}
diff --git a/compiler/rustc_lint/src/array_into_iter.rs b/compiler/rustc_lint/src/array_into_iter.rs
index 1facd97375433..d147148ac7136 100644
--- a/compiler/rustc_lint/src/array_into_iter.rs
+++ b/compiler/rustc_lint/src/array_into_iter.rs
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for ArrayIntoIter {
let mut diag = lint.build(&format!(
"this method call resolves to `<&{} as IntoIterator>::into_iter` \
(due to backwards compatibility), \
- but will resolve to <{} as IntoIterator>::into_iter in Rust 2021.",
+ but will resolve to <{} as IntoIterator>::into_iter in Rust 2021",
target, target,
));
diag.span_suggestion(
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 9b6493222e675..5656fff2fcb72 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -918,7 +918,7 @@ impl EarlyLintPass for AnonymousParameters {
lint.build(
"anonymous parameters are deprecated and will be \
- removed in the next edition.",
+ removed in the next edition",
)
.span_suggestion(
arg.pat.span,
@@ -1629,9 +1629,9 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
let predicates = cx.tcx.predicates_of(item.def_id);
for &(predicate, span) in predicates.predicates {
let predicate_kind_name = match predicate.kind().skip_binder() {
- Trait(..) => "Trait",
+ Trait(..) => "trait",
TypeOutlives(..) |
- RegionOutlives(..) => "Lifetime",
+ RegionOutlives(..) => "lifetime",
// Ignore projections, as they can only be global
// if the trait bound is global
diff --git a/compiler/rustc_lint/src/non_ascii_idents.rs b/compiler/rustc_lint/src/non_ascii_idents.rs
index 301e607fc58ad..9b4ee148df48a 100644
--- a/compiler/rustc_lint/src/non_ascii_idents.rs
+++ b/compiler/rustc_lint/src/non_ascii_idents.rs
@@ -331,9 +331,9 @@ impl EarlyLintPass for NonAsciiIdents {
for ((sp, ch_list), script_set) in lint_reports {
cx.struct_span_lint(MIXED_SCRIPT_CONFUSABLES, sp, |lint| {
let message = format!(
- "The usage of Script Group `{}` in this crate consists solely of mixed script confusables",
+ "the usage of Script Group `{}` in this crate consists solely of mixed script confusables",
script_set);
- let mut note = "The usage includes ".to_string();
+ let mut note = "the usage includes ".to_string();
for (idx, ch) in ch_list.into_iter().enumerate() {
if idx != 0 {
note += ", ";
@@ -341,8 +341,7 @@ impl EarlyLintPass for NonAsciiIdents {
let char_info = format!("'{}' (U+{:04X})", ch, ch as u32);
note += &char_info;
}
- note += ".";
- lint.build(&message).note(¬e).note("Please recheck to make sure their usages are indeed what you want.").emit()
+ lint.build(&message).note(¬e).note("please recheck to make sure their usages are indeed what you want").emit()
});
}
}
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index 48d8cdf57dcfc..3a05020c0b55b 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -878,7 +878,7 @@ impl<'a> CrateLoader<'a> {
"no global memory allocator found but one is \
required; link to std or \
add `#[global_allocator]` to a static item \
- that implements the GlobalAlloc trait.",
+ that implements the GlobalAlloc trait",
);
}
self.cstore.allocator_kind = Some(AllocatorKind::Default);
diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs
index b6922e0d72a06..80963c9658e3d 100644
--- a/compiler/rustc_metadata/src/locator.rs
+++ b/compiler/rustc_metadata/src/locator.rs
@@ -1030,7 +1030,8 @@ impl CrateError {
add,
);
err.help(&format!(
- "please recompile that crate using this compiler ({})",
+ "please recompile that crate using this compiler ({}) \
+ (consider running `cargo clean` first)",
rustc_version(),
));
let mismatches = locator.crate_rejections.via_version.iter();
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 39709e1bd0716..93226b6a2f2d7 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -319,13 +319,13 @@ impl Collector<'tcx> {
self.tcx.sess.err(&format!(
"renaming of the library `{}` was specified, \
however this crate contains no `#[link(...)]` \
- attributes referencing this library.",
+ attributes referencing this library",
lib.name
));
} else if !renames.insert(&lib.name) {
self.tcx.sess.err(&format!(
"multiple renamings were \
- specified for library `{}` .",
+ specified for library `{}`",
lib.name
));
}
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index a2adecd96367e..01847d352c381 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2117,7 +2117,7 @@ impl<'tcx> TyCtxt<'tcx> {
})
}
- /// Computes the def-ids of the transitive super-traits of `trait_def_id`. This (intentionally)
+ /// Computes the def-ids of the transitive supertraits of `trait_def_id`. This (intentionally)
/// does not compute the full elaborated super-predicates but just the set of def-ids. It is used
/// to identify which traits may define a given associated type to help avoid cycle errors.
/// Returns a `DefId` iterator.
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 8991ad32ae882..8983fda6ced80 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -599,7 +599,7 @@ impl<'tcx> Predicate<'tcx> {
// where both `'x` and `'b` would have a DB index of 1.
// The substitution from the input trait-ref is therefore going to be
// `'a => 'x` (where `'x` has a DB index of 1).
- // - The super-trait-ref is `for<'b> Bar1<'a,'b>`, where `'a` is an
+ // - The supertrait-ref is `for<'b> Bar1<'a,'b>`, where `'a` is an
// early-bound parameter and `'b' is a late-bound parameter with a
// DB index of 1.
// - If we replace `'a` with `'x` from the input, it too will have
diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs
index 72c4e27cbeabf..402391b87eaa9 100644
--- a/compiler/rustc_mir_dataflow/src/lib.rs
+++ b/compiler/rustc_mir_dataflow/src/lib.rs
@@ -2,7 +2,7 @@
#![feature(bool_to_option)]
#![feature(box_patterns)]
#![feature(box_syntax)]
-#![feature(const_panic)]
+#![cfg_attr(bootstrap, feature(const_panic))]
#![feature(exact_size_is_empty)]
#![feature(in_band_lifetimes)]
#![feature(iter_zip)]
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index b1b31e0784cfe..0ca640cd7b173 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -1,7 +1,7 @@
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(crate_visibility_modifier)]
-#![feature(const_panic)]
+#![cfg_attr(bootstrap, feature(const_panic))]
#![feature(in_band_lifetimes)]
#![feature(iter_zip)]
#![feature(map_try_insert)]
diff --git a/compiler/rustc_passes/src/weak_lang_items.rs b/compiler/rustc_passes/src/weak_lang_items.rs
index bb5be90cd404b..c6c32e69aab77 100644
--- a/compiler/rustc_passes/src/weak_lang_items.rs
+++ b/compiler/rustc_passes/src/weak_lang_items.rs
@@ -66,8 +66,8 @@ fn verify<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) {
tcx.sess.err("`#[panic_handler]` function required, but not found");
} else if item == LangItem::Oom {
if !tcx.features().default_alloc_error_handler {
- tcx.sess.err("`#[alloc_error_handler]` function required, but not found.");
- tcx.sess.note_without_error("Use `#![feature(default_alloc_error_handler)]` for a default error handler.");
+ tcx.sess.err("`#[alloc_error_handler]` function required, but not found");
+ tcx.sess.note_without_error("Use `#![feature(default_alloc_error_handler)]` for a default error handler");
}
} else {
tcx.sess.err(&format!("language item required, but not found: `{}`", name));
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index bb34776f0b02d..9be568b2cf145 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -1339,7 +1339,7 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
};
if module.is_trait() {
- self.r.session.span_err(import.span, "items in traits are not importable.");
+ self.r.session.span_err(import.span, "items in traits are not importable");
return;
} else if ptr::eq(module, import.parent_scope.module) {
return;
diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs
index c47d8b934cf2a..f4567b334836a 100644
--- a/compiler/rustc_save_analysis/src/dump_visitor.rs
+++ b/compiler/rustc_save_analysis/src/dump_visitor.rs
@@ -682,7 +682,7 @@ impl<'tcx> DumpVisitor<'tcx> {
);
}
- // super-traits
+ // supertraits
for super_bound in trait_refs.iter() {
let (def_id, sub_span) = match *super_bound {
hir::GenericBound::Trait(ref trait_ref, _) => (
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index fbcc3bf2c4815..bf04154a3dafe 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -1384,7 +1384,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
// Cannot enable crt-static with sanitizers on Linux
if sess.crt_static(None) && !sess.opts.debugging_opts.sanitizer.is_empty() {
sess.err(
- "Sanitizer is incompatible with statically linked libc, \
+ "sanitizer is incompatible with statically linked libc, \
disable it using `-C target-feature=-crt-static`",
);
}
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
index 93ddec61dc4a1..6447e4cbf2bf6 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -516,7 +516,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
});
let unit_obligation = obligation.with(predicate.to_predicate(tcx));
if self.predicate_may_hold(&unit_obligation) {
- err.note("this trait is implemented for `()`.");
+ err.note("this trait is implemented for `()`");
err.note(
"this error might have been caused by changes to \
Rust's type-inference algorithm (see issue #48950 \
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
index b3c9cf4c173ec..be438f02a9710 100644
--- a/compiler/rustc_trait_selection/src/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -623,7 +623,7 @@ fn dump_vtable_entries<'tcx>(
trait_ref: ty::PolyTraitRef<'tcx>,
entries: &[VtblEntry<'tcx>],
) {
- let msg = format!("Vtable entries for `{}`: {:#?}", trait_ref, entries);
+ let msg = format!("vtable entries for `{}`: {:#?}", trait_ref, entries);
tcx.sess.struct_span_err(sp, &msg).emit();
}
diff --git a/compiler/rustc_typeck/src/astconv/errors.rs b/compiler/rustc_typeck/src/astconv/errors.rs
index 695132281c6ba..ec75e4a55d4e5 100644
--- a/compiler/rustc_typeck/src/astconv/errors.rs
+++ b/compiler/rustc_typeck/src/astconv/errors.rs
@@ -199,7 +199,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
/// When there are any missing associated types, emit an E0191 error and attempt to supply a
/// reasonable suggestion on how to write it. For the case of multiple associated types in the
- /// same trait bound have the same name (as they come from different super-traits), we instead
+ /// same trait bound have the same name (as they come from different supertraits), we instead
/// emit a generic note suggesting using a `where` clause to constraint instead.
pub(crate) fn complain_about_missing_associated_types(
&self,
@@ -340,7 +340,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
using the fully-qualified path to the associated types";
if !where_constraints.is_empty() && suggestions.is_empty() {
// If there are duplicates associated type names and a single trait bound do not
- // use structured suggestion, it means that there are multiple super-traits with
+ // use structured suggestion, it means that there are multiple supertraits with
// the same associated type name.
err.help(where_msg);
}
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
index e492fd44185ca..889b68773c27b 100644
--- a/compiler/rustc_typeck/src/astconv/mod.rs
+++ b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -1319,7 +1319,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
);
first_trait.label_with_exp_info(&mut err, "first non-auto trait", "first use");
err.help(&format!(
- "consider creating a new trait with all of these as super-traits and using that \
+ "consider creating a new trait with all of these as supertraits and using that \
trait here instead: `trait NewTrait: {} {{}}`",
regular_traits
.iter()
diff --git a/compiler/rustc_typeck/src/check/coercion.rs b/compiler/rustc_typeck/src/check/coercion.rs
index e34b8d998b1c9..07e542b70b90c 100644
--- a/compiler/rustc_typeck/src/check/coercion.rs
+++ b/compiler/rustc_typeck/src/check/coercion.rs
@@ -1484,21 +1484,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
fcx.emit_coerce_suggestions(&mut err, expr, found, expected, None);
}
- // Error possibly reported in `check_assign` so avoid emitting error again.
- let assign_to_bool = expression
- // #67273: Use initial expected type as opposed to `expected`.
- // Otherwise we end up using prior coercions in e.g. a `match` expression:
- // ```
- // match i {
- // 0 => true, // Because of this...
- // 1 => i = 1, // ...`expected == bool` now, but not when checking `i = 1`.
- // _ => (),
- // };
- // ```
- .filter(|e| fcx.is_assign_to_bool(e, self.expected_ty()))
- .is_some();
-
- err.emit_unless(assign_to_bool || unsized_return);
+ err.emit_unless(unsized_return);
self.final_ty = Some(fcx.tcx.ty_error());
}
diff --git a/compiler/rustc_typeck/src/check/demand.rs b/compiler/rustc_typeck/src/check/demand.rs
index dcfbaff7ec792..1a2931b9377ce 100644
--- a/compiler/rustc_typeck/src/check/demand.rs
+++ b/compiler/rustc_typeck/src/check/demand.rs
@@ -145,12 +145,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let expr_ty = self.resolve_vars_with_obligations(checked_ty);
let mut err = self.report_mismatched_types(&cause, expected, expr_ty, e);
- if self.is_assign_to_bool(expr, expected) {
- // Error reported in `check_assign` so avoid emitting error again.
- err.delay_as_bug();
- return (expected, None);
- }
-
self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr);
(expected, Some(err))
@@ -172,14 +166,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
- /// Returns whether the expected type is `bool` and the expression is `x = y`.
- pub fn is_assign_to_bool(&self, expr: &hir::Expr<'_>, expected: Ty<'tcx>) -> bool {
- if let hir::ExprKind::Assign(..) = expr.kind {
- return expected == self.tcx.types.bool;
- }
- false
- }
-
/// If the expected type is an enum (Issue #55250) with any variants whose
/// sole field is of the found type, suggest such variants. (Issue #42764)
fn suggest_compatible_variants(
diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
index 09a55937cc5ad..676e751376a6c 100644
--- a/compiler/rustc_typeck/src/check/expr.rs
+++ b/compiler/rustc_typeck/src/check/expr.rs
@@ -92,8 +92,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let expr = expr.peel_drop_temps();
self.suggest_deref_ref_or_into(&mut err, expr, expected_ty, ty, None);
extend_err(&mut err);
- // Error possibly reported in `check_assign` so avoid emitting error again.
- err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
+ err.emit();
}
ty
}
diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs
index 9d6db32be63a4..44d6f076f5da4 100644
--- a/compiler/rustc_typeck/src/check/method/probe.rs
+++ b/compiler/rustc_typeck/src/check/method/probe.rs
@@ -964,7 +964,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
let trait_ref = ty::TraitRef::new(trait_def_id, trait_substs);
if self.tcx.is_trait_alias(trait_def_id) {
- // For trait aliases, assume all super-traits are relevant.
+ // For trait aliases, assume all supertraits are relevant.
let bounds = iter::once(ty::Binder::dummy(trait_ref));
self.elaborate_bounds(bounds, |this, new_trait_ref, item| {
let new_trait_ref = this.erase_late_bound_regions(new_trait_ref);
diff --git a/library/alloc/benches/vec_deque.rs b/library/alloc/benches/vec_deque.rs
index bf2dffd1e931e..404cfa6addb73 100644
--- a/library/alloc/benches/vec_deque.rs
+++ b/library/alloc/benches/vec_deque.rs
@@ -52,3 +52,18 @@ fn bench_try_fold(b: &mut Bencher) {
b.iter(|| black_box(ring.iter().try_fold(0, |a, b| Some(a + b))))
}
+
+#[bench]
+fn bench_from_array_1000(b: &mut Bencher) {
+ const N: usize = 1000;
+ let mut array: [usize; N] = [0; N];
+
+ for i in 0..N {
+ array[i] = i;
+ }
+
+ b.iter(|| {
+ let deq: VecDeque<_> = array.into();
+ black_box(deq);
+ })
+}
diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index 11b0ca4b421a7..d6032372168f1 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -1968,6 +1968,7 @@ impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap<K, V> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<K: Hash, V: Hash> Hash for BTreeMap<K, V> {
fn hash<H: Hasher>(&self, state: &mut H) {
+ self.len().hash(state);
for elt in self {
elt.hash(state);
}
diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index 4a2b0b33bf2b2..007548ad1ab58 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -3004,6 +3004,16 @@ impl<T, const N: usize> From<[T; N]> for VecDeque<T> {
/// assert_eq!(deq1, deq2);
/// ```
fn from(arr: [T; N]) -> Self {
- core::array::IntoIter::new(arr).collect()
+ let mut deq = VecDeque::with_capacity(N);
+ let arr = ManuallyDrop::new(arr);
+ if mem::size_of::<T>() != 0 {
+ // SAFETY: VecDeque::with_capacity ensures that there is enough capacity.
+ unsafe {
+ ptr::copy_nonoverlapping(arr.as_ptr(), deq.ptr(), N);
+ }
+ }
+ deq.tail = 0;
+ deq.head = N;
+ deq
}
}
diff --git a/library/alloc/src/collections/vec_deque/tests.rs b/library/alloc/src/collections/vec_deque/tests.rs
index 56257e4346254..2be83f68f017f 100644
--- a/library/alloc/src/collections/vec_deque/tests.rs
+++ b/library/alloc/src/collections/vec_deque/tests.rs
@@ -507,6 +507,36 @@ fn test_from_vec_zst_overflow() {
assert_eq!(vd.len(), vec.len());
}
+#[test]
+fn test_from_array() {
+ fn test<const N: usize>() {
+ let mut array: [usize; N] = [0; N];
+
+ for i in 0..N {
+ array[i] = i;
+ }
+
+ let deq: VecDeque<_> = array.into();
+
+ for i in 0..N {
+ assert_eq!(deq[i], i);
+ }
+
+ assert!(deq.cap().is_power_of_two());
+ assert_eq!(deq.len(), N);
+ }
+ test::<0>();
+ test::<1>();
+ test::<2>();
+ test::<32>();
+ test::<35>();
+
+ let array = [(); MAXIMUM_ZST_CAPACITY - 1];
+ let deq = VecDeque::from(array);
+ assert!(deq.cap().is_power_of_two());
+ assert_eq!(deq.len(), MAXIMUM_ZST_CAPACITY - 1);
+}
+
#[test]
fn test_vec_from_vecdeque() {
use crate::vec::Vec;
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 2aed9d03bc09d..ca41ce975e4fe 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -111,6 +111,7 @@
// that the feature-gate isn't enabled. Ideally, it wouldn't check for the feature gate for docs
// from other crates, but since this can only appear for lang items, it doesn't seem worth fixing.
#![feature(intra_doc_pointers)]
+#![feature(iter_advance_by)]
#![feature(iter_zip)]
#![feature(lang_items)]
#![feature(layout_for_ptr)]
diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs
index 4cb0a4b10bd0c..8a2d254a83451 100644
--- a/library/alloc/src/vec/into_iter.rs
+++ b/library/alloc/src/vec/into_iter.rs
@@ -161,6 +161,29 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
(exact, Some(exact))
}
+ #[inline]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let step_size = self.len().min(n);
+ let to_drop = ptr::slice_from_raw_parts_mut(self.ptr as *mut T, step_size);
+ if mem::size_of::<T>() == 0 {
+ // SAFETY: due to unchecked casts of unsigned amounts to signed offsets the wraparound
+ // effectively results in unsigned pointers representing positions 0..usize::MAX,
+ // which is valid for ZSTs.
+ self.ptr = unsafe { arith_offset(self.ptr as *const i8, step_size as isize) as *mut T }
+ } else {
+ // SAFETY: the min() above ensures that step_size is in bounds
+ self.ptr = unsafe { self.ptr.add(step_size) };
+ }
+ // SAFETY: the min() above ensures that step_size is in bounds
+ unsafe {
+ ptr::drop_in_place(to_drop);
+ }
+ if step_size < n {
+ return Err(step_size);
+ }
+ Ok(())
+ }
+
#[inline]
fn count(self) -> usize {
self.len()
@@ -203,6 +226,29 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
Some(unsafe { ptr::read(self.end) })
}
}
+
+ #[inline]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ let step_size = self.len().min(n);
+ if mem::size_of::<T>() == 0 {
+ // SAFETY: same as for advance_by()
+ self.end = unsafe {
+ arith_offset(self.end as *const i8, step_size.wrapping_neg() as isize) as *mut T
+ }
+ } else {
+ // SAFETY: same as for advance_by()
+ self.end = unsafe { self.end.offset(step_size.wrapping_neg() as isize) };
+ }
+ let to_drop = ptr::slice_from_raw_parts_mut(self.end as *mut T, step_size);
+ // SAFETY: same as for advance_by()
+ unsafe {
+ ptr::drop_in_place(to_drop);
+ }
+ if step_size < n {
+ return Err(step_size);
+ }
+ Ok(())
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/alloc/tests/btree_set_hash.rs b/library/alloc/tests/btree_set_hash.rs
index e06a95ded94c7..ab275ac4353ac 100644
--- a/library/alloc/tests/btree_set_hash.rs
+++ b/library/alloc/tests/btree_set_hash.rs
@@ -1,9 +1,8 @@
+use crate::hash;
use std::collections::BTreeSet;
#[test]
fn test_hash() {
- use crate::hash;
-
let mut x = BTreeSet::new();
let mut y = BTreeSet::new();
@@ -17,3 +16,14 @@ fn test_hash() {
assert_eq!(hash(&x), hash(&y));
}
+
+#[test]
+fn test_prefix_free() {
+ let x = BTreeSet::from([1, 2, 3]);
+ let y = BTreeSet::<i32>::new();
+
+ // If hashed by iteration alone, `(x, y)` and `(y, x)` would visit the same
+ // order of elements, resulting in the same hash. But now that we also hash
+ // the length, they get distinct sequences of hashed data.
+ assert_ne!(hash(&(&x, &y)), hash(&(&y, &x)));
+}
diff --git a/library/alloc/tests/lib.rs b/library/alloc/tests/lib.rs
index cae4dae708e59..c6159539b48d0 100644
--- a/library/alloc/tests/lib.rs
+++ b/library/alloc/tests/lib.rs
@@ -18,6 +18,7 @@
#![feature(binary_heap_retain)]
#![feature(binary_heap_as_slice)]
#![feature(inplace_iteration)]
+#![feature(iter_advance_by)]
#![feature(slice_group_by)]
#![feature(slice_partition_dedup)]
#![feature(vec_spare_capacity)]
diff --git a/library/alloc/tests/vec.rs b/library/alloc/tests/vec.rs
index c2df50b48f55d..00a878c079480 100644
--- a/library/alloc/tests/vec.rs
+++ b/library/alloc/tests/vec.rs
@@ -970,6 +970,24 @@ fn test_into_iter_leak() {
assert_eq!(unsafe { DROPS }, 3);
}
+#[test]
+fn test_into_iter_advance_by() {
+ let mut i = vec![1, 2, 3, 4, 5].into_iter();
+ i.advance_by(0).unwrap();
+ i.advance_back_by(0).unwrap();
+ assert_eq!(i.as_slice(), [1, 2, 3, 4, 5]);
+
+ i.advance_by(1).unwrap();
+ i.advance_back_by(1).unwrap();
+ assert_eq!(i.as_slice(), [2, 3, 4]);
+
+ assert_eq!(i.advance_back_by(usize::MAX), Err(3));
+
+ assert_eq!(i.advance_by(usize::MAX), Err(0));
+
+ assert_eq!(i.len(), 0);
+}
+
#[test]
fn test_from_iter_specialization() {
let src: Vec<usize> = vec![0usize; 1];
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index c0121eebb7fef..025ad54b539f5 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -1305,7 +1305,7 @@ impl Clone for BorrowRef<'_> {
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(
not(bootstrap),
- must_not_suspend = "Holding a Ref across suspend \
+ must_not_suspend = "holding a Ref across suspend \
points can cause BorrowErrors"
)]
pub struct Ref<'b, T: ?Sized + 'b> {
@@ -1686,7 +1686,7 @@ impl<'b> BorrowRefMut<'b> {
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(
not(bootstrap),
- must_not_suspend = "Holding a RefMut across suspend \
+ must_not_suspend = "holding a RefMut across suspend \
points can cause BorrowErrors"
)]
pub struct RefMut<'b, T: ?Sized + 'b> {
diff --git a/library/core/src/iter/adapters/copied.rs b/library/core/src/iter/adapters/copied.rs
index 3d3c8da678b8b..e5f2886dcafad 100644
--- a/library/core/src/iter/adapters/copied.rs
+++ b/library/core/src/iter/adapters/copied.rs
@@ -76,6 +76,11 @@ where
self.it.count()
}
+ #[inline]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ self.it.advance_by(n)
+ }
+
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T
where
@@ -112,6 +117,11 @@ where
{
self.it.rfold(init, copy_fold(f))
}
+
+ #[inline]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ self.it.advance_back_by(n)
+ }
}
#[stable(feature = "iter_copied", since = "1.36.0")]
diff --git a/library/core/src/iter/adapters/cycle.rs b/library/core/src/iter/adapters/cycle.rs
index 815e708f9ec0f..02b5939072ef0 100644
--- a/library/core/src/iter/adapters/cycle.rs
+++ b/library/core/src/iter/adapters/cycle.rs
@@ -79,6 +79,27 @@ where
}
}
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let mut rem = n;
+ match self.iter.advance_by(rem) {
+ ret @ Ok(_) => return ret,
+ Err(advanced) => rem -= advanced,
+ }
+
+ while rem > 0 {
+ self.iter = self.orig.clone();
+ match self.iter.advance_by(rem) {
+ ret @ Ok(_) => return ret,
+ Err(0) => return Err(n - rem),
+ Err(advanced) => rem -= advanced,
+ }
+ }
+
+ Ok(())
+ }
+
// No `fold` override, because `fold` doesn't make much sense for `Cycle`,
// and we can't do anything better than the default.
}
diff --git a/library/core/src/iter/adapters/enumerate.rs b/library/core/src/iter/adapters/enumerate.rs
index 3478a0cd40832..c877b45095ace 100644
--- a/library/core/src/iter/adapters/enumerate.rs
+++ b/library/core/src/iter/adapters/enumerate.rs
@@ -112,6 +112,21 @@ where
self.iter.fold(init, enumerate(self.count, fold))
}
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ match self.iter.advance_by(n) {
+ ret @ Ok(_) => {
+ self.count += n;
+ ret
+ }
+ ret @ Err(advanced) => {
+ self.count += advanced;
+ ret
+ }
+ }
+ }
+
#[rustc_inherit_overflow_checks]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item
@@ -191,6 +206,13 @@ where
let count = self.count + self.iter.len();
self.iter.rfold(init, enumerate(count, fold))
}
+
+ #[inline]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ // we do not need to update the count since that only tallies the number of items
+ // consumed from the front. consuming items from the back can never reduce that.
+ self.iter.advance_back_by(n)
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/iter/adapters/flatten.rs b/library/core/src/iter/adapters/flatten.rs
index 48880a4d91a57..351fd569d8acf 100644
--- a/library/core/src/iter/adapters/flatten.rs
+++ b/library/core/src/iter/adapters/flatten.rs
@@ -391,6 +391,41 @@ where
init
}
+
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let mut rem = n;
+ loop {
+ if let Some(ref mut front) = self.frontiter {
+ match front.advance_by(rem) {
+ ret @ Ok(_) => return ret,
+ Err(advanced) => rem -= advanced,
+ }
+ }
+ self.frontiter = match self.iter.next() {
+ Some(iterable) => Some(iterable.into_iter()),
+ _ => break,
+ }
+ }
+
+ self.frontiter = None;
+
+ if let Some(ref mut back) = self.backiter {
+ match back.advance_by(rem) {
+ ret @ Ok(_) => return ret,
+ Err(advanced) => rem -= advanced,
+ }
+ }
+
+ if rem > 0 {
+ return Err(n - rem);
+ }
+
+ self.backiter = None;
+
+ Ok(())
+ }
}
impl<I, U> DoubleEndedIterator for FlattenCompat<I, U>
@@ -486,6 +521,41 @@ where
init
}
+
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ let mut rem = n;
+ loop {
+ if let Some(ref mut back) = self.backiter {
+ match back.advance_back_by(rem) {
+ ret @ Ok(_) => return ret,
+ Err(advanced) => rem -= advanced,
+ }
+ }
+ match self.iter.next_back() {
+ Some(iterable) => self.backiter = Some(iterable.into_iter()),
+ _ => break,
+ }
+ }
+
+ self.backiter = None;
+
+ if let Some(ref mut front) = self.frontiter {
+ match front.advance_back_by(rem) {
+ ret @ Ok(_) => return ret,
+ Err(advanced) => rem -= advanced,
+ }
+ }
+
+ if rem > 0 {
+ return Err(n - rem);
+ }
+
+ self.frontiter = None;
+
+ Ok(())
+ }
}
trait ConstSizeIntoIterator: IntoIterator {
diff --git a/library/core/src/iter/adapters/skip.rs b/library/core/src/iter/adapters/skip.rs
index c358a6d12b7bc..9b89ca5a9479d 100644
--- a/library/core/src/iter/adapters/skip.rs
+++ b/library/core/src/iter/adapters/skip.rs
@@ -114,6 +114,38 @@ where
}
self.iter.fold(init, fold)
}
+
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let mut rem = n;
+
+ let step_one = self.n.saturating_add(rem);
+ match self.iter.advance_by(step_one) {
+ Ok(_) => {
+ rem -= step_one - self.n;
+ self.n = 0;
+ }
+ Err(advanced) => {
+ let advanced_without_skip = advanced.saturating_sub(self.n);
+ self.n = self.n.saturating_sub(advanced);
+ return Err(advanced_without_skip);
+ }
+ }
+
+ // step_one calculation may have saturated
+ if unlikely(rem > 0) {
+ return match self.iter.advance_by(rem) {
+ ret @ Ok(_) => ret,
+ Err(advanced) => {
+ rem -= advanced;
+ Err(n - rem)
+ }
+ };
+ }
+
+ Ok(())
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
@@ -174,6 +206,16 @@ where
self.try_rfold(init, ok(fold)).unwrap()
}
+
+ #[inline]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ let min = crate::cmp::min(self.len(), n);
+ return match self.iter.advance_back_by(min) {
+ ret @ Ok(_) if n <= min => ret,
+ Ok(_) => Err(min),
+ _ => panic!("ExactSizeIterator contract violation"),
+ };
+ }
}
#[stable(feature = "fused", since = "1.26.0")]
diff --git a/library/core/src/iter/adapters/take.rs b/library/core/src/iter/adapters/take.rs
index beda8c32c6bdc..d0d0128c82b84 100644
--- a/library/core/src/iter/adapters/take.rs
+++ b/library/core/src/iter/adapters/take.rs
@@ -111,6 +111,22 @@ where
self.try_fold(init, ok(fold)).unwrap()
}
+
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let min = self.n.min(n);
+ match self.iter.advance_by(min) {
+ Ok(_) => {
+ self.n -= min;
+ if min < n { Err(min) } else { Ok(()) }
+ }
+ ret @ Err(advanced) => {
+ self.n -= advanced;
+ ret
+ }
+ }
+ }
}
#[unstable(issue = "none", feature = "inplace_iteration")]
@@ -197,6 +213,24 @@ where
}
}
}
+
+ #[inline]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ let inner_len = self.iter.len();
+ let len = self.n;
+ let remainder = len.saturating_sub(n);
+ let to_advance = inner_len - remainder;
+ match self.iter.advance_back_by(to_advance) {
+ Ok(_) => {
+ self.n = remainder;
+ if n > len {
+ return Err(len);
+ }
+ return Ok(());
+ }
+ _ => panic!("ExactSizeIterator contract violation"),
+ }
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/iter/range.rs b/library/core/src/iter/range.rs
index 0f835689699fc..06733a1b50b91 100644
--- a/library/core/src/iter/range.rs
+++ b/library/core/src/iter/range.rs
@@ -521,10 +521,12 @@ trait RangeIteratorImpl {
// Iterator
fn spec_next(&mut self) -> Option<Self::Item>;
fn spec_nth(&mut self, n: usize) -> Option<Self::Item>;
+ fn spec_advance_by(&mut self, n: usize) -> Result<(), usize>;
// DoubleEndedIterator
fn spec_next_back(&mut self) -> Option<Self::Item>;
fn spec_nth_back(&mut self, n: usize) -> Option<Self::Item>;
+ fn spec_advance_back_by(&mut self, n: usize) -> Result<(), usize>;
}
impl<A: Step> RangeIteratorImpl for ops::Range<A> {
@@ -555,6 +557,22 @@ impl<A: Step> RangeIteratorImpl for ops::Range<A> {
None
}
+ #[inline]
+ default fn spec_advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let available = if self.start <= self.end {
+ Step::steps_between(&self.start, &self.end).unwrap_or(usize::MAX)
+ } else {
+ 0
+ };
+
+ let taken = available.min(n);
+
+ self.start =
+ Step::forward_checked(self.start.clone(), taken).expect("`Step` invariants not upheld");
+
+ if taken < n { Err(taken) } else { Ok(()) }
+ }
+
#[inline]
default fn spec_next_back(&mut self) -> Option<A> {
if self.start < self.end {
@@ -579,6 +597,22 @@ impl<A: Step> RangeIteratorImpl for ops::Range<A> {
self.end = self.start.clone();
None
}
+
+ #[inline]
+ default fn spec_advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ let available = if self.start <= self.end {
+ Step::steps_between(&self.start, &self.end).unwrap_or(usize::MAX)
+ } else {
+ 0
+ };
+
+ let taken = available.min(n);
+
+ self.end =
+ Step::backward_checked(self.end.clone(), taken).expect("`Step` invariants not upheld");
+
+ if taken < n { Err(taken) } else { Ok(()) }
+ }
}
impl<T: TrustedStep> RangeIteratorImpl for ops::Range<T> {
@@ -607,6 +641,25 @@ impl<T: TrustedStep> RangeIteratorImpl for ops::Range<T> {
None
}
+ #[inline]
+ fn spec_advance_by(&mut self, n: usize) -> Result<(), usize> {
+ let available = if self.start <= self.end {
+ Step::steps_between(&self.start, &self.end).unwrap_or(usize::MAX)
+ } else {
+ 0
+ };
+
+ let taken = available.min(n);
+
+ // SAFETY: the conditions above ensure that the count is in bounds. If start <= end
+ // then steps_between either returns a bound to which we clamp or returns None which
+ // together with the initial inequality implies more than usize::MAX steps.
+ // Otherwise 0 is returned which always safe to use.
+ self.start = unsafe { Step::forward_unchecked(self.start.clone(), taken) };
+
+ if taken < n { Err(taken) } else { Ok(()) }
+ }
+
#[inline]
fn spec_next_back(&mut self) -> Option<T> {
if self.start < self.end {
@@ -631,6 +684,22 @@ impl<T: TrustedStep> RangeIteratorImpl for ops::Range<T> {
self.end = self.start.clone();
None
}
+
+ #[inline]
+ fn spec_advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ let available = if self.start <= self.end {
+ Step::steps_between(&self.start, &self.end).unwrap_or(usize::MAX)
+ } else {
+ 0
+ };
+
+ let taken = available.min(n);
+
+ // SAFETY: same as the spec_advance_by() implementation
+ self.end = unsafe { Step::backward_unchecked(self.end.clone(), taken) };
+
+ if taken < n { Err(taken) } else { Ok(()) }
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
@@ -677,6 +746,11 @@ impl<A: Step> Iterator for ops::Range<A> {
true
}
+ #[inline]
+ fn advance_by(&mut self, n: usize) -> Result<(), usize> {
+ self.spec_advance_by(n)
+ }
+
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
@@ -750,6 +824,11 @@ impl<A: Step> DoubleEndedIterator for ops::Range<A> {
fn nth_back(&mut self, n: usize) -> Option<A> {
self.spec_nth_back(n)
}
+
+ #[inline]
+ fn advance_back_by(&mut self, n: usize) -> Result<(), usize> {
+ self.spec_advance_back_by(n)
+ }
}
// Safety:
diff --git a/library/core/src/iter/traits/double_ended.rs b/library/core/src/iter/traits/double_ended.rs
index 9a9cf20077096..9a589c1f3b55c 100644
--- a/library/core/src/iter/traits/double_ended.rs
+++ b/library/core/src/iter/traits/double_ended.rs
@@ -103,9 +103,15 @@ pub trait DoubleEndedIterator: Iterator {
/// elements the iterator is advanced by before running out of elements (i.e. the length
/// of the iterator). Note that `k` is always less than `n`.
///
- /// Calling `advance_back_by(0)` does not consume any elements and always returns [`Ok(())`].
+ /// Calling `advance_back_by(0)` can do meaningful work, for example [`Flatten`] can advance its
+ /// outer iterator until it finds an inner iterator that is not empty, which then often
+ /// allows it to return a more accurate `size_hint()` than in its initial state.
+ /// `advance_back_by(0)` may either return `Ok()` or `Err(0)`. The former conveys no information
+ /// whether the iterator is or is not exhausted, the latter can be treated as if [`next_back`]
+ /// had returned `None`. Replacing a `Err(0)` with `Ok` is only correct for `n = 0`.
///
/// [`advance_by`]: Iterator::advance_by
+ /// [`Flatten`]: crate::iter::Flatten
/// [`next_back`]: DoubleEndedIterator::next_back
///
/// # Examples
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index f2336fb2865b0..e6b6aec7d9431 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -246,8 +246,14 @@ pub trait Iterator {
/// of elements the iterator is advanced by before running out of elements (i.e. the
/// length of the iterator). Note that `k` is always less than `n`.
///
- /// Calling `advance_by(0)` does not consume any elements and always returns [`Ok(())`][Ok].
- ///
+ /// Calling `advance_by(0)` can do meaningful work, for example [`Flatten`]
+ /// can advance its outer iterator until it finds an inner iterator that is not empty, which
+ /// then often allows it to return a more accurate `size_hint()` than in its initial state.
+ /// `advance_by(0)` may either return `Ok()` or `Err(0)`. The former conveys no information
+ /// whether the iterator is or is not exhausted, the latter can be treated as if [`next`]
+ /// had returned `None`. Replacing a `Err(0)` with `Ok` is only correct for `n = 0`.
+ ///
+ /// [`Flatten`]: crate::iter::Flatten
/// [`next`]: Iterator::next
///
/// # Examples
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 45ef1fcde2a55..4742970f9542b 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -124,7 +124,7 @@
#![feature(const_fn_trait_bound)]
#![feature(const_impl_trait)]
#![feature(const_mut_refs)]
-#![feature(const_panic)]
+#![cfg_attr(bootstrap, feature(const_panic))]
#![feature(const_precise_live_drops)]
#![feature(const_raw_ptr_deref)]
#![feature(const_refs_to_cell)]
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index a34964b531dfc..c9c2d2e645ace 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -329,8 +329,8 @@
//! [`Ok`], or returns the provided default value if the [`Result`] is
//! [`Err`]
//! * [`map_or_else`] applies the provided function to the contained value
-//! of [`Ok`], or applies the provided fallback function to the contained
-//! value of [`Err`]
+//! of [`Ok`], or applies the provided default fallback function to the
+//! contained value of [`Err`]
//!
//! [`map_or`]: Result::map_or
//! [`map_or_else`]: Result::map_or_else
@@ -795,8 +795,8 @@ impl<T, E> Result<T, E> {
}
}
- /// Maps a `Result<T, E>` to `U` by applying a fallback function to a
- /// contained [`Err`] value, or a default function to a
+ /// Maps a `Result<T, E>` to `U` by applying a provided default fallback
+ /// function to a contained [`Err`] value, or a provided function to a
/// contained [`Ok`] value.
///
/// This function can be used to unpack a successful result
diff --git a/library/core/tests/iter/adapters/flatten.rs b/library/core/tests/iter/adapters/flatten.rs
index aaac39c297933..4ae50a2f06681 100644
--- a/library/core/tests/iter/adapters/flatten.rs
+++ b/library/core/tests/iter/adapters/flatten.rs
@@ -58,6 +58,23 @@ fn test_flatten_try_folds() {
assert_eq!(iter.next_back(), Some(35));
}
+#[test]
+fn test_flatten_advance_by() {
+ let mut it = once(0..10).chain(once(10..30)).chain(once(30..40)).flatten();
+ it.advance_by(5).unwrap();
+ assert_eq!(it.next(), Some(5));
+ it.advance_by(9).unwrap();
+ assert_eq!(it.next(), Some(15));
+ it.advance_back_by(4).unwrap();
+ assert_eq!(it.next_back(), Some(35));
+ it.advance_back_by(9).unwrap();
+ assert_eq!(it.next_back(), Some(25));
+
+ assert_eq!(it.advance_by(usize::MAX), Err(9));
+ assert_eq!(it.advance_back_by(usize::MAX), Err(0));
+ assert_eq!(it.size_hint(), (0, Some(0)));
+}
+
#[test]
fn test_flatten_non_fused_outer() {
let mut iter = NonFused::new(once(0..2)).flatten();
diff --git a/library/core/tests/iter/range.rs b/library/core/tests/iter/range.rs
index 44adc3c58d249..6b4cf33efe1ff 100644
--- a/library/core/tests/iter/range.rs
+++ b/library/core/tests/iter/range.rs
@@ -285,6 +285,29 @@ fn test_range_step() {
assert_eq!((isize::MIN..isize::MAX).step_by(1).size_hint(), (usize::MAX, Some(usize::MAX)));
}
+#[test]
+fn test_range_advance_by() {
+ let mut r = 0..usize::MAX;
+ r.advance_by(0).unwrap();
+ r.advance_back_by(0).unwrap();
+
+ assert_eq!(r.len(), usize::MAX);
+
+ r.advance_by(1).unwrap();
+ r.advance_back_by(1).unwrap();
+
+ assert_eq!((r.start, r.end), (1, usize::MAX - 1));
+
+ assert_eq!(r.advance_by(usize::MAX), Err(usize::MAX - 2));
+
+ let mut r = 0u128..u128::MAX;
+
+ r.advance_by(usize::MAX).unwrap();
+ r.advance_back_by(usize::MAX).unwrap();
+
+ assert_eq!((r.start, r.end), (0u128 + usize::MAX as u128, u128::MAX - usize::MAX as u128));
+}
+
#[test]
fn test_range_inclusive_step() {
assert_eq!((0..=50).step_by(10).collect::<Vec<_>>(), [0, 10, 20, 30, 40, 50]);
diff --git a/library/std/src/sync/mutex.rs b/library/std/src/sync/mutex.rs
index 0d844547376b2..57f1dcca30e0a 100644
--- a/library/std/src/sync/mutex.rs
+++ b/library/std/src/sync/mutex.rs
@@ -190,7 +190,7 @@ unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}
#[must_use = "if unused the Mutex will immediately unlock"]
#[cfg_attr(
not(bootstrap),
- must_not_suspend = "Holding a MutexGuard across suspend \
+ must_not_suspend = "holding a MutexGuard across suspend \
points can cause deadlocks, delays, \
and cause Futures to not implement `Send`"
)]
diff --git a/library/std/src/sync/rwlock.rs b/library/std/src/sync/rwlock.rs
index aa1ce82d96799..2f4395ceefd13 100644
--- a/library/std/src/sync/rwlock.rs
+++ b/library/std/src/sync/rwlock.rs
@@ -97,7 +97,7 @@ unsafe impl<T: ?Sized + Send + Sync> Sync for RwLock<T> {}
#[must_use = "if unused the RwLock will immediately unlock"]
#[cfg_attr(
not(bootstrap),
- must_not_suspend = "Holding a RwLockReadGuard across suspend \
+ must_not_suspend = "holding a RwLockReadGuard across suspend \
points can cause deadlocks, delays, \
and cause Futures to not implement `Send`"
)]
@@ -123,7 +123,7 @@ unsafe impl<T: ?Sized + Sync> Sync for RwLockReadGuard<'_, T> {}
#[must_use = "if unused the RwLock will immediately unlock"]
#[cfg_attr(
not(bootstrap),
- must_not_suspend = "Holding a RwLockWriteGuard across suspend \
+ must_not_suspend = "holding a RwLockWriteGuard across suspend \
points can cause deadlocks, delays, \
and cause Future's to not implement `Send`"
)]
diff --git a/src/librustdoc/passes/html_tags.rs b/src/librustdoc/passes/html_tags.rs
index a0144a5298eba..a3fde92d7655d 100644
--- a/src/librustdoc/passes/html_tags.rs
+++ b/src/librustdoc/passes/html_tags.rs
@@ -52,7 +52,7 @@ fn drop_tag(
continue;
}
let last_tag_name_low = last_tag_name.to_lowercase();
- if ALLOWED_UNCLOSED.iter().any(|&at| at == last_tag_name_low) {
+ if ALLOWED_UNCLOSED.contains(&last_tag_name_low.as_str()) {
continue;
}
// `tags` is used as a queue, meaning that everything after `pos` is included inside it.
@@ -207,7 +207,7 @@ impl<'a, 'tcx> DocFolder for InvalidHtmlTagsLinter<'a, 'tcx> {
for (tag, range) in tags.iter().filter(|(t, _)| {
let t = t.to_lowercase();
- ALLOWED_UNCLOSED.iter().find(|&&at| at == t).is_none()
+ !ALLOWED_UNCLOSED.contains(&t.as_str())
}) {
report_diag(&format!("unclosed HTML tag `{}`", tag), range);
}
diff --git a/src/test/assembly/asm/aarch64-outline-atomics.rs b/src/test/assembly/asm/aarch64-outline-atomics.rs
new file mode 100644
index 0000000000000..93dda712e1b9b
--- /dev/null
+++ b/src/test/assembly/asm/aarch64-outline-atomics.rs
@@ -0,0 +1,16 @@
+// min-llvm-version: 12.0
+// assembly-output: emit-asm
+// compile-flags: -O
+// compile-flags: --target aarch64-unknown-linux-gnu
+// needs-llvm-components: aarch64
+// only-aarch64
+
+#![crate_type = "rlib"]
+
+use std::sync::atomic::{AtomicI32, Ordering::*};
+
+pub fn compare_exchange(a: &AtomicI32) {
+ // On AArch64 LLVM should outline atomic operations.
+ // CHECK: __aarch64_cas4_relax
+ let _ = a.compare_exchange(0, 10, Relaxed, Relaxed);
+}
diff --git a/src/test/mir-opt/remove-never-const.rs b/src/test/mir-opt/remove-never-const.rs
index 1673f14b45ce4..017746647ab0d 100644
--- a/src/test/mir-opt/remove-never-const.rs
+++ b/src/test/mir-opt/remove-never-const.rs
@@ -5,7 +5,6 @@
// Force generation of optimized mir for functions that do not reach codegen.
// compile-flags: --emit mir,link
-#![feature(const_panic)]
#![feature(never_type)]
#![warn(const_err)]
diff --git a/src/test/mir-opt/remove_never_const.no_codegen.PreCodegen.after.mir b/src/test/mir-opt/remove_never_const.no_codegen.PreCodegen.after.mir
index 6f4a024d20f93..bf62c8441fd11 100644
--- a/src/test/mir-opt/remove_never_const.no_codegen.PreCodegen.after.mir
+++ b/src/test/mir-opt/remove_never_const.no_codegen.PreCodegen.after.mir
@@ -1,11 +1,11 @@
// MIR for `no_codegen` after PreCodegen
fn no_codegen() -> () {
- let mut _0: (); // return place in scope 0 at $DIR/remove-never-const.rs:19:20: 19:20
+ let mut _0: (); // return place in scope 0 at $DIR/remove-never-const.rs:18:20: 18:20
scope 1 {
}
bb0: {
- unreachable; // scope 0 at $DIR/remove-never-const.rs:20:13: 20:33
+ unreachable; // scope 0 at $DIR/remove-never-const.rs:19:13: 19:33
}
}
diff --git a/src/test/ui/anon-params/anon-params-deprecated.stderr b/src/test/ui/anon-params/anon-params-deprecated.stderr
index 98d52d659a9d3..474b14f59e3ab 100644
--- a/src/test/ui/anon-params/anon-params-deprecated.stderr
+++ b/src/test/ui/anon-params/anon-params-deprecated.stderr
@@ -1,4 +1,4 @@
-warning: anonymous parameters are deprecated and will be removed in the next edition.
+warning: anonymous parameters are deprecated and will be removed in the next edition
--> $DIR/anon-params-deprecated.rs:9:12
|
LL | fn foo(i32);
@@ -12,7 +12,7 @@ LL | #![warn(anonymous_parameters)]
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018!
= note: for more information, see issue #41686 <https://github.com/rust-lang/rust/issues/41686>
-warning: anonymous parameters are deprecated and will be removed in the next edition.
+warning: anonymous parameters are deprecated and will be removed in the next edition
--> $DIR/anon-params-deprecated.rs:12:30
|
LL | fn bar_with_default_impl(String, String) {}
@@ -21,7 +21,7 @@ LL | fn bar_with_default_impl(String, String) {}
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018!
= note: for more information, see issue #41686 <https://github.com/rust-lang/rust/issues/41686>
-warning: anonymous parameters are deprecated and will be removed in the next edition.
+warning: anonymous parameters are deprecated and will be removed in the next edition
--> $DIR/anon-params-deprecated.rs:12:38
|
LL | fn bar_with_default_impl(String, String) {}
diff --git a/src/test/ui/associated-type-bounds/super-trait-referencing-self.rs b/src/test/ui/associated-type-bounds/supertrait-referencing-self.rs
similarity index 100%
rename from src/test/ui/associated-type-bounds/super-trait-referencing-self.rs
rename to src/test/ui/associated-type-bounds/supertrait-referencing-self.rs
diff --git a/src/test/ui/associated-type-bounds/super-trait-referencing.rs b/src/test/ui/associated-type-bounds/supertrait-referencing.rs
similarity index 100%
rename from src/test/ui/associated-type-bounds/super-trait-referencing.rs
rename to src/test/ui/associated-type-bounds/supertrait-referencing.rs
diff --git a/src/test/ui/associated-type-bounds/super-trait-where-referencing-self.rs b/src/test/ui/associated-type-bounds/supertrait-where-referencing-self.rs
similarity index 100%
rename from src/test/ui/associated-type-bounds/super-trait-where-referencing-self.rs
rename to src/test/ui/associated-type-bounds/supertrait-where-referencing-self.rs
diff --git a/src/test/ui/associated-types/issue-22560.stderr b/src/test/ui/associated-types/issue-22560.stderr
index d2193cc4a4895..c5c70f226fdf6 100644
--- a/src/test/ui/associated-types/issue-22560.stderr
+++ b/src/test/ui/associated-types/issue-22560.stderr
@@ -32,7 +32,7 @@ LL | type Test = dyn Add + Sub;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Add<[type error]> + Sub<[type error]> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add<[type error]> + Sub<[type error]> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0191]: the value of the associated types `Output` (from trait `Add`), `Output` (from trait `Sub`) must be specified
diff --git a/src/test/ui/associated-types/missing-associated-types.stderr b/src/test/ui/associated-types/missing-associated-types.stderr
index 340d4e2418e0f..8c52736b02c4c 100644
--- a/src/test/ui/associated-types/missing-associated-types.stderr
+++ b/src/test/ui/associated-types/missing-associated-types.stderr
@@ -6,7 +6,7 @@ LL | type Foo<Rhs> = dyn Add<Rhs> + Sub<Rhs> + X<Rhs> + Y<Rhs>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + X<Rhs> + Y<Rhs> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + X<Rhs> + Y<Rhs> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0191]: the value of the associated types `A` (from trait `Y`), `Output` (from trait `Add`), `Output` (from trait `Mul`), `Output` (from trait `Sub`) must be specified
@@ -35,7 +35,7 @@ LL | type Bar<Rhs> = dyn Add<Rhs> + Sub<Rhs> + X<Rhs> + Z<Rhs>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + X<Rhs> + Z<Rhs> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + X<Rhs> + Z<Rhs> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0191]: the value of the associated types `A` (from trait `Z`), `B` (from trait `Z`), `Output` (from trait `Add`), `Output` (from trait `Div`), `Output` (from trait `Div`), `Output` (from trait `Mul`), `Output` (from trait `Sub`) must be specified
@@ -71,7 +71,7 @@ LL | type Baz<Rhs> = dyn Add<Rhs> + Sub<Rhs> + Y<Rhs>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + Y<Rhs> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + Y<Rhs> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0191]: the value of the associated types `A` (from trait `Y`), `Output` (from trait `Add`), `Output` (from trait `Sub`) must be specified
@@ -99,7 +99,7 @@ LL | type Bat<Rhs> = dyn Add<Rhs> + Sub<Rhs> + Fine<Rhs>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + Fine<Rhs> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add<Rhs> + Sub<Rhs> + Fine<Rhs> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0191]: the value of the associated types `Output` (from trait `Add`), `Output` (from trait `Sub`) must be specified
diff --git a/src/test/ui/consts/const-eval/const_panic.rs b/src/test/ui/consts/const-eval/const_panic.rs
index 100faded079d5..5b9a8f8e2a279 100644
--- a/src/test/ui/consts/const-eval/const_panic.rs
+++ b/src/test/ui/consts/const-eval/const_panic.rs
@@ -1,4 +1,3 @@
-#![feature(const_panic)]
#![allow(non_fmt_panics)]
#![crate_type = "lib"]
diff --git a/src/test/ui/consts/const-eval/const_panic.stderr b/src/test/ui/consts/const-eval/const_panic.stderr
index e98e4a506c0d6..3932c2bc0ac73 100644
--- a/src/test/ui/consts/const-eval/const_panic.stderr
+++ b/src/test/ui/consts/const-eval/const_panic.stderr
@@ -1,96 +1,96 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:7:15
+ --> $DIR/const_panic.rs:6:15
|
LL | const Z: () = std::panic!("cheese");
- | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic.rs:7:15
+ | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic.rs:6:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:10:16
+ --> $DIR/const_panic.rs:9:16
|
LL | const Z2: () = std::panic!();
- | ^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic.rs:10:16
+ | ^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic.rs:9:16
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:13:15
+ --> $DIR/const_panic.rs:12:15
|
LL | const Y: () = std::unreachable!();
- | ^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:13:15
+ | ^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:12:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:16:15
+ --> $DIR/const_panic.rs:15:15
|
LL | const X: () = std::unimplemented!();
- | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic.rs:16:15
+ | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic.rs:15:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:19:15
+ --> $DIR/const_panic.rs:18:15
|
LL | const W: () = std::panic!(MSG);
- | ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:19:15
+ | ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:18:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:22:16
+ --> $DIR/const_panic.rs:21:16
|
LL | const W2: () = std::panic!("{}", MSG);
- | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:22:16
+ | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:21:16
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:25:20
+ --> $DIR/const_panic.rs:24:20
|
LL | const Z_CORE: () = core::panic!("cheese");
- | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic.rs:25:20
+ | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic.rs:24:20
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:28:21
+ --> $DIR/const_panic.rs:27:21
|
LL | const Z2_CORE: () = core::panic!();
- | ^^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic.rs:28:21
+ | ^^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic.rs:27:21
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:31:20
+ --> $DIR/const_panic.rs:30:20
|
LL | const Y_CORE: () = core::unreachable!();
- | ^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:31:20
+ | ^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:30:20
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:34:20
+ --> $DIR/const_panic.rs:33:20
|
LL | const X_CORE: () = core::unimplemented!();
- | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic.rs:34:20
+ | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic.rs:33:20
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:37:20
+ --> $DIR/const_panic.rs:36:20
|
LL | const W_CORE: () = core::panic!(MSG);
- | ^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:37:20
+ | ^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:36:20
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic.rs:40:21
+ --> $DIR/const_panic.rs:39:21
|
LL | const W2_CORE: () = core::panic!("{}", MSG);
- | ^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:40:21
+ | ^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:39:21
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/const-eval/const_panic_2021.rs b/src/test/ui/consts/const-eval/const_panic_2021.rs
index 9b8652a776e61..4702aa2f5f01c 100644
--- a/src/test/ui/consts/const-eval/const_panic_2021.rs
+++ b/src/test/ui/consts/const-eval/const_panic_2021.rs
@@ -1,5 +1,4 @@
// edition:2021
-#![feature(const_panic)]
#![crate_type = "lib"]
const MSG: &str = "hello";
diff --git a/src/test/ui/consts/const-eval/const_panic_2021.stderr b/src/test/ui/consts/const-eval/const_panic_2021.stderr
index 9eb241ae8e59d..975a07e2b0efa 100644
--- a/src/test/ui/consts/const-eval/const_panic_2021.stderr
+++ b/src/test/ui/consts/const-eval/const_panic_2021.stderr
@@ -1,80 +1,80 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:7:15
+ --> $DIR/const_panic_2021.rs:6:15
|
LL | const A: () = std::panic!("blåhaj");
- | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'blåhaj', $DIR/const_panic_2021.rs:7:15
+ | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'blåhaj', $DIR/const_panic_2021.rs:6:15
|
= note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:10:15
+ --> $DIR/const_panic_2021.rs:9:15
|
LL | const B: () = std::panic!();
- | ^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic_2021.rs:10:15
+ | ^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic_2021.rs:9:15
|
= note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:13:15
+ --> $DIR/const_panic_2021.rs:12:15
|
LL | const C: () = std::unreachable!();
- | ^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_2021.rs:13:15
+ | ^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_2021.rs:12:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:16:15
+ --> $DIR/const_panic_2021.rs:15:15
|
LL | const D: () = std::unimplemented!();
- | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_2021.rs:16:15
+ | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_2021.rs:15:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:19:15
+ --> $DIR/const_panic_2021.rs:18:15
|
LL | const E: () = std::panic!("{}", MSG);
- | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic_2021.rs:19:15
+ | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic_2021.rs:18:15
|
= note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:22:20
+ --> $DIR/const_panic_2021.rs:21:20
|
LL | const A_CORE: () = core::panic!("shark");
- | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'shark', $DIR/const_panic_2021.rs:22:20
+ | ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'shark', $DIR/const_panic_2021.rs:21:20
|
= note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:25:20
+ --> $DIR/const_panic_2021.rs:24:20
|
LL | const B_CORE: () = core::panic!();
- | ^^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic_2021.rs:25:20
+ | ^^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic_2021.rs:24:20
|
= note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:28:20
+ --> $DIR/const_panic_2021.rs:27:20
|
LL | const C_CORE: () = core::unreachable!();
- | ^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_2021.rs:28:20
+ | ^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_2021.rs:27:20
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:31:20
+ --> $DIR/const_panic_2021.rs:30:20
|
LL | const D_CORE: () = core::unimplemented!();
- | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_2021.rs:31:20
+ | ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_2021.rs:30:20
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_2021.rs:34:20
+ --> $DIR/const_panic_2021.rs:33:20
|
LL | const E_CORE: () = core::panic!("{}", MSG);
- | ^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic_2021.rs:34:20
+ | ^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic_2021.rs:33:20
|
= note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/const-eval/const_panic_libcore_bin.rs b/src/test/ui/consts/const-eval/const_panic_libcore_bin.rs
index 1ea0845c968c6..d4dc1a51d73aa 100644
--- a/src/test/ui/consts/const-eval/const_panic_libcore_bin.rs
+++ b/src/test/ui/consts/const-eval/const_panic_libcore_bin.rs
@@ -1,6 +1,5 @@
#![crate_type = "bin"]
#![feature(lang_items)]
-#![feature(const_panic)]
#![no_main]
#![no_std]
diff --git a/src/test/ui/consts/const-eval/const_panic_libcore_bin.stderr b/src/test/ui/consts/const-eval/const_panic_libcore_bin.stderr
index 9abf8a20b8a35..b3fa38241a4ef 100644
--- a/src/test/ui/consts/const-eval/const_panic_libcore_bin.stderr
+++ b/src/test/ui/consts/const-eval/const_panic_libcore_bin.stderr
@@ -1,24 +1,24 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_libcore_bin.rs:9:15
+ --> $DIR/const_panic_libcore_bin.rs:8:15
|
LL | const Z: () = panic!("cheese");
- | ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic_libcore_bin.rs:9:15
+ | ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic_libcore_bin.rs:8:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_libcore_bin.rs:12:15
+ --> $DIR/const_panic_libcore_bin.rs:11:15
|
LL | const Y: () = unreachable!();
- | ^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_libcore_bin.rs:12:15
+ | ^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_libcore_bin.rs:11:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_libcore_bin.rs:15:15
+ --> $DIR/const_panic_libcore_bin.rs:14:15
|
LL | const X: () = unimplemented!();
- | ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_libcore_bin.rs:15:15
+ | ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_libcore_bin.rs:14:15
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/const-eval/const_panic_track_caller.rs b/src/test/ui/consts/const-eval/const_panic_track_caller.rs
index 7c2532673c835..9cf7a3ba7dc1c 100644
--- a/src/test/ui/consts/const-eval/const_panic_track_caller.rs
+++ b/src/test/ui/consts/const-eval/const_panic_track_caller.rs
@@ -1,4 +1,3 @@
-#![feature(const_panic)]
#![allow(non_fmt_panics)]
#![crate_type = "lib"]
diff --git a/src/test/ui/consts/const-eval/const_panic_track_caller.stderr b/src/test/ui/consts/const-eval/const_panic_track_caller.stderr
index 9a458db6ea24d..5c3b412d37fcc 100644
--- a/src/test/ui/consts/const-eval/const_panic_track_caller.stderr
+++ b/src/test/ui/consts/const-eval/const_panic_track_caller.stderr
@@ -1,14 +1,14 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/const_panic_track_caller.rs:16:5
+ --> $DIR/const_panic_track_caller.rs:15:5
|
LL | b()
| ^^^
| |
- | the evaluated program panicked at 'hey', $DIR/const_panic_track_caller.rs:16:5
- | inside `c` at $DIR/const_panic_track_caller.rs:16:5
+ | the evaluated program panicked at 'hey', $DIR/const_panic_track_caller.rs:15:5
+ | inside `c` at $DIR/const_panic_track_caller.rs:15:5
...
LL | const X: u32 = c();
- | --- inside `X` at $DIR/const_panic_track_caller.rs:22:16
+ | --- inside `X` at $DIR/const_panic_track_caller.rs:21:16
error: aborting due to previous error
diff --git a/src/test/ui/consts/const-eval/const_raw_ptr_ops.stderr b/src/test/ui/consts/const-eval/const_raw_ptr_ops.stderr
index 21d3f5e7e8536..1f5bca273d3b0 100644
--- a/src/test/ui/consts/const-eval/const_raw_ptr_ops.stderr
+++ b/src/test/ui/consts/const-eval/const_raw_ptr_ops.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be reliably compared during const eval.
+error: pointers cannot be reliably compared during const eval
--> $DIR/const_raw_ptr_ops.rs:4:26
|
LL | const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 };
@@ -6,7 +6,7 @@ LL | const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 };
|
= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
-error: pointers cannot be reliably compared during const eval.
+error: pointers cannot be reliably compared during const eval
--> $DIR/const_raw_ptr_ops.rs:6:27
|
LL | const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 };
diff --git a/src/test/ui/consts/const-eval/feature-gate-const_panic.rs b/src/test/ui/consts/const-eval/feature-gate-const_panic.rs
deleted file mode 100644
index ba5b07239a200..0000000000000
--- a/src/test/ui/consts/const-eval/feature-gate-const_panic.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-fn main() {}
-
-const Z: () = panic!("cheese");
-//~^ ERROR panicking in constants is unstable
-
-const Y: () = unreachable!();
-//~^ ERROR panicking in constants is unstable
-
-const X: () = unimplemented!();
-//~^ ERROR panicking in constants is unstable
diff --git a/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr b/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr
deleted file mode 100644
index 8d8e94cd4ff8a..0000000000000
--- a/src/test/ui/consts/const-eval/feature-gate-const_panic.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error[E0658]: panicking in constants is unstable
- --> $DIR/feature-gate-const_panic.rs:3:15
- |
-LL | const Z: () = panic!("cheese");
- | ^^^^^^^^^^^^^^^^
- |
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
- = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0658]: panicking in constants is unstable
- --> $DIR/feature-gate-const_panic.rs:6:15
- |
-LL | const Y: () = unreachable!();
- | ^^^^^^^^^^^^^^
- |
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
- = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0658]: panicking in constants is unstable
- --> $DIR/feature-gate-const_panic.rs:9:15
- |
-LL | const X: () = unimplemented!();
- | ^^^^^^^^^^^^^^^^
- |
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
- = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/consts/const-eval/match-test-ptr-null.stderr b/src/test/ui/consts/const-eval/match-test-ptr-null.stderr
index 4e55b36da7392..05c3951c1284b 100644
--- a/src/test/ui/consts/const-eval/match-test-ptr-null.stderr
+++ b/src/test/ui/consts/const-eval/match-test-ptr-null.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/match-test-ptr-null.rs:6:15
|
LL | match &1 as *const i32 as usize {
diff --git a/src/test/ui/consts/const-eval/panic-assoc-never-type.rs b/src/test/ui/consts/const-eval/panic-assoc-never-type.rs
index ab0256a986dbc..2bdf5d5476576 100644
--- a/src/test/ui/consts/const-eval/panic-assoc-never-type.rs
+++ b/src/test/ui/consts/const-eval/panic-assoc-never-type.rs
@@ -2,7 +2,6 @@
// Regression test for #66975
#![warn(const_err)]
-#![feature(const_panic)]
#![feature(never_type)]
struct PrintName;
diff --git a/src/test/ui/consts/const-eval/panic-assoc-never-type.stderr b/src/test/ui/consts/const-eval/panic-assoc-never-type.stderr
index f1c606a8a2e5d..9631b7748b546 100644
--- a/src/test/ui/consts/const-eval/panic-assoc-never-type.stderr
+++ b/src/test/ui/consts/const-eval/panic-assoc-never-type.stderr
@@ -1,8 +1,8 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/panic-assoc-never-type.rs:11:21
+ --> $DIR/panic-assoc-never-type.rs:10:21
|
LL | const VOID: ! = panic!();
- | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/panic-assoc-never-type.rs:11:21
+ | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/panic-assoc-never-type.rs:10:21
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/const-eval/panic-never-type.rs b/src/test/ui/consts/const-eval/panic-never-type.rs
index dd875768b168f..a74d3ba297189 100644
--- a/src/test/ui/consts/const-eval/panic-never-type.rs
+++ b/src/test/ui/consts/const-eval/panic-never-type.rs
@@ -1,6 +1,5 @@
// Regression test for #66975
#![warn(const_err)]
-#![feature(const_panic)]
#![feature(never_type)]
const VOID: ! = panic!();
diff --git a/src/test/ui/consts/const-eval/panic-never-type.stderr b/src/test/ui/consts/const-eval/panic-never-type.stderr
index 9b7f2181c1662..8f312d673a175 100644
--- a/src/test/ui/consts/const-eval/panic-never-type.stderr
+++ b/src/test/ui/consts/const-eval/panic-never-type.stderr
@@ -1,8 +1,8 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/panic-never-type.rs:6:17
+ --> $DIR/panic-never-type.rs:5:17
|
LL | const VOID: ! = panic!();
- | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/panic-never-type.rs:6:17
+ | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/panic-never-type.rs:5:17
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/const-eval/unwind-abort.rs b/src/test/ui/consts/const-eval/unwind-abort.rs
index 89b5135fd37e3..2b0e58166c254 100644
--- a/src/test/ui/consts/const-eval/unwind-abort.rs
+++ b/src/test/ui/consts/const-eval/unwind-abort.rs
@@ -1,4 +1,4 @@
-#![feature(c_unwind, const_panic, const_extern_fn)]
+#![feature(c_unwind, const_extern_fn)]
const extern "C" fn foo() {
panic!() //~ ERROR evaluation of constant value failed
diff --git a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
index 2e52bae2b676c..2b2d23477f681 100644
--- a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
+++ b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
@@ -25,7 +25,7 @@ LL | const unsafe extern "C" fn use_float() { 1.0 + 1.0; }
= note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
= help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/const-extern-fn-min-const-fn.rs:9:48
|
LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
diff --git a/src/test/ui/consts/const-float-bits-conv.rs b/src/test/ui/consts/const-float-bits-conv.rs
index 2dfc6de859783..c857ad6df2de2 100644
--- a/src/test/ui/consts/const-float-bits-conv.rs
+++ b/src/test/ui/consts/const-float-bits-conv.rs
@@ -1,7 +1,6 @@
// compile-flags: -Zmir-opt-level=0
// run-pass
-#![feature(const_panic)]
#![feature(const_float_bits_conv)]
#![feature(const_float_classify)]
diff --git a/src/test/ui/consts/const-float-classify.rs b/src/test/ui/consts/const-float-classify.rs
index 5d38e032ac408..74238d0dd9231 100644
--- a/src/test/ui/consts/const-float-classify.rs
+++ b/src/test/ui/consts/const-float-classify.rs
@@ -1,7 +1,6 @@
// compile-flags: -Zmir-opt-level=0
// run-pass
-#![feature(const_panic)]
#![feature(const_float_bits_conv)]
#![feature(const_float_classify)]
#![feature(const_trait_impl)]
diff --git a/src/test/ui/consts/control-flow/assert.rs b/src/test/ui/consts/control-flow/assert.rs
index b311cb140ccf6..9d17f65b93cab 100644
--- a/src/test/ui/consts/control-flow/assert.rs
+++ b/src/test/ui/consts/control-flow/assert.rs
@@ -1,14 +1,8 @@
-// Test that `assert` works when `const_panic` is enabled.
-
-// revisions: stock const_panic
-
-#![cfg_attr(const_panic, feature(const_panic))]
+// Test that `assert` works in consts.
const _: () = assert!(true);
-//[stock]~^ ERROR panicking in constants is unstable
const _: () = assert!(false);
-//[stock]~^ ERROR panicking in constants is unstable
-//[const_panic]~^^ ERROR evaluation of constant value failed
+//~^ ERROR evaluation of constant value failed
fn main() {}
diff --git a/src/test/ui/consts/control-flow/assert.const_panic.stderr b/src/test/ui/consts/control-flow/assert.stderr
similarity index 82%
rename from src/test/ui/consts/control-flow/assert.const_panic.stderr
rename to src/test/ui/consts/control-flow/assert.stderr
index 1deaa937edb37..8b1ca183de98b 100644
--- a/src/test/ui/consts/control-flow/assert.const_panic.stderr
+++ b/src/test/ui/consts/control-flow/assert.stderr
@@ -1,8 +1,8 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/assert.rs:10:15
+ --> $DIR/assert.rs:5:15
|
LL | const _: () = assert!(false);
- | ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/assert.rs:10:15
+ | ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/assert.rs:5:15
|
= note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/control-flow/assert.stock.stderr b/src/test/ui/consts/control-flow/assert.stock.stderr
deleted file mode 100644
index 0caaeca4ad23f..0000000000000
--- a/src/test/ui/consts/control-flow/assert.stock.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0658]: panicking in constants is unstable
- --> $DIR/assert.rs:7:15
- |
-LL | const _: () = assert!(true);
- | ^^^^^^^^^^^^^
- |
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
- = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0658]: panicking in constants is unstable
- --> $DIR/assert.rs:10:15
- |
-LL | const _: () = assert!(false);
- | ^^^^^^^^^^^^^^
- |
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
- = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/consts/control-flow/basics.rs b/src/test/ui/consts/control-flow/basics.rs
index 3a4f24bbcc339..02e5501f10cfe 100644
--- a/src/test/ui/consts/control-flow/basics.rs
+++ b/src/test/ui/consts/control-flow/basics.rs
@@ -2,8 +2,6 @@
// run-pass
-#![feature(const_panic)]
-
const X: u32 = 4;
const Y: u32 = 5;
diff --git a/src/test/ui/consts/control-flow/short-circuit-let.rs b/src/test/ui/consts/control-flow/short-circuit-let.rs
index 4dfa22b8ebaf6..8a58d06ac87bd 100644
--- a/src/test/ui/consts/control-flow/short-circuit-let.rs
+++ b/src/test/ui/consts/control-flow/short-circuit-let.rs
@@ -2,8 +2,6 @@
// run-pass
-#![feature(const_panic)]
-
const X: i32 = {
let mut x = 0;
let _ = true && { x = 1; false };
diff --git a/src/test/ui/consts/control-flow/short-circuit.rs b/src/test/ui/consts/control-flow/short-circuit.rs
index f6a0f03a4a6b8..6abe107855f80 100644
--- a/src/test/ui/consts/control-flow/short-circuit.rs
+++ b/src/test/ui/consts/control-flow/short-circuit.rs
@@ -3,8 +3,6 @@
// Test that both `&&` and `||` actually short-circuit.
// Formerly, both sides were evaluated unconditionally
-#![feature(const_panic)]
-
const TRUE: bool = true || panic!();
const FALSE: bool = false && panic!();
diff --git a/src/test/ui/consts/issue-17458.stderr b/src/test/ui/consts/issue-17458.stderr
index aab7d798db2e7..8936c8d84ecff 100644
--- a/src/test/ui/consts/issue-17458.stderr
+++ b/src/test/ui/consts/issue-17458.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/issue-17458.rs:1:28
|
LL | static X: usize = unsafe { core::ptr::null::<usize>() as usize };
diff --git a/src/test/ui/consts/issue-25826.stderr b/src/test/ui/consts/issue-25826.stderr
index 67d1b3ab9bed6..780edd2149fe1 100644
--- a/src/test/ui/consts/issue-25826.stderr
+++ b/src/test/ui/consts/issue-25826.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be reliably compared during const eval.
+error: pointers cannot be reliably compared during const eval
--> $DIR/issue-25826.rs:3:30
|
LL | const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
diff --git a/src/test/ui/consts/issue-32829.rs b/src/test/ui/consts/issue-32829.rs
index adfee7b925cc5..25f323b9803c8 100644
--- a/src/test/ui/consts/issue-32829.rs
+++ b/src/test/ui/consts/issue-32829.rs
@@ -1,5 +1,5 @@
static S : u64 = { { panic!("foo"); 0 } };
-//~^ ERROR panicking in statics is unstable
+//~^ ERROR could not evaluate static initializer
fn main() {
println!("{:?}", S);
diff --git a/src/test/ui/consts/issue-32829.stderr b/src/test/ui/consts/issue-32829.stderr
index eba15e3fcca8a..4b25bf1c99e18 100644
--- a/src/test/ui/consts/issue-32829.stderr
+++ b/src/test/ui/consts/issue-32829.stderr
@@ -1,13 +1,11 @@
-error[E0658]: panicking in statics is unstable
+error[E0080]: could not evaluate static initializer
--> $DIR/issue-32829.rs:1:22
|
LL | static S : u64 = { { panic!("foo"); 0 } };
- | ^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^ the evaluated program panicked at 'foo', $DIR/issue-32829.rs:1:22
|
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
-For more information about this error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0080`.
diff --git a/src/test/ui/consts/issue-52023-array-size-pointer-cast.stderr b/src/test/ui/consts/issue-52023-array-size-pointer-cast.stderr
index 363c7b2c8e462..9a3d5716e001b 100644
--- a/src/test/ui/consts/issue-52023-array-size-pointer-cast.stderr
+++ b/src/test/ui/consts/issue-52023-array-size-pointer-cast.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/issue-52023-array-size-pointer-cast.rs:2:17
|
LL | let _ = [0; (&0 as *const i32) as usize];
diff --git a/src/test/ui/consts/issue-66693-panic-in-array-len.rs b/src/test/ui/consts/issue-66693-panic-in-array-len.rs
index 718a19067a6ac..fc0dcd7a44daa 100644
--- a/src/test/ui/consts/issue-66693-panic-in-array-len.rs
+++ b/src/test/ui/consts/issue-66693-panic-in-array-len.rs
@@ -2,8 +2,6 @@
// in a separate stage before `const`s and `statics` and so the error below is hit and
// the compiler exits before generating errors for the others.
-#![feature(const_panic)]
-
fn main() {
let _ = [0i32; panic!(2f32)];
//~^ ERROR: argument to `panic!()` in a const context must have type `&str`
diff --git a/src/test/ui/consts/issue-66693-panic-in-array-len.stderr b/src/test/ui/consts/issue-66693-panic-in-array-len.stderr
index 2dd445b434b58..4ccbeb73c8a25 100644
--- a/src/test/ui/consts/issue-66693-panic-in-array-len.stderr
+++ b/src/test/ui/consts/issue-66693-panic-in-array-len.stderr
@@ -1,5 +1,5 @@
error: argument to `panic!()` in a const context must have type `&str`
- --> $DIR/issue-66693-panic-in-array-len.rs:8:20
+ --> $DIR/issue-66693-panic-in-array-len.rs:6:20
|
LL | let _ = [0i32; panic!(2f32)];
| ^^^^^^^^^^^^
@@ -7,10 +7,10 @@ LL | let _ = [0i32; panic!(2f32)];
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
- --> $DIR/issue-66693-panic-in-array-len.rs:12:21
+ --> $DIR/issue-66693-panic-in-array-len.rs:10:21
|
LL | let _ = [false; panic!()];
- | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-66693-panic-in-array-len.rs:12:21
+ | ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-66693-panic-in-array-len.rs:10:21
|
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/consts/issue-66693.rs b/src/test/ui/consts/issue-66693.rs
index 77fe4417d5b10..909bef7aefbd3 100644
--- a/src/test/ui/consts/issue-66693.rs
+++ b/src/test/ui/consts/issue-66693.rs
@@ -1,8 +1,6 @@
// Tests that the compiler does not ICE when const-evaluating a `panic!()` invocation with a
// non-`&str` argument.
-#![feature(const_panic)]
-
const _: () = panic!(1);
//~^ ERROR: argument to `panic!()` in a const context must have type `&str`
diff --git a/src/test/ui/consts/issue-66693.stderr b/src/test/ui/consts/issue-66693.stderr
index 3349e9813a809..3db6716a72e8b 100644
--- a/src/test/ui/consts/issue-66693.stderr
+++ b/src/test/ui/consts/issue-66693.stderr
@@ -1,5 +1,5 @@
error: argument to `panic!()` in a const context must have type `&str`
- --> $DIR/issue-66693.rs:6:15
+ --> $DIR/issue-66693.rs:4:15
|
LL | const _: () = panic!(1);
| ^^^^^^^^^
@@ -7,7 +7,7 @@ LL | const _: () = panic!(1);
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error: argument to `panic!()` in a const context must have type `&str`
- --> $DIR/issue-66693.rs:9:19
+ --> $DIR/issue-66693.rs:7:19
|
LL | static _FOO: () = panic!(true);
| ^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL | static _FOO: () = panic!(true);
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error: argument to `panic!()` in a const context must have type `&str`
- --> $DIR/issue-66693.rs:13:5
+ --> $DIR/issue-66693.rs:11:5
|
LL | panic!(&1);
| ^^^^^^^^^^^
diff --git a/src/test/ui/consts/issue-76064.rs b/src/test/ui/consts/issue-76064.rs
index d511f75df8129..3c153ad726e28 100644
--- a/src/test/ui/consts/issue-76064.rs
+++ b/src/test/ui/consts/issue-76064.rs
@@ -1,5 +1,3 @@
-// Note: non-`&str` panic arguments gained a separate error in PR #80734
-// which is why this doesn't match the issue
-struct Bug([u8; panic!("panic")]); //~ ERROR panicking in constants is unstable
+struct Bug([u8; panic!("panic")]); //~ ERROR evaluation of constant value failed
fn main() {}
diff --git a/src/test/ui/consts/issue-76064.stderr b/src/test/ui/consts/issue-76064.stderr
index 875bc5c5cd330..ef9d140536a3d 100644
--- a/src/test/ui/consts/issue-76064.stderr
+++ b/src/test/ui/consts/issue-76064.stderr
@@ -1,13 +1,11 @@
-error[E0658]: panicking in constants is unstable
- --> $DIR/issue-76064.rs:3:17
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-76064.rs:1:17
|
LL | struct Bug([u8; panic!("panic")]);
- | ^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^ the evaluated program panicked at 'panic', $DIR/issue-76064.rs:1:17
|
- = note: see issue #51999 <https://github.com/rust-lang/rust/issues/51999> for more information
- = help: add `#![feature(const_panic)]` to the crate attributes to enable
= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
-For more information about this error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0080`.
diff --git a/src/test/ui/consts/min_const_fn/cmp_fn_pointers.stderr b/src/test/ui/consts/min_const_fn/cmp_fn_pointers.stderr
index 04c2febeb9768..5d8483cd111bf 100644
--- a/src/test/ui/consts/min_const_fn/cmp_fn_pointers.stderr
+++ b/src/test/ui/consts/min_const_fn/cmp_fn_pointers.stderr
@@ -16,7 +16,7 @@ LL | const fn cmp(x: fn(), y: fn()) -> bool {
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
-error: pointers cannot be reliably compared during const eval.
+error: pointers cannot be reliably compared during const eval
--> $DIR/cmp_fn_pointers.rs:4:14
|
LL | unsafe { x == y }
diff --git a/src/test/ui/consts/min_const_fn/min_const_fn.stderr b/src/test/ui/consts/min_const_fn/min_const_fn.stderr
index 1e275d77bac67..fd1ab6f64bf56 100644
--- a/src/test/ui/consts/min_const_fn/min_const_fn.stderr
+++ b/src/test/ui/consts/min_const_fn/min_const_fn.stderr
@@ -164,7 +164,7 @@ LL | const fn foo26() -> &'static u32 { &BAR }
|
= help: consider extracting the value of the `static` to a `const`, and referring to that
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/min_const_fn.rs:92:42
|
LL | const fn foo30(x: *const u32) -> usize { x as usize }
@@ -173,7 +173,7 @@ LL | const fn foo30(x: *const u32) -> usize { x as usize }
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/min_const_fn.rs:94:63
|
LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize } }
@@ -182,7 +182,7 @@ LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize }
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/min_const_fn.rs:96:42
|
LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
@@ -191,7 +191,7 @@ LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
= note: at compile-time, pointers do not have an integer value
= note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/min_const_fn.rs:98:63
|
LL | const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize } }
diff --git a/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.32bit.stderr b/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.32bit.stderr
index 64d8540878ec2..186c5b1856baa 100644
--- a/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.32bit.stderr
+++ b/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.32bit.stderr
@@ -161,17 +161,11 @@ help: skipping check that does not even have a feature gate
|
LL | unsafe { match static_cross_crate::OPT_ZERO { Some(ref u) => u, None => panic!() } }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_panic` feature
- --> $DIR/const_refers_to_static_cross_crate.rs:32:77
- |
-LL | unsafe { match static_cross_crate::OPT_ZERO { Some(ref u) => u, None => panic!() } }
- | ^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/const_refers_to_static_cross_crate.rs:32:20
|
LL | unsafe { match static_cross_crate::OPT_ZERO { Some(ref u) => u, None => panic!() } }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this warning originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 10 previous errors; 3 warnings emitted
diff --git a/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.64bit.stderr b/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.64bit.stderr
index 8e793ab3f0d91..7a64abd7b9cb8 100644
--- a/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.64bit.stderr
+++ b/src/test/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.64bit.stderr
@@ -161,17 +161,11 @@ help: skipping check that does not even have a feature gate
|
LL | unsafe { match static_cross_crate::OPT_ZERO { Some(ref u) => u, None => panic!() } }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_panic` feature
- --> $DIR/const_refers_to_static_cross_crate.rs:32:77
- |
-LL | unsafe { match static_cross_crate::OPT_ZERO { Some(ref u) => u, None => panic!() } }
- | ^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/const_refers_to_static_cross_crate.rs:32:20
|
LL | unsafe { match static_cross_crate::OPT_ZERO { Some(ref u) => u, None => panic!() } }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this warning originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 10 previous errors; 3 warnings emitted
diff --git a/src/test/ui/consts/ptr_comparisons.rs b/src/test/ui/consts/ptr_comparisons.rs
index 9b5fd18f818b0..971b7c3cb179a 100644
--- a/src/test/ui/consts/ptr_comparisons.rs
+++ b/src/test/ui/consts/ptr_comparisons.rs
@@ -5,7 +5,6 @@
// normalize-stderr-64bit: "size 8" -> "size $$WORD"
#![feature(
- const_panic,
core_intrinsics,
const_raw_ptr_comparison,
const_ptr_offset,
diff --git a/src/test/ui/consts/ptr_comparisons.stderr b/src/test/ui/consts/ptr_comparisons.stderr
index a28ae521d5b9a..48cd5da213f3d 100644
--- a/src/test/ui/consts/ptr_comparisons.stderr
+++ b/src/test/ui/consts/ptr_comparisons.stderr
@@ -7,19 +7,19 @@ LL | unsafe { intrinsics::offset(self, count) }
| pointer arithmetic failed: alloc3 has size $WORD, so pointer to $TWO_WORDS bytes starting at offset 0 is out-of-bounds
| inside `ptr::const_ptr::<impl *const usize>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
|
- ::: $DIR/ptr_comparisons.rs:61:34
+ ::: $DIR/ptr_comparisons.rs:60:34
|
LL | const _: *const usize = unsafe { (FOO as *const usize).offset(2) };
- | ------------------------------- inside `_` at $DIR/ptr_comparisons.rs:61:34
+ | ------------------------------- inside `_` at $DIR/ptr_comparisons.rs:60:34
error[E0080]: evaluation of constant value failed
- --> $DIR/ptr_comparisons.rs:64:33
+ --> $DIR/ptr_comparisons.rs:63:33
|
LL | unsafe { std::ptr::addr_of!((*(FOO as *const usize as *const [u8; 1000]))[999]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereferencing pointer failed: alloc3 has size $WORD, so pointer to 1000 bytes starting at offset 0 is out-of-bounds
error: any use of this value will cause an error
- --> $DIR/ptr_comparisons.rs:68:27
+ --> $DIR/ptr_comparisons.rs:67:27
|
LL | const _: usize = unsafe { std::mem::transmute::<*const usize, usize>(FOO) + 4 };
| --------------------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---
@@ -31,7 +31,7 @@ LL | const _: usize = unsafe { std::mem::transmute::<*const usize, usize>(FOO) +
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: any use of this value will cause an error
- --> $DIR/ptr_comparisons.rs:73:27
+ --> $DIR/ptr_comparisons.rs:72:27
|
LL | const _: usize = unsafe { *std::mem::transmute::<&&usize, &usize>(&FOO) + 4 };
| --------------------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---
diff --git a/src/test/ui/consts/ptr_is_null.rs b/src/test/ui/consts/ptr_is_null.rs
index 324f59443f721..8babb68585dea 100644
--- a/src/test/ui/consts/ptr_is_null.rs
+++ b/src/test/ui/consts/ptr_is_null.rs
@@ -1,7 +1,7 @@
// compile-flags: --crate-type=lib
// check-pass
-#![feature(const_ptr_is_null, const_panic)]
+#![feature(const_ptr_is_null)]
const FOO: &usize = &42;
diff --git a/src/test/ui/consts/unwind-abort.rs b/src/test/ui/consts/unwind-abort.rs
index d9d0b91011d9a..6c94fc7b98b75 100644
--- a/src/test/ui/consts/unwind-abort.rs
+++ b/src/test/ui/consts/unwind-abort.rs
@@ -1,6 +1,6 @@
// check-pass
-#![feature(c_unwind, const_panic, const_extern_fn)]
+#![feature(c_unwind, const_extern_fn)]
// We don't unwind in const-eval anyways.
const extern "C" fn foo() {
diff --git a/src/test/ui/enum-discriminant/niche.rs b/src/test/ui/enum-discriminant/niche.rs
index b3694bb4216c6..8d30610504f7d 100644
--- a/src/test/ui/enum-discriminant/niche.rs
+++ b/src/test/ui/enum-discriminant/niche.rs
@@ -1,7 +1,5 @@
// run-pass
-#![feature(const_panic)]
-
//! Make sure that we read and write enum discriminants correctly for corner cases caused
//! by layout optimizations.
diff --git a/src/test/ui/error-codes/E0225.stderr b/src/test/ui/error-codes/E0225.stderr
index 435a2c9396273..a4b33a0b7b408 100644
--- a/src/test/ui/error-codes/E0225.stderr
+++ b/src/test/ui/error-codes/E0225.stderr
@@ -6,7 +6,7 @@ LL | let _: Box<dyn std::io::Read + std::io::Write>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: std::io::Read + std::io::Write {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: std::io::Read + std::io::Write {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -23,7 +23,7 @@ LL | let _: Box<dyn Foo>;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: std::io::Read + std::io::Write {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: std::io::Read + std::io::Write {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 2 previous errors
diff --git a/src/test/ui/error-codes/E0395.stderr b/src/test/ui/error-codes/E0395.stderr
index 674cc69645029..ea17e95a719af 100644
--- a/src/test/ui/error-codes/E0395.stderr
+++ b/src/test/ui/error-codes/E0395.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be reliably compared during const eval.
+error: pointers cannot be reliably compared during const eval
--> $DIR/E0395.rs:4:29
|
LL | static BAZ: bool = unsafe { (&FOO as *const i32) == (&BAR as *const i32) };
diff --git a/src/test/ui/future-incompatible-lint-group.stderr b/src/test/ui/future-incompatible-lint-group.stderr
index cb9be88c9ee44..d822847a7a589 100644
--- a/src/test/ui/future-incompatible-lint-group.stderr
+++ b/src/test/ui/future-incompatible-lint-group.stderr
@@ -1,4 +1,4 @@
-warning: anonymous parameters are deprecated and will be removed in the next edition.
+warning: anonymous parameters are deprecated and will be removed in the next edition
--> $DIR/future-incompatible-lint-group.rs:7:10
|
LL | fn f(u8) {}
diff --git a/src/test/ui/imports/issue-30560.stderr b/src/test/ui/imports/issue-30560.stderr
index b74134aaccc0d..69cfd4c06a8b8 100644
--- a/src/test/ui/imports/issue-30560.stderr
+++ b/src/test/ui/imports/issue-30560.stderr
@@ -1,4 +1,4 @@
-error: items in traits are not importable.
+error: items in traits are not importable
--> $DIR/issue-30560.rs:7:5
|
LL | use T::*;
diff --git a/src/test/ui/issues/issue-18294.stderr b/src/test/ui/issues/issue-18294.stderr
index 432e9a6518765..e0cbd2a216dbb 100644
--- a/src/test/ui/issues/issue-18294.stderr
+++ b/src/test/ui/issues/issue-18294.stderr
@@ -1,4 +1,4 @@
-error: pointers cannot be cast to integers during const eval.
+error: pointers cannot be cast to integers during const eval
--> $DIR/issue-18294.rs:3:31
|
LL | const Y: usize = unsafe { &X as *const u32 as usize };
diff --git a/src/test/ui/issues/issue-32963.stderr b/src/test/ui/issues/issue-32963.stderr
index b5aa7b1b94d15..5e7762b32200a 100644
--- a/src/test/ui/issues/issue-32963.stderr
+++ b/src/test/ui/issues/issue-32963.stderr
@@ -6,7 +6,7 @@ LL | size_of_copy::<dyn Misc + Copy>();
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Misc + Copy {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Misc + Copy {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -17,7 +17,7 @@ LL | size_of_copy::<dyn Misc + Copy>();
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Misc + Copy {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Misc + Copy {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0277]: the trait bound `dyn Misc: Copy` is not satisfied
diff --git a/src/test/ui/issues/issue-50403.stderr b/src/test/ui/issues/issue-50403.stderr
index d20a98ecc6ad5..a3a2ed044db3e 100644
--- a/src/test/ui/issues/issue-50403.stderr
+++ b/src/test/ui/issues/issue-50403.stderr
@@ -1,4 +1,4 @@
-error: concat_idents! takes 1 or more arguments.
+error: concat_idents! takes 1 or more arguments
--> $DIR/issue-50403.rs:4:13
|
LL | let x = concat_idents!();
diff --git a/src/test/ui/iterators/into-iter-on-arrays-2018.stderr b/src/test/ui/iterators/into-iter-on-arrays-2018.stderr
index bc08fdcafa08d..e994d69110698 100644
--- a/src/test/ui/iterators/into-iter-on-arrays-2018.stderr
+++ b/src/test/ui/iterators/into-iter-on-arrays-2018.stderr
@@ -1,4 +1,4 @@
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-2018.rs:14:34
|
LL | let _: Iter<'_, i32> = array.into_iter();
@@ -16,7 +16,7 @@ help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicit
LL | let _: Iter<'_, i32> = IntoIterator::into_iter(array);
| ++++++++++++++++++++++++ ~
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-2018.rs:18:44
|
LL | let _: Iter<'_, i32> = Box::new(array).into_iter();
@@ -25,7 +25,7 @@ LL | let _: Iter<'_, i32> = Box::new(array).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-2018.rs:22:43
|
LL | let _: Iter<'_, i32> = Rc::new(array).into_iter();
@@ -34,7 +34,7 @@ LL | let _: Iter<'_, i32> = Rc::new(array).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-2018.rs:25:41
|
LL | let _: Iter<'_, i32> = Array(array).into_iter();
@@ -43,7 +43,7 @@ LL | let _: Iter<'_, i32> = Array(array).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-2018.rs:32:24
|
LL | for _ in [1, 2, 3].into_iter() {}
diff --git a/src/test/ui/iterators/into-iter-on-arrays-lint.stderr b/src/test/ui/iterators/into-iter-on-arrays-lint.stderr
index 2df1a06df20ab..634728096ed69 100644
--- a/src/test/ui/iterators/into-iter-on-arrays-lint.stderr
+++ b/src/test/ui/iterators/into-iter-on-arrays-lint.stderr
@@ -1,4 +1,4 @@
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:10:11
|
LL | small.into_iter();
@@ -16,7 +16,7 @@ help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicit
LL | IntoIterator::into_iter(small);
| ++++++++++++++++++++++++ ~
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:13:12
|
LL | [1, 2].into_iter();
@@ -33,7 +33,7 @@ help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicit
LL | IntoIterator::into_iter([1, 2]);
| ++++++++++++++++++++++++ ~
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:16:9
|
LL | big.into_iter();
@@ -50,7 +50,7 @@ help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicit
LL | IntoIterator::into_iter(big);
| ++++++++++++++++++++++++ ~
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:19:15
|
LL | [0u8; 33].into_iter();
@@ -67,7 +67,7 @@ help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicit
LL | IntoIterator::into_iter([0u8; 33]);
| ++++++++++++++++++++++++ ~
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:23:21
|
LL | Box::new(small).into_iter();
@@ -76,7 +76,7 @@ LL | Box::new(small).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:26:22
|
LL | Box::new([1, 2]).into_iter();
@@ -85,7 +85,7 @@ LL | Box::new([1, 2]).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:29:19
|
LL | Box::new(big).into_iter();
@@ -94,7 +94,7 @@ LL | Box::new(big).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:32:25
|
LL | Box::new([0u8; 33]).into_iter();
@@ -103,7 +103,7 @@ LL | Box::new([0u8; 33]).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:36:31
|
LL | Box::new(Box::new(small)).into_iter();
@@ -112,7 +112,7 @@ LL | Box::new(Box::new(small)).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:39:32
|
LL | Box::new(Box::new([1, 2])).into_iter();
@@ -121,7 +121,7 @@ LL | Box::new(Box::new([1, 2])).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:42:29
|
LL | Box::new(Box::new(big)).into_iter();
@@ -130,7 +130,7 @@ LL | Box::new(Box::new(big)).into_iter();
= warning: this changes meaning in Rust 2021
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
-warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021.
+warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
--> $DIR/into-iter-on-arrays-lint.rs:45:35
|
LL | Box::new(Box::new([0u8; 33])).into_iter();
diff --git a/src/test/ui/lang-items/issue-83471.stderr b/src/test/ui/lang-items/issue-83471.stderr
index c6130bb3370be..6d796fe7f500b 100644
--- a/src/test/ui/lang-items/issue-83471.stderr
+++ b/src/test/ui/lang-items/issue-83471.stderr
@@ -26,7 +26,7 @@ LL | #[lang = "fn"]
|
= help: add `#![feature(lang_items)]` to the crate attributes to enable
-warning: anonymous parameters are deprecated and will be removed in the next edition.
+warning: anonymous parameters are deprecated and will be removed in the next edition
--> $DIR/issue-83471.rs:15:13
|
LL | fn call(export_name);
diff --git a/src/test/ui/lint/issue-87308.rs b/src/test/ui/lint/issue-87308.rs
new file mode 100644
index 0000000000000..48fbb2a0139f0
--- /dev/null
+++ b/src/test/ui/lint/issue-87308.rs
@@ -0,0 +1,12 @@
+// Regression test for issue #87308.
+
+// compile-flags: -Zunpretty=everybody_loops
+// check-pass
+
+macro_rules! foo {
+ () => { break 'x; }
+}
+
+pub fn main() {
+ 'x: loop { foo!() }
+}
diff --git a/src/test/ui/lint/issue-87308.stdout b/src/test/ui/lint/issue-87308.stdout
new file mode 100644
index 0000000000000..68a076c93be61
--- /dev/null
+++ b/src/test/ui/lint/issue-87308.stdout
@@ -0,0 +1,14 @@
+#![feature(prelude_import)]
+#![no_std]
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+#[macro_use]
+extern crate std;
+// Regression test for issue #87308.
+
+// compile-flags: -Zunpretty=everybody_loops
+// check-pass
+
+macro_rules! foo { () => { break 'x ; } }
+
+pub fn main() { loop { } }
diff --git a/src/test/ui/lint/must_not_suspend/mutex.stderr b/src/test/ui/lint/must_not_suspend/mutex.stderr
index 4e0d9343c2c71..093f581264f36 100644
--- a/src/test/ui/lint/must_not_suspend/mutex.stderr
+++ b/src/test/ui/lint/must_not_suspend/mutex.stderr
@@ -11,7 +11,7 @@ note: the lint level is defined here
|
LL | #![deny(must_not_suspend)]
| ^^^^^^^^^^^^^^^^
-note: Holding a MutexGuard across suspend points can cause deadlocks, delays, and cause Futures to not implement `Send`
+note: holding a MutexGuard across suspend points can cause deadlocks, delays, and cause Futures to not implement `Send`
--> $DIR/mutex.rs:7:9
|
LL | let _guard = m.lock().unwrap();
diff --git a/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.rs b/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.rs
index 7ee9c41f6a091..9d837d41f101f 100644
--- a/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.rs
+++ b/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.rs
@@ -1,14 +1,14 @@
#![deny(mixed_script_confusables)]
struct ΑctuallyNotLatin;
-//~^ ERROR The usage of Script Group `Greek` in this crate consists solely of
+//~^ ERROR the usage of Script Group `Greek` in this crate consists solely of
fn main() {
let v = ΑctuallyNotLatin;
}
mod роре {
-//~^ ERROR The usage of Script Group `Cyrillic` in this crate consists solely of
+//~^ ERROR the usage of Script Group `Cyrillic` in this crate consists solely of
const エ: &'static str = "アイウ";
- //~^ ERROR The usage of Script Group `Japanese, Katakana` in this crate consists solely of
+ //~^ ERROR the usage of Script Group `Japanese, Katakana` in this crate consists solely of
}
diff --git a/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.stderr b/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.stderr
index 4018b381fb8c5..9ca034b71b2a7 100644
--- a/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.stderr
+++ b/src/test/ui/lint/rfc-2457-non-ascii-idents/lint-mixed-script-confusables.stderr
@@ -1,4 +1,4 @@
-error: The usage of Script Group `Greek` in this crate consists solely of mixed script confusables
+error: the usage of Script Group `Greek` in this crate consists solely of mixed script confusables
--> $DIR/lint-mixed-script-confusables.rs:3:8
|
LL | struct ΑctuallyNotLatin;
@@ -9,26 +9,26 @@ note: the lint level is defined here
|
LL | #![deny(mixed_script_confusables)]
| ^^^^^^^^^^^^^^^^^^^^^^^^
- = note: The usage includes 'Α' (U+0391).
- = note: Please recheck to make sure their usages are indeed what you want.
+ = note: the usage includes 'Α' (U+0391)
+ = note: please recheck to make sure their usages are indeed what you want
-error: The usage of Script Group `Cyrillic` in this crate consists solely of mixed script confusables
+error: the usage of Script Group `Cyrillic` in this crate consists solely of mixed script confusables
--> $DIR/lint-mixed-script-confusables.rs:10:5
|
LL | mod роре {
| ^^^^
|
- = note: The usage includes 'е' (U+0435), 'о' (U+043E), 'р' (U+0440).
- = note: Please recheck to make sure their usages are indeed what you want.
+ = note: the usage includes 'е' (U+0435), 'о' (U+043E), 'р' (U+0440)
+ = note: please recheck to make sure their usages are indeed what you want
-error: The usage of Script Group `Japanese, Katakana` in this crate consists solely of mixed script confusables
+error: the usage of Script Group `Japanese, Katakana` in this crate consists solely of mixed script confusables
--> $DIR/lint-mixed-script-confusables.rs:12:11
|
LL | const エ: &'static str = "アイウ";
| ^^
|
- = note: The usage includes 'エ' (U+30A8).
- = note: Please recheck to make sure their usages are indeed what you want.
+ = note: the usage includes 'エ' (U+30A8)
+ = note: please recheck to make sure their usages are indeed what you want
error: aborting due to 3 previous errors
diff --git a/src/test/ui/macros/macros-nonfatal-errors.stderr b/src/test/ui/macros/macros-nonfatal-errors.stderr
index 00c23d501a1c5..a52f415dcac51 100644
--- a/src/test/ui/macros/macros-nonfatal-errors.stderr
+++ b/src/test/ui/macros/macros-nonfatal-errors.stderr
@@ -138,7 +138,7 @@ error: inline assembly must be a string literal
LL | llvm_asm!(invalid);
| ^^^^^^^
-error: concat_idents! requires ident args.
+error: concat_idents! requires ident args
--> $DIR/macros-nonfatal-errors.rs:102:5
|
LL | concat_idents!("not", "idents");
diff --git a/src/test/ui/missing/missing-alloc_error_handler.stderr b/src/test/ui/missing/missing-alloc_error_handler.stderr
index 511d0788b40a7..ed84493deb563 100644
--- a/src/test/ui/missing/missing-alloc_error_handler.stderr
+++ b/src/test/ui/missing/missing-alloc_error_handler.stderr
@@ -1,6 +1,6 @@
-error: `#[alloc_error_handler]` function required, but not found.
+error: `#[alloc_error_handler]` function required, but not found
-note: Use `#![feature(default_alloc_error_handler)]` for a default error handler.
+note: Use `#![feature(default_alloc_error_handler)]` for a default error handler
error: aborting due to previous error
diff --git a/src/test/ui/missing/missing-allocator.stderr b/src/test/ui/missing/missing-allocator.stderr
index 59648c42a5f31..0da5651c18cb1 100644
--- a/src/test/ui/missing/missing-allocator.stderr
+++ b/src/test/ui/missing/missing-allocator.stderr
@@ -1,4 +1,4 @@
-error: no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait.
+error: no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait
error: aborting due to previous error
diff --git a/src/test/ui/never_type/defaulted-never-note.fallback.stderr b/src/test/ui/never_type/defaulted-never-note.fallback.stderr
index 588d644c77b0d..a51edb1f09a94 100644
--- a/src/test/ui/never_type/defaulted-never-note.fallback.stderr
+++ b/src/test/ui/never_type/defaulted-never-note.fallback.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `!: ImplementedForUnitButNotNever` is not satisfie
LL | foo(_x);
| ^^^ the trait `ImplementedForUnitButNotNever` is not implemented for `!`
|
- = note: this trait is implemented for `()`.
+ = note: this trait is implemented for `()`
= note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #48950 <https://github.com/rust-lang/rust/issues/48950> for more information).
= help: did you intend to use the type `()` here instead?
note: required by a bound in `foo`
diff --git a/src/test/ui/never_type/diverging-fallback-no-leak.fallback.stderr b/src/test/ui/never_type/diverging-fallback-no-leak.fallback.stderr
index 3a5b602f1118f..ce5bbfc249ebc 100644
--- a/src/test/ui/never_type/diverging-fallback-no-leak.fallback.stderr
+++ b/src/test/ui/never_type/diverging-fallback-no-leak.fallback.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `!: Test` is not satisfied
LL | unconstrained_arg(return);
| ^^^^^^^^^^^^^^^^^ the trait `Test` is not implemented for `!`
|
- = note: this trait is implemented for `()`.
+ = note: this trait is implemented for `()`
= note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #48950 <https://github.com/rust-lang/rust/issues/48950> for more information).
= help: did you intend to use the type `()` here instead?
note: required by a bound in `unconstrained_arg`
diff --git a/src/test/ui/parser/issue-89388.rs b/src/test/ui/parser/issue-89388.rs
new file mode 100644
index 0000000000000..9153c071e8e1a
--- /dev/null
+++ b/src/test/ui/parser/issue-89388.rs
@@ -0,0 +1,7 @@
+// Regression test for #89388.
+
+fn main() {
+ let option: Option<&[u8]> = Some(b"...");
+ let _ = option.map([_]::to_vec);
+ //~^ ERROR: missing angle brackets in associated item path
+}
diff --git a/src/test/ui/parser/issue-89388.stderr b/src/test/ui/parser/issue-89388.stderr
new file mode 100644
index 0000000000000..cf28bef0f4ab0
--- /dev/null
+++ b/src/test/ui/parser/issue-89388.stderr
@@ -0,0 +1,8 @@
+error: missing angle brackets in associated item path
+ --> $DIR/issue-89388.rs:5:24
+ |
+LL | let _ = option.map([_]::to_vec);
+ | ^^^^^^^^^^^ help: try: `<[_]>::to_vec`
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/parser/trait-object-delimiters.stderr b/src/test/ui/parser/trait-object-delimiters.stderr
index ee638d8a4f5ec..75eeeda864607 100644
--- a/src/test/ui/parser/trait-object-delimiters.stderr
+++ b/src/test/ui/parser/trait-object-delimiters.stderr
@@ -52,7 +52,7 @@ LL | fn foo1(_: &dyn Drop + AsRef<str>) {}
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Drop + AsRef<str> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Drop + AsRef<str> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0224]: at least one trait is required for an object type
@@ -69,7 +69,7 @@ LL | fn foo5(_: &(dyn Drop + dyn AsRef<str>)) {}
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Drop + AsRef<str> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Drop + AsRef<str> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 9 previous errors
diff --git a/src/test/ui/parser/trait-object-trait-parens.stderr b/src/test/ui/parser/trait-object-trait-parens.stderr
index b39fe4646a3cc..657288c70f387 100644
--- a/src/test/ui/parser/trait-object-trait-parens.stderr
+++ b/src/test/ui/parser/trait-object-trait-parens.stderr
@@ -52,7 +52,7 @@ LL | let _: Box<(Obj) + (?Sized) + (for<'a> Trait<'a>)>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + for<'a> Trait<'a> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + for<'a> Trait<'a> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -63,7 +63,7 @@ LL | let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: for<'a> Trait<'a> + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: for<'a> Trait<'a> + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -74,7 +74,7 @@ LL | let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: for<'a> Trait<'a> + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: for<'a> Trait<'a> + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 6 previous errors; 3 warnings emitted
diff --git a/src/test/ui/rfc-1717-dllimport/missing-link-attr.stderr b/src/test/ui/rfc-1717-dllimport/missing-link-attr.stderr
index d836741f9eddf..d4410e147503a 100644
--- a/src/test/ui/rfc-1717-dllimport/missing-link-attr.stderr
+++ b/src/test/ui/rfc-1717-dllimport/missing-link-attr.stderr
@@ -1,4 +1,4 @@
-error: renaming of the library `foo` was specified, however this crate contains no `#[link(...)]` attributes referencing this library.
+error: renaming of the library `foo` was specified, however this crate contains no `#[link(...)]` attributes referencing this library
error: aborting due to previous error
diff --git a/src/test/ui/rfc-1717-dllimport/multiple-renames.stderr b/src/test/ui/rfc-1717-dllimport/multiple-renames.stderr
index 4e5a3647fa2d2..a6fec9c4e2b5f 100644
--- a/src/test/ui/rfc-1717-dllimport/multiple-renames.stderr
+++ b/src/test/ui/rfc-1717-dllimport/multiple-renames.stderr
@@ -1,4 +1,4 @@
-error: multiple renamings were specified for library `foo` .
+error: multiple renamings were specified for library `foo`
error: aborting due to previous error
diff --git a/src/test/ui/rfc-2457/extern_block_nonascii_forbidden.stderr b/src/test/ui/rfc-2457/extern_block_nonascii_forbidden.stderr
index ab8832e916315..ca1b8a6e7b9b2 100644
--- a/src/test/ui/rfc-2457/extern_block_nonascii_forbidden.stderr
+++ b/src/test/ui/rfc-2457/extern_block_nonascii_forbidden.stderr
@@ -6,7 +6,7 @@ LL | extern "C" {
LL | type 一;
| ^^
|
- = note: This limitation may be lifted in the future; see issue #83942 <https://github.com/rust-lang/rust/issues/83942> for more information
+ = note: this limitation may be lifted in the future; see issue #83942 <https://github.com/rust-lang/rust/issues/83942> for more information
error: items in `extern` blocks cannot use non-ascii identifiers
--> $DIR/extern_block_nonascii_forbidden.rs:5:8
@@ -17,7 +17,7 @@ LL | type 一;
LL | fn 二();
| ^^
|
- = note: This limitation may be lifted in the future; see issue #83942 <https://github.com/rust-lang/rust/issues/83942> for more information
+ = note: this limitation may be lifted in the future; see issue #83942 <https://github.com/rust-lang/rust/issues/83942> for more information
error: items in `extern` blocks cannot use non-ascii identifiers
--> $DIR/extern_block_nonascii_forbidden.rs:6:12
@@ -28,7 +28,7 @@ LL | extern "C" {
LL | static 三: usize;
| ^^
|
- = note: This limitation may be lifted in the future; see issue #83942 <https://github.com/rust-lang/rust/issues/83942> for more information
+ = note: this limitation may be lifted in the future; see issue #83942 <https://github.com/rust-lang/rust/issues/83942> for more information
error: aborting due to 3 previous errors
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const-drop.rs b/src/test/ui/rfc-2632-const-trait-impl/const-drop.rs
index 9a1b554f45f65..292017a1de24d 100644
--- a/src/test/ui/rfc-2632-const-trait-impl/const-drop.rs
+++ b/src/test/ui/rfc-2632-const-trait-impl/const-drop.rs
@@ -3,7 +3,6 @@
#![feature(const_trait_impl)]
#![feature(const_fn_trait_bound)]
#![feature(const_mut_refs)]
-#![feature(const_panic)]
#![cfg_attr(precise, feature(const_precise_live_drops))]
struct S<'a>(&'a mut u8);
diff --git a/src/test/ui/sanitize/crt-static.stderr b/src/test/ui/sanitize/crt-static.stderr
index 3a9c636d76046..9f74235fea5d2 100644
--- a/src/test/ui/sanitize/crt-static.stderr
+++ b/src/test/ui/sanitize/crt-static.stderr
@@ -1,4 +1,4 @@
-error: Sanitizer is incompatible with statically linked libc, disable it using `-C target-feature=-crt-static`
+error: sanitizer is incompatible with statically linked libc, disable it using `-C target-feature=-crt-static`
error: aborting due to previous error
diff --git a/src/test/ui/specialization/README-rpass.md b/src/test/ui/specialization/README-rpass.md
index 1373a2cf81b3a..c1486ce1ee821 100644
--- a/src/test/ui/specialization/README-rpass.md
+++ b/src/test/ui/specialization/README-rpass.md
@@ -8,7 +8,7 @@ Tests that specialization is working correctly:
- Specialization via concrete types vs unknown types
- In top level of the trait reference
- Embedded within another type (`Vec<T>` vs `Vec<i32>`)
- - [Specialization based on super trait relationships](specialization-super-traits.rs)
+ - [Specialization based on super trait relationships](specialization-supertraits.rs)
- [On assoc fns](specialization-assoc-fns.rs)
- [Ensure that impl order doesn't matter](specialization-out-of-order.rs)
diff --git a/src/test/ui/specialization/specialization-super-traits.rs b/src/test/ui/specialization/specialization-supertraits.rs
similarity index 100%
rename from src/test/ui/specialization/specialization-super-traits.rs
rename to src/test/ui/specialization/specialization-supertraits.rs
diff --git a/src/test/ui/specialization/specialization-super-traits.stderr b/src/test/ui/specialization/specialization-supertraits.stderr
similarity index 90%
rename from src/test/ui/specialization/specialization-super-traits.stderr
rename to src/test/ui/specialization/specialization-supertraits.stderr
index 165703d636574..d32e47a24c2c8 100644
--- a/src/test/ui/specialization/specialization-super-traits.stderr
+++ b/src/test/ui/specialization/specialization-supertraits.stderr
@@ -1,5 +1,5 @@
warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
- --> $DIR/specialization-super-traits.rs:3:12
+ --> $DIR/specialization-supertraits.rs:3:12
|
LL | #![feature(specialization)]
| ^^^^^^^^^^^^^^
diff --git a/src/test/ui/test-attrs/test-should-panic-attr.stderr b/src/test/ui/test-attrs/test-should-panic-attr.stderr
index 375ee79ca5ab7..492d1d5e03a4b 100644
--- a/src/test/ui/test-attrs/test-should-panic-attr.stderr
+++ b/src/test/ui/test-attrs/test-should-panic-attr.stderr
@@ -4,7 +4,7 @@ warning: argument must be of the form: `expected = "error message"`
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
@@ -12,7 +12,7 @@ warning: argument must be of the form: `expected = "error message"`
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
@@ -20,7 +20,7 @@ warning: argument must be of the form: `expected = "error message"`
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
@@ -28,7 +28,7 @@ warning: argument must be of the form: `expected = "error message"`
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: 4 warnings emitted
diff --git a/src/test/ui/traits/alias/no-duplicates.stderr b/src/test/ui/traits/alias/no-duplicates.stderr
index 9f38dd40c3acb..d3002db46a22e 100644
--- a/src/test/ui/traits/alias/no-duplicates.stderr
+++ b/src/test/ui/traits/alias/no-duplicates.stderr
@@ -12,7 +12,7 @@ LL | type _T00 = dyn _0 + _0;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -31,7 +31,7 @@ LL | type _T01 = dyn _1 + _0;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -53,7 +53,7 @@ LL | type _T02 = dyn _1 + _1;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -69,7 +69,7 @@ LL | type _T03 = dyn Obj + _1;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -85,7 +85,7 @@ LL | type _T04 = dyn _1 + Obj;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -110,7 +110,7 @@ LL | type _T10 = dyn _2 + _3;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -129,7 +129,7 @@ LL | type _T11 = dyn _3 + _2;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -146,7 +146,7 @@ LL | type _T12 = dyn Obj + _2;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -171,7 +171,7 @@ LL | type _T13 = dyn _2 + Obj;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -190,7 +190,7 @@ LL | type _T14 = dyn _1 + _3;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -209,7 +209,7 @@ LL | type _T15 = dyn _3 + _1;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -230,7 +230,7 @@ LL | type _T16 = dyn _1 + _4;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -251,7 +251,7 @@ LL | type _T17 = dyn _4 + _1;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -268,7 +268,7 @@ LL | type _T20 = dyn _5 + _5;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -282,7 +282,7 @@ LL | type _T21 = dyn Obj + _5;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -296,7 +296,7 @@ LL | type _T22 = dyn _5 + Obj;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -310,7 +310,7 @@ LL | type _T23 = dyn _5 + Send + Sync + Obj;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -333,7 +333,7 @@ LL | type _T30 = dyn _6;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -356,7 +356,7 @@ LL | type _T31 = dyn _6 + Send;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -379,7 +379,7 @@ LL | type _T32 = dyn Send + _6;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -398,7 +398,7 @@ LL | type _T40 = dyn _8 + Obj;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -417,7 +417,7 @@ LL | type _T41 = dyn Obj + _8;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -441,7 +441,7 @@ LL | type _T42 = dyn _8 + _4;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -465,7 +465,7 @@ LL | type _T43 = dyn _4 + _8;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -489,7 +489,7 @@ LL | type _T44 = dyn _4 + Send + Sync + _8;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -504,7 +504,7 @@ LL | type _T50 = dyn _9 + _10;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: for<'a> ObjL<'a> + for<'b> ObjL<'b> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: for<'a> ObjL<'a> + for<'b> ObjL<'b> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -519,7 +519,7 @@ LL | type _T60 = dyn _11 + _12;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 27 previous errors
diff --git a/src/test/ui/traits/alias/no-extra-traits.stderr b/src/test/ui/traits/alias/no-extra-traits.stderr
index cdb5cd90b85c6..eaba70d7ce395 100644
--- a/src/test/ui/traits/alias/no-extra-traits.stderr
+++ b/src/test/ui/traits/alias/no-extra-traits.stderr
@@ -9,7 +9,7 @@ LL | type _T00 = dyn _0 + ObjB;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -23,7 +23,7 @@ LL | type _T01 = dyn ObjB + _0;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -39,7 +39,7 @@ LL | type _T02 = dyn ObjB + _1;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -55,7 +55,7 @@ LL | type _T03 = dyn _1 + ObjB;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -74,7 +74,7 @@ LL | type _T10 = dyn _2 + _3;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -93,7 +93,7 @@ LL | type _T11 = dyn _3 + _2;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -114,7 +114,7 @@ LL | type _T12 = dyn _2 + _4;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -135,7 +135,7 @@ LL | type _T13 = dyn _4 + _2;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -154,7 +154,7 @@ LL | type _T20 = dyn _5 + _1;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -173,7 +173,7 @@ LL | type _T21 = dyn _1 + _5;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -187,7 +187,7 @@ LL | type _T22 = dyn _5 + ObjA;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -201,7 +201,7 @@ LL | type _T23 = dyn ObjA + _5;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -220,7 +220,7 @@ LL | type _T24 = dyn Send + _5 + _1 + Sync;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -239,7 +239,7 @@ LL | type _T25 = dyn _1 + Sync + _5 + Send;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -253,7 +253,7 @@ LL | type _T26 = dyn Sync + Send + _5 + ObjA;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -267,7 +267,7 @@ LL | type _T27 = dyn Send + Sync + ObjA + _5;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -292,7 +292,7 @@ LL | type _T30 = dyn _6;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -317,7 +317,7 @@ LL | type _T31 = dyn _6 + Send;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -342,7 +342,7 @@ LL | type _T32 = dyn Send + _6;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -377,7 +377,7 @@ LL | type _T33 = dyn _8;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -412,7 +412,7 @@ LL | type _T34 = dyn _8 + Send;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -447,7 +447,7 @@ LL | type _T35 = dyn Send + _8;
| trait alias used in trait object type (additional use)
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -466,7 +466,7 @@ LL | type _T40 = dyn _10 + ObjA;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -485,7 +485,7 @@ LL | type _T41 = dyn ObjA + _10;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -509,7 +509,7 @@ LL | type _T42 = dyn _10 + _1;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -528,7 +528,7 @@ LL | type _T43 = dyn Send + _10 + Sync + ObjA;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -547,7 +547,7 @@ LL | type _T44 = dyn ObjA + _10 + Send + Sync;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -571,7 +571,7 @@ LL | type _T45 = dyn Sync + Send + _10 + _1;
| |
| trait alias used in trait object type (first use)
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 28 previous errors
diff --git a/src/test/ui/traits/bad-sized.stderr b/src/test/ui/traits/bad-sized.stderr
index 1322b66003527..5421e71509f3a 100644
--- a/src/test/ui/traits/bad-sized.stderr
+++ b/src/test/ui/traits/bad-sized.stderr
@@ -6,7 +6,7 @@ LL | let x: Vec<dyn Trait + Sized> = Vec::new();
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Trait + Sized {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Trait + Sized {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0277]: the size for values of type `dyn Trait` cannot be known at compilation time
diff --git a/src/test/ui/traits/normalize-super-trait.rs b/src/test/ui/traits/normalize-supertrait.rs
similarity index 100%
rename from src/test/ui/traits/normalize-super-trait.rs
rename to src/test/ui/traits/normalize-supertrait.rs
diff --git a/src/test/ui/traits/vtable/vtable-diamond.rs b/src/test/ui/traits/vtable/vtable-diamond.rs
index f64ae95f1d4dd..ec25e8a707111 100644
--- a/src/test/ui/traits/vtable/vtable-diamond.rs
+++ b/src/test/ui/traits/vtable/vtable-diamond.rs
@@ -13,13 +13,13 @@ trait B: A {
#[rustc_dump_vtable]
trait C: A {
- //~^ error Vtable
+ //~^ error vtable
fn foo_c(&self) {}
}
#[rustc_dump_vtable]
trait D: B + C {
- //~^ error Vtable
+ //~^ error vtable
fn foo_d(&self) {}
}
diff --git a/src/test/ui/traits/vtable/vtable-diamond.stderr b/src/test/ui/traits/vtable/vtable-diamond.stderr
index 92a7f29536e3d..f2b64fac3b75e 100644
--- a/src/test/ui/traits/vtable/vtable-diamond.stderr
+++ b/src/test/ui/traits/vtable/vtable-diamond.stderr
@@ -1,4 +1,4 @@
-error: Vtable entries for `<S as D>`: [
+error: vtable entries for `<S as D>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -16,7 +16,7 @@ LL | | fn foo_d(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as C>`: [
+error: vtable entries for `<S as C>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
diff --git a/src/test/ui/traits/vtable/vtable-multi-level.rs b/src/test/ui/traits/vtable/vtable-multi-level.rs
index 33112b4eaaade..fcb5fd5274be4 100644
--- a/src/test/ui/traits/vtable/vtable-multi-level.rs
+++ b/src/test/ui/traits/vtable/vtable-multi-level.rs
@@ -17,7 +17,7 @@ trait A {
#[rustc_dump_vtable]
trait B {
- //~^ error Vtable
+ //~^ error vtable
fn foo_b(&self) {}
}
@@ -28,19 +28,19 @@ trait C: A + B {
#[rustc_dump_vtable]
trait D {
- //~^ error Vtable
+ //~^ error vtable
fn foo_d(&self) {}
}
#[rustc_dump_vtable]
trait E {
- //~^ error Vtable
+ //~^ error vtable
fn foo_e(&self) {}
}
#[rustc_dump_vtable]
trait F: D + E {
- //~^ error Vtable
+ //~^ error vtable
fn foo_f(&self) {}
}
@@ -51,49 +51,49 @@ trait G: C + F {
#[rustc_dump_vtable]
trait H {
- //~^ error Vtable
+ //~^ error vtable
fn foo_h(&self) {}
}
#[rustc_dump_vtable]
trait I {
- //~^ error Vtable
+ //~^ error vtable
fn foo_i(&self) {}
}
#[rustc_dump_vtable]
trait J: H + I {
- //~^ error Vtable
+ //~^ error vtable
fn foo_j(&self) {}
}
#[rustc_dump_vtable]
trait K {
- //~^ error Vtable
+ //~^ error vtable
fn foo_k(&self) {}
}
#[rustc_dump_vtable]
trait L {
- //~^ error Vtable
+ //~^ error vtable
fn foo_l(&self) {}
}
#[rustc_dump_vtable]
trait M: K + L {
- //~^ error Vtable
+ //~^ error vtable
fn foo_m(&self) {}
}
#[rustc_dump_vtable]
trait N: J + M {
- //~^ error Vtable
+ //~^ error vtable
fn foo_n(&self) {}
}
#[rustc_dump_vtable]
trait O: G + N {
- //~^ error Vtable
+ //~^ error vtable
fn foo_o(&self) {}
}
diff --git a/src/test/ui/traits/vtable/vtable-multi-level.stderr b/src/test/ui/traits/vtable/vtable-multi-level.stderr
index 7700db98e0bf1..742b88ea8a9c9 100644
--- a/src/test/ui/traits/vtable/vtable-multi-level.stderr
+++ b/src/test/ui/traits/vtable/vtable-multi-level.stderr
@@ -1,4 +1,4 @@
-error: Vtable entries for `<S as O>`: [
+error: vtable entries for `<S as O>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -37,7 +37,7 @@ LL | | fn foo_o(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as B>`: [
+error: vtable entries for `<S as B>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -51,7 +51,7 @@ LL | | fn foo_b(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as D>`: [
+error: vtable entries for `<S as D>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -65,7 +65,7 @@ LL | | fn foo_d(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as E>`: [
+error: vtable entries for `<S as E>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -79,7 +79,7 @@ LL | | fn foo_e(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as F>`: [
+error: vtable entries for `<S as F>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -96,7 +96,7 @@ LL | | fn foo_f(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as H>`: [
+error: vtable entries for `<S as H>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -110,7 +110,7 @@ LL | | fn foo_h(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as I>`: [
+error: vtable entries for `<S as I>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -124,7 +124,7 @@ LL | | fn foo_i(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as J>`: [
+error: vtable entries for `<S as J>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -141,7 +141,7 @@ LL | | fn foo_j(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as K>`: [
+error: vtable entries for `<S as K>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -155,7 +155,7 @@ LL | | fn foo_k(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as L>`: [
+error: vtable entries for `<S as L>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -169,7 +169,7 @@ LL | | fn foo_l(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as M>`: [
+error: vtable entries for `<S as M>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -186,7 +186,7 @@ LL | | fn foo_m(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as N>`: [
+error: vtable entries for `<S as N>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
diff --git a/src/test/ui/traits/vtable/vtable-multiple.rs b/src/test/ui/traits/vtable/vtable-multiple.rs
index cb0d0b7248190..8e7098a495ed1 100644
--- a/src/test/ui/traits/vtable/vtable-multiple.rs
+++ b/src/test/ui/traits/vtable/vtable-multiple.rs
@@ -8,13 +8,13 @@ trait A {
#[rustc_dump_vtable]
trait B {
- //~^ error Vtable
+ //~^ error vtable
fn foo_b(&self) {}
}
#[rustc_dump_vtable]
trait C: A + B {
- //~^ error Vtable
+ //~^ error vtable
fn foo_c(&self) {}
}
diff --git a/src/test/ui/traits/vtable/vtable-multiple.stderr b/src/test/ui/traits/vtable/vtable-multiple.stderr
index f51b083de2515..f25ac76fbe069 100644
--- a/src/test/ui/traits/vtable/vtable-multiple.stderr
+++ b/src/test/ui/traits/vtable/vtable-multiple.stderr
@@ -1,4 +1,4 @@
-error: Vtable entries for `<S as C>`: [
+error: vtable entries for `<S as C>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
@@ -15,7 +15,7 @@ LL | | fn foo_c(&self) {}
LL | | }
| |_^
-error: Vtable entries for `<S as B>`: [
+error: vtable entries for `<S as B>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
diff --git a/src/test/ui/traits/vtable/vtable-non-object-safe.rs b/src/test/ui/traits/vtable/vtable-non-object-safe.rs
index 45b6a8a98a79f..7661bb574613b 100644
--- a/src/test/ui/traits/vtable/vtable-non-object-safe.rs
+++ b/src/test/ui/traits/vtable/vtable-non-object-safe.rs
@@ -6,7 +6,7 @@
#[rustc_dump_vtable]
trait A: Iterator {}
-//~^ error Vtable
+//~^ error vtable
impl<T> A for T where T: Iterator {}
diff --git a/src/test/ui/traits/vtable/vtable-non-object-safe.stderr b/src/test/ui/traits/vtable/vtable-non-object-safe.stderr
index f3175b805d1b6..34fe910525be1 100644
--- a/src/test/ui/traits/vtable/vtable-non-object-safe.stderr
+++ b/src/test/ui/traits/vtable/vtable-non-object-safe.stderr
@@ -1,4 +1,4 @@
-error: Vtable entries for `<std::vec::IntoIter<u8> as A>`: [
+error: vtable entries for `<std::vec::IntoIter<u8> as A>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
diff --git a/src/test/ui/traits/vtable/vtable-vacant.rs b/src/test/ui/traits/vtable/vtable-vacant.rs
index 429ce523799f3..a64796358345f 100644
--- a/src/test/ui/traits/vtable/vtable-vacant.rs
+++ b/src/test/ui/traits/vtable/vtable-vacant.rs
@@ -13,7 +13,7 @@ trait A {
#[rustc_dump_vtable]
trait B: A {
- //~^ error Vtable
+ //~^ error vtable
fn foo_b1(&self) {}
fn foo_b2(&self) where Self: Send {}
}
diff --git a/src/test/ui/traits/vtable/vtable-vacant.stderr b/src/test/ui/traits/vtable/vtable-vacant.stderr
index f5cd36264fcff..e3b75e7cf33f3 100644
--- a/src/test/ui/traits/vtable/vtable-vacant.stderr
+++ b/src/test/ui/traits/vtable/vtable-vacant.stderr
@@ -1,4 +1,4 @@
-error: Vtable entries for `<S as B>`: [
+error: vtable entries for `<S as B>`: [
MetadataDropInPlace,
MetadataSize,
MetadataAlign,
diff --git a/src/test/ui/traits/wf-object/no-duplicates.stderr b/src/test/ui/traits/wf-object/no-duplicates.stderr
index b9506894f82c9..50dfcf956362e 100644
--- a/src/test/ui/traits/wf-object/no-duplicates.stderr
+++ b/src/test/ui/traits/wf-object/no-duplicates.stderr
@@ -6,7 +6,7 @@ LL | type _0 = dyn Obj + Obj;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -17,7 +17,7 @@ LL | type _1 = dyn Send + Obj + Obj;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -28,7 +28,7 @@ LL | type _2 = dyn Obj + Send + Obj;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -39,7 +39,7 @@ LL | type _4 = dyn for<'a> ObjL<'a> + for<'b> ObjL<'b>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: for<'a> ObjL<'a> + for<'b> ObjL<'b> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: for<'a> ObjL<'a> + for<'b> ObjL<'b> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
@@ -50,7 +50,7 @@ LL | type _5 = dyn ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)>;
| |
| first non-auto trait
|
- = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)> {}`
+ = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 5 previous errors
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-copy.stderr b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-copy.stderr
index 7bd951febf5c5..1e26623899bad 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-copy.stderr
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-copy.stderr
@@ -1,4 +1,4 @@
-warning: Trait bound String: Copy does not depend on any type or lifetime parameters
+warning: trait bound String: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-copy.rs:5:51
|
LL | fn copy_string(t: String) -> String where String: Copy {
@@ -6,19 +6,19 @@ LL | fn copy_string(t: String) -> String where String: Copy {
|
= note: `#[warn(trivial_bounds)]` on by default
-warning: Trait bound String: Copy does not depend on any type or lifetime parameters
+warning: trait bound String: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-copy.rs:12:56
|
LL | fn copy_out_string(t: &String) -> String where String: Copy {
| ^^^^
-warning: Trait bound String: Copy does not depend on any type or lifetime parameters
+warning: trait bound String: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-copy.rs:16:55
|
LL | fn copy_string_with_param<T>(x: String) where String: Copy {
| ^^^^
-warning: Trait bound for<'b> &'b mut i32: Copy does not depend on any type or lifetime parameters
+warning: trait bound for<'b> &'b mut i32: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-copy.rs:22:76
|
LL | fn copy_mut<'a>(t: &&'a mut i32) -> &'a mut i32 where for<'b> &'b mut i32: Copy {
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-projection.stderr b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-projection.stderr
index e7835814cb83e..ddc13c512f60f 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-projection.stderr
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-projection.stderr
@@ -1,4 +1,4 @@
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:21:8
|
LL | B: A
@@ -6,37 +6,37 @@ LL | B: A
|
= note: `#[warn(trivial_bounds)]` on by default
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:28:8
|
LL | B: A<X = i32>
| ^^^^^^^^^^
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:35:8
|
LL | B: A<X = u8>
| ^^^^^^^^^
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:42:8
|
LL | B: A<X = i32> + A
| ^^^^^^^^^^
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:42:21
|
LL | B: A<X = i32> + A
| ^
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:51:8
|
LL | B: A<X = u8> + A
| ^^^^^^^^^
-warning: Trait bound B: A does not depend on any type or lifetime parameters
+warning: trait bound B: A does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-projection.rs:51:20
|
LL | B: A<X = u8> + A
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-sized.stderr b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-sized.stderr
index ff254edbd7b0c..cf24d811c04e3 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-sized.stderr
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-sized.stderr
@@ -1,4 +1,4 @@
-warning: Trait bound str: Sized does not depend on any type or lifetime parameters
+warning: trait bound str: Sized does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-sized.rs:14:31
|
LL | struct S(str, str) where str: Sized;
@@ -6,13 +6,13 @@ LL | struct S(str, str) where str: Sized;
|
= note: `#[warn(trivial_bounds)]` on by default
-warning: Trait bound for<'a> T<(dyn A + 'a)>: Sized does not depend on any type or lifetime parameters
+warning: trait bound for<'a> T<(dyn A + 'a)>: Sized does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-sized.rs:17:49
|
LL | fn unsized_local() where for<'a> T<dyn A + 'a>: Sized {
| ^^^^^
-warning: Trait bound str: Sized does not depend on any type or lifetime parameters
+warning: trait bound str: Sized does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-sized.rs:22:35
|
LL | fn return_str() -> str where str: Sized {
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-well-formed.stderr b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-well-formed.stderr
index a9905052ffdfb..8f58a99a86f91 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-well-formed.stderr
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent-well-formed.stderr
@@ -1,4 +1,4 @@
-warning: Trait bound Vec<str>: Debug does not depend on any type or lifetime parameters
+warning: trait bound Vec<str>: Debug does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-well-formed.rs:7:30
|
LL | pub fn foo() where Vec<str>: Debug, str: Copy {
@@ -6,7 +6,7 @@ LL | pub fn foo() where Vec<str>: Debug, str: Copy {
|
= note: `#[warn(trivial_bounds)]` on by default
-warning: Trait bound str: Copy does not depend on any type or lifetime parameters
+warning: trait bound str: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent-well-formed.rs:7:42
|
LL | pub fn foo() where Vec<str>: Debug, str: Copy {
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent.stderr b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent.stderr
index 94c51c5788a32..16f32e043d500 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-inconsistent.stderr
+++ b/src/test/ui/trivial-bounds/trivial-bounds-inconsistent.stderr
@@ -1,4 +1,4 @@
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:14:19
|
LL | enum E where i32: Foo { V }
@@ -6,19 +6,19 @@ LL | enum E where i32: Foo { V }
|
= note: `#[warn(trivial_bounds)]` on by default
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:16:21
|
LL | struct S where i32: Foo;
| ^^^
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:18:20
|
LL | trait T where i32: Foo {}
| ^^^
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:20:20
|
LL | union U where i32: Foo { f: i32 }
@@ -37,55 +37,55 @@ LL - type Y where i32: Foo = ();
LL + type Y = ();
|
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:22:19
|
LL | type Y where i32: Foo = ();
| ^^^
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:26:28
|
LL | impl Foo for () where i32: Foo {
| ^^^
-warning: Trait bound i32: Foo does not depend on any type or lifetime parameters
+warning: trait bound i32: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:34:19
|
LL | fn f() where i32: Foo {
| ^^^
-warning: Trait bound &'static str: Foo does not depend on any type or lifetime parameters
+warning: trait bound &'static str: Foo does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:41:28
|
LL | fn g() where &'static str: Foo {
| ^^^
-warning: Trait bound str: Sized does not depend on any type or lifetime parameters
+warning: trait bound str: Sized does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:55:37
|
LL | struct TwoStrs(str, str) where str: Sized;
| ^^^^^
-warning: Trait bound for<'a> Dst<(dyn A + 'a)>: Sized does not depend on any type or lifetime parameters
+warning: trait bound for<'a> Dst<(dyn A + 'a)>: Sized does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:57:51
|
LL | fn unsized_local() where for<'a> Dst<dyn A + 'a>: Sized {
| ^^^^^
-warning: Trait bound str: Sized does not depend on any type or lifetime parameters
+warning: trait bound str: Sized does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:61:35
|
LL | fn return_str() -> str where str: Sized {
| ^^^^^
-warning: Trait bound String: Neg does not depend on any type or lifetime parameters
+warning: trait bound String: Neg does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:65:46
|
LL | fn use_op(s: String) -> String where String: ::std::ops::Neg<Output=String> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-warning: Trait bound i32: Iterator does not depend on any type or lifetime parameters
+warning: trait bound i32: Iterator does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-inconsistent.rs:70:25
|
LL | fn use_for() where i32: Iterator {
diff --git a/src/test/ui/trivial-bounds/trivial-bounds-lint.stderr b/src/test/ui/trivial-bounds/trivial-bounds-lint.stderr
index c685d9e740919..20e0ddfc29b36 100644
--- a/src/test/ui/trivial-bounds/trivial-bounds-lint.stderr
+++ b/src/test/ui/trivial-bounds/trivial-bounds-lint.stderr
@@ -1,4 +1,4 @@
-error: Trait bound i32: Copy does not depend on any type or lifetime parameters
+error: trait bound i32: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:5:21
|
LL | struct A where i32: Copy;
@@ -10,37 +10,37 @@ note: the lint level is defined here
LL | #![deny(trivial_bounds)]
| ^^^^^^^^^^^^^^
-error: Trait bound i32: X<()> does not depend on any type or lifetime parameters
+error: trait bound i32: X<()> does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:18:30
|
LL | fn global_param() where i32: X<()> {}
| ^^^^^
-error: Trait bound i32: Z does not depend on any type or lifetime parameters
+error: trait bound i32: Z does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:22:35
|
LL | fn global_projection() where i32: Z<S = i32> {}
| ^^^^^^^^^^
-error: Lifetime bound i32: 'static does not depend on any type or lifetime parameters
+error: lifetime bound i32: 'static does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:29:34
|
LL | fn global_lifetimes() where i32: 'static, &'static str: 'static {}
| ^^^^^^^
-error: Lifetime bound &'static str: 'static does not depend on any type or lifetime parameters
+error: lifetime bound &'static str: 'static does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:29:57
|
LL | fn global_lifetimes() where i32: 'static, &'static str: 'static {}
| ^^^^^^^
-error: Lifetime bound 'static: 'static does not depend on any type or lifetime parameters
+error: lifetime bound 'static: 'static does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:35:37
|
LL | fn global_outlives() where 'static: 'static {}
| ^^^^^^^
-error: Trait bound i32: Copy does not depend on any type or lifetime parameters
+error: trait bound i32: Copy does not depend on any type or lifetime parameters
--> $DIR/trivial-bounds-lint.rs:38:46
|
LL | fn mixed_bounds<T: Copy>() where i32: X<T> + Copy {}
diff --git a/src/test/ui/typeck/issue-87771-ice-assign-assign-to-bool.rs b/src/test/ui/typeck/issue-87771-ice-assign-assign-to-bool.rs
new file mode 100644
index 0000000000000..751dc8719cf33
--- /dev/null
+++ b/src/test/ui/typeck/issue-87771-ice-assign-assign-to-bool.rs
@@ -0,0 +1,4 @@
+fn main() {
+ let mut a;
+ a = a = true; //~ ERROR mismatched types
+}
diff --git a/src/test/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr b/src/test/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr
new file mode 100644
index 0000000000000..fe10fa733d238
--- /dev/null
+++ b/src/test/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr
@@ -0,0 +1,9 @@
+error[E0308]: mismatched types
+ --> $DIR/issue-87771-ice-assign-assign-to-bool.rs:3:9
+ |
+LL | a = a = true;
+ | ^^^^^^^^ expected `bool`, found `()`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.