From 403c8c2fd6205ca0687abde55fbe5af7b325b7d9 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Thu, 21 Nov 2024 03:23:56 -0800
Subject: E0277: suggest dereferencing function arguments in more cases

---
 tests/ui/no_send-rc.stderr                         |  4 +++
 tests/ui/suggestions/issue-84973-blacklist.stderr  |  4 +++
 .../suggest-dereferences/deref-argument.fixed      | 37 ++++++++++++++++++++
 .../traits/suggest-dereferences/deref-argument.rs  | 37 ++++++++++++++++++++
 .../suggest-dereferences/deref-argument.stderr     | 39 ++++++++++++++++++++++
 5 files changed, 121 insertions(+)
 create mode 100644 tests/ui/traits/suggest-dereferences/deref-argument.fixed
 create mode 100644 tests/ui/traits/suggest-dereferences/deref-argument.rs
 create mode 100644 tests/ui/traits/suggest-dereferences/deref-argument.stderr

(limited to 'tests')

diff --git a/tests/ui/no_send-rc.stderr b/tests/ui/no_send-rc.stderr
index 3534167870b..1430a7a29ea 100644
--- a/tests/ui/no_send-rc.stderr
+++ b/tests/ui/no_send-rc.stderr
@@ -12,6 +12,10 @@ note: required by a bound in `bar`
    |
 LL | fn bar<T: Send>(_: T) {}
    |           ^^^^ required by this bound in `bar`
+help: consider dereferencing here
+   |
+LL |     bar(*x);
+   |         +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-84973-blacklist.stderr b/tests/ui/suggestions/issue-84973-blacklist.stderr
index a6324a824c1..3db400418c7 100644
--- a/tests/ui/suggestions/issue-84973-blacklist.stderr
+++ b/tests/ui/suggestions/issue-84973-blacklist.stderr
@@ -86,6 +86,10 @@ note: required by a bound in `f_send`
    |
 LL | fn f_send<T: Send>(t: T) {}
    |              ^^^^ required by this bound in `f_send`
+help: consider dereferencing here
+   |
+LL |     f_send(*rc);
+   |            +
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/traits/suggest-dereferences/deref-argument.fixed b/tests/ui/traits/suggest-dereferences/deref-argument.fixed
new file mode 100644
index 00000000000..8235ae0b628
--- /dev/null
+++ b/tests/ui/traits/suggest-dereferences/deref-argument.fixed
@@ -0,0 +1,37 @@
+//@ run-rustfix
+//! diagnostic test for #90997.
+//! test that E0277 suggests dereferences to satisfy bounds when the referent is `Copy` or boxed.
+use std::ops::Deref;
+
+trait Test {
+    fn test(self);
+}
+fn consume_test(x: impl Test) { x.test() }
+
+impl Test for u32 {
+    fn test(self) {}
+}
+struct MyRef(u32);
+impl Deref for MyRef {
+    type Target = u32;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+struct NonCopy;
+impl Test for NonCopy {
+    fn test(self) {}
+}
+
+fn main() {
+    let my_ref = MyRef(0);
+    consume_test(*my_ref);
+    //~^ ERROR the trait bound `MyRef: Test` is not satisfied
+    //~| SUGGESTION *
+
+    let nested_box = Box::new(Box::new(Box::new(NonCopy)));
+    consume_test(***nested_box);
+    //~^ ERROR the trait bound `Box<Box<Box<NonCopy>>>: Test` is not satisfied
+    //~| SUGGESTION ***
+}
diff --git a/tests/ui/traits/suggest-dereferences/deref-argument.rs b/tests/ui/traits/suggest-dereferences/deref-argument.rs
new file mode 100644
index 00000000000..2f96b75c4e4
--- /dev/null
+++ b/tests/ui/traits/suggest-dereferences/deref-argument.rs
@@ -0,0 +1,37 @@
+//@ run-rustfix
+//! diagnostic test for #90997.
+//! test that E0277 suggests dereferences to satisfy bounds when the referent is `Copy` or boxed.
+use std::ops::Deref;
+
+trait Test {
+    fn test(self);
+}
+fn consume_test(x: impl Test) { x.test() }
+
+impl Test for u32 {
+    fn test(self) {}
+}
+struct MyRef(u32);
+impl Deref for MyRef {
+    type Target = u32;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+struct NonCopy;
+impl Test for NonCopy {
+    fn test(self) {}
+}
+
+fn main() {
+    let my_ref = MyRef(0);
+    consume_test(my_ref);
+    //~^ ERROR the trait bound `MyRef: Test` is not satisfied
+    //~| SUGGESTION *
+
+    let nested_box = Box::new(Box::new(Box::new(NonCopy)));
+    consume_test(nested_box);
+    //~^ ERROR the trait bound `Box<Box<Box<NonCopy>>>: Test` is not satisfied
+    //~| SUGGESTION ***
+}
diff --git a/tests/ui/traits/suggest-dereferences/deref-argument.stderr b/tests/ui/traits/suggest-dereferences/deref-argument.stderr
new file mode 100644
index 00000000000..3dc92fd6ab6
--- /dev/null
+++ b/tests/ui/traits/suggest-dereferences/deref-argument.stderr
@@ -0,0 +1,39 @@
+error[E0277]: the trait bound `MyRef: Test` is not satisfied
+  --> $DIR/deref-argument.rs:29:18
+   |
+LL |     consume_test(my_ref);
+   |     ------------ ^^^^^^ the trait `Test` is not implemented for `MyRef`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `consume_test`
+  --> $DIR/deref-argument.rs:9:25
+   |
+LL | fn consume_test(x: impl Test) { x.test() }
+   |                         ^^^^ required by this bound in `consume_test`
+help: consider dereferencing here
+   |
+LL |     consume_test(*my_ref);
+   |                  +
+
+error[E0277]: the trait bound `Box<Box<Box<NonCopy>>>: Test` is not satisfied
+  --> $DIR/deref-argument.rs:34:18
+   |
+LL |     consume_test(nested_box);
+   |     ------------ ^^^^^^^^^^ the trait `Test` is not implemented for `Box<Box<Box<NonCopy>>>`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `consume_test`
+  --> $DIR/deref-argument.rs:9:25
+   |
+LL | fn consume_test(x: impl Test) { x.test() }
+   |                         ^^^^ required by this bound in `consume_test`
+help: consider dereferencing here
+   |
+LL |     consume_test(***nested_box);
+   |                  +++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 04d9bb7a9a697f71abc4aac849a262f713807f29 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Mon, 25 Nov 2024 20:25:10 -0800
Subject: `add_move_error_suggestions`: use a HIR visitor rather than
 `SourceMap`

---
 .../rustc_borrowck/src/diagnostics/move_errors.rs  | 157 ++++++++++++++++-----
 tests/ui/issues/issue-12567.stderr                 |  28 ++--
 .../ref_pat_eat_one_layer_2024_fail2.stderr        |   7 +-
 ...t-removing-wrong-ref-pattern-issue-132806.fixed |  10 ++
 ...gest-removing-wrong-ref-pattern-issue-132806.rs |  10 ++
 ...-removing-wrong-ref-pattern-issue-132806.stderr |  18 +++
 tests/ui/nll/move-errors.stderr                    |   7 +-
 .../deref-patterns/cant_move_out_of_pattern.stderr |  10 ++
 tests/ui/suggestions/dont-suggest-ref/simple.rs    |  22 +--
 .../ui/suggestions/dont-suggest-ref/simple.stderr  |  77 +++++-----
 .../option-content-move-from-tuple-match.stderr    |   7 +-
 11 files changed, 249 insertions(+), 104 deletions(-)
 create mode 100644 tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.fixed
 create mode 100644 tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.rs
 create mode 100644 tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 4ba6b2e94ec..beacbdbd3fa 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -1,9 +1,10 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::intravisit::Visitor;
-use rustc_hir::{CaptureBy, ExprKind, HirId, Node};
+use rustc_hir::{self as hir, CaptureBy, ExprKind, HirId, Node};
 use rustc_middle::bug;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty};
@@ -683,48 +684,126 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     }
 
     fn add_move_error_suggestions(&self, err: &mut Diag<'_>, binds_to: &[Local]) {
-        let mut suggestions: Vec<(Span, String, String)> = Vec::new();
+        /// A HIR visitor to associate each binding with a `&` or `&mut` that could be removed to
+        /// make it bind by reference instead (if possible)
+        struct BindingFinder<'tcx> {
+            typeck_results: &'tcx ty::TypeckResults<'tcx>,
+            hir: rustc_middle::hir::map::Map<'tcx>,
+            /// Input: the span of the pattern we're finding bindings in
+            pat_span: Span,
+            /// Input: the spans of the bindings we're providing suggestions for
+            binding_spans: Vec<Span>,
+            /// Internal state: have we reached the pattern we're finding bindings in?
+            found_pat: bool,
+            /// Internal state: the innermost `&` or `&mut` "above" the visitor
+            ref_pat: Option<&'tcx hir::Pat<'tcx>>,
+            /// Internal state: could removing a `&` give bindings unexpected types?
+            has_adjustments: bool,
+            /// Output: for each input binding, the `&` or `&mut` to remove to make it by-ref
+            ref_pat_for_binding: Vec<(Span, Option<&'tcx hir::Pat<'tcx>>)>,
+            /// Output: ref patterns that can't be removed straightforwardly
+            cannot_remove: FxHashSet<HirId>,
+        }
+        impl<'tcx> Visitor<'tcx> for BindingFinder<'tcx> {
+            type NestedFilter = rustc_middle::hir::nested_filter::OnlyBodies;
+
+            fn nested_visit_map(&mut self) -> Self::Map {
+                self.hir
+            }
+
+            fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) -> Self::Result {
+                // Don't walk into const patterns or anything else that might confuse this
+                if !self.found_pat {
+                    hir::intravisit::walk_expr(self, ex)
+                }
+            }
+
+            fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
+                if p.span == self.pat_span {
+                    self.found_pat = true;
+                }
+
+                let parent_has_adjustments = self.has_adjustments;
+                self.has_adjustments |=
+                    self.typeck_results.pat_adjustments().contains_key(p.hir_id);
+
+                // Track the innermost `&` or `&mut` enclosing bindings, to suggest removing it.
+                let parent_ref_pat = self.ref_pat;
+                if let hir::PatKind::Ref(..) = p.kind {
+                    self.ref_pat = Some(p);
+                    // To avoid edition-dependent logic to figure out how many refs this `&` can
+                    // peel off, simply don't remove the "parent" `&`.
+                    self.cannot_remove.extend(parent_ref_pat.map(|r| r.hir_id));
+                    if self.has_adjustments {
+                        // Removing this `&` could give child bindings unexpected types, so don't.
+                        self.cannot_remove.insert(p.hir_id);
+                        // As long the `&` stays, child patterns' types should be as expected.
+                        self.has_adjustments = false;
+                    }
+                }
+
+                if let hir::PatKind::Binding(_, _, ident, _) = p.kind {
+                    // the spans in `binding_spans` encompass both the ident and binding mode
+                    if let Some(&bind_sp) =
+                        self.binding_spans.iter().find(|bind_sp| bind_sp.contains(ident.span))
+                    {
+                        self.ref_pat_for_binding.push((bind_sp, self.ref_pat));
+                    } else {
+                        // we've encountered a binding that we're not reporting a move error for.
+                        // we don't want to change its type, so don't remove the surrounding `&`.
+                        if let Some(ref_pat) = self.ref_pat {
+                            self.cannot_remove.insert(ref_pat.hir_id);
+                        }
+                    }
+                }
+
+                hir::intravisit::walk_pat(self, p);
+                self.ref_pat = parent_ref_pat;
+                self.has_adjustments = parent_has_adjustments;
+            }
+        }
+        let mut pat_span = None;
+        let mut binding_spans = Vec::new();
         for local in binds_to {
             let bind_to = &self.body.local_decls[*local];
-            if let LocalInfo::User(BindingForm::Var(VarBindingForm { pat_span, .. })) =
+            if let LocalInfo::User(BindingForm::Var(VarBindingForm { pat_span: pat_sp, .. })) =
                 *bind_to.local_info()
             {
-                let Ok(pat_snippet) = self.infcx.tcx.sess.source_map().span_to_snippet(pat_span)
-                else {
-                    continue;
-                };
-                let Some(stripped) = pat_snippet.strip_prefix('&') else {
-                    suggestions.push((
-                        bind_to.source_info.span.shrink_to_lo(),
-                        "consider borrowing the pattern binding".to_string(),
-                        "ref ".to_string(),
-                    ));
-                    continue;
-                };
-                let inner_pat_snippet = stripped.trim_start();
-                let (pat_span, suggestion, to_remove) = if inner_pat_snippet.starts_with("mut")
-                    && inner_pat_snippet["mut".len()..].starts_with(rustc_lexer::is_whitespace)
-                {
-                    let inner_pat_snippet = inner_pat_snippet["mut".len()..].trim_start();
-                    let pat_span = pat_span.with_hi(
-                        pat_span.lo()
-                            + BytePos((pat_snippet.len() - inner_pat_snippet.len()) as u32),
-                    );
-                    (pat_span, String::new(), "mutable borrow")
-                } else {
-                    let pat_span = pat_span.with_hi(
-                        pat_span.lo()
-                            + BytePos(
-                                (pat_snippet.len() - inner_pat_snippet.trim_start().len()) as u32,
-                            ),
-                    );
-                    (pat_span, String::new(), "borrow")
-                };
-                suggestions.push((
-                    pat_span,
-                    format!("consider removing the {to_remove}"),
-                    suggestion,
-                ));
+                pat_span = Some(pat_sp);
+                binding_spans.push(bind_to.source_info.span);
+            }
+        }
+        let Some(pat_span) = pat_span else { return };
+
+        let hir = self.infcx.tcx.hir();
+        let Some(body) = hir.maybe_body_owned_by(self.mir_def_id()) else { return };
+        let typeck_results = self.infcx.tcx.typeck(self.mir_def_id());
+        let mut finder = BindingFinder {
+            typeck_results,
+            hir,
+            pat_span,
+            binding_spans,
+            found_pat: false,
+            ref_pat: None,
+            has_adjustments: false,
+            ref_pat_for_binding: Vec::new(),
+            cannot_remove: FxHashSet::default(),
+        };
+        finder.visit_body(body);
+
+        let mut suggestions = Vec::new();
+        for (binding_span, opt_ref_pat) in finder.ref_pat_for_binding {
+            if let Some(ref_pat) = opt_ref_pat
+                && !finder.cannot_remove.contains(&ref_pat.hir_id)
+                && let hir::PatKind::Ref(subpat, mutbl) = ref_pat.kind
+                && let Some(ref_span) = ref_pat.span.trim_end(subpat.span)
+            {
+                let mutable_str = if mutbl.is_mut() { "mutable " } else { "" };
+                let msg = format!("consider removing the {mutable_str}borrow");
+                suggestions.push((ref_span, msg, "".to_string()));
+            } else {
+                let msg = "consider borrowing the pattern binding".to_string();
+                suggestions.push((binding_span.shrink_to_lo(), msg, "ref ".to_string()));
             }
         }
         suggestions.sort_unstable_by_key(|&(span, _, _)| span);
diff --git a/tests/ui/issues/issue-12567.stderr b/tests/ui/issues/issue-12567.stderr
index 3f95f18a967..0b19299ece3 100644
--- a/tests/ui/issues/issue-12567.stderr
+++ b/tests/ui/issues/issue-12567.stderr
@@ -11,14 +11,16 @@ LL |         (&[hd1, ..], &[hd2, ..])
    |                        --- ...and here
    |
    = note: move occurs because these variables have types that don't implement the `Copy` trait
-help: consider borrowing the pattern binding
+help: consider removing the borrow
    |
-LL |         (&[], &[ref hd, ..]) | (&[hd, ..], &[])
-   |                 +++
-help: consider borrowing the pattern binding
+LL -         (&[], &[hd, ..]) | (&[hd, ..], &[])
+LL +         (&[], [hd, ..]) | (&[hd, ..], &[])
+   |
+help: consider removing the borrow
+   |
+LL -         (&[hd1, ..], &[hd2, ..])
+LL +         (&[hd1, ..], [hd2, ..])
    |
-LL |         (&[hd1, ..], &[ref hd2, ..])
-   |                        +++
 
 error[E0508]: cannot move out of type `[T]`, a non-copy slice
   --> $DIR/issue-12567.rs:2:11
@@ -33,14 +35,16 @@ LL |         (&[hd1, ..], &[hd2, ..])
    |            --- ...and here
    |
    = note: move occurs because these variables have types that don't implement the `Copy` trait
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -         (&[], &[hd, ..]) | (&[hd, ..], &[])
+LL +         (&[], [hd, ..]) | (&[hd, ..], &[])
+   |
+help: consider removing the borrow
    |
-LL |         (&[], &[ref hd, ..]) | (&[hd, ..], &[])
-   |                 +++
-help: consider borrowing the pattern binding
+LL -         (&[hd1, ..], &[hd2, ..])
+LL +         ([hd1, ..], &[hd2, ..])
    |
-LL |         (&[ref hd1, ..], &[hd2, ..])
-   |            +++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/match/ref_pat_eat_one_layer_2024/ref_pat_eat_one_layer_2024_fail2.stderr b/tests/ui/match/ref_pat_eat_one_layer_2024/ref_pat_eat_one_layer_2024_fail2.stderr
index 52f4c09e5c0..a8b81394110 100644
--- a/tests/ui/match/ref_pat_eat_one_layer_2024/ref_pat_eat_one_layer_2024_fail2.stderr
+++ b/tests/ui/match/ref_pat_eat_one_layer_2024/ref_pat_eat_one_layer_2024_fail2.stderr
@@ -7,10 +7,11 @@ LL |     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
    |                       data moved here
    |                       move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
+LL +     if let Some(Some(x)) = Some(&Some(&mut 0)) {
    |
-LL |     if let Some(&Some(ref x)) = Some(&Some(&mut 0)) {
-   |                       +++
 
 error[E0596]: cannot borrow data in a `&` reference as mutable
   --> $DIR/ref_pat_eat_one_layer_2024_fail2.rs:11:10
diff --git a/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.fixed b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.fixed
new file mode 100644
index 00000000000..46b05e4c0a3
--- /dev/null
+++ b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.fixed
@@ -0,0 +1,10 @@
+//@ run-rustfix
+//! diagnostic test for #132806: make sure the suggestion to bind by-reference in patterns doesn't
+//! erroneously remove the wrong `&`
+
+use std::collections::HashMap;
+
+fn main() {
+    let _ = HashMap::<String, i32>::new().iter().filter(|&(_k, &_v)| { true });
+    //~^ ERROR cannot move out of a shared reference
+}
diff --git a/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.rs b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.rs
new file mode 100644
index 00000000000..1312fd6425b
--- /dev/null
+++ b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.rs
@@ -0,0 +1,10 @@
+//@ run-rustfix
+//! diagnostic test for #132806: make sure the suggestion to bind by-reference in patterns doesn't
+//! erroneously remove the wrong `&`
+
+use std::collections::HashMap;
+
+fn main() {
+    let _ = HashMap::<String, i32>::new().iter().filter(|&(&_k, &_v)| { true });
+    //~^ ERROR cannot move out of a shared reference
+}
diff --git a/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr
new file mode 100644
index 00000000000..ff579f93413
--- /dev/null
+++ b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr
@@ -0,0 +1,18 @@
+error[E0507]: cannot move out of a shared reference
+  --> $DIR/do-not-suggest-removing-wrong-ref-pattern-issue-132806.rs:8:58
+   |
+LL |     let _ = HashMap::<String, i32>::new().iter().filter(|&(&_k, &_v)| { true });
+   |                                                          ^^^--^^^^^^
+   |                                                             |
+   |                                                             data moved here
+   |                                                             move occurs because `_k` has type `String`, which does not implement the `Copy` trait
+   |
+help: consider removing the borrow
+   |
+LL -     let _ = HashMap::<String, i32>::new().iter().filter(|&(&_k, &_v)| { true });
+LL +     let _ = HashMap::<String, i32>::new().iter().filter(|&(_k, &_v)| { true });
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/nll/move-errors.stderr b/tests/ui/nll/move-errors.stderr
index d1384121379..bcb2ab84a23 100644
--- a/tests/ui/nll/move-errors.stderr
+++ b/tests/ui/nll/move-errors.stderr
@@ -209,10 +209,11 @@ LL |         (D(s), &t) => (),
    |                 data moved here
    |                 move occurs because `t` has type `String`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -         (D(s), &t) => (),
+LL +         (D(s), t) => (),
    |
-LL |         (D(s), &ref t) => (),
-   |                 +++
 
 error[E0509]: cannot move out of type `F`, which implements the `Drop` trait
   --> $DIR/move-errors.rs:102:11
diff --git a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
index 108db6d9e4b..2cf435b1179 100644
--- a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
+++ b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
@@ -9,6 +9,11 @@ LL |         deref!(x) => x,
    |                |
    |                data moved here
    |                move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |         deref!(ref x) => x,
+   |                +++
 
 error[E0507]: cannot move out of a shared reference
   --> $DIR/cant_move_out_of_pattern.rs:17:11
@@ -21,6 +26,11 @@ LL |         deref!(x) => x,
    |                |
    |                data moved here
    |                move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |         deref!(ref x) => x,
+   |                +++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/dont-suggest-ref/simple.rs b/tests/ui/suggestions/dont-suggest-ref/simple.rs
index 1e40e60a1ce..4dea5319264 100644
--- a/tests/ui/suggestions/dont-suggest-ref/simple.rs
+++ b/tests/ui/suggestions/dont-suggest-ref/simple.rs
@@ -219,42 +219,42 @@ pub fn main() {
 
     let (&X(_t),) = (&x.clone(),);
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the borrow
     if let (&Either::One(_t),) = (&e.clone(),) { }
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the borrow
     while let (&Either::One(_t),) = (&e.clone(),) { }
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the borrow
     match (&e.clone(),) {
         //~^ ERROR cannot move
         (&Either::One(_t),)
-        //~^ HELP consider borrowing the pattern binding
+        //~^ HELP consider removing the borrow
         | (&Either::Two(_t),) => (),
     }
     fn f3((&X(_t),): (&X,)) { }
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the borrow
 
     let (&mut X(_t),) = (&mut xm.clone(),);
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the mutable borrow
     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the mutable borrow
     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the mutable borrow
     match (&mut em.clone(),) {
         //~^ ERROR cannot move
         (&mut Either::One(_t),) => (),
-        //~^ HELP consider borrowing the pattern binding
+        //~^ HELP consider removing the mutable borrow
         (&mut Either::Two(_t),) => (),
-        //~^ HELP consider borrowing the pattern binding
+        //~^ HELP consider removing the mutable borrow
     }
     fn f4((&mut X(_t),): (&mut X,)) { }
     //~^ ERROR cannot move
-    //~| HELP consider borrowing the pattern binding
+    //~| HELP consider removing the mutable borrow
 
     // move from &Either/&X value
 
diff --git a/tests/ui/suggestions/dont-suggest-ref/simple.stderr b/tests/ui/suggestions/dont-suggest-ref/simple.stderr
index 7d902dbccc4..41571bf9b2c 100644
--- a/tests/ui/suggestions/dont-suggest-ref/simple.stderr
+++ b/tests/ui/suggestions/dont-suggest-ref/simple.stderr
@@ -578,10 +578,11 @@ LL |     let (&X(_t),) = (&x.clone(),);
    |             data moved here
    |             move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -     let (&X(_t),) = (&x.clone(),);
+LL +     let (X(_t),) = (&x.clone(),);
    |
-LL |     let (&X(ref _t),) = (&x.clone(),);
-   |             +++
 
 error[E0507]: cannot move out of a shared reference
   --> $DIR/simple.rs:223:34
@@ -592,10 +593,11 @@ LL |     if let (&Either::One(_t),) = (&e.clone(),) { }
    |                          data moved here
    |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -     if let (&Either::One(_t),) = (&e.clone(),) { }
+LL +     if let (Either::One(_t),) = (&e.clone(),) { }
    |
-LL |     if let (&Either::One(ref _t),) = (&e.clone(),) { }
-   |                          +++
 
 error[E0507]: cannot move out of a shared reference
   --> $DIR/simple.rs:226:37
@@ -606,10 +608,11 @@ LL |     while let (&Either::One(_t),) = (&e.clone(),) { }
    |                             data moved here
    |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -     while let (&Either::One(_t),) = (&e.clone(),) { }
+LL +     while let (Either::One(_t),) = (&e.clone(),) { }
    |
-LL |     while let (&Either::One(ref _t),) = (&e.clone(),) { }
-   |                             +++
 
 error[E0507]: cannot move out of a shared reference
   --> $DIR/simple.rs:229:11
@@ -623,10 +626,11 @@ LL |         (&Either::One(_t),)
    |                       data moved here
    |                       move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -         (&Either::One(_t),)
+LL +         (Either::One(_t),)
    |
-LL |         (&Either::One(ref _t),)
-   |                       +++
 
 error[E0507]: cannot move out of a mutable reference
   --> $DIR/simple.rs:239:25
@@ -637,10 +641,11 @@ LL |     let (&mut X(_t),) = (&mut xm.clone(),);
    |                 data moved here
    |                 move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the mutable borrow
+   |
+LL -     let (&mut X(_t),) = (&mut xm.clone(),);
+LL +     let (X(_t),) = (&mut xm.clone(),);
    |
-LL |     let (&mut X(ref _t),) = (&mut xm.clone(),);
-   |                 +++
 
 error[E0507]: cannot move out of a mutable reference
   --> $DIR/simple.rs:242:38
@@ -651,10 +656,11 @@ LL |     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
    |                              data moved here
    |                              move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the mutable borrow
+   |
+LL -     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
+LL +     if let (Either::One(_t),) = (&mut em.clone(),) { }
    |
-LL |     if let (&mut Either::One(ref _t),) = (&mut em.clone(),) { }
-   |                              +++
 
 error[E0507]: cannot move out of a mutable reference
   --> $DIR/simple.rs:245:41
@@ -665,10 +671,11 @@ LL |     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
    |                                 data moved here
    |                                 move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the mutable borrow
+   |
+LL -     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
+LL +     while let (Either::One(_t),) = (&mut em.clone(),) { }
    |
-LL |     while let (&mut Either::One(ref _t),) = (&mut em.clone(),) { }
-   |                                 +++
 
 error[E0507]: cannot move out of a mutable reference
   --> $DIR/simple.rs:248:11
@@ -683,14 +690,16 @@ LL |         (&mut Either::Two(_t),) => (),
    |                           -- ...and here
    |
    = note: move occurs because these variables have types that don't implement the `Copy` trait
-help: consider borrowing the pattern binding
+help: consider removing the mutable borrow
    |
-LL |         (&mut Either::One(ref _t),) => (),
-   |                           +++
-help: consider borrowing the pattern binding
+LL -         (&mut Either::One(_t),) => (),
+LL +         (Either::One(_t),) => (),
+   |
+help: consider removing the mutable borrow
+   |
+LL -         (&mut Either::Two(_t),) => (),
+LL +         (Either::Two(_t),) => (),
    |
-LL |         (&mut Either::Two(ref _t),) => (),
-   |                           +++
 
 error[E0507]: cannot move out of a shared reference
   --> $DIR/simple.rs:261:18
@@ -947,10 +956,11 @@ LL |     fn f3((&X(_t),): (&X,)) { }
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -     fn f3((&X(_t),): (&X,)) { }
+LL +     fn f3((X(_t),): (&X,)) { }
    |
-LL |     fn f3((&X(ref _t),): (&X,)) { }
-   |               +++
 
 error[E0507]: cannot move out of a mutable reference
   --> $DIR/simple.rs:255:11
@@ -961,10 +971,11 @@ LL |     fn f4((&mut X(_t),): (&mut X,)) { }
    |                   data moved here
    |                   move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the mutable borrow
+   |
+LL -     fn f4((&mut X(_t),): (&mut X,)) { }
+LL +     fn f4((X(_t),): (&mut X,)) { }
    |
-LL |     fn f4((&mut X(ref _t),): (&mut X,)) { }
-   |                   +++
 
 error[E0507]: cannot move out of `a.a` as enum variant `Some` which is behind a shared reference
   --> $DIR/simple.rs:331:20
diff --git a/tests/ui/suggestions/option-content-move-from-tuple-match.stderr b/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
index 63314acb87c..c93570c579e 100644
--- a/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
+++ b/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
@@ -10,10 +10,11 @@ LL |         (None, &c) => &c.unwrap(),
    |                 data moved here
    |                 move occurs because `c` has type `Option<String>`, which does not implement the `Copy` trait
    |
-help: consider borrowing the pattern binding
+help: consider removing the borrow
+   |
+LL -         (None, &c) => &c.unwrap(),
+LL +         (None, c) => &c.unwrap(),
    |
-LL |         (None, &ref c) => &c.unwrap(),
-   |                 +++
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From b661e98f09a195cd13457525b09b6db628835734 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 1 Dec 2024 19:10:44 -0300
Subject: Fix #128346

---
 compiler/rustc_expand/src/mbe/transcribe.rs        |  6 ++++--
 tests/crashes/128346.rs                            | 13 -------------
 .../macro-metavar-expr-concat/repetitions.rs       | 22 ++++++++++++++++++++--
 .../macro-metavar-expr-concat/repetitions.stderr   | 22 ++++++++++++++++++++++
 4 files changed, 46 insertions(+), 17 deletions(-)
 delete mode 100644 tests/crashes/128346.rs
 create mode 100644 tests/ui/macros/macro-metavar-expr-concat/repetitions.stderr

(limited to 'tests')

diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index b77d02e630a..c780cfd0e8f 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -696,8 +696,10 @@ fn transcribe_metavar_expr<'a>(
                     MetaVarExprConcatElem::Var(ident) => {
                         match matched_from_ident(dcx, *ident, interp)? {
                             NamedMatch::MatchedSeq(named_matches) => {
-                                let curr_idx = repeats.last().unwrap().0;
-                                match &named_matches[curr_idx] {
+                                let Some((curr_idx, _)) = repeats.last() else {
+                                    return Err(dcx.struct_span_err(sp.entire(), "invalid syntax"));
+                                };
+                                match &named_matches[*curr_idx] {
                                     // FIXME(c410-f3r) Nested repetitions are unimplemented
                                     MatchedSeq(_) => unimplemented!(),
                                     MatchedSingle(pnr) => {
diff --git a/tests/crashes/128346.rs b/tests/crashes/128346.rs
deleted file mode 100644
index 93d9c40a544..00000000000
--- a/tests/crashes/128346.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: rust-lang/rust#128346
-
-macro_rules! one_rep {
-    ( $($a:ident)* ) => {
-        A(
-            const ${concat($a, Z)}: i32 = 3;
-        )*
-    };
-}
-
-fn main() {
-    one_rep!(A B C);
-}
diff --git a/tests/ui/macros/macro-metavar-expr-concat/repetitions.rs b/tests/ui/macros/macro-metavar-expr-concat/repetitions.rs
index 781443207ac..52a7d5cd8a7 100644
--- a/tests/ui/macros/macro-metavar-expr-concat/repetitions.rs
+++ b/tests/ui/macros/macro-metavar-expr-concat/repetitions.rs
@@ -1,5 +1,3 @@
-//@ run-pass
-
 #![feature(macro_metavar_expr_concat)]
 
 macro_rules! one_rep {
@@ -10,9 +8,29 @@ macro_rules! one_rep {
     };
 }
 
+macro_rules! issue_128346 {
+    ( $($a:ident)* ) => {
+        A(
+            const ${concat($a, Z)}: i32 = 3;
+            //~^ ERROR invalid syntax
+        )*
+    };
+}
+
+macro_rules! issue_131393 {
+    ($t:ident $($en:ident)?) => {
+        read::<${concat($t, $en)}>()
+        //~^ ERROR invalid syntax
+        //~| ERROR invalid syntax
+    }
+}
+
 fn main() {
     one_rep!(A B C);
     assert_eq!(AZ, 3);
     assert_eq!(BZ, 3);
     assert_eq!(CZ, 3);
+    issue_128346!(A B C);
+    issue_131393!(u8);
+    issue_131393!(u16 le);
 }
diff --git a/tests/ui/macros/macro-metavar-expr-concat/repetitions.stderr b/tests/ui/macros/macro-metavar-expr-concat/repetitions.stderr
new file mode 100644
index 00000000000..c3006c4be5d
--- /dev/null
+++ b/tests/ui/macros/macro-metavar-expr-concat/repetitions.stderr
@@ -0,0 +1,22 @@
+error: invalid syntax
+  --> $DIR/repetitions.rs:14:20
+   |
+LL |             const ${concat($a, Z)}: i32 = 3;
+   |                    ^^^^^^^^^^^^^^^
+
+error: invalid syntax
+  --> $DIR/repetitions.rs:22:17
+   |
+LL |         read::<${concat($t, $en)}>()
+   |                 ^^^^^^^^^^^^^^^^^
+
+error: invalid syntax
+  --> $DIR/repetitions.rs:22:17
+   |
+LL |         read::<${concat($t, $en)}>()
+   |                 ^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d6ceae0fd89ad0f9e882aea1f9e92dff673fcfba Mon Sep 17 00:00:00 2001
From: "许杰友 Jieyou Xu (Joe)" <39484203+jieyouxu@users.noreply.github.com>
Date: Tue, 10 Dec 2024 21:02:49 +0800
Subject: Adjust `rustc_bootstap.rs` ui test

- Fixed test name, it should've been `rustc_bootstrap.rs`, oops.
- Slightly reworded test comment to make it more clear.
---
 .../bootstrap/rustc_bootstap.force_stable.stderr   | 10 -----
 tests/ui/bootstrap/rustc_bootstap.rs               | 47 ----------------------
 .../bootstrap/rustc_bootstrap.force_stable.stderr  | 10 +++++
 tests/ui/bootstrap/rustc_bootstrap.rs              | 47 ++++++++++++++++++++++
 4 files changed, 57 insertions(+), 57 deletions(-)
 delete mode 100644 tests/ui/bootstrap/rustc_bootstap.force_stable.stderr
 delete mode 100644 tests/ui/bootstrap/rustc_bootstap.rs
 create mode 100644 tests/ui/bootstrap/rustc_bootstrap.force_stable.stderr
 create mode 100644 tests/ui/bootstrap/rustc_bootstrap.rs

(limited to 'tests')

diff --git a/tests/ui/bootstrap/rustc_bootstap.force_stable.stderr b/tests/ui/bootstrap/rustc_bootstap.force_stable.stderr
deleted file mode 100644
index f378f3c70dd..00000000000
--- a/tests/ui/bootstrap/rustc_bootstap.force_stable.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: the option `Z` is only accepted on the nightly compiler
-
-help: consider switching to a nightly toolchain: `rustup default nightly`
-
-note: selecting a toolchain with `+toolchain` arguments require a rustup proxy; see <https://rust-lang.github.io/rustup/concepts/index.html>
-
-note: for more information about Rust's stability policy, see <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html#unstable-features>
-
-error: 1 nightly option were parsed
-
diff --git a/tests/ui/bootstrap/rustc_bootstap.rs b/tests/ui/bootstrap/rustc_bootstap.rs
deleted file mode 100644
index 3d792ef4be4..00000000000
--- a/tests/ui/bootstrap/rustc_bootstap.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//! Check `RUSTC_BOOTSTRAP`'s behavior in relation to feature stability and what rustc considers
-//! itself to be (stable vs non-stable ).
-//!
-//! `RUSTC_BOOTSTRAP` accepts:
-//!
-//! - `1`: cheat, allow usage of unstable features even if rustc thinks it is a stable compiler.
-//! - `x,y,z`: comma-delimited list of crates.
-//! - `-1`: force rustc to think it is a stable compiler.
-
-// ignore-tidy-linelength
-
-//@ revisions: default_nightly cheat cheat_single_crate cheat_multi_crate force_stable invalid_zero invalid_junk
-//@ only-nightly
-
-//@[default_nightly] unset-rustc-env:RUSTC_BOOTSTRAP
-//@[default_nightly] check-pass
-
-// For a nightly compiler, this is same as `default_nightly` as if `RUSTC_BOOTSTRAP` was unset.
-//@[invalid_zero] rustc-env:RUSTC_BOOTSTRAP=0
-//@[invalid_zero] check-pass
-
-// Invalid values are silently discarded, same as `default_nightly`, i.e. as if `RUSTC_BOOTSTRAP`
-// was unset.
-//@[invalid_junk] rustc-env:RUSTC_BOOTSTRAP=*
-//@[invalid_junk] check-pass
-
-//@[cheat] rustc-env:RUSTC_BOOTSTRAP=1
-//@[cheat] check-pass
-
-//@[cheat_single_crate] rustc-env:RUSTC_BOOTSTRAP=x
-//@[cheat_single_crate] check-pass
-
-//@[cheat_multi_crate] rustc-env:RUSTC_BOOTSTRAP=x,y,z
-//@[cheat_multi_crate] check-pass
-
-// Note: compiletest passes some `-Z` flags to the compiler for ui testing purposes, so here we
-// instead abuse the fact that `-Z unstable-options` is also part of rustc's stability story and is
-// also affected by `RUSTC_BOOTSTRAP`.
-//@[force_stable] rustc-env:RUSTC_BOOTSTRAP=-1
-//@[force_stable] compile-flags: -Z unstable-options
-//@[force_stable] regex-error-pattern: error: the option `Z` is only accepted on the nightly compiler
-
-#![crate_type = "lib"]
-
-// Note: `rustc_attrs` is a perma-unstable internal feature that is unlikely to change, which is
-// used as a proxy to check `RUSTC_BOOTSTRAP` versus stability checking logic.
-#![feature(rustc_attrs)]
diff --git a/tests/ui/bootstrap/rustc_bootstrap.force_stable.stderr b/tests/ui/bootstrap/rustc_bootstrap.force_stable.stderr
new file mode 100644
index 00000000000..f378f3c70dd
--- /dev/null
+++ b/tests/ui/bootstrap/rustc_bootstrap.force_stable.stderr
@@ -0,0 +1,10 @@
+error: the option `Z` is only accepted on the nightly compiler
+
+help: consider switching to a nightly toolchain: `rustup default nightly`
+
+note: selecting a toolchain with `+toolchain` arguments require a rustup proxy; see <https://rust-lang.github.io/rustup/concepts/index.html>
+
+note: for more information about Rust's stability policy, see <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html#unstable-features>
+
+error: 1 nightly option were parsed
+
diff --git a/tests/ui/bootstrap/rustc_bootstrap.rs b/tests/ui/bootstrap/rustc_bootstrap.rs
new file mode 100644
index 00000000000..daa28e0cdf2
--- /dev/null
+++ b/tests/ui/bootstrap/rustc_bootstrap.rs
@@ -0,0 +1,47 @@
+//! Check the compiler's behavior when the perma-unstable env var `RUSTC_BOOTSTRAP` is set in the
+//! environment in relation to feature stability and which channel rustc considers itself to be.
+//!
+//! `RUSTC_BOOTSTRAP` accepts:
+//!
+//! - `1`: cheat, allow usage of unstable features even if rustc thinks it is a stable compiler.
+//! - `x,y,z`: comma-delimited list of crates.
+//! - `-1`: force rustc to think it is a stable compiler.
+
+// ignore-tidy-linelength
+
+//@ revisions: default_nightly cheat cheat_single_crate cheat_multi_crate force_stable invalid_zero invalid_junk
+//@ only-nightly
+
+//@[default_nightly] unset-rustc-env:RUSTC_BOOTSTRAP
+//@[default_nightly] check-pass
+
+// For a nightly compiler, this is same as `default_nightly` as if `RUSTC_BOOTSTRAP` was unset.
+//@[invalid_zero] rustc-env:RUSTC_BOOTSTRAP=0
+//@[invalid_zero] check-pass
+
+// Invalid values are silently discarded, same as `default_nightly`, i.e. as if `RUSTC_BOOTSTRAP`
+// was unset.
+//@[invalid_junk] rustc-env:RUSTC_BOOTSTRAP=*
+//@[invalid_junk] check-pass
+
+//@[cheat] rustc-env:RUSTC_BOOTSTRAP=1
+//@[cheat] check-pass
+
+//@[cheat_single_crate] rustc-env:RUSTC_BOOTSTRAP=x
+//@[cheat_single_crate] check-pass
+
+//@[cheat_multi_crate] rustc-env:RUSTC_BOOTSTRAP=x,y,z
+//@[cheat_multi_crate] check-pass
+
+// Note: compiletest passes some `-Z` flags to the compiler for ui testing purposes, so here we
+// instead abuse the fact that `-Z unstable-options` is also part of rustc's stability story and is
+// also affected by `RUSTC_BOOTSTRAP`.
+//@[force_stable] rustc-env:RUSTC_BOOTSTRAP=-1
+//@[force_stable] compile-flags: -Z unstable-options
+//@[force_stable] regex-error-pattern: error: the option `Z` is only accepted on the nightly compiler
+
+#![crate_type = "lib"]
+
+// Note: `rustc_attrs` is a perma-unstable internal feature that is unlikely to change, which is
+// used as a proxy to check `RUSTC_BOOTSTRAP` versus stability checking logic.
+#![feature(rustc_attrs)]
-- 
cgit 1.4.1-3-g733a5


From 70fe5a150d2aa28e704a30a6ce8c2219e4b98583 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Sat, 21 Dec 2024 19:08:30 +0000
Subject: Avoid ICE in borrowck

Provide a fallback in `best_blame_constraint` when `find_constraint_paths_between_regions` doesn't have a result. This code is due a rework to avoid the letf-over `unwrap()`, but avoids the ICE caused by the repro.

Fix #133252.
---
 compiler/rustc_borrowck/src/region_infer/mod.rs    | 10 ++++-
 tests/crashes/133252.rs                            | 43 --------------------
 ...implementation-not-general-enough-ice-133252.rs | 47 ++++++++++++++++++++++
 ...ementation-not-general-enough-ice-133252.stderr | 34 ++++++++++++++++
 4 files changed, 89 insertions(+), 45 deletions(-)
 delete mode 100644 tests/crashes/133252.rs
 create mode 100644 tests/ui/borrowck/implementation-not-general-enough-ice-133252.rs
 create mode 100644 tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index d39fbf32921..37e93196335 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -1945,8 +1945,14 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         target_test: impl Fn(RegionVid) -> bool,
     ) -> (BlameConstraint<'tcx>, Vec<ExtraConstraintInfo>) {
         // Find all paths
-        let (path, target_region) =
-            self.find_constraint_paths_between_regions(from_region, target_test).unwrap();
+        let (path, target_region) = self
+            .find_constraint_paths_between_regions(from_region, target_test)
+            .or_else(|| {
+                self.find_constraint_paths_between_regions(from_region, |r| {
+                    self.cannot_name_placeholder(from_region, r)
+                })
+            })
+            .unwrap();
         debug!(
             "path={:#?}",
             path.iter()
diff --git a/tests/crashes/133252.rs b/tests/crashes/133252.rs
deleted file mode 100644
index 3cecf448287..00000000000
--- a/tests/crashes/133252.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ known-bug: #133252
-//@ edition:2021
-use std::future::Future;
-
-trait Owned: 'static {}
-fn ice() -> impl Future<Output = &'static dyn Owned> {
-    async {
-        let not_static = 0;
-        force_send(async_load(&not_static));
-        loop {}
-    }
-}
-
-fn force_send<T: Send>(_: T) {}
-
-fn async_load<'a, T: LoadQuery<'a>>(this: T) -> impl Future {
-    async {
-        this.get_future().await;
-    }
-}
-
-trait LoadQuery<'a>: Sized {
-    type LoadFuture: Future;
-
-    fn get_future(self) -> Self::LoadFuture {
-        loop {}
-    }
-}
-
-impl<'a> LoadQuery<'a> for &'a u8 {
-    type LoadFuture = SimpleFuture;
-}
-
-struct SimpleFuture;
-impl Future for SimpleFuture {
-    type Output = ();
-    fn poll(
-        self: std::pin::Pin<&mut Self>,
-        _: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Self::Output> {
-        loop {}
-    }
-}
diff --git a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.rs b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.rs
new file mode 100644
index 00000000000..7ee16e62b9a
--- /dev/null
+++ b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.rs
@@ -0,0 +1,47 @@
+// Regression test for borrowck ICE #133252
+//@ edition:2021
+use std::future::Future;
+
+trait Owned: 'static {}
+fn ice() -> impl Future<Output = &'static dyn Owned> {
+    async {
+        let not_static = 0;
+        force_send(async_load(&not_static));
+        //~^ ERROR implementation of `LoadQuery` is not general enough
+        //~| ERROR `not_static` does not live long enough
+        loop {}
+    }
+}
+
+fn force_send<T: Send>(_: T) {}
+
+fn async_load<'a, T: LoadQuery<'a>>(this: T) -> impl Future {
+    async {
+        this.get_future().await;
+    }
+}
+
+trait LoadQuery<'a>: Sized {
+    type LoadFuture: Future;
+
+    fn get_future(self) -> Self::LoadFuture {
+        loop {}
+    }
+}
+
+impl<'a> LoadQuery<'a> for &'a u8 {
+    type LoadFuture = SimpleFuture;
+}
+
+struct SimpleFuture;
+impl Future for SimpleFuture {
+    type Output = ();
+    fn poll(
+        self: std::pin::Pin<&mut Self>,
+        _: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        loop {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
new file mode 100644
index 00000000000..13c768dcbf6
--- /dev/null
+++ b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
@@ -0,0 +1,34 @@
+error: implementation of `LoadQuery` is not general enough
+  --> $DIR/implementation-not-general-enough-ice-133252.rs:9:9
+   |
+LL |         force_send(async_load(&not_static));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `LoadQuery` is not general enough
+   |
+   = note: `LoadQuery<'0>` would have to be implemented for the type `&u8`, for any lifetime `'0`...
+   = note: ...but `LoadQuery<'1>` is actually implemented for the type `&'1 u8`, for some specific lifetime `'1`
+
+error[E0597]: `not_static` does not live long enough
+  --> $DIR/implementation-not-general-enough-ice-133252.rs:9:31
+   |
+LL |     async {
+   |         - return type of async block is &(dyn Owned + '1)
+LL |         let not_static = 0;
+   |             ---------- binding `not_static` declared here
+LL |         force_send(async_load(&not_static));
+   |                    -----------^^^^^^^^^^^-
+   |                    |          |
+   |                    |          borrowed value does not live long enough
+   |                    argument requires that `not_static` is borrowed for `'1`
+...
+LL |     }
+   |     - `not_static` dropped here while still borrowed
+   |
+note: due to current limitations in the borrow checker, this implies a `'static` lifetime
+  --> $DIR/implementation-not-general-enough-ice-133252.rs:16:18
+   |
+LL | fn force_send<T: Send>(_: T) {}
+   |                  ^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0597`.
-- 
cgit 1.4.1-3-g733a5


From 535bc781f81d26883783b726770da94e4918c711 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 22 Dec 2024 01:46:44 +0000
Subject: Fix item bounds in old solver

---
 .../rustc_trait_selection/src/traits/effects.rs    | 165 +++++++++++++++++----
 .../const-traits/assoc-type-const-bound-usage-0.rs |   3 +-
 .../const-traits/assoc-type-const-bound-usage-1.rs |   3 +-
 .../assoc-type-const-bound-usage-1.stderr          |  35 -----
 ...oc-type-const-bound-usage-fail-2.current.stderr |  15 ++
 ...assoc-type-const-bound-usage-fail-2.next.stderr |  15 ++
 .../assoc-type-const-bound-usage-fail-2.rs         |   9 +-
 .../assoc-type-const-bound-usage-fail-2.stderr     |  15 --
 ...ssoc-type-const-bound-usage-fail.current.stderr |  15 ++
 .../assoc-type-const-bound-usage-fail.next.stderr  |  15 ++
 .../assoc-type-const-bound-usage-fail.rs           |   3 +-
 .../assoc-type-const-bound-usage-fail.stderr       |  15 --
 .../traits/const-traits/assoc-type.current.stderr  |  15 ++
 .../ui/traits/const-traits/assoc-type.next.stderr  |  15 ++
 tests/ui/traits/const-traits/assoc-type.rs         |   3 +-
 tests/ui/traits/const-traits/assoc-type.stderr     |  15 --
 16 files changed, 240 insertions(+), 116 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.stderr
 create mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr
 create mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr
 delete mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.stderr
 create mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
 create mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
 delete mode 100644 tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.stderr
 create mode 100644 tests/ui/traits/const-traits/assoc-type.current.stderr
 create mode 100644 tests/ui/traits/const-traits/assoc-type.next.stderr
 delete mode 100644 tests/ui/traits/const-traits/assoc-type.stderr

(limited to 'tests')

diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index b17a489a857..91484ef99db 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -1,13 +1,15 @@
 use rustc_hir as hir;
-use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt};
+use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes};
 use rustc_infer::traits::{ImplSource, Obligation, PredicateObligation};
 use rustc_middle::span_bug;
 use rustc_middle::ty::fast_reject::DeepRejectCtxt;
 use rustc_middle::ty::{self, TypingMode};
+use rustc_type_ir::elaborate::elaborate;
 use rustc_type_ir::solve::NoSolution;
-use thin_vec::ThinVec;
+use thin_vec::{ThinVec, thin_vec};
 
 use super::SelectionContext;
+use super::normalize::normalize_with_depth_to;
 
 pub type HostEffectObligation<'tcx> = Obligation<'tcx, ty::HostEffectPredicate<'tcx>>;
 
@@ -38,6 +40,12 @@ pub fn evaluate_host_effect_obligation<'tcx>(
         Err(EvaluationFailure::NoSolution) => {}
     }
 
+    match evaluate_host_effect_from_item_bounds(selcx, obligation) {
+        Ok(result) => return Ok(result),
+        Err(EvaluationFailure::Ambiguous) => return Err(EvaluationFailure::Ambiguous),
+        Err(EvaluationFailure::NoSolution) => {}
+    }
+
     match evaluate_host_effect_from_selection_candiate(selcx, obligation) {
         Ok(result) => return Ok(result),
         Err(EvaluationFailure::Ambiguous) => return Err(EvaluationFailure::Ambiguous),
@@ -48,24 +56,45 @@ pub fn evaluate_host_effect_obligation<'tcx>(
 }
 
 fn match_candidate<'tcx>(
-    infcx: &InferCtxt<'tcx>,
+    selcx: &mut SelectionContext<'_, 'tcx>,
     obligation: &HostEffectObligation<'tcx>,
     candidate: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+    candidate_is_unnormalized: bool,
+    more_nested: impl FnOnce(&mut SelectionContext<'_, 'tcx>, &mut ThinVec<PredicateObligation<'tcx>>),
 ) -> Result<ThinVec<PredicateObligation<'tcx>>, NoSolution> {
     if !candidate.skip_binder().constness.satisfies(obligation.predicate.constness) {
         return Err(NoSolution);
     }
 
-    let candidate = infcx.instantiate_binder_with_fresh_vars(
+    let mut candidate = selcx.infcx.instantiate_binder_with_fresh_vars(
         obligation.cause.span,
         BoundRegionConversionTime::HigherRankedType,
         candidate,
     );
 
-    let mut nested = infcx
-        .at(&obligation.cause, obligation.param_env)
-        .eq(DefineOpaqueTypes::Yes, obligation.predicate.trait_ref, candidate.trait_ref)?
-        .into_obligations();
+    let mut nested = thin_vec![];
+
+    // Unlike param-env bounds, item bounds may not be normalized.
+    if candidate_is_unnormalized {
+        candidate = normalize_with_depth_to(
+            selcx,
+            obligation.param_env,
+            obligation.cause.clone(),
+            obligation.recursion_depth,
+            candidate,
+            &mut nested,
+        );
+    }
+
+    nested.extend(
+        selcx
+            .infcx
+            .at(&obligation.cause, obligation.param_env)
+            .eq(DefineOpaqueTypes::Yes, obligation.predicate.trait_ref, candidate.trait_ref)?
+            .into_obligations(),
+    );
+
+    more_nested(selcx, &mut nested);
 
     for nested in &mut nested {
         nested.set_depth_from_parent(obligation.recursion_depth);
@@ -82,36 +111,116 @@ fn evaluate_host_effect_from_bounds<'tcx>(
     let drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx());
     let mut candidate = None;
 
-    for predicate in obligation.param_env.caller_bounds() {
-        let bound_predicate = predicate.kind();
-        if let ty::ClauseKind::HostEffect(data) = predicate.kind().skip_binder() {
-            let data = bound_predicate.rebind(data);
-            if data.skip_binder().trait_ref.def_id != obligation.predicate.trait_ref.def_id {
-                continue;
+    for clause in obligation.param_env.caller_bounds() {
+        let bound_clause = clause.kind();
+        let ty::ClauseKind::HostEffect(data) = bound_clause.skip_binder() else {
+            continue;
+        };
+        let data = bound_clause.rebind(data);
+        if data.skip_binder().trait_ref.def_id != obligation.predicate.trait_ref.def_id {
+            continue;
+        }
+
+        if !drcx
+            .args_may_unify(obligation.predicate.trait_ref.args, data.skip_binder().trait_ref.args)
+        {
+            continue;
+        }
+
+        let is_match =
+            infcx.probe(|_| match_candidate(selcx, obligation, data, false, |_, _| {}).is_ok());
+
+        if is_match {
+            if candidate.is_some() {
+                return Err(EvaluationFailure::Ambiguous);
+            } else {
+                candidate = Some(data);
             }
+        }
+    }
 
-            if !drcx.args_may_unify(
-                obligation.predicate.trait_ref.args,
-                data.skip_binder().trait_ref.args,
+    if let Some(data) = candidate {
+        Ok(match_candidate(selcx, obligation, data, false, |_, _| {})
+            .expect("candidate matched before, so it should match again"))
+    } else {
+        Err(EvaluationFailure::NoSolution)
+    }
+}
+
+fn evaluate_host_effect_from_item_bounds<'tcx>(
+    selcx: &mut SelectionContext<'_, 'tcx>,
+    obligation: &HostEffectObligation<'tcx>,
+) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
+    let infcx = selcx.infcx;
+    let tcx = infcx.tcx;
+    let drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx());
+    let mut candidate = None;
+
+    let mut consider_ty = obligation.predicate.self_ty();
+    while let ty::Alias(kind @ (ty::Projection | ty::Opaque), alias_ty) = *consider_ty.kind() {
+        if tcx.is_conditionally_const(alias_ty.def_id) {
+            for clause in elaborate(
+                tcx,
+                tcx.explicit_implied_const_bounds(alias_ty.def_id)
+                    .iter_instantiated_copied(tcx, alias_ty.args)
+                    .map(|(trait_ref, _)| {
+                        trait_ref.to_host_effect_clause(tcx, obligation.predicate.constness)
+                    }),
             ) {
-                continue;
-            }
+                let bound_clause = clause.kind();
+                let ty::ClauseKind::HostEffect(data) = bound_clause.skip_binder() else {
+                    unreachable!("should not elaborate non-HostEffect from HostEffect")
+                };
+                let data = bound_clause.rebind(data);
+                if data.skip_binder().trait_ref.def_id != obligation.predicate.trait_ref.def_id {
+                    continue;
+                }
 
-            let is_match = infcx.probe(|_| match_candidate(infcx, obligation, data).is_ok());
+                if !drcx.args_may_unify(
+                    obligation.predicate.trait_ref.args,
+                    data.skip_binder().trait_ref.args,
+                ) {
+                    continue;
+                }
 
-            if is_match {
-                if candidate.is_some() {
-                    return Err(EvaluationFailure::Ambiguous);
-                } else {
-                    candidate = Some(data);
+                let is_match = infcx
+                    .probe(|_| match_candidate(selcx, obligation, data, true, |_, _| {}).is_ok());
+
+                if is_match {
+                    if candidate.is_some() {
+                        return Err(EvaluationFailure::Ambiguous);
+                    } else {
+                        candidate = Some((data, alias_ty));
+                    }
                 }
             }
         }
+
+        if kind != ty::Projection {
+            break;
+        }
+
+        consider_ty = alias_ty.self_ty();
     }
 
-    if let Some(data) = candidate {
-        Ok(match_candidate(infcx, obligation, data)
-            .expect("candidate matched before, so it should match again"))
+    if let Some((data, alias_ty)) = candidate {
+        Ok(match_candidate(selcx, obligation, data, true, |selcx, nested| {
+            // An alias bound only holds if we also check the const conditions
+            // of the alias, so we need to register those, too.
+            let const_conditions = normalize_with_depth_to(
+                selcx,
+                obligation.param_env,
+                obligation.cause.clone(),
+                obligation.recursion_depth,
+                tcx.const_conditions(alias_ty.def_id).instantiate(tcx, alias_ty.args),
+                nested,
+            );
+            nested.extend(const_conditions.into_iter().map(|(trait_ref, _)| {
+                obligation
+                    .with(tcx, trait_ref.to_host_effect_clause(tcx, obligation.predicate.constness))
+            }));
+        })
+        .expect("candidate matched before, so it should match again"))
     } else {
         Err(EvaluationFailure::NoSolution)
     }
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-0.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-0.rs
index bac7ee023f4..9141d327aee 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-0.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-0.rs
@@ -1,4 +1,5 @@
-//@ compile-flags: -Znext-solver
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
 //@ check-pass
 
 #![feature(const_trait_impl)]
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.rs
index a0375cda079..19e86b50d33 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.rs
@@ -1,5 +1,4 @@
-//@ compile-flags: -Znext-solver
-//@ known-bug: unknown
+//@ check-pass
 
 #![feature(const_trait_impl, generic_const_exprs)]
 #![allow(incomplete_features)]
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.stderr
deleted file mode 100644
index 8d1c85c0c8a..00000000000
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-1.stderr
+++ /dev/null
@@ -1,35 +0,0 @@
-error: `-Znext-solver=globally` and `generic_const_exprs` are incompatible, using them at the same time is not allowed
-  --> $DIR/assoc-type-const-bound-usage-1.rs:4:30
-   |
-LL | #![feature(const_trait_impl, generic_const_exprs)]
-   |                              ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: remove one of these features
-
-error[E0284]: type annotations needed: cannot normalize `unqualified<T>::{constant#0}`
-  --> $DIR/assoc-type-const-bound-usage-1.rs:15:37
-   |
-LL | fn unqualified<T: const Trait>() -> Type<{ T::Assoc::func() }> {
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot normalize `unqualified<T>::{constant#0}`
-
-error[E0284]: type annotations needed: cannot normalize `qualified<T>::{constant#0}`
-  --> $DIR/assoc-type-const-bound-usage-1.rs:19:35
-   |
-LL | fn qualified<T: const Trait>() -> Type<{ <T as Trait>::Assoc::func() }> {
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot normalize `qualified<T>::{constant#0}`
-
-error[E0284]: type annotations needed: cannot normalize `unqualified<T>::{constant#0}`
-  --> $DIR/assoc-type-const-bound-usage-1.rs:16:5
-   |
-LL |     Type
-   |     ^^^^ cannot normalize `unqualified<T>::{constant#0}`
-
-error[E0284]: type annotations needed: cannot normalize `qualified<T>::{constant#0}`
-  --> $DIR/assoc-type-const-bound-usage-1.rs:20:5
-   |
-LL |     Type
-   |     ^^^^ cannot normalize `qualified<T>::{constant#0}`
-
-error: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr
new file mode 100644
index 00000000000..03da9159bea
--- /dev/null
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `U: ~const Other` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:24:5
+   |
+LL |     T::Assoc::<U>::func();
+   |     ^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `U: ~const Other` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:27:5
+   |
+LL |     <T as Trait>::Assoc::<U>::func();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr
new file mode 100644
index 00000000000..ce58b486a16
--- /dev/null
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:24:5
+   |
+LL |     T::Assoc::<U>::func();
+   |     ^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:27:5
+   |
+LL |     <T as Trait>::Assoc::<U>::func();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs
index b3a636b0f71..bdd98eaf541 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs
@@ -1,4 +1,5 @@
-//@ compile-flags: -Znext-solver
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
 
 // Check that `~const` item bounds only hold if the where clauses on the
 // associated type are also const.
@@ -21,9 +22,11 @@ trait Other {}
 
 const fn fails<T: ~const Trait, U: Other>() {
     T::Assoc::<U>::func();
-    //~^ ERROR the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+    //[current]~^ ERROR the trait bound `U: ~const Other` is not satisfied
+    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
     <T as Trait>::Assoc::<U>::func();
-    //~^ ERROR the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+    //[current]~^ ERROR the trait bound `U: ~const Other` is not satisfied
+    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
 }
 
 const fn works<T: ~const Trait, U: ~const Other>() {
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.stderr
deleted file mode 100644
index c7af0a220ca..00000000000
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0277]: the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:23:5
-   |
-LL |     T::Assoc::<U>::func();
-   |     ^^^^^^^^^^^^^
-
-error[E0277]: the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:25:5
-   |
-LL |     <T as Trait>::Assoc::<U>::func();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
new file mode 100644
index 00000000000..9c29a894749
--- /dev/null
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `T: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:17:5
+   |
+LL |     T::Assoc::func();
+   |     ^^^^^^^^
+
+error[E0277]: the trait bound `T: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:19:5
+   |
+LL |     <T as Trait>::Assoc::func();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
new file mode 100644
index 00000000000..9c29a894749
--- /dev/null
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `T: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:17:5
+   |
+LL |     T::Assoc::func();
+   |     ^^^^^^^^
+
+error[E0277]: the trait bound `T: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:19:5
+   |
+LL |     <T as Trait>::Assoc::func();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
index ce01086f0dc..3761fea1968 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
@@ -1,4 +1,5 @@
-//@ compile-flags: -Znext-solver
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
 
 // Check that `~const` item bounds only hold if the parent trait is `~const`.
 // i.e. check that we validate the const conditions for the associated type
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.stderr
deleted file mode 100644
index 99fc924ad06..00000000000
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0277]: the trait bound `T: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail.rs:16:5
-   |
-LL |     T::Assoc::func();
-   |     ^^^^^^^^
-
-error[E0277]: the trait bound `T: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail.rs:18:5
-   |
-LL |     <T as Trait>::Assoc::func();
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type.current.stderr b/tests/ui/traits/const-traits/assoc-type.current.stderr
new file mode 100644
index 00000000000..4bf9acfbd65
--- /dev/null
+++ b/tests/ui/traits/const-traits/assoc-type.current.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `NonConstAdd: ~const Add` is not satisfied
+  --> $DIR/assoc-type.rs:37:16
+   |
+LL |     type Bar = NonConstAdd;
+   |                ^^^^^^^^^^^
+   |
+note: required by a bound in `Foo::Bar`
+  --> $DIR/assoc-type.rs:33:15
+   |
+LL |     type Bar: ~const Add;
+   |               ^^^^^^ required by this bound in `Foo::Bar`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type.next.stderr b/tests/ui/traits/const-traits/assoc-type.next.stderr
new file mode 100644
index 00000000000..4bf9acfbd65
--- /dev/null
+++ b/tests/ui/traits/const-traits/assoc-type.next.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `NonConstAdd: ~const Add` is not satisfied
+  --> $DIR/assoc-type.rs:37:16
+   |
+LL |     type Bar = NonConstAdd;
+   |                ^^^^^^^^^^^
+   |
+note: required by a bound in `Foo::Bar`
+  --> $DIR/assoc-type.rs:33:15
+   |
+LL |     type Bar: ~const Add;
+   |               ^^^^^^ required by this bound in `Foo::Bar`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/assoc-type.rs b/tests/ui/traits/const-traits/assoc-type.rs
index 32c91fa51f1..a169b61994c 100644
--- a/tests/ui/traits/const-traits/assoc-type.rs
+++ b/tests/ui/traits/const-traits/assoc-type.rs
@@ -1,4 +1,5 @@
-//@ compile-flags: -Znext-solver
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
 
 #![feature(const_trait_impl)]
 
diff --git a/tests/ui/traits/const-traits/assoc-type.stderr b/tests/ui/traits/const-traits/assoc-type.stderr
deleted file mode 100644
index b318675b612..00000000000
--- a/tests/ui/traits/const-traits/assoc-type.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0277]: the trait bound `NonConstAdd: ~const Add` is not satisfied
-  --> $DIR/assoc-type.rs:36:16
-   |
-LL |     type Bar = NonConstAdd;
-   |                ^^^^^^^^^^^
-   |
-note: required by a bound in `Foo::Bar`
-  --> $DIR/assoc-type.rs:32:15
-   |
-LL |     type Bar: ~const Add;
-   |               ^^^^^^ required by this bound in `Foo::Bar`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 4dca485db6b0f552d7cee25b4a66f6c05acf9ce3 Mon Sep 17 00:00:00 2001
From: DianQK <dianqk@dianqk.net>
Date: Sun, 22 Dec 2024 14:47:34 +0800
Subject: Add `ignore-rustc-debug-assertions` to
 `tests/ui/associated-consts/issue-93775.rs`

---
 tests/ui/associated-consts/issue-93775.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/associated-consts/issue-93775.rs b/tests/ui/associated-consts/issue-93775.rs
index d7416d03707..88e88b55987 100644
--- a/tests/ui/associated-consts/issue-93775.rs
+++ b/tests/ui/associated-consts/issue-93775.rs
@@ -1,6 +1,6 @@
-//@ ignore-windows-msvc
-// FIXME(#132111, #133432): this test is flaky on windows msvc, it sometimes fail but it sometimes
-// passes.
+//@ ignore-rustc-debug-assertions
+// Similar to stress testing, the test case requires a larger call stack,
+// so we ignore rustc's debug assertions.
 
 //@ build-pass
 // ignore-tidy-linelength
-- 
cgit 1.4.1-3-g733a5


From 9a1c5eb5b385adb3cd04af0049cbf5c225cefdc3 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 21 Dec 2024 17:05:40 +0000
Subject: Begin to implement type system layer of unsafe binders

---
 compiler/rustc_ast_passes/src/feature_gate.rs      |   2 +-
 compiler/rustc_borrowck/src/lib.rs                 |   2 +
 .../rustc_codegen_ssa/src/debuginfo/type_names.rs  |   1 +
 .../rustc_const_eval/src/const_eval/valtrees.rs    |   8 +-
 .../rustc_const_eval/src/interpret/intrinsics.rs   |   1 +
 compiler/rustc_const_eval/src/interpret/stack.rs   |   2 +
 .../rustc_const_eval/src/interpret/validity.rs     |   1 +
 compiler/rustc_const_eval/src/util/type_name.rs    |   3 +-
 .../src/coherence/inherent_impls.rs                |   3 +-
 .../rustc_hir_analysis/src/coherence/orphan.rs     |   3 +-
 .../rustc_hir_analysis/src/hir_ty_lowering/mod.rs  |  14 +-
 .../rustc_hir_analysis/src/variance/constraints.rs |   5 +
 compiler/rustc_hir_typeck/src/cast.rs              |   2 +
 compiler/rustc_hir_typeck/src/expr.rs              |  98 ++++++++++--
 .../src/infer/canonical/canonicalizer.rs           |   1 +
 compiler/rustc_lint/src/types.rs                   |   2 +
 compiler/rustc_middle/src/ty/context.rs            |   4 +-
 compiler/rustc_middle/src/ty/error.rs              |   1 +
 compiler/rustc_middle/src/ty/flags.rs              |   6 +
 compiler/rustc_middle/src/ty/layout.rs             |   5 +
 compiler/rustc_middle/src/ty/print/mod.rs          |   1 +
 compiler/rustc_middle/src/ty/print/pretty.rs       |   4 +
 compiler/rustc_middle/src/ty/structural_impls.rs   |   2 +
 compiler/rustc_middle/src/ty/sty.rs                |  18 ++-
 compiler/rustc_middle/src/ty/util.rs               |  10 +-
 compiler/rustc_middle/src/ty/walk.rs               |   3 +
 .../rustc_mir_dataflow/src/move_paths/builder.rs   |   2 +
 .../rustc_mir_transform/src/dataflow_const_prop.rs |   3 +-
 .../src/lint_tail_expr_drop_order.rs               |   4 +-
 .../rustc_next_trait_solver/src/canonicalizer.rs   |   1 +
 compiler/rustc_next_trait_solver/src/coherence.rs  |   4 +-
 .../src/solve/assembly/mod.rs                      |   2 +
 .../src/solve/assembly/structural_traits.rs        |  15 +-
 .../src/solve/normalizes_to/mod.rs                 |  15 ++
 .../src/solve/trait_goals.rs                       |   3 +-
 compiler/rustc_pattern_analysis/src/rustc.rs       |   1 +
 compiler/rustc_privacy/src/lib.rs                  |   1 +
 .../src/cfi/typeid/itanium_cxx_abi/encode.rs       |   5 +
 .../src/cfi/typeid/itanium_cxx_abi/transform.rs    |   3 +-
 compiler/rustc_smir/src/rustc_smir/convert/ty.rs   |   2 +
 compiler/rustc_span/src/symbol.rs                  |   1 +
 compiler/rustc_symbol_mangling/src/v0.rs           |   3 +
 .../error_reporting/traits/fulfillment_errors.rs   |   1 +
 .../rustc_trait_selection/src/traits/project.rs    |   5 +
 .../src/traits/query/dropck_outlives.rs            |   8 +-
 .../src/traits/select/candidate_assembly.rs        |   9 +-
 .../rustc_trait_selection/src/traits/select/mod.rs |  10 ++
 compiler/rustc_trait_selection/src/traits/wf.rs    |   3 +
 compiler/rustc_ty_utils/src/instance.rs            |   3 +-
 compiler/rustc_ty_utils/src/layout.rs              |   5 +
 compiler/rustc_ty_utils/src/needs_drop.rs          |   5 +
 compiler/rustc_ty_utils/src/ty.rs                  |   2 +
 compiler/rustc_type_ir/src/binder.rs               |   8 +-
 compiler/rustc_type_ir/src/fast_reject.rs          |  12 +-
 compiler/rustc_type_ir/src/inherent.rs             |   3 +
 compiler/rustc_type_ir/src/outlives.rs             |   1 +
 compiler/rustc_type_ir/src/relate.rs               |   4 +
 compiler/rustc_type_ir/src/ty_kind.rs              |  71 +++++++++
 src/librustdoc/clean/mod.rs                        |   2 +
 src/librustdoc/passes/collect_intra_doc_links.rs   |   1 +
 src/tools/clippy/clippy_lints/src/dereference.rs   |   3 +-
 src/tools/clippy/clippy_utils/src/visitors.rs      |   4 +-
 tests/debuginfo/function-names.rs                  |   2 +-
 .../ui-fulldeps/internal-lints/ty_tykind_usage.rs  |  30 +---
 .../internal-lints/ty_tykind_usage.stderr          | 176 +--------------------
 tests/ui/feature-gates/feature-gate-auto-traits.rs |   2 +-
 .../feature-gates/feature-gate-auto-traits.stderr  |   2 +-
 tests/ui/symbol-names/basic.legacy.stderr          |   4 +-
 tests/ui/symbol-names/issue-60925.legacy.stderr    |   4 +-
 .../negative-impls/feature-gate-negative_impls.rs  |   2 +-
 .../feature-gate-negative_impls.stderr             |   2 +-
 tests/ui/unsafe-binders/expr.rs                    |  11 +-
 tests/ui/unsafe-binders/expr.stderr                |  24 ++-
 tests/ui/unsafe-binders/lifetime-resolution.rs     |   7 +-
 tests/ui/unsafe-binders/lifetime-resolution.stderr |  24 +--
 tests/ui/unsafe-binders/mismatch.rs                |  43 +++++
 tests/ui/unsafe-binders/mismatch.stderr            |  68 ++++++++
 tests/ui/unsafe-binders/simple.rs                  |   3 +-
 tests/ui/unsafe-binders/simple.stderr              |  10 +-
 79 files changed, 536 insertions(+), 305 deletions(-)
 create mode 100644 tests/ui/unsafe-binders/mismatch.rs
 create mode 100644 tests/ui/unsafe-binders/mismatch.stderr

(limited to 'tests')

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index f885b20c761..3fbf1210186 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -263,7 +263,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                         &self,
                         negative_impls,
                         span.to(of_trait.as_ref().map_or(span, |t| t.path.span)),
-                        "negative trait bounds are not yet fully implemented; \
+                        "negative trait bounds are not fully implemented; \
                          use marker types for now"
                     );
                 }
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 8ee1b1d0ae6..ac0293848cc 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1613,6 +1613,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::CoroutineWitness(..)
                     | ty::Never
                     | ty::Tuple(_)
+                    | ty::UnsafeBinder(_)
                     | ty::Alias(_, _)
                     | ty::Param(_)
                     | ty::Bound(_, _)
@@ -1654,6 +1655,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Dynamic(_, _, _)
                     | ty::CoroutineWitness(..)
                     | ty::Never
+                    | ty::UnsafeBinder(_)
                     | ty::Alias(_, _)
                     | ty::Param(_)
                     | ty::Bound(_, _)
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index cf72c2ed742..869798d8be1 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -432,6 +432,7 @@ fn push_debuginfo_type_name<'tcx>(
                 push_closure_or_coroutine_name(tcx, def_id, args, qualified, output, visited);
             }
         }
+        ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binders)"),
         ty::Param(_)
         | ty::Error(_)
         | ty::Infer(_)
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
index 6f51b09323d..4ff8aa9a3b4 100644
--- a/compiler/rustc_const_eval/src/const_eval/valtrees.rs
+++ b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -178,7 +178,8 @@ fn const_to_valtree_inner<'tcx>(
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
-        | ty::CoroutineWitness(..) => Err(ValTreeCreationError::NonSupportedType(ty)),
+        | ty::CoroutineWitness(..)
+        | ty::UnsafeBinder(_) => Err(ValTreeCreationError::NonSupportedType(ty)),
     }
 }
 
@@ -358,7 +359,10 @@ pub fn valtree_to_const_value<'tcx>(
         | ty::FnPtr(..)
         | ty::Str
         | ty::Slice(_)
-        | ty::Dynamic(..) => bug!("no ValTree should have been created for type {:?}", ty.kind()),
+        | ty::Dynamic(..)
+        | ty::UnsafeBinder(_) => {
+            bug!("no ValTree should have been created for type {:?}", ty.kind())
+        }
     }
 }
 
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 1af8438534f..e9eca8814c3 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -90,6 +90,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
             | ty::CoroutineWitness(..)
+            | ty::UnsafeBinder(_)
             | ty::Never
             | ty::Tuple(_)
             | ty::Error(_) => ConstValue::from_target_usize(0u64, &tcx),
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 6512675530a..7d0e0492792 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -505,6 +505,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 // We don't want to do any queries, so there is not much we can do with ADTs.
                 ty::Adt(..) => false,
 
+                ty::UnsafeBinder(ty) => is_very_trivially_sized(ty.skip_binder()),
+
                 ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) => false,
 
                 ty::Infer(ty::TyVar(_)) => false,
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 6f101395ccf..d75df1ad442 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -768,6 +768,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 // Nothing to check.
                 interp_ok(true)
             }
+            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
             // The above should be all the primitive types. The rest is compound, we
             // check them by visiting their fields/variants.
             ty::Adt(..)
diff --git a/compiler/rustc_const_eval/src/util/type_name.rs b/compiler/rustc_const_eval/src/util/type_name.rs
index 36c7bed5c11..e14cd603c58 100644
--- a/compiler/rustc_const_eval/src/util/type_name.rs
+++ b/compiler/rustc_const_eval/src/util/type_name.rs
@@ -38,7 +38,8 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
             | ty::FnPtr(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Dynamic(_, _, _) => self.pretty_print_type(ty),
+            | ty::Dynamic(_, _, _)
+            | ty::UnsafeBinder(_) => self.pretty_print_type(ty),
 
             // Placeholders (all printed as `_` to uniformize them).
             ty::Param(_) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => {
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index 8f6f5b5f222..a86dede48bf 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -178,7 +178,8 @@ impl<'tcx> InherentCollect<'tcx> {
             | ty::Ref(..)
             | ty::Never
             | ty::FnPtr(..)
-            | ty::Tuple(..) => self.check_primitive_impl(id, self_ty),
+            | ty::Tuple(..)
+            | ty::UnsafeBinder(_) => self.check_primitive_impl(id, self_ty),
             ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, _) | ty::Param(_) => {
                 Err(self.tcx.dcx().emit_err(errors::InherentNominal { span: item_span }))
             }
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index eca85c22a40..7d651155781 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -225,7 +225,8 @@ pub(crate) fn orphan_check_impl(
             | ty::FnDef(..)
             | ty::FnPtr(..)
             | ty::Never
-            | ty::Tuple(..) => (LocalImpl::Allow, NonlocalImpl::DisallowOther),
+            | ty::Tuple(..)
+            | ty::UnsafeBinder(_) => (LocalImpl::Allow, NonlocalImpl::DisallowOther),
 
             ty::Closure(..)
             | ty::CoroutineClosure(..)
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index b56222763d0..2154568c512 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2318,13 +2318,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     self.lower_fn_ty(hir_ty.hir_id, bf.safety, bf.abi, bf.decl, None, Some(hir_ty)),
                 )
             }
-            hir::TyKind::UnsafeBinder(_binder) => {
-                let guar = self
-                    .dcx()
-                    .struct_span_err(hir_ty.span, "unsafe binders are not yet implemented")
-                    .emit();
-                Ty::new_error(tcx, guar)
-            }
+            hir::TyKind::UnsafeBinder(binder) => Ty::new_unsafe_binder(
+                tcx,
+                ty::Binder::bind_with_vars(
+                    self.lower_ty(binder.inner_ty),
+                    tcx.late_bound_vars(hir_ty.hir_id),
+                ),
+            ),
             hir::TyKind::TraitObject(bounds, lifetime, repr) => {
                 if let Some(guar) = self.prohibit_or_lint_bare_trait_object_ty(hir_ty) {
                     // Don't continue with type analysis if the `dyn` keyword is missing
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs
index 415b23d812b..e954d2b9ea4 100644
--- a/compiler/rustc_hir_analysis/src/variance/constraints.rs
+++ b/compiler/rustc_hir_analysis/src/variance/constraints.rs
@@ -322,6 +322,11 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 self.add_constraints_from_sig(current, sig_tys.with(hdr), variance);
             }
 
+            ty::UnsafeBinder(ty) => {
+                // FIXME(unsafe_binders): This is covariant, right?
+                self.add_constraints_from_ty(current, ty.skip_binder(), variance);
+            }
+
             ty::Error(_) => {
                 // we encounter this when walking the trait references for object
                 // types, where we use Error as the Self type
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 8190095971b..7b07e0ee939 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -116,6 +116,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Some(&f) => self.pointer_kind(f, span)?,
             },
 
+            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+
             // Pointers to foreign types are thin, despite being unsized
             ty::Foreign(..) => Some(PointerKind::Thin),
             // We should really try to normalize here.
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index caea53d9200..5e7dc4370d9 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -574,8 +574,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.check_expr_index(base, idx, expr, brackets_span)
             }
             ExprKind::Yield(value, _) => self.check_expr_yield(value, expr),
-            ExprKind::UnsafeBinderCast(kind, expr, ty) => {
-                self.check_expr_unsafe_binder_cast(kind, expr, ty, expected)
+            ExprKind::UnsafeBinderCast(kind, inner_expr, ty) => {
+                self.check_expr_unsafe_binder_cast(expr.span, kind, inner_expr, ty, expected)
             }
             ExprKind::Err(guar) => Ty::new_error(tcx, guar),
         }
@@ -1649,14 +1649,94 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     fn check_expr_unsafe_binder_cast(
         &self,
-        _kind: hir::UnsafeBinderCastKind,
-        expr: &'tcx hir::Expr<'tcx>,
-        _hir_ty: Option<&'tcx hir::Ty<'tcx>>,
-        _expected: Expectation<'tcx>,
+        span: Span,
+        kind: hir::UnsafeBinderCastKind,
+        inner_expr: &'tcx hir::Expr<'tcx>,
+        hir_ty: Option<&'tcx hir::Ty<'tcx>>,
+        expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
-        let guar =
-            self.dcx().struct_span_err(expr.span, "unsafe binders are not yet implemented").emit();
-        Ty::new_error(self.tcx, guar)
+        self.dcx().span_err(inner_expr.span, "unsafe binder casts are not fully implemented");
+
+        match kind {
+            hir::UnsafeBinderCastKind::Wrap => {
+                let ascribed_ty =
+                    hir_ty.map(|hir_ty| self.lower_ty_saving_user_provided_ty(hir_ty));
+                let expected_ty = expected.only_has_type(self);
+                let binder_ty = match (ascribed_ty, expected_ty) {
+                    (Some(ascribed_ty), Some(expected_ty)) => {
+                        self.demand_eqtype(inner_expr.span, expected_ty, ascribed_ty);
+                        expected_ty
+                    }
+                    (Some(ty), None) | (None, Some(ty)) => ty,
+                    // This will always cause a structural resolve error, but we do it
+                    // so we don't need to manually report an E0282 both on this codepath
+                    // and in the others; it all happens in `structurally_resolve_type`.
+                    (None, None) => self.next_ty_var(inner_expr.span),
+                };
+
+                let binder_ty = self.structurally_resolve_type(inner_expr.span, binder_ty);
+                let hint_ty = match *binder_ty.kind() {
+                    ty::UnsafeBinder(binder) => self.instantiate_binder_with_fresh_vars(
+                        inner_expr.span,
+                        infer::BoundRegionConversionTime::HigherRankedType,
+                        binder.into(),
+                    ),
+                    ty::Error(e) => Ty::new_error(self.tcx, e),
+                    _ => {
+                        let guar = self
+                            .dcx()
+                            .struct_span_err(
+                                hir_ty.map_or(span, |hir_ty| hir_ty.span),
+                                format!(
+                                    "`wrap_binder!()` can only wrap into unsafe binder, not {}",
+                                    binder_ty.sort_string(self.tcx)
+                                ),
+                            )
+                            .with_note("unsafe binders are the only valid output of wrap")
+                            .emit();
+                        Ty::new_error(self.tcx, guar)
+                    }
+                };
+
+                self.check_expr_has_type_or_error(inner_expr, hint_ty, |_| {});
+
+                binder_ty
+            }
+            hir::UnsafeBinderCastKind::Unwrap => {
+                let ascribed_ty =
+                    hir_ty.map(|hir_ty| self.lower_ty_saving_user_provided_ty(hir_ty));
+                let hint_ty = ascribed_ty.unwrap_or_else(|| self.next_ty_var(inner_expr.span));
+                // FIXME(unsafe_binders): coerce here if needed?
+                let binder_ty = self.check_expr_has_type_or_error(inner_expr, hint_ty, |_| {});
+
+                // Unwrap the binder. This will be ambiguous if it's an infer var, and will error
+                // if it's not an unsafe binder.
+                let binder_ty = self.structurally_resolve_type(inner_expr.span, binder_ty);
+                match *binder_ty.kind() {
+                    ty::UnsafeBinder(binder) => self.instantiate_binder_with_fresh_vars(
+                        inner_expr.span,
+                        infer::BoundRegionConversionTime::HigherRankedType,
+                        binder.into(),
+                    ),
+                    ty::Error(e) => Ty::new_error(self.tcx, e),
+                    _ => {
+                        let guar = self
+                            .dcx()
+                            .struct_span_err(
+                                hir_ty.map_or(inner_expr.span, |hir_ty| hir_ty.span),
+                                format!(
+                                    "expected unsafe binder, found {} as input of \
+                                    `unwrap_binder!()`",
+                                    binder_ty.sort_string(self.tcx)
+                                ),
+                            )
+                            .with_note("only an unsafe binder type can be unwrapped")
+                            .emit();
+                        Ty::new_error(self.tcx, guar)
+                    }
+                }
+            }
+        }
     }
 
     fn check_expr_array(
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index fe66d306ceb..c47f27e871f 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -441,6 +441,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             | ty::FnDef(..)
             | ty::FnPtr(..)
             | ty::Dynamic(..)
+            | ty::UnsafeBinder(_)
             | ty::Never
             | ty::Tuple(..)
             | ty::Alias(..)
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index c0371b1f606..ef9aa11ef7b 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1284,6 +1284,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiSafe
             }
 
+            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+
             ty::Param(..)
             | ty::Alias(ty::Projection | ty::Inherent | ty::Weak, ..)
             | ty::Infer(..)
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 977e62becf1..d26c007d227 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -471,7 +471,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
             | ty::Never
-            | ty::Tuple(_) => {
+            | ty::Tuple(_)
+            | ty::UnsafeBinder(_) => {
                 let simp = ty::fast_reject::simplify_type(
                     tcx,
                     self_ty,
@@ -2295,6 +2296,7 @@ impl<'tcx> TyCtxt<'tcx> {
                     Ref,
                     FnDef,
                     FnPtr,
+                    UnsafeBinder,
                     Placeholder,
                     Coroutine,
                     CoroutineWitness,
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
index 4a82af32559..714094db053 100644
--- a/compiler/rustc_middle/src/ty/error.rs
+++ b/compiler/rustc_middle/src/ty/error.rs
@@ -191,6 +191,7 @@ impl<'tcx> Ty<'tcx> {
                 _ => "fn item".into(),
             },
             ty::FnPtr(..) => "fn pointer".into(),
+            ty::UnsafeBinder(_) => "unsafe binder".into(),
             ty::Dynamic(..) => "trait object".into(),
             ty::Closure(..) | ty::CoroutineClosure(..) => "closure".into(),
             ty::Coroutine(def_id, ..) => {
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index 04d03187541..0af57f636aa 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -253,6 +253,12 @@ impl FlagComputation {
             &ty::FnPtr(sig_tys, _) => self.bound_computation(sig_tys, |computation, sig_tys| {
                 computation.add_tys(sig_tys.inputs_and_output);
             }),
+
+            &ty::UnsafeBinder(bound_ty) => {
+                self.bound_computation(bound_ty.into(), |computation, ty| {
+                    computation.add_ty(ty);
+                })
+            }
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 367b0c07f9b..6e6da6de749 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -816,6 +816,11 @@ where
                     bug!("TyAndLayout::field({:?}): not applicable", this)
                 }
 
+                ty::UnsafeBinder(bound_ty) => {
+                    let ty = tcx.instantiate_bound_regions_with_erased(bound_ty.into());
+                    field_ty_or_layout(TyAndLayout { ty, ..this }, cx, i)
+                }
+
                 // Potentially-wide pointers.
                 ty::Ref(_, pointee, _) | ty::RawPtr(pointee, _) => {
                     assert!(i < this.fields.count());
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index cc746746760..b0150bc1192 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -291,6 +291,7 @@ fn characteristic_def_id_of_type_cached<'a>(
         | ty::Uint(_)
         | ty::Str
         | ty::FnPtr(..)
+        | ty::UnsafeBinder(_)
         | ty::Alias(..)
         | ty::Placeholder(..)
         | ty::Param(_)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index a089eac5d7e..8e89331ef03 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -695,6 +695,10 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                 }
             }
             ty::FnPtr(ref sig_tys, hdr) => p!(print(sig_tys.with(hdr))),
+            ty::UnsafeBinder(ref bound_ty) => {
+                // FIXME(unsafe_binders): Make this print `unsafe<>` rather than `for<>`.
+                self.wrap_binder(bound_ty, |ty, cx| cx.pretty_print_type(*ty))?;
+            }
             ty::Infer(infer_ty) => {
                 if self.should_print_verbose() {
                     p!(write("{:?}", ty.kind()));
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index f38454ceac0..68cb56f3583 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -393,6 +393,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::Tuple(ts) => ty::Tuple(ts.try_fold_with(folder)?),
             ty::FnDef(def_id, args) => ty::FnDef(def_id, args.try_fold_with(folder)?),
             ty::FnPtr(sig_tys, hdr) => ty::FnPtr(sig_tys.try_fold_with(folder)?, hdr),
+            ty::UnsafeBinder(f) => ty::UnsafeBinder(f.try_fold_with(folder)?),
             ty::Ref(r, ty, mutbl) => {
                 ty::Ref(r.try_fold_with(folder)?, ty.try_fold_with(folder)?, mutbl)
             }
@@ -443,6 +444,7 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::Tuple(ts) => ts.visit_with(visitor),
             ty::FnDef(_, args) => args.visit_with(visitor),
             ty::FnPtr(ref sig_tys, _) => sig_tys.visit_with(visitor),
+            ty::UnsafeBinder(ref f) => f.visit_with(visitor),
             ty::Ref(r, ty, _) => {
                 try_visit!(r.visit_with(visitor));
                 ty.visit_with(visitor)
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 045c483d6a5..92b3632c8ac 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -673,6 +673,11 @@ impl<'tcx> Ty<'tcx> {
         Ty::new(tcx, FnPtr(sig_tys, hdr))
     }
 
+    #[inline]
+    pub fn new_unsafe_binder(tcx: TyCtxt<'tcx>, b: Binder<'tcx, Ty<'tcx>>) -> Ty<'tcx> {
+        Ty::new(tcx, UnsafeBinder(b.into()))
+    }
+
     #[inline]
     pub fn new_dynamic(
         tcx: TyCtxt<'tcx>,
@@ -962,6 +967,10 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
         Ty::new_pat(interner, ty, pat)
     }
 
+    fn new_unsafe_binder(interner: TyCtxt<'tcx>, ty: ty::Binder<'tcx, Ty<'tcx>>) -> Self {
+        Ty::new_unsafe_binder(interner, ty)
+    }
+
     fn new_unit(interner: TyCtxt<'tcx>) -> Self {
         interner.types.unit
     }
@@ -1480,6 +1489,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::CoroutineWitness(..)
             | ty::Never
             | ty::Tuple(_)
+            | ty::UnsafeBinder(_)
             | ty::Error(_)
             | ty::Infer(IntVar(_) | FloatVar(_)) => tcx.types.u8,
 
@@ -1659,6 +1669,8 @@ impl<'tcx> Ty<'tcx> {
             // metadata of `tail`.
             ty::Param(_) | ty::Alias(..) => Err(tail),
 
+            | ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+
             ty::Infer(ty::TyVar(_))
             | ty::Pat(..)
             | ty::Bound(..)
@@ -1819,6 +1831,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Float(_)
             | ty::FnDef(..)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::RawPtr(..)
             | ty::Char
             | ty::Ref(..)
@@ -1898,6 +1911,8 @@ impl<'tcx> Ty<'tcx> {
             // Might be, but not "trivial" so just giving the safe answer.
             ty::Adt(..) | ty::Closure(..) | ty::CoroutineClosure(..) => false,
 
+            ty::UnsafeBinder(_) => false,
+
             // Needs normalization or revealing to determine, so no is the safe answer.
             ty::Alias(..) => false,
 
@@ -1976,7 +1991,8 @@ impl<'tcx> Ty<'tcx> {
             | Coroutine(_, _)
             | CoroutineWitness(..)
             | Never
-            | Tuple(_) => true,
+            | Tuple(_)
+            | UnsafeBinder(_) => true,
             Error(_) | Infer(_) | Alias(_, _) | Param(_) | Bound(_, _) | Placeholder(_) => false,
         }
     }
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index fc3530e3dde..ab8285f87d6 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1241,6 +1241,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Foreign(_)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::UnsafeBinder(_)
             | ty::Infer(_)
             | ty::Alias(..)
             | ty::Param(_)
@@ -1281,6 +1282,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Foreign(_)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::UnsafeBinder(_)
             | ty::Infer(_)
             | ty::Alias(..)
             | ty::Param(_)
@@ -1322,6 +1324,9 @@ impl<'tcx> Ty<'tcx> {
             | ty::Infer(ty::FreshIntTy(_))
             | ty::Infer(ty::FreshFloatTy(_)) => AsyncDropGlueMorphology::Noop,
 
+            // FIXME(unsafe_binders):
+            ty::UnsafeBinder(_) => todo!(),
+
             ty::Tuple(tys) if tys.is_empty() => AsyncDropGlueMorphology::Noop,
             ty::Adt(adt_def, _) if adt_def.is_manually_drop() => AsyncDropGlueMorphology::Noop,
 
@@ -1522,7 +1527,7 @@ impl<'tcx> Ty<'tcx> {
                 false
             }
 
-            ty::Foreign(_) | ty::CoroutineWitness(..) | ty::Error(_) => false,
+            ty::Foreign(_) | ty::CoroutineWitness(..) | ty::Error(_) | ty::UnsafeBinder(_) => false,
         }
     }
 
@@ -1681,7 +1686,8 @@ pub fn needs_drop_components_with_async<'tcx>(
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
-        | ty::CoroutineWitness(..) => Ok(smallvec![ty]),
+        | ty::CoroutineWitness(..)
+        | ty::UnsafeBinder(_) => Ok(smallvec![ty]),
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/walk.rs b/compiler/rustc_middle/src/ty/walk.rs
index a93a146ec7c..2dcba8c2f82 100644
--- a/compiler/rustc_middle/src/ty/walk.rs
+++ b/compiler/rustc_middle/src/ty/walk.rs
@@ -194,6 +194,9 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
                     sig_tys.skip_binder().inputs_and_output.iter().rev().map(|ty| ty.into()),
                 );
             }
+            ty::UnsafeBinder(bound_ty) => {
+                stack.push(bound_ty.skip_binder().into());
+            }
         },
         GenericArgKind::Lifetime(_) => {}
         GenericArgKind::Const(parent_ct) => match parent_ct.kind() {
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 0880364bfca..d1b3a389e9e 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -161,6 +161,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::CoroutineWitness(..)
                     | ty::Never
                     | ty::Tuple(_)
+                    | ty::UnsafeBinder(_)
                     | ty::Alias(_, _)
                     | ty::Param(_)
                     | ty::Bound(_, _)
@@ -200,6 +201,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::Dynamic(_, _, _)
                     | ty::CoroutineWitness(..)
                     | ty::Never
+                    | ty::UnsafeBinder(_)
                     | ty::Alias(_, _)
                     | ty::Param(_)
                     | ty::Bound(_, _)
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index 711cf2edc46..51af77778af 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -944,7 +944,8 @@ fn try_write_constant<'tcx>(
         | ty::Closure(..)
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
-        | ty::Dynamic(..) => throw_machine_stop_str!("unsupported type"),
+        | ty::Dynamic(..)
+        | ty::UnsafeBinder(_) => throw_machine_stop_str!("unsupported type"),
 
         ty::Error(_) | ty::Infer(..) | ty::CoroutineWitness(..) => bug!(),
     }
diff --git a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
index 7fb421dea0c..e5a183bc75c 100644
--- a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
+++ b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
@@ -285,7 +285,9 @@ fn ty_dtor_span<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Span> {
         | ty::Placeholder(_)
         | ty::Infer(_)
         | ty::Slice(_)
-        | ty::Array(_, _) => None,
+        | ty::Array(_, _)
+        | ty::UnsafeBinder(_) => None,
+
         ty::Adt(adt_def, _) => {
             let did = adt_def.did();
             let try_local_did_span = |did: DefId| {
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 2f7301d8fe5..8a54a4ece98 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -378,6 +378,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             | ty::Pat(_, _)
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
diff --git a/compiler/rustc_next_trait_solver/src/coherence.rs b/compiler/rustc_next_trait_solver/src/coherence.rs
index 2461ef0c0df..408742747c2 100644
--- a/compiler/rustc_next_trait_solver/src/coherence.rs
+++ b/compiler/rustc_next_trait_solver/src/coherence.rs
@@ -339,7 +339,9 @@ where
             | ty::Slice(..)
             | ty::RawPtr(..)
             | ty::Never
-            | ty::Tuple(..) => self.found_non_local_ty(ty),
+            | ty::Tuple(..)
+            // FIXME(unsafe_binders): Non-local?
+            | ty::UnsafeBinder(_) => self.found_non_local_ty(ty),
 
             ty::Param(..) => panic!("unexpected ty param"),
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
index 02f6439b77f..63432dc199b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -545,6 +545,7 @@ where
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Dynamic(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
@@ -634,6 +635,7 @@ where
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Alias(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 05ce61bc067..7da4f5e0107 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -83,6 +83,8 @@ where
             .map(|bty| bty.instantiate(cx, args))
             .collect()),
 
+        ty::UnsafeBinder(bound_ty) => Ok(vec![bound_ty.into()]),
+
         // For `PhantomData<T>`, we pass `T`.
         ty::Adt(def, args) if def.is_phantom_data() => Ok(vec![ty::Binder::dummy(args.type_at(0))]),
 
@@ -144,6 +146,8 @@ where
             panic!("unexpected type `{ty:?}`")
         }
 
+        ty::UnsafeBinder(bound_ty) => Ok(vec![bound_ty.into()]),
+
         // impl Sized for ()
         // impl Sized for (T1, T2, .., Tn) where Tn: Sized if n >= 1
         ty::Tuple(tys) => Ok(tys.last().map_or_else(Vec::new, |ty| vec![ty::Binder::dummy(ty)])),
@@ -239,6 +243,8 @@ where
             }
         },
 
+        ty::UnsafeBinder(_) => Err(NoSolution),
+
         // impl Copy/Clone for CoroutineWitness where T: Copy/Clone forall T in coroutine_hidden_types
         ty::CoroutineWitness(def_id, args) => Ok(ecx
             .cx()
@@ -374,6 +380,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
         | ty::Never
         | ty::Tuple(_)
         | ty::Pat(_, _)
+        | ty::UnsafeBinder(_)
         | ty::Alias(_, _)
         | ty::Param(_)
         | ty::Placeholder(..)
@@ -544,6 +551,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
         | ty::Never
+        | ty::UnsafeBinder(_)
         | ty::Tuple(_)
         | ty::Alias(_, _)
         | ty::Param(_)
@@ -694,7 +702,8 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
         | ty::Param(_)
         | ty::Placeholder(..)
         | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
-        | ty::Error(_) => return Err(NoSolution),
+        | ty::Error(_)
+        | ty::UnsafeBinder(_) => return Err(NoSolution),
 
         ty::Bound(..)
         | ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
@@ -764,6 +773,10 @@ pub(in crate::solve) fn const_conditions_for_destruct<I: Interner>(
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(_, _) => Err(NoSolution),
 
+        // FIXME(unsafe_binders): Unsafe binders could implement `~const Drop`
+        // if their inner type implements it.
+        ty::UnsafeBinder(_) => Err(NoSolution),
+
         ty::Dynamic(..) | ty::Param(_) | ty::Alias(..) | ty::Placeholder(_) | ty::Foreign(_) => {
             Err(NoSolution)
         }
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index b8867192225..f5ecfea5408 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -619,6 +619,11 @@ where
                     Some(tail_ty) => Ty::new_projection(cx, metadata_def_id, [tail_ty]),
                 },
 
+                ty::UnsafeBinder(_) => {
+                    // FIXME(unsafe_binder): Figure out how to handle pointee for unsafe binders.
+                    todo!()
+                }
+
                 ty::Infer(
                     ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_),
                 )
@@ -822,6 +827,11 @@ where
             | ty::Tuple(_)
             | ty::Error(_) => self_ty.discriminant_ty(ecx.cx()),
 
+            ty::UnsafeBinder(_) => {
+                // FIXME(unsafe_binders): instantiate this with placeholders?? i guess??
+                todo!("discr subgoal...")
+            }
+
             // We do not call `Ty::discriminant_ty` on alias, param, or placeholder
             // types, which return `<self_ty as DiscriminantKind>::Discriminant`
             // (or ICE in the case of placeholders). Projecting a type to itself
@@ -869,6 +879,11 @@ where
             | ty::Tuple(_)
             | ty::Error(_) => self_ty.async_destructor_ty(ecx.cx()),
 
+            ty::UnsafeBinder(_) => {
+                // FIXME(unsafe_binders): Instantiate the binder with placeholders I guess.
+                todo!()
+            }
+
             // We do not call `Ty::async_destructor_ty` on alias, param, or placeholder
             // types, which return `<self_ty as AsyncDestruct>::AsyncDestructor`
             // (or ICE in the case of placeholders). Projecting a type to itself
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index 886cdec0345..d68fca60829 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -1100,7 +1100,8 @@ where
             | ty::CoroutineWitness(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Adt(_, _) => {
+            | ty::Adt(_, _)
+            | ty::UnsafeBinder(_) => {
                 let mut disqualifying_impl = None;
                 self.cx().for_each_relevant_impl(
                     goal.predicate.def_id(),
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 009d817a1a9..ae991e3ce40 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -415,6 +415,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
+            | ty::UnsafeBinder(_)
             | ty::Alias(_, _)
             | ty::Param(_)
             | ty::Error(_) => ConstructorSet::Unlistable,
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index c50c9007a01..9ae2d981ab0 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -285,6 +285,7 @@ where
             | ty::Ref(..)
             | ty::Pat(..)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Param(..)
             | ty::Bound(..)
             | ty::Error(_)
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index 34e1c31683a..895259d52a7 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -621,6 +621,11 @@ pub(crate) fn encode_ty<'tcx>(
             typeid.push_str(&s);
         }
 
+        // FIXME(unsafe_binders): Implement this.
+        ty::UnsafeBinder(_) => {
+            todo!()
+        }
+
         // Trait types
         ty::Dynamic(predicates, region, kind) => {
             // u3dynI<element-type1[..element-typeN]>E, where <element-type> is <predicate>, as
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index 9c01bd04353..9c6186d6882 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -64,7 +64,8 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for TransformTy<'tcx> {
             | ty::Pat(..)
             | ty::Slice(..)
             | ty::Str
-            | ty::Tuple(..) => t.super_fold_with(self),
+            | ty::Tuple(..)
+            | ty::UnsafeBinder(_) => t.super_fold_with(self),
 
             ty::Bool => {
                 if self.options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) {
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index a4f61313001..e15dad78c69 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -356,6 +356,8 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
             ty::FnPtr(sig_tys, hdr) => {
                 TyKind::RigidTy(RigidTy::FnPtr(sig_tys.with(*hdr).stable(tables)))
             }
+            // FIXME(unsafe_binders):
+            ty::UnsafeBinder(_) => todo!(),
             ty::Dynamic(existential_predicates, region, dyn_kind) => {
                 TyKind::RigidTy(RigidTy::Dynamic(
                     existential_predicates
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 123e4b1f01f..65e515c0c2d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2149,6 +2149,7 @@ symbols! {
         unwrap,
         unwrap_binder,
         unwrap_or,
+        unwrap_unsafe_binder,
         use_extern_macros,
         use_nested_groups,
         used,
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index a801b3e53a1..0ca47eba5e8 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -466,6 +466,9 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
                 })?;
             }
 
+            // FIXME(unsafe_binder):
+            ty::UnsafeBinder(..) => todo!(),
+
             ty::Dynamic(predicates, r, kind) => {
                 self.push(match kind {
                     ty::Dyn => "D",
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index d41f8f46c17..885b606326c 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1532,6 +1532,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 ty::CoroutineWitness(..) => Some(20),
                 ty::CoroutineClosure(..) => Some(21),
                 ty::Pat(..) => Some(22),
+                ty::UnsafeBinder(..) => Some(23),
                 ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) | ty::Error(_) => None,
             }
         }
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 4bccd3450bc..54407d17dcf 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1047,6 +1047,8 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         // Integers and floats always have `u8` as their discriminant.
                         | ty::Infer(ty::InferTy::IntVar(_) | ty::InferTy::FloatVar(..)) => true,
 
+                        ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+
                         // type parameters, opaques, and unnormalized projections don't have
                         // a known discriminant and may need to be normalized further or rely
                         // on param env for discriminant projections
@@ -1072,6 +1074,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         | ty::Ref(..)
                         | ty::FnDef(..)
                         | ty::FnPtr(..)
+                        | ty::UnsafeBinder(_)
                         | ty::Dynamic(..)
                         | ty::Closure(..)
                         | ty::CoroutineClosure(..)
@@ -1163,6 +1166,8 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                             true
                         }
 
+                        ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+
                         // FIXME(compiler-errors): are Bound and Placeholder types ever known sized?
                         ty::Param(_)
                         | ty::Alias(..)
diff --git a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
index 1d3e8d43af7..4004e354dc1 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -83,7 +83,8 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         | ty::Placeholder(..)
         | ty::Infer(_)
         | ty::Bound(..)
-        | ty::Coroutine(..) => false,
+        | ty::Coroutine(..)
+        | ty::UnsafeBinder(_) => false,
     }
 }
 
@@ -336,6 +337,11 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
             constraints.dtorck_types.push(ty);
         }
 
+        // Can't instantiate binder here.
+        ty::UnsafeBinder(_) => {
+            constraints.dtorck_types.push(ty);
+        }
+
         ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) | ty::Error(_) => {
             // By the time this code runs, all type variables ought to
             // be fully resolved.
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 5e27fd43789..d6ac4baf8ad 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -619,7 +619,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 continue;
             }
 
-            match obligation.self_ty().skip_binder().kind() {
+            let self_ty = obligation.self_ty().skip_binder();
+            match self_ty.kind() {
                 // Fast path to avoid evaluating an obligation that trivially holds.
                 // There may be more bounds, but these are checked by the regular path.
                 ty::FnPtr(..) => return false,
@@ -651,6 +652,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::CoroutineClosure(..)
                 | ty::Coroutine(_, _)
                 | ty::CoroutineWitness(..)
+                | ty::UnsafeBinder(_)
                 | ty::Never
                 | ty::Tuple(_)
                 | ty::Error(_) => return true,
@@ -794,7 +796,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::Coroutine(..)
                 | ty::Never
                 | ty::Tuple(_)
-                | ty::CoroutineWitness(..) => {
+                | ty::CoroutineWitness(..)
+                | ty::UnsafeBinder(_) => {
                     // Only consider auto impls of unsafe traits when there are
                     // no unsafe fields.
                     if self.tcx().trait_is_unsafe(def_id) && self_ty.has_unsafe_fields() {
@@ -1176,6 +1179,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::FnDef(_, _)
             | ty::Pat(_, _)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
@@ -1220,6 +1224,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
+            | ty::UnsafeBinder(_)
             | ty::Never
             | ty::Tuple(..)
             | ty::Alias(..)
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 0462b1d9ee7..7857ed95cc7 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2095,6 +2095,9 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 }
             }
 
+            // FIXME(unsafe_binders): This binder needs to be squashed
+            ty::UnsafeBinder(binder_ty) => Where(binder_ty.map_bound(|ty| vec![ty])),
+
             ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) => None,
             ty::Infer(ty::TyVar(_)) => Ambiguous,
 
@@ -2133,6 +2136,10 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 None
             }
 
+            // FIXME(unsafe_binder): Should we conditionally
+            // (i.e. universally) implement copy/clone?
+            ty::UnsafeBinder(_) => None,
+
             ty::Dynamic(..)
             | ty::Str
             | ty::Slice(..)
@@ -2285,6 +2292,9 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Never
             | ty::Char => ty::Binder::dummy(Vec::new()),
 
+            // FIXME(unsafe_binders): Squash the double binder for now, I guess.
+            ty::UnsafeBinder(_) => return Err(SelectionError::Unimplemented),
+
             // Treat this like `struct str([u8]);`
             ty::Str => ty::Binder::dummy(vec![Ty::new_slice(self.tcx(), self.tcx().types.u8)]),
 
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index c95b1641d1f..9d32eb05386 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -828,6 +828,9 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 // Let the visitor iterate into the argument/return
                 // types appearing in the fn signature.
             }
+            ty::UnsafeBinder(_) => {
+                // FIXME(unsafe_binders): We should also recurse into the binder here.
+            }
 
             ty::Dynamic(data, r, _) => {
                 // WfObject
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
index eb30169a7d9..fc76a86f797 100644
--- a/compiler/rustc_ty_utils/src/instance.rs
+++ b/compiler/rustc_ty_utils/src/instance.rs
@@ -49,7 +49,8 @@ fn resolve_instance_raw<'tcx>(
                     | ty::Adt(..)
                     | ty::Dynamic(..)
                     | ty::Array(..)
-                    | ty::Slice(..) => {}
+                    | ty::Slice(..)
+                    | ty::UnsafeBinder(..) => {}
                     // Drop shims can only be built from ADTs.
                     _ => return Ok(None),
                 }
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index a3b2ed07d4b..9f138cf1275 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -666,6 +666,11 @@ fn layout_of_uncached<'tcx>(
             tcx.mk_layout(layout)
         }
 
+        ty::UnsafeBinder(bound_ty) => {
+            let ty = tcx.instantiate_bound_regions_with_erased(bound_ty.into());
+            cx.layout_of(ty)?.layout
+        }
+
         // Types with no meaningful known layout.
         ty::Alias(..) => {
             // NOTE(eddyb) `layout_of` query should've normalized these away,
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index 1c85eb2a861..80de7e20951 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -202,6 +202,11 @@ where
                         }
                     }
 
+                    ty::UnsafeBinder(bound_ty) => {
+                        let ty = self.tcx.instantiate_bound_regions_with_erased(bound_ty.into());
+                        queue_type(self, ty);
+                    }
+
                     _ if tcx.type_is_copy_modulo_regions(self.typing_env, component) => {}
 
                     ty::Closure(_, args) => {
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 774f0660258..7eed32e3a33 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -37,6 +37,8 @@ fn sized_constraint_for_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'
         | Never
         | Dynamic(_, _, ty::DynStar) => None,
 
+        UnsafeBinder(_) => todo!(),
+
         // these are never sized
         Str | Slice(..) | Dynamic(_, _, ty::Dyn) | Foreign(..) => Some(ty),
 
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index c06a578d8ec..47447af2215 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -6,8 +6,6 @@ use std::ops::{ControlFlow, Deref};
 use derive_where::derive_where;
 #[cfg(feature = "nightly")]
 use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
-#[cfg(feature = "nightly")]
-use rustc_serialize::Decodable;
 use tracing::instrument;
 
 use crate::data_structures::SsoHashSet;
@@ -69,14 +67,14 @@ macro_rules! impl_binder_encode_decode {
                     self.as_ref().skip_binder().encode(e);
                 }
             }
-            impl<I: Interner, D: crate::TyDecoder<I = I>> Decodable<D> for ty::Binder<I, $t>
+            impl<I: Interner, D: crate::TyDecoder<I = I>> rustc_serialize::Decodable<D> for ty::Binder<I, $t>
             where
                 $t: TypeVisitable<I> + rustc_serialize::Decodable<D>,
                 I::BoundVarKinds: rustc_serialize::Decodable<D>,
             {
                 fn decode(decoder: &mut D) -> Self {
-                    let bound_vars = Decodable::decode(decoder);
-                    ty::Binder::bind_with_vars(<$t>::decode(decoder), bound_vars)
+                    let bound_vars = rustc_serialize::Decodable::decode(decoder);
+                    ty::Binder::bind_with_vars(rustc_serialize::Decodable::decode(decoder), bound_vars)
                 }
             }
         )*
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
index 81c8a7d4bfa..9b3ff14d507 100644
--- a/compiler/rustc_type_ir/src/fast_reject.rs
+++ b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -41,6 +41,7 @@ pub enum SimplifiedType<DefId> {
     Coroutine(DefId),
     CoroutineWitness(DefId),
     Function(usize),
+    UnsafeBinder,
     Placeholder,
     Error,
 }
@@ -138,6 +139,7 @@ pub fn simplify_type<I: Interner>(
         ty::FnPtr(sig_tys, _hdr) => {
             Some(SimplifiedType::Function(sig_tys.skip_binder().inputs().len()))
         }
+        ty::UnsafeBinder(_) => Some(SimplifiedType::UnsafeBinder),
         ty::Placeholder(..) => Some(SimplifiedType::Placeholder),
         ty::Param(_) => match treat_params {
             TreatParams::AsRigid => Some(SimplifiedType::Placeholder),
@@ -290,7 +292,8 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
             | ty::Foreign(_)
-            | ty::Placeholder(_) => {}
+            | ty::Placeholder(_)
+            | ty::UnsafeBinder(_) => {}
         };
 
         // The type system needs to support exponentially large types
@@ -447,6 +450,13 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
                 matches!(rhs.kind(), ty::Pat(rhs_ty, _) if self.types_may_unify_inner(lhs_ty, rhs_ty, depth))
             }
 
+            ty::UnsafeBinder(lhs_ty) => match rhs.kind() {
+                ty::UnsafeBinder(rhs_ty) => {
+                    self.types_may_unify(lhs_ty.skip_binder(), rhs_ty.skip_binder())
+                }
+                _ => false,
+            },
+
             ty::Error(..) => true,
         }
     }
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 2db40accda3..872cf668018 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -112,6 +112,8 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn new_pat(interner: I, ty: Self, pat: I::Pat) -> Self;
 
+    fn new_unsafe_binder(interner: I, ty: ty::Binder<I, I::Ty>) -> Self;
+
     fn tuple_fields(self) -> I::Tys;
 
     fn to_opt_closure_kind(self) -> Option<ty::ClosureKind>;
@@ -185,6 +187,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Dynamic(_, _, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs
index 0e94e989b97..c26e211a794 100644
--- a/compiler/rustc_type_ir/src/outlives.rs
+++ b/compiler/rustc_type_ir/src/outlives.rs
@@ -202,6 +202,7 @@ impl<I: Interner> TypeVisitor<I> for OutlivesCollector<'_, I> {
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnPtr(..)
+            | ty::UnsafeBinder(_)
             | ty::Dynamic(_, _, _)
             | ty::Tuple(_) => {
                 ty.super_visit_with(self);
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
index 0b013b2017f..e628b66d2f0 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -549,6 +549,10 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
             Ok(Ty::new_pat(cx, ty, pat))
         }
 
+        (ty::UnsafeBinder(a_binder), ty::UnsafeBinder(b_binder)) => {
+            Ok(Ty::new_unsafe_binder(cx, relation.binders(*a_binder, *b_binder)?))
+        }
+
         _ => Err(TypeError::Sorts(ExpectedFound::new(a, b))),
     }
 }
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 033fcdb6c03..52e4fa19cb0 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -1,4 +1,5 @@
 use std::fmt;
+use std::ops::Deref;
 
 use derive_where::derive_where;
 use rustc_ast_ir::Mutability;
@@ -13,6 +14,7 @@ use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Gen
 use self::TyKind::*;
 pub use self::closure::*;
 use crate::inherent::*;
+use crate::visit::TypeVisitable;
 use crate::{self as ty, DebruijnIndex, Interner};
 
 mod closure;
@@ -150,6 +152,13 @@ pub enum TyKind<I: Interner> {
     /// worth the mild inconvenience.
     FnPtr(ty::Binder<I, FnSigTys<I>>, FnHeader<I>),
 
+    /// An unsafe binder type.
+    ///
+    /// A higher-ranked type used to represent a type which has had some of its
+    /// lifetimes erased. This can be used to represent types in positions where
+    /// a lifetime is literally inexpressible, such as self-referential types.
+    UnsafeBinder(UnsafeBinderInner<I>),
+
     /// A trait object. Written as `dyn for<'b> Trait<'b, Assoc = u32> + Send + 'a`.
     Dynamic(I::BoundExistentialPredicates, I::Region, DynKind),
 
@@ -287,6 +296,8 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
             Ref(r, t, m) => write!(f, "&{:?} {}{:?}", r, m.prefix_str(), t),
             FnDef(d, s) => f.debug_tuple("FnDef").field(d).field(&s).finish(),
             FnPtr(sig_tys, hdr) => write!(f, "{:?}", sig_tys.with(*hdr)),
+            // FIXME(unsafe_binder): print this like `unsafe<'a> T<'a>`.
+            UnsafeBinder(binder) => write!(f, "{:?}", binder),
             Dynamic(p, r, repr) => match repr {
                 DynKind::Dyn => write!(f, "dyn {p:?} + {r:?}"),
                 DynKind::DynStar => write!(f, "dyn* {p:?} + {r:?}"),
@@ -964,6 +975,66 @@ impl<I: Interner> fmt::Debug for FnSig<I> {
     }
 }
 
+// FIXME: this is a distinct type because we need to define `Encode`/`Decode`
+// impls in this crate for `Binder<I, I::Ty>`.
+#[derive_where(Clone, Copy, PartialEq, Eq, Hash; I: Interner)]
+#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
+pub struct UnsafeBinderInner<I: Interner>(ty::Binder<I, I::Ty>);
+
+impl<I: Interner> From<ty::Binder<I, I::Ty>> for UnsafeBinderInner<I> {
+    fn from(value: ty::Binder<I, I::Ty>) -> Self {
+        UnsafeBinderInner(value)
+    }
+}
+
+impl<I: Interner> From<UnsafeBinderInner<I>> for ty::Binder<I, I::Ty> {
+    fn from(value: UnsafeBinderInner<I>) -> Self {
+        value.0
+    }
+}
+
+impl<I: Interner> fmt::Debug for UnsafeBinderInner<I> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<I: Interner> Deref for UnsafeBinderInner<I> {
+    type Target = ty::Binder<I, I::Ty>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<I: Interner, E: crate::TyEncoder<I = I>> rustc_serialize::Encodable<E> for UnsafeBinderInner<I>
+where
+    I::Ty: rustc_serialize::Encodable<E>,
+    I::BoundVarKinds: rustc_serialize::Encodable<E>,
+{
+    fn encode(&self, e: &mut E) {
+        self.bound_vars().encode(e);
+        self.as_ref().skip_binder().encode(e);
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<I: Interner, D: crate::TyDecoder<I = I>> rustc_serialize::Decodable<D> for UnsafeBinderInner<I>
+where
+    I::Ty: TypeVisitable<I> + rustc_serialize::Decodable<D>,
+    I::BoundVarKinds: rustc_serialize::Decodable<D>,
+{
+    fn decode(decoder: &mut D) -> Self {
+        let bound_vars = rustc_serialize::Decodable::decode(decoder);
+        UnsafeBinderInner(ty::Binder::bind_with_vars(
+            rustc_serialize::Decodable::decode(decoder),
+            bound_vars,
+        ))
+    }
+}
+
 // This is just a `FnSig` without the `FnHeader` fields.
 #[derive_where(Clone, Copy, Debug, PartialEq, Eq, Hash; I: Interner)]
 #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 9d0c0f687c7..4d46f0e75c8 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2255,12 +2255,14 @@ pub(crate) fn clean_middle_ty<'tcx>(
             }
         }
 
+        ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binders)"),
         ty::Closure(..) => panic!("Closure"),
         ty::CoroutineClosure(..) => panic!("CoroutineClosure"),
         ty::Coroutine(..) => panic!("Coroutine"),
         ty::Placeholder(..) => panic!("Placeholder"),
         ty::CoroutineWitness(..) => panic!("CoroutineWitness"),
         ty::Infer(..) => panic!("Infer"),
+
         ty::Error(_) => FatalError.raise(),
     }
 }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index c9d1ceb0a91..3c1d0c35bef 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -559,6 +559,7 @@ impl<'tcx> LinkCollector<'_, 'tcx> {
             | ty::Coroutine(..)
             | ty::CoroutineWitness(..)
             | ty::Dynamic(..)
+            | ty::UnsafeBinder(_)
             | ty::Param(_)
             | ty::Bound(..)
             | ty::Placeholder(_)
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index e3959903fdd..821312a9e40 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -877,7 +877,8 @@ impl TyCoercionStability {
                 | ty::CoroutineClosure(..)
                 | ty::Never
                 | ty::Tuple(_)
-                | ty::Alias(ty::Projection, _) => Self::Deref,
+                | ty::Alias(ty::Projection, _)
+                | ty::UnsafeBinder(_) => Self::Deref,
             };
         }
     }
diff --git a/src/tools/clippy/clippy_utils/src/visitors.rs b/src/tools/clippy/clippy_utils/src/visitors.rs
index 71499b1293a..afceeec2272 100644
--- a/src/tools/clippy/clippy_utils/src/visitors.rs
+++ b/src/tools/clippy/clippy_utils/src/visitors.rs
@@ -677,6 +677,9 @@ pub fn for_each_unconsumed_temporary<'tcx, B>(
             ExprKind::Type(e, _) => {
                 helper(typeck, consume, e, f)?;
             },
+            ExprKind::UnsafeBinderCast(_, e, _) => {
+                helper(typeck, consume, e, f)?;
+            },
 
             // Either drops temporaries, jumps out of the current expression, or has no sub expression.
             ExprKind::DropTemps(_)
@@ -694,7 +697,6 @@ pub fn for_each_unconsumed_temporary<'tcx, B>(
             | ExprKind::Continue(_)
             | ExprKind::InlineAsm(_)
             | ExprKind::OffsetOf(..)
-            | ExprKind::UnsafeBinderCast(..)
             | ExprKind::Err(_) => (),
         }
         ControlFlow::Continue(())
diff --git a/tests/debuginfo/function-names.rs b/tests/debuginfo/function-names.rs
index d9b61e73621..c51884451e5 100644
--- a/tests/debuginfo/function-names.rs
+++ b/tests/debuginfo/function-names.rs
@@ -37,7 +37,7 @@
 // Const generic parameter
 // gdb-command:info functions -q function_names::const_generic_fn.*
 // gdb-check:[...]static fn function_names::const_generic_fn_bool<false>();
-// gdb-check:[...]static fn function_names::const_generic_fn_non_int<{CONST#a70c39591cb5f53d}>();
+// gdb-check:[...]static fn function_names::const_generic_fn_non_int<{CONST#ffa3db4ca1d52dce}>();
 // gdb-check:[...]static fn function_names::const_generic_fn_signed_int<-7>();
 // gdb-check:[...]static fn function_names::const_generic_fn_unsigned_int<14>();
 
diff --git a/tests/ui-fulldeps/internal-lints/ty_tykind_usage.rs b/tests/ui-fulldeps/internal-lints/ty_tykind_usage.rs
index f77b318039d..91998a8ec45 100644
--- a/tests/ui-fulldeps/internal-lints/ty_tykind_usage.rs
+++ b/tests/ui-fulldeps/internal-lints/ty_tykind_usage.rs
@@ -13,34 +13,8 @@ fn main() {
     let kind = TyKind::Bool; //~ ERROR usage of `ty::TyKind::<kind>`
 
     match kind {
-        TyKind::Bool => (),                 //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Char => (),                 //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Int(..) => (),              //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Uint(..) => (),             //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Float(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Adt(..) => (),              //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Foreign(..) => (),          //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Str => (),                  //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Array(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Pat(..) => (),              //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Slice(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::RawPtr(..) => (),           //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Ref(..) => (),              //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::FnDef(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::FnPtr(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Dynamic(..) => (),          //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Closure(..) => (),          //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::CoroutineClosure(..) => (), //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Coroutine(..) => (),        //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::CoroutineWitness(..) => (), //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Never => (),                //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Tuple(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Alias(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Param(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Bound(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Placeholder(..) => (),      //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Infer(..) => (),            //~ ERROR usage of `ty::TyKind::<kind>`
-        TyKind::Error(_) => (),             //~ ERROR usage of `ty::TyKind::<kind>`
+        TyKind::Bool => {},                 //~ ERROR usage of `ty::TyKind::<kind>`
+        _ => {}
     }
 
     if let ty::Int(int_ty) = kind {}
diff --git a/tests/ui-fulldeps/internal-lints/ty_tykind_usage.stderr b/tests/ui-fulldeps/internal-lints/ty_tykind_usage.stderr
index 53bf5cb1a82..19a73b36bfe 100644
--- a/tests/ui-fulldeps/internal-lints/ty_tykind_usage.stderr
+++ b/tests/ui-fulldeps/internal-lints/ty_tykind_usage.stderr
@@ -13,179 +13,17 @@ LL | #[deny(rustc::usage_of_ty_tykind)]
 error: usage of `ty::TyKind::<kind>`
   --> $DIR/ty_tykind_usage.rs:16:9
    |
-LL |         TyKind::Bool => (),
+LL |         TyKind::Bool => {},
    |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
 
 error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:17:9
-   |
-LL |         TyKind::Char => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:18:9
-   |
-LL |         TyKind::Int(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:19:9
-   |
-LL |         TyKind::Uint(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:20:9
-   |
-LL |         TyKind::Float(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:21:9
-   |
-LL |         TyKind::Adt(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:22:9
-   |
-LL |         TyKind::Foreign(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:23:9
-   |
-LL |         TyKind::Str => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:24:9
-   |
-LL |         TyKind::Array(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:25:9
-   |
-LL |         TyKind::Pat(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:26:9
-   |
-LL |         TyKind::Slice(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:27:9
-   |
-LL |         TyKind::RawPtr(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:28:9
-   |
-LL |         TyKind::Ref(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:29:9
-   |
-LL |         TyKind::FnDef(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:30:9
-   |
-LL |         TyKind::FnPtr(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:31:9
-   |
-LL |         TyKind::Dynamic(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:32:9
-   |
-LL |         TyKind::Closure(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:33:9
-   |
-LL |         TyKind::CoroutineClosure(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:34:9
-   |
-LL |         TyKind::Coroutine(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:35:9
-   |
-LL |         TyKind::CoroutineWitness(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:36:9
-   |
-LL |         TyKind::Never => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:37:9
-   |
-LL |         TyKind::Tuple(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:38:9
-   |
-LL |         TyKind::Alias(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:39:9
-   |
-LL |         TyKind::Param(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:40:9
-   |
-LL |         TyKind::Bound(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:41:9
-   |
-LL |         TyKind::Placeholder(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:42:9
-   |
-LL |         TyKind::Infer(..) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:43:9
-   |
-LL |         TyKind::Error(_) => (),
-   |         ^^^^^^ help: try using `ty::<kind>` directly: `ty`
-
-error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:48:12
+  --> $DIR/ty_tykind_usage.rs:22:12
    |
 LL |     if let TyKind::Int(int_ty) = kind {}
    |            ^^^^^^ help: try using `ty::<kind>` directly: `ty`
 
 error: usage of `ty::TyKind`
-  --> $DIR/ty_tykind_usage.rs:50:24
+  --> $DIR/ty_tykind_usage.rs:24:24
    |
 LL |     fn ty_kind(ty_bad: TyKind<'_>, ty_good: Ty<'_>) {}
    |                        ^^^^^^^^^^
@@ -193,7 +31,7 @@ LL |     fn ty_kind(ty_bad: TyKind<'_>, ty_good: Ty<'_>) {}
    = help: try using `Ty` instead
 
 error: usage of `ty::TyKind`
-  --> $DIR/ty_tykind_usage.rs:52:37
+  --> $DIR/ty_tykind_usage.rs:26:37
    |
 LL |     fn ir_ty_kind<I: Interner>(bad: IrTyKind<I>) -> IrTyKind<I> {
    |                                     ^^^^^^^^^^^
@@ -201,7 +39,7 @@ LL |     fn ir_ty_kind<I: Interner>(bad: IrTyKind<I>) -> IrTyKind<I> {
    = help: try using `Ty` instead
 
 error: usage of `ty::TyKind`
-  --> $DIR/ty_tykind_usage.rs:52:53
+  --> $DIR/ty_tykind_usage.rs:26:53
    |
 LL |     fn ir_ty_kind<I: Interner>(bad: IrTyKind<I>) -> IrTyKind<I> {
    |                                                     ^^^^^^^^^^^
@@ -209,12 +47,12 @@ LL |     fn ir_ty_kind<I: Interner>(bad: IrTyKind<I>) -> IrTyKind<I> {
    = help: try using `Ty` instead
 
 error: usage of `ty::TyKind::<kind>`
-  --> $DIR/ty_tykind_usage.rs:55:9
+  --> $DIR/ty_tykind_usage.rs:29:9
    |
 LL |         IrTyKind::Bool
    |         --------^^^^^^
    |         |
    |         help: try using `ty::<kind>` directly: `ty`
 
-error: aborting due to 34 previous errors
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/feature-gates/feature-gate-auto-traits.rs b/tests/ui/feature-gates/feature-gate-auto-traits.rs
index 80cfa9cee89..aab9e784fe9 100644
--- a/tests/ui/feature-gates/feature-gate-auto-traits.rs
+++ b/tests/ui/feature-gates/feature-gate-auto-traits.rs
@@ -7,6 +7,6 @@ auto trait AutoDummyTrait {}
 //~^ ERROR auto traits are experimental and possibly buggy
 
 impl !AutoDummyTrait for DummyStruct {}
-//~^ ERROR negative trait bounds are not yet fully implemented; use marker types for now
+//~^ ERROR negative trait bounds are not fully implemented; use marker types for now
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-auto-traits.stderr b/tests/ui/feature-gates/feature-gate-auto-traits.stderr
index 139229ca809..8fa5168b2d0 100644
--- a/tests/ui/feature-gates/feature-gate-auto-traits.stderr
+++ b/tests/ui/feature-gates/feature-gate-auto-traits.stderr
@@ -8,7 +8,7 @@ LL | auto trait AutoDummyTrait {}
    = help: add `#![feature(auto_traits)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: negative trait bounds are not yet fully implemented; use marker types for now
+error[E0658]: negative trait bounds are not fully implemented; use marker types for now
   --> $DIR/feature-gate-auto-traits.rs:9:6
    |
 LL | impl !AutoDummyTrait for DummyStruct {}
diff --git a/tests/ui/symbol-names/basic.legacy.stderr b/tests/ui/symbol-names/basic.legacy.stderr
index 6ce0ae09195..2f26c0cf0d3 100644
--- a/tests/ui/symbol-names/basic.legacy.stderr
+++ b/tests/ui/symbol-names/basic.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN5basic4main17had874e876c8b1028E)
+error: symbol-name(_ZN5basic4main17h144191e1523a280eE)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(basic::main::had874e876c8b1028)
+error: demangling(basic::main::h144191e1523a280e)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
diff --git a/tests/ui/symbol-names/issue-60925.legacy.stderr b/tests/ui/symbol-names/issue-60925.legacy.stderr
index cc4eec470fb..cc79cc8b516 100644
--- a/tests/ui/symbol-names/issue-60925.legacy.stderr
+++ b/tests/ui/symbol-names/issue-60925.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17haf0d0ad2255e29c6E)
+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h71f988fda3b6b180E)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::haf0d0ad2255e29c6)
+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h71f988fda3b6b180)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
diff --git a/tests/ui/traits/negative-impls/feature-gate-negative_impls.rs b/tests/ui/traits/negative-impls/feature-gate-negative_impls.rs
index 683fd6db6f2..8d3f6ff6d78 100644
--- a/tests/ui/traits/negative-impls/feature-gate-negative_impls.rs
+++ b/tests/ui/traits/negative-impls/feature-gate-negative_impls.rs
@@ -1,3 +1,3 @@
 trait MyTrait {}
-impl !MyTrait for u32 {} //~ ERROR negative trait bounds are not yet fully implemented
+impl !MyTrait for u32 {} //~ ERROR negative trait bounds are not fully implemented
 fn main() {}
diff --git a/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr b/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr
index f3dee114116..1777dfcc993 100644
--- a/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr
+++ b/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr
@@ -1,4 +1,4 @@
-error[E0658]: negative trait bounds are not yet fully implemented; use marker types for now
+error[E0658]: negative trait bounds are not fully implemented; use marker types for now
   --> $DIR/feature-gate-negative_impls.rs:2:6
    |
 LL | impl !MyTrait for u32 {}
diff --git a/tests/ui/unsafe-binders/expr.rs b/tests/ui/unsafe-binders/expr.rs
index d8c4c2df2cd..0fe68751f0a 100644
--- a/tests/ui/unsafe-binders/expr.rs
+++ b/tests/ui/unsafe-binders/expr.rs
@@ -4,10 +4,11 @@
 use std::unsafe_binder::{wrap_binder, unwrap_binder};
 
 fn main() {
+    unsafe {
     let x = 1;
-    let binder: unsafe<'a> &'a i32 = wrap_binder!(x);
-    //~^ ERROR unsafe binders are not yet implemented
-    //~| ERROR unsafe binders are not yet implemented
-    let rx = *unwrap_binder!(binder);
-    //~^ ERROR unsafe binders are not yet implemented
+        let binder: unsafe<'a> &'a i32 = wrap_binder!(&x);
+        //~^ ERROR unsafe binder casts are not fully implemented
+        let rx = *unwrap_binder!(binder);
+        //~^ ERROR unsafe binder casts are not fully implemented
+    }
 }
diff --git a/tests/ui/unsafe-binders/expr.stderr b/tests/ui/unsafe-binders/expr.stderr
index 26fae1958b0..78a288e10a3 100644
--- a/tests/ui/unsafe-binders/expr.stderr
+++ b/tests/ui/unsafe-binders/expr.stderr
@@ -7,23 +7,17 @@ LL | #![feature(unsafe_binders)]
    = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error: unsafe binders are not yet implemented
-  --> $DIR/expr.rs:8:17
+error: unsafe binder casts are not fully implemented
+  --> $DIR/expr.rs:9:55
    |
-LL |     let binder: unsafe<'a> &'a i32 = wrap_binder!(x);
-   |                 ^^^^^^^^^^^^^^^^^^
+LL |         let binder: unsafe<'a> &'a i32 = wrap_binder!(&x);
+   |                                                       ^^
 
-error: unsafe binders are not yet implemented
-  --> $DIR/expr.rs:8:51
+error: unsafe binder casts are not fully implemented
+  --> $DIR/expr.rs:11:34
    |
-LL |     let binder: unsafe<'a> &'a i32 = wrap_binder!(x);
-   |                                                   ^
+LL |         let rx = *unwrap_binder!(binder);
+   |                                  ^^^^^^
 
-error: unsafe binders are not yet implemented
-  --> $DIR/expr.rs:11:30
-   |
-LL |     let rx = *unwrap_binder!(binder);
-   |                              ^^^^^^
-
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/tests/ui/unsafe-binders/lifetime-resolution.rs b/tests/ui/unsafe-binders/lifetime-resolution.rs
index aebed9599d4..b352acfadf2 100644
--- a/tests/ui/unsafe-binders/lifetime-resolution.rs
+++ b/tests/ui/unsafe-binders/lifetime-resolution.rs
@@ -3,16 +3,13 @@
 
 fn foo<'a>() {
     let good: unsafe<'b> &'a &'b ();
-    //~^ ERROR unsafe binders are not yet implemented
 
     let missing: unsafe<> &'missing ();
-    //~^ ERROR unsafe binders are not yet implemented
-    //~| ERROR use of undeclared lifetime name `'missing`
+    //~^ ERROR use of undeclared lifetime name `'missing`
 
     fn inner<'b>() {
         let outer: unsafe<> &'a &'b ();
-        //~^ ERROR unsafe binders are not yet implemented
-        //~| can't use generic parameters from outer item
+        //~^ can't use generic parameters from outer item
     }
 }
 
diff --git a/tests/ui/unsafe-binders/lifetime-resolution.stderr b/tests/ui/unsafe-binders/lifetime-resolution.stderr
index 7a8ce929df1..69660c271bf 100644
--- a/tests/ui/unsafe-binders/lifetime-resolution.stderr
+++ b/tests/ui/unsafe-binders/lifetime-resolution.stderr
@@ -1,5 +1,5 @@
 error[E0261]: use of undeclared lifetime name `'missing`
-  --> $DIR/lifetime-resolution.rs:8:28
+  --> $DIR/lifetime-resolution.rs:7:28
    |
 LL |     let missing: unsafe<> &'missing ();
    |                            ^^^^^^^^ undeclared lifetime
@@ -15,7 +15,7 @@ LL | fn foo<'missing, 'a>() {
    |        +++++++++
 
 error[E0401]: can't use generic parameters from outer item
-  --> $DIR/lifetime-resolution.rs:13:30
+  --> $DIR/lifetime-resolution.rs:11:30
    |
 LL | fn foo<'a>() {
    |        -- lifetime parameter from outer item
@@ -41,25 +41,7 @@ LL | #![feature(unsafe_binders)]
    = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error: unsafe binders are not yet implemented
-  --> $DIR/lifetime-resolution.rs:5:15
-   |
-LL |     let good: unsafe<'b> &'a &'b ();
-   |               ^^^^^^^^^^^^^^^^^^^^^
-
-error: unsafe binders are not yet implemented
-  --> $DIR/lifetime-resolution.rs:8:18
-   |
-LL |     let missing: unsafe<> &'missing ();
-   |                  ^^^^^^^^^^^^^^^^^^^^^
-
-error: unsafe binders are not yet implemented
-  --> $DIR/lifetime-resolution.rs:13:20
-   |
-LL |         let outer: unsafe<> &'a &'b ();
-   |                    ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors; 1 warning emitted
 
 Some errors have detailed explanations: E0261, E0401.
 For more information about an error, try `rustc --explain E0261`.
diff --git a/tests/ui/unsafe-binders/mismatch.rs b/tests/ui/unsafe-binders/mismatch.rs
new file mode 100644
index 00000000000..731fe2d1ce9
--- /dev/null
+++ b/tests/ui/unsafe-binders/mismatch.rs
@@ -0,0 +1,43 @@
+#![feature(unsafe_binders)]
+//~^ WARN the feature `unsafe_binders` is incomplete
+
+use std::unsafe_binder::{wrap_binder, unwrap_binder};
+
+fn a() {
+    let _: unsafe<'a> &'a i32 = wrap_binder!(&());
+    //~^ ERROR unsafe binder casts are not fully implemented
+    //~| ERROR mismatched types
+}
+
+fn b() {
+    let _: i32 = wrap_binder!(&());
+    //~^ ERROR unsafe binder casts are not fully implemented
+    //~| ERROR `wrap_binder!()` can only wrap into unsafe binder
+}
+
+fn c() {
+    let y = 1;
+    unwrap_binder!(y);
+    //~^ ERROR unsafe binder casts are not fully implemented
+    //~| ERROR expected unsafe binder, found integer as input
+}
+
+fn d() {
+    let unknown = Default::default();
+    unwrap_binder!(unknown);
+    //~^ ERROR unsafe binder casts are not fully implemented
+    // FIXME(unsafe_binders): This should report ambiguity once we've removed
+    // the error above which taints the infcx.
+}
+
+fn e() {
+    let x = wrap_binder!(&42);
+    //~^ ERROR unsafe binder casts are not fully implemented
+    // Currently, type inference doesn't flow backwards for unsafe binders.
+    // It could, perhaps, but that may cause even more surprising corners.
+    // FIXME(unsafe_binders): This should report ambiguity once we've removed
+    // the error above which taints the infcx.
+    let _: unsafe<'a> &'a i32 = x;
+}
+
+fn main() {}
diff --git a/tests/ui/unsafe-binders/mismatch.stderr b/tests/ui/unsafe-binders/mismatch.stderr
new file mode 100644
index 00000000000..a720e5dbdc1
--- /dev/null
+++ b/tests/ui/unsafe-binders/mismatch.stderr
@@ -0,0 +1,68 @@
+warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/mismatch.rs:1:12
+   |
+LL | #![feature(unsafe_binders)]
+   |            ^^^^^^^^^^^^^^
+   |
+   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+error: unsafe binder casts are not fully implemented
+  --> $DIR/mismatch.rs:7:46
+   |
+LL |     let _: unsafe<'a> &'a i32 = wrap_binder!(&());
+   |                                              ^^^
+
+error[E0308]: mismatched types
+  --> $DIR/mismatch.rs:7:46
+   |
+LL |     let _: unsafe<'a> &'a i32 = wrap_binder!(&());
+   |                                              ^^^ expected `&i32`, found `&()`
+   |
+   = note: expected reference `&i32`
+              found reference `&()`
+
+error: unsafe binder casts are not fully implemented
+  --> $DIR/mismatch.rs:13:31
+   |
+LL |     let _: i32 = wrap_binder!(&());
+   |                               ^^^
+
+error: `wrap_binder!()` can only wrap into unsafe binder, not `i32`
+  --> $DIR/mismatch.rs:13:18
+   |
+LL |     let _: i32 = wrap_binder!(&());
+   |                  ^^^^^^^^^^^^^^^^^
+   |
+   = note: unsafe binders are the only valid output of wrap
+   = note: this error originates in the macro `wrap_binder` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe binder casts are not fully implemented
+  --> $DIR/mismatch.rs:20:20
+   |
+LL |     unwrap_binder!(y);
+   |                    ^
+
+error: expected unsafe binder, found integer as input of `unwrap_binder!()`
+  --> $DIR/mismatch.rs:20:20
+   |
+LL |     unwrap_binder!(y);
+   |                    ^
+   |
+   = note: only an unsafe binder type can be unwrapped
+
+error: unsafe binder casts are not fully implemented
+  --> $DIR/mismatch.rs:27:20
+   |
+LL |     unwrap_binder!(unknown);
+   |                    ^^^^^^^
+
+error: unsafe binder casts are not fully implemented
+  --> $DIR/mismatch.rs:34:26
+   |
+LL |     let x = wrap_binder!(&42);
+   |                          ^^^
+
+error: aborting due to 8 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unsafe-binders/simple.rs b/tests/ui/unsafe-binders/simple.rs
index cebff2cbfb8..6172a9e1e7b 100644
--- a/tests/ui/unsafe-binders/simple.rs
+++ b/tests/ui/unsafe-binders/simple.rs
@@ -1,7 +1,8 @@
+//@ check-pass
+
 #![feature(unsafe_binders)]
 //~^ WARN the feature `unsafe_binders` is incomplete
 
 fn main() {
     let x: unsafe<'a> &'a ();
-    //~^ ERROR unsafe binders are not yet implemented
 }
diff --git a/tests/ui/unsafe-binders/simple.stderr b/tests/ui/unsafe-binders/simple.stderr
index a21dbd00b4c..e4b82c12b06 100644
--- a/tests/ui/unsafe-binders/simple.stderr
+++ b/tests/ui/unsafe-binders/simple.stderr
@@ -1,5 +1,5 @@
 warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/simple.rs:1:12
+  --> $DIR/simple.rs:3:12
    |
 LL | #![feature(unsafe_binders)]
    |            ^^^^^^^^^^^^^^
@@ -7,11 +7,5 @@ LL | #![feature(unsafe_binders)]
    = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error: unsafe binders are not yet implemented
-  --> $DIR/simple.rs:5:12
-   |
-LL |     let x: unsafe<'a> &'a ();
-   |            ^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error; 1 warning emitted
+warning: 1 warning emitted
 
-- 
cgit 1.4.1-3-g733a5


From 87c2f9a5be900e835f3c41cec2886d54ec0ca012 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 22 Dec 2024 14:26:54 +1100
Subject: Revert "Auto merge of #130766 -
 clarfonthey:stable-coverage-attribute, r=wesleywiser"

This reverts commit 1d35638dc38dbfbf1cc2a9823135dfcf3c650169, reversing
changes made to f23a80a4c2fbca593b64e70f5970368824b4c5e9.
---
 compiler/rustc_feature/src/accepted.rs             |   3 -
 compiler/rustc_feature/src/builtin_attrs.rs        |   3 +-
 compiler/rustc_feature/src/unstable.rs             |   3 +
 library/core/src/cmp.rs                            |   2 +-
 library/core/src/lib.rs                            |   2 +-
 library/core/src/macros/mod.rs                     |   6 +-
 .../src/language-features/coverage-attribute.md    |  30 +++++++
 .../crates/hir-expand/src/inert_attr_macro.rs      |   2 +-
 tests/coverage/async.cov-map                       | 100 ++++++++++-----------
 tests/coverage/async.coverage                      |   1 +
 tests/coverage/async.rs                            |   1 +
 tests/coverage/async2.cov-map                      |  24 ++---
 tests/coverage/async2.coverage                     |   1 +
 tests/coverage/async2.rs                           |   1 +
 tests/coverage/async_block.cov-map                 |   8 +-
 tests/coverage/async_block.coverage                |   1 +
 tests/coverage/async_block.rs                      |   1 +
 tests/coverage/attr/impl.cov-map                   |  12 +--
 tests/coverage/attr/impl.coverage                  |   1 +
 tests/coverage/attr/impl.rs                        |   1 +
 tests/coverage/attr/module.cov-map                 |  12 +--
 tests/coverage/attr/module.coverage                |   1 +
 tests/coverage/attr/module.rs                      |   1 +
 tests/coverage/attr/nested.coverage                |   2 +-
 tests/coverage/attr/nested.rs                      |   2 +-
 tests/coverage/attr/off-on-sandwich.cov-map        |  12 +--
 tests/coverage/attr/off-on-sandwich.coverage       |   1 +
 tests/coverage/attr/off-on-sandwich.rs             |   1 +
 tests/coverage/auxiliary/executor.rs               |   1 +
 tests/coverage/await_ready.cov-map                 |   8 +-
 tests/coverage/await_ready.coverage                |   1 +
 tests/coverage/await_ready.rs                      |   1 +
 tests/coverage/bad_counter_ids.cov-map             |  32 +++----
 tests/coverage/bad_counter_ids.coverage            |   1 +
 tests/coverage/bad_counter_ids.rs                  |   1 +
 tests/coverage/branch/generics.cov-map             |  12 +--
 tests/coverage/branch/generics.coverage            |   1 +
 tests/coverage/branch/generics.rs                  |   1 +
 tests/coverage/branch/guard.cov-map                |   4 +-
 tests/coverage/branch/guard.coverage               |   1 +
 tests/coverage/branch/guard.rs                     |   1 +
 tests/coverage/branch/if-let.coverage              |   2 +-
 tests/coverage/branch/if-let.rs                    |   2 +-
 tests/coverage/branch/if.cov-map                   |  16 ++--
 tests/coverage/branch/if.coverage                  |   1 +
 tests/coverage/branch/if.rs                        |   1 +
 tests/coverage/branch/lazy-boolean.cov-map         |  16 ++--
 tests/coverage/branch/lazy-boolean.coverage        |   1 +
 tests/coverage/branch/lazy-boolean.rs              |   1 +
 tests/coverage/branch/let-else.cov-map             |   4 +-
 tests/coverage/branch/let-else.coverage            |   1 +
 tests/coverage/branch/let-else.rs                  |   1 +
 tests/coverage/branch/match-arms.cov-map           |  12 +--
 tests/coverage/branch/match-arms.coverage          |   1 +
 tests/coverage/branch/match-arms.rs                |   1 +
 tests/coverage/branch/match-trivial.cov-map        |   8 +-
 tests/coverage/branch/match-trivial.coverage       |   1 +
 tests/coverage/branch/match-trivial.rs             |   1 +
 tests/coverage/branch/no-mir-spans.cov-map         |  16 ++--
 tests/coverage/branch/no-mir-spans.coverage        |   1 +
 tests/coverage/branch/no-mir-spans.rs              |   1 +
 tests/coverage/branch/while.cov-map                |  16 ++--
 tests/coverage/branch/while.coverage               |   1 +
 tests/coverage/branch/while.rs                     |   1 +
 tests/coverage/closure_macro_async.cov-map         |  16 ++--
 tests/coverage/closure_macro_async.coverage        |   1 +
 tests/coverage/closure_macro_async.rs              |   1 +
 tests/coverage/closure_unit_return.cov-map         |  16 ++--
 tests/coverage/closure_unit_return.coverage        |   1 +
 tests/coverage/closure_unit_return.rs              |   1 +
 tests/coverage/condition/conditions.cov-map        |  28 +++---
 tests/coverage/condition/conditions.coverage       |   1 +
 tests/coverage/condition/conditions.rs             |   1 +
 tests/coverage/coverage_attr_closure.coverage      |   2 +-
 tests/coverage/coverage_attr_closure.rs            |   2 +-
 tests/coverage/fn_sig_into_try.cov-map             |  16 ++--
 tests/coverage/fn_sig_into_try.coverage            |   1 +
 tests/coverage/fn_sig_into_try.rs                  |   1 +
 tests/coverage/if_not.cov-map                      |   4 +-
 tests/coverage/if_not.coverage                     |   1 +
 tests/coverage/if_not.rs                           |   1 +
 tests/coverage/let_else_loop.cov-map               |  12 +--
 tests/coverage/let_else_loop.coverage              |   1 +
 tests/coverage/let_else_loop.rs                    |   1 +
 tests/coverage/macro_in_closure.cov-map            |   8 +-
 tests/coverage/macro_in_closure.coverage           |   1 +
 tests/coverage/macro_in_closure.rs                 |   1 +
 tests/coverage/mcdc/condition-limit.cov-map        |   4 +-
 tests/coverage/mcdc/condition-limit.coverage       |   1 +
 tests/coverage/mcdc/condition-limit.rs             |   1 +
 tests/coverage/mcdc/if.cov-map                     |  28 +++---
 tests/coverage/mcdc/if.coverage                    |   1 +
 tests/coverage/mcdc/if.rs                          |   1 +
 tests/coverage/mcdc/inlined_expressions.cov-map    |   4 +-
 tests/coverage/mcdc/inlined_expressions.coverage   |   1 +
 tests/coverage/mcdc/inlined_expressions.rs         |   1 +
 tests/coverage/mcdc/nested_if.cov-map              |  16 ++--
 tests/coverage/mcdc/nested_if.coverage             |   1 +
 tests/coverage/mcdc/nested_if.rs                   |   1 +
 tests/coverage/mcdc/non_control_flow.cov-map       |  28 +++---
 tests/coverage/mcdc/non_control_flow.coverage      |   1 +
 tests/coverage/mcdc/non_control_flow.rs            |   1 +
 tests/coverage/no_cov_crate.cov-map                |  28 +++---
 tests/coverage/no_cov_crate.coverage               |   1 +
 tests/coverage/no_cov_crate.rs                     |   1 +
 tests/coverage/no_spans.cov-map                    |   8 +-
 tests/coverage/no_spans.coverage                   |   1 +
 tests/coverage/no_spans.rs                         |   1 +
 tests/coverage/unreachable.coverage                |   2 +-
 tests/coverage/unreachable.rs                      |   2 +-
 .../branch_match_arms.main.InstrumentCoverage.diff |  14 +--
 tests/mir-opt/coverage/branch_match_arms.rs        |   1 +
 tests/ui/coverage-attr/bad-attr-ice.feat.stderr    |  15 ++++
 tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr  |  26 ++++++
 tests/ui/coverage-attr/bad-attr-ice.rs             |   6 ++
 tests/ui/coverage-attr/bad-attr-ice.stderr         |  15 ----
 tests/ui/coverage-attr/bad-syntax.rs               |   1 +
 tests/ui/coverage-attr/bad-syntax.stderr           |  26 +++---
 tests/ui/coverage-attr/name-value.rs               |   1 +
 tests/ui/coverage-attr/name-value.stderr           |  38 ++++----
 tests/ui/coverage-attr/no-coverage.rs              |   1 +
 tests/ui/coverage-attr/no-coverage.stderr          |  22 ++---
 tests/ui/coverage-attr/subword.rs                  |   1 +
 tests/ui/coverage-attr/subword.stderr              |   8 +-
 tests/ui/coverage-attr/word-only.rs                |   1 +
 tests/ui/coverage-attr/word-only.stderr            |  38 ++++----
 .../feature-gate-coverage-attribute.rs             |  14 +++
 .../feature-gate-coverage-attribute.stderr         |  22 +++++
 tests/ui/feature-gates/feature-gate-no-coverage.rs |  14 ---
 .../feature-gates/feature-gate-no-coverage.stderr  |  11 ---
 130 files changed, 537 insertions(+), 396 deletions(-)
 create mode 100644 src/doc/unstable-book/src/language-features/coverage-attribute.md
 create mode 100644 tests/ui/coverage-attr/bad-attr-ice.feat.stderr
 create mode 100644 tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr
 delete mode 100644 tests/ui/coverage-attr/bad-attr-ice.stderr
 create mode 100644 tests/ui/feature-gates/feature-gate-coverage-attribute.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-coverage-attribute.stderr
 delete mode 100644 tests/ui/feature-gates/feature-gate-no-coverage.rs
 delete mode 100644 tests/ui/feature-gates/feature-gate-no-coverage.stderr

(limited to 'tests')

diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 5a9b8c43e74..776de1988cc 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -157,9 +157,6 @@ declare_features! (
     (accepted, const_refs_to_static, "1.83.0", Some(119618)),
     /// Allows implementing `Copy` for closures where possible (RFC 2132).
     (accepted, copy_closures, "1.26.0", Some(44490)),
-    /// Allows function attribute `#[coverage(on/off)]`, to control coverage
-    /// instrumentation of that function.
-    (accepted, coverage_attribute, "CURRENT_RUSTC_VERSION", Some(84605)),
     /// Allows `crate` in paths.
     (accepted, crate_in_paths, "1.30.0", Some(45477)),
     /// Allows users to provide classes for fenced code block using `class:classname`.
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 63e5ebb8688..4112ae80980 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -480,9 +480,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(List: "address, kcfi, memory, thread"), DuplicatesOk,
         EncodeCrossCrate::No, experimental!(no_sanitize)
     ),
-    ungated!(
+    gated!(
         coverage, Normal, template!(OneOf: &[sym::off, sym::on]),
         ErrorPreceding, EncodeCrossCrate::No,
+        coverage_attribute, experimental!(coverage)
     ),
 
     ungated!(
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index ebb07195a28..d40823d2ed6 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -447,6 +447,9 @@ declare_features! (
     (unstable, coroutine_clone, "1.65.0", Some(95360)),
     /// Allows defining coroutines.
     (unstable, coroutines, "1.21.0", Some(43122)),
+    /// Allows function attribute `#[coverage(on/off)]`, to control coverage
+    /// instrumentation of that function.
+    (unstable, coverage_attribute, "1.74.0", Some(84605)),
     /// Allows non-builtin attributes in inner attribute position.
     (unstable, custom_inner_attributes, "1.30.0", Some(54726)),
     /// Allows custom test frameworks with `#![test_runner]` and `#[test_case]`.
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 66a6578fc72..5a3b9365cd2 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -348,7 +348,7 @@ pub trait Eq: PartialEq<Self> {
 #[rustc_builtin_macro]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow_internal_unstable(core_intrinsics, derive_eq, structural_match)]
-#[cfg_attr(bootstrap, allow_internal_unstable(coverage_attribute))]
+#[allow_internal_unstable(coverage_attribute)]
 pub macro Eq($item:item) {
     /* compiler built-in */
 }
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 18bd9bb8118..a7f741a9408 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -107,13 +107,13 @@
 //
 // Library features:
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(coverage_attribute))]
 #![cfg_attr(bootstrap, feature(do_not_recommend))]
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
 #![feature(const_eval_select)]
 #![feature(const_typed_swap)]
 #![feature(core_intrinsics)]
+#![feature(coverage_attribute)]
 #![feature(internal_impls_macro)]
 #![feature(ip)]
 #![feature(is_ascii_octdigit)]
diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index bff7ad98df3..ab674b58902 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -1673,8 +1673,7 @@ pub(crate) mod builtin {
     ///
     /// [the reference]: ../../../reference/attributes/testing.html#the-test-attribute
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[allow_internal_unstable(test, rustc_attrs)]
-    #[cfg_attr(bootstrap, allow_internal_unstable(coverage_attribute))]
+    #[allow_internal_unstable(test, rustc_attrs, coverage_attribute)]
     #[rustc_builtin_macro]
     pub macro test($item:item) {
         /* compiler built-in */
@@ -1687,8 +1686,7 @@ pub(crate) mod builtin {
         soft,
         reason = "`bench` is a part of custom test frameworks which are unstable"
     )]
-    #[allow_internal_unstable(test, rustc_attrs)]
-    #[cfg_attr(bootstrap, allow_internal_unstable(coverage_attribute))]
+    #[allow_internal_unstable(test, rustc_attrs, coverage_attribute)]
     #[rustc_builtin_macro]
     pub macro bench($item:item) {
         /* compiler built-in */
diff --git a/src/doc/unstable-book/src/language-features/coverage-attribute.md b/src/doc/unstable-book/src/language-features/coverage-attribute.md
new file mode 100644
index 00000000000..0a9bd07de07
--- /dev/null
+++ b/src/doc/unstable-book/src/language-features/coverage-attribute.md
@@ -0,0 +1,30 @@
+# `coverage_attribute`
+
+The tracking issue for this feature is: [#84605]
+
+[#84605]: https://github.com/rust-lang/rust/issues/84605
+
+---
+
+The `coverage` attribute can be used to selectively disable coverage
+instrumentation in an annotated function. This might be useful to:
+
+-   Avoid instrumentation overhead in a performance critical function
+-   Avoid generating coverage for a function that is not meant to be executed,
+    but still target 100% coverage for the rest of the program.
+
+## Example
+
+```rust
+#![feature(coverage_attribute)]
+
+// `foo()` will get coverage instrumentation (by default)
+fn foo() {
+  // ...
+}
+
+#[coverage(off)]
+fn bar() {
+  // ...
+}
+```
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
index 2bba410de02..9a7a1a01a09 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
@@ -237,7 +237,7 @@ pub const INERT_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(List: "address, kcfi, memory, thread"), DuplicatesOk,
         experimental!(no_sanitize)
     ),
-    ungated!(coverage, Normal, template!(Word, List: "on|off"), WarnFollowing),
+    gated!(coverage, Normal, template!(Word, List: "on|off"), WarnFollowing, coverage_attribute, experimental!(coverage)),
 
     ungated!(
         doc, Normal, template!(List: "hidden|inline|...", NameValueStr: "string"), DuplicatesOk
diff --git a/tests/coverage/async.cov-map b/tests/coverage/async.cov-map
index 9c6f4bd385f..d3eed6c4f2a 100644
--- a/tests/coverage/async.cov-map
+++ b/tests/coverage/async.cov-map
@@ -1,20 +1,20 @@
 Function name: async::c
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 0a, 01, 00, 19]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 0b, 01, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 10, 1) to (start + 0, 25)
+- Code(Counter(0)) at (prev + 11, 1) to (start + 0, 25)
 Highest counter ID seen: c0
 
 Function name: async::c::{closure#0}
-Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 0a, 19, 01, 0e, 05, 02, 09, 00, 0a, 02, 02, 09, 00, 0a, 01, 02, 01, 00, 02]
+Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 0b, 19, 01, 0e, 05, 02, 09, 00, 0a, 02, 02, 09, 00, 0a, 01, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 10, 25) to (start + 1, 14)
+- Code(Counter(0)) at (prev + 11, 25) to (start + 1, 14)
 - Code(Counter(1)) at (prev + 2, 9) to (start + 0, 10)
 - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 10)
     = (c0 - c1)
@@ -22,93 +22,93 @@ Number of file 0 mappings: 4
 Highest counter ID seen: c1
 
 Function name: async::d
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 12, 01, 00, 14]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 00, 14]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 18, 1) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 19, 1) to (start + 0, 20)
 Highest counter ID seen: c0
 
 Function name: async::d::{closure#0}
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 12, 14, 00, 19]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 14, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 18, 20) to (start + 0, 25)
+- Code(Counter(0)) at (prev + 19, 20) to (start + 0, 25)
 Highest counter ID seen: c0
 
 Function name: async::e (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 14, 01, 00, 14]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 15, 01, 00, 14]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 20, 1) to (start + 0, 20)
+- Code(Zero) at (prev + 21, 1) to (start + 0, 20)
 Highest counter ID seen: (none)
 
 Function name: async::e::{closure#0} (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 14, 14, 00, 19]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 15, 14, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 20, 20) to (start + 0, 25)
+- Code(Zero) at (prev + 21, 20) to (start + 0, 25)
 Highest counter ID seen: (none)
 
 Function name: async::f
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 16, 01, 00, 14]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 01, 00, 14]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 23, 1) to (start + 0, 20)
 Highest counter ID seen: c0
 
 Function name: async::f::{closure#0}
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 16, 14, 00, 19]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 14, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 22, 20) to (start + 0, 25)
+- Code(Counter(0)) at (prev + 23, 20) to (start + 0, 25)
 Highest counter ID seen: c0
 
 Function name: async::foo (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 18, 01, 00, 1e]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 19, 01, 00, 1e]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 24, 1) to (start + 0, 30)
+- Code(Zero) at (prev + 25, 1) to (start + 0, 30)
 Highest counter ID seen: (none)
 
 Function name: async::foo::{closure#0} (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 18, 1e, 00, 2d]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 19, 1e, 00, 2d]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 24, 30) to (start + 0, 45)
+- Code(Zero) at (prev + 25, 30) to (start + 0, 45)
 Highest counter ID seen: (none)
 
 Function name: async::g
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 1a, 01, 00, 17]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1b, 01, 00, 17]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 26, 1) to (start + 0, 23)
+- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 23)
 Highest counter ID seen: c0
 
 Function name: async::g::{closure#0} (unused)
-Raw bytes (59): 0x[01, 01, 00, 0b, 00, 1a, 17, 01, 0c, 00, 02, 09, 00, 0a, 00, 00, 0e, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 09, 00, 0a, 00, 00, 0e, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
+Raw bytes (59): 0x[01, 01, 00, 0b, 00, 1b, 17, 01, 0c, 00, 02, 09, 00, 0a, 00, 00, 0e, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 09, 00, 0a, 00, 00, 0e, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 11
-- Code(Zero) at (prev + 26, 23) to (start + 1, 12)
+- Code(Zero) at (prev + 27, 23) to (start + 1, 12)
 - Code(Zero) at (prev + 2, 9) to (start + 0, 10)
 - Code(Zero) at (prev + 0, 14) to (start + 0, 23)
 - Code(Zero) at (prev + 0, 27) to (start + 0, 28)
@@ -122,21 +122,21 @@ Number of file 0 mappings: 11
 Highest counter ID seen: (none)
 
 Function name: async::h
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 22, 01, 00, 16]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 23, 01, 00, 16]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 34, 1) to (start + 0, 22)
+- Code(Counter(0)) at (prev + 35, 1) to (start + 0, 22)
 Highest counter ID seen: c0
 
 Function name: async::h::{closure#0} (unused)
-Raw bytes (39): 0x[01, 01, 00, 07, 00, 22, 16, 03, 0c, 00, 04, 09, 00, 0a, 00, 00, 0e, 00, 19, 00, 00, 1a, 00, 1b, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
+Raw bytes (39): 0x[01, 01, 00, 07, 00, 23, 16, 03, 0c, 00, 04, 09, 00, 0a, 00, 00, 0e, 00, 19, 00, 00, 1a, 00, 1b, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 7
-- Code(Zero) at (prev + 34, 22) to (start + 3, 12)
+- Code(Zero) at (prev + 35, 22) to (start + 3, 12)
 - Code(Zero) at (prev + 4, 9) to (start + 0, 10)
 - Code(Zero) at (prev + 0, 14) to (start + 0, 25)
 - Code(Zero) at (prev + 0, 26) to (start + 0, 27)
@@ -146,23 +146,23 @@ Number of file 0 mappings: 7
 Highest counter ID seen: (none)
 
 Function name: async::i
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 2b, 01, 00, 13]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 2c, 01, 00, 13]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 43, 1) to (start + 0, 19)
+- Code(Counter(0)) at (prev + 44, 1) to (start + 0, 19)
 Highest counter ID seen: c0
 
 Function name: async::i::{closure#0}
-Raw bytes (63): 0x[01, 01, 02, 07, 15, 0d, 11, 0b, 01, 2b, 13, 04, 0c, 09, 05, 09, 00, 0a, 01, 00, 0e, 00, 18, 05, 00, 1c, 00, 21, 09, 00, 27, 00, 30, 11, 01, 09, 00, 0a, 19, 00, 0e, 00, 17, 1d, 00, 1b, 00, 20, 11, 00, 24, 00, 26, 15, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
+Raw bytes (63): 0x[01, 01, 02, 07, 15, 0d, 11, 0b, 01, 2c, 13, 04, 0c, 09, 05, 09, 00, 0a, 01, 00, 0e, 00, 18, 05, 00, 1c, 00, 21, 09, 00, 27, 00, 30, 11, 01, 09, 00, 0a, 19, 00, 0e, 00, 17, 1d, 00, 1b, 00, 20, 11, 00, 24, 00, 26, 15, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Expression(1, Add), rhs = Counter(5)
 - expression 1 operands: lhs = Counter(3), rhs = Counter(4)
 Number of file 0 mappings: 11
-- Code(Counter(0)) at (prev + 43, 19) to (start + 4, 12)
+- Code(Counter(0)) at (prev + 44, 19) to (start + 4, 12)
 - Code(Counter(2)) at (prev + 5, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 14) to (start + 0, 24)
 - Code(Counter(1)) at (prev + 0, 28) to (start + 0, 33)
@@ -177,14 +177,14 @@ Number of file 0 mappings: 11
 Highest counter ID seen: c7
 
 Function name: async::j
-Raw bytes (58): 0x[01, 01, 02, 07, 0d, 05, 09, 0a, 01, 36, 01, 00, 0d, 01, 0b, 0b, 00, 0c, 05, 01, 09, 00, 0a, 01, 00, 0e, 00, 1b, 05, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 09, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
+Raw bytes (58): 0x[01, 01, 02, 07, 0d, 05, 09, 0a, 01, 37, 01, 00, 0d, 01, 0b, 0b, 00, 0c, 05, 01, 09, 00, 0a, 01, 00, 0e, 00, 1b, 05, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 09, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 10
-- Code(Counter(0)) at (prev + 54, 1) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 55, 1) to (start + 0, 13)
 - Code(Counter(0)) at (prev + 11, 11) to (start + 0, 12)
 - Code(Counter(1)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 14) to (start + 0, 27)
@@ -198,13 +198,13 @@ Number of file 0 mappings: 10
 Highest counter ID seen: c4
 
 Function name: async::j::c
-Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 38, 05, 01, 12, 05, 02, 0d, 00, 0e, 02, 02, 0d, 00, 0e, 01, 02, 05, 00, 06]
+Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 39, 05, 01, 12, 05, 02, 0d, 00, 0e, 02, 02, 0d, 00, 0e, 01, 02, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 56, 5) to (start + 1, 18)
+- Code(Counter(0)) at (prev + 57, 5) to (start + 1, 18)
 - Code(Counter(1)) at (prev + 2, 13) to (start + 0, 14)
 - Code(Expression(0, Sub)) at (prev + 2, 13) to (start + 0, 14)
     = (c0 - c1)
@@ -212,30 +212,30 @@ Number of file 0 mappings: 4
 Highest counter ID seen: c1
 
 Function name: async::j::d
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 3f, 05, 00, 17]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 40, 05, 00, 17]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 63, 5) to (start + 0, 23)
+- Code(Counter(0)) at (prev + 64, 5) to (start + 0, 23)
 Highest counter ID seen: c0
 
 Function name: async::j::f
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 40, 05, 00, 17]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 41, 05, 00, 17]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 64, 5) to (start + 0, 23)
+- Code(Counter(0)) at (prev + 65, 5) to (start + 0, 23)
 Highest counter ID seen: c0
 
 Function name: async::k (unused)
-Raw bytes (29): 0x[01, 01, 00, 05, 00, 48, 01, 01, 0c, 00, 02, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
+Raw bytes (29): 0x[01, 01, 00, 05, 00, 49, 01, 01, 0c, 00, 02, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 5
-- Code(Zero) at (prev + 72, 1) to (start + 1, 12)
+- Code(Zero) at (prev + 73, 1) to (start + 1, 12)
 - Code(Zero) at (prev + 2, 14) to (start + 0, 16)
 - Code(Zero) at (prev + 1, 14) to (start + 0, 16)
 - Code(Zero) at (prev + 1, 14) to (start + 0, 16)
@@ -243,14 +243,14 @@ Number of file 0 mappings: 5
 Highest counter ID seen: (none)
 
 Function name: async::l
-Raw bytes (33): 0x[01, 01, 02, 01, 07, 05, 09, 05, 01, 50, 01, 01, 0c, 02, 02, 0e, 00, 10, 09, 01, 0e, 00, 10, 05, 01, 0e, 00, 10, 01, 02, 01, 00, 02]
+Raw bytes (33): 0x[01, 01, 02, 01, 07, 05, 09, 05, 01, 51, 01, 01, 0c, 02, 02, 0e, 00, 10, 09, 01, 0e, 00, 10, 05, 01, 0e, 00, 10, 01, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Expression(1, Add)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 80, 1) to (start + 1, 12)
+- Code(Counter(0)) at (prev + 81, 1) to (start + 1, 12)
 - Code(Expression(0, Sub)) at (prev + 2, 14) to (start + 0, 16)
     = (c0 - (c1 + c2))
 - Code(Counter(2)) at (prev + 1, 14) to (start + 0, 16)
@@ -259,29 +259,29 @@ Number of file 0 mappings: 5
 Highest counter ID seen: c2
 
 Function name: async::m
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 58, 01, 00, 19]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 59, 01, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 88, 1) to (start + 0, 25)
+- Code(Counter(0)) at (prev + 89, 1) to (start + 0, 25)
 Highest counter ID seen: c0
 
 Function name: async::m::{closure#0} (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 58, 19, 00, 22]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 59, 19, 00, 22]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 88, 25) to (start + 0, 34)
+- Code(Zero) at (prev + 89, 25) to (start + 0, 34)
 Highest counter ID seen: (none)
 
 Function name: async::main
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 5a, 01, 08, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 5b, 01, 08, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 90, 1) to (start + 8, 2)
+- Code(Counter(0)) at (prev + 91, 1) to (start + 8, 2)
 Highest counter ID seen: c0
 
diff --git a/tests/coverage/async.coverage b/tests/coverage/async.coverage
index cee0e1a0a85..aee76b05fb7 100644
--- a/tests/coverage/async.coverage
+++ b/tests/coverage/async.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |#![feature(custom_inner_attributes)] // for #![rustfmt::skip]
    LL|       |#![allow(unused_assignments, dead_code)]
    LL|       |#![rustfmt::skip]
diff --git a/tests/coverage/async.rs b/tests/coverage/async.rs
index 801c98c52df..da0a1c0b6f0 100644
--- a/tests/coverage/async.rs
+++ b/tests/coverage/async.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 #![feature(custom_inner_attributes)] // for #![rustfmt::skip]
 #![allow(unused_assignments, dead_code)]
 #![rustfmt::skip]
diff --git a/tests/coverage/async2.cov-map b/tests/coverage/async2.cov-map
index 926124fdc76..7660f917b65 100644
--- a/tests/coverage/async2.cov-map
+++ b/tests/coverage/async2.cov-map
@@ -1,58 +1,58 @@
 Function name: async2::async_func
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 0e, 01, 00, 17]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 0f, 01, 00, 17]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 14, 1) to (start + 0, 23)
+- Code(Counter(0)) at (prev + 15, 1) to (start + 0, 23)
 Highest counter ID seen: c0
 
 Function name: async2::async_func::{closure#0}
-Raw bytes (24): 0x[01, 01, 00, 04, 01, 0e, 17, 03, 09, 05, 03, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
+Raw bytes (24): 0x[01, 01, 00, 04, 01, 0f, 17, 03, 09, 05, 03, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 14, 23) to (start + 3, 9)
+- Code(Counter(0)) at (prev + 15, 23) to (start + 3, 9)
 - Code(Counter(1)) at (prev + 3, 10) to (start + 2, 6)
 - Code(Zero) at (prev + 2, 5) to (start + 0, 6)
 - Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
 Highest counter ID seen: c1
 
 Function name: async2::async_func_just_println
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 16, 01, 00, 24]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 01, 00, 24]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 36)
+- Code(Counter(0)) at (prev + 23, 1) to (start + 0, 36)
 Highest counter ID seen: c0
 
 Function name: async2::async_func_just_println::{closure#0}
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 16, 24, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 24, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 22, 36) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 23, 36) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: async2::main
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 1a, 01, 07, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1b, 01, 07, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 26, 1) to (start + 7, 2)
+- Code(Counter(0)) at (prev + 27, 1) to (start + 7, 2)
 Highest counter ID seen: c0
 
 Function name: async2::non_async_func
-Raw bytes (24): 0x[01, 01, 00, 04, 01, 06, 01, 03, 09, 05, 03, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
+Raw bytes (24): 0x[01, 01, 00, 04, 01, 07, 01, 03, 09, 05, 03, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 6, 1) to (start + 3, 9)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 3, 9)
 - Code(Counter(1)) at (prev + 3, 10) to (start + 2, 6)
 - Code(Zero) at (prev + 2, 5) to (start + 0, 6)
 - Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
diff --git a/tests/coverage/async2.coverage b/tests/coverage/async2.coverage
index 0e91fa975f5..fa56072924b 100644
--- a/tests/coverage/async2.coverage
+++ b/tests/coverage/async2.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2018
    LL|       |
    LL|       |//@ aux-build: executor.rs
diff --git a/tests/coverage/async2.rs b/tests/coverage/async2.rs
index 64e85f1b6bd..9bd4821518a 100644
--- a/tests/coverage/async2.rs
+++ b/tests/coverage/async2.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2018
 
 //@ aux-build: executor.rs
diff --git a/tests/coverage/async_block.cov-map b/tests/coverage/async_block.cov-map
index e9e7e9cd2c3..14ed4850d4a 100644
--- a/tests/coverage/async_block.cov-map
+++ b/tests/coverage/async_block.cov-map
@@ -1,11 +1,11 @@
 Function name: async_block::main
-Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 06, 01, 00, 0b, 05, 01, 09, 00, 0a, 03, 00, 0e, 00, 13, 05, 00, 14, 01, 16, 05, 07, 0a, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 07, 01, 00, 0b, 05, 01, 09, 00, 0a, 03, 00, 0e, 00, 13, 05, 00, 14, 01, 16, 05, 07, 0a, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 11)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 11)
 - Code(Counter(1)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 19)
     = (c0 + c1)
@@ -15,13 +15,13 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c1
 
 Function name: async_block::main::{closure#0}
-Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 08, 1c, 01, 17, 05, 01, 18, 02, 0e, 02, 02, 14, 02, 0e, 01, 03, 09, 00, 0a]
+Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 09, 1c, 01, 17, 05, 01, 18, 02, 0e, 02, 02, 14, 02, 0e, 01, 03, 09, 00, 0a]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 8, 28) to (start + 1, 23)
+- Code(Counter(0)) at (prev + 9, 28) to (start + 1, 23)
 - Code(Counter(1)) at (prev + 1, 24) to (start + 2, 14)
 - Code(Expression(0, Sub)) at (prev + 2, 20) to (start + 2, 14)
     = (c0 - c1)
diff --git a/tests/coverage/async_block.coverage b/tests/coverage/async_block.coverage
index 7ccc83499e6..9e3294492cd 100644
--- a/tests/coverage/async_block.coverage
+++ b/tests/coverage/async_block.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |//@ aux-build: executor.rs
diff --git a/tests/coverage/async_block.rs b/tests/coverage/async_block.rs
index 05a105224bb..d1e37ab7505 100644
--- a/tests/coverage/async_block.rs
+++ b/tests/coverage/async_block.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 //@ aux-build: executor.rs
diff --git a/tests/coverage/attr/impl.cov-map b/tests/coverage/attr/impl.cov-map
index 4d068c290f4..8a23c082082 100644
--- a/tests/coverage/attr/impl.cov-map
+++ b/tests/coverage/attr/impl.cov-map
@@ -1,27 +1,27 @@
 Function name: <impl::MyStruct>::off_on (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 0e, 05, 00, 13]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 0f, 05, 00, 13]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 14, 5) to (start + 0, 19)
+- Code(Zero) at (prev + 15, 5) to (start + 0, 19)
 Highest counter ID seen: (none)
 
 Function name: <impl::MyStruct>::on_inherit (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 16, 05, 00, 17]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 17, 05, 00, 17]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 22, 5) to (start + 0, 23)
+- Code(Zero) at (prev + 23, 5) to (start + 0, 23)
 Highest counter ID seen: (none)
 
 Function name: <impl::MyStruct>::on_on (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 19, 05, 00, 12]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 1a, 05, 00, 12]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 25, 5) to (start + 0, 18)
+- Code(Zero) at (prev + 26, 5) to (start + 0, 18)
 Highest counter ID seen: (none)
 
diff --git a/tests/coverage/attr/impl.coverage b/tests/coverage/attr/impl.coverage
index af00df5d743..670c1c36a96 100644
--- a/tests/coverage/attr/impl.coverage
+++ b/tests/coverage/attr/impl.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ reference: attributes.coverage.nesting
    LL|       |
diff --git a/tests/coverage/attr/impl.rs b/tests/coverage/attr/impl.rs
index db08fdc4179..c720a4cd6b2 100644
--- a/tests/coverage/attr/impl.rs
+++ b/tests/coverage/attr/impl.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.nesting
 
diff --git a/tests/coverage/attr/module.cov-map b/tests/coverage/attr/module.cov-map
index b318ac85a6c..81e20a2c264 100644
--- a/tests/coverage/attr/module.cov-map
+++ b/tests/coverage/attr/module.cov-map
@@ -1,27 +1,27 @@
 Function name: module::off::on (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 0c, 05, 00, 0f]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 0d, 05, 00, 0f]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 12, 5) to (start + 0, 15)
+- Code(Zero) at (prev + 13, 5) to (start + 0, 15)
 Highest counter ID seen: (none)
 
 Function name: module::on::inherit (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 14, 05, 00, 14]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 15, 05, 00, 14]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 20, 5) to (start + 0, 20)
+- Code(Zero) at (prev + 21, 5) to (start + 0, 20)
 Highest counter ID seen: (none)
 
 Function name: module::on::on (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 17, 05, 00, 0f]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 18, 05, 00, 0f]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 23, 5) to (start + 0, 15)
+- Code(Zero) at (prev + 24, 5) to (start + 0, 15)
 Highest counter ID seen: (none)
 
diff --git a/tests/coverage/attr/module.coverage b/tests/coverage/attr/module.coverage
index 732850fb04a..bba021b9b47 100644
--- a/tests/coverage/attr/module.coverage
+++ b/tests/coverage/attr/module.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ reference: attributes.coverage.nesting
    LL|       |
diff --git a/tests/coverage/attr/module.rs b/tests/coverage/attr/module.rs
index c0ec5bc1d62..1d17ac7d503 100644
--- a/tests/coverage/attr/module.rs
+++ b/tests/coverage/attr/module.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.nesting
 
diff --git a/tests/coverage/attr/nested.coverage b/tests/coverage/attr/nested.coverage
index 13e9aa0a8e8..6bd24d67936 100644
--- a/tests/coverage/attr/nested.coverage
+++ b/tests/coverage/attr/nested.coverage
@@ -1,4 +1,4 @@
-   LL|       |#![feature(stmt_expr_attributes)]
+   LL|       |#![feature(coverage_attribute, stmt_expr_attributes)]
    LL|       |//@ edition: 2021
    LL|       |//@ reference: attributes.coverage.nesting
    LL|       |
diff --git a/tests/coverage/attr/nested.rs b/tests/coverage/attr/nested.rs
index 184fa54c066..042fcc5319a 100644
--- a/tests/coverage/attr/nested.rs
+++ b/tests/coverage/attr/nested.rs
@@ -1,4 +1,4 @@
-#![feature(stmt_expr_attributes)]
+#![feature(coverage_attribute, stmt_expr_attributes)]
 //@ edition: 2021
 //@ reference: attributes.coverage.nesting
 
diff --git a/tests/coverage/attr/off-on-sandwich.cov-map b/tests/coverage/attr/off-on-sandwich.cov-map
index ae5c9bd19a2..ef6f5a9dc42 100644
--- a/tests/coverage/attr/off-on-sandwich.cov-map
+++ b/tests/coverage/attr/off-on-sandwich.cov-map
@@ -1,30 +1,30 @@
 Function name: off_on_sandwich::dense_a::dense_b
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 0f, 05, 02, 12, 01, 07, 05, 00, 06]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 10, 05, 02, 12, 01, 07, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 15, 5) to (start + 2, 18)
+- Code(Counter(0)) at (prev + 16, 5) to (start + 2, 18)
 - Code(Counter(0)) at (prev + 7, 5) to (start + 0, 6)
 Highest counter ID seen: c0
 
 Function name: off_on_sandwich::sparse_a::sparse_b::sparse_c
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 21, 09, 02, 17, 01, 0b, 09, 00, 0a]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 22, 09, 02, 17, 01, 0b, 09, 00, 0a]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 33, 9) to (start + 2, 23)
+- Code(Counter(0)) at (prev + 34, 9) to (start + 2, 23)
 - Code(Counter(0)) at (prev + 11, 9) to (start + 0, 10)
 Highest counter ID seen: c0
 
 Function name: off_on_sandwich::sparse_a::sparse_b::sparse_c::sparse_d
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 24, 0d, 02, 1b, 01, 07, 0d, 00, 0e]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 25, 0d, 02, 1b, 01, 07, 0d, 00, 0e]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 36, 13) to (start + 2, 27)
+- Code(Counter(0)) at (prev + 37, 13) to (start + 2, 27)
 - Code(Counter(0)) at (prev + 7, 13) to (start + 0, 14)
 Highest counter ID seen: c0
 
diff --git a/tests/coverage/attr/off-on-sandwich.coverage b/tests/coverage/attr/off-on-sandwich.coverage
index 7a8c01b31eb..4fbc3884903 100644
--- a/tests/coverage/attr/off-on-sandwich.coverage
+++ b/tests/coverage/attr/off-on-sandwich.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ reference: attributes.coverage.nesting
    LL|       |
diff --git a/tests/coverage/attr/off-on-sandwich.rs b/tests/coverage/attr/off-on-sandwich.rs
index 6603e071dee..3d914c99b62 100644
--- a/tests/coverage/attr/off-on-sandwich.rs
+++ b/tests/coverage/attr/off-on-sandwich.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.nesting
 
diff --git a/tests/coverage/auxiliary/executor.rs b/tests/coverage/auxiliary/executor.rs
index ed1fe032ef4..c282414fb8e 100644
--- a/tests/coverage/auxiliary/executor.rs
+++ b/tests/coverage/auxiliary/executor.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 use core::future::Future;
diff --git a/tests/coverage/await_ready.cov-map b/tests/coverage/await_ready.cov-map
index ea16b36b616..bc1af4e42e8 100644
--- a/tests/coverage/await_ready.cov-map
+++ b/tests/coverage/await_ready.cov-map
@@ -1,19 +1,19 @@
 Function name: await_ready::await_ready
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 0d, 01, 00, 1e]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 0e, 01, 00, 1e]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 13, 1) to (start + 0, 30)
+- Code(Counter(0)) at (prev + 14, 1) to (start + 0, 30)
 Highest counter ID seen: c0
 
 Function name: await_ready::await_ready::{closure#0}
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 0d, 1e, 03, 0f, 05, 04, 01, 00, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 0e, 1e, 03, 0f, 05, 04, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 13, 30) to (start + 3, 15)
+- Code(Counter(0)) at (prev + 14, 30) to (start + 3, 15)
 - Code(Counter(1)) at (prev + 4, 1) to (start + 0, 2)
 Highest counter ID seen: c1
 
diff --git a/tests/coverage/await_ready.coverage b/tests/coverage/await_ready.coverage
index 40107a92e41..1150d807e76 100644
--- a/tests/coverage/await_ready.coverage
+++ b/tests/coverage/await_ready.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |#![coverage(off)]
    LL|       |//@ edition: 2021
    LL|       |
diff --git a/tests/coverage/await_ready.rs b/tests/coverage/await_ready.rs
index 8fbdf7b8004..9eaa31dedda 100644
--- a/tests/coverage/await_ready.rs
+++ b/tests/coverage/await_ready.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 #![coverage(off)]
 //@ edition: 2021
 
diff --git a/tests/coverage/bad_counter_ids.cov-map b/tests/coverage/bad_counter_ids.cov-map
index ae9db139e3d..2b5399f33bb 100644
--- a/tests/coverage/bad_counter_ids.cov-map
+++ b/tests/coverage/bad_counter_ids.cov-map
@@ -1,88 +1,88 @@
 Function name: bad_counter_ids::eq_bad
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 23, 01, 02, 1f, 00, 03, 01, 00, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 24, 01, 02, 1f, 00, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 35, 1) to (start + 2, 31)
+- Code(Counter(0)) at (prev + 36, 1) to (start + 2, 31)
 - Code(Zero) at (prev + 3, 1) to (start + 0, 2)
 Highest counter ID seen: c0
 
 Function name: bad_counter_ids::eq_bad_message
-Raw bytes (21): 0x[01, 01, 01, 01, 00, 03, 01, 28, 01, 02, 0f, 02, 02, 20, 00, 2b, 00, 01, 01, 00, 02]
+Raw bytes (21): 0x[01, 01, 01, 01, 00, 03, 01, 29, 01, 02, 0f, 02, 02, 20, 00, 2b, 00, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Zero
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 40, 1) to (start + 2, 15)
+- Code(Counter(0)) at (prev + 41, 1) to (start + 2, 15)
 - Code(Expression(0, Sub)) at (prev + 2, 32) to (start + 0, 43)
     = (c0 - Zero)
 - Code(Zero) at (prev + 1, 1) to (start + 0, 2)
 Highest counter ID seen: c0
 
 Function name: bad_counter_ids::eq_good
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 0f, 01, 02, 1f, 05, 03, 01, 00, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 10, 01, 02, 1f, 05, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 15, 1) to (start + 2, 31)
+- Code(Counter(0)) at (prev + 16, 1) to (start + 2, 31)
 - Code(Counter(1)) at (prev + 3, 1) to (start + 0, 2)
 Highest counter ID seen: c1
 
 Function name: bad_counter_ids::eq_good_message
-Raw bytes (19): 0x[01, 01, 00, 03, 01, 14, 01, 02, 0f, 00, 02, 20, 00, 2b, 05, 01, 01, 00, 02]
+Raw bytes (19): 0x[01, 01, 00, 03, 01, 15, 01, 02, 0f, 00, 02, 20, 00, 2b, 05, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 20, 1) to (start + 2, 15)
+- Code(Counter(0)) at (prev + 21, 1) to (start + 2, 15)
 - Code(Zero) at (prev + 2, 32) to (start + 0, 43)
 - Code(Counter(1)) at (prev + 1, 1) to (start + 0, 2)
 Highest counter ID seen: c1
 
 Function name: bad_counter_ids::ne_bad
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 2d, 01, 02, 1f, 00, 03, 01, 00, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 2e, 01, 02, 1f, 00, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 45, 1) to (start + 2, 31)
+- Code(Counter(0)) at (prev + 46, 1) to (start + 2, 31)
 - Code(Zero) at (prev + 3, 1) to (start + 0, 2)
 Highest counter ID seen: c0
 
 Function name: bad_counter_ids::ne_bad_message
-Raw bytes (19): 0x[01, 01, 00, 03, 01, 32, 01, 02, 0f, 05, 02, 20, 00, 2b, 00, 01, 01, 00, 02]
+Raw bytes (19): 0x[01, 01, 00, 03, 01, 33, 01, 02, 0f, 05, 02, 20, 00, 2b, 00, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 50, 1) to (start + 2, 15)
+- Code(Counter(0)) at (prev + 51, 1) to (start + 2, 15)
 - Code(Counter(1)) at (prev + 2, 32) to (start + 0, 43)
 - Code(Zero) at (prev + 1, 1) to (start + 0, 2)
 Highest counter ID seen: c1
 
 Function name: bad_counter_ids::ne_good
-Raw bytes (16): 0x[01, 01, 01, 01, 00, 02, 01, 19, 01, 02, 1f, 02, 03, 01, 00, 02]
+Raw bytes (16): 0x[01, 01, 01, 01, 00, 02, 01, 1a, 01, 02, 1f, 02, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Zero
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 25, 1) to (start + 2, 31)
+- Code(Counter(0)) at (prev + 26, 1) to (start + 2, 31)
 - Code(Expression(0, Sub)) at (prev + 3, 1) to (start + 0, 2)
     = (c0 - Zero)
 Highest counter ID seen: c0
 
 Function name: bad_counter_ids::ne_good_message
-Raw bytes (21): 0x[01, 01, 01, 01, 00, 03, 01, 1e, 01, 02, 0f, 00, 02, 20, 00, 2b, 02, 01, 01, 00, 02]
+Raw bytes (21): 0x[01, 01, 01, 01, 00, 03, 01, 1f, 01, 02, 0f, 00, 02, 20, 00, 2b, 02, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Zero
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 30, 1) to (start + 2, 15)
+- Code(Counter(0)) at (prev + 31, 1) to (start + 2, 15)
 - Code(Zero) at (prev + 2, 32) to (start + 0, 43)
 - Code(Expression(0, Sub)) at (prev + 1, 1) to (start + 0, 2)
     = (c0 - Zero)
diff --git a/tests/coverage/bad_counter_ids.coverage b/tests/coverage/bad_counter_ids.coverage
index eede634923d..f6c69913cdd 100644
--- a/tests/coverage/bad_counter_ids.coverage
+++ b/tests/coverage/bad_counter_ids.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Copt-level=0 -Zmir-opt-level=3
    LL|       |
diff --git a/tests/coverage/bad_counter_ids.rs b/tests/coverage/bad_counter_ids.rs
index 8fa0d83bf20..ef31d682e4f 100644
--- a/tests/coverage/bad_counter_ids.rs
+++ b/tests/coverage/bad_counter_ids.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Copt-level=0 -Zmir-opt-level=3
 
diff --git a/tests/coverage/branch/generics.cov-map b/tests/coverage/branch/generics.cov-map
index 9ff8e29f9e7..656890634ff 100644
--- a/tests/coverage/branch/generics.cov-map
+++ b/tests/coverage/branch/generics.cov-map
@@ -1,11 +1,11 @@
 Function name: generics::print_size::<()>
-Raw bytes (33): 0x[01, 01, 01, 01, 05, 05, 01, 05, 01, 01, 24, 20, 05, 02, 01, 08, 00, 24, 05, 00, 25, 02, 06, 02, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (33): 0x[01, 01, 01, 01, 05, 05, 01, 06, 01, 01, 24, 20, 05, 02, 01, 08, 00, 24, 05, 00, 25, 02, 06, 02, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 5, 1) to (start + 1, 36)
+- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 36)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 1, 8) to (start + 0, 36)
     true  = c1
     false = (c0 - c1)
@@ -16,13 +16,13 @@ Number of file 0 mappings: 5
 Highest counter ID seen: c1
 
 Function name: generics::print_size::<u32>
-Raw bytes (33): 0x[01, 01, 01, 01, 05, 05, 01, 05, 01, 01, 24, 20, 05, 02, 01, 08, 00, 24, 05, 00, 25, 02, 06, 02, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (33): 0x[01, 01, 01, 01, 05, 05, 01, 06, 01, 01, 24, 20, 05, 02, 01, 08, 00, 24, 05, 00, 25, 02, 06, 02, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 5, 1) to (start + 1, 36)
+- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 36)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 1, 8) to (start + 0, 36)
     true  = c1
     false = (c0 - c1)
@@ -33,13 +33,13 @@ Number of file 0 mappings: 5
 Highest counter ID seen: c1
 
 Function name: generics::print_size::<u64>
-Raw bytes (33): 0x[01, 01, 01, 01, 05, 05, 01, 05, 01, 01, 24, 20, 05, 02, 01, 08, 00, 24, 05, 00, 25, 02, 06, 02, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (33): 0x[01, 01, 01, 01, 05, 05, 01, 06, 01, 01, 24, 20, 05, 02, 01, 08, 00, 24, 05, 00, 25, 02, 06, 02, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 5, 1) to (start + 1, 36)
+- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 36)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 1, 8) to (start + 0, 36)
     true  = c1
     false = (c0 - c1)
diff --git a/tests/coverage/branch/generics.coverage b/tests/coverage/branch/generics.coverage
index 849ddfa7a72..85f73d45f65 100644
--- a/tests/coverage/branch/generics.coverage
+++ b/tests/coverage/branch/generics.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/generics.rs b/tests/coverage/branch/generics.rs
index 24bfdaaa687..d870ace7006 100644
--- a/tests/coverage/branch/generics.rs
+++ b/tests/coverage/branch/generics.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/guard.cov-map b/tests/coverage/branch/guard.cov-map
index 9e02240f1a2..7ca499bd847 100644
--- a/tests/coverage/branch/guard.cov-map
+++ b/tests/coverage/branch/guard.cov-map
@@ -1,5 +1,5 @@
 Function name: guard::branch_match_guard
-Raw bytes (89): 0x[01, 01, 08, 05, 0d, 05, 17, 0d, 11, 1f, 17, 05, 09, 0d, 11, 1f, 15, 05, 09, 0d, 01, 0b, 01, 01, 10, 02, 03, 0b, 00, 0c, 15, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 05, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 1d, 02, 0a, 11, 03, 0e, 00, 0f, 02, 00, 14, 00, 19, 20, 11, 06, 00, 14, 00, 1e, 11, 00, 1d, 02, 0a, 0e, 03, 0e, 02, 0a, 1b, 04, 01, 00, 02]
+Raw bytes (89): 0x[01, 01, 08, 05, 0d, 05, 17, 0d, 11, 1f, 17, 05, 09, 0d, 11, 1f, 15, 05, 09, 0d, 01, 0c, 01, 01, 10, 02, 03, 0b, 00, 0c, 15, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 05, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 1d, 02, 0a, 11, 03, 0e, 00, 0f, 02, 00, 14, 00, 19, 20, 11, 06, 00, 14, 00, 1e, 11, 00, 1d, 02, 0a, 0e, 03, 0e, 02, 0a, 1b, 04, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 8
@@ -12,7 +12,7 @@ Number of expressions: 8
 - expression 6 operands: lhs = Expression(7, Add), rhs = Counter(5)
 - expression 7 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 13
-- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
 - Code(Expression(0, Sub)) at (prev + 3, 11) to (start + 0, 12)
     = (c1 - c3)
 - Code(Counter(5)) at (prev + 1, 20) to (start + 2, 10)
diff --git a/tests/coverage/branch/guard.coverage b/tests/coverage/branch/guard.coverage
index 3376209d373..f89b965b5d0 100644
--- a/tests/coverage/branch/guard.coverage
+++ b/tests/coverage/branch/guard.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/guard.rs b/tests/coverage/branch/guard.rs
index 78b79a62946..fa049e6206d 100644
--- a/tests/coverage/branch/guard.rs
+++ b/tests/coverage/branch/guard.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/if-let.coverage b/tests/coverage/branch/if-let.coverage
index 368597f1daa..9a3f0113f75 100644
--- a/tests/coverage/branch/if-let.coverage
+++ b/tests/coverage/branch/if-let.coverage
@@ -1,4 +1,4 @@
-   LL|       |#![feature(let_chains)]
+   LL|       |#![feature(coverage_attribute, let_chains)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/if-let.rs b/tests/coverage/branch/if-let.rs
index 1ac506964b1..13db00a82b1 100644
--- a/tests/coverage/branch/if-let.rs
+++ b/tests/coverage/branch/if-let.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+#![feature(coverage_attribute, let_chains)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/if.cov-map b/tests/coverage/branch/if.cov-map
index bd507c5a324..3d9a1d2e1ab 100644
--- a/tests/coverage/branch/if.cov-map
+++ b/tests/coverage/branch/if.cov-map
@@ -1,5 +1,5 @@
 Function name: if::branch_and
-Raw bytes (54): 0x[01, 01, 03, 05, 09, 09, 0d, 05, 0d, 08, 01, 2a, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 09, 00, 0d, 00, 0e, 20, 0d, 06, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 05, 03, 01, 00, 02]
+Raw bytes (54): 0x[01, 01, 03, 05, 09, 09, 0d, 05, 0d, 08, 01, 2b, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 09, 00, 0d, 00, 0e, 20, 0d, 06, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 05, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -7,7 +7,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(2), rhs = Counter(3)
 - expression 2 operands: lhs = Counter(1), rhs = Counter(3)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 42, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 43, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 8) to (start + 0, 9)
     true  = c2
@@ -23,7 +23,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c3
 
 Function name: if::branch_not
-Raw bytes (116): 0x[01, 01, 07, 05, 09, 05, 0d, 05, 0d, 05, 11, 05, 11, 05, 15, 05, 15, 12, 01, 0b, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 09, 01, 09, 00, 11, 02, 01, 05, 00, 06, 05, 01, 08, 00, 0a, 20, 0a, 0d, 00, 08, 00, 0a, 0a, 00, 0b, 02, 06, 0d, 02, 05, 00, 06, 05, 01, 08, 00, 0b, 20, 11, 12, 00, 08, 00, 0b, 11, 00, 0c, 02, 06, 12, 02, 05, 00, 06, 05, 01, 08, 00, 0c, 20, 1a, 15, 00, 08, 00, 0c, 1a, 00, 0d, 02, 06, 15, 02, 05, 00, 06, 05, 01, 01, 00, 02]
+Raw bytes (116): 0x[01, 01, 07, 05, 09, 05, 0d, 05, 0d, 05, 11, 05, 11, 05, 15, 05, 15, 12, 01, 0c, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 09, 01, 09, 00, 11, 02, 01, 05, 00, 06, 05, 01, 08, 00, 0a, 20, 0a, 0d, 00, 08, 00, 0a, 0a, 00, 0b, 02, 06, 0d, 02, 05, 00, 06, 05, 01, 08, 00, 0b, 20, 11, 12, 00, 08, 00, 0b, 11, 00, 0c, 02, 06, 12, 02, 05, 00, 06, 05, 01, 08, 00, 0c, 20, 1a, 15, 00, 08, 00, 0c, 1a, 00, 0d, 02, 06, 15, 02, 05, 00, 06, 05, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 7
@@ -35,7 +35,7 @@ Number of expressions: 7
 - expression 5 operands: lhs = Counter(1), rhs = Counter(5)
 - expression 6 operands: lhs = Counter(1), rhs = Counter(5)
 Number of file 0 mappings: 18
-- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 8) to (start + 0, 9)
     true  = c2
@@ -68,7 +68,7 @@ Number of file 0 mappings: 18
 Highest counter ID seen: c5
 
 Function name: if::branch_not_as
-Raw bytes (90): 0x[01, 01, 05, 05, 09, 05, 0d, 05, 0d, 05, 11, 05, 11, 0e, 01, 1c, 01, 01, 10, 05, 03, 08, 00, 14, 20, 02, 09, 00, 08, 00, 14, 02, 00, 15, 02, 06, 09, 02, 05, 00, 06, 05, 01, 08, 00, 15, 20, 0d, 0a, 00, 08, 00, 15, 0d, 00, 16, 02, 06, 0a, 02, 05, 00, 06, 05, 01, 08, 00, 16, 20, 12, 11, 00, 08, 00, 16, 12, 00, 17, 02, 06, 11, 02, 05, 00, 06, 05, 01, 01, 00, 02]
+Raw bytes (90): 0x[01, 01, 05, 05, 09, 05, 0d, 05, 0d, 05, 11, 05, 11, 0e, 01, 1d, 01, 01, 10, 05, 03, 08, 00, 14, 20, 02, 09, 00, 08, 00, 14, 02, 00, 15, 02, 06, 09, 02, 05, 00, 06, 05, 01, 08, 00, 15, 20, 0d, 0a, 00, 08, 00, 15, 0d, 00, 16, 02, 06, 0a, 02, 05, 00, 06, 05, 01, 08, 00, 16, 20, 12, 11, 00, 08, 00, 16, 12, 00, 17, 02, 06, 11, 02, 05, 00, 06, 05, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 5
@@ -78,7 +78,7 @@ Number of expressions: 5
 - expression 3 operands: lhs = Counter(1), rhs = Counter(4)
 - expression 4 operands: lhs = Counter(1), rhs = Counter(4)
 Number of file 0 mappings: 14
-- Code(Counter(0)) at (prev + 28, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 29, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 8) to (start + 0, 20)
 - Branch { true: Expression(0, Sub), false: Counter(2) } at (prev + 0, 8) to (start + 0, 20)
     true  = (c1 - c2)
@@ -104,7 +104,7 @@ Number of file 0 mappings: 14
 Highest counter ID seen: c4
 
 Function name: if::branch_or
-Raw bytes (60): 0x[01, 01, 06, 05, 09, 05, 17, 09, 0d, 09, 0d, 05, 17, 09, 0d, 08, 01, 34, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 02, 00, 0d, 00, 0e, 20, 0d, 12, 00, 0d, 00, 0e, 17, 00, 0f, 02, 06, 12, 02, 0c, 02, 06, 05, 03, 01, 00, 02]
+Raw bytes (60): 0x[01, 01, 06, 05, 09, 05, 17, 09, 0d, 09, 0d, 05, 17, 09, 0d, 08, 01, 35, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 02, 00, 0d, 00, 0e, 20, 0d, 12, 00, 0d, 00, 0e, 17, 00, 0f, 02, 06, 12, 02, 0c, 02, 06, 05, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 6
@@ -115,7 +115,7 @@ Number of expressions: 6
 - expression 4 operands: lhs = Counter(1), rhs = Expression(5, Add)
 - expression 5 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 52, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 53, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 8) to (start + 0, 9)
     true  = c2
diff --git a/tests/coverage/branch/if.coverage b/tests/coverage/branch/if.coverage
index fd0a3d87a8d..3d107188ca6 100644
--- a/tests/coverage/branch/if.coverage
+++ b/tests/coverage/branch/if.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/if.rs b/tests/coverage/branch/if.rs
index 9e06ffc1aa5..151eede75bb 100644
--- a/tests/coverage/branch/if.rs
+++ b/tests/coverage/branch/if.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/lazy-boolean.cov-map b/tests/coverage/branch/lazy-boolean.cov-map
index 70819505485..94522734bcd 100644
--- a/tests/coverage/branch/lazy-boolean.cov-map
+++ b/tests/coverage/branch/lazy-boolean.cov-map
@@ -1,11 +1,11 @@
 Function name: lazy_boolean::branch_and
-Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 12, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0d, 00, 0e, 20, 09, 02, 00, 0d, 00, 0e, 09, 00, 12, 00, 13, 05, 01, 05, 01, 02]
+Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 13, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0d, 00, 0e, 20, 09, 02, 00, 0d, 00, 0e, 09, 00, 12, 00, 13, 05, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 18, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 19, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 4, 9) to (start + 0, 10)
 - Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
@@ -16,13 +16,13 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c2
 
 Function name: lazy_boolean::branch_or
-Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 1a, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0d, 00, 0e, 20, 09, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 05, 01, 05, 01, 02]
+Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 1b, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0d, 00, 0e, 20, 09, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 05, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 26, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 27, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 4, 9) to (start + 0, 10)
 - Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
@@ -34,7 +34,7 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c2
 
 Function name: lazy_boolean::chain
-Raw bytes (141): 0x[01, 01, 0f, 05, 09, 09, 0d, 0d, 11, 05, 15, 05, 15, 05, 3b, 15, 19, 05, 3b, 15, 19, 05, 37, 3b, 1d, 15, 19, 05, 37, 3b, 1d, 15, 19, 13, 01, 23, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0d, 00, 12, 20, 09, 02, 00, 0d, 00, 12, 09, 00, 16, 00, 1b, 20, 0d, 06, 00, 16, 00, 1b, 0d, 00, 1f, 00, 24, 20, 11, 0a, 00, 1f, 00, 24, 11, 00, 28, 00, 2d, 05, 01, 05, 00, 11, 05, 03, 09, 00, 0a, 05, 00, 0d, 00, 12, 20, 15, 12, 00, 0d, 00, 12, 12, 00, 16, 00, 1b, 20, 19, 1e, 00, 16, 00, 1b, 1e, 00, 1f, 00, 24, 20, 1d, 32, 00, 1f, 00, 24, 32, 00, 28, 00, 2d, 05, 01, 05, 01, 02]
+Raw bytes (141): 0x[01, 01, 0f, 05, 09, 09, 0d, 0d, 11, 05, 15, 05, 15, 05, 3b, 15, 19, 05, 3b, 15, 19, 05, 37, 3b, 1d, 15, 19, 05, 37, 3b, 1d, 15, 19, 13, 01, 24, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0d, 00, 12, 20, 09, 02, 00, 0d, 00, 12, 09, 00, 16, 00, 1b, 20, 0d, 06, 00, 16, 00, 1b, 0d, 00, 1f, 00, 24, 20, 11, 0a, 00, 1f, 00, 24, 11, 00, 28, 00, 2d, 05, 01, 05, 00, 11, 05, 03, 09, 00, 0a, 05, 00, 0d, 00, 12, 20, 15, 12, 00, 0d, 00, 12, 12, 00, 16, 00, 1b, 20, 19, 1e, 00, 16, 00, 1b, 1e, 00, 1f, 00, 24, 20, 1d, 32, 00, 1f, 00, 24, 32, 00, 28, 00, 2d, 05, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 15
@@ -54,7 +54,7 @@ Number of expressions: 15
 - expression 13 operands: lhs = Expression(14, Add), rhs = Counter(7)
 - expression 14 operands: lhs = Counter(5), rhs = Counter(6)
 Number of file 0 mappings: 19
-- Code(Counter(0)) at (prev + 35, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 36, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 4, 9) to (start + 0, 10)
 - Code(Counter(1)) at (prev + 0, 13) to (start + 0, 18)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 18)
@@ -91,7 +91,7 @@ Number of file 0 mappings: 19
 Highest counter ID seen: c7
 
 Function name: lazy_boolean::nested_mixed
-Raw bytes (137): 0x[01, 01, 0d, 05, 09, 05, 1f, 09, 0d, 09, 0d, 1f, 11, 09, 0d, 1f, 11, 09, 0d, 05, 15, 15, 19, 05, 19, 05, 33, 19, 1d, 13, 01, 30, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 09, 02, 00, 0e, 00, 13, 02, 00, 17, 00, 1d, 20, 0d, 06, 00, 17, 00, 1d, 1f, 00, 23, 00, 28, 20, 11, 1a, 00, 23, 00, 28, 1a, 00, 2c, 00, 33, 05, 01, 05, 00, 11, 05, 03, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 15, 22, 00, 0e, 00, 13, 15, 00, 17, 00, 1c, 20, 19, 26, 00, 17, 00, 1c, 2a, 00, 22, 00, 28, 20, 1d, 2e, 00, 22, 00, 28, 1d, 00, 2c, 00, 33, 05, 01, 05, 01, 02]
+Raw bytes (137): 0x[01, 01, 0d, 05, 09, 05, 1f, 09, 0d, 09, 0d, 1f, 11, 09, 0d, 1f, 11, 09, 0d, 05, 15, 15, 19, 05, 19, 05, 33, 19, 1d, 13, 01, 31, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 09, 02, 00, 0e, 00, 13, 02, 00, 17, 00, 1d, 20, 0d, 06, 00, 17, 00, 1d, 1f, 00, 23, 00, 28, 20, 11, 1a, 00, 23, 00, 28, 1a, 00, 2c, 00, 33, 05, 01, 05, 00, 11, 05, 03, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 15, 22, 00, 0e, 00, 13, 15, 00, 17, 00, 1c, 20, 19, 26, 00, 17, 00, 1c, 2a, 00, 22, 00, 28, 20, 1d, 2e, 00, 22, 00, 28, 1d, 00, 2c, 00, 33, 05, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 13
@@ -109,7 +109,7 @@ Number of expressions: 13
 - expression 11 operands: lhs = Counter(1), rhs = Expression(12, Add)
 - expression 12 operands: lhs = Counter(6), rhs = Counter(7)
 Number of file 0 mappings: 19
-- Code(Counter(0)) at (prev + 48, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 49, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 4, 9) to (start + 0, 10)
 - Code(Counter(1)) at (prev + 0, 14) to (start + 0, 19)
 - Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 14) to (start + 0, 19)
diff --git a/tests/coverage/branch/lazy-boolean.coverage b/tests/coverage/branch/lazy-boolean.coverage
index 6e5dfbd19f3..f6aba1da46e 100644
--- a/tests/coverage/branch/lazy-boolean.coverage
+++ b/tests/coverage/branch/lazy-boolean.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/lazy-boolean.rs b/tests/coverage/branch/lazy-boolean.rs
index 68267bf56ed..3c73fc1a87d 100644
--- a/tests/coverage/branch/lazy-boolean.rs
+++ b/tests/coverage/branch/lazy-boolean.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/let-else.cov-map b/tests/coverage/branch/let-else.cov-map
index 466de5d5de3..e6bf7ed6a92 100644
--- a/tests/coverage/branch/let-else.cov-map
+++ b/tests/coverage/branch/let-else.cov-map
@@ -1,11 +1,11 @@
 Function name: let_else::let_else
-Raw bytes (43): 0x[01, 01, 01, 05, 09, 07, 01, 0b, 01, 01, 10, 20, 02, 09, 03, 09, 00, 10, 02, 00, 0e, 00, 0f, 05, 00, 13, 00, 18, 09, 01, 09, 01, 0f, 02, 04, 05, 00, 0b, 05, 01, 01, 00, 02]
+Raw bytes (43): 0x[01, 01, 01, 05, 09, 07, 01, 0c, 01, 01, 10, 20, 02, 09, 03, 09, 00, 10, 02, 00, 0e, 00, 0f, 05, 00, 13, 00, 18, 09, 01, 09, 01, 0f, 02, 04, 05, 00, 0b, 05, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 7
-- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
 - Branch { true: Expression(0, Sub), false: Counter(2) } at (prev + 3, 9) to (start + 0, 16)
     true  = (c1 - c2)
     false = c2
diff --git a/tests/coverage/branch/let-else.coverage b/tests/coverage/branch/let-else.coverage
index f0549205590..22ad8f2b0e1 100644
--- a/tests/coverage/branch/let-else.coverage
+++ b/tests/coverage/branch/let-else.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/let-else.rs b/tests/coverage/branch/let-else.rs
index 0d23d956541..af0665d8241 100644
--- a/tests/coverage/branch/let-else.rs
+++ b/tests/coverage/branch/let-else.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/match-arms.cov-map b/tests/coverage/branch/match-arms.cov-map
index 5d9f94923bc..53d0a4edbd0 100644
--- a/tests/coverage/branch/match-arms.cov-map
+++ b/tests/coverage/branch/match-arms.cov-map
@@ -1,5 +1,5 @@
 Function name: match_arms::guards
-Raw bytes (98): 0x[01, 01, 0d, 11, 19, 27, 19, 2b, 00, 2f, 11, 33, 0d, 05, 09, 1f, 25, 23, 21, 27, 1d, 2b, 00, 2f, 11, 33, 0d, 05, 09, 0c, 01, 2f, 01, 01, 10, 11, 03, 0b, 00, 10, 1d, 01, 11, 00, 29, 20, 1d, 05, 00, 17, 00, 1b, 21, 01, 11, 00, 29, 20, 21, 09, 00, 17, 00, 1b, 25, 01, 11, 00, 29, 20, 25, 0d, 00, 17, 00, 1b, 19, 01, 11, 00, 29, 20, 19, 02, 00, 17, 00, 1b, 06, 01, 0e, 00, 18, 1b, 03, 05, 01, 02]
+Raw bytes (98): 0x[01, 01, 0d, 11, 19, 27, 19, 2b, 00, 2f, 11, 33, 0d, 05, 09, 1f, 25, 23, 21, 27, 1d, 2b, 00, 2f, 11, 33, 0d, 05, 09, 0c, 01, 30, 01, 01, 10, 11, 03, 0b, 00, 10, 1d, 01, 11, 00, 29, 20, 1d, 05, 00, 17, 00, 1b, 21, 01, 11, 00, 29, 20, 21, 09, 00, 17, 00, 1b, 25, 01, 11, 00, 29, 20, 25, 0d, 00, 17, 00, 1b, 19, 01, 11, 00, 29, 20, 19, 02, 00, 17, 00, 1b, 06, 01, 0e, 00, 18, 1b, 03, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 13
@@ -17,7 +17,7 @@ Number of expressions: 13
 - expression 11 operands: lhs = Expression(12, Add), rhs = Counter(3)
 - expression 12 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 12
-- Code(Counter(0)) at (prev + 47, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 48, 1) to (start + 1, 16)
 - Code(Counter(4)) at (prev + 3, 11) to (start + 0, 16)
 - Code(Counter(7)) at (prev + 1, 17) to (start + 0, 41)
 - Branch { true: Counter(7), false: Counter(1) } at (prev + 0, 23) to (start + 0, 27)
@@ -42,7 +42,7 @@ Number of file 0 mappings: 12
 Highest counter ID seen: c9
 
 Function name: match_arms::match_arms
-Raw bytes (45): 0x[01, 01, 03, 05, 07, 0b, 11, 09, 0d, 07, 01, 17, 01, 01, 10, 05, 03, 0b, 00, 10, 09, 01, 11, 00, 21, 0d, 01, 11, 00, 21, 11, 01, 11, 00, 21, 02, 01, 11, 00, 21, 05, 03, 05, 01, 02]
+Raw bytes (45): 0x[01, 01, 03, 05, 07, 0b, 11, 09, 0d, 07, 01, 18, 01, 01, 10, 05, 03, 0b, 00, 10, 09, 01, 11, 00, 21, 0d, 01, 11, 00, 21, 11, 01, 11, 00, 21, 02, 01, 11, 00, 21, 05, 03, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -50,7 +50,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
 - expression 2 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 7
-- Code(Counter(0)) at (prev + 23, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 24, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 11) to (start + 0, 16)
 - Code(Counter(2)) at (prev + 1, 17) to (start + 0, 33)
 - Code(Counter(3)) at (prev + 1, 17) to (start + 0, 33)
@@ -61,7 +61,7 @@ Number of file 0 mappings: 7
 Highest counter ID seen: c4
 
 Function name: match_arms::or_patterns
-Raw bytes (57): 0x[01, 01, 04, 09, 0d, 05, 0b, 03, 11, 05, 03, 09, 01, 24, 01, 01, 10, 05, 03, 0b, 00, 10, 09, 01, 11, 00, 12, 0d, 00, 1e, 00, 1f, 03, 00, 24, 00, 2e, 11, 01, 11, 00, 12, 06, 00, 1e, 00, 1f, 0e, 00, 24, 00, 2e, 05, 03, 05, 01, 02]
+Raw bytes (57): 0x[01, 01, 04, 09, 0d, 05, 0b, 03, 11, 05, 03, 09, 01, 25, 01, 01, 10, 05, 03, 0b, 00, 10, 09, 01, 11, 00, 12, 0d, 00, 1e, 00, 1f, 03, 00, 24, 00, 2e, 11, 01, 11, 00, 12, 06, 00, 1e, 00, 1f, 0e, 00, 24, 00, 2e, 05, 03, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 4
@@ -70,7 +70,7 @@ Number of expressions: 4
 - expression 2 operands: lhs = Expression(0, Add), rhs = Counter(4)
 - expression 3 operands: lhs = Counter(1), rhs = Expression(0, Add)
 Number of file 0 mappings: 9
-- Code(Counter(0)) at (prev + 36, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 37, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 11) to (start + 0, 16)
 - Code(Counter(2)) at (prev + 1, 17) to (start + 0, 18)
 - Code(Counter(3)) at (prev + 0, 30) to (start + 0, 31)
diff --git a/tests/coverage/branch/match-arms.coverage b/tests/coverage/branch/match-arms.coverage
index bc797d55a53..ea8a6f97ab1 100644
--- a/tests/coverage/branch/match-arms.coverage
+++ b/tests/coverage/branch/match-arms.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/match-arms.rs b/tests/coverage/branch/match-arms.rs
index 6292a9c2050..63151f59ffe 100644
--- a/tests/coverage/branch/match-arms.rs
+++ b/tests/coverage/branch/match-arms.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/match-trivial.cov-map b/tests/coverage/branch/match-trivial.cov-map
index 0a1d8cef050..6af8ce46f5f 100644
--- a/tests/coverage/branch/match-trivial.cov-map
+++ b/tests/coverage/branch/match-trivial.cov-map
@@ -1,19 +1,19 @@
 Function name: match_trivial::_uninhabited (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 15, 01, 01, 10]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 16, 01, 01, 10]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 21, 1) to (start + 1, 16)
+- Code(Zero) at (prev + 22, 1) to (start + 1, 16)
 Highest counter ID seen: (none)
 
 Function name: match_trivial::trivial
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 1d, 01, 01, 10, 05, 03, 0b, 05, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 1e, 01, 01, 10, 05, 03, 0b, 05, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 29, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 30, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 11) to (start + 5, 2)
 Highest counter ID seen: c1
 
diff --git a/tests/coverage/branch/match-trivial.coverage b/tests/coverage/branch/match-trivial.coverage
index bd6be9ea3b5..4ffb172e1b6 100644
--- a/tests/coverage/branch/match-trivial.coverage
+++ b/tests/coverage/branch/match-trivial.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/match-trivial.rs b/tests/coverage/branch/match-trivial.rs
index 62680916d5c..db8887a26b7 100644
--- a/tests/coverage/branch/match-trivial.rs
+++ b/tests/coverage/branch/match-trivial.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/no-mir-spans.cov-map b/tests/coverage/branch/no-mir-spans.cov-map
index 15ead0726e1..6003efc36ca 100644
--- a/tests/coverage/branch/no-mir-spans.cov-map
+++ b/tests/coverage/branch/no-mir-spans.cov-map
@@ -1,35 +1,35 @@
 Function name: no_mir_spans::while_cond
-Raw bytes (16): 0x[01, 01, 00, 02, 01, 0f, 01, 00, 11, 20, 05, 09, 04, 0b, 00, 10]
+Raw bytes (16): 0x[01, 01, 00, 02, 01, 10, 01, 00, 11, 20, 05, 09, 04, 0b, 00, 10]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 15, 1) to (start + 0, 17)
+- Code(Counter(0)) at (prev + 16, 1) to (start + 0, 17)
 - Branch { true: Counter(1), false: Counter(2) } at (prev + 4, 11) to (start + 0, 16)
     true  = c1
     false = c2
 Highest counter ID seen: c2
 
 Function name: no_mir_spans::while_cond_not
-Raw bytes (16): 0x[01, 01, 00, 02, 01, 18, 01, 00, 15, 20, 09, 05, 04, 0b, 00, 14]
+Raw bytes (16): 0x[01, 01, 00, 02, 01, 19, 01, 00, 15, 20, 09, 05, 04, 0b, 00, 14]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 24, 1) to (start + 0, 21)
+- Code(Counter(0)) at (prev + 25, 1) to (start + 0, 21)
 - Branch { true: Counter(2), false: Counter(1) } at (prev + 4, 11) to (start + 0, 20)
     true  = c2
     false = c1
 Highest counter ID seen: c2
 
 Function name: no_mir_spans::while_op_and
-Raw bytes (25): 0x[01, 01, 01, 05, 09, 03, 01, 21, 01, 00, 13, 20, 05, 0d, 05, 0b, 00, 10, 20, 02, 09, 00, 14, 00, 19]
+Raw bytes (25): 0x[01, 01, 01, 05, 09, 03, 01, 22, 01, 00, 13, 20, 05, 0d, 05, 0b, 00, 10, 20, 02, 09, 00, 14, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 33, 1) to (start + 0, 19)
+- Code(Counter(0)) at (prev + 34, 1) to (start + 0, 19)
 - Branch { true: Counter(1), false: Counter(3) } at (prev + 5, 11) to (start + 0, 16)
     true  = c1
     false = c3
@@ -39,13 +39,13 @@ Number of file 0 mappings: 3
 Highest counter ID seen: c3
 
 Function name: no_mir_spans::while_op_or
-Raw bytes (25): 0x[01, 01, 01, 09, 0d, 03, 01, 2c, 01, 00, 12, 20, 05, 09, 05, 0b, 00, 10, 20, 0d, 02, 00, 14, 00, 19]
+Raw bytes (25): 0x[01, 01, 01, 09, 0d, 03, 01, 2d, 01, 00, 12, 20, 05, 09, 05, 0b, 00, 10, 20, 0d, 02, 00, 14, 00, 19]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 44, 1) to (start + 0, 18)
+- Code(Counter(0)) at (prev + 45, 1) to (start + 0, 18)
 - Branch { true: Counter(1), false: Counter(2) } at (prev + 5, 11) to (start + 0, 16)
     true  = c1
     false = c2
diff --git a/tests/coverage/branch/no-mir-spans.coverage b/tests/coverage/branch/no-mir-spans.coverage
index be5a1ef3442..2cae98ed3ff 100644
--- a/tests/coverage/branch/no-mir-spans.coverage
+++ b/tests/coverage/branch/no-mir-spans.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch,no-mir-spans
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/no-mir-spans.rs b/tests/coverage/branch/no-mir-spans.rs
index 47b4d1eff58..acb268f2d45 100644
--- a/tests/coverage/branch/no-mir-spans.rs
+++ b/tests/coverage/branch/no-mir-spans.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch,no-mir-spans
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/while.cov-map b/tests/coverage/branch/while.cov-map
index f2956efade1..5eb08a42803 100644
--- a/tests/coverage/branch/while.cov-map
+++ b/tests/coverage/branch/while.cov-map
@@ -1,11 +1,11 @@
 Function name: while::while_cond
-Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 0b, 01, 01, 10, 05, 03, 09, 00, 12, 03, 01, 0b, 00, 10, 20, 09, 05, 00, 0b, 00, 10, 09, 00, 11, 02, 06, 05, 03, 01, 00, 02]
+Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 0c, 01, 01, 10, 05, 03, 09, 00, 12, 03, 01, 0b, 00, 10, 20, 09, 05, 00, 0b, 00, 10, 09, 00, 11, 02, 06, 05, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 9) to (start + 0, 18)
 - Code(Expression(0, Add)) at (prev + 1, 11) to (start + 0, 16)
     = (c1 + c2)
@@ -17,13 +17,13 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c2
 
 Function name: while::while_cond_not
-Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 14, 01, 01, 10, 05, 03, 09, 00, 12, 03, 01, 0b, 00, 14, 20, 09, 05, 00, 0b, 00, 14, 09, 00, 15, 02, 06, 05, 03, 01, 00, 02]
+Raw bytes (38): 0x[01, 01, 01, 05, 09, 06, 01, 15, 01, 01, 10, 05, 03, 09, 00, 12, 03, 01, 0b, 00, 14, 20, 09, 05, 00, 0b, 00, 14, 09, 00, 15, 02, 06, 05, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 20, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 21, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 9) to (start + 0, 18)
 - Code(Expression(0, Add)) at (prev + 1, 11) to (start + 0, 20)
     = (c1 + c2)
@@ -35,7 +35,7 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c2
 
 Function name: while::while_op_and
-Raw bytes (56): 0x[01, 01, 04, 05, 09, 03, 0d, 03, 0d, 05, 0d, 08, 01, 1d, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 0a, 0d, 00, 0b, 00, 10, 0a, 00, 14, 00, 19, 20, 09, 0e, 00, 14, 00, 19, 09, 00, 1a, 03, 06, 05, 04, 01, 00, 02]
+Raw bytes (56): 0x[01, 01, 04, 05, 09, 03, 0d, 03, 0d, 05, 0d, 08, 01, 1e, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 0a, 0d, 00, 0b, 00, 10, 0a, 00, 14, 00, 19, 20, 09, 0e, 00, 14, 00, 19, 09, 00, 1a, 03, 06, 05, 04, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 4
@@ -44,7 +44,7 @@ Number of expressions: 4
 - expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
 - expression 3 operands: lhs = Counter(1), rhs = Counter(3)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 29, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 30, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 9) to (start + 1, 18)
 - Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 16)
     = (c1 + c2)
@@ -61,7 +61,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c3
 
 Function name: while::while_op_or
-Raw bytes (58): 0x[01, 01, 05, 07, 0d, 05, 09, 05, 0d, 05, 0d, 09, 0d, 08, 01, 28, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 09, 0f, 00, 0b, 00, 10, 0f, 00, 14, 00, 19, 20, 0d, 05, 00, 14, 00, 19, 13, 00, 1a, 03, 06, 05, 04, 01, 00, 02]
+Raw bytes (58): 0x[01, 01, 05, 07, 0d, 05, 09, 05, 0d, 05, 0d, 09, 0d, 08, 01, 29, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 09, 0f, 00, 0b, 00, 10, 0f, 00, 14, 00, 19, 20, 0d, 05, 00, 14, 00, 19, 13, 00, 1a, 03, 06, 05, 04, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 5
@@ -71,7 +71,7 @@ Number of expressions: 5
 - expression 3 operands: lhs = Counter(1), rhs = Counter(3)
 - expression 4 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 40, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 41, 1) to (start + 1, 16)
 - Code(Counter(1)) at (prev + 3, 9) to (start + 1, 18)
 - Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 16)
     = ((c1 + c2) + c3)
diff --git a/tests/coverage/branch/while.coverage b/tests/coverage/branch/while.coverage
index b16c8d7defd..8d9a6c3bc68 100644
--- a/tests/coverage/branch/while.coverage
+++ b/tests/coverage/branch/while.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=branch
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/branch/while.rs b/tests/coverage/branch/while.rs
index e7180c43a5e..507815fbecb 100644
--- a/tests/coverage/branch/while.rs
+++ b/tests/coverage/branch/while.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=branch
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/closure_macro_async.cov-map b/tests/coverage/closure_macro_async.cov-map
index 6a36ce2e5fe..1bd1460a147 100644
--- a/tests/coverage/closure_macro_async.cov-map
+++ b/tests/coverage/closure_macro_async.cov-map
@@ -1,29 +1,29 @@
 Function name: closure_macro_async::load_configuration_files
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 20, 01, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 32, 1) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: closure_macro_async::test
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 24, 01, 00, 2b]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 25, 01, 00, 2b]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 36, 1) to (start + 0, 43)
+- Code(Counter(0)) at (prev + 37, 1) to (start + 0, 43)
 Highest counter ID seen: c0
 
 Function name: closure_macro_async::test::{closure#0}
-Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 24, 2b, 01, 21, 02, 02, 09, 00, 0f, 01, 00, 12, 00, 54, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 01, 03, 01, 00, 02]
+Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 25, 2b, 01, 21, 02, 02, 09, 00, 0f, 01, 00, 12, 00, 54, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 36, 43) to (start + 1, 33)
+- Code(Counter(0)) at (prev + 37, 43) to (start + 1, 33)
 - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15)
     = (c0 - c1)
 - Code(Counter(0)) at (prev + 0, 18) to (start + 0, 84)
@@ -34,7 +34,7 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c1
 
 Function name: closure_macro_async::test::{closure#0}::{closure#0}
-Raw bytes (35): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 05, 01, 13, 1c, 03, 21, 05, 04, 11, 01, 27, 02, 03, 11, 00, 16, 06, 00, 17, 00, 1e, 01, 02, 09, 00, 0a]
+Raw bytes (35): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 05, 01, 14, 1c, 03, 21, 05, 04, 11, 01, 27, 02, 03, 11, 00, 16, 06, 00, 17, 00, 1e, 01, 02, 09, 00, 0a]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -42,7 +42,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
 - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 19, 28) to (start + 3, 33)
+- Code(Counter(0)) at (prev + 20, 28) to (start + 3, 33)
 - Code(Counter(1)) at (prev + 4, 17) to (start + 1, 39)
 - Code(Expression(0, Sub)) at (prev + 3, 17) to (start + 0, 22)
     = (c0 - c1)
diff --git a/tests/coverage/closure_macro_async.coverage b/tests/coverage/closure_macro_async.coverage
index efa40489bcf..1e1ffec9f76 100644
--- a/tests/coverage/closure_macro_async.coverage
+++ b/tests/coverage/closure_macro_async.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2018
    LL|       |
    LL|       |//@ aux-build: executor.rs
diff --git a/tests/coverage/closure_macro_async.rs b/tests/coverage/closure_macro_async.rs
index 1f67f2623a1..5dbb438424d 100644
--- a/tests/coverage/closure_macro_async.rs
+++ b/tests/coverage/closure_macro_async.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2018
 
 //@ aux-build: executor.rs
diff --git a/tests/coverage/closure_unit_return.cov-map b/tests/coverage/closure_unit_return.cov-map
index 0d108b3dcc7..9a66e0b0e77 100644
--- a/tests/coverage/closure_unit_return.cov-map
+++ b/tests/coverage/closure_unit_return.cov-map
@@ -1,38 +1,38 @@
 Function name: closure_unit_return::explicit_unit
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 06, 01, 01, 10, 01, 05, 05, 02, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 07, 01, 01, 10, 01, 05, 05, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 16)
 - Code(Counter(0)) at (prev + 5, 5) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: closure_unit_return::explicit_unit::{closure#0} (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 07, 16, 02, 06]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 08, 16, 02, 06]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 7, 22) to (start + 2, 6)
+- Code(Zero) at (prev + 8, 22) to (start + 2, 6)
 Highest counter ID seen: (none)
 
 Function name: closure_unit_return::implicit_unit
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 0f, 01, 01, 10, 01, 05, 05, 02, 02]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 10, 01, 01, 10, 01, 05, 05, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 16)
+- Code(Counter(0)) at (prev + 16, 1) to (start + 1, 16)
 - Code(Counter(0)) at (prev + 5, 5) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: closure_unit_return::implicit_unit::{closure#0} (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 10, 16, 02, 06]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 11, 16, 02, 06]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 16, 22) to (start + 2, 6)
+- Code(Zero) at (prev + 17, 22) to (start + 2, 6)
 Highest counter ID seen: (none)
 
diff --git a/tests/coverage/closure_unit_return.coverage b/tests/coverage/closure_unit_return.coverage
index 131fab993f0..5e57e0db160 100644
--- a/tests/coverage/closure_unit_return.coverage
+++ b/tests/coverage/closure_unit_return.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |// Regression test for an inconsistency between functions that return the value
diff --git a/tests/coverage/closure_unit_return.rs b/tests/coverage/closure_unit_return.rs
index 74334f32f6e..d4f139dd363 100644
--- a/tests/coverage/closure_unit_return.rs
+++ b/tests/coverage/closure_unit_return.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 // Regression test for an inconsistency between functions that return the value
diff --git a/tests/coverage/condition/conditions.cov-map b/tests/coverage/condition/conditions.cov-map
index d437c91b2b0..417637f2d2e 100644
--- a/tests/coverage/condition/conditions.cov-map
+++ b/tests/coverage/condition/conditions.cov-map
@@ -1,5 +1,5 @@
 Function name: conditions::assign_3_and_or
-Raw bytes (65): 0x[01, 01, 05, 01, 05, 05, 09, 01, 09, 01, 13, 09, 0d, 09, 01, 1b, 01, 00, 2f, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 0a, 00, 17, 00, 18, 20, 0d, 0e, 00, 17, 00, 18, 01, 01, 05, 01, 02]
+Raw bytes (65): 0x[01, 01, 05, 01, 05, 05, 09, 01, 09, 01, 13, 09, 0d, 09, 01, 1c, 01, 00, 2f, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 0a, 00, 17, 00, 18, 20, 0d, 0e, 00, 17, 00, 18, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 5
@@ -9,7 +9,7 @@ Number of expressions: 5
 - expression 3 operands: lhs = Counter(0), rhs = Expression(4, Add)
 - expression 4 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 9
-- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 47)
+- Code(Counter(0)) at (prev + 28, 1) to (start + 0, 47)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
@@ -28,7 +28,7 @@ Number of file 0 mappings: 9
 Highest counter ID seen: c3
 
 Function name: conditions::assign_3_or_and
-Raw bytes (63): 0x[01, 01, 04, 01, 05, 01, 0b, 05, 09, 09, 0d, 09, 01, 16, 01, 00, 2f, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 09, 00, 17, 00, 18, 20, 0d, 0e, 00, 17, 00, 18, 01, 01, 05, 01, 02]
+Raw bytes (63): 0x[01, 01, 04, 01, 05, 01, 0b, 05, 09, 09, 0d, 09, 01, 17, 01, 00, 2f, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 09, 00, 17, 00, 18, 20, 0d, 0e, 00, 17, 00, 18, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 4
@@ -37,7 +37,7 @@ Number of expressions: 4
 - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 3 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 9
-- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 47)
+- Code(Counter(0)) at (prev + 23, 1) to (start + 0, 47)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
@@ -56,14 +56,14 @@ Number of file 0 mappings: 9
 Highest counter ID seen: c3
 
 Function name: conditions::assign_and
-Raw bytes (47): 0x[01, 01, 02, 01, 05, 05, 09, 07, 01, 0c, 01, 00, 21, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 01, 02]
+Raw bytes (47): 0x[01, 01, 02, 01, 05, 05, 09, 07, 01, 0d, 01, 00, 21, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 7
-- Code(Counter(0)) at (prev + 12, 1) to (start + 0, 33)
+- Code(Counter(0)) at (prev + 13, 1) to (start + 0, 33)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
@@ -77,7 +77,7 @@ Number of file 0 mappings: 7
 Highest counter ID seen: c2
 
 Function name: conditions::assign_or
-Raw bytes (49): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 07, 01, 11, 01, 00, 20, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 01, 02]
+Raw bytes (49): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 07, 01, 12, 01, 00, 20, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -85,7 +85,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
 - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 7
-- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 32)
+- Code(Counter(0)) at (prev + 18, 1) to (start + 0, 32)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
@@ -100,23 +100,23 @@ Number of file 0 mappings: 7
 Highest counter ID seen: c2
 
 Function name: conditions::foo
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 20, 01, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 32, 1) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: conditions::func_call
-Raw bytes (37): 0x[01, 01, 02, 01, 05, 05, 09, 05, 01, 24, 01, 01, 0a, 20, 05, 02, 01, 09, 00, 0a, 05, 00, 0e, 00, 0f, 20, 09, 06, 00, 0e, 00, 0f, 01, 01, 01, 00, 02]
+Raw bytes (37): 0x[01, 01, 02, 01, 05, 05, 09, 05, 01, 25, 01, 01, 0a, 20, 05, 02, 01, 09, 00, 0a, 05, 00, 0e, 00, 0f, 20, 09, 06, 00, 0e, 00, 0f, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 36, 1) to (start + 1, 10)
+- Code(Counter(0)) at (prev + 37, 1) to (start + 1, 10)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 1, 9) to (start + 0, 10)
     true  = c1
     false = (c0 - c1)
@@ -128,11 +128,11 @@ Number of file 0 mappings: 5
 Highest counter ID seen: c2
 
 Function name: conditions::simple_assign
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 01, 03, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 08, 01, 03, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 7, 1) to (start + 3, 2)
+- Code(Counter(0)) at (prev + 8, 1) to (start + 3, 2)
 Highest counter ID seen: c0
 
diff --git a/tests/coverage/condition/conditions.coverage b/tests/coverage/condition/conditions.coverage
index 117e9aabb5b..3215b391d62 100644
--- a/tests/coverage/condition/conditions.coverage
+++ b/tests/coverage/condition/conditions.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ compile-flags: -Zcoverage-options=condition
    LL|       |//@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/condition/conditions.rs b/tests/coverage/condition/conditions.rs
index 63fa962ce5f..3d658dc93e0 100644
--- a/tests/coverage/condition/conditions.rs
+++ b/tests/coverage/condition/conditions.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ compile-flags: -Zcoverage-options=condition
 //@ llvm-cov-flags: --show-branches=count
diff --git a/tests/coverage/coverage_attr_closure.coverage b/tests/coverage/coverage_attr_closure.coverage
index 31898786afc..7bdb96bdab8 100644
--- a/tests/coverage/coverage_attr_closure.coverage
+++ b/tests/coverage/coverage_attr_closure.coverage
@@ -1,4 +1,4 @@
-   LL|       |#![feature(stmt_expr_attributes)]
+   LL|       |#![feature(coverage_attribute, stmt_expr_attributes)]
    LL|       |#![allow(dead_code)]
    LL|       |//@ edition: 2021
    LL|       |
diff --git a/tests/coverage/coverage_attr_closure.rs b/tests/coverage/coverage_attr_closure.rs
index c66ccb7f5a5..4341a868ab8 100644
--- a/tests/coverage/coverage_attr_closure.rs
+++ b/tests/coverage/coverage_attr_closure.rs
@@ -1,4 +1,4 @@
-#![feature(stmt_expr_attributes)]
+#![feature(coverage_attribute, stmt_expr_attributes)]
 #![allow(dead_code)]
 //@ edition: 2021
 
diff --git a/tests/coverage/fn_sig_into_try.cov-map b/tests/coverage/fn_sig_into_try.cov-map
index cd8726fe1c3..374811dba9e 100644
--- a/tests/coverage/fn_sig_into_try.cov-map
+++ b/tests/coverage/fn_sig_into_try.cov-map
@@ -1,20 +1,20 @@
 Function name: fn_sig_into_try::a
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 09, 01, 05, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 0a, 01, 05, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 9, 1) to (start + 5, 2)
+- Code(Counter(0)) at (prev + 10, 1) to (start + 5, 2)
 Highest counter ID seen: c0
 
 Function name: fn_sig_into_try::b
-Raw bytes (26): 0x[01, 01, 01, 01, 00, 04, 01, 10, 01, 03, 0f, 00, 03, 0f, 00, 10, 02, 01, 05, 00, 0c, 01, 01, 01, 00, 02]
+Raw bytes (26): 0x[01, 01, 01, 01, 00, 04, 01, 11, 01, 03, 0f, 00, 03, 0f, 00, 10, 02, 01, 05, 00, 0c, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Zero
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 16, 1) to (start + 3, 15)
+- Code(Counter(0)) at (prev + 17, 1) to (start + 3, 15)
 - Code(Zero) at (prev + 3, 15) to (start + 0, 16)
 - Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
     = (c0 - Zero)
@@ -22,13 +22,13 @@ Number of file 0 mappings: 4
 Highest counter ID seen: c0
 
 Function name: fn_sig_into_try::c
-Raw bytes (26): 0x[01, 01, 01, 01, 00, 04, 01, 17, 01, 03, 17, 00, 03, 17, 00, 18, 02, 01, 05, 00, 0c, 01, 01, 01, 00, 02]
+Raw bytes (26): 0x[01, 01, 01, 01, 00, 04, 01, 18, 01, 03, 17, 00, 03, 17, 00, 18, 02, 01, 05, 00, 0c, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Zero
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 23, 1) to (start + 3, 23)
+- Code(Counter(0)) at (prev + 24, 1) to (start + 3, 23)
 - Code(Zero) at (prev + 3, 23) to (start + 0, 24)
 - Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
     = (c0 - Zero)
@@ -36,13 +36,13 @@ Number of file 0 mappings: 4
 Highest counter ID seen: c0
 
 Function name: fn_sig_into_try::d
-Raw bytes (26): 0x[01, 01, 01, 01, 00, 04, 01, 1e, 01, 04, 0f, 00, 04, 0f, 00, 10, 02, 01, 05, 00, 0c, 01, 01, 01, 00, 02]
+Raw bytes (26): 0x[01, 01, 01, 01, 00, 04, 01, 1f, 01, 04, 0f, 00, 04, 0f, 00, 10, 02, 01, 05, 00, 0c, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Zero
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 30, 1) to (start + 4, 15)
+- Code(Counter(0)) at (prev + 31, 1) to (start + 4, 15)
 - Code(Zero) at (prev + 4, 15) to (start + 0, 16)
 - Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
     = (c0 - Zero)
diff --git a/tests/coverage/fn_sig_into_try.coverage b/tests/coverage/fn_sig_into_try.coverage
index 05b8edf15a4..cabe747ce5a 100644
--- a/tests/coverage/fn_sig_into_try.coverage
+++ b/tests/coverage/fn_sig_into_try.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |// Regression test for inconsistent handling of function signature spans that
diff --git a/tests/coverage/fn_sig_into_try.rs b/tests/coverage/fn_sig_into_try.rs
index fd3e0c3f7c6..cda5e716edf 100644
--- a/tests/coverage/fn_sig_into_try.rs
+++ b/tests/coverage/fn_sig_into_try.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 // Regression test for inconsistent handling of function signature spans that
diff --git a/tests/coverage/if_not.cov-map b/tests/coverage/if_not.cov-map
index 6f366796722..f47139ce5a4 100644
--- a/tests/coverage/if_not.cov-map
+++ b/tests/coverage/if_not.cov-map
@@ -1,5 +1,5 @@
 Function name: if_not::if_not
-Raw bytes (60): 0x[01, 01, 03, 01, 05, 01, 09, 01, 0d, 0a, 01, 04, 01, 03, 0d, 02, 04, 05, 02, 06, 05, 02, 05, 00, 06, 01, 03, 09, 01, 0d, 06, 02, 05, 02, 06, 09, 02, 05, 00, 06, 01, 03, 09, 01, 0d, 0a, 02, 05, 02, 06, 0d, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (60): 0x[01, 01, 03, 01, 05, 01, 09, 01, 0d, 0a, 01, 05, 01, 03, 0d, 02, 04, 05, 02, 06, 05, 02, 05, 00, 06, 01, 03, 09, 01, 0d, 06, 02, 05, 02, 06, 09, 02, 05, 00, 06, 01, 03, 09, 01, 0d, 0a, 02, 05, 02, 06, 0d, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -7,7 +7,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(0), rhs = Counter(2)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(3)
 Number of file 0 mappings: 10
-- Code(Counter(0)) at (prev + 4, 1) to (start + 3, 13)
+- Code(Counter(0)) at (prev + 5, 1) to (start + 3, 13)
 - Code(Expression(0, Sub)) at (prev + 4, 5) to (start + 2, 6)
     = (c0 - c1)
 - Code(Counter(1)) at (prev + 2, 5) to (start + 0, 6)
diff --git a/tests/coverage/if_not.coverage b/tests/coverage/if_not.coverage
index c96627d88ae..678ccf9f2f8 100644
--- a/tests/coverage/if_not.coverage
+++ b/tests/coverage/if_not.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |#[rustfmt::skip]
diff --git a/tests/coverage/if_not.rs b/tests/coverage/if_not.rs
index d1c2b5fc982..69283ef2527 100644
--- a/tests/coverage/if_not.rs
+++ b/tests/coverage/if_not.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 #[rustfmt::skip]
diff --git a/tests/coverage/let_else_loop.cov-map b/tests/coverage/let_else_loop.cov-map
index 5a3ccff87c3..7789114c239 100644
--- a/tests/coverage/let_else_loop.cov-map
+++ b/tests/coverage/let_else_loop.cov-map
@@ -1,32 +1,32 @@
 Function name: let_else_loop::_if (unused)
-Raw bytes (19): 0x[01, 01, 00, 03, 00, 15, 01, 01, 0c, 00, 01, 0f, 00, 16, 00, 00, 20, 00, 27]
+Raw bytes (19): 0x[01, 01, 00, 03, 00, 16, 01, 01, 0c, 00, 01, 0f, 00, 16, 00, 00, 20, 00, 27]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 3
-- Code(Zero) at (prev + 21, 1) to (start + 1, 12)
+- Code(Zero) at (prev + 22, 1) to (start + 1, 12)
 - Code(Zero) at (prev + 1, 15) to (start + 0, 22)
 - Code(Zero) at (prev + 0, 32) to (start + 0, 39)
 Highest counter ID seen: (none)
 
 Function name: let_else_loop::_loop_either_way (unused)
-Raw bytes (19): 0x[01, 01, 00, 03, 00, 0e, 01, 01, 14, 00, 01, 1c, 00, 23, 00, 01, 05, 00, 0c]
+Raw bytes (19): 0x[01, 01, 00, 03, 00, 0f, 01, 01, 14, 00, 01, 1c, 00, 23, 00, 01, 05, 00, 0c]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 3
-- Code(Zero) at (prev + 14, 1) to (start + 1, 20)
+- Code(Zero) at (prev + 15, 1) to (start + 1, 20)
 - Code(Zero) at (prev + 1, 28) to (start + 0, 35)
 - Code(Zero) at (prev + 1, 5) to (start + 0, 12)
 Highest counter ID seen: (none)
 
 Function name: let_else_loop::loopy
-Raw bytes (19): 0x[01, 01, 00, 03, 01, 08, 01, 01, 14, 09, 01, 1c, 00, 23, 05, 01, 01, 00, 02]
+Raw bytes (19): 0x[01, 01, 00, 03, 01, 09, 01, 01, 14, 09, 01, 1c, 00, 23, 05, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 3
-- Code(Counter(0)) at (prev + 8, 1) to (start + 1, 20)
+- Code(Counter(0)) at (prev + 9, 1) to (start + 1, 20)
 - Code(Counter(2)) at (prev + 1, 28) to (start + 0, 35)
 - Code(Counter(1)) at (prev + 1, 1) to (start + 0, 2)
 Highest counter ID seen: c2
diff --git a/tests/coverage/let_else_loop.coverage b/tests/coverage/let_else_loop.coverage
index b42e1e144ae..bd13f6e5650 100644
--- a/tests/coverage/let_else_loop.coverage
+++ b/tests/coverage/let_else_loop.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |// Regression test for <https://github.com/rust-lang/rust/issues/122738>.
diff --git a/tests/coverage/let_else_loop.rs b/tests/coverage/let_else_loop.rs
index 83571287859..8217c0d072a 100644
--- a/tests/coverage/let_else_loop.rs
+++ b/tests/coverage/let_else_loop.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 // Regression test for <https://github.com/rust-lang/rust/issues/122738>.
diff --git a/tests/coverage/macro_in_closure.cov-map b/tests/coverage/macro_in_closure.cov-map
index 38ce58d9ea5..9614154a366 100644
--- a/tests/coverage/macro_in_closure.cov-map
+++ b/tests/coverage/macro_in_closure.cov-map
@@ -1,18 +1,18 @@
 Function name: macro_in_closure::NO_BLOCK::{closure#0}
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 06, 1c, 00, 2d]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 1c, 00, 2d]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 6, 28) to (start + 0, 45)
+- Code(Counter(0)) at (prev + 7, 28) to (start + 0, 45)
 Highest counter ID seen: c0
 
 Function name: macro_in_closure::WITH_BLOCK::{closure#0}
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 08, 1e, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 09, 1e, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 8, 30) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 9, 30) to (start + 2, 2)
 Highest counter ID seen: c0
 
diff --git a/tests/coverage/macro_in_closure.coverage b/tests/coverage/macro_in_closure.coverage
index c829c512cb8..a23ad2c37ec 100644
--- a/tests/coverage/macro_in_closure.coverage
+++ b/tests/coverage/macro_in_closure.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |// If a closure body consists entirely of a single bang-macro invocation, the
diff --git a/tests/coverage/macro_in_closure.rs b/tests/coverage/macro_in_closure.rs
index 251fbf04ee3..3d62b54073f 100644
--- a/tests/coverage/macro_in_closure.rs
+++ b/tests/coverage/macro_in_closure.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 // If a closure body consists entirely of a single bang-macro invocation, the
diff --git a/tests/coverage/mcdc/condition-limit.cov-map b/tests/coverage/mcdc/condition-limit.cov-map
index befe8866a59..8ff5d6360f6 100644
--- a/tests/coverage/mcdc/condition-limit.cov-map
+++ b/tests/coverage/mcdc/condition-limit.cov-map
@@ -1,5 +1,5 @@
 Function name: condition_limit::accept_7_conditions
-Raw bytes (147): 0x[01, 01, 08, 01, 05, 05, 09, 09, 0d, 0d, 11, 11, 15, 15, 19, 19, 1d, 01, 1d, 12, 01, 06, 01, 02, 09, 28, 08, 07, 02, 08, 00, 27, 30, 05, 02, 01, 07, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 07, 06, 00, 00, 0d, 00, 0e, 09, 00, 12, 00, 13, 30, 0d, 0a, 06, 05, 00, 00, 12, 00, 13, 0d, 00, 17, 00, 18, 30, 11, 0e, 05, 04, 00, 00, 17, 00, 18, 11, 00, 1c, 00, 1d, 30, 15, 12, 04, 03, 00, 00, 1c, 00, 1d, 15, 00, 21, 00, 22, 30, 19, 16, 03, 02, 00, 00, 21, 00, 22, 19, 00, 26, 00, 27, 30, 1d, 1a, 02, 00, 00, 00, 26, 00, 27, 1d, 00, 28, 02, 06, 1e, 02, 05, 00, 06, 01, 01, 01, 00, 02]
+Raw bytes (147): 0x[01, 01, 08, 01, 05, 05, 09, 09, 0d, 0d, 11, 11, 15, 15, 19, 19, 1d, 01, 1d, 12, 01, 07, 01, 02, 09, 28, 08, 07, 02, 08, 00, 27, 30, 05, 02, 01, 07, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 07, 06, 00, 00, 0d, 00, 0e, 09, 00, 12, 00, 13, 30, 0d, 0a, 06, 05, 00, 00, 12, 00, 13, 0d, 00, 17, 00, 18, 30, 11, 0e, 05, 04, 00, 00, 17, 00, 18, 11, 00, 1c, 00, 1d, 30, 15, 12, 04, 03, 00, 00, 1c, 00, 1d, 15, 00, 21, 00, 22, 30, 19, 16, 03, 02, 00, 00, 21, 00, 22, 19, 00, 26, 00, 27, 30, 1d, 1a, 02, 00, 00, 00, 26, 00, 27, 1d, 00, 28, 02, 06, 1e, 02, 05, 00, 06, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 8
@@ -12,7 +12,7 @@ Number of expressions: 8
 - expression 6 operands: lhs = Counter(6), rhs = Counter(7)
 - expression 7 operands: lhs = Counter(0), rhs = Counter(7)
 Number of file 0 mappings: 18
-- Code(Counter(0)) at (prev + 6, 1) to (start + 2, 9)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 2, 9)
 - MCDCDecision { bitmap_idx: 8, conditions_num: 7 } at (prev + 2, 8) to (start + 0, 39)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 7, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
diff --git a/tests/coverage/mcdc/condition-limit.coverage b/tests/coverage/mcdc/condition-limit.coverage
index 1a990f27ac2..d11b8a17710 100644
--- a/tests/coverage/mcdc/condition-limit.coverage
+++ b/tests/coverage/mcdc/condition-limit.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ min-llvm-version: 19
    LL|       |//@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/condition-limit.rs b/tests/coverage/mcdc/condition-limit.rs
index 520a9f44e08..2e8f1619379 100644
--- a/tests/coverage/mcdc/condition-limit.rs
+++ b/tests/coverage/mcdc/condition-limit.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ min-llvm-version: 19
 //@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/if.cov-map b/tests/coverage/mcdc/if.cov-map
index 1b038f48429..771351f649f 100644
--- a/tests/coverage/mcdc/if.cov-map
+++ b/tests/coverage/mcdc/if.cov-map
@@ -1,5 +1,5 @@
 Function name: if::mcdc_check_a
-Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 0e, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 0f, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -7,7 +7,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(2)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 14, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -23,7 +23,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c2
 
 Function name: if::mcdc_check_b
-Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 16, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 17, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -31,7 +31,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(2)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 22, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 23, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -47,7 +47,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c2
 
 Function name: if::mcdc_check_both
-Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 1e, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 1f, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -55,7 +55,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(2)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 30, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 31, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -71,7 +71,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c2
 
 Function name: if::mcdc_check_neither
-Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 06, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (62): 0x[01, 01, 03, 01, 05, 05, 09, 01, 09, 08, 01, 07, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 06, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 0a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -79,7 +79,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(2)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -95,7 +95,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c2
 
 Function name: if::mcdc_check_not_tree_decision
-Raw bytes (85): 0x[01, 01, 07, 01, 05, 01, 17, 05, 09, 05, 09, 17, 0d, 05, 09, 01, 0d, 0a, 01, 30, 01, 03, 0a, 28, 05, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 03, 00, 09, 00, 0a, 02, 00, 0e, 00, 0f, 30, 09, 06, 03, 02, 00, 00, 0e, 00, 0f, 17, 00, 14, 00, 15, 30, 0d, 12, 02, 00, 00, 00, 14, 00, 15, 0d, 00, 16, 02, 06, 1a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (85): 0x[01, 01, 07, 01, 05, 01, 17, 05, 09, 05, 09, 17, 0d, 05, 09, 01, 0d, 0a, 01, 31, 01, 03, 0a, 28, 05, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 03, 00, 09, 00, 0a, 02, 00, 0e, 00, 0f, 30, 09, 06, 03, 02, 00, 00, 0e, 00, 0f, 17, 00, 14, 00, 15, 30, 0d, 12, 02, 00, 00, 00, 14, 00, 15, 0d, 00, 16, 02, 06, 1a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 7
@@ -107,7 +107,7 @@ Number of expressions: 7
 - expression 5 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 6 operands: lhs = Counter(0), rhs = Counter(3)
 Number of file 0 mappings: 10
-- Code(Counter(0)) at (prev + 48, 1) to (start + 3, 10)
+- Code(Counter(0)) at (prev + 49, 1) to (start + 3, 10)
 - MCDCDecision { bitmap_idx: 5, conditions_num: 3 } at (prev + 3, 8) to (start + 0, 21)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 3 } at (prev + 0, 9) to (start + 0, 10)
     true  = c1
@@ -129,7 +129,7 @@ Number of file 0 mappings: 10
 Highest counter ID seen: c3
 
 Function name: if::mcdc_check_tree_decision
-Raw bytes (87): 0x[01, 01, 08, 01, 05, 05, 09, 05, 09, 05, 1f, 09, 0d, 09, 0d, 01, 1f, 09, 0d, 0a, 01, 26, 01, 03, 09, 28, 04, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0e, 00, 0f, 30, 09, 0a, 02, 00, 03, 00, 0e, 00, 0f, 0a, 00, 13, 00, 14, 30, 0d, 0e, 03, 00, 00, 00, 13, 00, 14, 1f, 00, 16, 02, 06, 1a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (87): 0x[01, 01, 08, 01, 05, 05, 09, 05, 09, 05, 1f, 09, 0d, 09, 0d, 01, 1f, 09, 0d, 0a, 01, 27, 01, 03, 09, 28, 04, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0e, 00, 0f, 30, 09, 0a, 02, 00, 03, 00, 0e, 00, 0f, 0a, 00, 13, 00, 14, 30, 0d, 0e, 03, 00, 00, 00, 13, 00, 14, 1f, 00, 16, 02, 06, 1a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 8
@@ -142,7 +142,7 @@ Number of expressions: 8
 - expression 6 operands: lhs = Counter(0), rhs = Expression(7, Add)
 - expression 7 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 10
-- Code(Counter(0)) at (prev + 38, 1) to (start + 3, 9)
+- Code(Counter(0)) at (prev + 39, 1) to (start + 3, 9)
 - MCDCDecision { bitmap_idx: 4, conditions_num: 3 } at (prev + 3, 8) to (start + 0, 21)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -164,7 +164,7 @@ Number of file 0 mappings: 10
 Highest counter ID seen: c3
 
 Function name: if::mcdc_nested_if
-Raw bytes (120): 0x[01, 01, 0b, 01, 05, 01, 2b, 05, 09, 05, 09, 2b, 0d, 05, 09, 0d, 11, 2b, 11, 05, 09, 01, 2b, 05, 09, 0e, 01, 3a, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 00, 02, 00, 08, 00, 09, 02, 00, 0d, 00, 0e, 30, 09, 26, 02, 00, 00, 00, 0d, 00, 0e, 2b, 01, 09, 01, 0d, 28, 06, 02, 01, 0c, 00, 12, 30, 0d, 12, 01, 02, 00, 00, 0c, 00, 0d, 0d, 00, 11, 00, 12, 30, 11, 1a, 02, 00, 00, 00, 11, 00, 12, 11, 00, 13, 02, 0a, 1e, 02, 09, 00, 0a, 26, 01, 0c, 02, 06, 01, 03, 01, 00, 02]
+Raw bytes (120): 0x[01, 01, 0b, 01, 05, 01, 2b, 05, 09, 05, 09, 2b, 0d, 05, 09, 0d, 11, 2b, 11, 05, 09, 01, 2b, 05, 09, 0e, 01, 3b, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 00, 02, 00, 08, 00, 09, 02, 00, 0d, 00, 0e, 30, 09, 26, 02, 00, 00, 00, 0d, 00, 0e, 2b, 01, 09, 01, 0d, 28, 06, 02, 01, 0c, 00, 12, 30, 0d, 12, 01, 02, 00, 00, 0c, 00, 0d, 0d, 00, 11, 00, 12, 30, 11, 1a, 02, 00, 00, 00, 11, 00, 12, 11, 00, 13, 02, 0a, 1e, 02, 09, 00, 0a, 26, 01, 0c, 02, 06, 01, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 11
@@ -180,7 +180,7 @@ Number of expressions: 11
 - expression 9 operands: lhs = Counter(0), rhs = Expression(10, Add)
 - expression 10 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 14
-- Code(Counter(0)) at (prev + 58, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 59, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
diff --git a/tests/coverage/mcdc/if.coverage b/tests/coverage/mcdc/if.coverage
index cee74de3c5f..b000c7d5d2f 100644
--- a/tests/coverage/mcdc/if.coverage
+++ b/tests/coverage/mcdc/if.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ min-llvm-version: 19
    LL|       |//@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/if.rs b/tests/coverage/mcdc/if.rs
index 895b736d066..a2abb2edf11 100644
--- a/tests/coverage/mcdc/if.rs
+++ b/tests/coverage/mcdc/if.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ min-llvm-version: 19
 //@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/inlined_expressions.cov-map b/tests/coverage/mcdc/inlined_expressions.cov-map
index 7d78e572a3b..6a112b66e88 100644
--- a/tests/coverage/mcdc/inlined_expressions.cov-map
+++ b/tests/coverage/mcdc/inlined_expressions.cov-map
@@ -1,12 +1,12 @@
 Function name: inlined_expressions::inlined_instance
-Raw bytes (50): 0x[01, 01, 02, 01, 05, 05, 09, 06, 01, 07, 01, 01, 06, 28, 03, 02, 01, 05, 00, 0b, 30, 05, 02, 01, 02, 00, 00, 05, 00, 06, 05, 00, 0a, 00, 0b, 30, 09, 06, 02, 00, 00, 00, 0a, 00, 0b, 01, 01, 01, 00, 02]
+Raw bytes (50): 0x[01, 01, 02, 01, 05, 05, 09, 06, 01, 08, 01, 01, 06, 28, 03, 02, 01, 05, 00, 0b, 30, 05, 02, 01, 02, 00, 00, 05, 00, 06, 05, 00, 0a, 00, 0b, 30, 09, 06, 02, 00, 00, 00, 0a, 00, 0b, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 6)
+- Code(Counter(0)) at (prev + 8, 1) to (start + 1, 6)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 5) to (start + 0, 11)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 5) to (start + 0, 6)
     true  = c1
diff --git a/tests/coverage/mcdc/inlined_expressions.coverage b/tests/coverage/mcdc/inlined_expressions.coverage
index 12bf55d6460..57c655a2054 100644
--- a/tests/coverage/mcdc/inlined_expressions.coverage
+++ b/tests/coverage/mcdc/inlined_expressions.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ min-llvm-version: 19
    LL|       |//@ compile-flags: -Zcoverage-options=mcdc -Copt-level=z -Cllvm-args=--inline-threshold=0
diff --git a/tests/coverage/mcdc/inlined_expressions.rs b/tests/coverage/mcdc/inlined_expressions.rs
index dbab0b8a662..651e2fe8438 100644
--- a/tests/coverage/mcdc/inlined_expressions.rs
+++ b/tests/coverage/mcdc/inlined_expressions.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ min-llvm-version: 19
 //@ compile-flags: -Zcoverage-options=mcdc -Copt-level=z -Cllvm-args=--inline-threshold=0
diff --git a/tests/coverage/mcdc/nested_if.cov-map b/tests/coverage/mcdc/nested_if.cov-map
index 59564404481..72c7d68840d 100644
--- a/tests/coverage/mcdc/nested_if.cov-map
+++ b/tests/coverage/mcdc/nested_if.cov-map
@@ -1,5 +1,5 @@
 Function name: nested_if::doubly_nested_if_in_condition
-Raw bytes (168): 0x[01, 01, 0e, 01, 05, 05, 09, 05, 09, 05, 13, 09, 19, 19, 1d, 05, 1f, 09, 1d, 09, 0d, 2b, 05, 01, 15, 33, 05, 37, 15, 01, 11, 14, 01, 0e, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 11, 15, 02, 00, 00, 00, 0d, 00, 4e, 05, 00, 10, 00, 11, 28, 06, 02, 00, 10, 00, 36, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 30, 0d, 21, 02, 00, 00, 00, 15, 00, 36, 0a, 00, 18, 00, 19, 28, 03, 02, 00, 18, 00, 1e, 30, 19, 0e, 01, 02, 00, 00, 18, 00, 19, 19, 00, 1d, 00, 1e, 30, 1d, 16, 02, 00, 00, 00, 1d, 00, 1e, 1d, 00, 21, 00, 25, 1a, 00, 2f, 00, 34, 23, 00, 39, 00, 3e, 21, 00, 48, 00, 4c, 11, 00, 4f, 02, 06, 26, 02, 0c, 02, 06, 2e, 03, 01, 00, 02]
+Raw bytes (168): 0x[01, 01, 0e, 01, 05, 05, 09, 05, 09, 05, 13, 09, 19, 19, 1d, 05, 1f, 09, 1d, 09, 0d, 2b, 05, 01, 15, 33, 05, 37, 15, 01, 11, 14, 01, 0f, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 11, 15, 02, 00, 00, 00, 0d, 00, 4e, 05, 00, 10, 00, 11, 28, 06, 02, 00, 10, 00, 36, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 30, 0d, 21, 02, 00, 00, 00, 15, 00, 36, 0a, 00, 18, 00, 19, 28, 03, 02, 00, 18, 00, 1e, 30, 19, 0e, 01, 02, 00, 00, 18, 00, 19, 19, 00, 1d, 00, 1e, 30, 1d, 16, 02, 00, 00, 00, 1d, 00, 1e, 1d, 00, 21, 00, 25, 1a, 00, 2f, 00, 34, 23, 00, 39, 00, 3e, 21, 00, 48, 00, 4c, 11, 00, 4f, 02, 06, 26, 02, 0c, 02, 06, 2e, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 14
@@ -18,7 +18,7 @@ Number of expressions: 14
 - expression 12 operands: lhs = Expression(13, Add), rhs = Counter(5)
 - expression 13 operands: lhs = Counter(0), rhs = Counter(4)
 Number of file 0 mappings: 20
-- Code(Counter(0)) at (prev + 14, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 9, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 78)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -58,7 +58,7 @@ Number of file 0 mappings: 20
 Highest counter ID seen: c8
 
 Function name: nested_if::nested_if_in_condition
-Raw bytes (124): 0x[01, 01, 0d, 01, 05, 05, 09, 05, 09, 05, 1f, 09, 0d, 09, 0d, 05, 1f, 09, 0d, 27, 05, 01, 15, 2f, 05, 33, 15, 01, 11, 0e, 01, 06, 01, 01, 09, 28, 06, 02, 01, 08, 00, 2e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 11, 15, 02, 00, 00, 00, 0d, 00, 2e, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 0a, 00, 15, 00, 16, 30, 0d, 1a, 02, 00, 00, 00, 15, 00, 16, 1f, 00, 19, 00, 1d, 1a, 00, 27, 00, 2c, 11, 00, 2f, 02, 06, 22, 02, 0c, 02, 06, 2a, 03, 01, 00, 02]
+Raw bytes (124): 0x[01, 01, 0d, 01, 05, 05, 09, 05, 09, 05, 1f, 09, 0d, 09, 0d, 05, 1f, 09, 0d, 27, 05, 01, 15, 2f, 05, 33, 15, 01, 11, 0e, 01, 07, 01, 01, 09, 28, 06, 02, 01, 08, 00, 2e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 11, 15, 02, 00, 00, 00, 0d, 00, 2e, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 0a, 00, 15, 00, 16, 30, 0d, 1a, 02, 00, 00, 00, 15, 00, 16, 1f, 00, 19, 00, 1d, 1a, 00, 27, 00, 2c, 11, 00, 2f, 02, 06, 22, 02, 0c, 02, 06, 2a, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 13
@@ -76,7 +76,7 @@ Number of expressions: 13
 - expression 11 operands: lhs = Expression(12, Add), rhs = Counter(5)
 - expression 12 operands: lhs = Counter(0), rhs = Counter(4)
 Number of file 0 mappings: 14
-- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 6, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 46)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -106,7 +106,7 @@ Number of file 0 mappings: 14
 Highest counter ID seen: c5
 
 Function name: nested_if::nested_in_then_block_in_condition
-Raw bytes (176): 0x[01, 01, 12, 01, 05, 05, 09, 05, 09, 05, 33, 09, 0d, 09, 0d, 33, 11, 09, 0d, 11, 15, 33, 15, 09, 0d, 05, 33, 09, 0d, 3b, 05, 01, 1d, 43, 05, 47, 1d, 01, 19, 14, 01, 21, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4b, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 19, 1d, 02, 00, 00, 00, 0d, 00, 4b, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 0a, 00, 15, 00, 16, 30, 0d, 2e, 02, 00, 00, 00, 15, 00, 16, 33, 00, 1c, 00, 1d, 28, 06, 02, 00, 1c, 00, 22, 30, 11, 1a, 01, 02, 00, 00, 1c, 00, 1d, 11, 00, 21, 00, 22, 30, 15, 22, 02, 00, 00, 00, 21, 00, 22, 15, 00, 25, 00, 29, 26, 00, 33, 00, 38, 2e, 00, 44, 00, 49, 19, 00, 4c, 02, 06, 36, 02, 0c, 02, 06, 3e, 03, 01, 00, 02]
+Raw bytes (176): 0x[01, 01, 12, 01, 05, 05, 09, 05, 09, 05, 33, 09, 0d, 09, 0d, 33, 11, 09, 0d, 11, 15, 33, 15, 09, 0d, 05, 33, 09, 0d, 3b, 05, 01, 1d, 43, 05, 47, 1d, 01, 19, 14, 01, 22, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4b, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 19, 1d, 02, 00, 00, 00, 0d, 00, 4b, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 0a, 00, 15, 00, 16, 30, 0d, 2e, 02, 00, 00, 00, 15, 00, 16, 33, 00, 1c, 00, 1d, 28, 06, 02, 00, 1c, 00, 22, 30, 11, 1a, 01, 02, 00, 00, 1c, 00, 1d, 11, 00, 21, 00, 22, 30, 15, 22, 02, 00, 00, 00, 21, 00, 22, 15, 00, 25, 00, 29, 26, 00, 33, 00, 38, 2e, 00, 44, 00, 49, 19, 00, 4c, 02, 06, 36, 02, 0c, 02, 06, 3e, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 18
@@ -129,7 +129,7 @@ Number of expressions: 18
 - expression 16 operands: lhs = Expression(17, Add), rhs = Counter(7)
 - expression 17 operands: lhs = Counter(0), rhs = Counter(6)
 Number of file 0 mappings: 20
-- Code(Counter(0)) at (prev + 33, 1) to (start + 1, 9)
+- Code(Counter(0)) at (prev + 34, 1) to (start + 1, 9)
 - MCDCDecision { bitmap_idx: 9, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 75)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
@@ -170,7 +170,7 @@ Number of file 0 mappings: 20
 Highest counter ID seen: c7
 
 Function name: nested_if::nested_single_condition_decision
-Raw bytes (89): 0x[01, 01, 08, 01, 05, 05, 09, 05, 09, 13, 05, 01, 11, 1b, 05, 1f, 11, 01, 0d, 0b, 01, 16, 01, 04, 09, 28, 03, 02, 04, 08, 00, 29, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 11, 02, 00, 00, 00, 0d, 00, 29, 05, 00, 10, 00, 11, 20, 09, 0a, 00, 10, 00, 11, 09, 00, 14, 00, 19, 0a, 00, 23, 00, 27, 0d, 00, 2a, 02, 06, 0e, 02, 0c, 02, 06, 16, 03, 01, 00, 02]
+Raw bytes (89): 0x[01, 01, 08, 01, 05, 05, 09, 05, 09, 13, 05, 01, 11, 1b, 05, 1f, 11, 01, 0d, 0b, 01, 17, 01, 04, 09, 28, 03, 02, 04, 08, 00, 29, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 11, 02, 00, 00, 00, 0d, 00, 29, 05, 00, 10, 00, 11, 20, 09, 0a, 00, 10, 00, 11, 09, 00, 14, 00, 19, 0a, 00, 23, 00, 27, 0d, 00, 2a, 02, 06, 0e, 02, 0c, 02, 06, 16, 03, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 8
@@ -183,7 +183,7 @@ Number of expressions: 8
 - expression 6 operands: lhs = Expression(7, Add), rhs = Counter(4)
 - expression 7 operands: lhs = Counter(0), rhs = Counter(3)
 Number of file 0 mappings: 11
-- Code(Counter(0)) at (prev + 22, 1) to (start + 4, 9)
+- Code(Counter(0)) at (prev + 23, 1) to (start + 4, 9)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 4, 8) to (start + 0, 41)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
     true  = c1
diff --git a/tests/coverage/mcdc/nested_if.coverage b/tests/coverage/mcdc/nested_if.coverage
index 4c872708a6e..ca0cb54d581 100644
--- a/tests/coverage/mcdc/nested_if.coverage
+++ b/tests/coverage/mcdc/nested_if.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ min-llvm-version: 19
    LL|       |//@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/nested_if.rs b/tests/coverage/mcdc/nested_if.rs
index 3356a768a69..83f188ea47e 100644
--- a/tests/coverage/mcdc/nested_if.rs
+++ b/tests/coverage/mcdc/nested_if.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ min-llvm-version: 19
 //@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/non_control_flow.cov-map b/tests/coverage/mcdc/non_control_flow.cov-map
index ee128d997c0..c282d53c5ac 100644
--- a/tests/coverage/mcdc/non_control_flow.cov-map
+++ b/tests/coverage/mcdc/non_control_flow.cov-map
@@ -1,5 +1,5 @@
 Function name: non_control_flow::assign_3
-Raw bytes (79): 0x[01, 01, 04, 01, 05, 01, 0b, 05, 09, 09, 0d, 0a, 01, 15, 01, 00, 28, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 04, 03, 00, 0d, 00, 18, 30, 05, 02, 01, 00, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 30, 09, 06, 02, 03, 00, 00, 12, 00, 13, 09, 00, 17, 00, 18, 30, 0d, 0e, 03, 00, 00, 00, 17, 00, 18, 01, 01, 05, 01, 02]
+Raw bytes (79): 0x[01, 01, 04, 01, 05, 01, 0b, 05, 09, 09, 0d, 0a, 01, 16, 01, 00, 28, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 04, 03, 00, 0d, 00, 18, 30, 05, 02, 01, 00, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 30, 09, 06, 02, 03, 00, 00, 12, 00, 13, 09, 00, 17, 00, 18, 30, 0d, 0e, 03, 00, 00, 00, 17, 00, 18, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 4
@@ -8,7 +8,7 @@ Number of expressions: 4
 - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
 - expression 3 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 10
-- Code(Counter(0)) at (prev + 21, 1) to (start + 0, 40)
+- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 40)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - MCDCDecision { bitmap_idx: 4, conditions_num: 3 } at (prev + 0, 13) to (start + 0, 24)
@@ -28,7 +28,7 @@ Number of file 0 mappings: 10
 Highest counter ID seen: c3
 
 Function name: non_control_flow::assign_3_bis
-Raw bytes (81): 0x[01, 01, 05, 01, 05, 05, 09, 01, 09, 01, 13, 09, 0d, 0a, 01, 1a, 01, 00, 2c, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 05, 03, 00, 0d, 00, 18, 30, 05, 02, 01, 03, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 06, 03, 00, 02, 00, 12, 00, 13, 0a, 00, 17, 00, 18, 30, 0d, 0e, 02, 00, 00, 00, 17, 00, 18, 01, 01, 05, 01, 02]
+Raw bytes (81): 0x[01, 01, 05, 01, 05, 05, 09, 01, 09, 01, 13, 09, 0d, 0a, 01, 1b, 01, 00, 2c, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 05, 03, 00, 0d, 00, 18, 30, 05, 02, 01, 03, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 06, 03, 00, 02, 00, 12, 00, 13, 0a, 00, 17, 00, 18, 30, 0d, 0e, 02, 00, 00, 00, 17, 00, 18, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 5
@@ -38,7 +38,7 @@ Number of expressions: 5
 - expression 3 operands: lhs = Counter(0), rhs = Expression(4, Add)
 - expression 4 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 10
-- Code(Counter(0)) at (prev + 26, 1) to (start + 0, 44)
+- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 44)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - MCDCDecision { bitmap_idx: 5, conditions_num: 3 } at (prev + 0, 13) to (start + 0, 24)
@@ -58,14 +58,14 @@ Number of file 0 mappings: 10
 Highest counter ID seen: c3
 
 Function name: non_control_flow::assign_and
-Raw bytes (60): 0x[01, 01, 02, 01, 05, 05, 09, 08, 01, 0b, 01, 00, 21, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 03, 02, 00, 0d, 00, 13, 30, 05, 02, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 06, 02, 00, 00, 00, 12, 00, 13, 01, 01, 05, 01, 02]
+Raw bytes (60): 0x[01, 01, 02, 01, 05, 05, 09, 08, 01, 0c, 01, 00, 21, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 03, 02, 00, 0d, 00, 13, 30, 05, 02, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 06, 02, 00, 00, 00, 12, 00, 13, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 11, 1) to (start + 0, 33)
+- Code(Counter(0)) at (prev + 12, 1) to (start + 0, 33)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 0, 13) to (start + 0, 19)
@@ -80,7 +80,7 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c2
 
 Function name: non_control_flow::assign_or
-Raw bytes (62): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 08, 01, 10, 01, 00, 20, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 03, 02, 00, 0d, 00, 13, 30, 05, 02, 01, 00, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 30, 09, 06, 02, 00, 00, 00, 12, 00, 13, 01, 01, 05, 01, 02]
+Raw bytes (62): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 08, 01, 11, 01, 00, 20, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 03, 02, 00, 0d, 00, 13, 30, 05, 02, 01, 00, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 30, 09, 06, 02, 00, 00, 00, 12, 00, 13, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 3
@@ -88,7 +88,7 @@ Number of expressions: 3
 - expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
 - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 8
-- Code(Counter(0)) at (prev + 16, 1) to (start + 0, 32)
+- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 32)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 0, 13) to (start + 0, 19)
@@ -104,23 +104,23 @@ Number of file 0 mappings: 8
 Highest counter ID seen: c2
 
 Function name: non_control_flow::foo
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 24, 01, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 25, 01, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 36, 1) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 37, 1) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: non_control_flow::func_call
-Raw bytes (50): 0x[01, 01, 02, 01, 05, 05, 09, 06, 01, 28, 01, 01, 0a, 28, 03, 02, 01, 09, 00, 0f, 30, 05, 02, 01, 02, 00, 00, 09, 00, 0a, 05, 00, 0e, 00, 0f, 30, 09, 06, 02, 00, 00, 00, 0e, 00, 0f, 01, 01, 01, 00, 02]
+Raw bytes (50): 0x[01, 01, 02, 01, 05, 05, 09, 06, 01, 29, 01, 01, 0a, 28, 03, 02, 01, 09, 00, 0f, 30, 05, 02, 01, 02, 00, 00, 09, 00, 0a, 05, 00, 0e, 00, 0f, 30, 09, 06, 02, 00, 00, 00, 0e, 00, 0f, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
 Number of file 0 mappings: 6
-- Code(Counter(0)) at (prev + 40, 1) to (start + 1, 10)
+- Code(Counter(0)) at (prev + 41, 1) to (start + 1, 10)
 - MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 9) to (start + 0, 15)
 - MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 9) to (start + 0, 10)
     true  = c1
@@ -133,7 +133,7 @@ Number of file 0 mappings: 6
 Highest counter ID seen: c2
 
 Function name: non_control_flow::right_comb_tree
-Raw bytes (111): 0x[01, 01, 05, 01, 05, 05, 09, 09, 0d, 0d, 11, 11, 15, 0e, 01, 1f, 01, 00, 41, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 06, 05, 00, 0d, 00, 2a, 30, 05, 02, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 13, 00, 14, 30, 09, 06, 02, 03, 00, 00, 13, 00, 14, 09, 00, 19, 00, 1a, 30, 0d, 0a, 03, 04, 00, 00, 19, 00, 1a, 0d, 00, 1f, 00, 20, 30, 11, 0e, 04, 05, 00, 00, 1f, 00, 20, 11, 00, 24, 00, 27, 30, 15, 12, 05, 00, 00, 00, 24, 00, 27, 01, 01, 05, 01, 02]
+Raw bytes (111): 0x[01, 01, 05, 01, 05, 05, 09, 09, 0d, 0d, 11, 11, 15, 0e, 01, 20, 01, 00, 41, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 06, 05, 00, 0d, 00, 2a, 30, 05, 02, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 13, 00, 14, 30, 09, 06, 02, 03, 00, 00, 13, 00, 14, 09, 00, 19, 00, 1a, 30, 0d, 0a, 03, 04, 00, 00, 19, 00, 1a, 0d, 00, 1f, 00, 20, 30, 11, 0e, 04, 05, 00, 00, 1f, 00, 20, 11, 00, 24, 00, 27, 30, 15, 12, 05, 00, 00, 00, 24, 00, 27, 01, 01, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 5
@@ -143,7 +143,7 @@ Number of expressions: 5
 - expression 3 operands: lhs = Counter(3), rhs = Counter(4)
 - expression 4 operands: lhs = Counter(4), rhs = Counter(5)
 Number of file 0 mappings: 14
-- Code(Counter(0)) at (prev + 31, 1) to (start + 0, 65)
+- Code(Counter(0)) at (prev + 32, 1) to (start + 0, 65)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
 - MCDCDecision { bitmap_idx: 6, conditions_num: 5 } at (prev + 0, 13) to (start + 0, 42)
diff --git a/tests/coverage/mcdc/non_control_flow.coverage b/tests/coverage/mcdc/non_control_flow.coverage
index 204c46dc7b5..cead419fbdf 100644
--- a/tests/coverage/mcdc/non_control_flow.coverage
+++ b/tests/coverage/mcdc/non_control_flow.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |//@ min-llvm-version: 19
    LL|       |//@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/mcdc/non_control_flow.rs b/tests/coverage/mcdc/non_control_flow.rs
index a836d8b55c0..6cfce6fae93 100644
--- a/tests/coverage/mcdc/non_control_flow.rs
+++ b/tests/coverage/mcdc/non_control_flow.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ min-llvm-version: 19
 //@ compile-flags: -Zcoverage-options=mcdc
diff --git a/tests/coverage/no_cov_crate.cov-map b/tests/coverage/no_cov_crate.cov-map
index 0eb86ef9366..04171fdb79b 100644
--- a/tests/coverage/no_cov_crate.cov-map
+++ b/tests/coverage/no_cov_crate.cov-map
@@ -1,67 +1,67 @@
 Function name: no_cov_crate::add_coverage_1
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 15, 01, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 16, 01, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 21, 1) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 22, 1) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: no_cov_crate::add_coverage_2
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 19, 01, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1a, 01, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 25, 1) to (start + 2, 2)
+- Code(Counter(0)) at (prev + 26, 1) to (start + 2, 2)
 Highest counter ID seen: c0
 
 Function name: no_cov_crate::add_coverage_not_called (unused)
-Raw bytes (9): 0x[01, 01, 00, 01, 00, 1e, 01, 02, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 1f, 01, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Zero) at (prev + 30, 1) to (start + 2, 2)
+- Code(Zero) at (prev + 31, 1) to (start + 2, 2)
 Highest counter ID seen: (none)
 
 Function name: no_cov_crate::main
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 4e, 01, 0b, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 4f, 01, 0b, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 78, 1) to (start + 11, 2)
+- Code(Counter(0)) at (prev + 79, 1) to (start + 11, 2)
 Highest counter ID seen: c0
 
 Function name: no_cov_crate::nested_fns::outer
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 32, 05, 02, 23, 01, 0c, 05, 00, 06]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 33, 05, 02, 23, 01, 0c, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 50, 5) to (start + 2, 35)
+- Code(Counter(0)) at (prev + 51, 5) to (start + 2, 35)
 - Code(Counter(0)) at (prev + 12, 5) to (start + 0, 6)
 Highest counter ID seen: c0
 
 Function name: no_cov_crate::nested_fns::outer_both_covered
-Raw bytes (14): 0x[01, 01, 00, 02, 01, 40, 05, 02, 17, 01, 0b, 05, 00, 06]
+Raw bytes (14): 0x[01, 01, 00, 02, 01, 41, 05, 02, 17, 01, 0b, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 2
-- Code(Counter(0)) at (prev + 64, 5) to (start + 2, 23)
+- Code(Counter(0)) at (prev + 65, 5) to (start + 2, 23)
 - Code(Counter(0)) at (prev + 11, 5) to (start + 0, 6)
 Highest counter ID seen: c0
 
 Function name: no_cov_crate::nested_fns::outer_both_covered::inner
-Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 44, 09, 01, 17, 05, 01, 18, 02, 0e, 02, 02, 14, 02, 0e, 01, 03, 09, 00, 0a]
+Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 45, 09, 01, 17, 05, 01, 18, 02, 0e, 02, 02, 14, 02, 0e, 01, 03, 09, 00, 0a]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 1
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 68, 9) to (start + 1, 23)
+- Code(Counter(0)) at (prev + 69, 9) to (start + 1, 23)
 - Code(Counter(1)) at (prev + 1, 24) to (start + 2, 14)
 - Code(Expression(0, Sub)) at (prev + 2, 20) to (start + 2, 14)
     = (c0 - c1)
diff --git a/tests/coverage/no_cov_crate.coverage b/tests/coverage/no_cov_crate.coverage
index a75057287bc..2a8961e6c93 100644
--- a/tests/coverage/no_cov_crate.coverage
+++ b/tests/coverage/no_cov_crate.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |// Enables `coverage(off)` on the entire crate
    LL|       |//@ reference: attributes.coverage.intro
    LL|       |//@ reference: attributes.coverage.nesting
diff --git a/tests/coverage/no_cov_crate.rs b/tests/coverage/no_cov_crate.rs
index df8594e9790..72fd6317a17 100644
--- a/tests/coverage/no_cov_crate.rs
+++ b/tests/coverage/no_cov_crate.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 // Enables `coverage(off)` on the entire crate
 //@ reference: attributes.coverage.intro
 //@ reference: attributes.coverage.nesting
diff --git a/tests/coverage/no_spans.cov-map b/tests/coverage/no_spans.cov-map
index c6178fc41cf..7f43b68fa90 100644
--- a/tests/coverage/no_spans.cov-map
+++ b/tests/coverage/no_spans.cov-map
@@ -1,18 +1,18 @@
 Function name: no_spans::affected_function
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 19, 1c, 00, 1d]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1a, 1c, 00, 1d]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 25, 28) to (start + 0, 29)
+- Code(Counter(0)) at (prev + 26, 28) to (start + 0, 29)
 Highest counter ID seen: c0
 
 Function name: no_spans::affected_function::{closure#0}
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 1a, 0c, 00, 0e]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1b, 0c, 00, 0e]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 26, 12) to (start + 0, 14)
+- Code(Counter(0)) at (prev + 27, 12) to (start + 0, 14)
 Highest counter ID seen: c0
 
diff --git a/tests/coverage/no_spans.coverage b/tests/coverage/no_spans.coverage
index c722210e35f..19e8c2fe5b6 100644
--- a/tests/coverage/no_spans.coverage
+++ b/tests/coverage/no_spans.coverage
@@ -1,3 +1,4 @@
+   LL|       |#![feature(coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |// If the span extractor can't find any relevant spans for a function, the
diff --git a/tests/coverage/no_spans.rs b/tests/coverage/no_spans.rs
index db28bfd0590..e5312406f8a 100644
--- a/tests/coverage/no_spans.rs
+++ b/tests/coverage/no_spans.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 
 // If the span extractor can't find any relevant spans for a function, the
diff --git a/tests/coverage/unreachable.coverage b/tests/coverage/unreachable.coverage
index 6f9f45dce1e..aa37ccc7d33 100644
--- a/tests/coverage/unreachable.coverage
+++ b/tests/coverage/unreachable.coverage
@@ -1,4 +1,4 @@
-   LL|       |#![feature(core_intrinsics)]
+   LL|       |#![feature(core_intrinsics, coverage_attribute)]
    LL|       |//@ edition: 2021
    LL|       |
    LL|       |// <https://github.com/rust-lang/rust/issues/116171>
diff --git a/tests/coverage/unreachable.rs b/tests/coverage/unreachable.rs
index d6082f85a36..443e1c8ccab 100644
--- a/tests/coverage/unreachable.rs
+++ b/tests/coverage/unreachable.rs
@@ -1,4 +1,4 @@
-#![feature(core_intrinsics)]
+#![feature(core_intrinsics, coverage_attribute)]
 //@ edition: 2021
 
 // <https://github.com/rust-lang/rust/issues/116171>
diff --git a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
index 69ef6016d25..138586300ce 100644
--- a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
+++ b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
@@ -26,16 +26,16 @@
           debug a => _9;
       }
   
-+     coverage body span: $DIR/branch_match_arms.rs:13:11: 20:2 (#0)
++     coverage body span: $DIR/branch_match_arms.rs:14:11: 21:2 (#0)
 +     coverage ExpressionId(0) => Expression { lhs: Counter(1), op: Add, rhs: Counter(2) };
 +     coverage ExpressionId(1) => Expression { lhs: Expression(0), op: Add, rhs: Counter(3) };
 +     coverage ExpressionId(2) => Expression { lhs: Counter(0), op: Subtract, rhs: Expression(1) };
-+     coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:13:1: 14:21 (#0);
-+     coverage Code(Counter(1)) => $DIR/branch_match_arms.rs:15:17: 15:33 (#0);
-+     coverage Code(Counter(2)) => $DIR/branch_match_arms.rs:16:17: 16:33 (#0);
-+     coverage Code(Counter(3)) => $DIR/branch_match_arms.rs:17:17: 17:33 (#0);
-+     coverage Code(Expression(2)) => $DIR/branch_match_arms.rs:18:17: 18:33 (#0);
-+     coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:20:2: 20:2 (#0);
++     coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:14:1: 15:21 (#0);
++     coverage Code(Counter(1)) => $DIR/branch_match_arms.rs:16:17: 16:33 (#0);
++     coverage Code(Counter(2)) => $DIR/branch_match_arms.rs:17:17: 17:33 (#0);
++     coverage Code(Counter(3)) => $DIR/branch_match_arms.rs:18:17: 18:33 (#0);
++     coverage Code(Expression(2)) => $DIR/branch_match_arms.rs:19:17: 19:33 (#0);
++     coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:21:2: 21:2 (#0);
 + 
       bb0: {
 +         Coverage::CounterIncrement(0);
diff --git a/tests/mir-opt/coverage/branch_match_arms.rs b/tests/mir-opt/coverage/branch_match_arms.rs
index 84ffddcb289..18764b38d6e 100644
--- a/tests/mir-opt/coverage/branch_match_arms.rs
+++ b/tests/mir-opt/coverage/branch_match_arms.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ test-mir-pass: InstrumentCoverage
 //@ compile-flags: -Cinstrument-coverage -Zno-profiler-runtime -Zcoverage-options=branch
 // skip-filecheck
diff --git a/tests/ui/coverage-attr/bad-attr-ice.feat.stderr b/tests/ui/coverage-attr/bad-attr-ice.feat.stderr
new file mode 100644
index 00000000000..50e1c39d4f8
--- /dev/null
+++ b/tests/ui/coverage-attr/bad-attr-ice.feat.stderr
@@ -0,0 +1,15 @@
+error: malformed `coverage` attribute input
+  --> $DIR/bad-attr-ice.rs:11:1
+   |
+LL | #[coverage]
+   | ^^^^^^^^^^^
+   |
+help: the following are the possible correct uses
+   |
+LL | #[coverage(off)]
+   |
+LL | #[coverage(on)]
+   |
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr b/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr
new file mode 100644
index 00000000000..e8bdd99c9b9
--- /dev/null
+++ b/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr
@@ -0,0 +1,26 @@
+error: malformed `coverage` attribute input
+  --> $DIR/bad-attr-ice.rs:11:1
+   |
+LL | #[coverage]
+   | ^^^^^^^^^^^
+   |
+help: the following are the possible correct uses
+   |
+LL | #[coverage(off)]
+   |
+LL | #[coverage(on)]
+   |
+
+error[E0658]: the `#[coverage]` attribute is an experimental feature
+  --> $DIR/bad-attr-ice.rs:11:1
+   |
+LL | #[coverage]
+   | ^^^^^^^^^^^
+   |
+   = note: see issue #84605 <https://github.com/rust-lang/rust/issues/84605> for more information
+   = help: add `#![feature(coverage_attribute)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/coverage-attr/bad-attr-ice.rs b/tests/ui/coverage-attr/bad-attr-ice.rs
index 4b58989e3a2..8d57bbbf49a 100644
--- a/tests/ui/coverage-attr/bad-attr-ice.rs
+++ b/tests/ui/coverage-attr/bad-attr-ice.rs
@@ -1,3 +1,5 @@
+#![cfg_attr(feat, feature(coverage_attribute))]
+//@ revisions: feat nofeat
 //@ compile-flags: -Cinstrument-coverage
 //@ needs-profiler-runtime
 //@ reference: attributes.coverage.syntax
@@ -8,4 +10,8 @@
 
 #[coverage]
 //~^ ERROR malformed `coverage` attribute input
+//[nofeat]~| the `#[coverage]` attribute is an experimental feature
 fn main() {}
+
+// FIXME(#130766): When the `#[coverage(..)]` attribute is stabilized,
+// get rid of the revisions and just make this a normal test.
diff --git a/tests/ui/coverage-attr/bad-attr-ice.stderr b/tests/ui/coverage-attr/bad-attr-ice.stderr
deleted file mode 100644
index dc88bb8d1a4..00000000000
--- a/tests/ui/coverage-attr/bad-attr-ice.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: malformed `coverage` attribute input
-  --> $DIR/bad-attr-ice.rs:9:1
-   |
-LL | #[coverage]
-   | ^^^^^^^^^^^
-   |
-help: the following are the possible correct uses
-   |
-LL | #[coverage(off)]
-   |
-LL | #[coverage(on)]
-   |
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/coverage-attr/bad-syntax.rs b/tests/ui/coverage-attr/bad-syntax.rs
index ad6c5dc03f1..062e82ee4b6 100644
--- a/tests/ui/coverage-attr/bad-syntax.rs
+++ b/tests/ui/coverage-attr/bad-syntax.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.syntax
 //@ reference: attributes.coverage.duplicates
diff --git a/tests/ui/coverage-attr/bad-syntax.stderr b/tests/ui/coverage-attr/bad-syntax.stderr
index 072a8c4ca94..5592e89070d 100644
--- a/tests/ui/coverage-attr/bad-syntax.stderr
+++ b/tests/ui/coverage-attr/bad-syntax.stderr
@@ -1,5 +1,5 @@
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:16:1
+  --> $DIR/bad-syntax.rs:17:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:19:1
+  --> $DIR/bad-syntax.rs:20:1
    |
 LL | #[coverage = true]
    | ^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:22:1
+  --> $DIR/bad-syntax.rs:23:1
    |
 LL | #[coverage()]
    | ^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:25:1
+  --> $DIR/bad-syntax.rs:26:1
    |
 LL | #[coverage(off, off)]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:28:1
+  --> $DIR/bad-syntax.rs:29:1
    |
 LL | #[coverage(off, on)]
    | ^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:31:1
+  --> $DIR/bad-syntax.rs:32:1
    |
 LL | #[coverage(bogus)]
    | ^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:34:1
+  --> $DIR/bad-syntax.rs:35:1
    |
 LL | #[coverage(bogus, off)]
    | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/bad-syntax.rs:37:1
+  --> $DIR/bad-syntax.rs:38:1
    |
 LL | #[coverage(off, bogus)]
    | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -103,7 +103,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: expected identifier, found `,`
-  --> $DIR/bad-syntax.rs:43:12
+  --> $DIR/bad-syntax.rs:44:12
    |
 LL | #[coverage(,off)]
    |            ^ expected identifier
@@ -115,25 +115,25 @@ LL + #[coverage(off)]
    |
 
 error: multiple `coverage` attributes
-  --> $DIR/bad-syntax.rs:8:1
+  --> $DIR/bad-syntax.rs:9:1
    |
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/bad-syntax.rs:9:1
+  --> $DIR/bad-syntax.rs:10:1
    |
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^
 
 error: multiple `coverage` attributes
-  --> $DIR/bad-syntax.rs:12:1
+  --> $DIR/bad-syntax.rs:13:1
    |
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/bad-syntax.rs:13:1
+  --> $DIR/bad-syntax.rs:14:1
    |
 LL | #[coverage(on)]
    | ^^^^^^^^^^^^^^^
diff --git a/tests/ui/coverage-attr/name-value.rs b/tests/ui/coverage-attr/name-value.rs
index cdb2f6490f2..e5df5bc3da0 100644
--- a/tests/ui/coverage-attr/name-value.rs
+++ b/tests/ui/coverage-attr/name-value.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.syntax
 
diff --git a/tests/ui/coverage-attr/name-value.stderr b/tests/ui/coverage-attr/name-value.stderr
index 38101764d6f..84a57f575f9 100644
--- a/tests/ui/coverage-attr/name-value.stderr
+++ b/tests/ui/coverage-attr/name-value.stderr
@@ -1,5 +1,5 @@
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:11:1
+  --> $DIR/name-value.rs:12:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:16:5
+  --> $DIR/name-value.rs:17:5
    |
 LL |     #![coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     #![coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:20:1
+  --> $DIR/name-value.rs:21:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:28:5
+  --> $DIR/name-value.rs:29:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:25:1
+  --> $DIR/name-value.rs:26:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:38:5
+  --> $DIR/name-value.rs:39:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:43:5
+  --> $DIR/name-value.rs:44:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:34:1
+  --> $DIR/name-value.rs:35:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -103,7 +103,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:52:5
+  --> $DIR/name-value.rs:53:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:57:5
+  --> $DIR/name-value.rs:58:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:49:1
+  --> $DIR/name-value.rs:50:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -142,7 +142,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:63:1
+  --> $DIR/name-value.rs:64:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -155,7 +155,7 @@ LL | #[coverage(on)]
    |
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:20:1
+  --> $DIR/name-value.rs:21:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
@@ -164,7 +164,7 @@ LL | struct MyStruct;
    | ---------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:34:1
+  --> $DIR/name-value.rs:35:1
    |
 LL |   #[coverage = "off"]
    |   ^^^^^^^^^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL | | }
    | |_- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:38:5
+  --> $DIR/name-value.rs:39:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -186,7 +186,7 @@ LL |     const X: u32;
    |     ------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:43:5
+  --> $DIR/name-value.rs:44:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -195,7 +195,7 @@ LL |     type T;
    |     ------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:28:5
+  --> $DIR/name-value.rs:29:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -204,7 +204,7 @@ LL |     const X: u32 = 7;
    |     ----------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:52:5
+  --> $DIR/name-value.rs:53:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
@@ -213,7 +213,7 @@ LL |     const X: u32 = 8;
    |     ----------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/name-value.rs:57:5
+  --> $DIR/name-value.rs:58:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/coverage-attr/no-coverage.rs b/tests/ui/coverage-attr/no-coverage.rs
index 691456aee40..d715ec8a302 100644
--- a/tests/ui/coverage-attr/no-coverage.rs
+++ b/tests/ui/coverage-attr/no-coverage.rs
@@ -1,6 +1,7 @@
 //@ reference: attributes.coverage.allowed-positions
 
 #![feature(extern_types)]
+#![feature(coverage_attribute)]
 #![feature(impl_trait_in_assoc_type)]
 #![warn(unused_attributes)]
 #![coverage(off)]
diff --git a/tests/ui/coverage-attr/no-coverage.stderr b/tests/ui/coverage-attr/no-coverage.stderr
index 2421d2771f5..1412b54b8d7 100644
--- a/tests/ui/coverage-attr/no-coverage.stderr
+++ b/tests/ui/coverage-attr/no-coverage.stderr
@@ -1,5 +1,5 @@
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:8:1
+  --> $DIR/no-coverage.rs:9:1
    |
 LL |   #[coverage(off)]
    |   ^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | | }
    | |_- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:40:5
+  --> $DIR/no-coverage.rs:41:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     let _ = ();
    |     ----------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:44:9
+  --> $DIR/no-coverage.rs:45:9
    |
 LL |         #[coverage(off)]
    |         ^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |         () => (),
    |         -------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:48:5
+  --> $DIR/no-coverage.rs:49:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     return ();
    |     --------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:10:5
+  --> $DIR/no-coverage.rs:11:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     const X: u32;
    |     ------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:13:5
+  --> $DIR/no-coverage.rs:14:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     type T;
    |     ------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:23:5
+  --> $DIR/no-coverage.rs:24:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |     type T = Self;
    |     -------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:26:5
+  --> $DIR/no-coverage.rs:27:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |     type U = impl Trait;
    |     -------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:31:5
+  --> $DIR/no-coverage.rs:32:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -76,7 +76,7 @@ LL |     static X: u32;
    |     -------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:34:5
+  --> $DIR/no-coverage.rs:35:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL |     type T;
    |     ------- not a function or closure
 
 error: unconstrained opaque type
-  --> $DIR/no-coverage.rs:27:14
+  --> $DIR/no-coverage.rs:28:14
    |
 LL |     type U = impl Trait;
    |              ^^^^^^^^^^
diff --git a/tests/ui/coverage-attr/subword.rs b/tests/ui/coverage-attr/subword.rs
index ff5b750e70e..84a5132ac4a 100644
--- a/tests/ui/coverage-attr/subword.rs
+++ b/tests/ui/coverage-attr/subword.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.syntax
 
diff --git a/tests/ui/coverage-attr/subword.stderr b/tests/ui/coverage-attr/subword.stderr
index 3a106898f8b..a672ff4ac41 100644
--- a/tests/ui/coverage-attr/subword.stderr
+++ b/tests/ui/coverage-attr/subword.stderr
@@ -1,5 +1,5 @@
 error: malformed `coverage` attribute input
-  --> $DIR/subword.rs:7:1
+  --> $DIR/subword.rs:8:1
    |
 LL | #[coverage(yes(milord))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/subword.rs:10:1
+  --> $DIR/subword.rs:11:1
    |
 LL | #[coverage(no(milord))]
    | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/subword.rs:13:1
+  --> $DIR/subword.rs:14:1
    |
 LL | #[coverage(yes = "milord")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL | #[coverage(on)]
    | ~~~~~~~~~~~~~~~
 
 error: malformed `coverage` attribute input
-  --> $DIR/subword.rs:16:1
+  --> $DIR/subword.rs:17:1
    |
 LL | #[coverage(no = "milord")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/coverage-attr/word-only.rs b/tests/ui/coverage-attr/word-only.rs
index 496268fd8c8..add225cdb93 100644
--- a/tests/ui/coverage-attr/word-only.rs
+++ b/tests/ui/coverage-attr/word-only.rs
@@ -1,3 +1,4 @@
+#![feature(coverage_attribute)]
 //@ edition: 2021
 //@ reference: attributes.coverage.syntax
 
diff --git a/tests/ui/coverage-attr/word-only.stderr b/tests/ui/coverage-attr/word-only.stderr
index 154ea61f3a3..97a0723988f 100644
--- a/tests/ui/coverage-attr/word-only.stderr
+++ b/tests/ui/coverage-attr/word-only.stderr
@@ -1,5 +1,5 @@
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:11:1
+  --> $DIR/word-only.rs:12:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:16:5
+  --> $DIR/word-only.rs:17:5
    |
 LL |     #![coverage]
    |     ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     #![coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:20:1
+  --> $DIR/word-only.rs:21:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:28:5
+  --> $DIR/word-only.rs:29:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:25:1
+  --> $DIR/word-only.rs:26:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:38:5
+  --> $DIR/word-only.rs:39:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:43:5
+  --> $DIR/word-only.rs:44:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:34:1
+  --> $DIR/word-only.rs:35:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -103,7 +103,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:52:5
+  --> $DIR/word-only.rs:53:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:57:5
+  --> $DIR/word-only.rs:58:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL |     #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:49:1
+  --> $DIR/word-only.rs:50:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -142,7 +142,7 @@ LL | #[coverage(on)]
    |
 
 error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:63:1
+  --> $DIR/word-only.rs:64:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -155,7 +155,7 @@ LL | #[coverage(on)]
    |
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:20:1
+  --> $DIR/word-only.rs:21:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
@@ -164,7 +164,7 @@ LL | struct MyStruct;
    | ---------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:34:1
+  --> $DIR/word-only.rs:35:1
    |
 LL |   #[coverage]
    |   ^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL | | }
    | |_- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:38:5
+  --> $DIR/word-only.rs:39:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -186,7 +186,7 @@ LL |     const X: u32;
    |     ------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:43:5
+  --> $DIR/word-only.rs:44:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -195,7 +195,7 @@ LL |     type T;
    |     ------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:28:5
+  --> $DIR/word-only.rs:29:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -204,7 +204,7 @@ LL |     const X: u32 = 7;
    |     ----------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:52:5
+  --> $DIR/word-only.rs:53:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
@@ -213,7 +213,7 @@ LL |     const X: u32 = 8;
    |     ----------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/word-only.rs:57:5
+  --> $DIR/word-only.rs:58:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-coverage-attribute.rs b/tests/ui/feature-gates/feature-gate-coverage-attribute.rs
new file mode 100644
index 00000000000..0a463755f13
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-coverage-attribute.rs
@@ -0,0 +1,14 @@
+#![crate_type = "lib"]
+#![feature(no_coverage)] //~ ERROR feature has been removed [E0557]
+
+#[derive(PartialEq, Eq)] // ensure deriving `Eq` does not enable `feature(coverage)`
+struct Foo {
+    a: u8,
+    b: u32,
+}
+
+#[coverage(off)] //~ ERROR the `#[coverage]` attribute is an experimental feature
+fn requires_feature_coverage() -> bool {
+    let bar = Foo { a: 0, b: 0 };
+    bar == Foo { a: 0, b: 0 }
+}
diff --git a/tests/ui/feature-gates/feature-gate-coverage-attribute.stderr b/tests/ui/feature-gates/feature-gate-coverage-attribute.stderr
new file mode 100644
index 00000000000..00e0f0afbde
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-coverage-attribute.stderr
@@ -0,0 +1,22 @@
+error[E0557]: feature has been removed
+  --> $DIR/feature-gate-coverage-attribute.rs:2:12
+   |
+LL | #![feature(no_coverage)]
+   |            ^^^^^^^^^^^ feature has been removed
+   |
+   = note: renamed to `coverage_attribute`
+
+error[E0658]: the `#[coverage]` attribute is an experimental feature
+  --> $DIR/feature-gate-coverage-attribute.rs:10:1
+   |
+LL | #[coverage(off)]
+   | ^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #84605 <https://github.com/rust-lang/rust/issues/84605> for more information
+   = help: add `#![feature(coverage_attribute)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0557, E0658.
+For more information about an error, try `rustc --explain E0557`.
diff --git a/tests/ui/feature-gates/feature-gate-no-coverage.rs b/tests/ui/feature-gates/feature-gate-no-coverage.rs
deleted file mode 100644
index 9c28b293854..00000000000
--- a/tests/ui/feature-gates/feature-gate-no-coverage.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![crate_type = "lib"]
-#![feature(no_coverage)] //~ ERROR feature has been removed [E0557]
-
-#[derive(PartialEq, Eq)] // ensure deriving `Eq` does not enable `feature(coverage)`
-struct Foo {
-    a: u8,
-    b: u32,
-}
-
-#[coverage(off)]
-fn requires_feature_coverage() -> bool {
-    let bar = Foo { a: 0, b: 0 };
-    bar == Foo { a: 0, b: 0 }
-}
diff --git a/tests/ui/feature-gates/feature-gate-no-coverage.stderr b/tests/ui/feature-gates/feature-gate-no-coverage.stderr
deleted file mode 100644
index fa378bbd9dc..00000000000
--- a/tests/ui/feature-gates/feature-gate-no-coverage.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0557]: feature has been removed
-  --> $DIR/feature-gate-no-coverage.rs:2:12
-   |
-LL | #![feature(no_coverage)]
-   |            ^^^^^^^^^^^ feature has been removed
-   |
-   = note: renamed to `coverage_attribute`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0557`.
-- 
cgit 1.4.1-3-g733a5


From d6a9ad6190eac56b2c5847541ecf6e7bbcc2565e Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Mon, 23 Dec 2024 09:14:30 +0000
Subject: remove unused imports from rmake tests

---
 tests/run-make/embed-source-dwarf/rmake.rs           | 2 +-
 tests/run-make/libstd-no-protected/rmake.rs          | 2 +-
 tests/run-make/libtest-thread-limit/rmake.rs         | 5 +----
 tests/run-make/missing-unstable-trait-bound/rmake.rs | 2 +-
 tests/run-make/no-alloc-shim/rmake.rs                | 2 +-
 tests/run-make/rustdoc-map-file/rmake.rs             | 2 --
 tests/run-make/rustdoc-output-stdout/rmake.rs        | 2 --
 7 files changed, 5 insertions(+), 12 deletions(-)

(limited to 'tests')

diff --git a/tests/run-make/embed-source-dwarf/rmake.rs b/tests/run-make/embed-source-dwarf/rmake.rs
index c7106967a85..0aae07ff2e6 100644
--- a/tests/run-make/embed-source-dwarf/rmake.rs
+++ b/tests/run-make/embed-source-dwarf/rmake.rs
@@ -10,7 +10,7 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
 
-use gimli::{AttributeValue, EndianRcSlice, Reader, RunTimeEndian};
+use gimli::{EndianRcSlice, Reader, RunTimeEndian};
 use object::{Object, ObjectSection};
 use run_make_support::{gimli, object, rfs, rustc};
 
diff --git a/tests/run-make/libstd-no-protected/rmake.rs b/tests/run-make/libstd-no-protected/rmake.rs
index 3bba59a8f4d..4091406d46e 100644
--- a/tests/run-make/libstd-no-protected/rmake.rs
+++ b/tests/run-make/libstd-no-protected/rmake.rs
@@ -7,7 +7,7 @@
 use run_make_support::object::Endianness;
 use run_make_support::object::read::archive::ArchiveFile;
 use run_make_support::object::read::elf::{FileHeader as _, SectionHeader as _};
-use run_make_support::rfs::{read, read_dir};
+use run_make_support::rfs::read;
 use run_make_support::{has_prefix, has_suffix, object, path, rustc, shallow_find_files, target};
 
 type FileHeader = run_make_support::object::elf::FileHeader64<Endianness>;
diff --git a/tests/run-make/libtest-thread-limit/rmake.rs b/tests/run-make/libtest-thread-limit/rmake.rs
index fe14d2c046c..817328cd3c3 100644
--- a/tests/run-make/libtest-thread-limit/rmake.rs
+++ b/tests/run-make/libtest-thread-limit/rmake.rs
@@ -15,10 +15,7 @@
 // Reason: this should be ignored in cg_clif (Cranelift) CI and anywhere
 // else that uses panic=abort.
 
-use std::ffi::{self, CStr, CString};
-use std::path::PathBuf;
-
-use run_make_support::{libc, run, rustc};
+use run_make_support::{libc, rustc};
 
 fn main() {
     rustc().input("test.rs").arg("--test").run();
diff --git a/tests/run-make/missing-unstable-trait-bound/rmake.rs b/tests/run-make/missing-unstable-trait-bound/rmake.rs
index 20f77f7c9aa..3f76c65247d 100644
--- a/tests/run-make/missing-unstable-trait-bound/rmake.rs
+++ b/tests/run-make/missing-unstable-trait-bound/rmake.rs
@@ -6,7 +6,7 @@
 // Ensure that on stable we don't suggest restricting with an unsafe trait and we continue
 // mentioning the rest of the obligation chain.
 
-use run_make_support::{diff, rust_lib_name, rustc};
+use run_make_support::{diff, rustc};
 
 fn main() {
     let out = rustc()
diff --git a/tests/run-make/no-alloc-shim/rmake.rs b/tests/run-make/no-alloc-shim/rmake.rs
index c398a3177df..d61ef5de8c5 100644
--- a/tests/run-make/no-alloc-shim/rmake.rs
+++ b/tests/run-make/no-alloc-shim/rmake.rs
@@ -13,7 +13,7 @@
 // Tracking issue: https://github.com/rust-lang/rust/issues/128602
 // Discussion: https://github.com/rust-lang/rust/pull/128407#discussion_r1702439172
 
-use run_make_support::{cc, cwd, has_extension, has_prefix, run, rustc, shallow_find_files};
+use run_make_support::{cc, has_extension, has_prefix, run, rustc, shallow_find_files};
 
 fn main() {
     rustc().input("foo.rs").crate_type("bin").emit("obj").panic("abort").run();
diff --git a/tests/run-make/rustdoc-map-file/rmake.rs b/tests/run-make/rustdoc-map-file/rmake.rs
index d7e3510fe31..50dcc603c02 100644
--- a/tests/run-make/rustdoc-map-file/rmake.rs
+++ b/tests/run-make/rustdoc-map-file/rmake.rs
@@ -1,8 +1,6 @@
 // This test ensures that all items from `foo` are correctly generated into the `redirect-map.json`
 // file with `--generate-redirect-map` rustdoc option.
 
-use std::path::Path;
-
 use run_make_support::rfs::read_to_string;
 use run_make_support::{path, rustdoc, serde_json};
 
diff --git a/tests/run-make/rustdoc-output-stdout/rmake.rs b/tests/run-make/rustdoc-output-stdout/rmake.rs
index bcf5e4d9723..d2fd0451163 100644
--- a/tests/run-make/rustdoc-output-stdout/rmake.rs
+++ b/tests/run-make/rustdoc-output-stdout/rmake.rs
@@ -1,8 +1,6 @@
 // This test verifies that rustdoc `-o -` prints JSON on stdout and doesn't generate
 // a JSON file.
 
-use std::path::PathBuf;
-
 use run_make_support::path_helpers::{cwd, has_extension, read_dir_entries_recursive};
 use run_make_support::{rustdoc, serde_json};
 
-- 
cgit 1.4.1-3-g733a5


From 1d77a2c6772bbe8346f6e42f52f62a5a3c46908c Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Mon, 23 Dec 2024 09:26:57 +0000
Subject: clean up `remove-dir-all-race` rmake test

- removes unused variables
- fixes a few typos
---
 tests/run-make/remove-dir-all-race/rmake.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/tests/run-make/remove-dir-all-race/rmake.rs b/tests/run-make/remove-dir-all-race/rmake.rs
index 03c94b76127..32abca92424 100644
--- a/tests/run-make/remove-dir-all-race/rmake.rs
+++ b/tests/run-make/remove-dir-all-race/rmake.rs
@@ -1,13 +1,13 @@
 //@ ignore-windows
 
 // This test attempts to make sure that running `remove_dir_all`
-// doesn't result in a NotFound error one of the files it
+// doesn't result in a NotFound error if one of the files it
 // is deleting is deleted concurrently.
 //
 // The windows implementation for `remove_dir_all` is significantly
 // more complicated, and has not yet been brought up to par with
 // the implementation on other platforms, so this test is marked as
-// `ignore-windows` until someone more expirenced with windows can
+// `ignore-windows` until someone more experienced with windows can
 // sort that out.
 
 use std::fs::remove_dir_all;
@@ -27,13 +27,12 @@ fn main() {
             write("outer/inner.txt", b"sometext");
 
             thread::scope(|scope| {
-                let t1 = scope.spawn(|| {
+                scope.spawn(|| {
                     thread::sleep(Duration::from_nanos(i));
                     remove_dir_all("outer").unwrap();
                 });
 
-                let race_happened_ref = &race_happened;
-                let t2 = scope.spawn(|| {
+                scope.spawn(|| {
                     let r1 = remove_dir_all("outer/inner");
                     let r2 = remove_dir_all("outer/inner.txt");
                     if r1.is_ok() && r2.is_err() {
@@ -44,10 +43,10 @@ fn main() {
 
             assert!(!Path::new("outer").exists());
 
-            // trying to remove a nonexistant top-level directory should
+            // trying to remove a nonexistent top-level directory should
             // still result in an error.
             let Err(err) = remove_dir_all("outer") else {
-                panic!("removing nonexistant dir did not result in an error");
+                panic!("removing nonexistent dir did not result in an error");
             };
             assert_eq!(err.kind(), std::io::ErrorKind::NotFound);
         }
-- 
cgit 1.4.1-3-g733a5


From 9ca5df692b61db524d6a4c8e78042e9db2cc18b4 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Mon, 23 Dec 2024 09:31:01 +0000
Subject: remove unnecessary `mut` from `dump-ice-to-disk` rmake test

---
 tests/run-make/dump-ice-to-disk/rmake.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/run-make/dump-ice-to-disk/rmake.rs b/tests/run-make/dump-ice-to-disk/rmake.rs
index 15f35eb2d3d..a7a98d31f50 100644
--- a/tests/run-make/dump-ice-to-disk/rmake.rs
+++ b/tests/run-make/dump-ice-to-disk/rmake.rs
@@ -83,7 +83,7 @@ fn extract_exactly_one_ice_file<P: AsRef<Path>>(name: &'static str, dir: P) -> I
 
 fn main() {
     // Establish baseline ICE message.
-    let mut default_ice_dump = OnceCell::new();
+    let default_ice_dump = OnceCell::new();
     run_in_tmpdir(|| {
         rustc().env("RUSTC_ICE", cwd()).input("lib.rs").arg("-Ztreat-err-as-bug=1").run_fail();
         let dump = extract_exactly_one_ice_file("baseline", cwd());
-- 
cgit 1.4.1-3-g733a5


From 6f19bd08b07b590ff20a2285c3dc4938d3e37447 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Mon, 23 Dec 2024 09:34:52 +0000
Subject: fix a few typos in rmake tests' comments

---
 tests/run-make/import-macro-verbatim/verbatim.rs | 2 +-
 tests/run-make/llvm-outputs/rmake.rs             | 4 ++--
 tests/run-make/musl-default-linking/rmake.rs     | 2 +-
 tests/run-make/no-builtins-lto/rmake.rs          | 2 +-
 tests/run-make/symbol-visibility/rmake.rs        | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'tests')

diff --git a/tests/run-make/import-macro-verbatim/verbatim.rs b/tests/run-make/import-macro-verbatim/verbatim.rs
index 56a83673c1f..0123a4a7e22 100644
--- a/tests/run-make/import-macro-verbatim/verbatim.rs
+++ b/tests/run-make/import-macro-verbatim/verbatim.rs
@@ -1,4 +1,4 @@
-//! Include a file by concating the verbatim path using `/` instead of `\`
+//! Include a file by concatenating the verbatim path using `/` instead of `\`
 
 include!(concat!(env!("VERBATIM_DIR"), "/include/include.txt"));
 fn main() {
diff --git a/tests/run-make/llvm-outputs/rmake.rs b/tests/run-make/llvm-outputs/rmake.rs
index 632e9a09ba5..2ce31b260a1 100644
--- a/tests/run-make/llvm-outputs/rmake.rs
+++ b/tests/run-make/llvm-outputs/rmake.rs
@@ -9,8 +9,8 @@ fn main() {
     let mut path_ir = PathBuf::new();
     run_in_tmpdir(|| {
         let p = cwd();
-        path_bc = p.join("nonexistant_dir_bc");
-        path_ir = p.join("nonexistant_dir_ir");
+        path_bc = p.join("nonexistent_dir_bc");
+        path_ir = p.join("nonexistent_dir_ir");
         rustc().input("-").stdin_buf("fn main() {}").out_dir(&path_bc).emit("llvm-bc").run();
         rustc().input("-").stdin_buf("fn main() {}").out_dir(&path_ir).emit("llvm-ir").run();
         assert!(path_bc.exists());
diff --git a/tests/run-make/musl-default-linking/rmake.rs b/tests/run-make/musl-default-linking/rmake.rs
index b6d428d3f27..d203595a447 100644
--- a/tests/run-make/musl-default-linking/rmake.rs
+++ b/tests/run-make/musl-default-linking/rmake.rs
@@ -48,7 +48,7 @@ fn main() {
         let default = &target_spec["crt-static-default"];
 
         // If the value is `null`, then the default to dynamically link from
-        // musl_base was not overriden.
+        // musl_base was not overridden.
         if default.is_null() {
             continue;
         }
diff --git a/tests/run-make/no-builtins-lto/rmake.rs b/tests/run-make/no-builtins-lto/rmake.rs
index 8e0c3a63649..56fdfde42f0 100644
--- a/tests/run-make/no-builtins-lto/rmake.rs
+++ b/tests/run-make/no-builtins-lto/rmake.rs
@@ -1,4 +1,4 @@
-// The rlib produced by a no_builtins crate should be explicitely linked
+// The rlib produced by a no_builtins crate should be explicitly linked
 // during compilation, and as a result be present in the linker arguments.
 // See the comments inside this file for more details.
 // See https://github.com/rust-lang/rust/pull/35637
diff --git a/tests/run-make/symbol-visibility/rmake.rs b/tests/run-make/symbol-visibility/rmake.rs
index f84e63ef74e..ec936bc3b07 100644
--- a/tests/run-make/symbol-visibility/rmake.rs
+++ b/tests/run-make/symbol-visibility/rmake.rs
@@ -1,7 +1,7 @@
 // Dynamic libraries on Rust used to export a very high amount of symbols,
 // going as far as filling the output with mangled names and generic function
 // names. After the rework of #38117, this test checks that no mangled Rust symbols
-// are exported, and that generics are only shown if explicitely requested.
+// are exported, and that generics are only shown if explicitly requested.
 // See https://github.com/rust-lang/rust/issues/37530
 
 use run_make_support::object::read::Object;
-- 
cgit 1.4.1-3-g733a5


From 7ee520491e5c13b7f572583198f4d9812bd3580a Mon Sep 17 00:00:00 2001
From: "许杰友 Jieyou Xu (Joe)" <39484203+jieyouxu@users.noreply.github.com>
Date: Sun, 22 Dec 2024 20:14:19 +0800
Subject: tests: migrate `incr-add-rust-src-component` to rmake.rs

The Makefile version seems to contain a bug. Over the years, the
directory structure of the `rust-src` component changed as the source
tree directory structure changed. `libstd` is no longer a thing directly
under `root/lib/rustlib/src/rust/src/`, it is moved to
`root/lib/rustlib/src/rust/library/std`.

Co-authored-by: Oneirical <manchot@videotron.ca>
---
 src/tools/tidy/src/allowed_run_make_makefiles.txt  |   1 -
 .../run-make/incr-add-rust-src-component/Makefile  |  45 -------
 .../run-make/incr-add-rust-src-component/rmake.rs  | 131 +++++++++++++++++++++
 3 files changed, 131 insertions(+), 46 deletions(-)
 delete mode 100644 tests/run-make/incr-add-rust-src-component/Makefile
 create mode 100644 tests/run-make/incr-add-rust-src-component/rmake.rs

(limited to 'tests')

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 0e156b9d1ac..f7ecb485152 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -1,7 +1,6 @@
 run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/extern-fn-reachable/Makefile
-run-make/incr-add-rust-src-component/Makefile
 run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
 run-make/split-debuginfo/Makefile
diff --git a/tests/run-make/incr-add-rust-src-component/Makefile b/tests/run-make/incr-add-rust-src-component/Makefile
deleted file mode 100644
index fd09c2299f9..00000000000
--- a/tests/run-make/incr-add-rust-src-component/Makefile
+++ /dev/null
@@ -1,45 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# rust-lang/rust#70924: Test that if we add rust-src component in between two
-# incremental compiles, the compiler does not ICE on the second.
-
-# This test uses `ln -s` rather than copying to save testing time, but its
-# usage doesn't work on windows. So ignore windows.
-
-# ignore-windows
-
-SYSROOT:=$(shell $(RUSTC) --print sysroot)
-FAKEROOT=$(TMPDIR)/fakeroot
-INCR=$(TMPDIR)/incr
-
-# Make a local copy of the sysroot; then remove the rust-src part of it, if
-# present, for the *first* build. Then put in a facsimile of the rust-src
-# component for the second build, in order to expose the ICE from issue #70924.
-#
-# Note that it is much easier to just do `cp -a $(SYSROOT)/* $(FAKEROOT)` as a
-# first step, but I am concerned that would be too expensive in a unit test
-# compared to making symbolic links.
-#
-# Anyway, the pattern you'll see here is: For every prefix in
-# root/lib/rustlib/src, link all of prefix parent content, then remove the
-# prefix, then loop on the next prefix. This way, we basically create a copy of
-# the context around root/lib/rustlib/src, and can freely add/remove the src
-# component itself.
-all:
-	mkdir $(FAKEROOT)
-	ln -s $(SYSROOT)/* $(FAKEROOT)
-	rm -f $(FAKEROOT)/lib
-	mkdir $(FAKEROOT)/lib
-	ln -s $(SYSROOT)/lib/* $(FAKEROOT)/lib
-	rm -f $(FAKEROOT)/lib/rustlib
-	mkdir $(FAKEROOT)/lib/rustlib
-	ln -s $(SYSROOT)/lib/rustlib/* $(FAKEROOT)/lib/rustlib
-	rm -f $(FAKEROOT)/lib/rustlib/src
-	mkdir $(FAKEROOT)/lib/rustlib/src
-	ln -s $(SYSROOT)/lib/rustlib/src/* $(FAKEROOT)/lib/rustlib/src
-	rm -f $(FAKEROOT)/lib/rustlib/src/rust
-	$(RUSTC) --sysroot $(FAKEROOT) -C incremental=$(INCR) main.rs
-	mkdir -p $(FAKEROOT)/lib/rustlib/src/rust/src/libstd
-	touch $(FAKEROOT)/lib/rustlib/src/rust/src/libstd/lib.rs
-	$(RUSTC) --sysroot $(FAKEROOT) -C incremental=$(INCR) main.rs
diff --git a/tests/run-make/incr-add-rust-src-component/rmake.rs b/tests/run-make/incr-add-rust-src-component/rmake.rs
new file mode 100644
index 00000000000..964f1410a96
--- /dev/null
+++ b/tests/run-make/incr-add-rust-src-component/rmake.rs
@@ -0,0 +1,131 @@
+//! Regression test for rust-lang/rust#70924. Check that if we add the `rust-src` component in
+//! between two incremental compiles, that the compiler doesn't ICE on the second invocation.
+//!
+//! This test uses symbolic links to save testing time.
+//!
+//! The way this test works is that, for every prefix in `root/lib/rustlib/src`, link all of prefix
+//! parent content, then remove the prefix, then loop on the next prefix. This way, we basically
+//! create a copy of the context around `root/lib/rustlib/src`, and can freely add/remove the src
+//! component itself.
+
+//@ ignore-cross-compile
+// Reason: test needs to run.
+
+//@ needs-symlink
+// Reason: test needs symlink to create stub directories and files.
+
+use std::path::Path;
+
+use run_make_support::rfs::read_dir_entries;
+use run_make_support::{bare_rustc, path, rfs, run};
+
+#[derive(Debug, Copy, Clone)]
+struct Symlink<'a, 'b> {
+    src_dir: &'a Path,
+    dst_dir: &'b Path,
+}
+
+fn shallow_symlink_dir<'a, 'b>(Symlink { src_dir, dst_dir }: Symlink<'a, 'b>) {
+    eprintln!(
+        "shallow_symlink_dir: src_dir={} -> dst_dir={}",
+        src_dir.display(),
+        dst_dir.display()
+    );
+
+    read_dir_entries(src_dir, |src_path| {
+        let src_metadata = rfs::symlink_metadata(src_path);
+        let filename = src_path.file_name().unwrap();
+        if src_metadata.is_dir() {
+            rfs::symlink_dir(src_path, dst_dir.join(filename));
+        } else if src_metadata.is_file() {
+            rfs::symlink_file(src_path, dst_dir.join(filename));
+        } else if src_metadata.is_symlink() {
+            rfs::copy_symlink(src_path, dst_dir.join(filename));
+        }
+    });
+}
+
+fn recreate_dir(path: &Path) {
+    rfs::recursive_remove(path);
+    rfs::create_dir(path);
+}
+
+fn main() {
+    let sysroot = bare_rustc().print("sysroot").run().stdout_utf8();
+    let sysroot = sysroot.trim();
+    let sysroot = path(sysroot);
+
+    let incr = path("incr");
+
+    let fakeroot = path("fakeroot");
+    rfs::create_dir(&fakeroot);
+
+    shallow_symlink_dir(Symlink { src_dir: &sysroot, dst_dir: &fakeroot });
+    recreate_dir(&fakeroot.join("lib"));
+
+    shallow_symlink_dir(Symlink { src_dir: &sysroot.join("lib"), dst_dir: &fakeroot.join("lib") });
+    recreate_dir(&fakeroot.join("lib").join("rustlib"));
+
+    shallow_symlink_dir(Symlink {
+        src_dir: &sysroot.join("lib").join("rustlib"),
+        dst_dir: &fakeroot.join("lib").join("rustlib"),
+    });
+    recreate_dir(&fakeroot.join("lib").join("rustlib").join("src"));
+
+    shallow_symlink_dir(Symlink {
+        src_dir: &sysroot.join("lib").join("rustlib").join("src"),
+        dst_dir: &fakeroot.join("lib").join("rustlib").join("src"),
+    });
+
+    rfs::recursive_remove(&fakeroot.join("lib").join("rustlib").join("src").join("rust"));
+
+    let run_incr_rustc = || {
+        bare_rustc()
+            .sysroot(&fakeroot)
+            .arg("-C")
+            .arg(format!("incremental={}", incr.to_str().unwrap()))
+            .input("main.rs")
+            .run();
+    };
+
+    // Run rustc w/ incremental once...
+    run_incr_rustc();
+
+    // NOTE: the Makefile version of this used `$SYSROOT/lib/rustlib/src/rust/src/libstd/lib.rs`,
+    // but that actually got moved around and reorganized over the years. As of Dec 2024, the
+    // rust-src component is more like (specific for our purposes):
+    //
+    // ```
+    // $SYSROOT/lib/rustlib/src/rust/
+    //     library/std/src/lib.rs
+    //     src/
+    // ```
+    rfs::create_dir_all(
+        &fakeroot
+            .join("lib")
+            .join("rustlib")
+            .join("src")
+            .join("rust")
+            .join("library")
+            .join("std")
+            .join("src"),
+    );
+    rfs::write(
+        &fakeroot
+            .join("lib")
+            .join("rustlib")
+            .join("src")
+            .join("rust")
+            .join("library")
+            .join("std")
+            .join("src")
+            .join("lib.rs"),
+        b"",
+    );
+
+    // ... and a second time.
+    run_incr_rustc();
+
+    // Basic sanity check that the compiled binary can run.
+    run("main");
+}
-- 
cgit 1.4.1-3-g733a5


From 0efa90f2464cad23abd371676b592d672d039057 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Thu, 19 Dec 2024 06:43:09 -0800
Subject: Add a test for coverage attr on trait function

---
 tests/coverage/attr/trait-impl-inherit.cov-map  |  9 +++++++++
 tests/coverage/attr/trait-impl-inherit.coverage | 26 +++++++++++++++++++++++++
 tests/coverage/attr/trait-impl-inherit.rs       | 25 ++++++++++++++++++++++++
 3 files changed, 60 insertions(+)
 create mode 100644 tests/coverage/attr/trait-impl-inherit.cov-map
 create mode 100644 tests/coverage/attr/trait-impl-inherit.coverage
 create mode 100644 tests/coverage/attr/trait-impl-inherit.rs

(limited to 'tests')

diff --git a/tests/coverage/attr/trait-impl-inherit.cov-map b/tests/coverage/attr/trait-impl-inherit.cov-map
new file mode 100644
index 00000000000..eab9f926bb7
--- /dev/null
+++ b/tests/coverage/attr/trait-impl-inherit.cov-map
@@ -0,0 +1,9 @@
+Function name: <trait_impl_inherit::S as trait_impl_inherit::T>::f
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 11, 05, 02, 06]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 17, 5) to (start + 2, 6)
+Highest counter ID seen: c0
+
diff --git a/tests/coverage/attr/trait-impl-inherit.coverage b/tests/coverage/attr/trait-impl-inherit.coverage
new file mode 100644
index 00000000000..b92d82aefbc
--- /dev/null
+++ b/tests/coverage/attr/trait-impl-inherit.coverage
@@ -0,0 +1,26 @@
+   LL|       |#![feature(coverage_attribute)]
+   LL|       |// Checks that `#[coverage(..)]` in a trait method is not inherited in an
+   LL|       |// implementation.
+   LL|       |//@ edition: 2021
+   LL|       |//@ reference: attributes.coverage.trait-impl-inherit
+   LL|       |
+   LL|       |trait T {
+   LL|       |    #[coverage(off)]
+   LL|       |    fn f(&self) {
+   LL|       |        println!("default");
+   LL|       |    }
+   LL|       |}
+   LL|       |
+   LL|       |struct S;
+   LL|       |
+   LL|       |impl T for S {
+   LL|      1|    fn f(&self) {
+   LL|      1|        println!("impl S");
+   LL|      1|    }
+   LL|       |}
+   LL|       |
+   LL|       |#[coverage(off)]
+   LL|       |fn main() {
+   LL|       |    S.f();
+   LL|       |}
+
diff --git a/tests/coverage/attr/trait-impl-inherit.rs b/tests/coverage/attr/trait-impl-inherit.rs
new file mode 100644
index 00000000000..951fecce90a
--- /dev/null
+++ b/tests/coverage/attr/trait-impl-inherit.rs
@@ -0,0 +1,25 @@
+#![feature(coverage_attribute)]
+// Checks that `#[coverage(..)]` in a trait method is not inherited in an
+// implementation.
+//@ edition: 2021
+//@ reference: attributes.coverage.trait-impl-inherit
+
+trait T {
+    #[coverage(off)]
+    fn f(&self) {
+        println!("default");
+    }
+}
+
+struct S;
+
+impl T for S {
+    fn f(&self) {
+        println!("impl S");
+    }
+}
+
+#[coverage(off)]
+fn main() {
+    S.f();
+}
-- 
cgit 1.4.1-3-g733a5


From 5d9f17f58c35503aeef74046d9d7d8521e265ba1 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Thu, 19 Dec 2024 06:51:07 -0800
Subject: Add test for coverage on a body-less trait function

---
 tests/ui/coverage-attr/no-coverage.rs     |  9 ++++++++
 tests/ui/coverage-attr/no-coverage.stderr | 36 ++++++++++++++++++++++---------
 2 files changed, 35 insertions(+), 10 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/coverage-attr/no-coverage.rs b/tests/ui/coverage-attr/no-coverage.rs
index d715ec8a302..c386f25816e 100644
--- a/tests/ui/coverage-attr/no-coverage.rs
+++ b/tests/ui/coverage-attr/no-coverage.rs
@@ -15,6 +15,12 @@ trait Trait {
     type T;
 
     type U;
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    fn f(&self);
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    fn g();
 }
 
 #[coverage(off)]
@@ -26,6 +32,9 @@ impl Trait for () {
 
     #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
     type U = impl Trait; //~ ERROR unconstrained opaque type
+
+    fn f(&self) {}
+    fn g() {}
 }
 
 extern "C" {
diff --git a/tests/ui/coverage-attr/no-coverage.stderr b/tests/ui/coverage-attr/no-coverage.stderr
index 1412b54b8d7..f5a44ecec74 100644
--- a/tests/ui/coverage-attr/no-coverage.stderr
+++ b/tests/ui/coverage-attr/no-coverage.stderr
@@ -7,12 +7,12 @@ LL | / trait Trait {
 LL | |     #[coverage(off)]
 LL | |     const X: u32;
 ...  |
-LL | |     type U;
+LL | |     fn g();
 LL | | }
    | |_- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:41:5
+  --> $DIR/no-coverage.rs:50:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     let _ = ();
    |     ----------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:45:9
+  --> $DIR/no-coverage.rs:54:9
    |
 LL |         #[coverage(off)]
    |         ^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |         () => (),
    |         -------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:49:5
+  --> $DIR/no-coverage.rs:58:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -52,7 +52,23 @@ LL |     type T;
    |     ------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:24:5
+  --> $DIR/no-coverage.rs:19:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     fn f(&self);
+   |     ------------ not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/no-coverage.rs:22:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     fn g();
+   |     ------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/no-coverage.rs:30:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -60,7 +76,7 @@ LL |     type T = Self;
    |     -------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:27:5
+  --> $DIR/no-coverage.rs:33:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -68,7 +84,7 @@ LL |     type U = impl Trait;
    |     -------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:32:5
+  --> $DIR/no-coverage.rs:41:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -76,7 +92,7 @@ LL |     static X: u32;
    |     -------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:35:5
+  --> $DIR/no-coverage.rs:44:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -84,13 +100,13 @@ LL |     type T;
    |     ------- not a function or closure
 
 error: unconstrained opaque type
-  --> $DIR/no-coverage.rs:28:14
+  --> $DIR/no-coverage.rs:34:14
    |
 LL |     type U = impl Trait;
    |              ^^^^^^^^^^
    |
    = note: `U` must be used in combination with a concrete type within the same impl
 
-error: aborting due to 11 previous errors
+error: aborting due to 13 previous errors
 
 For more information about this error, try `rustc --explain E0788`.
-- 
cgit 1.4.1-3-g733a5


From af1c8da172a9d9d18af4a7e1c59bfecd2f051111 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 23 Dec 2024 15:30:27 +0100
Subject: core: fix const ptr::swap_nonoverlapping when there are pointers at
 odd offsets in the type

---
 library/core/src/intrinsics/mod.rs               | 14 ++---
 library/core/src/ptr/mod.rs                      | 73 ++++++++++++++----------
 library/core/tests/lib.rs                        |  1 +
 library/core/tests/ptr.rs                        | 63 ++++++++++++++++----
 tests/ui/consts/missing_span_in_backtrace.stderr |  3 +
 5 files changed, 106 insertions(+), 48 deletions(-)

(limited to 'tests')

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 3e53c0497cc..42b8eb33a1a 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -3795,7 +3795,7 @@ where
 /// See [`const_eval_select()`] for the rules and requirements around that intrinsic.
 pub(crate) macro const_eval_select {
     (
-        @capture { $($arg:ident : $ty:ty = $val:expr),* $(,)? } $( -> $ret:ty )? :
+        @capture$([$($binders:tt)*])? { $($arg:ident : $ty:ty = $val:expr),* $(,)? } $( -> $ret:ty )? :
         if const
             $(#[$compiletime_attr:meta])* $compiletime:block
         else
@@ -3803,7 +3803,7 @@ pub(crate) macro const_eval_select {
     ) => {
         // Use the `noinline` arm, after adding explicit `inline` attributes
         $crate::intrinsics::const_eval_select!(
-            @capture { $($arg : $ty = $val),* } $(-> $ret)? :
+            @capture$([$($binders)*])? { $($arg : $ty = $val),* } $(-> $ret)? :
             #[noinline]
             if const
                 #[inline] // prevent codegen on this function
@@ -3817,7 +3817,7 @@ pub(crate) macro const_eval_select {
     },
     // With a leading #[noinline], we don't add inline attributes
     (
-        @capture { $($arg:ident : $ty:ty = $val:expr),* $(,)? } $( -> $ret:ty )? :
+        @capture$([$($binders:tt)*])? { $($arg:ident : $ty:ty = $val:expr),* $(,)? } $( -> $ret:ty )? :
         #[noinline]
         if const
             $(#[$compiletime_attr:meta])* $compiletime:block
@@ -3825,12 +3825,12 @@ pub(crate) macro const_eval_select {
             $(#[$runtime_attr:meta])* $runtime:block
     ) => {{
         $(#[$runtime_attr])*
-        fn runtime($($arg: $ty),*) $( -> $ret )? {
+        fn runtime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
             $runtime
         }
 
         $(#[$compiletime_attr])*
-        const fn compiletime($($arg: $ty),*) $( -> $ret )? {
+        const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
             // Don't warn if one of the arguments is unused.
             $(let _ = $arg;)*
 
@@ -3842,14 +3842,14 @@ pub(crate) macro const_eval_select {
     // We support leaving away the `val` expressions for *all* arguments
     // (but not for *some* arguments, that's too tricky).
     (
-        @capture { $($arg:ident : $ty:ty),* $(,)? } $( -> $ret:ty )? :
+        @capture$([$($binders:tt)*])? { $($arg:ident : $ty:ty),* $(,)? } $( -> $ret:ty )? :
         if const
             $(#[$compiletime_attr:meta])* $compiletime:block
         else
             $(#[$runtime_attr:meta])* $runtime:block
     ) => {
         $crate::intrinsics::const_eval_select!(
-            @capture { $($arg : $ty = $arg),* } $(-> $ret)? :
+            @capture$([$($binders)*])? { $($arg : $ty = $arg),* } $(-> $ret)? :
             if const
                 $(#[$compiletime_attr])* $compiletime
             else
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 1423e7ea8d1..e6e13eaff7b 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -395,6 +395,7 @@
 #![allow(clippy::not_unsafe_ptr_arg_deref)]
 
 use crate::cmp::Ordering;
+use crate::intrinsics::const_eval_select;
 use crate::marker::FnPtr;
 use crate::mem::{self, MaybeUninit, SizedTypeProperties};
 use crate::{fmt, hash, intrinsics, ub_checks};
@@ -1074,25 +1075,6 @@ pub const unsafe fn swap<T>(x: *mut T, y: *mut T) {
 #[rustc_const_unstable(feature = "const_swap_nonoverlapping", issue = "133668")]
 #[rustc_diagnostic_item = "ptr_swap_nonoverlapping"]
 pub const unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) {
-    #[allow(unused)]
-    macro_rules! attempt_swap_as_chunks {
-        ($ChunkTy:ty) => {
-            if mem::align_of::<T>() >= mem::align_of::<$ChunkTy>()
-                && mem::size_of::<T>() % mem::size_of::<$ChunkTy>() == 0
-            {
-                let x: *mut $ChunkTy = x.cast();
-                let y: *mut $ChunkTy = y.cast();
-                let count = count * (mem::size_of::<T>() / mem::size_of::<$ChunkTy>());
-                // SAFETY: these are the same bytes that the caller promised were
-                // ok, just typed as `MaybeUninit<ChunkTy>`s instead of as `T`s.
-                // The `if` condition above ensures that we're not violating
-                // alignment requirements, and that the division is exact so
-                // that we don't lose any bytes off the end.
-                return unsafe { swap_nonoverlapping_simple_untyped(x, y, count) };
-            }
-        };
-    }
-
     ub_checks::assert_unsafe_precondition!(
         check_language_ub,
         "ptr::swap_nonoverlapping requires that both pointer arguments are aligned and non-null \
@@ -1111,19 +1093,48 @@ pub const unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) {
         }
     );
 
-    // Split up the slice into small power-of-two-sized chunks that LLVM is able
-    // to vectorize (unless it's a special type with more-than-pointer alignment,
-    // because we don't want to pessimize things like slices of SIMD vectors.)
-    if mem::align_of::<T>() <= mem::size_of::<usize>()
-        && (!mem::size_of::<T>().is_power_of_two()
-            || mem::size_of::<T>() > mem::size_of::<usize>() * 2)
-    {
-        attempt_swap_as_chunks!(usize);
-        attempt_swap_as_chunks!(u8);
-    }
+    const_eval_select!(
+        @capture[T] { x: *mut T, y: *mut T, count: usize }:
+        if const {
+            // At compile-time we want to always copy this in chunks of `T`, to ensure that if there
+            // are pointers inside `T` we will copy them in one go rather than trying to copy a part
+            // of a pointer (which would not work).
+            // SAFETY: Same preconditions as this function
+            unsafe { swap_nonoverlapping_simple_untyped(x, y, count) }
+        } else {
+            macro_rules! attempt_swap_as_chunks {
+                ($ChunkTy:ty) => {
+                    if mem::align_of::<T>() >= mem::align_of::<$ChunkTy>()
+                        && mem::size_of::<T>() % mem::size_of::<$ChunkTy>() == 0
+                    {
+                        let x: *mut $ChunkTy = x.cast();
+                        let y: *mut $ChunkTy = y.cast();
+                        let count = count * (mem::size_of::<T>() / mem::size_of::<$ChunkTy>());
+                        // SAFETY: these are the same bytes that the caller promised were
+                        // ok, just typed as `MaybeUninit<ChunkTy>`s instead of as `T`s.
+                        // The `if` condition above ensures that we're not violating
+                        // alignment requirements, and that the division is exact so
+                        // that we don't lose any bytes off the end.
+                        return unsafe { swap_nonoverlapping_simple_untyped(x, y, count) };
+                    }
+                };
+            }
+
+            // Split up the slice into small power-of-two-sized chunks that LLVM is able
+            // to vectorize (unless it's a special type with more-than-pointer alignment,
+            // because we don't want to pessimize things like slices of SIMD vectors.)
+            if mem::align_of::<T>() <= mem::size_of::<usize>()
+            && (!mem::size_of::<T>().is_power_of_two()
+                || mem::size_of::<T>() > mem::size_of::<usize>() * 2)
+            {
+                attempt_swap_as_chunks!(usize);
+                attempt_swap_as_chunks!(u8);
+            }
 
-    // SAFETY: Same preconditions as this function
-    unsafe { swap_nonoverlapping_simple_untyped(x, y, count) }
+            // SAFETY: Same preconditions as this function
+            unsafe { swap_nonoverlapping_simple_untyped(x, y, count) }
+        }
+    )
 }
 
 /// Same behavior and safety conditions as [`swap_nonoverlapping`]
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 89b65eefd02..9f0ab7b3f29 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -16,6 +16,7 @@
 #![feature(const_black_box)]
 #![feature(const_eval_select)]
 #![feature(const_swap)]
+#![feature(const_swap_nonoverlapping)]
 #![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
diff --git a/library/core/tests/ptr.rs b/library/core/tests/ptr.rs
index 454b13a7ee3..e6825d8e39e 100644
--- a/library/core/tests/ptr.rs
+++ b/library/core/tests/ptr.rs
@@ -860,7 +860,10 @@ fn swap_copy_untyped() {
 }
 
 #[test]
-fn test_const_copy() {
+fn test_const_copy_ptr() {
+    // `copy` and `copy_nonoverlapping` are thin layers on top of intrinsics. Ensure they correctly
+    // deal with pointers even when the pointers cross the boundary from one "element" being copied
+    // to another.
     const {
         let ptr1 = &1;
         let mut ptr2 = &666;
@@ -899,21 +902,61 @@ fn test_const_copy() {
 }
 
 #[test]
-fn test_const_swap() {
+fn test_const_swap_ptr() {
+    // The `swap` functions are implemented in the library, they are not primitives.
+    // Only `swap_nonoverlapping` takes a count; pointers that cross multiple elements
+    // are *not* supported.
+    // We put the pointer at an odd offset in the type and copy them as an array of bytes,
+    // which should catch most of the ways that the library implementation can get it wrong.
+
+    #[cfg(target_pointer_width = "32")]
+    type HalfPtr = i16;
+    #[cfg(target_pointer_width = "64")]
+    type HalfPtr = i32;
+
+    #[repr(C, packed)]
+    #[allow(unused)]
+    struct S {
+        f1: HalfPtr,
+        // Crucially this field is at an offset that is not a multiple of the pointer size.
+        ptr: &'static i32,
+        // Make sure the entire type does not have a power-of-2 size:
+        // make it 3 pointers in size. This used to hit a bug in `swap_nonoverlapping`.
+        f2: [HalfPtr; 3],
+    }
+
+    // Ensure the entire thing is usize-aligned, so in principle this
+    // looks like it could be eligible for a `usize` copying loop.
+    #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
+    #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
+    struct A(S);
+
     const {
-        let mut ptr1 = &1;
-        let mut ptr2 = &666;
+        let mut s1 = A(S { ptr: &1, f1: 0, f2: [0; 3] });
+        let mut s2 = A(S { ptr: &666, f1: 0, f2: [0; 3] });
 
-        // Swap ptr1 and ptr2, bytewise. `swap` does not take a count
-        // so the best we can do is use an array.
-        type T = [u8; mem::size_of::<&i32>()];
+        // Swap ptr1 and ptr2, as an array.
+        type T = [u8; mem::size_of::<A>()];
         unsafe {
-            ptr::swap(ptr::from_mut(&mut ptr1).cast::<T>(), ptr::from_mut(&mut ptr2).cast::<T>());
+            ptr::swap(ptr::from_mut(&mut s1).cast::<T>(), ptr::from_mut(&mut s2).cast::<T>());
         }
 
         // Make sure they still work.
-        assert!(*ptr1 == 666);
-        assert!(*ptr2 == 1);
+        assert!(*s1.0.ptr == 666);
+        assert!(*s2.0.ptr == 1);
+
+        // Swap them back, again as an array.
+        unsafe {
+            ptr::swap_nonoverlapping(
+                ptr::from_mut(&mut s1).cast::<T>(),
+                ptr::from_mut(&mut s2).cast::<T>(),
+                1,
+            );
+        }
+
+        // Make sure they still work.
+        assert!(*s1.0.ptr == 1);
+        assert!(*s2.0.ptr == 666);
     };
 }
 
diff --git a/tests/ui/consts/missing_span_in_backtrace.stderr b/tests/ui/consts/missing_span_in_backtrace.stderr
index 72d15702e89..05ae7305dbc 100644
--- a/tests/ui/consts/missing_span_in_backtrace.stderr
+++ b/tests/ui/consts/missing_span_in_backtrace.stderr
@@ -7,6 +7,8 @@ note: inside `std::ptr::read::<MaybeUninit<MaybeUninit<u8>>>`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `std::ptr::swap_nonoverlapping_simple_untyped::<MaybeUninit<u8>>`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `swap_nonoverlapping::compiletime::<MaybeUninit<u8>>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `swap_nonoverlapping::<MaybeUninit<u8>>`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `X`
@@ -20,6 +22,7 @@ note: inside `X`
    | |_________^
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
+   = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `const_eval_select` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From b893221517243d942ab503793f885dcefbfa4f45 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 19 Dec 2024 04:13:28 +0000
Subject: Always run tail_expr_drop_order lint on promoted MIR

---
 compiler/rustc_mir_transform/src/lib.rs            |  3 +-
 tests/ui/drop/lint-tail-expr-drop-order.rs         |  1 -
 tests/ui/drop/lint-tail-expr-drop-order.stderr     | 46 +++++++++++-----------
 .../tail_expr_drop_order-on-coroutine-unwind.rs    |  1 -
 ...tail_expr_drop_order-on-coroutine-unwind.stderr | 10 ++---
 tests/ui/error-codes/E0452.rs                      |  2 +
 tests/ui/error-codes/E0452.stderr                  | 18 ++++++++-
 .../command-line-register-unknown-lint-tool.stderr |  7 +++-
 .../ui/lint/force-warn/warnings-lint-group.stderr  |  6 ++-
 tests/ui/lint/lint-malformed.rs                    |  2 +
 tests/ui/lint/lint-malformed.stderr                | 18 ++++++++-
 tests/ui/tool-attributes/unknown-lint-tool-name.rs |  1 +
 .../tool-attributes/unknown-lint-tool-name.stderr  | 15 +++++--
 13 files changed, 92 insertions(+), 38 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 5c090bf7cad..e1fba9be5bb 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -437,6 +437,8 @@ fn mir_promoted(
         Some(MirPhase::Analysis(AnalysisPhase::Initial)),
     );
 
+    lint_tail_expr_drop_order::run_lint(tcx, def, &body);
+
     let promoted = promote_pass.promoted_fragments.into_inner();
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))
 }
@@ -492,7 +494,6 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
     }
 
     let (body, _) = tcx.mir_promoted(def);
-    lint_tail_expr_drop_order::run_lint(tcx, def, &body.borrow());
     let mut body = body.steal();
 
     if let Some(error_reported) = tainted_by_errors {
diff --git a/tests/ui/drop/lint-tail-expr-drop-order.rs b/tests/ui/drop/lint-tail-expr-drop-order.rs
index cc7c081740d..b2a5db0d871 100644
--- a/tests/ui/drop/lint-tail-expr-drop-order.rs
+++ b/tests/ui/drop/lint-tail-expr-drop-order.rs
@@ -2,7 +2,6 @@
 // This lint is to capture potential change in program semantics
 // due to implementation of RFC 3606 <https://github.com/rust-lang/rfcs/pull/3606>
 //@ edition: 2021
-//@ build-fail
 
 #![deny(tail_expr_drop_order)] //~ NOTE: the lint level is defined here
 #![allow(dropping_copy_types)]
diff --git a/tests/ui/drop/lint-tail-expr-drop-order.stderr b/tests/ui/drop/lint-tail-expr-drop-order.stderr
index b6cf5f40b6e..92afae5af67 100644
--- a/tests/ui/drop/lint-tail-expr-drop-order.stderr
+++ b/tests/ui/drop/lint-tail-expr-drop-order.stderr
@@ -1,5 +1,5 @@
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:42:15
+  --> $DIR/lint-tail-expr-drop-order.rs:41:15
    |
 LL |     let x = LoudDropper;
    |         -
@@ -19,14 +19,14 @@ LL | }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
 LL | | }
    | |_^
 note: `x` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
@@ -34,13 +34,13 @@ LL | | }
    | |_^
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 note: the lint level is defined here
-  --> $DIR/lint-tail-expr-drop-order.rs:7:9
+  --> $DIR/lint-tail-expr-drop-order.rs:6:9
    |
 LL | #![deny(tail_expr_drop_order)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:67:19
+  --> $DIR/lint-tail-expr-drop-order.rs:66:19
    |
 LL |         let x = LoudDropper;
    |             -
@@ -60,14 +60,14 @@ LL |     }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
 LL | | }
    | |_^
 note: `x` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
@@ -76,7 +76,7 @@ LL | | }
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:94:7
+  --> $DIR/lint-tail-expr-drop-order.rs:93:7
    |
 LL |     let x = LoudDropper;
    |         -
@@ -96,14 +96,14 @@ LL | }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
 LL | | }
    | |_^
 note: `x` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
@@ -112,7 +112,7 @@ LL | | }
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:147:5
+  --> $DIR/lint-tail-expr-drop-order.rs:146:5
    |
 LL |     let future = f();
    |         ------
@@ -132,14 +132,14 @@ LL | }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
 LL | | }
    | |_^
 note: `future` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
@@ -148,7 +148,7 @@ LL | | }
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:164:14
+  --> $DIR/lint-tail-expr-drop-order.rs:163:14
    |
 LL |     let x = T::default();
    |         -
@@ -170,7 +170,7 @@ LL | }
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:178:5
+  --> $DIR/lint-tail-expr-drop-order.rs:177:5
    |
 LL |     let x: Result<LoudDropper, ()> = Ok(LoudDropper);
    |         -
@@ -190,14 +190,14 @@ LL | }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
 LL | | }
    | |_^
 note: `x` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
@@ -206,7 +206,7 @@ LL | | }
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:222:5
+  --> $DIR/lint-tail-expr-drop-order.rs:221:5
    |
 LL |     let x = LoudDropper2;
    |         -
@@ -226,7 +226,7 @@ LL | }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:195:5
+  --> $DIR/lint-tail-expr-drop-order.rs:194:5
    |
 LL | /     impl Drop for LoudDropper3 {
 LL | |
@@ -236,7 +236,7 @@ LL | |         }
 LL | |     }
    | |_____^
 note: `x` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:207:5
+  --> $DIR/lint-tail-expr-drop-order.rs:206:5
    |
 LL | /     impl Drop for LoudDropper2 {
 LL | |
@@ -248,7 +248,7 @@ LL | |     }
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order.rs:235:13
+  --> $DIR/lint-tail-expr-drop-order.rs:234:13
    |
 LL |             LoudDropper.get()
    |             ^^^^^^^^^^^
@@ -268,14 +268,14 @@ LL |     ));
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#1` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
 LL | | }
    | |_^
 note: `_x` invokes this custom destructor
-  --> $DIR/lint-tail-expr-drop-order.rs:11:1
+  --> $DIR/lint-tail-expr-drop-order.rs:10:1
    |
 LL | / impl Drop for LoudDropper {
 ...  |
diff --git a/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.rs b/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.rs
index 8d85cee19fd..5b9c24978b4 100644
--- a/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.rs
+++ b/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.rs
@@ -1,5 +1,4 @@
 //@ edition: 2021
-//@ build-fail
 
 // Make sure we don't ICE when emitting the "lint" drop statement
 // used for tail_expr_drop_order.
diff --git a/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.stderr b/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.stderr
index d04abebe144..d98100bc1b0 100644
--- a/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.stderr
+++ b/tests/ui/drop/tail_expr_drop_order-on-coroutine-unwind.stderr
@@ -1,5 +1,5 @@
 error: relative drop order changing in Rust 2024
-  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:20:15
+  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:19:15
    |
 LL |         match func().await {
    |               ^^^^^^^-----
@@ -21,21 +21,21 @@ LL |     }
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 note: `#2` invokes this custom destructor
-  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:10:1
+  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:9:1
    |
 LL | / impl std::ops::Drop for Drop {
 LL | |     fn drop(&mut self) {}
 LL | | }
    | |_^
 note: `#1` invokes this custom destructor
-  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:10:1
+  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:9:1
    |
 LL | / impl std::ops::Drop for Drop {
 LL | |     fn drop(&mut self) {}
 LL | | }
    | |_^
 note: `e` invokes this custom destructor
-  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:10:1
+  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:9:1
    |
 LL | / impl std::ops::Drop for Drop {
 LL | |     fn drop(&mut self) {}
@@ -43,7 +43,7 @@ LL | | }
    | |_^
    = note: most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages
 note: the lint level is defined here
-  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:7:9
+  --> $DIR/tail_expr_drop_order-on-coroutine-unwind.rs:6:9
    |
 LL | #![deny(tail_expr_drop_order)]
    |         ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/error-codes/E0452.rs b/tests/ui/error-codes/E0452.rs
index 5066cd99be9..4e5a6c93014 100644
--- a/tests/ui/error-codes/E0452.rs
+++ b/tests/ui/error-codes/E0452.rs
@@ -2,5 +2,7 @@
                     //~| ERROR E0452
                     //~| ERROR E0452
                     //~| ERROR E0452
+                    //~| ERROR E0452
+                    //~| ERROR E0452
 fn main() {
 }
diff --git a/tests/ui/error-codes/E0452.stderr b/tests/ui/error-codes/E0452.stderr
index 986c135ed89..c20429e363d 100644
--- a/tests/ui/error-codes/E0452.stderr
+++ b/tests/ui/error-codes/E0452.stderr
@@ -28,6 +28,22 @@ LL | #![allow(foo = "")]
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 4 previous errors
+error[E0452]: malformed lint attribute input
+  --> $DIR/E0452.rs:1:10
+   |
+LL | #![allow(foo = "")]
+   |          ^^^^^^^^ bad attribute argument
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0452]: malformed lint attribute input
+  --> $DIR/E0452.rs:1:10
+   |
+LL | #![allow(foo = "")]
+   |          ^^^^^^^^ bad attribute argument
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0452`.
diff --git a/tests/ui/lint/command-line-register-unknown-lint-tool.stderr b/tests/ui/lint/command-line-register-unknown-lint-tool.stderr
index 65aa1962830..7bdee5ec9a4 100644
--- a/tests/ui/lint/command-line-register-unknown-lint-tool.stderr
+++ b/tests/ui/lint/command-line-register-unknown-lint-tool.stderr
@@ -7,6 +7,11 @@ error[E0602]: unknown lint tool: `unknown_tool`
    = note: requested on the command line with `-A unknown_tool::foo`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 2 previous errors
+error[E0602]: unknown lint tool: `unknown_tool`
+   |
+   = note: requested on the command line with `-A unknown_tool::foo`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0602`.
diff --git a/tests/ui/lint/force-warn/warnings-lint-group.stderr b/tests/ui/lint/force-warn/warnings-lint-group.stderr
index 3e73269a233..a303bb573f9 100644
--- a/tests/ui/lint/force-warn/warnings-lint-group.stderr
+++ b/tests/ui/lint/force-warn/warnings-lint-group.stderr
@@ -4,6 +4,10 @@ error[E0602]: `warnings` lint group is not supported with ´--force-warn´
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 2 previous errors
+error[E0602]: `warnings` lint group is not supported with ´--force-warn´
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0602`.
diff --git a/tests/ui/lint/lint-malformed.rs b/tests/ui/lint/lint-malformed.rs
index 188e702f98b..cf5570753d8 100644
--- a/tests/ui/lint/lint-malformed.rs
+++ b/tests/ui/lint/lint-malformed.rs
@@ -3,4 +3,6 @@
                        //~| ERROR malformed lint attribute
                        //~| ERROR malformed lint attribute
                        //~| ERROR malformed lint attribute
+                       //~| ERROR malformed lint attribute
+                       //~| ERROR malformed lint attribute
 fn main() { }
diff --git a/tests/ui/lint/lint-malformed.stderr b/tests/ui/lint/lint-malformed.stderr
index 2c9f045de71..0bdcc293b65 100644
--- a/tests/ui/lint/lint-malformed.stderr
+++ b/tests/ui/lint/lint-malformed.stderr
@@ -34,6 +34,22 @@ LL | #![allow(bar = "baz")]
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 5 previous errors
+error[E0452]: malformed lint attribute input
+  --> $DIR/lint-malformed.rs:2:10
+   |
+LL | #![allow(bar = "baz")]
+   |          ^^^^^^^^^^^ bad attribute argument
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0452]: malformed lint attribute input
+  --> $DIR/lint-malformed.rs:2:10
+   |
+LL | #![allow(bar = "baz")]
+   |          ^^^^^^^^^^^ bad attribute argument
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0452`.
diff --git a/tests/ui/tool-attributes/unknown-lint-tool-name.rs b/tests/ui/tool-attributes/unknown-lint-tool-name.rs
index cd5d2f028af..59fc56d820e 100644
--- a/tests/ui/tool-attributes/unknown-lint-tool-name.rs
+++ b/tests/ui/tool-attributes/unknown-lint-tool-name.rs
@@ -1,5 +1,6 @@
 #![deny(foo::bar)] //~ ERROR unknown tool name `foo` found in scoped lint: `foo::bar`
                    //~| ERROR unknown tool name `foo` found in scoped lint: `foo::bar`
+                   //~| ERROR unknown tool name `foo` found in scoped lint: `foo::bar`
 
 #[allow(foo::bar)] //~ ERROR unknown tool name `foo` found in scoped lint: `foo::bar`
                    //~| ERROR unknown tool name `foo` found in scoped lint: `foo::bar`
diff --git a/tests/ui/tool-attributes/unknown-lint-tool-name.stderr b/tests/ui/tool-attributes/unknown-lint-tool-name.stderr
index 72731ab1e3d..5d99777a14a 100644
--- a/tests/ui/tool-attributes/unknown-lint-tool-name.stderr
+++ b/tests/ui/tool-attributes/unknown-lint-tool-name.stderr
@@ -7,7 +7,7 @@ LL | #![deny(foo::bar)]
    = help: add `#![register_tool(foo)]` to the crate root
 
 error[E0710]: unknown tool name `foo` found in scoped lint: `foo::bar`
-  --> $DIR/unknown-lint-tool-name.rs:4:9
+  --> $DIR/unknown-lint-tool-name.rs:5:9
    |
 LL | #[allow(foo::bar)]
    |         ^^^
@@ -24,7 +24,7 @@ LL | #![deny(foo::bar)]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0710]: unknown tool name `foo` found in scoped lint: `foo::bar`
-  --> $DIR/unknown-lint-tool-name.rs:4:9
+  --> $DIR/unknown-lint-tool-name.rs:5:9
    |
 LL | #[allow(foo::bar)]
    |         ^^^
@@ -32,6 +32,15 @@ LL | #[allow(foo::bar)]
    = help: add `#![register_tool(foo)]` to the crate root
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 4 previous errors
+error[E0710]: unknown tool name `foo` found in scoped lint: `foo::bar`
+  --> $DIR/unknown-lint-tool-name.rs:1:9
+   |
+LL | #![deny(foo::bar)]
+   |         ^^^
+   |
+   = help: add `#![register_tool(foo)]` to the crate root
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0710`.
-- 
cgit 1.4.1-3-g733a5


From 92f93f6d1127cd8f2438474ebe4620231f5d5473 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 23 Dec 2024 21:49:48 +0000
Subject: Note def descr in NonConstFunctionCall

---
 compiler/rustc_const_eval/messages.ftl                   |  2 +-
 compiler/rustc_const_eval/src/check_consts/ops.rs        |  1 +
 compiler/rustc_const_eval/src/errors.rs                  |  1 +
 compiler/rustc_error_codes/src/error_codes/E0015.md      |  2 +-
 .../const-super-trait-nightly-disabled.stderr            |  2 +-
 .../const-super-trait-nightly-enabled.stderr             |  2 +-
 .../const-super-trait-stable-disabled.stderr             |  2 +-
 .../const-super-trait-stable-enabled.stderr              |  2 +-
 tests/ui/asm/non-const.rs                                |  2 +-
 tests/ui/asm/non-const.stderr                            |  2 +-
 tests/ui/borrowck/issue-64453.rs                         |  2 +-
 tests/ui/borrowck/issue-64453.stderr                     |  2 +-
 tests/ui/const-generics/nested-type.full.stderr          |  2 +-
 tests/ui/const-generics/nested-type.min.stderr           |  2 +-
 tests/ui/const-generics/nested-type.rs                   |  2 +-
 tests/ui/consts/const-call.rs                            |  2 +-
 tests/ui/consts/const-call.stderr                        |  2 +-
 tests/ui/consts/const-eval/format.rs                     |  6 +++---
 tests/ui/consts/const-eval/format.stderr                 |  6 +++---
 tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr |  2 +-
 .../const-extern-fn/const-extern-fn-call-extern-fn.rs    |  4 ++--
 .../const-extern-fn-call-extern-fn.stderr                |  4 ++--
 tests/ui/consts/const-fn-not-safe-for-const.stderr       |  2 +-
 tests/ui/consts/control-flow/issue-46843.rs              |  2 +-
 tests/ui/consts/control-flow/issue-46843.stderr          |  2 +-
 tests/ui/consts/issue-16538.stderr                       |  2 +-
 tests/ui/consts/issue-32829-2.rs                         |  6 +++---
 tests/ui/consts/issue-32829-2.stderr                     |  6 +++---
 tests/ui/consts/issue-43105.rs                           |  2 +-
 tests/ui/consts/issue-43105.stderr                       |  2 +-
 tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs    |  2 +-
 .../ui/consts/min_const_fn/bad_const_fn_body_ice.stderr  |  2 +-
 tests/ui/consts/mir_check_nonconst.rs                    |  2 +-
 tests/ui/consts/mir_check_nonconst.stderr                |  2 +-
 tests/ui/error-codes/E0010-teach.rs                      |  2 +-
 tests/ui/error-codes/E0010-teach.stderr                  |  2 +-
 tests/ui/error-codes/E0010.rs                            |  2 +-
 tests/ui/error-codes/E0010.stderr                        |  2 +-
 tests/ui/error-codes/E0015.rs                            |  2 +-
 tests/ui/error-codes/E0015.stderr                        |  2 +-
 tests/ui/explicit-tail-calls/constck.rs                  |  4 ++--
 tests/ui/explicit-tail-calls/constck.stderr              |  4 ++--
 tests/ui/issues/issue-7364.rs                            |  2 +-
 tests/ui/issues/issue-7364.stderr                        |  2 +-
 tests/ui/resolve/issue-39559-2.stderr                    |  4 ++--
 tests/ui/static/static-mut-not-constant.rs               |  2 +-
 tests/ui/static/static-mut-not-constant.stderr           |  2 +-
 tests/ui/static/static-vec-repeat-not-constant.stderr    |  2 +-
 tests/ui/statics/check-values-constraints.rs             |  2 +-
 tests/ui/statics/check-values-constraints.stderr         | 16 ++++++++--------
 .../const-traits/call-const-trait-method-pass.stderr     |  2 +-
 tests/ui/traits/const-traits/call-generic-in-impl.stderr |  2 +-
 .../traits/const-traits/call-generic-method-chain.stderr |  2 +-
 .../const-traits/call-generic-method-dup-bound.stderr    |  2 +-
 .../traits/const-traits/call-generic-method-pass.stderr  |  2 +-
 .../traits/const-traits/const-check-fns-in-const-impl.rs |  2 +-
 .../const-traits/const-check-fns-in-const-impl.stderr    |  2 +-
 .../const_closure-const_trait_impl-ice-113381.rs         |  2 +-
 .../const_closure-const_trait_impl-ice-113381.stderr     |  2 +-
 .../const_derives/derive-const-non-const-type.stderr     |  2 +-
 .../const-traits/const_derives/derive-const-use.stderr   |  6 +++---
 .../const-traits/ice-112822-expected-type-for-param.rs   |  2 +-
 .../ice-112822-expected-type-for-param.stderr            |  2 +-
 .../const-traits/inline-incorrect-early-bound-in-ctfe.rs |  2 +-
 .../inline-incorrect-early-bound-in-ctfe.stderr          |  2 +-
 tests/ui/traits/const-traits/issue-79450.rs              |  2 +-
 tests/ui/traits/const-traits/issue-79450.stderr          |  2 +-
 tests/ui/traits/const-traits/issue-88155.rs              |  2 +-
 tests/ui/traits/const-traits/issue-88155.stderr          |  2 +-
 .../non-const-op-const-closure-non-const-outer.rs        |  2 +-
 .../non-const-op-const-closure-non-const-outer.stderr    |  2 +-
 .../const-traits/non-const-op-in-closure-in-const.stderr |  2 +-
 tests/ui/traits/const-traits/std-impl-gate.gated.stderr  |  2 +-
 tests/ui/traits/const-traits/std-impl-gate.rs            |  2 +-
 tests/ui/traits/const-traits/std-impl-gate.stock.stderr  |  2 +-
 .../ui/traits/const-traits/super-traits-fail-2.nn.stderr |  2 +-
 .../ui/traits/const-traits/super-traits-fail-2.ny.stderr |  2 +-
 tests/ui/traits/const-traits/super-traits-fail-2.rs      |  2 +-
 .../traits/const-traits/super-traits-fail-3.nnn.stderr   |  2 +-
 .../traits/const-traits/super-traits-fail-3.nny.stderr   |  2 +-
 tests/ui/traits/const-traits/super-traits-fail-3.rs      |  2 +-
 .../traits/const-traits/super-traits-fail-3.ynn.stderr   |  2 +-
 .../traits/const-traits/super-traits-fail-3.yny.stderr   |  2 +-
 tests/ui/typeck/typeck_type_placeholder_item.stderr      |  4 ++--
 84 files changed, 107 insertions(+), 105 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index c31c94495d0..0c2242b810b 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -253,7 +253,7 @@ const_eval_non_const_fmt_macro_call =
     cannot call non-const formatting macro in {const_eval_const_context}s
 
 const_eval_non_const_fn_call =
-    cannot call non-const fn `{$def_path_str}` in {const_eval_const_context}s
+    cannot call non-const {$def_descr} `{$def_path_str}` in {const_eval_const_context}s
 
 const_eval_non_const_impl =
     impl defined here, but it is not `const`
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
index afb7900c4b0..ebd680ac28a 100644
--- a/compiler/rustc_const_eval/src/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -304,6 +304,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
             }
             _ => ccx.dcx().create_err(errors::NonConstFnCall {
                 span,
+                def_descr: ccx.tcx.def_descr(callee),
                 def_path_str: ccx.tcx.def_path_str_with_args(callee, args),
                 kind: ccx.const_kind(),
             }),
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 80236ee05b7..57534540019 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -192,6 +192,7 @@ pub(crate) struct NonConstFnCall {
     #[primary_span]
     pub span: Span,
     pub def_path_str: String,
+    pub def_descr: &'static str,
     pub kind: ConstContext,
 }
 
diff --git a/compiler/rustc_error_codes/src/error_codes/E0015.md b/compiler/rustc_error_codes/src/error_codes/E0015.md
index ac78f66adad..244cc476243 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0015.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0015.md
@@ -7,7 +7,7 @@ fn create_some() -> Option<u8> {
     Some(1)
 }
 
-// error: cannot call non-const fn `create_some` in constants
+// error: cannot call non-const function `create_some` in constants
 const FOO: Option<u8> = create_some();
 ```
 
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
index 596f7c510be..82f57864d85 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
@@ -52,7 +52,7 @@ help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> const-super-trait.rs:10:7
    |
 LL |     x.a();
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
index 7235278d1bd..8f4c78ccfa4 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
@@ -32,7 +32,7 @@ help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> const-super-trait.rs:10:7
    |
 LL |     x.a();
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
index eacdaf5e369..b7cd7097f44 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
@@ -50,7 +50,7 @@ note: `Bar` can't be used with `~const` because it isn't annotated with `#[const
 7 | trait Bar: ~const Foo {}
   | ^^^^^^^^^^^^^^^^^^^^^
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> const-super-trait.rs:10:7
    |
 10 |     x.a();
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
index 9ddec6e422c..4c59d870671 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
@@ -40,7 +40,7 @@ note: `Bar` can't be used with `~const` because it isn't annotated with `#[const
 7 | trait Bar: ~const Foo {}
   | ^^^^^^^^^^^^^^^^^^^^^
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> const-super-trait.rs:10:7
    |
 10 |     x.a();
diff --git a/tests/ui/asm/non-const.rs b/tests/ui/asm/non-const.rs
index 63c46563226..dc9317b90b1 100644
--- a/tests/ui/asm/non-const.rs
+++ b/tests/ui/asm/non-const.rs
@@ -8,4 +8,4 @@ fn main() {}
 fn non_const_fn(x: i32) -> i32 { x }
 
 global_asm!("/* {} */", const non_const_fn(0));
-//~^ERROR: cannot call non-const fn
+//~^ERROR: cannot call non-const function
diff --git a/tests/ui/asm/non-const.stderr b/tests/ui/asm/non-const.stderr
index 5fae2ac9843..eac4fe841bf 100644
--- a/tests/ui/asm/non-const.stderr
+++ b/tests/ui/asm/non-const.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `non_const_fn` in constants
+error[E0015]: cannot call non-const function `non_const_fn` in constants
   --> $DIR/non-const.rs:10:31
    |
 LL | global_asm!("/* {} */", const non_const_fn(0));
diff --git a/tests/ui/borrowck/issue-64453.rs b/tests/ui/borrowck/issue-64453.rs
index 5f1f35d6ca9..587bf0e80f5 100644
--- a/tests/ui/borrowck/issue-64453.rs
+++ b/tests/ui/borrowck/issue-64453.rs
@@ -2,7 +2,7 @@ struct Project;
 struct Value;
 
 static settings_dir: String = format!("");
-//~^ ERROR cannot call non-const fn
+//~^ ERROR cannot call non-const function
 
 fn from_string(_: String) -> Value {
     Value
diff --git a/tests/ui/borrowck/issue-64453.stderr b/tests/ui/borrowck/issue-64453.stderr
index 98b05ead649..8ec9a10f09f 100644
--- a/tests/ui/borrowck/issue-64453.stderr
+++ b/tests/ui/borrowck/issue-64453.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `format` in statics
+error[E0015]: cannot call non-const function `format` in statics
   --> $DIR/issue-64453.rs:4:31
    |
 LL | static settings_dir: String = format!("");
diff --git a/tests/ui/const-generics/nested-type.full.stderr b/tests/ui/const-generics/nested-type.full.stderr
index 04dc84ea3cf..e5a1f230380 100644
--- a/tests/ui/const-generics/nested-type.full.stderr
+++ b/tests/ui/const-generics/nested-type.full.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `Foo::{constant#0}::Foo::<17>::value` in constants
+error[E0015]: cannot call non-const associated function `Foo::{constant#0}::Foo::<17>::value` in constants
   --> $DIR/nested-type.rs:15:5
    |
 LL |     Foo::<17>::value()
diff --git a/tests/ui/const-generics/nested-type.min.stderr b/tests/ui/const-generics/nested-type.min.stderr
index cdc0b9807d9..8282acd4ea7 100644
--- a/tests/ui/const-generics/nested-type.min.stderr
+++ b/tests/ui/const-generics/nested-type.min.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `Foo::{constant#0}::Foo::<17>::value` in constants
+error[E0015]: cannot call non-const associated function `Foo::{constant#0}::Foo::<17>::value` in constants
   --> $DIR/nested-type.rs:15:5
    |
 LL |     Foo::<17>::value()
diff --git a/tests/ui/const-generics/nested-type.rs b/tests/ui/const-generics/nested-type.rs
index a9d106237b3..ddd84d472bf 100644
--- a/tests/ui/const-generics/nested-type.rs
+++ b/tests/ui/const-generics/nested-type.rs
@@ -13,7 +13,7 @@ struct Foo<const N: [u8; {
     }
 
     Foo::<17>::value()
-    //~^ ERROR cannot call non-const fn
+    //~^ ERROR cannot call non-const associated function
 }]>;
 //[min]~^^^^^^^^^^^^ ERROR `[u8; {
 
diff --git a/tests/ui/consts/const-call.rs b/tests/ui/consts/const-call.rs
index 28e89559fe5..851b66f7623 100644
--- a/tests/ui/consts/const-call.rs
+++ b/tests/ui/consts/const-call.rs
@@ -4,5 +4,5 @@ fn f(x: usize) -> usize {
 
 fn main() {
     let _ = [0; f(2)];
-    //~^ ERROR cannot call non-const fn
+    //~^ ERROR cannot call non-const function
 }
diff --git a/tests/ui/consts/const-call.stderr b/tests/ui/consts/const-call.stderr
index 4e7098a5c8f..b9dcf5addb5 100644
--- a/tests/ui/consts/const-call.stderr
+++ b/tests/ui/consts/const-call.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `f` in constants
+error[E0015]: cannot call non-const function `f` in constants
   --> $DIR/const-call.rs:6:17
    |
 LL |     let _ = [0; f(2)];
diff --git a/tests/ui/consts/const-eval/format.rs b/tests/ui/consts/const-eval/format.rs
index b12df824a33..e56d15e935b 100644
--- a/tests/ui/consts/const-eval/format.rs
+++ b/tests/ui/consts/const-eval/format.rs
@@ -1,14 +1,14 @@
 const fn failure() {
     panic!("{:?}", 0);
     //~^ ERROR cannot call non-const formatting macro in constant functions
-    //~| ERROR cannot call non-const fn `Arguments::<'_>::new_v1::<1, 1>` in constant functions
+    //~| ERROR cannot call non-const associated function `Arguments::<'_>::new_v1::<1, 1>` in constant functions
 }
 
 const fn print() {
     println!("{:?}", 0);
     //~^ ERROR cannot call non-const formatting macro in constant functions
-    //~| ERROR cannot call non-const fn `Arguments::<'_>::new_v1::<2, 1>` in constant functions
-    //~| ERROR cannot call non-const fn `_print` in constant functions
+    //~| ERROR cannot call non-const associated function `Arguments::<'_>::new_v1::<2, 1>` in constant functions
+    //~| ERROR cannot call non-const function `_print` in constant functions
 }
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/format.stderr b/tests/ui/consts/const-eval/format.stderr
index ce3f9f2190e..25ed44e0f33 100644
--- a/tests/ui/consts/const-eval/format.stderr
+++ b/tests/ui/consts/const-eval/format.stderr
@@ -7,7 +7,7 @@ LL |     panic!("{:?}", 0);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `$crate::const_format_args` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `Arguments::<'_>::new_v1::<1, 1>` in constant functions
+error[E0015]: cannot call non-const associated function `Arguments::<'_>::new_v1::<1, 1>` in constant functions
   --> $DIR/format.rs:2:5
    |
 LL |     panic!("{:?}", 0);
@@ -25,7 +25,7 @@ LL |     println!("{:?}", 0);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `Arguments::<'_>::new_v1::<2, 1>` in constant functions
+error[E0015]: cannot call non-const associated function `Arguments::<'_>::new_v1::<2, 1>` in constant functions
   --> $DIR/format.rs:8:5
    |
 LL |     println!("{:?}", 0);
@@ -34,7 +34,7 @@ LL |     println!("{:?}", 0);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `_print` in constant functions
+error[E0015]: cannot call non-const function `_print` in constant functions
   --> $DIR/format.rs:8:5
    |
 LL |     println!("{:?}", 0);
diff --git a/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr b/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
index 94aa3ee4d7a..6e428079afe 100644
--- a/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
+++ b/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `core::slice::<impl [()]>::get_unchecked::<std::ops::Range<usize>>` in constants
+error[E0015]: cannot call non-const method `core::slice::<impl [()]>::get_unchecked::<std::ops::Range<usize>>` in constants
   --> $DIR/ub-slice-get-unchecked.rs:7:29
    |
 LL | const B: &[()] = unsafe { A.get_unchecked(3..1) };
diff --git a/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.rs b/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.rs
index 31c15400f84..0b475087d55 100644
--- a/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.rs
+++ b/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.rs
@@ -5,7 +5,7 @@ extern "C" {
 const extern "C" fn bar() {
     unsafe {
         regular_in_block();
-        //~^ ERROR: cannot call non-const fn
+        //~^ ERROR: cannot call non-const function
     }
 }
 
@@ -14,7 +14,7 @@ extern "C" fn regular() {}
 const extern "C" fn foo() {
     unsafe {
         regular();
-        //~^ ERROR: cannot call non-const fn
+        //~^ ERROR: cannot call non-const function
     }
 }
 
diff --git a/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr b/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr
index 5d37f524e03..1fa881cf42b 100644
--- a/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr
+++ b/tests/ui/consts/const-extern-fn/const-extern-fn-call-extern-fn.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `regular_in_block` in constant functions
+error[E0015]: cannot call non-const function `regular_in_block` in constant functions
   --> $DIR/const-extern-fn-call-extern-fn.rs:7:9
    |
 LL |         regular_in_block();
@@ -6,7 +6,7 @@ LL |         regular_in_block();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `regular` in constant functions
+error[E0015]: cannot call non-const function `regular` in constant functions
   --> $DIR/const-extern-fn-call-extern-fn.rs:16:9
    |
 LL |         regular();
diff --git a/tests/ui/consts/const-fn-not-safe-for-const.stderr b/tests/ui/consts/const-fn-not-safe-for-const.stderr
index 674e05a0ba9..e8f0566e73d 100644
--- a/tests/ui/consts/const-fn-not-safe-for-const.stderr
+++ b/tests/ui/consts/const-fn-not-safe-for-const.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `random` in constant functions
+error[E0015]: cannot call non-const function `random` in constant functions
   --> $DIR/const-fn-not-safe-for-const.rs:14:5
    |
 LL |     random()
diff --git a/tests/ui/consts/control-flow/issue-46843.rs b/tests/ui/consts/control-flow/issue-46843.rs
index ddddc8505c6..fd6366d3c18 100644
--- a/tests/ui/consts/control-flow/issue-46843.rs
+++ b/tests/ui/consts/control-flow/issue-46843.rs
@@ -8,7 +8,7 @@ fn non_const() -> Thing {
 }
 
 pub const Q: i32 = match non_const() {
-    //~^ ERROR cannot call non-const fn
+    //~^ ERROR cannot call non-const function
     Thing::This => 1,
     Thing::That => 0
 };
diff --git a/tests/ui/consts/control-flow/issue-46843.stderr b/tests/ui/consts/control-flow/issue-46843.stderr
index 69bf78839be..42eb035647c 100644
--- a/tests/ui/consts/control-flow/issue-46843.stderr
+++ b/tests/ui/consts/control-flow/issue-46843.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `non_const` in constants
+error[E0015]: cannot call non-const function `non_const` in constants
   --> $DIR/issue-46843.rs:10:26
    |
 LL | pub const Q: i32 = match non_const() {
diff --git a/tests/ui/consts/issue-16538.stderr b/tests/ui/consts/issue-16538.stderr
index c4f5364b4d7..8bd11541a7d 100644
--- a/tests/ui/consts/issue-16538.stderr
+++ b/tests/ui/consts/issue-16538.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `Y::foo` in statics
+error[E0015]: cannot call non-const function `Y::foo` in statics
   --> $DIR/issue-16538.rs:11:23
    |
 LL | static foo: &Y::X = &*Y::foo(Y::x as *const Y::X);
diff --git a/tests/ui/consts/issue-32829-2.rs b/tests/ui/consts/issue-32829-2.rs
index d70b5a8c4e1..c7ad0979293 100644
--- a/tests/ui/consts/issue-32829-2.rs
+++ b/tests/ui/consts/issue-32829-2.rs
@@ -8,7 +8,7 @@ const bad : u32 = {
 const bad_two : u32 = {
     {
         invalid();
-        //~^ ERROR: cannot call non-const fn `invalid`
+        //~^ ERROR: cannot call non-const function `invalid`
         0
     }
 };
@@ -30,7 +30,7 @@ static bad_four : u32 = {
 static bad_five : u32 = {
     {
         invalid();
-        //~^ ERROR: cannot call non-const fn `invalid`
+        //~^ ERROR: cannot call non-const function `invalid`
         0
     }
 };
@@ -52,7 +52,7 @@ static mut bad_seven : u32 = {
 static mut bad_eight : u32 = {
     {
         invalid();
-        //~^ ERROR: cannot call non-const fn `invalid`
+        //~^ ERROR: cannot call non-const function `invalid`
         0
     }
 };
diff --git a/tests/ui/consts/issue-32829-2.stderr b/tests/ui/consts/issue-32829-2.stderr
index bd0b8c15b55..eedd9d34e55 100644
--- a/tests/ui/consts/issue-32829-2.stderr
+++ b/tests/ui/consts/issue-32829-2.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `invalid` in constants
+error[E0015]: cannot call non-const function `invalid` in constants
   --> $DIR/issue-32829-2.rs:10:9
    |
 LL |         invalid();
@@ -6,7 +6,7 @@ LL |         invalid();
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `invalid` in statics
+error[E0015]: cannot call non-const function `invalid` in statics
   --> $DIR/issue-32829-2.rs:32:9
    |
 LL |         invalid();
@@ -15,7 +15,7 @@ LL |         invalid();
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const fn `invalid` in statics
+error[E0015]: cannot call non-const function `invalid` in statics
   --> $DIR/issue-32829-2.rs:54:9
    |
 LL |         invalid();
diff --git a/tests/ui/consts/issue-43105.rs b/tests/ui/consts/issue-43105.rs
index a4ee34c0532..738b73416e0 100644
--- a/tests/ui/consts/issue-43105.rs
+++ b/tests/ui/consts/issue-43105.rs
@@ -1,7 +1,7 @@
 fn xyz() -> u8 { 42 }
 
 const NUM: u8 = xyz();
-//~^ ERROR cannot call non-const fn
+//~^ ERROR cannot call non-const function
 
 fn main() {
     match 1 {
diff --git a/tests/ui/consts/issue-43105.stderr b/tests/ui/consts/issue-43105.stderr
index 0e08feb58de..c030c0f5fcd 100644
--- a/tests/ui/consts/issue-43105.stderr
+++ b/tests/ui/consts/issue-43105.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `xyz` in constants
+error[E0015]: cannot call non-const function `xyz` in constants
   --> $DIR/issue-43105.rs:3:17
    |
 LL | const NUM: u8 = xyz();
diff --git a/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs b/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs
index 258997597ea..6a6b0e666e1 100644
--- a/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs
+++ b/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs
@@ -1,7 +1,7 @@
 const fn foo(a: i32) -> Vec<i32> {
     vec![1, 2, 3]
     //~^ ERROR allocations are not allowed
-    //~| ERROR cannot call non-const fn
+    //~| ERROR cannot call non-const method
 }
 
 fn main() {}
diff --git a/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.stderr b/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.stderr
index 74234108911..8e52a7aa35e 100644
--- a/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.stderr
+++ b/tests/ui/consts/min_const_fn/bad_const_fn_body_ice.stderr
@@ -6,7 +6,7 @@ LL |     vec![1, 2, 3]
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constant functions
+error[E0015]: cannot call non-const method `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constant functions
   --> $DIR/bad_const_fn_body_ice.rs:2:5
    |
 LL |     vec![1, 2, 3]
diff --git a/tests/ui/consts/mir_check_nonconst.rs b/tests/ui/consts/mir_check_nonconst.rs
index b6f34b922fa..eede36bd6ed 100644
--- a/tests/ui/consts/mir_check_nonconst.rs
+++ b/tests/ui/consts/mir_check_nonconst.rs
@@ -6,6 +6,6 @@ fn bar() -> Foo {
 }
 
 static foo: Foo = bar();
-//~^ ERROR cannot call non-const fn
+//~^ ERROR cannot call non-const function
 
 fn main() {}
diff --git a/tests/ui/consts/mir_check_nonconst.stderr b/tests/ui/consts/mir_check_nonconst.stderr
index 95d64622ad7..e930fa2103d 100644
--- a/tests/ui/consts/mir_check_nonconst.stderr
+++ b/tests/ui/consts/mir_check_nonconst.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `bar` in statics
+error[E0015]: cannot call non-const function `bar` in statics
   --> $DIR/mir_check_nonconst.rs:8:19
    |
 LL | static foo: Foo = bar();
diff --git a/tests/ui/error-codes/E0010-teach.rs b/tests/ui/error-codes/E0010-teach.rs
index 146e68df14a..0eef2478387 100644
--- a/tests/ui/error-codes/E0010-teach.rs
+++ b/tests/ui/error-codes/E0010-teach.rs
@@ -3,5 +3,5 @@
 #![allow(warnings)]
 
 const CON: Vec<i32> = vec![1, 2, 3]; //~ ERROR E0010
-//~| ERROR cannot call non-const fn
+//~| ERROR cannot call non-const method
 fn main() {}
diff --git a/tests/ui/error-codes/E0010-teach.stderr b/tests/ui/error-codes/E0010-teach.stderr
index 37a9892ccbf..82bbe01aef7 100644
--- a/tests/ui/error-codes/E0010-teach.stderr
+++ b/tests/ui/error-codes/E0010-teach.stderr
@@ -7,7 +7,7 @@ LL | const CON: Vec<i32> = vec![1, 2, 3];
    = note: The runtime heap is not yet available at compile-time, so no runtime heap allocations can be created.
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constants
+error[E0015]: cannot call non-const method `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constants
   --> $DIR/E0010-teach.rs:5:23
    |
 LL | const CON: Vec<i32> = vec![1, 2, 3];
diff --git a/tests/ui/error-codes/E0010.rs b/tests/ui/error-codes/E0010.rs
index 11721efffcb..edb96714dd3 100644
--- a/tests/ui/error-codes/E0010.rs
+++ b/tests/ui/error-codes/E0010.rs
@@ -1,5 +1,5 @@
 #![allow(warnings)]
 
 const CON: Vec<i32> = vec![1, 2, 3]; //~ ERROR E0010
-//~| ERROR cannot call non-const fn
+//~| ERROR cannot call non-const method
 fn main() {}
diff --git a/tests/ui/error-codes/E0010.stderr b/tests/ui/error-codes/E0010.stderr
index 08947222422..87b722b5f65 100644
--- a/tests/ui/error-codes/E0010.stderr
+++ b/tests/ui/error-codes/E0010.stderr
@@ -6,7 +6,7 @@ LL | const CON: Vec<i32> = vec![1, 2, 3];
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constants
+error[E0015]: cannot call non-const method `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constants
   --> $DIR/E0010.rs:3:23
    |
 LL | const CON: Vec<i32> = vec![1, 2, 3];
diff --git a/tests/ui/error-codes/E0015.rs b/tests/ui/error-codes/E0015.rs
index b0211358d81..7a80308d7bb 100644
--- a/tests/ui/error-codes/E0015.rs
+++ b/tests/ui/error-codes/E0015.rs
@@ -3,6 +3,6 @@ fn create_some() -> Option<u8> {
 }
 
 const FOO: Option<u8> = create_some();
-//~^ ERROR cannot call non-const fn `create_some` in constants [E0015]
+//~^ ERROR cannot call non-const function `create_some` in constants [E0015]
 
 fn main() {}
diff --git a/tests/ui/error-codes/E0015.stderr b/tests/ui/error-codes/E0015.stderr
index 9d892a3e098..0c983d28434 100644
--- a/tests/ui/error-codes/E0015.stderr
+++ b/tests/ui/error-codes/E0015.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `create_some` in constants
+error[E0015]: cannot call non-const function `create_some` in constants
   --> $DIR/E0015.rs:5:25
    |
 LL | const FOO: Option<u8> = create_some();
diff --git a/tests/ui/explicit-tail-calls/constck.rs b/tests/ui/explicit-tail-calls/constck.rs
index 36fc3ef6f99..4179fe8caf3 100644
--- a/tests/ui/explicit-tail-calls/constck.rs
+++ b/tests/ui/explicit-tail-calls/constck.rs
@@ -4,14 +4,14 @@
 const fn f() {
     if false {
         become not_const();
-        //~^ error: cannot call non-const fn `not_const` in constant functions
+        //~^ error: cannot call non-const function `not_const` in constant functions
     }
 }
 
 const fn g((): ()) {
     if false {
         become yes_const(not_const());
-        //~^ error: cannot call non-const fn `not_const` in constant functions
+        //~^ error: cannot call non-const function `not_const` in constant functions
     }
 }
 
diff --git a/tests/ui/explicit-tail-calls/constck.stderr b/tests/ui/explicit-tail-calls/constck.stderr
index d9967c45fa0..c223d273b38 100644
--- a/tests/ui/explicit-tail-calls/constck.stderr
+++ b/tests/ui/explicit-tail-calls/constck.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `not_const` in constant functions
+error[E0015]: cannot call non-const function `not_const` in constant functions
   --> $DIR/constck.rs:6:16
    |
 LL |         become not_const();
@@ -6,7 +6,7 @@ LL |         become not_const();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `not_const` in constant functions
+error[E0015]: cannot call non-const function `not_const` in constant functions
   --> $DIR/constck.rs:13:26
    |
 LL |         become yes_const(not_const());
diff --git a/tests/ui/issues/issue-7364.rs b/tests/ui/issues/issue-7364.rs
index 0608f902fde..4ce9beb68cd 100644
--- a/tests/ui/issues/issue-7364.rs
+++ b/tests/ui/issues/issue-7364.rs
@@ -3,6 +3,6 @@ use std::cell::RefCell;
 // Regression test for issue 7364
 static boxed: Box<RefCell<isize>> = Box::new(RefCell::new(0));
 //~^ ERROR `RefCell<isize>` cannot be shared between threads safely [E0277]
-//~| ERROR cannot call non-const fn
+//~| ERROR cannot call non-const associated function
 
 fn main() { }
diff --git a/tests/ui/issues/issue-7364.stderr b/tests/ui/issues/issue-7364.stderr
index 65ec1d75053..a47a90c90ce 100644
--- a/tests/ui/issues/issue-7364.stderr
+++ b/tests/ui/issues/issue-7364.stderr
@@ -11,7 +11,7 @@ note: required because it appears within the type `Box<RefCell<isize>>`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
    = note: shared static variables must have a type that implements `Sync`
 
-error[E0015]: cannot call non-const fn `Box::<RefCell<isize>>::new` in statics
+error[E0015]: cannot call non-const associated function `Box::<RefCell<isize>>::new` in statics
   --> $DIR/issue-7364.rs:4:37
    |
 LL | static boxed: Box<RefCell<isize>> = Box::new(RefCell::new(0));
diff --git a/tests/ui/resolve/issue-39559-2.stderr b/tests/ui/resolve/issue-39559-2.stderr
index ea27e7bd250..f6e6917d01e 100644
--- a/tests/ui/resolve/issue-39559-2.stderr
+++ b/tests/ui/resolve/issue-39559-2.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `<Dim3 as Dim>::dim` in constants
+error[E0015]: cannot call non-const associated function `<Dim3 as Dim>::dim` in constants
   --> $DIR/issue-39559-2.rs:14:24
    |
 LL |     let array: [usize; Dim3::dim()]
@@ -6,7 +6,7 @@ LL |     let array: [usize; Dim3::dim()]
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `<Dim3 as Dim>::dim` in constants
+error[E0015]: cannot call non-const associated function `<Dim3 as Dim>::dim` in constants
   --> $DIR/issue-39559-2.rs:16:15
    |
 LL |         = [0; Dim3::dim()];
diff --git a/tests/ui/static/static-mut-not-constant.rs b/tests/ui/static/static-mut-not-constant.rs
index d501e5c2956..3830b468287 100644
--- a/tests/ui/static/static-mut-not-constant.rs
+++ b/tests/ui/static/static-mut-not-constant.rs
@@ -1,4 +1,4 @@
 static mut a: Box<isize> = Box::new(3);
-//~^ ERROR cannot call non-const fn
+//~^ ERROR cannot call non-const associated function
 
 fn main() {}
diff --git a/tests/ui/static/static-mut-not-constant.stderr b/tests/ui/static/static-mut-not-constant.stderr
index 46dc175cb29..f28ea0b1689 100644
--- a/tests/ui/static/static-mut-not-constant.stderr
+++ b/tests/ui/static/static-mut-not-constant.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `Box::<isize>::new` in statics
+error[E0015]: cannot call non-const associated function `Box::<isize>::new` in statics
   --> $DIR/static-mut-not-constant.rs:1:28
    |
 LL | static mut a: Box<isize> = Box::new(3);
diff --git a/tests/ui/static/static-vec-repeat-not-constant.stderr b/tests/ui/static/static-vec-repeat-not-constant.stderr
index a3b930323d5..e6ff199ae01 100644
--- a/tests/ui/static/static-vec-repeat-not-constant.stderr
+++ b/tests/ui/static/static-vec-repeat-not-constant.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `foo` in statics
+error[E0015]: cannot call non-const function `foo` in statics
   --> $DIR/static-vec-repeat-not-constant.rs:3:25
    |
 LL | static a: [isize; 2] = [foo(); 2];
diff --git a/tests/ui/statics/check-values-constraints.rs b/tests/ui/statics/check-values-constraints.rs
index 005a7798895..9df76b5c149 100644
--- a/tests/ui/statics/check-values-constraints.rs
+++ b/tests/ui/statics/check-values-constraints.rs
@@ -89,7 +89,7 @@ static mut STATIC13: SafeStruct =
 
 static mut STATIC14: SafeStruct = SafeStruct {
     field1: SafeEnum::Variant1,
-    field2: SafeEnum::Variant4("str".to_string()), //~ ERROR cannot call non-const fn
+    field2: SafeEnum::Variant4("str".to_string()), //~ ERROR cannot call non-const method
 };
 
 static STATIC15: &'static [Vec<MyOwned>] = &[
diff --git a/tests/ui/statics/check-values-constraints.stderr b/tests/ui/statics/check-values-constraints.stderr
index b4ee34530d3..eb2d37d297e 100644
--- a/tests/ui/statics/check-values-constraints.stderr
+++ b/tests/ui/statics/check-values-constraints.stderr
@@ -19,7 +19,7 @@ LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:81:33
    |
 LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
@@ -29,7 +29,7 @@ LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `<str as ToString>::to_string` in statics
+error[E0015]: cannot call non-const method `<str as ToString>::to_string` in statics
   --> $DIR/check-values-constraints.rs:92:38
    |
 LL |     field2: SafeEnum::Variant4("str".to_string()),
@@ -46,7 +46,7 @@ LL |     vec![MyOwned],
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:96:5
    |
 LL |     vec![MyOwned],
@@ -64,7 +64,7 @@ LL |     vec![MyOwned],
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:98:5
    |
 LL |     vec![MyOwned],
@@ -82,7 +82,7 @@ LL |     &vec![MyOwned],
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:103:6
    |
 LL |     &vec![MyOwned],
@@ -100,7 +100,7 @@ LL |     &vec![MyOwned],
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [MyOwned]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:105:6
    |
 LL |     &vec![MyOwned],
@@ -118,7 +118,7 @@ LL | static STATIC19: Vec<isize> = vec![3];
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [isize]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [isize]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:111:31
    |
 LL | static STATIC19: Vec<isize> = vec![3];
@@ -136,7 +136,7 @@ LL |         static x: Vec<isize> = vec![3];
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `slice::<impl [isize]>::into_vec::<std::alloc::Global>` in statics
+error[E0015]: cannot call non-const method `slice::<impl [isize]>::into_vec::<std::alloc::Global>` in statics
   --> $DIR/check-values-constraints.rs:117:32
    |
 LL |         static x: Vec<isize> = vec![3];
diff --git a/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr b/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr
index ef494bde98c..7746f103ac3 100644
--- a/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr
+++ b/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr
@@ -7,7 +7,7 @@ LL | impl const PartialEq for Int {
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error[E0015]: cannot call non-const fn `<Int as PartialEq>::eq` in constant functions
+error[E0015]: cannot call non-const method `<Int as PartialEq>::eq` in constant functions
   --> $DIR/call-const-trait-method-pass.rs:20:15
    |
 LL |         !self.eq(other)
diff --git a/tests/ui/traits/const-traits/call-generic-in-impl.stderr b/tests/ui/traits/const-traits/call-generic-in-impl.stderr
index 58d0997f5a3..a45dfd95b4a 100644
--- a/tests/ui/traits/const-traits/call-generic-in-impl.stderr
+++ b/tests/ui/traits/const-traits/call-generic-in-impl.stderr
@@ -17,7 +17,7 @@ note: `PartialEq` can't be used with `~const` because it isn't annotated with `#
   --> $SRC_DIR/core/src/cmp.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error[E0015]: cannot call non-const fn `<T as PartialEq>::eq` in constant functions
+error[E0015]: cannot call non-const method `<T as PartialEq>::eq` in constant functions
   --> $DIR/call-generic-in-impl.rs:12:9
    |
 LL |         PartialEq::eq(self, other)
diff --git a/tests/ui/traits/const-traits/call-generic-method-chain.stderr b/tests/ui/traits/const-traits/call-generic-method-chain.stderr
index d7a2a186494..40b4f14733f 100644
--- a/tests/ui/traits/const-traits/call-generic-method-chain.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-chain.stderr
@@ -53,7 +53,7 @@ LL |     *t == *t
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `<S as PartialEq>::eq` in constant functions
+error[E0015]: cannot call non-const method `<S as PartialEq>::eq` in constant functions
   --> $DIR/call-generic-method-chain.rs:16:15
    |
 LL |         !self.eq(other)
diff --git a/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr b/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
index 90465d0a5b2..c74f5cf786c 100644
--- a/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
@@ -53,7 +53,7 @@ LL |     *t == *t
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `<S as PartialEq>::eq` in constant functions
+error[E0015]: cannot call non-const method `<S as PartialEq>::eq` in constant functions
   --> $DIR/call-generic-method-dup-bound.rs:14:15
    |
 LL |         !self.eq(other)
diff --git a/tests/ui/traits/const-traits/call-generic-method-pass.stderr b/tests/ui/traits/const-traits/call-generic-method-pass.stderr
index a7626a4e99d..1a33ff5ab45 100644
--- a/tests/ui/traits/const-traits/call-generic-method-pass.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-pass.stderr
@@ -34,7 +34,7 @@ LL |     *t == *t
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `<S as PartialEq>::eq` in constant functions
+error[E0015]: cannot call non-const method `<S as PartialEq>::eq` in constant functions
   --> $DIR/call-generic-method-pass.rs:16:15
    |
 LL |         !self.eq(other)
diff --git a/tests/ui/traits/const-traits/const-check-fns-in-const-impl.rs b/tests/ui/traits/const-traits/const-check-fns-in-const-impl.rs
index 0330ed5ca8b..f7686ea6139 100644
--- a/tests/ui/traits/const-traits/const-check-fns-in-const-impl.rs
+++ b/tests/ui/traits/const-traits/const-check-fns-in-const-impl.rs
@@ -12,7 +12,7 @@ fn non_const() {}
 
 impl const T for S {
     fn foo() { non_const() }
-    //~^ ERROR cannot call non-const fn
+    //~^ ERROR cannot call non-const function
 }
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr b/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr
index d111a9d5639..599a5503b0f 100644
--- a/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr
+++ b/tests/ui/traits/const-traits/const-check-fns-in-const-impl.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `non_const` in constant functions
+error[E0015]: cannot call non-const function `non_const` in constant functions
   --> $DIR/const-check-fns-in-const-impl.rs:14:16
    |
 LL |     fn foo() { non_const() }
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
index 877249135cd..92427039b43 100644
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
+++ b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
@@ -12,6 +12,6 @@ impl Foo for () {
 
 fn main() {
     (const || { (()).foo() })();
-    //~^ ERROR: cannot call non-const fn `<() as Foo>::foo` in constant functions
+    //~^ ERROR: cannot call non-const method `<() as Foo>::foo` in constant functions
     // FIXME(const_trait_impl) this should probably say constant closures
 }
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
index 243e94087bb..c08642ba5a3 100644
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
+++ b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `<() as Foo>::foo` in constant functions
+error[E0015]: cannot call non-const method `<() as Foo>::foo` in constant functions
   --> $DIR/const_closure-const_trait_impl-ice-113381.rs:14:22
    |
 LL |     (const || { (()).foo() })();
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
index 8a6401afcf1..64564de2a0c 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
@@ -8,7 +8,7 @@ LL | #[derive_const(Default)]
    = note: adding a non-const method body in the future would be a breaking change
    = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `<A as Default>::default` in constant functions
+error[E0015]: cannot call non-const associated function `<A as Default>::default` in constant functions
   --> $DIR/derive-const-non-const-type.rs:11:14
    |
 LL | #[derive_const(Default)]
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
index 3b06f4d801a..9ad3b0c1617 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
@@ -48,7 +48,7 @@ LL | #[derive_const(Default, PartialEq)]
    = note: adding a non-const method body in the future would be a breaking change
    = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `<S as Default>::default` in constants
+error[E0015]: cannot call non-const associated function `<S as Default>::default` in constants
   --> $DIR/derive-const-use.rs:18:35
    |
 LL | const _: () = assert!(S((), A) == S::default());
@@ -64,7 +64,7 @@ LL | const _: () = assert!(S((), A) == S::default());
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `<() as Default>::default` in constant functions
+error[E0015]: cannot call non-const associated function `<() as Default>::default` in constant functions
   --> $DIR/derive-const-use.rs:16:14
    |
 LL | #[derive_const(Default, PartialEq)]
@@ -75,7 +75,7 @@ LL | pub struct S((), A);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `<A as Default>::default` in constant functions
+error[E0015]: cannot call non-const associated function `<A as Default>::default` in constant functions
   --> $DIR/derive-const-use.rs:16:18
    |
 LL | #[derive_const(Default, PartialEq)]
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
index 8ff15dd09cc..4cb013b9323 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
@@ -10,7 +10,7 @@ const fn test() -> impl ~const Fn() {
         match sl {
             [first, remainder @ ..] => {
                 assert_eq!(first, &b'f');
-                //~^ ERROR cannot call non-const fn
+                //~^ ERROR cannot call non-const function
                 //~| ERROR cannot call non-const operator
             }
             [] => panic!(),
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
index 280f8807f5f..8d9371bf9f6 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
@@ -46,7 +46,7 @@ LL |                 assert_eq!(first, &b'f');
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const fn `core::panicking::assert_failed::<&u8, &u8>` in constant functions
+error[E0015]: cannot call non-const function `core::panicking::assert_failed::<&u8, &u8>` in constant functions
   --> $DIR/ice-112822-expected-type-for-param.rs:12:17
    |
 LL |                 assert_eq!(first, &b'f');
diff --git a/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.rs b/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.rs
index 86cb38e0bcf..da533d5e321 100644
--- a/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.rs
+++ b/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.rs
@@ -24,7 +24,7 @@ impl Trait for () {
 
 const fn foo() {
     ().foo();
-    //~^ ERROR cannot call non-const fn `<() as Trait>::foo` in constant functions
+    //~^ ERROR cannot call non-const method `<() as Trait>::foo` in constant functions
 }
 
 const UWU: () = foo();
diff --git a/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr b/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr
index c4547f4c43d..ad0829ff05f 100644
--- a/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr
+++ b/tests/ui/traits/const-traits/inline-incorrect-early-bound-in-ctfe.stderr
@@ -7,7 +7,7 @@ LL |     fn foo(self);
 LL |     fn foo<T>(self) {
    |            ^ found 1 type parameter
 
-error[E0015]: cannot call non-const fn `<() as Trait>::foo` in constant functions
+error[E0015]: cannot call non-const method `<() as Trait>::foo` in constant functions
   --> $DIR/inline-incorrect-early-bound-in-ctfe.rs:26:8
    |
 LL |     ().foo();
diff --git a/tests/ui/traits/const-traits/issue-79450.rs b/tests/ui/traits/const-traits/issue-79450.rs
index 521576d27ef..5ba5036ce27 100644
--- a/tests/ui/traits/const-traits/issue-79450.rs
+++ b/tests/ui/traits/const-traits/issue-79450.rs
@@ -6,7 +6,7 @@ trait Tr {
     fn req(&self);
 
     fn prov(&self) {
-        println!("lul"); //~ ERROR: cannot call non-const fn `_print` in constant functions
+        println!("lul"); //~ ERROR: cannot call non-const function `_print` in constant functions
         self.req();
     }
 }
diff --git a/tests/ui/traits/const-traits/issue-79450.stderr b/tests/ui/traits/const-traits/issue-79450.stderr
index 85996c21211..5bdebbbfb03 100644
--- a/tests/ui/traits/const-traits/issue-79450.stderr
+++ b/tests/ui/traits/const-traits/issue-79450.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `_print` in constant functions
+error[E0015]: cannot call non-const function `_print` in constant functions
   --> $DIR/issue-79450.rs:9:9
    |
 LL |         println!("lul");
diff --git a/tests/ui/traits/const-traits/issue-88155.rs b/tests/ui/traits/const-traits/issue-88155.rs
index 08739de8313..a26128a6ecc 100644
--- a/tests/ui/traits/const-traits/issue-88155.rs
+++ b/tests/ui/traits/const-traits/issue-88155.rs
@@ -9,7 +9,7 @@ pub trait A {
 pub const fn foo<T: A>() -> bool {
     T::assoc()
     //FIXME ~^ ERROR the trait bound
-    //FIXME ~| ERROR cannot call non-const fn
+    //FIXME ~| ERROR cannot call non-const function
 }
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/issue-88155.stderr b/tests/ui/traits/const-traits/issue-88155.stderr
index 157b54214fa..2e140ac9ff6 100644
--- a/tests/ui/traits/const-traits/issue-88155.stderr
+++ b/tests/ui/traits/const-traits/issue-88155.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `<T as A>::assoc` in constant functions
+error[E0015]: cannot call non-const associated function `<T as A>::assoc` in constant functions
   --> $DIR/issue-88155.rs:10:5
    |
 LL |     T::assoc()
diff --git a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
index cd8bb5963ad..fa0f7869644 100644
--- a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
+++ b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
@@ -11,5 +11,5 @@ impl Foo for () {
 
 fn main() {
     (const || { (()).foo() })();
-    //~^ ERROR: cannot call non-const fn
+    //~^ ERROR: cannot call non-const method
 }
diff --git a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
index 97ad83130d4..2d33406c222 100644
--- a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
+++ b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `<() as Foo>::foo` in constant functions
+error[E0015]: cannot call non-const method `<() as Foo>::foo` in constant functions
   --> $DIR/non-const-op-const-closure-non-const-outer.rs:13:22
    |
 LL |     (const || { (()).foo() })();
diff --git a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
index 4ddb1e8c5a9..190af5e7c2d 100644
--- a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
+++ b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
@@ -17,7 +17,7 @@ note: `From` can't be used with `~const` because it isn't annotated with `#[cons
   --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error[E0015]: cannot call non-const fn `<B as From<A>>::from` in constant functions
+error[E0015]: cannot call non-const associated function `<B as From<A>>::from` in constant functions
   --> $DIR/non-const-op-in-closure-in-const.rs:12:9
    |
 LL |         B::from(self)
diff --git a/tests/ui/traits/const-traits/std-impl-gate.gated.stderr b/tests/ui/traits/const-traits/std-impl-gate.gated.stderr
index f3b17130761..a78cf8ce61e 100644
--- a/tests/ui/traits/const-traits/std-impl-gate.gated.stderr
+++ b/tests/ui/traits/const-traits/std-impl-gate.gated.stderr
@@ -4,7 +4,7 @@ error[E0635]: unknown feature `const_default_impls`
 LL | #![cfg_attr(gated, feature(const_trait_impl, const_default_impls))]
    |                                              ^^^^^^^^^^^^^^^^^^^
 
-error[E0015]: cannot call non-const fn `<Vec<usize> as Default>::default` in constant functions
+error[E0015]: cannot call non-const associated function `<Vec<usize> as Default>::default` in constant functions
   --> $DIR/std-impl-gate.rs:13:5
    |
 LL |     Default::default()
diff --git a/tests/ui/traits/const-traits/std-impl-gate.rs b/tests/ui/traits/const-traits/std-impl-gate.rs
index a9e2ff06290..84091931997 100644
--- a/tests/ui/traits/const-traits/std-impl-gate.rs
+++ b/tests/ui/traits/const-traits/std-impl-gate.rs
@@ -11,7 +11,7 @@ fn non_const_context() -> Vec<usize> {
 
 const fn const_context() -> Vec<usize> {
     Default::default()
-    //[stock]~^ ERROR cannot call non-const fn
+    //[stock]~^ ERROR cannot call non-const associated function
 }
 
 fn main() {
diff --git a/tests/ui/traits/const-traits/std-impl-gate.stock.stderr b/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
index 7240b5f4a94..8728f652ef9 100644
--- a/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
+++ b/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
@@ -1,4 +1,4 @@
-error[E0015]: cannot call non-const fn `<Vec<usize> as Default>::default` in constant functions
+error[E0015]: cannot call non-const associated function `<Vec<usize> as Default>::default` in constant functions
   --> $DIR/std-impl-gate.rs:13:5
    |
 LL |     Default::default()
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
index 51b88cf8702..8f88e3aa8bc 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
@@ -45,7 +45,7 @@ help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> $DIR/super-traits-fail-2.rs:20:7
    |
 LL |     x.a();
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
index 38fb6f05412..087e80de788 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
@@ -57,7 +57,7 @@ help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> $DIR/super-traits-fail-2.rs:20:7
    |
 LL |     x.a();
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.rs b/tests/ui/traits/const-traits/super-traits-fail-2.rs
index 53a84bcdd1b..6cc9d739476 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.rs
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.rs
@@ -19,7 +19,7 @@ trait Bar: ~const Foo {}
 const fn foo<T: Bar>(x: &T) {
     x.a();
     //[yy,yn]~^ ERROR the trait bound `T: ~const Foo`
-    //[nn,ny]~^^ ERROR cannot call non-const fn `<T as Foo>::a` in constant functions
+    //[nn,ny]~^^ ERROR cannot call non-const method `<T as Foo>::a` in constant functions
 }
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
index fd802fde5bd..a5ef716a62a 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
@@ -88,7 +88,7 @@ help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> $DIR/super-traits-fail-3.rs:36:7
    |
 LL |     x.a();
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
index fd802fde5bd..a5ef716a62a 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
@@ -88,7 +88,7 @@ help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> $DIR/super-traits-fail-3.rs:36:7
    |
 LL |     x.a();
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.rs b/tests/ui/traits/const-traits/super-traits-fail-3.rs
index aa27554e7f8..d7e0cdc26ed 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.rs
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.rs
@@ -35,7 +35,7 @@ const fn foo<T: ~const Bar>(x: &T) {
     //[nyy,nyn,nny,nnn]~^^^ ERROR: const trait impls are experimental
     x.a();
     //[yyn]~^ ERROR: the trait bound `T: ~const Foo` is not satisfied
-    //[ynn,yny,nny,nnn]~^^ ERROR: cannot call non-const fn `<T as Foo>::a` in constant functions
+    //[ynn,yny,nny,nnn]~^^ ERROR: cannot call non-const method `<T as Foo>::a` in constant functions
     //[nyy,nyn]~^^^ ERROR: cannot call conditionally-const method `<T as Foo>::a` in constant functions
 }
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
index 16424696eeb..f22bdd472e5 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
@@ -68,7 +68,7 @@ help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> $DIR/super-traits-fail-3.rs:36:7
    |
 LL |     x.a();
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
index c81544c4bf5..14b50815b8e 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
@@ -57,7 +57,7 @@ help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
+error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
   --> $DIR/super-traits-fail-3.rs:36:7
    |
 LL |     x.a();
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.stderr b/tests/ui/typeck/typeck_type_placeholder_item.stderr
index 5e32d5c429e..e62ebae5fd2 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item.stderr
@@ -668,7 +668,7 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL |     type F: std::ops::Fn(_);
    |                          ^ not allowed in type signatures
 
-error[E0015]: cannot call non-const fn `<std::ops::Range<i32> as Iterator>::filter::<{closure@$DIR/typeck_type_placeholder_item.rs:230:29: 230:32}>` in constants
+error[E0015]: cannot call non-const method `<std::ops::Range<i32> as Iterator>::filter::<{closure@$DIR/typeck_type_placeholder_item.rs:230:29: 230:32}>` in constants
   --> $DIR/typeck_type_placeholder_item.rs:230:22
    |
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
@@ -676,7 +676,7 @@ LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const fn `<Filter<std::ops::Range<i32>, {closure@$DIR/typeck_type_placeholder_item.rs:230:29: 230:32}> as Iterator>::map::<i32, {closure@$DIR/typeck_type_placeholder_item.rs:230:49: 230:52}>` in constants
+error[E0015]: cannot call non-const method `<Filter<std::ops::Range<i32>, {closure@$DIR/typeck_type_placeholder_item.rs:230:29: 230:32}> as Iterator>::map::<i32, {closure@$DIR/typeck_type_placeholder_item.rs:230:49: 230:52}>` in constants
   --> $DIR/typeck_type_placeholder_item.rs:230:45
    |
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
-- 
cgit 1.4.1-3-g733a5


From e97be25aa950c25b8f099ef3f9ed642dab0aafae Mon Sep 17 00:00:00 2001
From: fudancoder <fudancoder@icloud.com.>
Date: Thu, 19 Dec 2024 21:38:12 +0800
Subject: Fix some typos

Signed-off-by: fudancoder <fudancoder@icloud.com.>
---
 tests/ui/lint/lint-overflowing-ops.rs                                 | 2 +-
 tests/ui/lint/unconditional_panic_promoted.rs                         | 2 +-
 tests/ui/moves/auxiliary/suggest-borrow-for-generic-arg-aux.rs        | 2 +-
 tests/ui/moves/suggest-borrow-for-generic-arg.fixed                   | 4 ++--
 tests/ui/moves/suggest-borrow-for-generic-arg.rs                      | 4 ++--
 .../ui/regions/regions-assoc-type-in-supertrait-outlives-container.rs | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/lint/lint-overflowing-ops.rs b/tests/ui/lint/lint-overflowing-ops.rs
index c5b9f892b0b..eec347010ad 100644
--- a/tests/ui/lint/lint-overflowing-ops.rs
+++ b/tests/ui/lint/lint-overflowing-ops.rs
@@ -1,5 +1,5 @@
 // Tests that overflowing or bound-exceeding operations
-// are correclty linted including when they are const promoted
+// are correctly linted including when they are const promoted
 
 // We are using "-Z deduplicate-diagnostics=yes" because different
 // build configurations emit different number of duplicate diagnostics
diff --git a/tests/ui/lint/unconditional_panic_promoted.rs b/tests/ui/lint/unconditional_panic_promoted.rs
index 37bcf046513..e9ae834c8d8 100644
--- a/tests/ui/lint/unconditional_panic_promoted.rs
+++ b/tests/ui/lint/unconditional_panic_promoted.rs
@@ -2,7 +2,7 @@
 
 fn main() {
     // MIR encodes this as a reborrow from a promoted constant.
-    // But the array lenth can still be gotten from the type.
+    // But the array length can still be gotten from the type.
     let slice = &[0, 1];
     let _ = slice[2]; //~ ERROR: this operation will panic at runtime [unconditional_panic]
 }
diff --git a/tests/ui/moves/auxiliary/suggest-borrow-for-generic-arg-aux.rs b/tests/ui/moves/auxiliary/suggest-borrow-for-generic-arg-aux.rs
index c71238ba072..a5f58d88fb1 100644
--- a/tests/ui/moves/auxiliary/suggest-borrow-for-generic-arg-aux.rs
+++ b/tests/ui/moves/auxiliary/suggest-borrow-for-generic-arg-aux.rs
@@ -1,4 +1,4 @@
-//! auxiliary definitons for suggest-borrow-for-generic-arg.rs, to ensure the suggestion works on
+//! auxiliary definitions for suggest-borrow-for-generic-arg.rs, to ensure the suggestion works on
 //! functions defined in other crates.
 
 use std::io::{self, Read, Write};
diff --git a/tests/ui/moves/suggest-borrow-for-generic-arg.fixed b/tests/ui/moves/suggest-borrow-for-generic-arg.fixed
index b5e0b468aa6..e47a2d08b61 100644
--- a/tests/ui/moves/suggest-borrow-for-generic-arg.fixed
+++ b/tests/ui/moves/suggest-borrow-for-generic-arg.fixed
@@ -1,5 +1,5 @@
-//! Test suggetions to borrow generic arguments instead of moving. Tests for other instances of this
-//! can be found in `moved-value-on-as-ref-arg.rs` and `borrow-closures-instead-of-move.rs`
+//! Test suggestions to borrow generic arguments instead of moving. Tests for other instances of
+//! this can be found in `moved-value-on-as-ref-arg.rs` and `borrow-closures-instead-of-move.rs`
 //@ run-rustfix
 //@ aux-crate:aux=suggest-borrow-for-generic-arg-aux.rs
 //@ edition: 2021
diff --git a/tests/ui/moves/suggest-borrow-for-generic-arg.rs b/tests/ui/moves/suggest-borrow-for-generic-arg.rs
index e08978db63a..5895999c51d 100644
--- a/tests/ui/moves/suggest-borrow-for-generic-arg.rs
+++ b/tests/ui/moves/suggest-borrow-for-generic-arg.rs
@@ -1,5 +1,5 @@
-//! Test suggetions to borrow generic arguments instead of moving. Tests for other instances of this
-//! can be found in `moved-value-on-as-ref-arg.rs` and `borrow-closures-instead-of-move.rs`
+//! Test suggestions to borrow generic arguments instead of moving. Tests for other instances of
+//! this can be found in `moved-value-on-as-ref-arg.rs` and `borrow-closures-instead-of-move.rs`
 //@ run-rustfix
 //@ aux-crate:aux=suggest-borrow-for-generic-arg-aux.rs
 //@ edition: 2021
diff --git a/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.rs b/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.rs
index eb6e66818fc..3219f63f5df 100644
--- a/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.rs
+++ b/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.rs
@@ -1,7 +1,7 @@
 // Test that we are imposing the requirement that every associated
 // type of a bound that appears in the where clause on a struct must
 // outlive the location in which the type appears, even when the
-// associted type is in a supertype. Issue #22246.
+// associated type is in a supertype. Issue #22246.
 
 #![allow(dead_code)]
 
-- 
cgit 1.4.1-3-g733a5


From be1d5dd494172ad8ff1676a52762f3fe90d2ffcb Mon Sep 17 00:00:00 2001
From: oliveredget <188809800+oliveredget@users.noreply.github.com>
Date: Tue, 24 Dec 2024 23:37:30 +0800
Subject: chore: fix typos

---
 library/core/src/macros/mod.rs                | 2 +-
 library/core/src/str/lossy.rs                 | 4 ++--
 library/core/tests/iter/adapters/take.rs      | 2 +-
 src/tools/compiletest/src/read2.rs            | 2 +-
 tests/ui/traits/non_lifetime_binders/basic.rs | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'tests')

diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index ab674b58902..402b436d28e 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -1549,7 +1549,7 @@ pub(crate) mod builtin {
     /// NAME is a string that represents a valid function name.
     /// MODE is any of Forward, Reverse, ForwardFirst, ReverseFirst.
     /// INPUT_ACTIVITIES consists of one valid activity for each input parameter.
-    /// OUTPUT_ACTIVITY must not be set if we implicitely return nothing (or explicitely return
+    /// OUTPUT_ACTIVITY must not be set if we implicitly return nothing (or explicitly return
     /// `-> ()`). Otherwise it must be set to one of the allowed activities.
     #[unstable(feature = "autodiff", issue = "124509")]
     #[allow_internal_unstable(rustc_attrs)]
diff --git a/library/core/src/str/lossy.rs b/library/core/src/str/lossy.rs
index e7677c8317a..ed2cefc59a5 100644
--- a/library/core/src/str/lossy.rs
+++ b/library/core/src/str/lossy.rs
@@ -8,7 +8,7 @@ impl [u8] {
     /// Creates an iterator over the contiguous valid UTF-8 ranges of this
     /// slice, and the non-UTF-8 fragments in between.
     ///
-    /// See the [`Utf8Chunk`] type for documenation of the items yielded by this iterator.
+    /// See the [`Utf8Chunk`] type for documentation of the items yielded by this iterator.
     ///
     /// # Examples
     ///
@@ -150,7 +150,7 @@ impl fmt::Debug for Debug<'_> {
 /// If you want a simple conversion from UTF-8 byte slices to string slices,
 /// [`from_utf8`] is easier to use.
 ///
-/// See the [`Utf8Chunk`] type for documenation of the items yielded by this iterator.
+/// See the [`Utf8Chunk`] type for documentation of the items yielded by this iterator.
 ///
 /// [byteslice]: slice
 /// [`from_utf8`]: super::from_utf8
diff --git a/library/core/tests/iter/adapters/take.rs b/library/core/tests/iter/adapters/take.rs
index 65a8a93b4a9..b932059afec 100644
--- a/library/core/tests/iter/adapters/take.rs
+++ b/library/core/tests/iter/adapters/take.rs
@@ -255,7 +255,7 @@ fn test_reverse_on_zip() {
 
     let zipped_iter = vec_1.iter().zip(core::iter::repeat(0).take(20));
 
-    // Cannot call rev here for automatic reversed zip constuction
+    // Cannot call rev here for automatic reversed zip construction
     for (&one, zero) in zipped_iter.rev() {
         assert_eq!((1, 0), (one, zero));
     }
diff --git a/src/tools/compiletest/src/read2.rs b/src/tools/compiletest/src/read2.rs
index 62e675c77ae..28ca5589992 100644
--- a/src/tools/compiletest/src/read2.rs
+++ b/src/tools/compiletest/src/read2.rs
@@ -90,7 +90,7 @@ impl ProcOutput {
                         .count();
                     *filtered_len -= matches * path_bytes.len();
 
-                    // We can't just remove the length of the filtered path from the output lenght,
+                    // We can't just remove the length of the filtered path from the output length,
                     // otherwise a compiler emitting only filtered paths would OOM compiletest. Add
                     // a fixed placeholder length for each path to prevent that.
                     *filtered_len += matches * FILTERED_PATHS_PLACEHOLDER_LEN;
diff --git a/tests/ui/traits/non_lifetime_binders/basic.rs b/tests/ui/traits/non_lifetime_binders/basic.rs
index 7e45b76434a..533891bf830 100644
--- a/tests/ui/traits/non_lifetime_binders/basic.rs
+++ b/tests/ui/traits/non_lifetime_binders/basic.rs
@@ -1,5 +1,5 @@
 //@ check-pass
-// Basic test that show's we can succesfully typeck a `for<T>` where clause.
+// Basic test that show's we can successfully typeck a `for<T>` where clause.
 
 #![feature(non_lifetime_binders)]
 //~^ WARN the feature `non_lifetime_binders` is incomplete
-- 
cgit 1.4.1-3-g733a5


From 374800b88d2802ed29bf5116b437d1f6f1a259d8 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sun, 15 Dec 2024 09:59:15 +0100
Subject: Bump `stdarch`

---
 library/portable-simd/crates/core_simd/src/vendor/arm.rs | 13 ++-----------
 library/stdarch                                          |  2 +-
 tests/ui/traits/issue-77982.rs                           |  1 +
 tests/ui/traits/issue-77982.stderr                       | 14 +++++++-------
 4 files changed, 11 insertions(+), 19 deletions(-)

(limited to 'tests')

diff --git a/library/portable-simd/crates/core_simd/src/vendor/arm.rs b/library/portable-simd/crates/core_simd/src/vendor/arm.rs
index f8878d11f09..3dc54481b6f 100644
--- a/library/portable-simd/crates/core_simd/src/vendor/arm.rs
+++ b/library/portable-simd/crates/core_simd/src/vendor/arm.rs
@@ -48,17 +48,6 @@ mod neon {
     from_transmute! { unsafe u64x2 => poly64x2_t }
 }
 
-#[cfg(any(
-    all(target_feature = "v5te", not(target_feature = "mclass")),
-    all(target_feature = "mclass", target_feature = "dsp"),
-))]
-mod dsp {
-    use super::*;
-
-    from_transmute! { unsafe Simd<u16, 2> => uint16x2_t }
-    from_transmute! { unsafe Simd<i16, 2> => int16x2_t }
-}
-
 #[cfg(any(
     all(target_feature = "v6", not(target_feature = "mclass")),
     all(target_feature = "mclass", target_feature = "dsp"),
@@ -68,6 +57,8 @@ mod simd32 {
 
     from_transmute! { unsafe Simd<u8, 4> => uint8x4_t }
     from_transmute! { unsafe Simd<i8, 4> => int8x4_t }
+    from_transmute! { unsafe Simd<u16, 2> => uint16x2_t }
+    from_transmute! { unsafe Simd<i16, 2> => int16x2_t }
 }
 
 #[cfg(all(
diff --git a/library/stdarch b/library/stdarch
index e5e00aab0a8..684de0d6fef 160000
--- a/library/stdarch
+++ b/library/stdarch
@@ -1 +1 @@
-Subproject commit e5e00aab0a8c8fa35fb7865e88fa82366f615c53
+Subproject commit 684de0d6fef708cae08214fef9643dd9ec7296e1
diff --git a/tests/ui/traits/issue-77982.rs b/tests/ui/traits/issue-77982.rs
index 57d7899f6dd..dce25e62e46 100644
--- a/tests/ui/traits/issue-77982.rs
+++ b/tests/ui/traits/issue-77982.rs
@@ -1,4 +1,5 @@
 //@ ignore-windows different list of satisfying impls
+//@ ignore-arm different list of satisfying impls
 use std::collections::HashMap;
 
 fn what() {
diff --git a/tests/ui/traits/issue-77982.stderr b/tests/ui/traits/issue-77982.stderr
index 0f4b3c3c877..2b26a1b7ab1 100644
--- a/tests/ui/traits/issue-77982.stderr
+++ b/tests/ui/traits/issue-77982.stderr
@@ -1,5 +1,5 @@
 error[E0283]: type annotations needed
-  --> $DIR/issue-77982.rs:9:10
+  --> $DIR/issue-77982.rs:10:10
    |
 LL |     opts.get(opt.as_ref());
    |          ^^^ ------------ type must be known at this point
@@ -18,7 +18,7 @@ LL |     opts.get::<Q>(opt.as_ref());
    |             +++++
 
 error[E0283]: type annotations needed
-  --> $DIR/issue-77982.rs:9:10
+  --> $DIR/issue-77982.rs:10:10
    |
 LL |     opts.get(opt.as_ref());
    |          ^^^     ------ type must be known at this point
@@ -36,7 +36,7 @@ LL |     opts.get::<Q>(opt.as_ref());
    |             +++++
 
 error[E0283]: type annotations needed
-  --> $DIR/issue-77982.rs:14:59
+  --> $DIR/issue-77982.rs:15:59
    |
 LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(0u32.into())).collect();
    |                                            ---            ^^^^
@@ -56,13 +56,13 @@ LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<T>>::into
    |                                                      +++++++++++++++++++++++    ~
 
 error[E0283]: type annotations needed for `Box<_>`
-  --> $DIR/issue-77982.rs:37:9
+  --> $DIR/issue-77982.rs:38:9
    |
 LL |     let _ = ().foo();
    |         ^      --- type must be known at this point
    |
 note: multiple `impl`s satisfying `(): Foo<'_, _>` found
-  --> $DIR/issue-77982.rs:30:1
+  --> $DIR/issue-77982.rs:31:1
    |
 LL | impl Foo<'static, u32> for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,13 +74,13 @@ LL |     let _: Box<T> = ().foo();
    |          ++++++++
 
 error[E0283]: type annotations needed for `Box<_>`
-  --> $DIR/issue-77982.rs:41:9
+  --> $DIR/issue-77982.rs:42:9
    |
 LL |     let _ = (&()).bar();
    |         ^         --- type must be known at this point
    |
 note: multiple `impl`s satisfying `&(): Bar<'_, _>` found
-  --> $DIR/issue-77982.rs:33:1
+  --> $DIR/issue-77982.rs:34:1
    |
 LL | impl<'a> Bar<'static, u32> for &'a () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From a6a707169d42e3ef2ca8ef243a6023a2c7df988b Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 24 Dec 2024 19:08:09 +0000
Subject: Consider arm to diverge if guard diverges

---
 compiler/rustc_hir_typeck/src/_match.rs | 12 ++++++++++--
 tests/ui/reachable/expr_match.rs        |  8 ++++++--
 tests/ui/reachable/expr_match.stderr    | 24 +++++++++++++++++++++++-
 3 files changed, 39 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
index 243313ee876..87300f5bb83 100644
--- a/compiler/rustc_hir_typeck/src/_match.rs
+++ b/compiler/rustc_hir_typeck/src/_match.rs
@@ -77,12 +77,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut prior_non_diverging_arms = vec![]; // Used only for diagnostics.
         let mut prior_arm = None;
         for arm in arms {
+            self.diverges.set(Diverges::Maybe);
+
             if let Some(e) = &arm.guard {
-                self.diverges.set(Diverges::Maybe);
                 self.check_expr_has_type_or_error(e, tcx.types.bool, |_| {});
+
+                // FIXME: If this is the first arm and the pattern is irrefutable,
+                // e.g. `_` or `x`, and the guard diverges, then the whole match
+                // may also be considered to diverge. We should warn on all subsequent
+                // arms, too, just like we do for diverging scrutinees above.
             }
 
-            self.diverges.set(Diverges::Maybe);
+            // N.B. We don't reset diverges here b/c we want to warn in the arm
+            // if the guard diverges, like: `x if { loop {} } => f()`, and we
+            // also want to consider the arm to diverge itself.
 
             let arm_ty = self.check_expr_with_expectation(arm.body, expected);
             all_arms_diverge &= self.diverges.get();
diff --git a/tests/ui/reachable/expr_match.rs b/tests/ui/reachable/expr_match.rs
index 2fd26b54e15..1bae061c984 100644
--- a/tests/ui/reachable/expr_match.rs
+++ b/tests/ui/reachable/expr_match.rs
@@ -21,9 +21,13 @@ fn d() {
 }
 
 fn e() {
-    // Here the compiler fails to figure out that the `println` is dead.
-    match () { () if return => (), () => return }
+    match () {
+        () if return => (),
+        //~^ ERROR unreachable expression
+        () => return,
+    }
     println!("I am dead");
+    //~^ ERROR unreachable statement
 }
 
 fn f() {
diff --git a/tests/ui/reachable/expr_match.stderr b/tests/ui/reachable/expr_match.stderr
index d15208609cf..ae202a6e0c3 100644
--- a/tests/ui/reachable/expr_match.stderr
+++ b/tests/ui/reachable/expr_match.stderr
@@ -23,5 +23,27 @@ LL |     println!("I am dead");
    |
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 2 previous errors
+error: unreachable expression
+  --> $DIR/expr_match.rs:25:25
+   |
+LL |         () if return => (),
+   |               ------    ^^ unreachable expression
+   |               |
+   |               any code following this expression is unreachable
+
+error: unreachable statement
+  --> $DIR/expr_match.rs:29:5
+   |
+LL | /     match () {
+LL | |         () if return => (),
+LL | |
+LL | |         () => return,
+LL | |     }
+   | |_____- any code following this `match` expression is unreachable, as all arms diverge
+LL |       println!("I am dead");
+   |       ^^^^^^^^^^^^^^^^^^^^^ unreachable statement
+   |
+   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4005b68119701c36a7930320b51d3666750020a Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 24 Dec 2024 22:59:11 +1100
Subject: Rename `tests/ui/coverage-attr/no-coverage.rs` to
 `allowed-positions.rs`

---
 tests/ui/coverage-attr/allowed-positions.rs     |  62 +++++++++++++
 tests/ui/coverage-attr/allowed-positions.stderr | 112 ++++++++++++++++++++++++
 tests/ui/coverage-attr/no-coverage.rs           |  60 -------------
 tests/ui/coverage-attr/no-coverage.stderr       | 112 ------------------------
 4 files changed, 174 insertions(+), 172 deletions(-)
 create mode 100644 tests/ui/coverage-attr/allowed-positions.rs
 create mode 100644 tests/ui/coverage-attr/allowed-positions.stderr
 delete mode 100644 tests/ui/coverage-attr/no-coverage.rs
 delete mode 100644 tests/ui/coverage-attr/no-coverage.stderr

(limited to 'tests')

diff --git a/tests/ui/coverage-attr/allowed-positions.rs b/tests/ui/coverage-attr/allowed-positions.rs
new file mode 100644
index 00000000000..bfffbd26250
--- /dev/null
+++ b/tests/ui/coverage-attr/allowed-positions.rs
@@ -0,0 +1,62 @@
+//! Tests where the `#[coverage(..)]` attribute can and cannot be used.
+
+//@ reference: attributes.coverage.allowed-positions
+
+#![feature(coverage_attribute)]
+#![feature(extern_types)]
+#![feature(impl_trait_in_assoc_type)]
+#![warn(unused_attributes)]
+#![coverage(off)]
+
+#[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+trait Trait {
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    const X: u32;
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    type T;
+
+    type U;
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    fn f(&self);
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    fn g();
+}
+
+#[coverage(off)]
+impl Trait for () {
+    const X: u32 = 0;
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    type T = Self;
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    type U = impl Trait; //~ ERROR unconstrained opaque type
+
+    fn f(&self) {}
+    fn g() {}
+}
+
+extern "C" {
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    static X: u32;
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    type T;
+}
+
+#[coverage(off)]
+fn main() {
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    let _ = ();
+
+    match () {
+        #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+        () => (),
+    }
+
+    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    return ();
+}
diff --git a/tests/ui/coverage-attr/allowed-positions.stderr b/tests/ui/coverage-attr/allowed-positions.stderr
new file mode 100644
index 00000000000..80099fbd6dd
--- /dev/null
+++ b/tests/ui/coverage-attr/allowed-positions.stderr
@@ -0,0 +1,112 @@
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:11:1
+   |
+LL |   #[coverage(off)]
+   |   ^^^^^^^^^^^^^^^^
+LL | / trait Trait {
+LL | |     #[coverage(off)]
+LL | |     const X: u32;
+...  |
+LL | |     fn g();
+LL | | }
+   | |_- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:52:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     let _ = ();
+   |     ----------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:56:9
+   |
+LL |         #[coverage(off)]
+   |         ^^^^^^^^^^^^^^^^
+LL |         () => (),
+   |         -------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:60:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     return ();
+   |     --------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:13:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     const X: u32;
+   |     ------------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:16:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     type T;
+   |     ------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:21:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     fn f(&self);
+   |     ------------ not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:24:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     fn g();
+   |     ------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:32:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     type T = Self;
+   |     -------------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:35:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     type U = impl Trait;
+   |     -------------------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:43:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     static X: u32;
+   |     -------------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:46:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     type T;
+   |     ------- not a function or closure
+
+error: unconstrained opaque type
+  --> $DIR/allowed-positions.rs:36:14
+   |
+LL |     type U = impl Trait;
+   |              ^^^^^^^^^^
+   |
+   = note: `U` must be used in combination with a concrete type within the same impl
+
+error: aborting due to 13 previous errors
+
+For more information about this error, try `rustc --explain E0788`.
diff --git a/tests/ui/coverage-attr/no-coverage.rs b/tests/ui/coverage-attr/no-coverage.rs
deleted file mode 100644
index c386f25816e..00000000000
--- a/tests/ui/coverage-attr/no-coverage.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ reference: attributes.coverage.allowed-positions
-
-#![feature(extern_types)]
-#![feature(coverage_attribute)]
-#![feature(impl_trait_in_assoc_type)]
-#![warn(unused_attributes)]
-#![coverage(off)]
-
-#[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-trait Trait {
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    const X: u32;
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    type T;
-
-    type U;
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    fn f(&self);
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    fn g();
-}
-
-#[coverage(off)]
-impl Trait for () {
-    const X: u32 = 0;
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    type T = Self;
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    type U = impl Trait; //~ ERROR unconstrained opaque type
-
-    fn f(&self) {}
-    fn g() {}
-}
-
-extern "C" {
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    static X: u32;
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    type T;
-}
-
-#[coverage(off)]
-fn main() {
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    let _ = ();
-
-    match () {
-        #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-        () => (),
-    }
-
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
-    return ();
-}
diff --git a/tests/ui/coverage-attr/no-coverage.stderr b/tests/ui/coverage-attr/no-coverage.stderr
deleted file mode 100644
index f5a44ecec74..00000000000
--- a/tests/ui/coverage-attr/no-coverage.stderr
+++ /dev/null
@@ -1,112 +0,0 @@
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:9:1
-   |
-LL |   #[coverage(off)]
-   |   ^^^^^^^^^^^^^^^^
-LL | / trait Trait {
-LL | |     #[coverage(off)]
-LL | |     const X: u32;
-...  |
-LL | |     fn g();
-LL | | }
-   | |_- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:50:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     let _ = ();
-   |     ----------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:54:9
-   |
-LL |         #[coverage(off)]
-   |         ^^^^^^^^^^^^^^^^
-LL |         () => (),
-   |         -------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:58:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     return ();
-   |     --------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:11:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     const X: u32;
-   |     ------------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:14:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     type T;
-   |     ------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:19:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     fn f(&self);
-   |     ------------ not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:22:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     fn g();
-   |     ------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:30:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     type T = Self;
-   |     -------------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:33:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     type U = impl Trait;
-   |     -------------------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:41:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     static X: u32;
-   |     -------------- not a function or closure
-
-error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/no-coverage.rs:44:5
-   |
-LL |     #[coverage(off)]
-   |     ^^^^^^^^^^^^^^^^
-LL |     type T;
-   |     ------- not a function or closure
-
-error: unconstrained opaque type
-  --> $DIR/no-coverage.rs:34:14
-   |
-LL |     type U = impl Trait;
-   |              ^^^^^^^^^^
-   |
-   = note: `U` must be used in combination with a concrete type within the same impl
-
-error: aborting due to 13 previous errors
-
-For more information about this error, try `rustc --explain E0788`.
-- 
cgit 1.4.1-3-g733a5


From 9bcd1dee9507fe68a31842b7676b9631d69781fa Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 25 Dec 2024 01:08:59 +0000
Subject: Actually print all the relevant parts of a coroutine in verbose mode

---
 compiler/rustc_middle/src/ty/print/pretty.rs              | 6 ++++++
 tests/ui/async-await/async-closures/def-path.stderr       | 4 ++--
 tests/ui/coroutine/print/coroutine-print-verbose-2.stderr | 4 ++--
 tests/ui/coroutine/print/coroutine-print-verbose-3.stderr | 2 +-
 4 files changed, 11 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 8e89331ef03..9fe1caa4b58 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -841,6 +841,12 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                     p!(
                         " upvar_tys=",
                         print(args.as_coroutine().tupled_upvars_ty()),
+                        " resume_ty=",
+                        print(args.as_coroutine().resume_ty()),
+                        " yield_ty=",
+                        print(args.as_coroutine().yield_ty()),
+                        " return_ty=",
+                        print(args.as_coroutine().return_ty()),
                         " witness=",
                         print(args.as_coroutine().witness())
                     );
diff --git a/tests/ui/async-await/async-closures/def-path.stderr b/tests/ui/async-await/async-closures/def-path.stderr
index cf25b2d2d23..13ebaf67e54 100644
--- a/tests/ui/async-await/async-closures/def-path.stderr
+++ b/tests/ui/async-await/async-closures/def-path.stderr
@@ -5,11 +5,11 @@ LL |     let x = async || {};
    |                      -- the expected `async` closure body
 LL |
 LL |     let () = x();
-   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t witness=?6t}`
+   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?6t}`
    |         |
    |         expected `async` closure body, found `()`
    |
-   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t witness=?6t}`
+   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?6t}`
                          found unit type `()`
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr
index 2ab9d35f05a..8877d45ddda 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-2.stderr
@@ -9,7 +9,7 @@ LL | |         drop(a);
 LL | |     });
    | |______^ coroutine is not `Sync`
    |
-   = help: within `{main::{closure#0} upvar_tys=() witness={main::{closure#0}}}`, the trait `Sync` is not implemented for `NotSync`
+   = help: within `{main::{closure#0} upvar_tys=() resume_ty=() yield_ty=() return_ty=() witness={main::{closure#0}}}`, the trait `Sync` is not implemented for `NotSync`
 note: coroutine is not `Sync` as this value is used across a yield
   --> $DIR/coroutine-print-verbose-2.rs:20:9
    |
@@ -34,7 +34,7 @@ LL | |         drop(a);
 LL | |     });
    | |______^ coroutine is not `Send`
    |
-   = help: within `{main::{closure#1} upvar_tys=() witness={main::{closure#1}}}`, the trait `Send` is not implemented for `NotSend`
+   = help: within `{main::{closure#1} upvar_tys=() resume_ty=() yield_ty=() return_ty=() witness={main::{closure#1}}}`, the trait `Send` is not implemented for `NotSend`
 note: coroutine is not `Send` as this value is used across a yield
   --> $DIR/coroutine-print-verbose-2.rs:27:9
    |
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
index dce45aeae56..2f9f20cf1ff 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
@@ -11,7 +11,7 @@ LL | |     };
    | |_____^ expected `()`, found coroutine
    |
    = note: expected unit type `()`
-              found coroutine `{main::{closure#0} upvar_tys=?4t witness=?6t}`
+              found coroutine `{main::{closure#0} upvar_tys=?4t resume_ty=() yield_ty=i32 return_ty=&'?1 str witness=?6t}`
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From 2c31c550206ae0f5d88db5f3d46e0957b669dfc9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 25 Dec 2024 01:27:21 +0000
Subject: Use PostBorrowckAnalysis in check_coroutine_obligations

---
 compiler/rustc_hir_analysis/src/check/check.rs | 23 +++++++++++++++--------
 tests/ui/coroutine/issue-52304.rs              |  2 ++
 2 files changed, 17 insertions(+), 8 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 5548a6a6ef7..8c6059d49a8 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1845,13 +1845,18 @@ pub(super) fn check_coroutine_obligations(
 
     debug!(?typeck_results.coroutine_stalled_predicates);
 
+    let mode = if tcx.next_trait_solver_globally() {
+        TypingMode::post_borrowck_analysis(tcx, def_id)
+    } else {
+        TypingMode::analysis_in_body(tcx, def_id)
+    };
+
     let infcx = tcx
         .infer_ctxt()
         // typeck writeback gives us predicates with their regions erased.
         // As borrowck already has checked lifetimes, we do not need to do it again.
         .ignoring_regions()
-        // FIXME(#132279): This should eventually use the already defined hidden types.
-        .build(TypingMode::analysis_in_body(tcx, def_id));
+        .build(mode);
 
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
     for (predicate, cause) in &typeck_results.coroutine_stalled_predicates {
@@ -1864,12 +1869,14 @@ pub(super) fn check_coroutine_obligations(
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
 
-    // Check that any hidden types found when checking these stalled coroutine obligations
-    // are valid.
-    for (key, ty) in infcx.take_opaque_types() {
-        let hidden_type = infcx.resolve_vars_if_possible(ty.hidden_type);
-        let key = infcx.resolve_vars_if_possible(key);
-        sanity_check_found_hidden_type(tcx, key, hidden_type)?;
+    if !tcx.next_trait_solver_globally() {
+        // Check that any hidden types found when checking these stalled coroutine obligations
+        // are valid.
+        for (key, ty) in infcx.take_opaque_types() {
+            let hidden_type = infcx.resolve_vars_if_possible(ty.hidden_type);
+            let key = infcx.resolve_vars_if_possible(key);
+            sanity_check_found_hidden_type(tcx, key, hidden_type)?;
+        }
     }
 
     Ok(())
diff --git a/tests/ui/coroutine/issue-52304.rs b/tests/ui/coroutine/issue-52304.rs
index 552bc0028ee..77dfe839195 100644
--- a/tests/ui/coroutine/issue-52304.rs
+++ b/tests/ui/coroutine/issue-52304.rs
@@ -1,4 +1,6 @@
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
 
 #![feature(coroutines, coroutine_trait)]
 
-- 
cgit 1.4.1-3-g733a5


From 5e98118901e9d358cc246e3fabe119bcd6a245bc Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 24 Dec 2024 23:08:28 +1100
Subject: Fully redact the [E0788] error message in tests, to make changes
 easier

---
 tests/ui/coverage-attr/allowed-positions.rs | 24 ++++++++++++------------
 tests/ui/coverage-attr/name-value.rs        | 14 +++++++-------
 tests/ui/coverage-attr/word-only.rs         | 14 +++++++-------
 3 files changed, 26 insertions(+), 26 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/coverage-attr/allowed-positions.rs b/tests/ui/coverage-attr/allowed-positions.rs
index bfffbd26250..3c400761948 100644
--- a/tests/ui/coverage-attr/allowed-positions.rs
+++ b/tests/ui/coverage-attr/allowed-positions.rs
@@ -8,20 +8,20 @@
 #![warn(unused_attributes)]
 #![coverage(off)]
 
-#[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+#[coverage(off)] //~ ERROR [E0788]
 trait Trait {
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     const X: u32;
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     type T;
 
     type U;
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     fn f(&self);
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     fn g();
 }
 
@@ -29,10 +29,10 @@ trait Trait {
 impl Trait for () {
     const X: u32 = 0;
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     type T = Self;
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     type U = impl Trait; //~ ERROR unconstrained opaque type
 
     fn f(&self) {}
@@ -40,23 +40,23 @@ impl Trait for () {
 }
 
 extern "C" {
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     static X: u32;
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     type T;
 }
 
 #[coverage(off)]
 fn main() {
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     let _ = ();
 
     match () {
-        #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+        #[coverage(off)] //~ ERROR [E0788]
         () => (),
     }
 
-    #[coverage(off)] //~ ERROR attribute should be applied to a function definition or closure
+    #[coverage(off)] //~ ERROR [E0788]
     return ();
 }
diff --git a/tests/ui/coverage-attr/name-value.rs b/tests/ui/coverage-attr/name-value.rs
index e5df5bc3da0..ffd9afe2ce1 100644
--- a/tests/ui/coverage-attr/name-value.rs
+++ b/tests/ui/coverage-attr/name-value.rs
@@ -20,7 +20,7 @@ mod my_mod_inner {
 
 #[coverage = "off"]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR attribute should be applied to a function definition or closure
+//~| ERROR [E0788]
 struct MyStruct;
 
 #[coverage = "off"]
@@ -28,22 +28,22 @@ struct MyStruct;
 impl MyStruct {
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     const X: u32 = 7;
 }
 
 #[coverage = "off"]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR attribute should be applied to a function definition or closure
+//~| ERROR [E0788]
 trait MyTrait {
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     const X: u32;
 
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     type T;
 }
 
@@ -52,12 +52,12 @@ trait MyTrait {
 impl MyTrait for MyStruct {
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     const X: u32 = 8;
 
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     type T = ();
 }
 
diff --git a/tests/ui/coverage-attr/word-only.rs b/tests/ui/coverage-attr/word-only.rs
index add225cdb93..d0f743938f3 100644
--- a/tests/ui/coverage-attr/word-only.rs
+++ b/tests/ui/coverage-attr/word-only.rs
@@ -20,7 +20,7 @@ mod my_mod_inner {
 
 #[coverage]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR attribute should be applied to a function definition or closure
+//~| ERROR [E0788]
 struct MyStruct;
 
 #[coverage]
@@ -28,22 +28,22 @@ struct MyStruct;
 impl MyStruct {
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     const X: u32 = 7;
 }
 
 #[coverage]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR attribute should be applied to a function definition or closure
+//~| ERROR [E0788]
 trait MyTrait {
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     const X: u32;
 
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     type T;
 }
 
@@ -52,12 +52,12 @@ trait MyTrait {
 impl MyTrait for MyStruct {
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     const X: u32 = 8;
 
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR attribute should be applied to a function definition or closure
+    //~| ERROR [E0788]
     type T = ();
 }
 
-- 
cgit 1.4.1-3-g733a5


From 9124662da3e0d573703c9bb07d5e3cf8d06f1b20 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 25 Dec 2024 13:29:20 +1100
Subject: Expand the main test for where the coverage attribute is allowed

Some of these cases are also implicitly checked by other tests, but it's
helpful to also explicitly list them in the main test.
---
 tests/ui/coverage-attr/allowed-positions.rs     |  80 +++++++++++++---
 tests/ui/coverage-attr/allowed-positions.stderr | 116 +++++++++++++++++-------
 2 files changed, 148 insertions(+), 48 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/coverage-attr/allowed-positions.rs b/tests/ui/coverage-attr/allowed-positions.rs
index 3c400761948..d4345c8d443 100644
--- a/tests/ui/coverage-attr/allowed-positions.rs
+++ b/tests/ui/coverage-attr/allowed-positions.rs
@@ -8,35 +8,68 @@
 #![warn(unused_attributes)]
 #![coverage(off)]
 
+#[coverage(off)]
+mod submod {}
+
 #[coverage(off)] //~ ERROR [E0788]
-trait Trait {
-    #[coverage(off)] //~ ERROR [E0788]
-    const X: u32;
+type MyTypeAlias = ();
 
+#[coverage(off)] //~ ERROR [E0788]
+trait MyTrait {
     #[coverage(off)] //~ ERROR [E0788]
-    type T;
+    const TRAIT_ASSOC_CONST: u32;
 
-    type U;
+    #[coverage(off)] //~ ERROR [E0788]
+    type TraitAssocType;
 
     #[coverage(off)] //~ ERROR [E0788]
-    fn f(&self);
+    fn trait_method(&self);
+
+    #[coverage(off)]
+    fn trait_method_with_default(&self) {}
 
     #[coverage(off)] //~ ERROR [E0788]
-    fn g();
+    fn trait_assoc_fn();
 }
 
 #[coverage(off)]
-impl Trait for () {
-    const X: u32 = 0;
+impl MyTrait for () {
+    const TRAIT_ASSOC_CONST: u32 = 0;
 
     #[coverage(off)] //~ ERROR [E0788]
-    type T = Self;
+    type TraitAssocType = Self;
+
+    #[coverage(off)]
+    fn trait_method(&self) {}
+    #[coverage(off)]
+    fn trait_method_with_default(&self) {}
+    #[coverage(off)]
+    fn trait_assoc_fn() {}
+}
+
+trait HasAssocType {
+    type T;
+    fn constrain_assoc_type() -> Self::T;
+}
 
+impl HasAssocType for () {
     #[coverage(off)] //~ ERROR [E0788]
-    type U = impl Trait; //~ ERROR unconstrained opaque type
+    type T = impl Copy;
+    fn constrain_assoc_type() -> Self::T {}
+}
+
+#[coverage(off)] //~ ERROR [E0788]
+struct MyStruct {
+    #[coverage(off)] //~ ERROR [E0788]
+    field: u32,
+}
 
-    fn f(&self) {}
-    fn g() {}
+#[coverage(off)]
+impl MyStruct {
+    #[coverage(off)]
+    fn method(&self) {}
+    #[coverage(off)]
+    fn assoc_fn() {}
 }
 
 extern "C" {
@@ -45,6 +78,9 @@ extern "C" {
 
     #[coverage(off)] //~ ERROR [E0788]
     type T;
+
+    #[coverage(off)] //~ ERROR [E0788]
+    fn foreign_fn();
 }
 
 #[coverage(off)]
@@ -52,6 +88,24 @@ fn main() {
     #[coverage(off)] //~ ERROR [E0788]
     let _ = ();
 
+    // Currently not allowed on let statements, even if they bind to a closure.
+    // It might be nice to support this as a special case someday, but trying
+    // to define the precise boundaries of that special case might be tricky.
+    #[coverage(off)] //~ ERROR [E0788]
+    let _let_closure = || ();
+
+    // In situations where attributes can already be applied to expressions,
+    // the coverage attribute is allowed on closure expressions.
+    let _closure_tail_expr = {
+        #[coverage(off)]
+        || ()
+    };
+
+    // Applying attributes to arbitrary expressions requires an unstable
+    // feature, but if that feature were enabled then this would be allowed.
+    let _closure_expr = #[coverage(off)] || ();
+    //~^ ERROR attributes on expressions are experimental [E0658]
+
     match () {
         #[coverage(off)] //~ ERROR [E0788]
         () => (),
diff --git a/tests/ui/coverage-attr/allowed-positions.stderr b/tests/ui/coverage-attr/allowed-positions.stderr
index 80099fbd6dd..08a578ddd83 100644
--- a/tests/ui/coverage-attr/allowed-positions.stderr
+++ b/tests/ui/coverage-attr/allowed-positions.stderr
@@ -1,18 +1,55 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/allowed-positions.rs:106:25
+   |
+LL |     let _closure_expr = #[coverage(off)] || ();
+   |                         ^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:11:1
+  --> $DIR/allowed-positions.rs:14:1
+   |
+LL | #[coverage(off)]
+   | ^^^^^^^^^^^^^^^^
+LL | type MyTypeAlias = ();
+   | ---------------------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:17:1
    |
 LL |   #[coverage(off)]
    |   ^^^^^^^^^^^^^^^^
-LL | / trait Trait {
+LL | / trait MyTrait {
 LL | |     #[coverage(off)]
-LL | |     const X: u32;
+LL | |     const TRAIT_ASSOC_CONST: u32;
 ...  |
-LL | |     fn g();
+LL | |     fn trait_assoc_fn();
+LL | | }
+   | |_- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:61:1
+   |
+LL |   #[coverage(off)]
+   |   ^^^^^^^^^^^^^^^^
+LL | / struct MyStruct {
+LL | |     #[coverage(off)]
+LL | |     field: u32,
 LL | | }
    | |_- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:52:5
+  --> $DIR/allowed-positions.rs:63:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     field: u32,
+   |     ---------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:88:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -20,7 +57,15 @@ LL |     let _ = ();
    |     ----------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:56:9
+  --> $DIR/allowed-positions.rs:94:5
+   |
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     let _let_closure = || ();
+   |     ------------------------- not a function or closure
+
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:110:9
    |
 LL |         #[coverage(off)]
    |         ^^^^^^^^^^^^^^^^
@@ -28,7 +73,7 @@ LL |         () => (),
    |         -------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:60:5
+  --> $DIR/allowed-positions.rs:114:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -36,55 +81,55 @@ LL |     return ();
    |     --------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:13:5
+  --> $DIR/allowed-positions.rs:19:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
-LL |     const X: u32;
-   |     ------------- not a function or closure
+LL |     const TRAIT_ASSOC_CONST: u32;
+   |     ----------------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:16:5
+  --> $DIR/allowed-positions.rs:22:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
-LL |     type T;
-   |     ------- not a function or closure
+LL |     type TraitAssocType;
+   |     -------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:21:5
+  --> $DIR/allowed-positions.rs:25:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
-LL |     fn f(&self);
-   |     ------------ not a function or closure
+LL |     fn trait_method(&self);
+   |     ----------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:24:5
+  --> $DIR/allowed-positions.rs:31:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
-LL |     fn g();
-   |     ------- not a function or closure
+LL |     fn trait_assoc_fn();
+   |     -------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:32:5
+  --> $DIR/allowed-positions.rs:39:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
-LL |     type T = Self;
-   |     -------------- not a function or closure
+LL |     type TraitAssocType = Self;
+   |     --------------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:35:5
+  --> $DIR/allowed-positions.rs:56:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
-LL |     type U = impl Trait;
-   |     -------------------- not a function or closure
+LL |     type T = impl Copy;
+   |     ------------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:43:5
+  --> $DIR/allowed-positions.rs:76:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
@@ -92,21 +137,22 @@ LL |     static X: u32;
    |     -------------- not a function or closure
 
 error[E0788]: attribute should be applied to a function definition or closure
-  --> $DIR/allowed-positions.rs:46:5
+  --> $DIR/allowed-positions.rs:79:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     type T;
    |     ------- not a function or closure
 
-error: unconstrained opaque type
-  --> $DIR/allowed-positions.rs:36:14
-   |
-LL |     type U = impl Trait;
-   |              ^^^^^^^^^^
+error[E0788]: attribute should be applied to a function definition or closure
+  --> $DIR/allowed-positions.rs:82:5
    |
-   = note: `U` must be used in combination with a concrete type within the same impl
+LL |     #[coverage(off)]
+   |     ^^^^^^^^^^^^^^^^
+LL |     fn foreign_fn();
+   |     ---------------- not a function or closure
 
-error: aborting due to 13 previous errors
+error: aborting due to 18 previous errors
 
-For more information about this error, try `rustc --explain E0788`.
+Some errors have detailed explanations: E0658, E0788.
+For more information about an error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From 399620939844d7b2e4a93e450f8c578960d0b6f2 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 25 Dec 2024 14:57:21 +1100
Subject: Overhaul error messages for disallowed coverage attributes

---
 compiler/rustc_passes/messages.ftl              |   8 +-
 compiler/rustc_passes/src/check_attr.rs         |  25 ++++--
 compiler/rustc_passes/src/errors.rs             |  16 +++-
 tests/ui/coverage-attr/allowed-positions.stderr | 102 ++++++++++++++++--------
 tests/ui/coverage-attr/name-value.stderr        |  42 ++++++----
 tests/ui/coverage-attr/word-only.stderr         |  42 ++++++----
 6 files changed, 160 insertions(+), 75 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index ba3101e9058..f39bea2a56f 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -112,9 +112,11 @@ passes_coroutine_on_non_closure =
     attribute should be applied to closures
     .label = not a closure
 
-passes_coverage_not_fn_or_closure =
-    attribute should be applied to a function definition or closure
-    .label = not a function or closure
+passes_coverage_attribute_not_allowed =
+    coverage attribute not allowed here
+    .not_fn_impl_mod = not a function, impl block, or module
+    .no_body = function has no body
+    .help = coverage attribute can be applied to a function (with body), impl block, or module
 
 passes_dead_codes =
     { $multiple ->
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 8cf20a378d4..12f715a0fe4 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -432,21 +432,34 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
     /// Checks that `#[coverage(..)]` is applied to a function/closure/method,
     /// or to an impl block or module.
-    fn check_coverage(&self, attr: &Attribute, span: Span, target: Target) {
+    fn check_coverage(&self, attr: &Attribute, target_span: Span, target: Target) {
+        let mut not_fn_impl_mod = None;
+        let mut no_body = None;
+
         match target {
             Target::Fn
             | Target::Closure
             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent)
             | Target::Impl
-            | Target::Mod => {}
+            | Target::Mod => return,
+
+            // These are "functions", but they aren't allowed because they don't
+            // have a body, so the usual explanation would be confusing.
+            Target::Method(MethodKind::Trait { body: false }) | Target::ForeignFn => {
+                no_body = Some(target_span);
+            }
 
             _ => {
-                self.dcx().emit_err(errors::CoverageNotFnOrClosure {
-                    attr_span: attr.span,
-                    defn_span: span,
-                });
+                not_fn_impl_mod = Some(target_span);
             }
         }
+
+        self.dcx().emit_err(errors::CoverageAttributeNotAllowed {
+            attr_span: attr.span,
+            not_fn_impl_mod,
+            no_body,
+            help: (),
+        });
     }
 
     /// Checks that `#[optimize(..)]` is applied to a function/closure/method,
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 163325f2a3c..d95fa5db0ce 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -71,13 +71,21 @@ pub(crate) struct InlineNotFnOrClosure {
     pub defn_span: Span,
 }
 
+/// "coverage attribute not allowed here"
 #[derive(Diagnostic)]
-#[diag(passes_coverage_not_fn_or_closure, code = E0788)]
-pub(crate) struct CoverageNotFnOrClosure {
+#[diag(passes_coverage_attribute_not_allowed, code = E0788)]
+pub(crate) struct CoverageAttributeNotAllowed {
     #[primary_span]
     pub attr_span: Span,
-    #[label]
-    pub defn_span: Span,
+    /// "not a function, impl block, or module"
+    #[label(passes_not_fn_impl_mod)]
+    pub not_fn_impl_mod: Option<Span>,
+    /// "function has no body"
+    #[label(passes_no_body)]
+    pub no_body: Option<Span>,
+    /// "coverage attribute can be applied to a function (with body), impl block, or module"
+    #[help]
+    pub help: (),
 }
 
 #[derive(Diagnostic)]
diff --git a/tests/ui/coverage-attr/allowed-positions.stderr b/tests/ui/coverage-attr/allowed-positions.stderr
index 08a578ddd83..34562a4da1b 100644
--- a/tests/ui/coverage-attr/allowed-positions.stderr
+++ b/tests/ui/coverage-attr/allowed-positions.stderr
@@ -8,15 +8,17 @@ LL |     let _closure_expr = #[coverage(off)] || ();
    = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:14:1
    |
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^
 LL | type MyTypeAlias = ();
-   | ---------------------- not a function or closure
+   | ---------------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:17:1
    |
 LL |   #[coverage(off)]
@@ -27,9 +29,11 @@ LL | |     const TRAIT_ASSOC_CONST: u32;
 ...  |
 LL | |     fn trait_assoc_fn();
 LL | | }
-   | |_- not a function or closure
+   | |_- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:61:1
    |
 LL |   #[coverage(off)]
@@ -38,119 +42,149 @@ LL | / struct MyStruct {
 LL | |     #[coverage(off)]
 LL | |     field: u32,
 LL | | }
-   | |_- not a function or closure
+   | |_- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:63:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     field: u32,
-   |     ---------- not a function or closure
+   |     ---------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:88:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     let _ = ();
-   |     ----------- not a function or closure
+   |     ----------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:94:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     let _let_closure = || ();
-   |     ------------------------- not a function or closure
+   |     ------------------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:110:9
    |
 LL |         #[coverage(off)]
    |         ^^^^^^^^^^^^^^^^
 LL |         () => (),
-   |         -------- not a function or closure
+   |         -------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:114:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     return ();
-   |     --------- not a function or closure
+   |     --------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:19:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     const TRAIT_ASSOC_CONST: u32;
-   |     ----------------------------- not a function or closure
+   |     ----------------------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:22:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     type TraitAssocType;
-   |     -------------------- not a function or closure
+   |     -------------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:25:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     fn trait_method(&self);
-   |     ----------------------- not a function or closure
+   |     ----------------------- function has no body
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:31:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     fn trait_assoc_fn();
-   |     -------------------- not a function or closure
+   |     -------------------- function has no body
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:39:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     type TraitAssocType = Self;
-   |     --------------------------- not a function or closure
+   |     --------------------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:56:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     type T = impl Copy;
-   |     ------------------- not a function or closure
+   |     ------------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:76:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     static X: u32;
-   |     -------------- not a function or closure
+   |     -------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:79:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     type T;
-   |     ------- not a function or closure
+   |     ------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/allowed-positions.rs:82:5
    |
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
 LL |     fn foreign_fn();
-   |     ---------------- not a function or closure
+   |     ---------------- function has no body
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/coverage-attr/name-value.stderr b/tests/ui/coverage-attr/name-value.stderr
index 84a57f575f9..bfd22ed5451 100644
--- a/tests/ui/coverage-attr/name-value.stderr
+++ b/tests/ui/coverage-attr/name-value.stderr
@@ -154,16 +154,18 @@ LL | #[coverage(off)]
 LL | #[coverage(on)]
    |
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:21:1
    |
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
 ...
 LL | struct MyStruct;
-   | ---------------- not a function or closure
+   | ---------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:35:1
    |
 LL |   #[coverage = "off"]
@@ -174,52 +176,64 @@ LL | |     #[coverage = "off"]
 ...  |
 LL | |     type T;
 LL | | }
-   | |_- not a function or closure
+   | |_- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:39:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
 ...
 LL |     const X: u32;
-   |     ------------- not a function or closure
+   |     ------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:44:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
 ...
 LL |     type T;
-   |     ------- not a function or closure
+   |     ------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:29:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
 ...
 LL |     const X: u32 = 7;
-   |     ----------------- not a function or closure
+   |     ----------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:53:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
 ...
 LL |     const X: u32 = 8;
-   |     ----------------- not a function or closure
+   |     ----------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/name-value.rs:58:5
    |
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
 ...
 LL |     type T = ();
-   |     ------------ not a function or closure
+   |     ------------ not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
 error: aborting due to 19 previous errors
 
diff --git a/tests/ui/coverage-attr/word-only.stderr b/tests/ui/coverage-attr/word-only.stderr
index 97a0723988f..bad50b0c961 100644
--- a/tests/ui/coverage-attr/word-only.stderr
+++ b/tests/ui/coverage-attr/word-only.stderr
@@ -154,16 +154,18 @@ LL | #[coverage(off)]
 LL | #[coverage(on)]
    |
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:21:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
 ...
 LL | struct MyStruct;
-   | ---------------- not a function or closure
+   | ---------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:35:1
    |
 LL |   #[coverage]
@@ -174,52 +176,64 @@ LL | |     #[coverage]
 ...  |
 LL | |     type T;
 LL | | }
-   | |_- not a function or closure
+   | |_- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:39:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
 ...
 LL |     const X: u32;
-   |     ------------- not a function or closure
+   |     ------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:44:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
 ...
 LL |     type T;
-   |     ------- not a function or closure
+   |     ------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:29:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
 ...
 LL |     const X: u32 = 7;
-   |     ----------------- not a function or closure
+   |     ----------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:53:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
 ...
 LL |     const X: u32 = 8;
-   |     ----------------- not a function or closure
+   |     ----------------- not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
-error[E0788]: attribute should be applied to a function definition or closure
+error[E0788]: coverage attribute not allowed here
   --> $DIR/word-only.rs:58:5
    |
 LL |     #[coverage]
    |     ^^^^^^^^^^^
 ...
 LL |     type T = ();
-   |     ------------ not a function or closure
+   |     ------------ not a function, impl block, or module
+   |
+   = help: coverage attribute can be applied to a function (with body), impl block, or module
 
 error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e48fc62ce075985089f117e0472586be1af167b7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 25 Dec 2024 16:15:28 +1100
Subject: Un-redact one occurrence of "coverage attribute not allowed here"

---
 tests/ui/coverage-attr/allowed-positions.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/ui/coverage-attr/allowed-positions.rs b/tests/ui/coverage-attr/allowed-positions.rs
index d4345c8d443..f1169fa6570 100644
--- a/tests/ui/coverage-attr/allowed-positions.rs
+++ b/tests/ui/coverage-attr/allowed-positions.rs
@@ -11,7 +11,7 @@
 #[coverage(off)]
 mod submod {}
 
-#[coverage(off)] //~ ERROR [E0788]
+#[coverage(off)] //~ ERROR coverage attribute not allowed here [E0788]
 type MyTypeAlias = ();
 
 #[coverage(off)] //~ ERROR [E0788]
-- 
cgit 1.4.1-3-g733a5


From 6de3a2e3a9c45e12f63a8e861131a39b1eb0e021 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 25 Dec 2024 10:36:32 +0100
Subject: stabilize const_swap

---
 library/core/src/intrinsics/mod.rs                 |  3 ++-
 library/core/src/lib.rs                            |  1 -
 library/core/src/mem/mod.rs                        |  2 +-
 library/core/src/ptr/mod.rs                        |  3 +--
 library/core/src/ptr/mut_ptr.rs                    |  2 +-
 library/core/src/ptr/non_null.rs                   |  2 +-
 library/core/src/slice/mod.rs                      |  2 +-
 library/core/tests/lib.rs                          |  1 -
 tests/ui/consts/issue-94371.rs                     |  2 --
 tests/ui/consts/qualif-indirect-mutation-fail.rs   |  1 -
 .../ui/consts/qualif-indirect-mutation-fail.stderr | 22 +++++++++++-----------
 tests/ui/thread-local/thread-local-static.rs       |  1 -
 tests/ui/thread-local/thread-local-static.stderr   |  4 ++--
 13 files changed, 20 insertions(+), 26 deletions(-)

(limited to 'tests')

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 42b8eb33a1a..9844243d168 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -3954,7 +3954,8 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 #[inline]
 #[rustc_intrinsic]
 // Const-unstable because `swap_nonoverlapping` is const-unstable.
-#[rustc_const_unstable(feature = "const_typed_swap", issue = "none")]
+#[rustc_intrinsic_const_stable_indirect]
+#[rustc_allow_const_fn_unstable(const_swap_nonoverlapping)] // this is anyway not called since CTFE implements the intrinsic
 pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
     // SAFETY: The caller provided single non-overlapping items behind
     // pointers, so swapping them with `count: 1` is fine.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index a7f741a9408..c7646f9f270 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -111,7 +111,6 @@
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
 #![feature(const_eval_select)]
-#![feature(const_typed_swap)]
 #![feature(core_intrinsics)]
 #![feature(coverage_attribute)]
 #![feature(internal_impls_macro)]
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index 57acc9dcd6e..1576eb43152 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -725,7 +725,7 @@ pub unsafe fn uninitialized<T>() -> T {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_swap", issue = "83163")]
+#[rustc_const_stable(feature = "const_swap", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_diagnostic_item = "mem_swap"]
 pub const fn swap<T>(x: &mut T, y: &mut T) {
     // SAFETY: `&mut` guarantees these are typed readable and writable
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index e6e13eaff7b..ac074c097d9 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -1009,9 +1009,8 @@ pub const fn slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_swap", issue = "83163")]
+#[rustc_const_stable(feature = "const_swap", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_diagnostic_item = "ptr_swap"]
-#[rustc_const_stable_indirect]
 pub const unsafe fn swap<T>(x: *mut T, y: *mut T) {
     // Give ourselves some scratch space to work with.
     // We do not have to worry about drops: `MaybeUninit` does nothing when dropped.
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index 34567917b52..d75d570a969 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -1594,7 +1594,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// [`ptr::swap`]: crate::ptr::swap()
     #[stable(feature = "pointer_methods", since = "1.26.0")]
-    #[rustc_const_unstable(feature = "const_swap", issue = "83163")]
+    #[rustc_const_stable(feature = "const_swap", since = "CURRENT_RUSTC_VERSION")]
     #[inline(always)]
     pub const unsafe fn swap(self, with: *mut T)
     where
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index e0ba469272e..1058fa42cc1 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -1146,7 +1146,7 @@ impl<T: ?Sized> NonNull<T> {
     /// [`ptr::swap`]: crate::ptr::swap()
     #[inline(always)]
     #[stable(feature = "non_null_convenience", since = "1.80.0")]
-    #[rustc_const_unstable(feature = "const_swap", issue = "83163")]
+    #[rustc_const_stable(feature = "const_swap", since = "CURRENT_RUSTC_VERSION")]
     pub const unsafe fn swap(self, with: NonNull<T>)
     where
         T: Sized,
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index ab65f9d6d2f..3e8c698a7ab 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -913,7 +913,7 @@ impl<T> [T] {
     /// assert!(v == ["a", "b", "e", "d", "c"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_swap", issue = "83163")]
+    #[rustc_const_stable(feature = "const_swap", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     #[track_caller]
     pub const fn swap(&mut self, a: usize, b: usize) {
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 9f0ab7b3f29..fcb26530fcf 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -15,7 +15,6 @@
 #![feature(clone_to_uninit)]
 #![feature(const_black_box)]
 #![feature(const_eval_select)]
-#![feature(const_swap)]
 #![feature(const_swap_nonoverlapping)]
 #![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
diff --git a/tests/ui/consts/issue-94371.rs b/tests/ui/consts/issue-94371.rs
index ad9ee9a5a3e..b2dd7053c1f 100644
--- a/tests/ui/consts/issue-94371.rs
+++ b/tests/ui/consts/issue-94371.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(const_swap)]
-
 #[repr(C)]
 struct Demo(u64, bool, u64, u32, u64, u64, u64);
 
diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.rs b/tests/ui/consts/qualif-indirect-mutation-fail.rs
index c6e08a557c8..0f59a86b7cc 100644
--- a/tests/ui/consts/qualif-indirect-mutation-fail.rs
+++ b/tests/ui/consts/qualif-indirect-mutation-fail.rs
@@ -1,6 +1,5 @@
 //@ compile-flags: --crate-type=lib
 #![feature(const_precise_live_drops)]
-#![feature(const_swap)]
 
 // Mutable borrow of a field with drop impl.
 pub const fn f() {
diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.stderr b/tests/ui/consts/qualif-indirect-mutation-fail.stderr
index f706b7cf699..e76d7d3b670 100644
--- a/tests/ui/consts/qualif-indirect-mutation-fail.stderr
+++ b/tests/ui/consts/qualif-indirect-mutation-fail.stderr
@@ -1,5 +1,5 @@
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:13:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:12:9
    |
 LL |     let mut x = None;
    |         ^^^^^ the destructor for this type cannot be evaluated in constants
@@ -19,13 +19,13 @@ note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
 note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `A1`
-  --> $DIR/qualif-indirect-mutation-fail.rs:19:1
+  --> $DIR/qualif-indirect-mutation-fail.rs:18:1
    |
 LL | };
    | ^
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:29:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:28:9
    |
 LL |     let _z = x;
    |         ^^ the destructor for this type cannot be evaluated in constants
@@ -44,13 +44,13 @@ note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
 note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `A2`
-  --> $DIR/qualif-indirect-mutation-fail.rs:30:1
+  --> $DIR/qualif-indirect-mutation-fail.rs:29:1
    |
 LL | };
    | ^
 
 error[E0493]: destructor of `(u32, Option<String>)` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:7:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:6:9
    |
 LL |     let mut a: (u32, Option<String>) = (0, None);
    |         ^^^^^ the destructor for this type cannot be evaluated in constant functions
@@ -59,7 +59,7 @@ LL | }
    | - value is dropped here
 
 error[E0493]: destructor of `Option<T>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:34:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:33:9
    |
 LL |     let x: Option<T> = None;
    |         ^ the destructor for this type cannot be evaluated in constant functions
@@ -68,7 +68,7 @@ LL | }
    | - value is dropped here
 
 error[E0493]: destructor of `Option<T>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:42:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:41:9
    |
 LL |     let _y = x;
    |         ^^ the destructor for this type cannot be evaluated in constant functions
@@ -76,7 +76,7 @@ LL | }
    | - value is dropped here
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:50:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:49:9
    |
 LL |     let mut y: Option<String> = None;
    |         ^^^^^ the destructor for this type cannot be evaluated in constant functions
@@ -85,7 +85,7 @@ LL | }
    | - value is dropped here
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:47:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:46:9
    |
 LL |     let mut x: Option<String> = None;
    |         ^^^^^ the destructor for this type cannot be evaluated in constant functions
@@ -94,7 +94,7 @@ LL | }
    | - value is dropped here
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:60:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:59:9
    |
 LL |     let y: Option<String> = None;
    |         ^ the destructor for this type cannot be evaluated in constant functions
@@ -103,7 +103,7 @@ LL | }
    | - value is dropped here
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:57:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:56:9
    |
 LL |     let x: Option<String> = None;
    |         ^ the destructor for this type cannot be evaluated in constant functions
diff --git a/tests/ui/thread-local/thread-local-static.rs b/tests/ui/thread-local/thread-local-static.rs
index af30f538366..422dac41002 100644
--- a/tests/ui/thread-local/thread-local-static.rs
+++ b/tests/ui/thread-local/thread-local-static.rs
@@ -1,7 +1,6 @@
 //@ edition:2018
 
 #![feature(thread_local)]
-#![feature(const_swap)]
 #![allow(static_mut_refs)]
 
 #[thread_local]
diff --git a/tests/ui/thread-local/thread-local-static.stderr b/tests/ui/thread-local/thread-local-static.stderr
index 3bc1aec00c1..bb078b79748 100644
--- a/tests/ui/thread-local/thread-local-static.stderr
+++ b/tests/ui/thread-local/thread-local-static.stderr
@@ -1,5 +1,5 @@
 error[E0133]: use of mutable static is unsafe and requires unsafe function or block
-  --> $DIR/thread-local-static.rs:10:28
+  --> $DIR/thread-local-static.rs:9:28
    |
 LL |     std::mem::swap(x, &mut STATIC_VAR_2)
    |                            ^^^^^^^^^^^^ use of mutable static
@@ -7,7 +7,7 @@ LL |     std::mem::swap(x, &mut STATIC_VAR_2)
    = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
 
 error[E0625]: thread-local statics cannot be accessed at compile-time
-  --> $DIR/thread-local-static.rs:10:28
+  --> $DIR/thread-local-static.rs:9:28
    |
 LL |     std::mem::swap(x, &mut STATIC_VAR_2)
    |                            ^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 7291b1eaf7db863720f017f9f8a675ada86528e9 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 25 Dec 2024 10:49:23 +0100
Subject: rename typed_swap → typed_swap_nonoverlapping
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 compiler/rustc_codegen_ssa/src/mir/intrinsic.rs       |  2 +-
 compiler/rustc_codegen_ssa/src/traits/builder.rs      |  2 +-
 compiler/rustc_const_eval/src/interpret/intrinsics.rs |  2 +-
 compiler/rustc_hir_analysis/src/check/intrinsic.rs    |  4 +++-
 compiler/rustc_span/src/symbol.rs                     |  2 +-
 library/core/src/intrinsics/mod.rs                    | 19 +++++++++++++++++--
 library/core/src/mem/mod.rs                           |  2 +-
 .../tests/fail/intrinsics/typed-swap-invalid-array.rs |  4 ++--
 .../fail/intrinsics/typed-swap-invalid-array.stderr   |  4 ++--
 .../fail/intrinsics/typed-swap-invalid-scalar.rs      |  4 ++--
 .../fail/intrinsics/typed-swap-invalid-scalar.stderr  |  4 ++--
 .../miri/tests/fail/intrinsics/typed-swap-overlap.rs  |  4 ++--
 .../tests/fail/intrinsics/typed-swap-overlap.stderr   |  4 ++--
 tests/codegen/intrinsics/typed_swap.rs                | 12 ++++++------
 14 files changed, 43 insertions(+), 26 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
index 299b98c0a4f..304ac4544ee 100644
--- a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
@@ -75,7 +75,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         // If we're swapping something that's *not* an `OperandValue::Ref`,
         // then we can do it directly and avoid the alloca.
         // Otherwise, we'll let the fallback MIR body take care of it.
-        if let sym::typed_swap = name {
+        if let sym::typed_swap_nonoverlapping = name {
             let pointee_ty = fn_args.type_at(0);
             let pointee_layout = bx.layout_of(pointee_ty);
             if !bx.is_backend_ref(pointee_layout)
diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index b0138ac8bfe..3ee13b19f66 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -382,7 +382,7 @@ pub trait BuilderMethods<'a, 'tcx>:
     /// Avoids `alloca`s for Immediates and ScalarPairs.
     ///
     /// FIXME: Maybe do something smarter for Ref types too?
-    /// For now, the `typed_swap` intrinsic just doesn't call this for those
+    /// For now, the `typed_swap_nonoverlapping` intrinsic just doesn't call this for those
     /// cases (in non-debug), preferring the fallback body instead.
     fn typed_place_swap(
         &mut self,
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 44f6335dc7f..04346af41fc 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -424,7 +424,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let result = self.raw_eq_intrinsic(&args[0], &args[1])?;
                 self.write_scalar(result, dest)?;
             }
-            sym::typed_swap => {
+            sym::typed_swap_nonoverlapping => {
                 self.typed_swap_intrinsic(&args[0], &args[1])?;
             }
 
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 39479401910..0f329639cc1 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -496,7 +496,9 @@ pub fn check_intrinsic_type(
                 (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
             }
 
-            sym::typed_swap => (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)); 2], tcx.types.unit),
+            sym::typed_swap_nonoverlapping => {
+                (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)); 2], tcx.types.unit)
+            }
 
             sym::discriminant_value => {
                 let assoc_items = tcx.associated_item_def_ids(
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 3d202f11722..b2c259cc5ca 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2058,7 +2058,7 @@ symbols! {
         type_macros,
         type_name,
         type_privacy_lints,
-        typed_swap,
+        typed_swap_nonoverlapping,
         u128,
         u128_legacy_const_max,
         u128_legacy_const_min,
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 9844243d168..7d06fc8a692 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -3940,6 +3940,21 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
     false
 }
 
+#[rustc_nounwind]
+#[inline]
+#[rustc_intrinsic]
+#[rustc_intrinsic_const_stable_indirect]
+#[rustc_allow_const_fn_unstable(const_swap_nonoverlapping)] // this is anyway not called since CTFE implements the intrinsic
+#[cfg(bootstrap)]
+pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
+    // SAFETY: The caller provided single non-overlapping items behind
+    // pointers, so swapping them with `count: 1` is fine.
+    unsafe { ptr::swap_nonoverlapping(x, y, 1) };
+}
+
+#[cfg(bootstrap)]
+pub use typed_swap as typed_swap_nonoverlapping;
+
 /// Non-overlapping *typed* swap of a single value.
 ///
 /// The codegen backends will replace this with a better implementation when
@@ -3953,10 +3968,10 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 #[rustc_nounwind]
 #[inline]
 #[rustc_intrinsic]
-// Const-unstable because `swap_nonoverlapping` is const-unstable.
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_allow_const_fn_unstable(const_swap_nonoverlapping)] // this is anyway not called since CTFE implements the intrinsic
-pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
+#[cfg(not(bootstrap))]
+pub const unsafe fn typed_swap_nonoverlapping<T>(x: *mut T, y: *mut T) {
     // SAFETY: The caller provided single non-overlapping items behind
     // pointers, so swapping them with `count: 1` is fine.
     unsafe { ptr::swap_nonoverlapping(x, y, 1) };
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index 1576eb43152..2d66e5c2f2a 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -730,7 +730,7 @@ pub unsafe fn uninitialized<T>() -> T {
 pub const fn swap<T>(x: &mut T, y: &mut T) {
     // SAFETY: `&mut` guarantees these are typed readable and writable
     // as well as non-overlapping.
-    unsafe { intrinsics::typed_swap(x, y) }
+    unsafe { intrinsics::typed_swap_nonoverlapping(x, y) }
 }
 
 /// Replaces `dest` with the default value of `T`, returning the previous `dest` value.
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.rs b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.rs
index 89fdd2a01eb..de154d771a0 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.rs
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.rs
@@ -1,7 +1,7 @@
 #![feature(core_intrinsics)]
 #![feature(rustc_attrs)]
 
-use std::intrinsics::typed_swap;
+use std::intrinsics::typed_swap_nonoverlapping;
 use std::ptr::addr_of_mut;
 
 fn invalid_array() {
@@ -10,7 +10,7 @@ fn invalid_array() {
     unsafe {
         let a = addr_of_mut!(a).cast::<[bool; 100]>();
         let b = addr_of_mut!(b).cast::<[bool; 100]>();
-        typed_swap(a, b); //~ERROR: constructing invalid value
+        typed_swap_nonoverlapping(a, b); //~ERROR: constructing invalid value
     }
 }
 
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr
index 20b20412e75..5884d13a2ad 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: constructing invalid value at [0]: encountered 0x02, but expected a boolean
   --> tests/fail/intrinsics/typed-swap-invalid-array.rs:LL:CC
    |
-LL |         typed_swap(a, b);
-   |         ^^^^^^^^^^^^^^^^ constructing invalid value at [0]: encountered 0x02, but expected a boolean
+LL |         typed_swap_nonoverlapping(a, b);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at [0]: encountered 0x02, but expected a boolean
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.rs b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.rs
index 9d014a523f8..3cc96e79fec 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.rs
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.rs
@@ -1,7 +1,7 @@
 #![feature(core_intrinsics)]
 #![feature(rustc_attrs)]
 
-use std::intrinsics::typed_swap;
+use std::intrinsics::typed_swap_nonoverlapping;
 use std::ptr::addr_of_mut;
 
 fn invalid_scalar() {
@@ -10,7 +10,7 @@ fn invalid_scalar() {
     unsafe {
         let a = addr_of_mut!(a).cast::<bool>();
         let b = addr_of_mut!(b).cast::<bool>();
-        typed_swap(a, b); //~ERROR: constructing invalid value
+        typed_swap_nonoverlapping(a, b); //~ERROR: constructing invalid value
     }
 }
 
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.stderr b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.stderr
index 6062465f36a..9804233c7fa 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: constructing invalid value: encountered 0x02, but expected a boolean
   --> tests/fail/intrinsics/typed-swap-invalid-scalar.rs:LL:CC
    |
-LL |         typed_swap(a, b);
-   |         ^^^^^^^^^^^^^^^^ constructing invalid value: encountered 0x02, but expected a boolean
+LL |         typed_swap_nonoverlapping(a, b);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered 0x02, but expected a boolean
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.rs b/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.rs
index 7a9ad63ad7b..7b1be4abb15 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.rs
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.rs
@@ -1,13 +1,13 @@
 #![feature(core_intrinsics)]
 #![feature(rustc_attrs)]
 
-use std::intrinsics::typed_swap;
+use std::intrinsics::typed_swap_nonoverlapping;
 use std::ptr::addr_of_mut;
 
 fn main() {
     let mut a = [0_u8; 100];
     unsafe {
         let a = addr_of_mut!(a);
-        typed_swap(a, a); //~ERROR: called on overlapping ranges
+        typed_swap_nonoverlapping(a, a); //~ERROR: called on overlapping ranges
     }
 }
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.stderr b/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.stderr
index 5c9cbb78c1e..6d578841fe5 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-overlap.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: `copy_nonoverlapping` called on overlapping ranges
   --> tests/fail/intrinsics/typed-swap-overlap.rs:LL:CC
    |
-LL |         typed_swap(a, a);
-   |         ^^^^^^^^^^^^^^^^ `copy_nonoverlapping` called on overlapping ranges
+LL |         typed_swap_nonoverlapping(a, a);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `copy_nonoverlapping` called on overlapping ranges
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/tests/codegen/intrinsics/typed_swap.rs b/tests/codegen/intrinsics/typed_swap.rs
index e73931d1d54..6b55078407a 100644
--- a/tests/codegen/intrinsics/typed_swap.rs
+++ b/tests/codegen/intrinsics/typed_swap.rs
@@ -8,14 +8,14 @@
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]
 
-use std::intrinsics::typed_swap;
+use std::intrinsics::typed_swap_nonoverlapping;
 
 // CHECK-LABEL: @swap_unit(
 #[no_mangle]
 pub unsafe fn swap_unit(x: &mut (), y: &mut ()) {
     // CHECK: start
     // CHECK-NEXT: ret void
-    typed_swap(x, y)
+    typed_swap_nonoverlapping(x, y)
 }
 
 // CHECK-LABEL: @swap_i32(
@@ -32,7 +32,7 @@ pub unsafe fn swap_i32(x: &mut i32, y: &mut i32) {
     // OPT3: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %x, ptr align 4 %y, i64 4, i1 false)
     // CHECK: store i32 %[[TEMP]], ptr %y, align 4
     // CHECK: ret void
-    typed_swap(x, y)
+    typed_swap_nonoverlapping(x, y)
 }
 
 // CHECK-LABEL: @swap_pair(
@@ -47,7 +47,7 @@ pub unsafe fn swap_pair(x: &mut (i32, u32), y: &mut (i32, u32)) {
     // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %x, ptr align 4 %y, i64 8, i1 false)
     // CHECK: store i32
     // CHECK: store i32
-    typed_swap(x, y)
+    typed_swap_nonoverlapping(x, y)
 }
 
 // CHECK-LABEL: @swap_str(
@@ -63,7 +63,7 @@ pub unsafe fn swap_str<'a>(x: &mut &'a str, y: &mut &'a str) {
     // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 16, i1 false)
     // CHECK: store ptr
     // CHECK: store i64
-    typed_swap(x, y)
+    typed_swap_nonoverlapping(x, y)
 }
 
 // OPT0-LABEL: @swap_string(
@@ -73,5 +73,5 @@ pub unsafe fn swap_string(x: &mut String, y: &mut String) {
     // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %[[TEMP]], ptr align 8 %x, i64 24, i1 false)
     // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 24, i1 false)
     // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 %[[TEMP]], i64 24, i1 false)
-    typed_swap(x, y)
+    typed_swap_nonoverlapping(x, y)
 }
-- 
cgit 1.4.1-3-g733a5


From c880e8bbcb3479092b2b6e00889a3f5639ee425f Mon Sep 17 00:00:00 2001
From: jyn <github@jyn.dev>
Date: Tue, 24 Dec 2024 16:21:22 -0500
Subject: Run `tests/ui/backtrace/std-backtrace.rs` on MSVC.

The original PR which disabled these only mentions them being broken on
i686 msvc. Let's try to see if we can reenable this test for msvc (both
32-bit and 64-bit).
---
 tests/ui/backtrace/std-backtrace.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'tests')

diff --git a/tests/ui/backtrace/std-backtrace.rs b/tests/ui/backtrace/std-backtrace.rs
index b4806457877..57d953a8640 100644
--- a/tests/ui/backtrace/std-backtrace.rs
+++ b/tests/ui/backtrace/std-backtrace.rs
@@ -3,7 +3,6 @@
 //@ ignore-wasm32 spawning processes is not supported
 //@ ignore-openbsd no support for libbacktrace without filename
 //@ ignore-sgx no processes
-//@ ignore-msvc see #62897 and `backtrace-debuginfo.rs` test
 //@ ignore-fuchsia Backtraces not symbolized
 //@ compile-flags:-g
 //@ compile-flags:-Cstrip=none
-- 
cgit 1.4.1-3-g733a5


From 592259930b27525789f14f07396f02b254d4dfc9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 25 Dec 2024 20:14:43 +0000
Subject: Report correct SelectionError for ConstArgHasType in new solver
 fulfill

---
 compiler/rustc_trait_selection/src/solve/fulfill.rs   | 19 ++++++++++++++++++-
 .../const-in-impl-fn-return-type.current.stderr       | 15 +++++++++++++++
 .../const-in-impl-fn-return-type.next.stderr          | 15 +++++++++++++++
 .../issue-114918/const-in-impl-fn-return-type.rs      |  5 +++++
 .../issue-114918/const-in-impl-fn-return-type.stderr  | 15 ---------------
 5 files changed, 53 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.current.stderr
 create mode 100644 tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.next.stderr
 delete mode 100644 tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr

(limited to 'tests')

diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 2b2623a050e..c79a8abca20 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -10,9 +10,9 @@ use rustc_infer::traits::{
     self, FromSolverError, MismatchedProjectionTypes, Obligation, ObligationCause,
     ObligationCauseCode, PredicateObligation, PredicateObligations, SelectionError, TraitEngine,
 };
-use rustc_middle::bug;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{self, TyCtxt};
+use rustc_middle::{bug, span_bug};
 use rustc_next_trait_solver::solve::{GenerateProofTree, HasChanged, SolverDelegateEvalExt as _};
 use tracing::{instrument, trace};
 
@@ -258,6 +258,23 @@ fn fulfillment_error_for_no_solution<'tcx>(
                 MismatchedProjectionTypes { err: TypeError::Mismatch },
             )
         }
+        ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, expected_ty)) => {
+            let ct_ty = match ct.kind() {
+                ty::ConstKind::Unevaluated(uv) => {
+                    infcx.tcx.type_of(uv.def).instantiate(infcx.tcx, uv.args)
+                }
+                ty::ConstKind::Param(param_ct) => param_ct.find_ty_from_env(obligation.param_env),
+                _ => span_bug!(
+                    obligation.cause.span,
+                    "ConstArgHasWrongType failed but we don't know how to compute type"
+                ),
+            };
+            FulfillmentErrorCode::Select(SelectionError::ConstArgHasWrongType {
+                ct,
+                ct_ty,
+                expected_ty,
+            })
+        }
         ty::PredicateKind::NormalizesTo(..) => {
             FulfillmentErrorCode::Project(MismatchedProjectionTypes { err: TypeError::Mismatch })
         }
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.current.stderr b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.current.stderr
new file mode 100644
index 00000000000..1bcc0dbaf67
--- /dev/null
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.current.stderr
@@ -0,0 +1,15 @@
+error[E0308]: mismatched types
+  --> $DIR/const-in-impl-fn-return-type.rs:20:39
+   |
+LL |     fn func<const N: u32>() -> [(); { () }] {
+   |                                       ^^ expected `usize`, found `()`
+
+error: the constant `N` is not of type `usize`
+  --> $DIR/const-in-impl-fn-return-type.rs:12:32
+   |
+LL |     fn func<const N: u32>() -> [(); N];
+   |                                ^^^^^^^ expected `usize`, found `u32`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.next.stderr b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.next.stderr
new file mode 100644
index 00000000000..1bcc0dbaf67
--- /dev/null
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.next.stderr
@@ -0,0 +1,15 @@
+error[E0308]: mismatched types
+  --> $DIR/const-in-impl-fn-return-type.rs:20:39
+   |
+LL |     fn func<const N: u32>() -> [(); { () }] {
+   |                                       ^^ expected `usize`, found `()`
+
+error: the constant `N` is not of type `usize`
+  --> $DIR/const-in-impl-fn-return-type.rs:12:32
+   |
+LL |     fn func<const N: u32>() -> [(); N];
+   |                                ^^^^^^^ expected `usize`, found `u32`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
index 5eef2688721..6bbac9d45bb 100644
--- a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
@@ -1,4 +1,9 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+
 // Regression test for #114918
+
 // Test that a const generic enclosed in a block within the return type
 // of an impl fn produces a type mismatch error instead of triggering
 // a const eval cycle
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
deleted file mode 100644
index 8017e5446cc..00000000000
--- a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/const-in-impl-fn-return-type.rs:15:39
-   |
-LL |     fn func<const N: u32>() -> [(); { () }] {
-   |                                       ^^ expected `usize`, found `()`
-
-error: the constant `N` is not of type `usize`
-  --> $DIR/const-in-impl-fn-return-type.rs:7:32
-   |
-LL |     fn func<const N: u32>() -> [(); N];
-   |                                ^^^^^^^ expected `usize`, found `u32`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
-- 
cgit 1.4.1-3-g733a5


From 01307cf03f5b95759a8e84bce659f6326e247049 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Tue, 24 Dec 2024 23:41:50 +0000
Subject: Implement `default_overrides_default_fields` lint

Detect when a manual `Default` implementation isn't using the existing default field values and suggest using `..` instead:

```
error: `Default` impl doesn't use the declared default field values
  --> $DIR/manual-default-impl-could-be-derived.rs:14:1
   |
LL | / impl Default for A {
LL | |     fn default() -> Self {
LL | |         A {
LL | |             y: 0,
   | |                - this field has a default value
...  |
LL | | }
   | |_^
   |
   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
note: the lint level is defined here
  --> $DIR/manual-default-impl-could-be-derived.rs:5:9
   |
LL | #![deny(default_overrides_default_fields)]
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```
---
 .../rustc_lint/src/default_could_be_derived.rs     | 185 ++++++++++++++++++++
 compiler/rustc_lint/src/lib.rs                     |   3 +
 .../manual-default-impl-could-be-derived.rs        | 194 +++++++++++++++++++++
 .../manual-default-impl-could-be-derived.stderr    | 144 +++++++++++++++
 4 files changed, 526 insertions(+)
 create mode 100644 compiler/rustc_lint/src/default_could_be_derived.rs
 create mode 100644 tests/ui/structs/manual-default-impl-could-be-derived.rs
 create mode 100644 tests/ui/structs/manual-default-impl-could-be-derived.stderr

(limited to 'tests')

diff --git a/compiler/rustc_lint/src/default_could_be_derived.rs b/compiler/rustc_lint/src/default_could_be_derived.rs
new file mode 100644
index 00000000000..d95cbb05158
--- /dev/null
+++ b/compiler/rustc_lint/src/default_could_be_derived.rs
@@ -0,0 +1,185 @@
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Diag;
+use rustc_hir as hir;
+use rustc_middle::ty;
+use rustc_session::{declare_lint, impl_lint_pass};
+use rustc_span::Symbol;
+use rustc_span::symbol::sym;
+
+use crate::{LateContext, LateLintPass};
+
+declare_lint! {
+    /// The `default_overrides_default_fields` lint checks for manual `impl` blocks of the
+    /// `Default` trait of types with default field values.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #![feature(default_field_values)]
+    /// struct Foo {
+    ///     x: i32 = 101,
+    ///     y: NonDefault,
+    /// }
+    ///
+    /// struct NonDefault;
+    ///
+    /// #[deny(default_overrides_default_fields)]
+    /// impl Default for Foo {
+    ///     fn default() -> Foo {
+    ///         Foo { x: 100, y: NonDefault }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Manually writing a `Default` implementation for a type that has
+    /// default field values runs the risk of diverging behavior between
+    /// `Type { .. }` and `<Type as Default>::default()`, which would be a
+    /// foot-gun for users of that type that would expect these to be
+    /// equivalent. If `Default` can't be derived due to some fields not
+    /// having a `Default` implementation, we encourage the use of `..` for
+    /// the fields that do have a default field value.
+    pub DEFAULT_OVERRIDES_DEFAULT_FIELDS,
+    Deny,
+    "detect `Default` impl that should use the type's default field values",
+    @feature_gate = default_field_values;
+}
+
+#[derive(Default)]
+pub(crate) struct DefaultCouldBeDerived;
+
+impl_lint_pass!(DefaultCouldBeDerived => [DEFAULT_OVERRIDES_DEFAULT_FIELDS]);
+
+impl<'tcx> LateLintPass<'tcx> for DefaultCouldBeDerived {
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
+        // Look for manual implementations of `Default`.
+        let Some(default_def_id) = cx.tcx.get_diagnostic_item(sym::Default) else { return };
+        let hir::ImplItemKind::Fn(_sig, body_id) = impl_item.kind else { return };
+        let assoc = cx.tcx.associated_item(impl_item.owner_id);
+        let parent = assoc.container_id(cx.tcx);
+        if cx.tcx.has_attr(parent, sym::automatically_derived) {
+            // We don't care about what `#[derive(Default)]` produces in this lint.
+            return;
+        }
+        let Some(trait_ref) = cx.tcx.impl_trait_ref(parent) else { return };
+        let trait_ref = trait_ref.instantiate_identity();
+        if trait_ref.def_id != default_def_id {
+            return;
+        }
+        let ty = trait_ref.self_ty();
+        let ty::Adt(def, _) = ty.kind() else { return };
+
+        // We now know we have a manually written definition of a `<Type as Default>::default()`.
+
+        let hir = cx.tcx.hir();
+
+        let type_def_id = def.did();
+        let body = hir.body(body_id);
+
+        // FIXME: evaluate bodies with statements and evaluate bindings to see if they would be
+        // derivable.
+        let hir::ExprKind::Block(hir::Block { stmts: _, expr: Some(expr), .. }, None) =
+            body.value.kind
+        else {
+            return;
+        };
+
+        // Keep a mapping of field name to `hir::FieldDef` for every field in the type. We'll use
+        // these to check for things like checking whether it has a default or using its span for
+        // suggestions.
+        let orig_fields = match hir.get_if_local(type_def_id) {
+            Some(hir::Node::Item(hir::Item {
+                kind:
+                    hir::ItemKind::Struct(hir::VariantData::Struct { fields, recovered: _ }, _generics),
+                ..
+            })) => fields.iter().map(|f| (f.ident.name, f)).collect::<FxHashMap<_, _>>(),
+            _ => return,
+        };
+
+        // We check `fn default()` body is a single ADT literal and get all the fields that are
+        // being set.
+        let hir::ExprKind::Struct(_qpath, fields, tail) = expr.kind else { return };
+
+        // We have a struct literal
+        //
+        // struct Foo {
+        //     field: Type,
+        // }
+        //
+        // impl Default for Foo {
+        //     fn default() -> Foo {
+        //         Foo {
+        //             field: val,
+        //         }
+        //     }
+        // }
+        //
+        // We would suggest `#[derive(Default)]` if `field` has a default value, regardless of what
+        // it is; we don't want to encourage divergent behavior between `Default::default()` and
+        // `..`.
+
+        if let hir::StructTailExpr::Base(_) = tail {
+            // This is *very* niche. We'd only get here if someone wrote
+            // impl Default for Ty {
+            //     fn default() -> Ty {
+            //         Ty { ..something() }
+            //     }
+            // }
+            // where `something()` would have to be a call or path.
+            // We have nothing meaninful to do with this.
+            return;
+        }
+
+        // At least one of the fields with a default value have been overriden in
+        // the `Default` implementation. We suggest removing it and relying on `..`
+        // instead.
+        let any_default_field_given =
+            fields.iter().any(|f| orig_fields.get(&f.ident.name).and_then(|f| f.default).is_some());
+
+        if !any_default_field_given {
+            // None of the default fields were actually provided explicitly, so the manual impl
+            // doesn't override them (the user used `..`), so there's no risk of divergent behavior.
+            return;
+        }
+
+        let Some(local) = parent.as_local() else { return };
+        let hir_id = cx.tcx.local_def_id_to_hir_id(local);
+        let hir::Node::Item(item) = cx.tcx.hir_node(hir_id) else { return };
+        cx.tcx.node_span_lint(DEFAULT_OVERRIDES_DEFAULT_FIELDS, hir_id, item.span, |diag| {
+            mk_lint(diag, orig_fields, fields);
+        });
+    }
+}
+
+fn mk_lint(
+    diag: &mut Diag<'_, ()>,
+    orig_fields: FxHashMap<Symbol, &hir::FieldDef<'_>>,
+    fields: &[hir::ExprField<'_>],
+) {
+    diag.primary_message("`Default` impl doesn't use the declared default field values");
+
+    // For each field in the struct expression
+    //   - if the field in the type has a default value, it should be removed
+    //   - elif the field is an expression that could be a default value, it should be used as the
+    //     field's default value (FIXME: not done).
+    //   - else, we wouldn't touch this field, it would remain in the manual impl
+    let mut removed_all_fields = true;
+    for field in fields {
+        if orig_fields.get(&field.ident.name).and_then(|f| f.default).is_some() {
+            diag.span_label(field.expr.span, "this field has a default value");
+        } else {
+            removed_all_fields = false;
+        }
+    }
+
+    diag.help(if removed_all_fields {
+        "to avoid divergence in behavior between `Struct { .. }` and \
+         `<Struct as Default>::default()`, derive the `Default`"
+    } else {
+        "use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them \
+         diverging over time"
+    });
+}
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index d7f0d2a6941..1465c2cff7b 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -41,6 +41,7 @@ mod async_fn_in_trait;
 pub mod builtin;
 mod context;
 mod dangling;
+mod default_could_be_derived;
 mod deref_into_dyn_supertrait;
 mod drop_forget_useless;
 mod early;
@@ -85,6 +86,7 @@ use async_closures::AsyncClosureUsage;
 use async_fn_in_trait::AsyncFnInTrait;
 use builtin::*;
 use dangling::*;
+use default_could_be_derived::DefaultCouldBeDerived;
 use deref_into_dyn_supertrait::*;
 use drop_forget_useless::*;
 use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
@@ -189,6 +191,7 @@ late_lint_methods!(
         BuiltinCombinedModuleLateLintPass,
         [
             ForLoopsOverFallibles: ForLoopsOverFallibles,
+            DefaultCouldBeDerived: DefaultCouldBeDerived::default(),
             DerefIntoDynSupertrait: DerefIntoDynSupertrait,
             DropForgetUseless: DropForgetUseless,
             ImproperCTypesDeclarations: ImproperCTypesDeclarations,
diff --git a/tests/ui/structs/manual-default-impl-could-be-derived.rs b/tests/ui/structs/manual-default-impl-could-be-derived.rs
new file mode 100644
index 00000000000..773b7389988
--- /dev/null
+++ b/tests/ui/structs/manual-default-impl-could-be-derived.rs
@@ -0,0 +1,194 @@
+// Warn when we encounter a manual `Default` impl that could be derived.
+// Restricted only to types using `default_field_values`.
+#![feature(default_field_values)]
+#![allow(dead_code)]
+#![deny(default_overrides_default_fields)]
+struct S(i32);
+fn s() -> S { S(1) }
+
+struct A {
+    x: S,
+    y: i32 = 1,
+}
+
+impl Default for A { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        A {
+            y: 0,
+            x: s(),
+        }
+    }
+}
+
+struct B {
+    x: S = S(3),
+    y: i32 = 1,
+}
+
+impl Default for B { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        B {
+            x: s(),
+            y: 0,
+        }
+    }
+}
+
+struct C {
+    x: S,
+    y: i32 = 1,
+    z: i32 = 1,
+}
+
+impl Default for C { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        C {
+            x: s(),
+            y: 0,
+            ..
+        }
+    }
+}
+
+struct D {
+    x: S,
+    y: i32 = 1,
+    z: i32 = 1,
+}
+
+impl Default for D { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        D {
+            y: 0,
+            x: s(),
+            ..
+        }
+    }
+}
+
+struct E {
+    x: S,
+    y: i32 = 1,
+    z: i32 = 1,
+}
+
+impl Default for E { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        E {
+            y: 0,
+            z: 0,
+            x: s(),
+        }
+    }
+}
+
+// Let's ensure that the span for `x` and the span for `y` don't overlap when suggesting their
+// removal in favor of their default field values.
+struct E2 {
+    x: S,
+    y: i32 = 1,
+    z: i32 = 1,
+}
+
+impl Default for E2 { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        E2 {
+            x: s(),
+            y: i(),
+            z: 0,
+        }
+    }
+}
+
+fn i() -> i32 {
+    1
+}
+
+// Account for a `const fn` being the `Default::default()` of a field's type.
+struct F {
+    x: G,
+    y: i32 = 1,
+}
+
+impl Default for F { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        F {
+            x: g_const(),
+            y: 0,
+        }
+    }
+}
+
+struct G;
+
+impl Default for G { // ok
+    fn default() -> Self {
+        g_const()
+    }
+}
+
+const fn g_const() -> G {
+    G
+}
+
+// Account for a `const fn` being used in `Default::default()`, even if the type doesn't use it as
+// its own `Default`. We suggest setting the default field value in that case.
+struct H {
+    x: I,
+    y: i32 = 1,
+}
+
+impl Default for H { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        H {
+            x: i_const(),
+            y: 0,
+        }
+    }
+}
+
+struct I;
+
+const fn i_const() -> I {
+    I
+}
+
+// Account for a `const` and struct literal being the `Default::default()` of a field's type.
+struct M {
+    x: N,
+    y: i32 = 1,
+    z: A,
+}
+
+impl Default for M { // ok, `y` is not specified
+    fn default() -> Self {
+        M {
+            x: N_CONST,
+            z: A {
+                x: S(0),
+                y: 0,
+            },
+            ..
+        }
+    }
+}
+
+struct N;
+
+const N_CONST: N = N;
+
+struct O {
+    x: Option<i32>,
+    y: i32 = 1,
+}
+
+impl Default for O { //~ ERROR default_overrides_default_fields
+    fn default() -> Self {
+        O {
+            x: None,
+            y: 1,
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/structs/manual-default-impl-could-be-derived.stderr b/tests/ui/structs/manual-default-impl-could-be-derived.stderr
new file mode 100644
index 00000000000..e8f607fac7e
--- /dev/null
+++ b/tests/ui/structs/manual-default-impl-could-be-derived.stderr
@@ -0,0 +1,144 @@
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:14:1
+   |
+LL | / impl Default for A {
+LL | |     fn default() -> Self {
+LL | |         A {
+LL | |             y: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+note: the lint level is defined here
+  --> $DIR/manual-default-impl-could-be-derived.rs:5:9
+   |
+LL | #![deny(default_overrides_default_fields)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:28:1
+   |
+LL | / impl Default for B {
+LL | |     fn default() -> Self {
+LL | |         B {
+LL | |             x: s(),
+   | |                --- this field has a default value
+LL | |             y: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: to avoid divergence in behavior between `Struct { .. }` and `<Struct as Default>::default()`, derive the `Default`
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:43:1
+   |
+LL | / impl Default for C {
+LL | |     fn default() -> Self {
+LL | |         C {
+LL | |             x: s(),
+LL | |             y: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:59:1
+   |
+LL | / impl Default for D {
+LL | |     fn default() -> Self {
+LL | |         D {
+LL | |             y: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:75:1
+   |
+LL | / impl Default for E {
+LL | |     fn default() -> Self {
+LL | |         E {
+LL | |             y: 0,
+   | |                - this field has a default value
+LL | |             z: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:93:1
+   |
+LL | / impl Default for E2 {
+LL | |     fn default() -> Self {
+LL | |         E2 {
+LL | |             x: s(),
+LL | |             y: i(),
+   | |                --- this field has a default value
+LL | |             z: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:113:1
+   |
+LL | / impl Default for F {
+LL | |     fn default() -> Self {
+LL | |         F {
+LL | |             x: g_const(),
+LL | |             y: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:141:1
+   |
+LL | / impl Default for H {
+LL | |     fn default() -> Self {
+LL | |         H {
+LL | |             x: i_const(),
+LL | |             y: 0,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: `Default` impl doesn't use the declared default field values
+  --> $DIR/manual-default-impl-could-be-derived.rs:185:1
+   |
+LL | / impl Default for O {
+LL | |     fn default() -> Self {
+LL | |         O {
+LL | |             x: None,
+LL | |             y: 1,
+   | |                - this field has a default value
+...  |
+LL | | }
+   | |_^
+   |
+   = help: use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them diverging over time
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 801c1d8b907389eac18f3c4f0d66de6077795af7 Mon Sep 17 00:00:00 2001
From: jyn <github@jyn.dev>
Date: Wed, 25 Dec 2024 19:31:25 -0500
Subject: fix default-backtrace-ice test

when running `tests/ui/panics/default-backtrace-ice.rs locally it gave this error:
```
failures:

---- [ui] tests/ui/panics/default-backtrace-ice.rs stdout ----
Saved the actual stderr to "/home/jyn/src/rust3/build/x86_64-unknown-linux-gnu/test/ui/panics/default-backtrace-ice/default-backtrace-ice.stderr"
diff of stderr:

7
8	aborting due to `-Z treat-err-as-bug=1`
9	stack backtrace:
-	(end_short_backtrace)
-	(begin_short_backtrace)
-	(end_short_backtrace)
-	(begin_short_backtrace)
+	      [... omitted 22 frames ...]
+
```

this is a regression from setting RUST_BACKTRACE=1 by default. we need to turn off the new behavior when running UI tests so that they reflect our dist compiler. normally that's done by checking `sess.unstable_opts.ui_testing`, but this happens extremely early in the compiler before we've expanded arg files. do an extremely simple hack that doesn't work in all cases - we don't need it to work in all cases, only when running UI tests.
---
 compiler/rustc_driver_impl/src/lib.rs        | 4 +++-
 tests/ui/panics/default-backtrace-ice.rs     | 2 ++
 tests/ui/panics/default-backtrace-ice.stderr | 2 +-
 3 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index b13cc4d0b06..90f382e7226 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -1388,7 +1388,9 @@ pub fn install_ice_hook(
     // opt in to less-verbose backtraces by manually setting "RUST_BACKTRACE"
     // (e.g. `RUST_BACKTRACE=1`)
     if env::var_os("RUST_BACKTRACE").is_none() {
-        if env!("CFG_RELEASE_CHANNEL") == "dev" {
+        // HACK: this check is extremely dumb, but we don't really need it to be smarter since this should only happen in the test suite anyway.
+        let ui_testing = std::env::args().any(|arg| arg == "-Zui-testing");
+        if env!("CFG_RELEASE_CHANNEL") == "dev" && !ui_testing {
             panic::set_backtrace_style(panic::BacktraceStyle::Short);
         } else {
             panic::set_backtrace_style(panic::BacktraceStyle::Full);
diff --git a/tests/ui/panics/default-backtrace-ice.rs b/tests/ui/panics/default-backtrace-ice.rs
index 718d1da5bb7..7953283f028 100644
--- a/tests/ui/panics/default-backtrace-ice.rs
+++ b/tests/ui/panics/default-backtrace-ice.rs
@@ -1,6 +1,8 @@
 //@ unset-rustc-env:RUST_BACKTRACE
 //@ compile-flags:-Z treat-err-as-bug=1
 //@ error-pattern:stack backtrace:
+// Verify this is a full backtrace, not a short backtrace.
+//@ error-pattern:__rust_begin_short_backtrace
 //@ failure-status:101
 //@ ignore-msvc
 //@ normalize-stderr-test: "note: .*" -> ""
diff --git a/tests/ui/panics/default-backtrace-ice.stderr b/tests/ui/panics/default-backtrace-ice.stderr
index 23b863568bc..046b2cca7f9 100644
--- a/tests/ui/panics/default-backtrace-ice.stderr
+++ b/tests/ui/panics/default-backtrace-ice.stderr
@@ -1,5 +1,5 @@
 error: internal compiler error[E0425]: cannot find value `missing_ident` in this scope
-  --> $DIR/default-backtrace-ice.rs:21:13
+  --> $DIR/default-backtrace-ice.rs:23:13
    |
 LL | fn main() { missing_ident; }
    |             ^^^^^^^^^^^^^ not found in this scope
-- 
cgit 1.4.1-3-g733a5


From 1511de3c9e7716a4fd7aa7ea53140b2c44c8a4dd Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 26 Dec 2024 15:47:26 +1100
Subject: Add more `begin_panic` normalizations to panic backtrace tests

---
 tests/ui/panics/issue-47429-short-backtraces.rs             | 2 ++
 tests/ui/panics/issue-47429-short-backtraces.run.stderr     | 2 +-
 tests/ui/panics/runtime-switch.rs                           | 2 ++
 tests/ui/panics/runtime-switch.run.stderr                   | 2 +-
 tests/ui/panics/short-ice-remove-middle-frames-2.rs         | 2 ++
 tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr | 2 +-
 tests/ui/panics/short-ice-remove-middle-frames.rs           | 2 ++
 tests/ui/panics/short-ice-remove-middle-frames.run.stderr   | 2 +-
 8 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/panics/issue-47429-short-backtraces.rs b/tests/ui/panics/issue-47429-short-backtraces.rs
index 0d216fdd653..56b9cfcd361 100644
--- a/tests/ui/panics/issue-47429-short-backtraces.rs
+++ b/tests/ui/panics/issue-47429-short-backtraces.rs
@@ -9,6 +9,8 @@
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
 //@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+// This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
+//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
 //@ normalize-stderr-test: "\n +at [^\n]+" -> ""
 
diff --git a/tests/ui/panics/issue-47429-short-backtraces.run.stderr b/tests/ui/panics/issue-47429-short-backtraces.run.stderr
index 1078a2fbc90..6a22e0215fe 100644
--- a/tests/ui/panics/issue-47429-short-backtraces.run.stderr
+++ b/tests/ui/panics/issue-47429-short-backtraces.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/issue-47429-short-backtraces.rs:24:5:
+thread 'main' panicked at $DIR/issue-47429-short-backtraces.rs:26:5:
 explicit panic
 stack backtrace:
    0: std::panicking::begin_panic
diff --git a/tests/ui/panics/runtime-switch.rs b/tests/ui/panics/runtime-switch.rs
index 10dce250909..e06f05d5fe8 100644
--- a/tests/ui/panics/runtime-switch.rs
+++ b/tests/ui/panics/runtime-switch.rs
@@ -9,6 +9,8 @@
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
 //@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+// This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
+//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
 //@ normalize-stderr-test: "\n +at [^\n]+" -> ""
 
diff --git a/tests/ui/panics/runtime-switch.run.stderr b/tests/ui/panics/runtime-switch.run.stderr
index abbb91eba60..35be010d6be 100644
--- a/tests/ui/panics/runtime-switch.run.stderr
+++ b/tests/ui/panics/runtime-switch.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/runtime-switch.rs:27:5:
+thread 'main' panicked at $DIR/runtime-switch.rs:29:5:
 explicit panic
 stack backtrace:
    0: std::panicking::begin_panic
diff --git a/tests/ui/panics/short-ice-remove-middle-frames-2.rs b/tests/ui/panics/short-ice-remove-middle-frames-2.rs
index c2f04cd122c..9b6d34d97b2 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames-2.rs
+++ b/tests/ui/panics/short-ice-remove-middle-frames-2.rs
@@ -12,6 +12,8 @@
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
 //@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+// This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
+//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
 //@ normalize-stderr-test: "\n +at [^\n]+" -> ""
 
diff --git a/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr b/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
index 67577f3568e..ab23ce78062 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
+++ b/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/short-ice-remove-middle-frames-2.rs:61:5:
+thread 'main' panicked at $DIR/short-ice-remove-middle-frames-2.rs:63:5:
 debug!!!
 stack backtrace:
    0: std::panicking::begin_panic
diff --git a/tests/ui/panics/short-ice-remove-middle-frames.rs b/tests/ui/panics/short-ice-remove-middle-frames.rs
index c035e7e69bc..b1af247130b 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames.rs
+++ b/tests/ui/panics/short-ice-remove-middle-frames.rs
@@ -13,6 +13,8 @@
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
 //@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+// This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
+//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
 //@ normalize-stderr-test: "\n +at [^\n]+" -> ""
 
diff --git a/tests/ui/panics/short-ice-remove-middle-frames.run.stderr b/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
index 63fa466ab24..d2616911e3b 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
+++ b/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/short-ice-remove-middle-frames.rs:57:5:
+thread 'main' panicked at $DIR/short-ice-remove-middle-frames.rs:59:5:
 debug!!!
 stack backtrace:
    0: std::panicking::begin_panic
-- 
cgit 1.4.1-3-g733a5


From 12d66d95069ef79bdc4fa3a3de388718a8644a0b Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Sun, 22 Dec 2024 20:20:02 +0000
Subject: Account for removal of multiline span in suggestion

When highlighting the removed parts of a suggestion, properly account for spans that cover more than one line.

Fix #134485.
---
 compiler/rustc_errors/src/emitter.rs               |  86 +++-
 .../error-emitter/multiline-removal-suggestion.rs  |  58 +++
 .../error-emitter/multiline-removal-suggestion.svg | 504 +++++++++++++++++++++
 3 files changed, 641 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/error-emitter/multiline-removal-suggestion.rs
 create mode 100644 tests/ui/error-emitter/multiline-removal-suggestion.svg

(limited to 'tests')

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index 977721a5b8a..f938352820d 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -2216,6 +2216,11 @@ impl HumanEmitter {
                 show_code_change
             {
                 for part in parts {
+                    let snippet = if let Ok(snippet) = sm.span_to_snippet(part.span) {
+                        snippet
+                    } else {
+                        String::new()
+                    };
                     let span_start_pos = sm.lookup_char_pos(part.span.lo()).col_display;
                     let span_end_pos = sm.lookup_char_pos(part.span.hi()).col_display;
 
@@ -2263,13 +2268,80 @@ impl HumanEmitter {
                     }
                     if let DisplaySuggestion::Diff = show_code_change {
                         // Colorize removal with red in diff format.
-                        buffer.set_style_range(
-                            row_num - 2,
-                            (padding as isize + span_start_pos as isize) as usize,
-                            (padding as isize + span_end_pos as isize) as usize,
-                            Style::Removal,
-                            true,
-                        );
+
+                        // Below, there's some tricky buffer indexing going on. `row_num` at this
+                        // point corresponds to:
+                        //
+                        //    |
+                        // LL | CODE
+                        //    | ++++  <- `row_num`
+                        //
+                        // in the buffer. When we have a diff format output, we end up with
+                        //
+                        //    |
+                        // LL - OLDER   <- row_num - 2
+                        // LL + NEWER
+                        //    |         <- row_num
+                        //
+                        // The `row_num - 2` is to select the buffer line that has the "old version
+                        // of the diff" at that point. When the removal is a single line, `i` is
+                        // `0`, `newlines` is `1` so `(newlines - i - 1)` ends up being `0`, so row
+                        // points at `LL - OLDER`. When the removal corresponds to multiple lines,
+                        // we end up with `newlines > 1` and `i` being `0..newlines - 1`.
+                        //
+                        //    |
+                        // LL - OLDER   <- row_num - 2 - (newlines - last_i - 1)
+                        // LL - CODE
+                        // LL - BEING
+                        // LL - REMOVED <- row_num - 2 - (newlines - first_i - 1)
+                        // LL + NEWER
+                        //    |         <- row_num
+
+                        let newlines = snippet.lines().count();
+                        if newlines > 0 && row_num > newlines {
+                            // Account for removals where the part being removed spans multiple
+                            // lines.
+                            // FIXME: We check the number of rows because in some cases, like in
+                            // `tests/ui/lint/invalid-nan-comparison-suggestion.rs`, the rendered
+                            // suggestion will only show the first line of code being replaced. The
+                            // proper way of doing this would be to change the suggestion rendering
+                            // logic to show the whole prior snippet, but the current output is not
+                            // too bad to begin with, so we side-step that issue here.
+                            for (i, line) in snippet.lines().enumerate() {
+                                let line = normalize_whitespace(line);
+                                let row = row_num - 2 - (newlines - i - 1);
+                                // On the first line, we highlight between the start of the part
+                                // span, and the end of that line.
+                                // On the last line, we highlight between the start of the line, and
+                                // the column of the part span end.
+                                // On all others, we highlight the whole line.
+                                let start = if i == 0 {
+                                    (padding as isize + span_start_pos as isize) as usize
+                                } else {
+                                    padding
+                                };
+                                let end = if i == 0 {
+                                    (padding as isize
+                                        + span_start_pos as isize
+                                        + line.len() as isize)
+                                        as usize
+                                } else if i == newlines - 1 {
+                                    (padding as isize + span_end_pos as isize) as usize
+                                } else {
+                                    (padding as isize + line.len() as isize) as usize
+                                };
+                                buffer.set_style_range(row, start, end, Style::Removal, true);
+                            }
+                        } else {
+                            // The removed code fits all in one line.
+                            buffer.set_style_range(
+                                row_num - 2,
+                                (padding as isize + span_start_pos as isize) as usize,
+                                (padding as isize + span_end_pos as isize) as usize,
+                                Style::Removal,
+                                true,
+                            );
+                        }
                     }
 
                     // length of the code after substitution
diff --git a/tests/ui/error-emitter/multiline-removal-suggestion.rs b/tests/ui/error-emitter/multiline-removal-suggestion.rs
new file mode 100644
index 00000000000..72e9ea357c9
--- /dev/null
+++ b/tests/ui/error-emitter/multiline-removal-suggestion.rs
@@ -0,0 +1,58 @@
+// Make sure suggestion for removal of a span that covers multiple lines is properly highlighted.
+//@ compile-flags: --error-format=human --color=always
+//@ edition:2018
+//@ only-linux
+// ignore-tidy-tab
+// We use `\t` instead of spaces for indentation to ensure that the highlighting logic properly
+// accounts for replaced characters (like we do for `\t` with `    `). The naïve way of highlighting
+// could be counting chars of the original code, instead of operating on the code as it is being
+// displayed.
+use std::collections::{HashMap, HashSet};
+fn foo() -> Vec<(bool, HashSet<u8>)> {
+	let mut hm = HashMap::<bool, Vec<HashSet<u8>>>::new();
+	hm.into_iter()
+		.map(|(is_true, ts)| {
+			ts.into_iter()
+				.map(|t| {
+					(
+						is_true,
+						t,
+					)
+				}).flatten()
+		})
+		.flatten()
+		.collect()
+}
+fn bar() -> Vec<(bool, HashSet<u8>)> {
+	let mut hm = HashMap::<bool, Vec<HashSet<u8>>>::new();
+	hm.into_iter()
+		.map(|(is_true, ts)| {
+			ts.into_iter()
+				.map(|t| (is_true, t))
+				.flatten()
+		})
+		.flatten()
+		.collect()
+}
+fn baz() -> Vec<(bool, HashSet<u8>)> {
+	let mut hm = HashMap::<bool, Vec<HashSet<u8>>>::new();
+	hm.into_iter()
+		.map(|(is_true, ts)| {
+			ts.into_iter().map(|t| {
+				(is_true, t)
+			}).flatten()
+		})
+		.flatten()
+		.collect()
+}
+fn bay() -> Vec<(bool, HashSet<u8>)> {
+	let mut hm = HashMap::<bool, Vec<HashSet<u8>>>::new();
+	hm.into_iter()
+		.map(|(is_true, ts)| {
+			ts.into_iter()
+				.map(|t| (is_true, t)).flatten()
+		})
+		.flatten()
+		.collect()
+}
+fn main() {}
diff --git a/tests/ui/error-emitter/multiline-removal-suggestion.svg b/tests/ui/error-emitter/multiline-removal-suggestion.svg
new file mode 100644
index 00000000000..95c7740f699
--- /dev/null
+++ b/tests/ui/error-emitter/multiline-removal-suggestion.svg
@@ -0,0 +1,504 @@
+<svg width="1902px" height="4322px" xmlns="http://www.w3.org/2000/svg">
+  <style>
+    .fg { fill: #AAAAAA }
+    .bg { background: #000000 }
+    .fg-ansi256-009 { fill: #FF5555 }
+    .fg-ansi256-010 { fill: #55FF55 }
+    .fg-ansi256-012 { fill: #5555FF }
+    .fg-ansi256-014 { fill: #55FFFF }
+    .container {
+      padding: 0 10px;
+      line-height: 18px;
+    }
+    .bold { font-weight: bold; }
+    tspan {
+      font: 14px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
+      white-space: pre;
+      line-height: 18px;
+    }
+  </style>
+
+  <rect width="100%" height="100%" y="0" rx="4.5" class="bg" />
+
+  <text xml:space="preserve" class="container fg">
+    <tspan x="10px" y="28px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:21:8</tspan>
+</tspan>
+    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 }).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                    </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="118px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="136px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="154px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="172px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="190px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="208px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+</tspan>
+    <tspan x="10px" y="226px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="244px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="262px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| {</tspan>
+</tspan>
+    <tspan x="10px" y="280px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                     (</tspan>
+</tspan>
+    <tspan x="10px" y="298px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                         is_true,</tspan>
+</tspan>
+    <tspan x="10px" y="316px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                         t,</tspan>
+</tspan>
+    <tspan x="10px" y="334px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                     )</tspan>
+</tspan>
+    <tspan x="10px" y="352px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 })</tspan><tspan>.flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="370px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="388px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="406px">
+</tspan>
+    <tspan x="10px" y="424px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="442px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:13:2</tspan>
+</tspan>
+    <tspan x="10px" y="460px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="478px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="496px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="514px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="532px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| {</tspan>
+</tspan>
+    <tspan x="10px" y="550px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-009 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="568px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 }).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="586px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+</tspan>
+    <tspan x="10px" y="604px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="622px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="640px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="658px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="676px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="694px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="712px">
+</tspan>
+    <tspan x="10px" y="730px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@multiline-removal-suggestion.rs:14:8}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+</tspan>
+    <tspan x="10px" y="748px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:24:4</tspan>
+</tspan>
+    <tspan x="10px" y="766px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="784px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="802px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="820px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="838px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| {</tspan>
+</tspan>
+    <tspan x="10px" y="856px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="874px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="892px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
+</tspan>
+    <tspan x="10px" y="910px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
+</tspan>
+    <tspan x="10px" y="928px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
+</tspan>
+    <tspan x="10px" y="946px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="964px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="982px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
+</tspan>
+    <tspan x="10px" y="1000px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:16:10: 16:13}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+</tspan>
+    <tspan x="10px" y="1018px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1036px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:16:10: 16:13}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+</tspan>
+    <tspan x="10px" y="1054px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1072px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:16:10: 16:13}&gt;&gt;: IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1090px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1108px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1126px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1144px">
+</tspan>
+    <tspan x="10px" y="1162px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="1180px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:32:6</tspan>
+</tspan>
+    <tspan x="10px" y="1198px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1216px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="1234px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                  </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="1252px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1270px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="1288px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1306px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="1324px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="1342px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+</tspan>
+    <tspan x="10px" y="1360px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1378px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="1396px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| (is_true, t))</tspan>
+</tspan>
+    <tspan x="10px" y="1414px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="1432px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1450px">
+</tspan>
+    <tspan x="10px" y="1468px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="1486px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:28:2</tspan>
+</tspan>
+    <tspan x="10px" y="1504px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1522px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="1540px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="1558px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="1576px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| (is_true, t))</tspan>
+</tspan>
+    <tspan x="10px" y="1594px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="1612px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+</tspan>
+    <tspan x="10px" y="1630px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="1648px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1666px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="1684px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="1702px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="1720px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="1738px">
+</tspan>
+    <tspan x="10px" y="1756px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@multiline-removal-suggestion.rs:29:8}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+</tspan>
+    <tspan x="10px" y="1774px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:35:4</tspan>
+</tspan>
+    <tspan x="10px" y="1792px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1810px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="1828px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="1846px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="1864px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t))</tspan>
+</tspan>
+    <tspan x="10px" y="1882px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1900px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="1918px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
+</tspan>
+    <tspan x="10px" y="1936px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
+</tspan>
+    <tspan x="10px" y="1954px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
+</tspan>
+    <tspan x="10px" y="1972px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="1990px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2008px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
+</tspan>
+    <tspan x="10px" y="2026px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:31:10: 31:13}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+</tspan>
+    <tspan x="10px" y="2044px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2062px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:31:10: 31:13}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+</tspan>
+    <tspan x="10px" y="2080px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2098px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:31:10: 31:13}&gt;&gt;: IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2116px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2134px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2152px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2170px">
+</tspan>
+    <tspan x="10px" y="2188px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="2206px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:43:7</tspan>
+</tspan>
+    <tspan x="10px" y="2224px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2242px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             }).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="2260px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="2278px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2296px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="2314px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2332px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="2350px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="2368px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+</tspan>
+    <tspan x="10px" y="2386px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2404px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan><tspan class="fg-ansi256-009">.map(|t| {</tspan>
+</tspan>
+    <tspan x="10px" y="2422px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 (is_true, t)</tspan>
+</tspan>
+    <tspan x="10px" y="2440px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-             })</tspan><tspan>.flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="2458px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="2476px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2494px">
+</tspan>
+    <tspan x="10px" y="2512px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="2530px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:39:2</tspan>
+</tspan>
+    <tspan x="10px" y="2548px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2566px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="2584px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="2602px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter().map(|t| {</tspan>
+</tspan>
+    <tspan x="10px" y="2620px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 (is_true, t)</tspan>
+</tspan>
+    <tspan x="10px" y="2638px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             }).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="2656px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+</tspan>
+    <tspan x="10px" y="2674px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="2692px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2710px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="2728px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="2746px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="2764px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="2782px">
+</tspan>
+    <tspan x="10px" y="2800px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@multiline-removal-suggestion.rs:40:8}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+</tspan>
+    <tspan x="10px" y="2818px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:46:4</tspan>
+</tspan>
+    <tspan x="10px" y="2836px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2854px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="2872px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="2890px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter().map(|t| {</tspan>
+</tspan>
+    <tspan x="10px" y="2908px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 (is_true, t)</tspan>
+</tspan>
+    <tspan x="10px" y="2926px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="2944px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="2962px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
+</tspan>
+    <tspan x="10px" y="2980px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
+</tspan>
+    <tspan x="10px" y="2998px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
+</tspan>
+    <tspan x="10px" y="3016px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3034px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3052px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
+</tspan>
+    <tspan x="10px" y="3070px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:41:23: 41:26}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+</tspan>
+    <tspan x="10px" y="3088px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3106px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:41:23: 41:26}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+</tspan>
+    <tspan x="10px" y="3124px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3142px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:41:23: 41:26}&gt;&gt;: IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3160px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3178px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3196px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3214px">
+</tspan>
+    <tspan x="10px" y="3232px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="3250px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:53:28</tspan>
+</tspan>
+    <tspan x="10px" y="3268px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3286px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="3304px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                                        </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="3322px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3340px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="3358px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3376px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="3394px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="3412px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+</tspan>
+    <tspan x="10px" y="3430px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3448px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="3466px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| (is_true, t))</tspan><tspan>.flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="3484px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="3502px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3520px">
+</tspan>
+    <tspan x="10px" y="3538px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="3556px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:50:2</tspan>
+</tspan>
+    <tspan x="10px" y="3574px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3592px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="3610px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="3628px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="3646px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="3664px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+</tspan>
+    <tspan x="10px" y="3682px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+</tspan>
+    <tspan x="10px" y="3700px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3718px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+</tspan>
+    <tspan x="10px" y="3736px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="3754px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+</tspan>
+    <tspan x="10px" y="3772px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+</tspan>
+    <tspan x="10px" y="3790px">
+</tspan>
+    <tspan x="10px" y="3808px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@multiline-removal-suggestion.rs:51:8}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+</tspan>
+    <tspan x="10px" y="3826px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:56:4</tspan>
+</tspan>
+    <tspan x="10px" y="3844px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="3862px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="3880px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+</tspan>
+    <tspan x="10px" y="3898px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+</tspan>
+    <tspan x="10px" y="3916px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="3934px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         })</tspan>
+</tspan>
+    <tspan x="10px" y="3952px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
+</tspan>
+    <tspan x="10px" y="3970px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
+</tspan>
+    <tspan x="10px" y="3988px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
+</tspan>
+    <tspan x="10px" y="4006px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
+</tspan>
+    <tspan x="10px" y="4024px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="4042px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="4060px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
+</tspan>
+    <tspan x="10px" y="4078px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:53:10: 53:13}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+</tspan>
+    <tspan x="10px" y="4096px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="4114px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:53:10: 53:13}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+</tspan>
+    <tspan x="10px" y="4132px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="4150px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:53:10: 53:13}&gt;&gt;: IntoIterator`</tspan>
+</tspan>
+    <tspan x="10px" y="4168px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="4186px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="4204px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
+</tspan>
+    <tspan x="10px" y="4222px">
+</tspan>
+    <tspan x="10px" y="4240px"><tspan class="fg-ansi256-009 bold">error</tspan><tspan class="bold">: aborting due to 12 previous errors</tspan>
+</tspan>
+    <tspan x="10px" y="4258px">
+</tspan>
+    <tspan x="10px" y="4276px"><tspan class="bold">Some errors have detailed explanations: E0277, E0599.</tspan>
+</tspan>
+    <tspan x="10px" y="4294px"><tspan class="bold">For more information about an error, try `rustc --explain E0277`.</tspan>
+</tspan>
+    <tspan x="10px" y="4312px">
+</tspan>
+  </text>
+
+</svg>
-- 
cgit 1.4.1-3-g733a5


From f349d720e785645c59d12cbf8709da5294e45709 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 26 Dec 2024 19:13:50 +0000
Subject: Make ty::Error implement auto traits

---
 .../src/traits/select/candidate_assembly.rs        |  4 +++-
 tests/crashes/131050.rs                            | 23 --------------------
 tests/ui/consts/error-is-freeze.rs                 | 14 ++++++++++++
 tests/ui/consts/error-is-freeze.stderr             | 14 ++++++++++++
 tests/ui/impl-trait/auto-trait-contains-err.rs     | 25 ++++++++++++++++++++++
 tests/ui/impl-trait/auto-trait-contains-err.stderr | 11 ++++++++++
 6 files changed, 67 insertions(+), 24 deletions(-)
 delete mode 100644 tests/crashes/131050.rs
 create mode 100644 tests/ui/consts/error-is-freeze.rs
 create mode 100644 tests/ui/consts/error-is-freeze.stderr
 create mode 100644 tests/ui/impl-trait/auto-trait-contains-err.rs
 create mode 100644 tests/ui/impl-trait/auto-trait-contains-err.stderr

(limited to 'tests')

diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index d6ac4baf8ad..968dc631e50 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -819,7 +819,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         candidates.vec.push(AutoImplCandidate)
                     }
                 }
-                ty::Error(_) => {} // do not add an auto trait impl for `ty::Error` for now.
+                ty::Error(_) => {
+                    candidates.vec.push(AutoImplCandidate);
+                }
             }
         }
     }
diff --git a/tests/crashes/131050.rs b/tests/crashes/131050.rs
deleted file mode 100644
index 3e3a600ef3d..00000000000
--- a/tests/crashes/131050.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ known-bug: #131050
-//@ compile-flags: --edition=2021
-
-use std::future::Future;
-
-fn invalid_future() -> impl Future {}
-
-fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
-    async { &|| async { invalid_future().await } }
-}
-
-fn coerce_impl_trait() -> impl Future<Output = impl Send> {
-    create_complex_future()
-}
-
-trait ReturnsSend {}
-
-impl<F, R> ReturnsSend for F
-where
-    F: Fn() -> R,
-    R: Send,
-{
-}
diff --git a/tests/ui/consts/error-is-freeze.rs b/tests/ui/consts/error-is-freeze.rs
new file mode 100644
index 00000000000..fe27d029e66
--- /dev/null
+++ b/tests/ui/consts/error-is-freeze.rs
@@ -0,0 +1,14 @@
+// Make sure we treat the error type as freeze to suppress useless errors.
+
+struct MyStruct {
+    foo: Option<UndefinedType>,
+    //~^ ERROR cannot find type `UndefinedType` in this scope
+}
+impl MyStruct {
+    pub const EMPTY_REF: &'static Self = &Self::EMPTY;
+    pub const EMPTY: Self = Self {
+        foo: None,
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/consts/error-is-freeze.stderr b/tests/ui/consts/error-is-freeze.stderr
new file mode 100644
index 00000000000..f3bfd1ea5e2
--- /dev/null
+++ b/tests/ui/consts/error-is-freeze.stderr
@@ -0,0 +1,14 @@
+error[E0412]: cannot find type `UndefinedType` in this scope
+  --> $DIR/error-is-freeze.rs:4:17
+   |
+LL |     foo: Option<UndefinedType>,
+   |                 ^^^^^^^^^^^^^ not found in this scope
+   |
+help: you might be missing a type parameter
+   |
+LL | struct MyStruct<UndefinedType> {
+   |                +++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/impl-trait/auto-trait-contains-err.rs b/tests/ui/impl-trait/auto-trait-contains-err.rs
new file mode 100644
index 00000000000..d7f094211d7
--- /dev/null
+++ b/tests/ui/impl-trait/auto-trait-contains-err.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: --edition=2021
+
+use std::future::Future;
+
+fn invalid_future() -> impl Future {}
+//~^ ERROR `()` is not a future
+
+fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
+    async { &|| async { invalid_future().await } }
+}
+
+fn coerce_impl_trait() -> impl Future<Output = impl Send> {
+    create_complex_future()
+}
+
+trait ReturnsSend {}
+
+impl<F, R> ReturnsSend for F
+where
+    F: Fn() -> R,
+    R: Send,
+{
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/auto-trait-contains-err.stderr b/tests/ui/impl-trait/auto-trait-contains-err.stderr
new file mode 100644
index 00000000000..4da6b285ae1
--- /dev/null
+++ b/tests/ui/impl-trait/auto-trait-contains-err.stderr
@@ -0,0 +1,11 @@
+error[E0277]: `()` is not a future
+  --> $DIR/auto-trait-contains-err.rs:5:24
+   |
+LL | fn invalid_future() -> impl Future {}
+   |                        ^^^^^^^^^^^ `()` is not a future
+   |
+   = help: the trait `Future` is not implemented for `()`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 16a4ad7d7b0d163f7be6803c786c3b83d42913bb Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 26 Dec 2024 15:43:43 -0700
Subject: rustdoc: use shorter paths as preferred canonical paths

This is a solution to the `std::sync::poison` linking problem,
and, in general, makes intra-doc links shorter and clearer.
---
 src/librustdoc/formats/cache.rs                    | 19 +++++-----
 .../rustdoc/inline_local/parent-path-is-better.rs  | 40 ++++++++++++++++++++++
 2 files changed, 50 insertions(+), 9 deletions(-)
 create mode 100644 tests/rustdoc/inline_local/parent-path-is-better.rs

(limited to 'tests')

diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index b63122565c4..361cea75f5e 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -305,6 +305,7 @@ impl DocFolder for CacheBuilder<'_, '_> {
             | clean::MacroItem(..)
             | clean::ProcMacroItem(..)
             | clean::VariantItem(..) => {
+                use rustc_data_structures::fx::IndexEntry as Entry;
                 if !self.cache.stripped_mod {
                     // Re-exported items mean that the same id can show up twice
                     // in the rustdoc ast that we're looking at. We know,
@@ -313,15 +314,15 @@ impl DocFolder for CacheBuilder<'_, '_> {
                     // paths map if there was already an entry present and we're
                     // not a public item.
                     let item_def_id = item.item_id.expect_def_id();
-                    if !self.cache.paths.contains_key(&item_def_id)
-                        || self
-                            .cache
-                            .effective_visibilities
-                            .is_directly_public(self.tcx, item_def_id)
-                    {
-                        self.cache
-                            .paths
-                            .insert(item_def_id, (self.cache.stack.clone(), item.type_()));
+                    match self.cache.paths.entry(item_def_id) {
+                        Entry::Vacant(entry) => {
+                            entry.insert((self.cache.stack.clone(), item.type_()));
+                        }
+                        Entry::Occupied(mut entry) => {
+                            if entry.get().0.len() > self.cache.stack.len() {
+                                entry.insert((self.cache.stack.clone(), item.type_()));
+                            }
+                        }
                     }
                 }
             }
diff --git a/tests/rustdoc/inline_local/parent-path-is-better.rs b/tests/rustdoc/inline_local/parent-path-is-better.rs
new file mode 100644
index 00000000000..086540d5444
--- /dev/null
+++ b/tests/rustdoc/inline_local/parent-path-is-better.rs
@@ -0,0 +1,40 @@
+//! Test case for [134702]
+//!
+//! [134702]: https://github.com/rust-lang/rust/issues/134702
+#![crate_name = "foo"]
+
+pub mod inside1 {
+    pub use self::inner::Inside1;
+    mod inner {
+        pub struct Inside1;
+        impl Inside1 {
+            pub fn stuff(self) {}
+        }
+    }
+}
+
+pub mod inside2 {
+    pub use self::inner::Inside2;
+    mod inner {
+        pub struct Inside2;
+        impl Inside2 {
+            pub fn stuff(self) {}
+        }
+    }
+}
+
+pub mod nested {
+    //! [Inside1] [Inside2]
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside1.html"]' 'Inside1'
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside2.html"]' 'Inside2'
+    //! [Inside1::stuff] [Inside2::stuff]
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside1.html#method.stuff"]' 'Inside1::stuff'
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside2.html#method.stuff"]' 'Inside2::stuff'
+    use crate::inside1::Inside1;
+    use crate::inside2::Inside2;
+}
+
+#[doc(inline)]
+pub use inside1::Inside1;
+#[doc(inline)]
+pub use inside2::Inside2;
-- 
cgit 1.4.1-3-g733a5


From da1c1c33abe43feb50ebe01b59dade8da4304909 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 26 Dec 2024 16:35:29 -0700
Subject: Adjust test for slightly changed inlining behavior

---
 tests/rustdoc-js-std/path-maxeditdistance.js |  8 +++---
 tests/rustdoc-js-std/path-ordering.js        | 10 +++----
 tests/rustdoc-js-std/simd-type-signatures.js | 40 ++++++++++++++--------------
 tests/rustdoc/intra-doc/pub-use.rs           |  2 +-
 4 files changed, 30 insertions(+), 30 deletions(-)

(limited to 'tests')

diff --git a/tests/rustdoc-js-std/path-maxeditdistance.js b/tests/rustdoc-js-std/path-maxeditdistance.js
index af71713f055..fd12a056496 100644
--- a/tests/rustdoc-js-std/path-maxeditdistance.js
+++ b/tests/rustdoc-js-std/path-maxeditdistance.js
@@ -17,10 +17,10 @@ const EXPECTED = [
             { 'path': 'std::vec::IntoIter', 'name': 'into_iter' },
             { 'path': 'std::vec::ExtractIf', 'name': 'into_iter' },
             { 'path': 'std::vec::Splice', 'name': 'into_iter' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'iter' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'iter_mut' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'from_iter' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'into_iter' },
+            { 'path': 'std::collections::VecDeque', 'name': 'iter' },
+            { 'path': 'std::collections::VecDeque', 'name': 'iter_mut' },
+            { 'path': 'std::collections::VecDeque', 'name': 'from_iter' },
+            { 'path': 'std::collections::VecDeque', 'name': 'into_iter' },
         ],
     },
     {
diff --git a/tests/rustdoc-js-std/path-ordering.js b/tests/rustdoc-js-std/path-ordering.js
index 4bfc6256052..4bec4827d51 100644
--- a/tests/rustdoc-js-std/path-ordering.js
+++ b/tests/rustdoc-js-std/path-ordering.js
@@ -3,17 +3,17 @@ const EXPECTED = [
         query: 'hashset::insert',
         others: [
             // ensure hashset::insert comes first
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'insert' },
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert' },
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert_with' },
+            { 'path': 'std::collections::HashSet', 'name': 'insert' },
+            { 'path': 'std::collections::HashSet', 'name': 'get_or_insert' },
+            { 'path': 'std::collections::HashSet', 'name': 'get_or_insert_with' },
         ],
     },
     {
         query: 'hash::insert',
         others: [
             // ensure hashset/hashmap::insert come first
-            { 'path': 'std::collections::hash_map::HashMap', 'name': 'insert' },
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'insert' },
+            { 'path': 'std::collections::HashMap', 'name': 'insert' },
+            { 'path': 'std::collections::HashSet', 'name': 'insert' },
         ],
     },
 ];
diff --git a/tests/rustdoc-js-std/simd-type-signatures.js b/tests/rustdoc-js-std/simd-type-signatures.js
index 4fc14e65ac4..fea34ff97f2 100644
--- a/tests/rustdoc-js-std/simd-type-signatures.js
+++ b/tests/rustdoc-js-std/simd-type-signatures.js
@@ -11,29 +11,29 @@ const EXPECTED = [
         'query': 'simd<i16>, simd<i16> -> simd<i16>',
         'others': [
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_max',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_max'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_max'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_min',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_min'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_min'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_add',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_add'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_add'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_sub',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_sub'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_sub'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_clamp',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_clamp'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_clamp'
             },
         ],
     },
@@ -41,29 +41,29 @@ const EXPECTED = [
         'query': 'simd<i8>, simd<i8> -> simd<i8>',
         'others': [
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_max',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_max'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_max'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_min',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_min'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_min'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_add',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_add'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_add'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_sub',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_sub'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_sub'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_clamp',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_clamp'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_clamp'
             },
         ],
     },
diff --git a/tests/rustdoc/intra-doc/pub-use.rs b/tests/rustdoc/intra-doc/pub-use.rs
index 7c70adad7d9..5aeb3eb149e 100644
--- a/tests/rustdoc/intra-doc/pub-use.rs
+++ b/tests/rustdoc/intra-doc/pub-use.rs
@@ -7,7 +7,7 @@ extern crate inner;
 /// [mod@std::env] [g]
 //@ has outer/index.html
 //@ has - '//a[@href="{{channel}}/std/env/index.html"]' "std::env"
-//@ has - '//a[@href="fn.f.html"]' "g"
+//@ has - '//a[@href="fn.g.html"]' "g"
 pub use f as g;
 
 // Make sure the documentation is actually correct by documenting an inlined re-export
-- 
cgit 1.4.1-3-g733a5


From d997bc998e6522e86d04b210cef88e0e78b77ef6 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 25 Dec 2024 18:52:35 +1100
Subject: Simplify or delete normalize directives that don't care about
 bit-width

---
 tests/ui/const-generics/transmute-fail.rs          |  3 +--
 tests/ui/const-generics/transmute-fail.stderr      | 30 +++++++++++-----------
 tests/ui/consts/issue-17718-const-bad-values.rs    |  3 +--
 .../ui/consts/issue-17718-const-bad-values.stderr  |  4 +--
 .../debuginfo-type-name-layout-ice-94961-1.rs      |  2 --
 .../debuginfo-type-name-layout-ice-94961-2.rs      |  2 --
 tests/ui/limits/huge-struct.rs                     |  3 +--
 tests/ui/limits/huge-struct.stderr                 |  2 +-
 tests/ui/limits/issue-55878.rs                     |  2 --
 tests/ui/limits/issue-55878.stderr                 |  2 +-
 10 files changed, 22 insertions(+), 31 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/const-generics/transmute-fail.rs b/tests/ui/const-generics/transmute-fail.rs
index 95c71160567..ee041972a9f 100644
--- a/tests/ui/const-generics/transmute-fail.rs
+++ b/tests/ui/const-generics/transmute-fail.rs
@@ -1,6 +1,5 @@
 // ignore-tidy-linelength
-//@ normalize-stderr-32bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
-//@ normalize-stderr-64bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
+//@ normalize-stderr-test: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
 
 
 #![feature(transmute_generic_consts)]
diff --git a/tests/ui/const-generics/transmute-fail.stderr b/tests/ui/const-generics/transmute-fail.stderr
index 638ce790345..978a9744e88 100644
--- a/tests/ui/const-generics/transmute-fail.stderr
+++ b/tests/ui/const-generics/transmute-fail.stderr
@@ -1,11 +1,11 @@
 error: the constant `W` is not of type `usize`
-  --> $DIR/transmute-fail.rs:17:42
+  --> $DIR/transmute-fail.rs:16:42
    |
 LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
    |                                          ^^^^^^^^^^^^^ expected `usize`, found `bool`
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:12:9
+  --> $DIR/transmute-fail.rs:11:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -14,13 +14,13 @@ LL |         std::mem::transmute(v)
    = note: target type: `[[u32; W + 1]; H]` (size can vary because of [u32; W + 1])
 
 error: the constant `W` is not of type `usize`
-  --> $DIR/transmute-fail.rs:20:9
+  --> $DIR/transmute-fail.rs:19:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:27:9
+  --> $DIR/transmute-fail.rs:26:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[u32; W * H * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:34:9
+  --> $DIR/transmute-fail.rs:33:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type $REALLY_TOO_BIG are too big for the target architecture)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:40:14
+  --> $DIR/transmute-fail.rs:39:14
    |
 LL |     unsafe { std::mem::transmute(v) }
    |              ^^^^^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |     unsafe { std::mem::transmute(v) }
    = note: target type: `[[[u32; 9999999]; 777777777]; 239]` (values of the type $REALLY_TOO_BIG are too big for the target architecture)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:46:9
+  --> $DIR/transmute-fail.rs:45:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:57:9
+  --> $DIR/transmute-fail.rs:56:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[u32; W * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:64:9
+  --> $DIR/transmute-fail.rs:63:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:73:9
+  --> $DIR/transmute-fail.rs:72:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[u32; D * W * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:82:9
+  --> $DIR/transmute-fail.rs:81:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[[u32; D * W]; H]` (size can vary because of [u32; D * W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:89:9
+  --> $DIR/transmute-fail.rs:88:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[u8; L * 2]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:96:9
+  --> $DIR/transmute-fail.rs:95:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[u16; L]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:103:9
+  --> $DIR/transmute-fail.rs:102:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -119,7 +119,7 @@ LL |         std::mem::transmute(v)
    = note: target type: `[[u8; 1]; L]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:112:9
+  --> $DIR/transmute-fail.rs:111:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/consts/issue-17718-const-bad-values.rs b/tests/ui/consts/issue-17718-const-bad-values.rs
index fca6cb08537..894fa5ab22f 100644
--- a/tests/ui/consts/issue-17718-const-bad-values.rs
+++ b/tests/ui/consts/issue-17718-const-bad-values.rs
@@ -1,5 +1,4 @@
-//@ normalize-stderr-32bit: "\(size: \d+, align: \d+\)" -> "(size: $$PTR, align: $$PTR)"
-//@ normalize-stderr-64bit: "\(size: \d+, align: \d+\)" -> "(size: $$PTR, align: $$PTR)"
+//@ normalize-stderr-test: "\(size: \d+, align: \d+\)" -> "(size: $$PTR, align: $$PTR)"
 //@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 #![allow(static_mut_refs)]
diff --git a/tests/ui/consts/issue-17718-const-bad-values.stderr b/tests/ui/consts/issue-17718-const-bad-values.stderr
index 102491e90ba..364fa7be5aa 100644
--- a/tests/ui/consts/issue-17718-const-bad-values.stderr
+++ b/tests/ui/consts/issue-17718-const-bad-values.stderr
@@ -1,11 +1,11 @@
 error[E0764]: mutable references are not allowed in the final value of constants
-  --> $DIR/issue-17718-const-bad-values.rs:7:34
+  --> $DIR/issue-17718-const-bad-values.rs:6:34
    |
 LL | const C1: &'static mut [usize] = &mut [];
    |                                  ^^^^^^^
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/issue-17718-const-bad-values.rs:11:1
+  --> $DIR/issue-17718-const-bad-values.rs:10:1
    |
 LL | const C2: &'static mut i32 = unsafe { &mut S };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered reference to mutable memory in `const`
diff --git a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.rs b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.rs
index a1922c98ef6..3bff4471698 100644
--- a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.rs
+++ b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.rs
@@ -4,8 +4,6 @@
 //@ compile-flags:-C debuginfo=2
 //@ build-fail
 //@ error-pattern: too big for the target architecture
-//@ normalize-stderr-64bit: "18446744073709551615" -> "SIZE"
-//@ normalize-stderr-32bit: "4294967295" -> "SIZE"
 
 #![crate_type = "rlib"]
 
diff --git a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.rs b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.rs
index 3456cd55b75..6a3f8f4c249 100644
--- a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.rs
+++ b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.rs
@@ -6,8 +6,6 @@
 //@ compile-flags:-C debuginfo=2
 //@ build-fail
 //@ error-pattern: too big for the target architecture
-//@ normalize-stderr-64bit: "18446744073709551615" -> "SIZE"
-//@ normalize-stderr-32bit: "4294967295" -> "SIZE"
 
 #![crate_type = "rlib"]
 
diff --git a/tests/ui/limits/huge-struct.rs b/tests/ui/limits/huge-struct.rs
index f7ce4f26db1..bf132d359f5 100644
--- a/tests/ui/limits/huge-struct.rs
+++ b/tests/ui/limits/huge-struct.rs
@@ -2,8 +2,7 @@
 //@ build-fail
 //@ normalize-stderr-test: "S32" -> "SXX"
 //@ normalize-stderr-test: "S1M" -> "SXX"
-//@ normalize-stderr-32bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
-//@ normalize-stderr-64bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
+//@ normalize-stderr-test: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
 
 struct S32<T> {
     v0: T,
diff --git a/tests/ui/limits/huge-struct.stderr b/tests/ui/limits/huge-struct.stderr
index b10455ffd2d..e03456f1c7b 100644
--- a/tests/ui/limits/huge-struct.stderr
+++ b/tests/ui/limits/huge-struct.stderr
@@ -1,5 +1,5 @@
 error: values of the type $REALLY_TOO_BIG are too big for the target architecture
-  --> $DIR/huge-struct.rs:48:9
+  --> $DIR/huge-struct.rs:47:9
    |
 LL |     let fat: Option<SXX<SXX<SXX<u32>>>> = None;
    |         ^^^
diff --git a/tests/ui/limits/issue-55878.rs b/tests/ui/limits/issue-55878.rs
index 81696e226fd..db4a2724452 100644
--- a/tests/ui/limits/issue-55878.rs
+++ b/tests/ui/limits/issue-55878.rs
@@ -1,6 +1,4 @@
 //@ build-fail
-//@ normalize-stderr-64bit: "18446744073709551615" -> "SIZE"
-//@ normalize-stderr-32bit: "4294967295" -> "SIZE"
 
 //@ error-pattern: are too big for the target architecture
 fn main() {
diff --git a/tests/ui/limits/issue-55878.stderr b/tests/ui/limits/issue-55878.stderr
index 51c4837f458..d2b5150c556 100644
--- a/tests/ui/limits/issue-55878.stderr
+++ b/tests/ui/limits/issue-55878.stderr
@@ -6,7 +6,7 @@ error[E0080]: evaluation of constant value failed
 note: inside `std::mem::size_of::<[u8; usize::MAX]>`
   --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
 note: inside `main`
-  --> $DIR/issue-55878.rs:7:26
+  --> $DIR/issue-55878.rs:5:26
    |
 LL |     println!("Size: {}", std::mem::size_of::<[u8; u64::MAX as usize]>());
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 835fbcbcab82ce728a7233de6c32a2d206e3336c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 25 Dec 2024 22:12:17 +1100
Subject: Remove the `-test` suffix from normalize directives

---
 src/tools/compiletest/src/directive-list.rs          |  4 ++--
 src/tools/compiletest/src/header.rs                  |  4 ++--
 src/tools/tidy/src/style.rs                          |  7 +++----
 tests/rustdoc-ui/2024-doctests-checks.rs             |  6 +++---
 tests/rustdoc-ui/2024-doctests-crate-attribute.rs    |  6 +++---
 .../argfile/commandline-argfile-missing-windows.rs   |  4 ++--
 .../argfile/commandline-argfile-missing.rs           |  4 ++--
 .../argfile/commandline-argfile-multiple-windows.rs  |  6 +++---
 .../argfile/commandline-argfile-multiple.rs          |  6 +++---
 .../disambiguator-endswith-named-suffix.rs           |  2 +-
 tests/rustdoc-ui/doctest/block-doc-comment.rs        |  2 +-
 tests/rustdoc-ui/doctest/cfg-test.rs                 |  4 ++--
 tests/rustdoc-ui/doctest/check-cfg-test.rs           |  6 +++---
 tests/rustdoc-ui/doctest/comment-in-attr-134221-2.rs |  6 +++---
 tests/rustdoc-ui/doctest/comment-in-attr-134221.rs   |  6 +++---
 tests/rustdoc-ui/doctest/dead-code-2024.rs           |  4 ++--
 tests/rustdoc-ui/doctest/dead-code.rs                |  4 ++--
 tests/rustdoc-ui/doctest/display-output.rs           |  4 ++--
 .../doctest/doc-comment-multi-line-attr.rs           |  4 ++--
 .../doctest/doc-comment-multi-line-cfg-attr.rs       |  4 ++--
 tests/rustdoc-ui/doctest/doc-test-doctest-feature.rs |  4 ++--
 tests/rustdoc-ui/doctest/doc-test-rustdoc-feature.rs |  4 ++--
 .../doctest/doctest-multiline-crate-attribute.rs     |  4 ++--
 .../doctest/doctest-output-include-fail.rs           |  4 ++--
 tests/rustdoc-ui/doctest/doctest-output.rs           |  4 ++--
 .../doctest/failed-doctest-compile-fail.rs           |  4 ++--
 .../failed-doctest-extra-semicolon-on-item.rs        |  4 ++--
 .../doctest/failed-doctest-missing-codes.rs          |  4 ++--
 .../doctest/failed-doctest-output-windows.rs         |  4 ++--
 tests/rustdoc-ui/doctest/failed-doctest-output.rs    |  4 ++--
 .../doctest/failed-doctest-should-panic-2021.rs      |  4 ++--
 .../doctest/failed-doctest-should-panic.rs           |  4 ++--
 tests/rustdoc-ui/doctest/merged-ignore-no_run.rs     |  4 ++--
 tests/rustdoc-ui/doctest/nested-main.rs              |  4 ++--
 tests/rustdoc-ui/doctest/no-run-flag.rs              |  4 ++--
 tests/rustdoc-ui/doctest/nocapture-fail.rs           |  6 +++---
 tests/rustdoc-ui/doctest/nocapture.rs                |  4 ++--
 tests/rustdoc-ui/doctest/non-local-defs-impl.rs      |  4 ++--
 tests/rustdoc-ui/doctest/non_local_defs.rs           |  6 +++---
 .../doctest/relative-path-include-bytes-132203.rs    |  4 ++--
 tests/rustdoc-ui/doctest/run-directory.rs            |  4 ++--
 tests/rustdoc-ui/doctest/rustflags-multiple-args.rs  |  4 ++--
 tests/rustdoc-ui/doctest/rustflags.rs                |  4 ++--
 tests/rustdoc-ui/doctest/standalone-warning-2024.rs  |  6 +++---
 tests/rustdoc-ui/doctest/test-no_std.rs              |  4 ++--
 tests/rustdoc-ui/doctest/test-type.rs                |  4 ++--
 tests/rustdoc-ui/doctest/unparseable-doc-test.rs     |  4 ++--
 tests/rustdoc-ui/doctest/wrong-ast-2024.rs           |  6 +++---
 tests/rustdoc-ui/doctest/wrong-ast.rs                |  4 ++--
 .../infinite-recursive-type-impl-trait-return.rs     |  4 ++--
 tests/rustdoc-ui/ice-bug-report-url.rs               | 12 ++++++------
 .../rustdoc-ui/intra-doc/email-address-localhost.rs  |  2 +-
 tests/rustdoc-ui/intra-doc/unknown-disambiguator.rs  |  2 +-
 tests/rustdoc-ui/issues/issue-80992.rs               |  4 ++--
 tests/rustdoc-ui/issues/issue-81662-shortness.rs     |  4 ++--
 .../rustdoc-ui/issues/issue-83883-describe-lints.rs  |  4 ++--
 tests/rustdoc-ui/issues/issue-91134.rs               |  4 ++--
 tests/rustdoc-ui/lints/check.rs                      |  2 +-
 tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs    |  2 +-
 .../remap-path-prefix-failed-doctest-output.rs       |  4 ++--
 .../rustdoc-ui/remap-path-prefix-invalid-doctest.rs  |  2 +-
 .../remap-path-prefix-passed-doctest-output.rs       |  2 +-
 tests/rustdoc-ui/track-diagnostics.rs                |  2 +-
 tests/ui-fulldeps/codegen-backend/hotplug.rs         |  4 ++--
 tests/ui-fulldeps/fluent-messages/test.rs            |  2 +-
 tests/ui-fulldeps/missing-rustc-driver-error.rs      |  4 ++--
 .../diagnostic-derive-doc-comment-field.rs           |  4 ++--
 .../session-diagnostic/diagnostic-derive.rs          |  4 ++--
 tests/ui/abi/c-zst.rs                                |  2 +-
 tests/ui/abi/debug.rs                                | 10 +++++-----
 tests/ui/abi/sysv64-zst.rs                           |  2 +-
 tests/ui/abi/win64-zst.rs                            |  2 +-
 .../argfile/commandline-argfile-missing-windows.rs   |  4 ++--
 tests/ui/argfile/commandline-argfile-missing.rs      |  4 ++--
 .../argfile/commandline-argfile-multiple-windows.rs  |  6 +++---
 tests/ui/argfile/commandline-argfile-multiple.rs     |  6 +++---
 .../associated-types-in-ambiguous-context.rs         |  2 +-
 tests/ui/attributes/dump-preds.rs                    |  2 +-
 tests/ui/attributes/dump_def_parents.rs              |  2 +-
 .../ui/attributes/extented-attribute-macro-error.rs  |  2 +-
 tests/ui/check-cfg/and-more-diagnostic.rs            |  4 ++--
 tests/ui/check-cfg/target_feature.rs                 |  2 +-
 tests/ui/codegen/mismatched-data-layouts.rs          |  4 ++--
 tests/ui/codegen/target-cpus.rs                      |  2 +-
 .../generic_const_exprs/issue-80742.rs               |  6 +++---
 tests/ui/const-generics/transmute-fail.rs            |  2 +-
 tests/ui/const-ptr/forbidden_slices.rs               |  4 ++--
 tests/ui/consts/const-eval/const-eval-query-stack.rs | 20 ++++++++++----------
 .../const-eval/heap/dealloc_intrinsic_dangling.rs    |  6 +++---
 tests/ui/consts/const-eval/raw-bytes.rs              |  2 +-
 tests/ui/consts/const-eval/ub-enum.rs                |  6 +++---
 tests/ui/consts/const-eval/ub-nonnull.rs             |  4 ++--
 tests/ui/consts/const-eval/ub-ref-ptr.rs             |  4 ++--
 tests/ui/consts/const-eval/ub-uninhabit.rs           |  4 ++--
 tests/ui/consts/const-eval/ub-wide-ptr.rs            |  8 ++++----
 tests/ui/consts/const-mut-refs/mut_ref_in_final.rs   |  6 +++---
 .../const-mut-refs/mut_ref_in_final_dynamic_check.rs |  6 +++---
 tests/ui/consts/const_refs_to_static_fail.rs         |  4 ++--
 tests/ui/consts/const_refs_to_static_fail_invalid.rs |  4 ++--
 tests/ui/consts/dangling-alloc-id-ice.rs             |  6 +++---
 tests/ui/consts/dangling-zst-ice-issue-126393.rs     |  6 +++---
 tests/ui/consts/issue-17718-const-bad-values.rs      |  4 ++--
 tests/ui/consts/issue-miri-1910.rs                   |  2 +-
 .../consts/miri_unleashed/const_refers_to_static.rs  |  4 ++--
 .../const_refers_to_static_cross_crate.rs            |  4 ++--
 tests/ui/consts/miri_unleashed/mutable_references.rs |  4 ++--
 tests/ui/consts/offset_from_ub.rs                    |  2 +-
 tests/ui/consts/offset_ub.rs                         |  6 +++---
 tests/ui/consts/overflowing-consts.rs                |  4 ++--
 tests/ui/consts/validate_never_arrays.rs             |  4 ++--
 tests/ui/coroutine/static-not-unpin.rs               |  2 +-
 tests/ui/crate-loading/crateresolve1.rs              |  6 +++---
 tests/ui/crate-loading/crateresolve2.rs              |  4 ++--
 tests/ui/crate-loading/invalid-rlib.rs               |  2 +-
 tests/ui/diagnostic-width/E0271.rs                   |  2 +-
 tests/ui/diagnostic-width/long-E0308.rs              |  2 +-
 tests/ui/duplicate_entry_error.rs                    |  2 +-
 tests/ui/error-codes/E0017.rs                        |  4 ++--
 tests/ui/error-codes/E0152.rs                        |  2 +-
 tests/ui/error-codes/E0275.rs                        |  2 +-
 tests/ui/error-codes/E0462.rs                        |  6 +++---
 tests/ui/error-codes/E0464.rs                        |  6 +++---
 tests/ui/error-codes/E0523.rs                        |  6 +++---
 tests/ui/errors/remap-path-prefix-sysroot.rs         |  2 +-
 tests/ui/errors/remap-path-prefix.rs                 |  2 +-
 .../ui/extern/extern-C-non-FFI-safe-arg-ice-52334.rs |  4 ++--
 tests/ui/extern/extern-types-field-offset.rs         |  2 +-
 tests/ui/extern/extern-types-size_of_val.rs          |  2 +-
 .../trait-bounds/hang-on-deeply-nested-dyn.rs        |  2 +-
 .../trait-bounds/hrtb-doesnt-borrow-self-1.rs        |  2 +-
 .../trait-bounds/hrtb-doesnt-borrow-self-2.rs        |  2 +-
 tests/ui/hygiene/panic-location.rs                   |  2 +-
 tests/ui/hygiene/unpretty-debug.rs                   |  2 +-
 tests/ui/hygiene/unpretty-debug.stdout               |  2 +-
 tests/ui/impl-trait/erased-regions-in-hidden-ty.rs   |  2 +-
 tests/ui/include-macros/parent_dir.rs                |  2 +-
 tests/ui/infinite/infinite-instantiation.rs          |  2 +-
 tests/ui/intrinsics/not-overridden.rs                |  6 +++---
 .../ui/invalid/invalid-debugger-visualizer-option.rs |  4 ++--
 .../ui/io-checks/non-ice-error-on-worker-io-fail.rs  |  4 ++--
 tests/ui/issues/issue-20413.rs                       |  2 +-
 tests/ui/issues/issue-21763.rs                       |  2 +-
 tests/ui/issues/issue-28625.rs                       |  2 +-
 tests/ui/issues/issue-32377.rs                       |  2 +-
 .../issue-37311-type-length-limit/issue-37311.rs     |  2 +-
 tests/ui/issues/issue-67552.rs                       |  2 +-
 tests/ui/issues/issue-8727.rs                        |  2 +-
 tests/ui/lang-items/duplicate.rs                     |  2 +-
 tests/ui/layout/debug.rs                             |  2 +-
 tests/ui/layout/enum-scalar-pair-int-ptr.rs          |  6 +++---
 tests/ui/layout/enum.rs                              |  2 +-
 tests/ui/layout/ice-type-error-in-tail-124031.rs     |  2 +-
 ...issue-96158-scalarpair-payload-might-be-uninit.rs |  2 +-
 tests/ui/layout/issue-96185-overaligned-enum.rs      |  2 +-
 tests/ui/layout/struct.rs                            |  2 +-
 tests/ui/layout/valid_range_oob.rs                   |  4 ++--
 tests/ui/layout/zero-sized-array-enum-niche.rs       |  2 +-
 tests/ui/limits/huge-enum.rs                         |  4 ++--
 tests/ui/limits/huge-struct.rs                       |  6 +++---
 tests/ui/limits/issue-17913.rs                       |  2 +-
 tests/ui/link-native-libs/msvc-non-utf8-output.rs    |  2 +-
 tests/ui/lint/lint-overflowing-ops.rs                |  4 ++--
 tests/ui/lto/lto-duplicate-symbols.rs                |  2 +-
 tests/ui/macros/macros-nonfatal-errors.rs            |  2 +-
 tests/ui/methods/inherent-bound-in-probe.rs          |  2 +-
 tests/ui/mir/lint/storage-live.rs                    |  8 ++++----
 tests/ui/modules/path-no-file-name.rs                |  4 ++--
 tests/ui/packed/packed-struct-transmute.rs           |  2 +-
 tests/ui/panic-handler/panic-handler-std.rs          |  2 +-
 tests/ui/panics/default-backtrace-ice.rs             | 12 ++++++------
 tests/ui/panics/issue-47429-short-backtraces.rs      |  6 +++---
 tests/ui/panics/panic-in-cleanup.rs                  |  6 +++---
 tests/ui/panics/panic-in-ffi.rs                      |  6 +++---
 tests/ui/panics/panic-in-message-fmt.rs              |  6 +++---
 .../panics/panic-short-backtrace-windows-x86_64.rs   |  2 +-
 tests/ui/panics/runtime-switch.rs                    |  6 +++---
 tests/ui/panics/short-ice-remove-middle-frames-2.rs  |  6 +++---
 tests/ui/panics/short-ice-remove-middle-frames.rs    |  6 +++---
 tests/ui/parser/issues/issue-5806.rs                 |  4 ++--
 tests/ui/parser/mod_file_with_path_attr.rs           |  2 +-
 tests/ui/print-request/macos-target.rs               |  6 +++---
 tests/ui/proc-macro/load-panic-backtrace.rs          |  4 ++--
 tests/ui/proc-macro/meta-macro-hygiene.rs            |  6 +++---
 tests/ui/proc-macro/meta-macro-hygiene.stdout        |  6 +++---
 tests/ui/proc-macro/nonterminal-token-hygiene.rs     |  6 +++---
 tests/ui/proc-macro/nonterminal-token-hygiene.stdout |  6 +++---
 tests/ui/process/println-with-broken-pipe.rs         |  2 +-
 tests/ui/recursion/issue-23122-2.rs                  |  2 +-
 tests/ui/recursion/issue-83150.rs                    |  2 +-
 tests/ui/recursion/recursion.rs                      |  2 +-
 tests/ui/regions/issue-102374.rs                     |  2 +-
 tests/ui/repr/repr-c-dead-variants.rs                |  2 +-
 tests/ui/repr/repr-c-int-dead-variants.rs            |  2 +-
 .../multiple_definitions_attribute_merging.rs        |  6 +++---
 tests/ui/resolve/proc_macro_generated_packed.rs      |  6 +++---
 tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.rs   | 12 ++++++------
 tests/ui/statics/mutable_memory_validation.rs        |  4 ++--
 tests/ui/svh/changing-crates.rs                      |  2 +-
 tests/ui/svh/svh-change-lit.rs                       |  2 +-
 tests/ui/svh/svh-change-significant-cfg.rs           |  2 +-
 tests/ui/svh/svh-change-trait-bound.rs               |  2 +-
 tests/ui/svh/svh-change-type-arg.rs                  |  2 +-
 tests/ui/svh/svh-change-type-ret.rs                  |  2 +-
 tests/ui/svh/svh-change-type-static.rs               |  2 +-
 tests/ui/svh/svh-use-trait.rs                        |  2 +-
 tests/ui/symbol-names/const-generics-demangling.rs   |  4 ++--
 .../ui/symbol-names/const-generics-str-demangling.rs |  2 +-
 .../const-generics-structural-demangling.rs          |  2 +-
 tests/ui/symbol-names/impl1.rs                       |  2 +-
 tests/ui/symbol-names/issue-75326.rs                 |  2 +-
 tests/ui/symbol-names/trait-objects.rs               |  2 +-
 tests/ui/symbol-names/types.rs                       |  4 ++--
 tests/ui/test-attrs/terse.rs                         |  2 +-
 tests/ui/test-attrs/test-filter-multiple.rs          |  2 +-
 tests/ui/test-attrs/test-panic-abort-nocapture.rs    |  2 +-
 tests/ui/test-attrs/test-panic-abort.rs              |  2 +-
 tests/ui/test-attrs/test-passed.rs                   |  2 +-
 tests/ui/test-attrs/test-thread-capture.rs           |  2 +-
 tests/ui/test-attrs/test-thread-nocapture.rs         |  2 +-
 tests/ui/test-attrs/test-type.rs                     |  2 +-
 tests/ui/test-attrs/tests-listing-format-json.rs     |  4 ++--
 tests/ui/track-diagnostics/track.rs                  |  6 +++---
 tests/ui/track-diagnostics/track2.rs                 |  2 +-
 tests/ui/track-diagnostics/track3.rs                 |  2 +-
 tests/ui/track-diagnostics/track4.rs                 |  2 +-
 tests/ui/track-diagnostics/track5.rs                 |  2 +-
 tests/ui/track-diagnostics/track6.rs                 |  2 +-
 tests/ui/traits/on_unimplemented_long_types.rs       |  2 +-
 .../trait-upcasting/illegal-upcast-to-impl-opaque.rs |  8 ++++----
 tests/ui/transmute/transmute-different-sizes.rs      |  2 +-
 tests/ui/transmute/transmute-fat-pointers.rs         |  2 +-
 tests/ui/transmute/transmute-impl.rs                 |  2 +-
 tests/ui/treat-err-as-bug/err.rs                     |  4 ++--
 tests/ui/treat-err-as-bug/span_delayed_bug.rs        |  4 ++--
 tests/ui/type/pattern_types/range_patterns.rs        |  2 +-
 tests/ui/unknown-llvm-arg.rs                         |  4 ++--
 tests/ui/unpretty/avoid-crash.rs                     |  2 +-
 tests/ui/unpretty/staged-api-invalid-path-108697.rs  |  2 +-
 238 files changed, 442 insertions(+), 443 deletions(-)

(limited to 'tests')

diff --git a/src/tools/compiletest/src/directive-list.rs b/src/tools/compiletest/src/directive-list.rs
index 5638d471890..01068af3e8c 100644
--- a/src/tools/compiletest/src/directive-list.rs
+++ b/src/tools/compiletest/src/directive-list.rs
@@ -160,10 +160,10 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "needs-xray",
     "no-auto-check-cfg",
     "no-prefer-dynamic",
+    "normalize-stderr",
     "normalize-stderr-32bit",
     "normalize-stderr-64bit",
-    "normalize-stderr-test",
-    "normalize-stdout-test",
+    "normalize-stdout",
     "only-16bit",
     "only-32bit",
     "only-64bit",
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index f2a944e78cc..67ecdaf9e5e 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -984,8 +984,8 @@ impl Config {
         let (directive_name, _value) = line.split_once(':')?;
 
         let kind = match directive_name {
-            "normalize-stdout-test" => NormalizeKind::Stdout,
-            "normalize-stderr-test" => NormalizeKind::Stderr,
+            "normalize-stdout" => NormalizeKind::Stdout,
+            "normalize-stderr" => NormalizeKind::Stderr,
             "normalize-stderr-32bit" => NormalizeKind::Stderr32bit,
             "normalize-stderr-64bit" => NormalizeKind::Stderr64bit,
             _ => return None,
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 35cda17e168..aefcd2bb0cc 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -69,8 +69,7 @@ const ANNOTATIONS_TO_IGNORE: &[&str] = &[
     "// gdb",
     "// lldb",
     "// cdb",
-    "// normalize-stderr-test",
-    "//@ normalize-stderr-test",
+    "//@ normalize-stderr",
 ];
 
 fn generate_problems<'a>(
@@ -198,8 +197,8 @@ fn should_ignore(line: &str) -> bool {
 
     // For `ui_test`-style UI test directives, also ignore
     // - `//@[rev] compile-flags`
-    // - `//@[rev] normalize-stderr-test`
-        || static_regex!("\\s*//@(\\[.*\\]) (compile-flags|normalize-stderr-test|error-pattern).*")
+    // - `//@[rev] normalize-stderr`
+        || static_regex!("\\s*//@(\\[.*\\]) (compile-flags|normalize-stderr|error-pattern).*")
             .is_match(line)
         // Matching for rustdoc tests commands.
         // It allows to prevent them emitting warnings like `line longer than 100 chars`.
diff --git a/tests/rustdoc-ui/2024-doctests-checks.rs b/tests/rustdoc-ui/2024-doctests-checks.rs
index f3e4e10f571..0c3a11771f3 100644
--- a/tests/rustdoc-ui/2024-doctests-checks.rs
+++ b/tests/rustdoc-ui/2024-doctests-checks.rs
@@ -1,9 +1,9 @@
 //@ check-pass
 //@ edition: 2024
 //@ compile-flags: --test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout: "tests/rustdoc-ui" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 /// ```
 /// let x = 12;
diff --git a/tests/rustdoc-ui/2024-doctests-crate-attribute.rs b/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
index a353fc7cc44..c9887cbc63b 100644
--- a/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
+++ b/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
@@ -1,9 +1,9 @@
 //@ check-pass
 //@ edition: 2024
 //@ compile-flags: --test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout: "tests/rustdoc-ui" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 /// This doctest is used to ensure that if a crate attribute is present,
 /// it will not be part of the merged doctests.
diff --git a/tests/rustdoc-ui/argfile/commandline-argfile-missing-windows.rs b/tests/rustdoc-ui/argfile/commandline-argfile-missing-windows.rs
index 24cfd25ccad..1a1cf6b9e75 100644
--- a/tests/rustdoc-ui/argfile/commandline-argfile-missing-windows.rs
+++ b/tests/rustdoc-ui/argfile/commandline-argfile-missing-windows.rs
@@ -5,8 +5,8 @@
 // line arguments and is only run on windows.
 //
 //@ only-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}\argfile\commandline-argfile-missing.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/rustdoc-ui/argfile/commandline-argfile-missing.rs b/tests/rustdoc-ui/argfile/commandline-argfile-missing.rs
index fe6a849b0c8..8d9335f5add 100644
--- a/tests/rustdoc-ui/argfile/commandline-argfile-missing.rs
+++ b/tests/rustdoc-ui/argfile/commandline-argfile-missing.rs
@@ -6,8 +6,8 @@
 // windows.
 //
 //@ ignore-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}/argfile/commandline-argfile-missing.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/rustdoc-ui/argfile/commandline-argfile-multiple-windows.rs b/tests/rustdoc-ui/argfile/commandline-argfile-multiple-windows.rs
index 84c050d84e2..9cbbd505c57 100644
--- a/tests/rustdoc-ui/argfile/commandline-argfile-multiple-windows.rs
+++ b/tests/rustdoc-ui/argfile/commandline-argfile-multiple-windows.rs
@@ -5,9 +5,9 @@
 // line arguments and is only run on windows.
 //
 //@ only-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
-//@ normalize-stderr-test: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}\argfile\commandline-argfile-missing.args @{{src-base}}\argfile\commandline-argfile-badutf8.args @{{src-base}}\argfile\commandline-argfile-missing2.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/rustdoc-ui/argfile/commandline-argfile-multiple.rs b/tests/rustdoc-ui/argfile/commandline-argfile-multiple.rs
index f658ee34fbb..f211a50892c 100644
--- a/tests/rustdoc-ui/argfile/commandline-argfile-multiple.rs
+++ b/tests/rustdoc-ui/argfile/commandline-argfile-multiple.rs
@@ -6,9 +6,9 @@
 // windows.
 //
 //@ ignore-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
-//@ normalize-stderr-test: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}/argfile/commandline-argfile-missing.args @{{src-base}}/argfile/commandline-argfile-badutf8.args @{{src-base}}/argfile/commandline-argfile-missing2.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/rustdoc-ui/disambiguator-endswith-named-suffix.rs b/tests/rustdoc-ui/disambiguator-endswith-named-suffix.rs
index c3da1fdd7cc..1174e16dd53 100644
--- a/tests/rustdoc-ui/disambiguator-endswith-named-suffix.rs
+++ b/tests/rustdoc-ui/disambiguator-endswith-named-suffix.rs
@@ -1,5 +1,5 @@
 //@ check-pass
-//@ normalize-stderr-test: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
+//@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
 
 //! [struct@m!()]   //~ WARN: unmatched disambiguator `struct` and suffix `!()`
 //! [struct@m!{}]
diff --git a/tests/rustdoc-ui/doctest/block-doc-comment.rs b/tests/rustdoc-ui/doctest/block-doc-comment.rs
index df953dc49be..84bb5abb244 100644
--- a/tests/rustdoc-ui/doctest/block-doc-comment.rs
+++ b/tests/rustdoc-ui/doctest/block-doc-comment.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 //@ compile-flags:--test
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // This test ensures that no code block is detected in the doc comments.
 
diff --git a/tests/rustdoc-ui/doctest/cfg-test.rs b/tests/rustdoc-ui/doctest/cfg-test.rs
index 573172349ac..340a2eec87a 100644
--- a/tests/rustdoc-ui/doctest/cfg-test.rs
+++ b/tests/rustdoc-ui/doctest/cfg-test.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags:--test --test-args --test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // Crates like core have doctests gated on `cfg(not(test))` so we need to make
 // sure `cfg(test)` is not active when running `rustdoc --test`.
diff --git a/tests/rustdoc-ui/doctest/check-cfg-test.rs b/tests/rustdoc-ui/doctest/check-cfg-test.rs
index b3bff381d64..39fdb3a5853 100644
--- a/tests/rustdoc-ui/doctest/check-cfg-test.rs
+++ b/tests/rustdoc-ui/doctest/check-cfg-test.rs
@@ -1,8 +1,8 @@
 //@ check-pass
 //@ compile-flags: --test --nocapture --check-cfg=cfg(feature,values("test")) -Z unstable-options
-//@ normalize-stderr-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stderr: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// The doctest will produce a warning because feature invalid is unexpected
 /// ```
diff --git a/tests/rustdoc-ui/doctest/comment-in-attr-134221-2.rs b/tests/rustdoc-ui/doctest/comment-in-attr-134221-2.rs
index 8cdd665ff69..944939c8efe 100644
--- a/tests/rustdoc-ui/doctest/comment-in-attr-134221-2.rs
+++ b/tests/rustdoc-ui/doctest/comment-in-attr-134221-2.rs
@@ -1,8 +1,8 @@
 //@ compile-flags:--test --test-args --test-threads=1
 //@ failure-status: 101
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 //! ```
 #![doc = "#![all\
diff --git a/tests/rustdoc-ui/doctest/comment-in-attr-134221.rs b/tests/rustdoc-ui/doctest/comment-in-attr-134221.rs
index 3689ebe166a..2fbc8a21560 100644
--- a/tests/rustdoc-ui/doctest/comment-in-attr-134221.rs
+++ b/tests/rustdoc-ui/doctest/comment-in-attr-134221.rs
@@ -4,9 +4,9 @@
 
 //@ compile-flags:--test --test-args --test-threads=1
 //@ failure-status: 101
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 /*!
 ```rust
diff --git a/tests/rustdoc-ui/doctest/dead-code-2024.rs b/tests/rustdoc-ui/doctest/dead-code-2024.rs
index 41459c5e651..079d44570bb 100644
--- a/tests/rustdoc-ui/doctest/dead-code-2024.rs
+++ b/tests/rustdoc-ui/doctest/dead-code-2024.rs
@@ -2,8 +2,8 @@
 
 //@ edition: 2024
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
diff --git a/tests/rustdoc-ui/doctest/dead-code.rs b/tests/rustdoc-ui/doctest/dead-code.rs
index cb9b4c28f6c..1ea3e1d53ac 100644
--- a/tests/rustdoc-ui/doctest/dead-code.rs
+++ b/tests/rustdoc-ui/doctest/dead-code.rs
@@ -1,8 +1,8 @@
 // This test ensures that the doctest will not use `#[allow(unused)]`.
 
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
diff --git a/tests/rustdoc-ui/doctest/display-output.rs b/tests/rustdoc-ui/doctest/display-output.rs
index 70d15ea6f8a..d5de341b696 100644
--- a/tests/rustdoc-ui/doctest/display-output.rs
+++ b/tests/rustdoc-ui/doctest/display-output.rs
@@ -3,8 +3,8 @@
 //@ check-pass
 //@ edition:2018
 //@ compile-flags:--test --test-args=--show-output
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// #![warn(unused)]
diff --git a/tests/rustdoc-ui/doctest/doc-comment-multi-line-attr.rs b/tests/rustdoc-ui/doctest/doc-comment-multi-line-attr.rs
index f95d6f82933..135ecca7ffd 100644
--- a/tests/rustdoc-ui/doctest/doc-comment-multi-line-attr.rs
+++ b/tests/rustdoc-ui/doctest/doc-comment-multi-line-attr.rs
@@ -1,7 +1,7 @@
 // Regression test for #97440: Multiline inner attribute triggers ICE during doctest
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 //! ```rust
diff --git a/tests/rustdoc-ui/doctest/doc-comment-multi-line-cfg-attr.rs b/tests/rustdoc-ui/doctest/doc-comment-multi-line-cfg-attr.rs
index 8cafadfdc82..16adb3c6c54 100644
--- a/tests/rustdoc-ui/doctest/doc-comment-multi-line-cfg-attr.rs
+++ b/tests/rustdoc-ui/doctest/doc-comment-multi-line-cfg-attr.rs
@@ -1,6 +1,6 @@
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/doc-test-doctest-feature.rs b/tests/rustdoc-ui/doctest/doc-test-doctest-feature.rs
index fca1f51ed21..9c2d200329a 100644
--- a/tests/rustdoc-ui/doctest/doc-test-doctest-feature.rs
+++ b/tests/rustdoc-ui/doctest/doc-test-doctest-feature.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // Make sure `cfg(doctest)` is set when finding doctests but not inside
 // the doctests.
diff --git a/tests/rustdoc-ui/doctest/doc-test-rustdoc-feature.rs b/tests/rustdoc-ui/doctest/doc-test-rustdoc-feature.rs
index 6d12d7af56a..dd04adfe617 100644
--- a/tests/rustdoc-ui/doctest/doc-test-rustdoc-feature.rs
+++ b/tests/rustdoc-ui/doctest/doc-test-rustdoc-feature.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 #![feature(doc_cfg)]
 
diff --git a/tests/rustdoc-ui/doctest/doctest-multiline-crate-attribute.rs b/tests/rustdoc-ui/doctest/doctest-multiline-crate-attribute.rs
index b446492e472..1f80e002ef5 100644
--- a/tests/rustdoc-ui/doctest/doctest-multiline-crate-attribute.rs
+++ b/tests/rustdoc-ui/doctest/doctest-multiline-crate-attribute.rs
@@ -1,6 +1,6 @@
 //@ compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/doctest-output-include-fail.rs b/tests/rustdoc-ui/doctest/doctest-output-include-fail.rs
index 58612b682a0..a47bac3daef 100644
--- a/tests/rustdoc-ui/doctest/doctest-output-include-fail.rs
+++ b/tests/rustdoc-ui/doctest/doctest-output-include-fail.rs
@@ -1,7 +1,7 @@
 //@ edition:2024
 //@ compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 // https://github.com/rust-lang/rust/issues/130470
diff --git a/tests/rustdoc-ui/doctest/doctest-output.rs b/tests/rustdoc-ui/doctest/doctest-output.rs
index 946bc550b12..fb4ab068000 100644
--- a/tests/rustdoc-ui/doctest/doctest-output.rs
+++ b/tests/rustdoc-ui/doctest/doctest-output.rs
@@ -5,8 +5,8 @@
 //@[edition2024]edition:2015
 //@[edition2024]aux-build:extern_macros.rs
 //@[edition2024]compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 //! ```
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-compile-fail.rs b/tests/rustdoc-ui/doctest/failed-doctest-compile-fail.rs
index 4d0e035f86e..6f7b2672b56 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-compile-fail.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-compile-fail.rs
@@ -2,8 +2,8 @@
 // adapted to use that, and that normalize line can go away
 
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```compile_fail
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs
index b65ef432705..508faadcf67 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs
@@ -2,8 +2,8 @@
 // adapted to use that, and that normalize line can go away
 
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// <https://github.com/rust-lang/rust/issues/91014>
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.rs b/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.rs
index 766d9486143..ded674bf18a 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.rs
@@ -2,8 +2,8 @@
 // adapted to use that, and that normalize line can go away
 
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```compile_fail,E0004
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.rs b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.rs
index cf0d8b9daa1..3a08faf626f 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.rs
@@ -7,8 +7,8 @@
 
 //@ compile-flags:--test --test-args --test-threads=1
 //@ rustc-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 // doctest fails at runtime
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output.rs b/tests/rustdoc-ui/doctest/failed-doctest-output.rs
index 160796065f3..84c72268881 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output.rs
@@ -7,8 +7,8 @@
 
 //@ compile-flags:--test --test-args --test-threads=1
 //@ rustc-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 // doctest fails at runtime
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
index 4fe513b4066..d8c43100d2f 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
@@ -2,8 +2,8 @@
 // adapted to use that, and that normalize line can go away
 
 //@ compile-flags:--test --edition 2021
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```should_panic
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs
index d057218688c..793f8654661 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs
@@ -3,8 +3,8 @@
 
 //@ edition: 2024
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```should_panic
diff --git a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
index 754791361e8..7dac64e6de4 100644
--- a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
+++ b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
@@ -1,7 +1,7 @@
 //@ edition: 2024
 //@ compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 /// ```ignore (test)
diff --git a/tests/rustdoc-ui/doctest/nested-main.rs b/tests/rustdoc-ui/doctest/nested-main.rs
index e939ba81214..d1b3bd6da40 100644
--- a/tests/rustdoc-ui/doctest/nested-main.rs
+++ b/tests/rustdoc-ui/doctest/nested-main.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // Regression test for <https://github.com/rust-lang/rust/issues/131893>.
 // It ensures that if a function called `main` is nested, it will not consider
diff --git a/tests/rustdoc-ui/doctest/no-run-flag.rs b/tests/rustdoc-ui/doctest/no-run-flag.rs
index 0f7a0a175f1..8f1381e0760 100644
--- a/tests/rustdoc-ui/doctest/no-run-flag.rs
+++ b/tests/rustdoc-ui/doctest/no-run-flag.rs
@@ -2,8 +2,8 @@
 
 //@ check-pass
 //@ compile-flags:-Z unstable-options --test --no-run --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// let a = true;
diff --git a/tests/rustdoc-ui/doctest/nocapture-fail.rs b/tests/rustdoc-ui/doctest/nocapture-fail.rs
index db4062e8494..8c64a49f650 100644
--- a/tests/rustdoc-ui/doctest/nocapture-fail.rs
+++ b/tests/rustdoc-ui/doctest/nocapture-fail.rs
@@ -1,8 +1,8 @@
 //@ check-pass
 //@ compile-flags:--test -Zunstable-options --nocapture
-//@ normalize-stderr-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stderr: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```compile_fail
 /// fn foo() {
diff --git a/tests/rustdoc-ui/doctest/nocapture.rs b/tests/rustdoc-ui/doctest/nocapture.rs
index 3b87dad49f9..c4360341864 100644
--- a/tests/rustdoc-ui/doctest/nocapture.rs
+++ b/tests/rustdoc-ui/doctest/nocapture.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags:--test -Zunstable-options --nocapture
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// println!("hello!");
diff --git a/tests/rustdoc-ui/doctest/non-local-defs-impl.rs b/tests/rustdoc-ui/doctest/non-local-defs-impl.rs
index b1ab5323a2b..04fdd285506 100644
--- a/tests/rustdoc-ui/doctest/non-local-defs-impl.rs
+++ b/tests/rustdoc-ui/doctest/non-local-defs-impl.rs
@@ -3,8 +3,8 @@
 //@ failure-status: 101
 //@ aux-build:pub_trait.rs
 //@ compile-flags: --test --test-args --test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 #![doc(test(attr(deny(non_local_definitions))))]
 #![doc(test(attr(allow(dead_code))))]
diff --git a/tests/rustdoc-ui/doctest/non_local_defs.rs b/tests/rustdoc-ui/doctest/non_local_defs.rs
index a2f66c39223..ce65ad2cf72 100644
--- a/tests/rustdoc-ui/doctest/non_local_defs.rs
+++ b/tests/rustdoc-ui/doctest/non_local_defs.rs
@@ -1,8 +1,8 @@
 //@ check-pass
 //@ compile-flags:--test --test-args --test-threads=1 --nocapture -Zunstable-options
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stderr-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stderr: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 //! ```
 //! #[macro_export]
diff --git a/tests/rustdoc-ui/doctest/relative-path-include-bytes-132203.rs b/tests/rustdoc-ui/doctest/relative-path-include-bytes-132203.rs
index 5a1d4d0a60d..5c9e2978e48 100644
--- a/tests/rustdoc-ui/doctest/relative-path-include-bytes-132203.rs
+++ b/tests/rustdoc-ui/doctest/relative-path-include-bytes-132203.rs
@@ -7,8 +7,8 @@
 //@[edition2024]edition:2024
 //@[edition2024]check-pass
 //@[edition2024]compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // https://github.com/rust-lang/rust/issues/132203
 // This version, because it's edition2024, passes thanks to the new
diff --git a/tests/rustdoc-ui/doctest/run-directory.rs b/tests/rustdoc-ui/doctest/run-directory.rs
index 0e3a30ba461..090bd19c4d9 100644
--- a/tests/rustdoc-ui/doctest/run-directory.rs
+++ b/tests/rustdoc-ui/doctest/run-directory.rs
@@ -4,8 +4,8 @@
 //@ check-pass
 //@ [correct]compile-flags:--test --test-run-directory={{src-base}}
 //@ [incorrect]compile-flags:--test --test-run-directory={{src-base}}/coverage
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// assert_eq!(
diff --git a/tests/rustdoc-ui/doctest/rustflags-multiple-args.rs b/tests/rustdoc-ui/doctest/rustflags-multiple-args.rs
index 8519920e53b..8d8c60ede58 100644
--- a/tests/rustdoc-ui/doctest/rustflags-multiple-args.rs
+++ b/tests/rustdoc-ui/doctest/rustflags-multiple-args.rs
@@ -4,8 +4,8 @@
 //@ check-pass
 //@ compile-flags: --test -Zunstable-options --doctest-compilation-args=--cfg=testcase_must_be_present
 //@ compile-flags: --doctest-compilation-args=--cfg=another
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// #[cfg(testcase_must_be_present)]
diff --git a/tests/rustdoc-ui/doctest/rustflags.rs b/tests/rustdoc-ui/doctest/rustflags.rs
index fa460e35547..9f1e6017ea1 100644
--- a/tests/rustdoc-ui/doctest/rustflags.rs
+++ b/tests/rustdoc-ui/doctest/rustflags.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags: --test -Zunstable-options --doctest-compilation-args=--cfg=testcase_must_be_present
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// #[cfg(testcase_must_be_present)]
diff --git a/tests/rustdoc-ui/doctest/standalone-warning-2024.rs b/tests/rustdoc-ui/doctest/standalone-warning-2024.rs
index 35d1c738bb1..c53a8b48749 100644
--- a/tests/rustdoc-ui/doctest/standalone-warning-2024.rs
+++ b/tests/rustdoc-ui/doctest/standalone-warning-2024.rs
@@ -2,9 +2,9 @@
 
 //@ edition: 2024
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 #![deny(warnings)]
 
diff --git a/tests/rustdoc-ui/doctest/test-no_std.rs b/tests/rustdoc-ui/doctest/test-no_std.rs
index b8af892552d..9abfa4a3728 100644
--- a/tests/rustdoc-ui/doctest/test-no_std.rs
+++ b/tests/rustdoc-ui/doctest/test-no_std.rs
@@ -1,6 +1,6 @@
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 #![no_std]
diff --git a/tests/rustdoc-ui/doctest/test-type.rs b/tests/rustdoc-ui/doctest/test-type.rs
index 846a98a853b..28c862fb69b 100644
--- a/tests/rustdoc-ui/doctest/test-type.rs
+++ b/tests/rustdoc-ui/doctest/test-type.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: --test --test-args=--test-threads=1
 //@ check-pass
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 /// ```
 /// let a = true;
diff --git a/tests/rustdoc-ui/doctest/unparseable-doc-test.rs b/tests/rustdoc-ui/doctest/unparseable-doc-test.rs
index 43acfa6de3f..d90e152aada 100644
--- a/tests/rustdoc-ui/doctest/unparseable-doc-test.rs
+++ b/tests/rustdoc-ui/doctest/unparseable-doc-test.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: --test
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 //@ rustc-env: RUST_BACKTRACE=0
 
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
index a1455c01bc6..3b4fb3f3443 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
@@ -1,8 +1,8 @@
 //@ edition: 2024
 //@ compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 //@ failure-status: 101
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.rs b/tests/rustdoc-ui/doctest/wrong-ast.rs
index 92286b33dcf..be8f5417586 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast.rs
@@ -1,6 +1,6 @@
 //@ compile-flags:--test --test-args=--test-threads=1
-//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```
diff --git a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.rs b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.rs
index dfa528acb26..032da8f53f0 100644
--- a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.rs
+++ b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "`.*`" -> "`DEF_ID`"
-//@ normalize-stdout-test: "`.*`" -> "`DEF_ID`"
+//@ normalize-stderr: "`.*`" -> "`DEF_ID`"
+//@ normalize-stdout: "`.*`" -> "`DEF_ID`"
 //@ edition:2018
 
 pub async fn f() -> impl std::fmt::Debug {
diff --git a/tests/rustdoc-ui/ice-bug-report-url.rs b/tests/rustdoc-ui/ice-bug-report-url.rs
index f270340e07e..9260644e44f 100644
--- a/tests/rustdoc-ui/ice-bug-report-url.rs
+++ b/tests/rustdoc-ui/ice-bug-report-url.rs
@@ -4,12 +4,12 @@
 //@ error-pattern: aborting due to
 //@ error-pattern: we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new?labels=C-bug%2C+I-ICE%2C+T-rustdoc&template=ice.md
 
-//@ normalize-stderr-test: "note: compiler flags.*\n\n" -> ""
-//@ normalize-stderr-test: "note: rustc.*running on.*" -> "note: rustc {version} running on {platform}"
-//@ normalize-stderr-test: "thread.*panicked at compiler.*" -> ""
-//@ normalize-stderr-test: " +\d{1,}: .*\n" -> ""
-//@ normalize-stderr-test: " + at .*\n" -> ""
-//@ normalize-stderr-test: ".*note: Some details are omitted.*\n" -> ""
+//@ normalize-stderr: "note: compiler flags.*\n\n" -> ""
+//@ normalize-stderr: "note: rustc.*running on.*" -> "note: rustc {version} running on {platform}"
+//@ normalize-stderr: "thread.*panicked at compiler.*" -> ""
+//@ normalize-stderr: " +\d{1,}: .*\n" -> ""
+//@ normalize-stderr: " + at .*\n" -> ""
+//@ normalize-stderr: ".*note: Some details are omitted.*\n" -> ""
 
 fn wrong()
 //~^ ERROR expected one of
diff --git a/tests/rustdoc-ui/intra-doc/email-address-localhost.rs b/tests/rustdoc-ui/intra-doc/email-address-localhost.rs
index adef39527eb..3faff8a3cca 100644
--- a/tests/rustdoc-ui/intra-doc/email-address-localhost.rs
+++ b/tests/rustdoc-ui/intra-doc/email-address-localhost.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
+//@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
 //@ check-pass
 #![deny(warnings)]
 
diff --git a/tests/rustdoc-ui/intra-doc/unknown-disambiguator.rs b/tests/rustdoc-ui/intra-doc/unknown-disambiguator.rs
index 68b818e32b3..86b31cb14d8 100644
--- a/tests/rustdoc-ui/intra-doc/unknown-disambiguator.rs
+++ b/tests/rustdoc-ui/intra-doc/unknown-disambiguator.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
+//@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
 #![deny(warnings)]
 
 //! Linking to [foo@banana] and [`bar@banana!()`].
diff --git a/tests/rustdoc-ui/issues/issue-80992.rs b/tests/rustdoc-ui/issues/issue-80992.rs
index 31cc8b78ecc..c328ac53e53 100644
--- a/tests/rustdoc-ui/issues/issue-80992.rs
+++ b/tests/rustdoc-ui/issues/issue-80992.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags:--test
-//@ normalize-stdout-test: "tests/rustdoc-ui/issues" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/issues" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 pub fn test() -> Result<(), ()> {
     //! ```compile_fail
diff --git a/tests/rustdoc-ui/issues/issue-81662-shortness.rs b/tests/rustdoc-ui/issues/issue-81662-shortness.rs
index 7df63261ce7..8719442c34f 100644
--- a/tests/rustdoc-ui/issues/issue-81662-shortness.rs
+++ b/tests/rustdoc-ui/issues/issue-81662-shortness.rs
@@ -1,8 +1,8 @@
 //@ compile-flags:--test --error-format=short
 //@ check-stdout
 //@ error-pattern:cannot find function `foo`
-//@ normalize-stdout-test: "tests/rustdoc-ui/issues" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/issues" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```rust
diff --git a/tests/rustdoc-ui/issues/issue-83883-describe-lints.rs b/tests/rustdoc-ui/issues/issue-83883-describe-lints.rs
index a7b1c734d7f..35d2fda4585 100644
--- a/tests/rustdoc-ui/issues/issue-83883-describe-lints.rs
+++ b/tests/rustdoc-ui/issues/issue-83883-describe-lints.rs
@@ -6,5 +6,5 @@
 //
 // ignore-tidy-linelength
 //
-//@ normalize-stdout-test: "( +name  default  meaning\n +----  -------  -------\n)?( *[[:word:]:-]+  (allow  |warn   |deny   |forbid )  [^\n]+\n)+" -> "    $$NAMES  $$LEVELS  $$MEANINGS"
-//@ normalize-stdout-test: " +name  sub-lints\n +----  ---------\n( *[[:word:]:-]+  [^\n]+\n)+" -> "    $$NAMES  $$SUB_LINTS"
+//@ normalize-stdout: "( +name  default  meaning\n +----  -------  -------\n)?( *[[:word:]:-]+  (allow  |warn   |deny   |forbid )  [^\n]+\n)+" -> "    $$NAMES  $$LEVELS  $$MEANINGS"
+//@ normalize-stdout: " +name  sub-lints\n +----  ---------\n( *[[:word:]:-]+  [^\n]+\n)+" -> "    $$NAMES  $$SUB_LINTS"
diff --git a/tests/rustdoc-ui/issues/issue-91134.rs b/tests/rustdoc-ui/issues/issue-91134.rs
index 6b1fec957ea..1c53ecfeb8b 100644
--- a/tests/rustdoc-ui/issues/issue-91134.rs
+++ b/tests/rustdoc-ui/issues/issue-91134.rs
@@ -1,8 +1,8 @@
 //@ compile-flags: --test --crate-name=empty_fn --extern=empty_fn --test-args=--test-threads=1
 //@ aux-build:empty-fn.rs
 //@ check-pass
-//@ normalize-stdout-test: "tests/rustdoc-ui/issues" -> "$$DIR"
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "tests/rustdoc-ui/issues" -> "$$DIR"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ edition:2021
 
 /// <https://github.com/rust-lang/rust/issues/91134>
diff --git a/tests/rustdoc-ui/lints/check.rs b/tests/rustdoc-ui/lints/check.rs
index 058c5d6c468..61c9f188952 100644
--- a/tests/rustdoc-ui/lints/check.rs
+++ b/tests/rustdoc-ui/lints/check.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 //@ compile-flags: -Z unstable-options --check
-//@ normalize-stderr-test: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
+//@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
 
 #![feature(rustdoc_missing_doc_code_examples)]
 //~^ WARN
diff --git a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs
index 12d4892d36a..6e631061e8a 100644
--- a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs
+++ b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs
@@ -1,5 +1,5 @@
 //@ error-pattern: no documentation found
-//@ normalize-stderr-test: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
+//@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
 #![deny(rustdoc::missing_crate_level_docs)]
 //^~ NOTE defined here
 
diff --git a/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.rs b/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.rs
index 57c0c1af031..72c3330709a 100644
--- a/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.rs
+++ b/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.rs
@@ -4,8 +4,8 @@
 //@ failure-status: 101
 //@ compile-flags:--test -Z unstable-options --remap-path-prefix={{src-base}}=remapped_path --test-args --test-threads=1
 //@ rustc-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test: "exit (status|code): 101" -> "exit status: 101"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "exit (status|code): 101" -> "exit status: 101"
 
 // doctest fails at runtime
 /// ```
diff --git a/tests/rustdoc-ui/remap-path-prefix-invalid-doctest.rs b/tests/rustdoc-ui/remap-path-prefix-invalid-doctest.rs
index 96a79e85f6b..c18a416d43f 100644
--- a/tests/rustdoc-ui/remap-path-prefix-invalid-doctest.rs
+++ b/tests/rustdoc-ui/remap-path-prefix-invalid-doctest.rs
@@ -4,7 +4,7 @@
 //@ failure-status: 101
 //@ compile-flags:--test -Z unstable-options --remap-path-prefix={{src-base}}=remapped_path --test-args --test-threads=1
 //@ rustc-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // doctest fails to compile
 /// ```
diff --git a/tests/rustdoc-ui/remap-path-prefix-passed-doctest-output.rs b/tests/rustdoc-ui/remap-path-prefix-passed-doctest-output.rs
index 4c61c43578c..6fa04ef77f3 100644
--- a/tests/rustdoc-ui/remap-path-prefix-passed-doctest-output.rs
+++ b/tests/rustdoc-ui/remap-path-prefix-passed-doctest-output.rs
@@ -5,7 +5,7 @@
 // adapted to use that, and that normalize line can go away
 
 //@ compile-flags:--test -Z unstable-options --remap-path-prefix={{src-base}}=remapped_path --test-args --test-threads=1
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // doctest passes at runtime
 /// ```
diff --git a/tests/rustdoc-ui/track-diagnostics.rs b/tests/rustdoc-ui/track-diagnostics.rs
index 403b8c78917..5c950a11082 100644
--- a/tests/rustdoc-ui/track-diagnostics.rs
+++ b/tests/rustdoc-ui/track-diagnostics.rs
@@ -3,7 +3,7 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 struct A;
 struct B;
diff --git a/tests/ui-fulldeps/codegen-backend/hotplug.rs b/tests/ui-fulldeps/codegen-backend/hotplug.rs
index dc0fb3f9efd..917b20fcdb5 100644
--- a/tests/ui-fulldeps/codegen-backend/hotplug.rs
+++ b/tests/ui-fulldeps/codegen-backend/hotplug.rs
@@ -3,8 +3,8 @@
 //@ ignore-stage1 (requires matching sysroot built with in-tree compiler)
 
 //@ aux-codegen-backend: the_backend.rs
-//@ normalize-stdout-test: "libthe_backend.dylib" -> "libthe_backend.so"
-//@ normalize-stdout-test: "the_backend.dll" -> "libthe_backend.so"
+//@ normalize-stdout: "libthe_backend.dylib" -> "libthe_backend.so"
+//@ normalize-stdout: "the_backend.dll" -> "libthe_backend.so"
 
 //@ revisions: normal dep bindep
 //@ compile-flags: --crate-type=lib
diff --git a/tests/ui-fulldeps/fluent-messages/test.rs b/tests/ui-fulldeps/fluent-messages/test.rs
index 3361ebcef01..c1f5fe730c7 100644
--- a/tests/ui-fulldeps/fluent-messages/test.rs
+++ b/tests/ui-fulldeps/fluent-messages/test.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "could not open Fluent resource:.*" -> "could not open Fluent resource: os-specific message"
+//@ normalize-stderr: "could not open Fluent resource:.*" -> "could not open Fluent resource: os-specific message"
 
 #![feature(rustc_private)]
 #![crate_type = "lib"]
diff --git a/tests/ui-fulldeps/missing-rustc-driver-error.rs b/tests/ui-fulldeps/missing-rustc-driver-error.rs
index 23ca39363bc..03ab5ce7b25 100644
--- a/tests/ui-fulldeps/missing-rustc-driver-error.rs
+++ b/tests/ui-fulldeps/missing-rustc-driver-error.rs
@@ -1,8 +1,8 @@
 // Test that we get the following hint when trying to use a compiler crate without rustc_driver.
 //@ error-pattern: try adding `extern crate rustc_driver;` at the top level of this crate
 //@ compile-flags: --emit link
-//@ normalize-stderr-test: ".*crate .* required.*\n\n" -> ""
-//@ normalize-stderr-test: "aborting due to [0-9]+" -> "aborting due to NUMBER"
+//@ normalize-stderr: ".*crate .* required.*\n\n" -> ""
+//@ normalize-stderr: "aborting due to [0-9]+" -> "aborting due to NUMBER"
 
 #![feature(rustc_private)]
 
diff --git a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.rs b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.rs
index 7921ede23c5..37f78a7777c 100644
--- a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.rs
+++ b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.rs
@@ -1,7 +1,7 @@
 //@ check-fail
 // Tests that a doc comment will not preclude a field from being considered a diagnostic argument
-//@ normalize-stderr-test: "the following other types implement trait `IntoDiagArg`:(?:.*\n){0,9}\s+and \d+ others" -> "normalized in stderr"
-//@ normalize-stderr-test: "(COMPILER_DIR/.*\.rs):[0-9]+:[0-9]+" -> "$1:LL:CC"
+//@ normalize-stderr: "the following other types implement trait `IntoDiagArg`:(?:.*\n){0,9}\s+and \d+ others" -> "normalized in stderr"
+//@ normalize-stderr: "(COMPILER_DIR/.*\.rs):[0-9]+:[0-9]+" -> "$1:LL:CC"
 
 // The proc_macro2 crate handles spans differently when on beta/stable release rather than nightly,
 // changing the output of this test. Since Subdiagnostic is strictly internal to the compiler
diff --git a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive.rs b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive.rs
index 1577b68e748..fa2d037064d 100644
--- a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive.rs
+++ b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive.rs
@@ -1,7 +1,7 @@
 //@ check-fail
 // Tests error conditions for specifying diagnostics using #[derive(Diagnostic)]
-//@ normalize-stderr-test: "the following other types implement trait `IntoDiagArg`:(?:.*\n){0,9}\s+and \d+ others" -> "normalized in stderr"
-//@ normalize-stderr-test: "(COMPILER_DIR/.*\.rs):[0-9]+:[0-9]+" -> "$1:LL:CC"
+//@ normalize-stderr: "the following other types implement trait `IntoDiagArg`:(?:.*\n){0,9}\s+and \d+ others" -> "normalized in stderr"
+//@ normalize-stderr: "(COMPILER_DIR/.*\.rs):[0-9]+:[0-9]+" -> "$1:LL:CC"
 
 // The proc_macro2 crate handles spans differently when on beta/stable release rather than nightly,
 // changing the output of this test. Since Diagnostic is strictly internal to the compiler
diff --git a/tests/ui/abi/c-zst.rs b/tests/ui/abi/c-zst.rs
index 69ebefa09ac..6b299ffadb7 100644
--- a/tests/ui/abi/c-zst.rs
+++ b/tests/ui/abi/c-zst.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+//@ normalize-stderr: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
 /*!
 C doesn't have zero-sized types... except it does.
 
diff --git a/tests/ui/abi/debug.rs b/tests/ui/abi/debug.rs
index 16d61602734..565743bf978 100644
--- a/tests/ui/abi/debug.rs
+++ b/tests/ui/abi/debug.rs
@@ -1,9 +1,9 @@
-//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
-//@ normalize-stderr-test: "(size): Size\([48] bytes\)" -> "$1: $$SOME_SIZE"
-//@ normalize-stderr-test: "(can_unwind): (true|false)" -> "$1: $$SOME_BOOL"
-//@ normalize-stderr-test: "(valid_range): 0\.\.=(4294967295|18446744073709551615)" -> "$1: $$FULL"
+//@ normalize-stderr: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+//@ normalize-stderr: "(size): Size\([48] bytes\)" -> "$1: $$SOME_SIZE"
+//@ normalize-stderr: "(can_unwind): (true|false)" -> "$1: $$SOME_BOOL"
+//@ normalize-stderr: "(valid_range): 0\.\.=(4294967295|18446744073709551615)" -> "$1: $$FULL"
 // This pattern is prepared for when we account for alignment in the niche.
-//@ normalize-stderr-test: "(valid_range): [1-9]\.\.=(429496729[0-9]|1844674407370955161[0-9])" -> "$1: $$NON_NULL"
+//@ normalize-stderr: "(valid_range): [1-9]\.\.=(429496729[0-9]|1844674407370955161[0-9])" -> "$1: $$NON_NULL"
 // Some attributes are only computed for release builds:
 //@ compile-flags: -O
 #![feature(rustc_attrs)]
diff --git a/tests/ui/abi/sysv64-zst.rs b/tests/ui/abi/sysv64-zst.rs
index 6f4497e77a1..42ba1fb5f03 100644
--- a/tests/ui/abi/sysv64-zst.rs
+++ b/tests/ui/abi/sysv64-zst.rs
@@ -1,5 +1,5 @@
 //@ only-x86_64
-//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+//@ normalize-stderr: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
 
 #![feature(rustc_attrs)]
 #![crate_type = "lib"]
diff --git a/tests/ui/abi/win64-zst.rs b/tests/ui/abi/win64-zst.rs
index a2f7d19eb45..bc4e0e629eb 100644
--- a/tests/ui/abi/win64-zst.rs
+++ b/tests/ui/abi/win64-zst.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+//@ normalize-stderr: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
 //@ only-x86_64
 
 //@ revisions: x86_64-linux
diff --git a/tests/ui/argfile/commandline-argfile-missing-windows.rs b/tests/ui/argfile/commandline-argfile-missing-windows.rs
index 24cfd25ccad..1a1cf6b9e75 100644
--- a/tests/ui/argfile/commandline-argfile-missing-windows.rs
+++ b/tests/ui/argfile/commandline-argfile-missing-windows.rs
@@ -5,8 +5,8 @@
 // line arguments and is only run on windows.
 //
 //@ only-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}\argfile\commandline-argfile-missing.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/ui/argfile/commandline-argfile-missing.rs b/tests/ui/argfile/commandline-argfile-missing.rs
index fe6a849b0c8..8d9335f5add 100644
--- a/tests/ui/argfile/commandline-argfile-missing.rs
+++ b/tests/ui/argfile/commandline-argfile-missing.rs
@@ -6,8 +6,8 @@
 // windows.
 //
 //@ ignore-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}/argfile/commandline-argfile-missing.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/ui/argfile/commandline-argfile-multiple-windows.rs b/tests/ui/argfile/commandline-argfile-multiple-windows.rs
index 84c050d84e2..9cbbd505c57 100644
--- a/tests/ui/argfile/commandline-argfile-multiple-windows.rs
+++ b/tests/ui/argfile/commandline-argfile-multiple-windows.rs
@@ -5,9 +5,9 @@
 // line arguments and is only run on windows.
 //
 //@ only-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
-//@ normalize-stderr-test: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}\argfile\commandline-argfile-missing.args @{{src-base}}\argfile\commandline-argfile-badutf8.args @{{src-base}}\argfile\commandline-argfile-missing2.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/ui/argfile/commandline-argfile-multiple.rs b/tests/ui/argfile/commandline-argfile-multiple.rs
index f658ee34fbb..f211a50892c 100644
--- a/tests/ui/argfile/commandline-argfile-multiple.rs
+++ b/tests/ui/argfile/commandline-argfile-multiple.rs
@@ -6,9 +6,9 @@
 // windows.
 //
 //@ ignore-windows
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ERR"
-//@ normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
-//@ normalize-stderr-test: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
+//@ normalize-stderr: "os error \d+" -> "os error $$ERR"
+//@ normalize-stderr: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
+//@ normalize-stderr: "commandline-argfile-missing2.args:[^(]*" -> "commandline-argfile-missing2.args: $$FILE_MISSING "
 //@ compile-flags: --cfg cmdline_set @{{src-base}}/argfile/commandline-argfile-missing.args @{{src-base}}/argfile/commandline-argfile-badutf8.args @{{src-base}}/argfile/commandline-argfile-missing2.args
 
 #[cfg(not(cmdline_set))]
diff --git a/tests/ui/associated-types/associated-types-in-ambiguous-context.rs b/tests/ui/associated-types/associated-types-in-ambiguous-context.rs
index 98bbff794ca..3c0d66f8a0d 100644
--- a/tests/ui/associated-types/associated-types-in-ambiguous-context.rs
+++ b/tests/ui/associated-types/associated-types-in-ambiguous-context.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "and \d+ other candidates" -> "and N other candidates"
+//@ normalize-stderr: "and \d+ other candidates" -> "and N other candidates"
 
 trait Get {
     type Value;
diff --git a/tests/ui/attributes/dump-preds.rs b/tests/ui/attributes/dump-preds.rs
index ca38e23b237..071a7baede5 100644
--- a/tests/ui/attributes/dump-preds.rs
+++ b/tests/ui/attributes/dump-preds.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "DefId\(.+?\)" -> "DefId(..)"
+//@ normalize-stderr: "DefId\(.+?\)" -> "DefId(..)"
 
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/attributes/dump_def_parents.rs b/tests/ui/attributes/dump_def_parents.rs
index 04a725f6c14..af117e4fa63 100644
--- a/tests/ui/attributes/dump_def_parents.rs
+++ b/tests/ui/attributes/dump_def_parents.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "DefId\(.+?\)" -> "DefId(..)"
+//@ normalize-stderr: "DefId\(.+?\)" -> "DefId(..)"
 #![feature(rustc_attrs)]
 
 fn bar() {
diff --git a/tests/ui/attributes/extented-attribute-macro-error.rs b/tests/ui/attributes/extented-attribute-macro-error.rs
index 5dcb38d7da9..83060024dac 100644
--- a/tests/ui/attributes/extented-attribute-macro-error.rs
+++ b/tests/ui/attributes/extented-attribute-macro-error.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "couldn't read.*" -> "couldn't read the file"
+//@ normalize-stderr: "couldn't read.*" -> "couldn't read the file"
 
 #![doc = include_str!("../not_existing_file.md")]
 struct Documented {}
diff --git a/tests/ui/check-cfg/and-more-diagnostic.rs b/tests/ui/check-cfg/and-more-diagnostic.rs
index 82867f3b435..977f55e8a6d 100644
--- a/tests/ui/check-cfg/and-more-diagnostic.rs
+++ b/tests/ui/check-cfg/and-more-diagnostic.rs
@@ -4,8 +4,8 @@
 //@ check-pass
 //@ no-auto-check-cfg
 //@ compile-flags: --check-cfg=cfg()
-//@ normalize-stderr-test: "and \d+ more" -> "and X more"
-//@ normalize-stderr-test: "`[a-zA-Z0-9_-]+`" -> "`xxx`"
+//@ normalize-stderr: "and \d+ more" -> "and X more"
+//@ normalize-stderr: "`[a-zA-Z0-9_-]+`" -> "`xxx`"
 
 fn main() {
     cfg!(target_feature = "zebra");
diff --git a/tests/ui/check-cfg/target_feature.rs b/tests/ui/check-cfg/target_feature.rs
index 6028dae66c4..3c0f1a3c2f6 100644
--- a/tests/ui/check-cfg/target_feature.rs
+++ b/tests/ui/check-cfg/target_feature.rs
@@ -10,7 +10,7 @@
 //@ check-pass
 //@ no-auto-check-cfg
 //@ compile-flags: --check-cfg=cfg() -Zcheck-cfg-all-expected
-//@ normalize-stderr-test: "`, `" -> "`\n`"
+//@ normalize-stderr: "`, `" -> "`\n`"
 
 fn main() {
     cfg!(target_feature = "_UNEXPECTED_VALUE");
diff --git a/tests/ui/codegen/mismatched-data-layouts.rs b/tests/ui/codegen/mismatched-data-layouts.rs
index 7d63895c65b..955f917ee33 100644
--- a/tests/ui/codegen/mismatched-data-layouts.rs
+++ b/tests/ui/codegen/mismatched-data-layouts.rs
@@ -4,8 +4,8 @@
 //@ needs-llvm-components: x86
 //@ compile-flags: --crate-type=lib --target={{src-base}}/codegen/mismatched-data-layout.json -Z unstable-options
 //@ error-pattern: differs from LLVM target's
-//@ normalize-stderr-test: "`, `[A-Za-z0-9-:]*`" -> "`, `normalized data layout`"
-//@ normalize-stderr-test: "layout, `[A-Za-z0-9-:]*`" -> "layout, `normalized data layout`"
+//@ normalize-stderr: "`, `[A-Za-z0-9-:]*`" -> "`, `normalized data layout`"
+//@ normalize-stderr: "layout, `[A-Za-z0-9-:]*`" -> "layout, `normalized data layout`"
 
 #![feature(lang_items, no_core, auto_traits)]
 #![no_core]
diff --git a/tests/ui/codegen/target-cpus.rs b/tests/ui/codegen/target-cpus.rs
index 363915c6419..f26203171f3 100644
--- a/tests/ui/codegen/target-cpus.rs
+++ b/tests/ui/codegen/target-cpus.rs
@@ -6,4 +6,4 @@
 // output so that the stdout with LLVM-at-HEAD matches the output of the LLVM
 // versions currently used by default.
 // FIXME(#133919): Once Rust upgrades to LLVM 20, remove this.
-//@ normalize-stdout-test: "(?m)^ *lime1\n" -> ""
+//@ normalize-stdout: "(?m)^ *lime1\n" -> ""
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-80742.rs b/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
index 30851b49cdc..73357d208c0 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
@@ -1,9 +1,9 @@
 //@ check-fail
 //@ known-bug: #97477
 //@ failure-status: 101
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*\n" -> ""
-//@ normalize-stderr-test: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
 //@ rustc-env:RUST_BACKTRACE=0
 
 // This test used to cause an ICE in rustc_mir::interpret::step::eval_rvalue_into_place
diff --git a/tests/ui/const-generics/transmute-fail.rs b/tests/ui/const-generics/transmute-fail.rs
index ee041972a9f..cf9064bd8f4 100644
--- a/tests/ui/const-generics/transmute-fail.rs
+++ b/tests/ui/const-generics/transmute-fail.rs
@@ -1,5 +1,5 @@
 // ignore-tidy-linelength
-//@ normalize-stderr-test: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
+//@ normalize-stderr: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
 
 
 #![feature(transmute_generic_consts)]
diff --git a/tests/ui/const-ptr/forbidden_slices.rs b/tests/ui/const-ptr/forbidden_slices.rs
index bc4993466eb..59ea92c5ab3 100644
--- a/tests/ui/const-ptr/forbidden_slices.rs
+++ b/tests/ui/const-ptr/forbidden_slices.rs
@@ -1,6 +1,6 @@
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 #![feature(
     slice_from_ptr_range,
diff --git a/tests/ui/consts/const-eval/const-eval-query-stack.rs b/tests/ui/consts/const-eval/const-eval-query-stack.rs
index c015c5e0c49..8de398787b4 100644
--- a/tests/ui/consts/const-eval/const-eval-query-stack.rs
+++ b/tests/ui/consts/const-eval/const-eval-query-stack.rs
@@ -1,16 +1,16 @@
 //@ compile-flags: -Ztreat-err-as-bug=1
 //@ failure-status: 101
 //@ rustc-env:RUST_BACKTRACE=1
-//@ normalize-stderr-test: "\nerror: .*unexpectedly panicked.*\n\n" -> ""
-//@ normalize-stderr-test: "note: we would appreciate a bug report.*\n\n" -> ""
-//@ normalize-stderr-test: "note: compiler flags.*\n\n" -> ""
-//@ normalize-stderr-test: "note: rustc.*running on.*\n\n" -> ""
-//@ normalize-stderr-test: "thread.*panicked.*:\n.*\n" -> ""
-//@ normalize-stderr-test: "stack backtrace:\n" -> ""
-//@ normalize-stderr-test: "\s\d{1,}: .*\n" -> ""
-//@ normalize-stderr-test: "\s at .*\n" -> ""
-//@ normalize-stderr-test: ".*note: Some details.*\n" -> ""
-//@ normalize-stderr-test: ".*omitted \d{1,} frame.*\n" -> ""
+//@ normalize-stderr: "\nerror: .*unexpectedly panicked.*\n\n" -> ""
+//@ normalize-stderr: "note: we would appreciate a bug report.*\n\n" -> ""
+//@ normalize-stderr: "note: compiler flags.*\n\n" -> ""
+//@ normalize-stderr: "note: rustc.*running on.*\n\n" -> ""
+//@ normalize-stderr: "thread.*panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "stack backtrace:\n" -> ""
+//@ normalize-stderr: "\s\d{1,}: .*\n" -> ""
+//@ normalize-stderr: "\s at .*\n" -> ""
+//@ normalize-stderr: ".*note: Some details.*\n" -> ""
+//@ normalize-stderr: ".*omitted \d{1,} frame.*\n" -> ""
 #![allow(unconditional_panic)]
 
 const X: i32 = 1 / 0; //~ERROR constant
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs
index 3054e79770d..509c872f609 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs
@@ -2,9 +2,9 @@
 #![feature(const_heap)]
 
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-//@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 
 use std::intrinsics;
 
diff --git a/tests/ui/consts/const-eval/raw-bytes.rs b/tests/ui/consts/const-eval/raw-bytes.rs
index 0df732df30e..9187de56362 100644
--- a/tests/ui/consts/const-eval/raw-bytes.rs
+++ b/tests/ui/consts/const-eval/raw-bytes.rs
@@ -1,7 +1,7 @@
 //@ stderr-per-bitwidth
 //@ ignore-endian-big
 // ignore-tidy-linelength
-//@ normalize-stderr-test: "╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼" -> "╾ALLOC_ID$1╼"
+//@ normalize-stderr: "╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼" -> "╾ALLOC_ID$1╼"
 #![allow(invalid_value)]
 #![feature(never_type, rustc_attrs, ptr_metadata, slice_from_ptr_range, const_slice_from_ptr_range)]
 
diff --git a/tests/ui/consts/const-eval/ub-enum.rs b/tests/ui/consts/const-eval/ub-enum.rs
index 728c1666deb..11cd87023d1 100644
--- a/tests/ui/consts/const-eval/ub-enum.rs
+++ b/tests/ui/consts/const-eval/ub-enum.rs
@@ -1,7 +1,7 @@
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-//@ normalize-stderr-test: "0x0+" -> "0x0"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "0x0+" -> "0x0"
 #![feature(never_type)]
 #![allow(invalid_value)]
 
diff --git a/tests/ui/consts/const-eval/ub-nonnull.rs b/tests/ui/consts/const-eval/ub-nonnull.rs
index 47d3ca97fda..b8e312759b4 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.rs
+++ b/tests/ui/consts/const-eval/ub-nonnull.rs
@@ -1,6 +1,6 @@
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?─*╼ )+ *│.*" -> "HEX_DUMP"
 #![allow(invalid_value)] // make sure we cannot allow away the errors tested here
 #![feature(rustc_attrs, ptr_metadata)]
 
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index 44b25a6438e..78d6fb5b65b 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -1,7 +1,7 @@
 // ignore-tidy-linelength
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 #![allow(invalid_value)]
 
 use std::mem;
diff --git a/tests/ui/consts/const-eval/ub-uninhabit.rs b/tests/ui/consts/const-eval/ub-uninhabit.rs
index 0167de26e94..d0515a4e6f0 100644
--- a/tests/ui/consts/const-eval/ub-uninhabit.rs
+++ b/tests/ui/consts/const-eval/ub-uninhabit.rs
@@ -1,6 +1,6 @@
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 #![feature(core_intrinsics)]
 #![feature(never_type)]
 
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.rs b/tests/ui/consts/const-eval/ub-wide-ptr.rs
index 991d4424dcf..a071a44272b 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.rs
@@ -5,10 +5,10 @@
 use std::{ptr, mem};
 
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-//@ normalize-stderr-test: "offset \d+" -> "offset N"
-//@ normalize-stderr-test: "size \d+" -> "size N"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "offset \d+" -> "offset N"
+//@ normalize-stderr: "size \d+" -> "size N"
 
 
 /// A newtype wrapper to prevent MIR generation from inserting reborrows that would affect the error
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
index af7463e6574..283c1224e01 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
@@ -1,6 +1,6 @@
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
-//@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
+//@ normalize-stderr: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 
 use std::cell::UnsafeCell;
 use std::mem;
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs
index 2539fcccb84..ac903fca20a 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs
@@ -1,6 +1,6 @@
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
-//@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
+//@ normalize-stderr: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 
 use std::sync::Mutex;
 
diff --git a/tests/ui/consts/const_refs_to_static_fail.rs b/tests/ui/consts/const_refs_to_static_fail.rs
index 44e848ab637..596ed50af38 100644
--- a/tests/ui/consts/const_refs_to_static_fail.rs
+++ b/tests/ui/consts/const_refs_to_static_fail.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 #![feature(sync_unsafe_cell)]
 
diff --git a/tests/ui/consts/const_refs_to_static_fail_invalid.rs b/tests/ui/consts/const_refs_to_static_fail_invalid.rs
index aa101cf9d8a..3383a208345 100644
--- a/tests/ui/consts/const_refs_to_static_fail_invalid.rs
+++ b/tests/ui/consts/const_refs_to_static_fail_invalid.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 #![allow(static_mut_refs)]
 
 fn invalid() {
diff --git a/tests/ui/consts/dangling-alloc-id-ice.rs b/tests/ui/consts/dangling-alloc-id-ice.rs
index da95d4d1347..8e9493c8d28 100644
--- a/tests/ui/consts/dangling-alloc-id-ice.rs
+++ b/tests/ui/consts/dangling-alloc-id-ice.rs
@@ -1,8 +1,8 @@
 // https://github.com/rust-lang/rust/issues/55223
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-//@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 
 union Foo<'a> {
     y: &'a (),
diff --git a/tests/ui/consts/dangling-zst-ice-issue-126393.rs b/tests/ui/consts/dangling-zst-ice-issue-126393.rs
index b56fcd235c7..4beee913a97 100644
--- a/tests/ui/consts/dangling-zst-ice-issue-126393.rs
+++ b/tests/ui/consts/dangling-zst-ice-issue-126393.rs
@@ -1,7 +1,7 @@
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-//@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 
 pub struct Wrapper;
 pub static MAGIC_FFI_REF: &'static Wrapper = unsafe {
diff --git a/tests/ui/consts/issue-17718-const-bad-values.rs b/tests/ui/consts/issue-17718-const-bad-values.rs
index 894fa5ab22f..c4de7b61f07 100644
--- a/tests/ui/consts/issue-17718-const-bad-values.rs
+++ b/tests/ui/consts/issue-17718-const-bad-values.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "\(size: \d+, align: \d+\)" -> "(size: $$PTR, align: $$PTR)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "\(size: \d+, align: \d+\)" -> "(size: $$PTR, align: $$PTR)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 #![allow(static_mut_refs)]
 
diff --git a/tests/ui/consts/issue-miri-1910.rs b/tests/ui/consts/issue-miri-1910.rs
index a66cb6b6665..107d9742b92 100644
--- a/tests/ui/consts/issue-miri-1910.rs
+++ b/tests/ui/consts/issue-miri-1910.rs
@@ -1,5 +1,5 @@
 //@ error-pattern unable to turn pointer into raw bytes
-//@ normalize-stderr-test: "alloc[0-9]+\+0x[a-z0-9]+" -> "ALLOC"
+//@ normalize-stderr: "alloc[0-9]+\+0x[a-z0-9]+" -> "ALLOC"
 
 const C: () = unsafe {
     let foo = Some(&42 as *const i32);
diff --git a/tests/ui/consts/miri_unleashed/const_refers_to_static.rs b/tests/ui/consts/miri_unleashed/const_refers_to_static.rs
index 56259532573..a6691fa2a2f 100644
--- a/tests/ui/consts/miri_unleashed/const_refers_to_static.rs
+++ b/tests/ui/consts/miri_unleashed/const_refers_to_static.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Zunleash-the-miri-inside-of-you
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
diff --git a/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.rs b/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.rs
index facb21a04ef..b33ebfb06be 100644
--- a/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.rs
+++ b/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: -Zunleash-the-miri-inside-of-you
 //@ aux-build:static_cross_crate.rs
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 #![feature(half_open_range_patterns_in_slices)]
 #![allow(static_mut_refs)]
 
diff --git a/tests/ui/consts/miri_unleashed/mutable_references.rs b/tests/ui/consts/miri_unleashed/mutable_references.rs
index a60058cc5c0..039d0fadfcc 100644
--- a/tests/ui/consts/miri_unleashed/mutable_references.rs
+++ b/tests/ui/consts/miri_unleashed/mutable_references.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Zunleash-the-miri-inside-of-you
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 #![allow(static_mut_refs)]
 use std::cell::UnsafeCell;
diff --git a/tests/ui/consts/offset_from_ub.rs b/tests/ui/consts/offset_from_ub.rs
index 7efc5dd3e28..0232b03a813 100644
--- a/tests/ui/consts/offset_from_ub.rs
+++ b/tests/ui/consts/offset_from_ub.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bytes" -> "$$BYTES bytes"
+//@ normalize-stderr: "\d+ bytes" -> "$$BYTES bytes"
 #![feature(const_ptr_sub_ptr)]
 #![feature(core_intrinsics)]
 
diff --git a/tests/ui/consts/offset_ub.rs b/tests/ui/consts/offset_ub.rs
index 5026d9a2713..dda6dd388f2 100644
--- a/tests/ui/consts/offset_ub.rs
+++ b/tests/ui/consts/offset_ub.rs
@@ -1,8 +1,8 @@
 use std::ptr;
 
-//@ normalize-stderr-test: "0xf+" -> "0xf..f"
-//@ normalize-stderr-test: "0x7f+" -> "0x7f..f"
-//@ normalize-stderr-test: "\d+ bytes" -> "$$BYTES bytes"
+//@ normalize-stderr: "0xf+" -> "0xf..f"
+//@ normalize-stderr: "0x7f+" -> "0x7f..f"
+//@ normalize-stderr: "\d+ bytes" -> "$$BYTES bytes"
 
 
 pub const BEFORE_START: *const u8 = unsafe { (&0u8 as *const u8).offset(-1) }; //~NOTE
diff --git a/tests/ui/consts/overflowing-consts.rs b/tests/ui/consts/overflowing-consts.rs
index 68282750dce..5ff205ce58e 100644
--- a/tests/ui/consts/overflowing-consts.rs
+++ b/tests/ui/consts/overflowing-consts.rs
@@ -6,8 +6,8 @@
 //@ [opt]compile-flags: -O
 //@ [opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
 //@ ignore-pass (test tests codegen-time behaviour)
-//@ normalize-stderr-test: "shift left by `(64|32)_usize`, which" -> "shift left by `%BITS%`, which"
-//@ normalize-stderr-test: "shift right by `(64|32)_usize`, which" -> "shift right by `%BITS%`, which"
+//@ normalize-stderr: "shift left by `(64|32)_usize`, which" -> "shift left by `%BITS%`, which"
+//@ normalize-stderr: "shift right by `(64|32)_usize`, which" -> "shift right by `%BITS%`, which"
 
 
 #[cfg(target_pointer_width = "32")]
diff --git a/tests/ui/consts/validate_never_arrays.rs b/tests/ui/consts/validate_never_arrays.rs
index 7585a78a0d3..055bb1c69c8 100644
--- a/tests/ui/consts/validate_never_arrays.rs
+++ b/tests/ui/consts/validate_never_arrays.rs
@@ -1,6 +1,6 @@
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 #![feature(never_type)]
 
 const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) }; //~ ERROR undefined behavior
diff --git a/tests/ui/coroutine/static-not-unpin.rs b/tests/ui/coroutine/static-not-unpin.rs
index b66a248654e..9be7eca63cb 100644
--- a/tests/ui/coroutine/static-not-unpin.rs
+++ b/tests/ui/coroutine/static-not-unpin.rs
@@ -5,7 +5,7 @@
 
 #![feature(coroutines, stmt_expr_attributes)]
 
-//@ normalize-stderr-test: "std::pin::Unpin" -> "std::marker::Unpin"
+//@ normalize-stderr: "std::pin::Unpin" -> "std::marker::Unpin"
 
 use std::marker::Unpin;
 
diff --git a/tests/ui/crate-loading/crateresolve1.rs b/tests/ui/crate-loading/crateresolve1.rs
index 2fccb744e82..9200b6a6231 100644
--- a/tests/ui/crate-loading/crateresolve1.rs
+++ b/tests/ui/crate-loading/crateresolve1.rs
@@ -2,9 +2,9 @@
 //@ aux-build:crateresolve1-2.rs
 //@ aux-build:crateresolve1-3.rs
 
-//@ normalize-stderr-test: "\.nll/" -> "/"
-//@ normalize-stderr-test: "\\\?\\" -> ""
-//@ normalize-stderr-test: "(lib)?crateresolve1-([123])\.[a-z]+" -> "libcrateresolve1-$2.somelib"
+//@ normalize-stderr: "\.nll/" -> "/"
+//@ normalize-stderr: "\\\?\\" -> ""
+//@ normalize-stderr: "(lib)?crateresolve1-([123])\.[a-z]+" -> "libcrateresolve1-$2.somelib"
 
 // NOTE: This test is duplicated at `tests/ui/error-codes/E0464.rs`.
 
diff --git a/tests/ui/crate-loading/crateresolve2.rs b/tests/ui/crate-loading/crateresolve2.rs
index 159ce04c3c4..bec692eb8d2 100644
--- a/tests/ui/crate-loading/crateresolve2.rs
+++ b/tests/ui/crate-loading/crateresolve2.rs
@@ -4,8 +4,8 @@
 //@ aux-build:crateresolve2-2.rs
 //@ aux-build:crateresolve2-3.rs
 
-//@ normalize-stderr-test: "\.nll/" -> "/"
-//@ normalize-stderr-test: "\\\?\\" -> ""
+//@ normalize-stderr: "\.nll/" -> "/"
+//@ normalize-stderr: "\\\?\\" -> ""
 
 extern crate crateresolve2;
 //~^ ERROR multiple candidates for `rmeta` dependency `crateresolve2` found
diff --git a/tests/ui/crate-loading/invalid-rlib.rs b/tests/ui/crate-loading/invalid-rlib.rs
index 0b401add8e4..6b463526244 100644
--- a/tests/ui/crate-loading/invalid-rlib.rs
+++ b/tests/ui/crate-loading/invalid-rlib.rs
@@ -1,5 +1,5 @@
 //@ compile-flags: --crate-type lib --extern foo={{src-base}}/crate-loading/auxiliary/libfoo.rlib
-//@ normalize-stderr-test: "failed to mmap file '.*auxiliary/libfoo.rlib':.*" -> "failed to mmap file 'auxiliary/libfoo.rlib'"
+//@ normalize-stderr: "failed to mmap file '.*auxiliary/libfoo.rlib':.*" -> "failed to mmap file 'auxiliary/libfoo.rlib'"
 // don't emit warn logging, it's basically the same as the errors and it's annoying to normalize
 //@ rustc-env:RUSTC_LOG=error
 //@ edition:2018
diff --git a/tests/ui/diagnostic-width/E0271.rs b/tests/ui/diagnostic-width/E0271.rs
index dedae4365e8..061ba45c219 100644
--- a/tests/ui/diagnostic-width/E0271.rs
+++ b/tests/ui/diagnostic-width/E0271.rs
@@ -1,7 +1,7 @@
 //@ revisions: ascii unicode
 //@[ascii] compile-flags: --diagnostic-width=40
 //@[unicode] compile-flags: -Zunstable-options --error-format=human-unicode --diagnostic-width=40
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 trait Future {
     type Error;
 }
diff --git a/tests/ui/diagnostic-width/long-E0308.rs b/tests/ui/diagnostic-width/long-E0308.rs
index 695852f83ac..93987226020 100644
--- a/tests/ui/diagnostic-width/long-E0308.rs
+++ b/tests/ui/diagnostic-width/long-E0308.rs
@@ -1,7 +1,7 @@
 //@ revisions: ascii unicode
 //@[ascii] compile-flags: --diagnostic-width=60 -Zwrite-long-types-to-disk=yes
 //@[unicode] compile-flags: -Zunstable-options --json=diagnostic-unicode --diagnostic-width=60 -Zwrite-long-types-to-disk=yes
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 mod a {
     // Force the "short path for unique types" machinery to trip up
diff --git a/tests/ui/duplicate_entry_error.rs b/tests/ui/duplicate_entry_error.rs
index e8b905a65f6..5a25802c6e7 100644
--- a/tests/ui/duplicate_entry_error.rs
+++ b/tests/ui/duplicate_entry_error.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "loaded from .*libstd-.*.rlib" -> "loaded from SYSROOT/libstd-*.rlib"
+//@ normalize-stderr: "loaded from .*libstd-.*.rlib" -> "loaded from SYSROOT/libstd-*.rlib"
 // note-pattern: first defined in crate `std`.
 
 // Test for issue #31788 and E0152
diff --git a/tests/ui/error-codes/E0017.rs b/tests/ui/error-codes/E0017.rs
index e103d3bf5b1..8c685aad030 100644
--- a/tests/ui/error-codes/E0017.rs
+++ b/tests/ui/error-codes/E0017.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "\(size: ., align: .\)" -> ""
-//@ normalize-stderr-test: " +│ ╾─+╼" -> ""
+//@ normalize-stderr: "\(size: ., align: .\)" -> ""
+//@ normalize-stderr: " +│ ╾─+╼" -> ""
 
 static X: i32 = 1;
 const C: i32 = 2;
diff --git a/tests/ui/error-codes/E0152.rs b/tests/ui/error-codes/E0152.rs
index 44d462c27e6..565e92baf02 100644
--- a/tests/ui/error-codes/E0152.rs
+++ b/tests/ui/error-codes/E0152.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "loaded from .*liballoc-.*.rlib" -> "loaded from SYSROOT/liballoc-*.rlib"
+//@ normalize-stderr: "loaded from .*liballoc-.*.rlib" -> "loaded from SYSROOT/liballoc-*.rlib"
 #![feature(lang_items)]
 
 #[lang = "owned_box"]
diff --git a/tests/ui/error-codes/E0275.rs b/tests/ui/error-codes/E0275.rs
index 889d9d8be90..df7b606155e 100644
--- a/tests/ui/error-codes/E0275.rs
+++ b/tests/ui/error-codes/E0275.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 trait Foo {}
 
 struct Bar<T>(T);
diff --git a/tests/ui/error-codes/E0462.rs b/tests/ui/error-codes/E0462.rs
index 2dd3b16394d..12214331445 100644
--- a/tests/ui/error-codes/E0462.rs
+++ b/tests/ui/error-codes/E0462.rs
@@ -1,8 +1,8 @@
 //@ aux-build:found-staticlib.rs
 
-//@ normalize-stderr-test: "\.nll/" -> "/"
-//@ normalize-stderr-test: "\\\?\\" -> ""
-//@ normalize-stderr-test: "(lib)?found_staticlib\.[a-z]+" -> "libfound_staticlib.somelib"
+//@ normalize-stderr: "\.nll/" -> "/"
+//@ normalize-stderr: "\\\?\\" -> ""
+//@ normalize-stderr: "(lib)?found_staticlib\.[a-z]+" -> "libfound_staticlib.somelib"
 
 extern crate found_staticlib; //~ ERROR E0462
 
diff --git a/tests/ui/error-codes/E0464.rs b/tests/ui/error-codes/E0464.rs
index 4ecf21996cc..aaf4d3a8f50 100644
--- a/tests/ui/error-codes/E0464.rs
+++ b/tests/ui/error-codes/E0464.rs
@@ -2,9 +2,9 @@
 //@ aux-build:crateresolve1-2.rs
 //@ aux-build:crateresolve1-3.rs
 
-//@ normalize-stderr-test: "\.nll/" -> "/"
-//@ normalize-stderr-test: "\\\?\\" -> ""
-//@ normalize-stderr-test: "(lib)?crateresolve1-([123])\.[a-z]+" -> "libcrateresolve1-$2.somelib"
+//@ normalize-stderr: "\.nll/" -> "/"
+//@ normalize-stderr: "\\\?\\" -> ""
+//@ normalize-stderr: "(lib)?crateresolve1-([123])\.[a-z]+" -> "libcrateresolve1-$2.somelib"
 
 // NOTE: This test is duplicated from `tests/ui/crate-loading/crateresolve1.rs`.
 
diff --git a/tests/ui/error-codes/E0523.rs b/tests/ui/error-codes/E0523.rs
index 4ecf21996cc..aaf4d3a8f50 100644
--- a/tests/ui/error-codes/E0523.rs
+++ b/tests/ui/error-codes/E0523.rs
@@ -2,9 +2,9 @@
 //@ aux-build:crateresolve1-2.rs
 //@ aux-build:crateresolve1-3.rs
 
-//@ normalize-stderr-test: "\.nll/" -> "/"
-//@ normalize-stderr-test: "\\\?\\" -> ""
-//@ normalize-stderr-test: "(lib)?crateresolve1-([123])\.[a-z]+" -> "libcrateresolve1-$2.somelib"
+//@ normalize-stderr: "\.nll/" -> "/"
+//@ normalize-stderr: "\\\?\\" -> ""
+//@ normalize-stderr: "(lib)?crateresolve1-([123])\.[a-z]+" -> "libcrateresolve1-$2.somelib"
 
 // NOTE: This test is duplicated from `tests/ui/crate-loading/crateresolve1.rs`.
 
diff --git a/tests/ui/errors/remap-path-prefix-sysroot.rs b/tests/ui/errors/remap-path-prefix-sysroot.rs
index 4cbb38709be..7281e6da094 100644
--- a/tests/ui/errors/remap-path-prefix-sysroot.rs
+++ b/tests/ui/errors/remap-path-prefix-sysroot.rs
@@ -8,7 +8,7 @@
 // The $SRC_DIR*.rs:LL:COL normalisation doesn't kick in automatically
 // as the remapped revision will not begin with $SRC_DIR_REAL,
 // so we have to do it ourselves.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:COL"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:COL"
 
 use std::thread;
 struct Worker {
diff --git a/tests/ui/errors/remap-path-prefix.rs b/tests/ui/errors/remap-path-prefix.rs
index 6283a8737ff..8809caa4d4f 100644
--- a/tests/ui/errors/remap-path-prefix.rs
+++ b/tests/ui/errors/remap-path-prefix.rs
@@ -5,7 +5,7 @@
 // no-remap-src-base: Manually remap, so the remapped path remains in .stderr file.
 
 // The remapped paths are not normalized by compiletest.
-//@ normalize-stderr-test: "\\(errors)" -> "/$1"
+//@ normalize-stderr: "\\(errors)" -> "/$1"
 
 // The remapped paths aren't recognized by compiletest, so we
 // cannot use line-specific patterns.
diff --git a/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.rs b/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.rs
index bf060b3d168..33d295f7ebe 100644
--- a/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.rs
+++ b/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.rs
@@ -1,8 +1,8 @@
 // test for ICE when casting extern "C" fn when it has a non-FFI-safe argument
 // issue: rust-lang/rust#52334
 //@ check-pass
-//@ normalize-stderr-test: "\[i8\]" -> "[i8 or u8 (arch dependant)]"
-//@ normalize-stderr-test: "\[u8\]" -> "[i8 or u8 (arch dependant)]"
+//@ normalize-stderr: "\[i8\]" -> "[i8 or u8 (arch dependant)]"
+//@ normalize-stderr: "\[u8\]" -> "[i8 or u8 (arch dependant)]"
 
 type Foo = extern "C" fn(::std::ffi::CStr);
 //~^ WARN `extern` fn uses type
diff --git a/tests/ui/extern/extern-types-field-offset.rs b/tests/ui/extern/extern-types-field-offset.rs
index e9c4bb7b230..75f3eab3e27 100644
--- a/tests/ui/extern/extern-types-field-offset.rs
+++ b/tests/ui/extern/extern-types-field-offset.rs
@@ -1,7 +1,7 @@
 //@ run-fail
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stderr-test: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
+//@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
 #![feature(extern_types)]
 
 extern "C" {
diff --git a/tests/ui/extern/extern-types-size_of_val.rs b/tests/ui/extern/extern-types-size_of_val.rs
index cc4d34e59fa..399a5828ff3 100644
--- a/tests/ui/extern/extern-types-size_of_val.rs
+++ b/tests/ui/extern/extern-types-size_of_val.rs
@@ -1,7 +1,7 @@
 //@ run-fail
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stderr-test: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
+//@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
 //@ revisions: size align
 #![feature(extern_types)]
 
diff --git a/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.rs b/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.rs
index a884c94734a..7b6ba9f7f16 100644
--- a/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.rs
+++ b/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 fn id(
     f: &dyn Fn(u32),
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-1.rs b/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-1.rs
index 799df8cae9f..f880749ec83 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-1.rs
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-1.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 // rust-lang/rust#30786: the use of `for<'b> &'b mut A: Stream<Item=T>`
 // should act as assertion that item does not borrow from its stream;
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-2.rs b/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-2.rs
index 92e2e7f796e..ff4c0cf24d6 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-2.rs
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-doesnt-borrow-self-2.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 // rust-lang/rust#30786: the use of `for<'b> &'b mut A: Stream<Item=T`
 // should act as assertion that item does not borrow from its stream;
diff --git a/tests/ui/hygiene/panic-location.rs b/tests/ui/hygiene/panic-location.rs
index 580a8bcff05..4731d8e1d53 100644
--- a/tests/ui/hygiene/panic-location.rs
+++ b/tests/ui/hygiene/panic-location.rs
@@ -1,7 +1,7 @@
 //@ run-fail
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 //
 // Regression test for issue #70963
 // The reported panic location should not be `<::core::macros::panic macros>`.
diff --git a/tests/ui/hygiene/unpretty-debug.rs b/tests/ui/hygiene/unpretty-debug.rs
index 8e05d60e218..4d3d139deda 100644
--- a/tests/ui/hygiene/unpretty-debug.rs
+++ b/tests/ui/hygiene/unpretty-debug.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: -Zunpretty=expanded,hygiene
 
 // Don't break whenever Symbol numbering changes
-//@ normalize-stdout-test: "\d+#" -> "0#"
+//@ normalize-stdout: "\d+#" -> "0#"
 
 // minimal junk
 #![feature(no_core)]
diff --git a/tests/ui/hygiene/unpretty-debug.stdout b/tests/ui/hygiene/unpretty-debug.stdout
index 1f620cef239..e475cfac2fc 100644
--- a/tests/ui/hygiene/unpretty-debug.stdout
+++ b/tests/ui/hygiene/unpretty-debug.stdout
@@ -2,7 +2,7 @@
 //@ compile-flags: -Zunpretty=expanded,hygiene
 
 // Don't break whenever Symbol numbering changes
-//@ normalize-stdout-test: "\d+#" -> "0#"
+//@ normalize-stdout: "\d+#" -> "0#"
 
 // minimal junk
 #![feature /* 0#0 */(no_core)]
diff --git a/tests/ui/impl-trait/erased-regions-in-hidden-ty.rs b/tests/ui/impl-trait/erased-regions-in-hidden-ty.rs
index 294b27e1dc1..766c37419cd 100644
--- a/tests/ui/impl-trait/erased-regions-in-hidden-ty.rs
+++ b/tests/ui/impl-trait/erased-regions-in-hidden-ty.rs
@@ -2,7 +2,7 @@
 //@ ignore-compare-mode-next-solver (explicit revisions)
 //@ compile-flags: -Zverbose-internals
 //@[next] compile-flags: -Znext-solver
-//@ normalize-stderr-test: "DefId\([^\)]+\)" -> "DefId(..)"
+//@ normalize-stderr: "DefId\([^\)]+\)" -> "DefId(..)"
 
 #![feature(rustc_attrs)]
 #![rustc_hidden_type_of_opaques]
diff --git a/tests/ui/include-macros/parent_dir.rs b/tests/ui/include-macros/parent_dir.rs
index 5fadff77a37..1dcf27324d1 100644
--- a/tests/ui/include-macros/parent_dir.rs
+++ b/tests/ui/include-macros/parent_dir.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "`: .*" -> "`: $$FILE_NOT_FOUND_MSG"
+//@ normalize-stderr: "`: .*" -> "`: $$FILE_NOT_FOUND_MSG"
 
 fn main() {
     let _ = include_str!("include-macros/file.txt");            //~ ERROR couldn't read
diff --git a/tests/ui/infinite/infinite-instantiation.rs b/tests/ui/infinite/infinite-instantiation.rs
index ed6fe693ebf..7e1bff6b124 100644
--- a/tests/ui/infinite/infinite-instantiation.rs
+++ b/tests/ui/infinite/infinite-instantiation.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-//@ normalize-stderr-test: ".nll/" -> "/"
+//@ normalize-stderr: ".nll/" -> "/"
 
 trait ToOpt: Sized {
     fn to_option(&self) -> Option<Self>;
diff --git a/tests/ui/intrinsics/not-overridden.rs b/tests/ui/intrinsics/not-overridden.rs
index 16f8e9bcf6a..b57b4e5bc06 100644
--- a/tests/ui/intrinsics/not-overridden.rs
+++ b/tests/ui/intrinsics/not-overridden.rs
@@ -3,9 +3,9 @@
 #![feature(intrinsics)]
 //@ build-fail
 //@ failure-status:101
-//@ normalize-stderr-test: ".*note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*:\n.*\n" -> ""
-//@ normalize-stderr-test: "internal compiler error:.*: intrinsic const_deallocate " -> ""
+//@ normalize-stderr: ".*note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "internal compiler error:.*: intrinsic const_deallocate " -> ""
 //@ rustc-env:RUST_BACKTRACE=0
 
 #[rustc_intrinsic]
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-option.rs b/tests/ui/invalid/invalid-debugger-visualizer-option.rs
index 16e5619e8e4..0f1cf15a687 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-option.rs
+++ b/tests/ui/invalid/invalid-debugger-visualizer-option.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "foo.random:.*\(" -> "foo.random: $$FILE_NOT_FOUND_MSG ("
-//@ normalize-stderr-test: "os error \d+" -> "os error $$FILE_NOT_FOUND_CODE"
+//@ normalize-stderr: "foo.random:.*\(" -> "foo.random: $$FILE_NOT_FOUND_MSG ("
+//@ normalize-stderr: "os error \d+" -> "os error $$FILE_NOT_FOUND_CODE"
 
 #![debugger_visualizer(random_file = "../foo.random")] //~ ERROR invalid argument
 #![debugger_visualizer(natvis_file = "../foo.random")] //~ ERROR
diff --git a/tests/ui/io-checks/non-ice-error-on-worker-io-fail.rs b/tests/ui/io-checks/non-ice-error-on-worker-io-fail.rs
index a6deb8bab29..7cae77eb67f 100644
--- a/tests/ui/io-checks/non-ice-error-on-worker-io-fail.rs
+++ b/tests/ui/io-checks/non-ice-error-on-worker-io-fail.rs
@@ -19,10 +19,10 @@
 //@ error-pattern: error
 
 // On Mac OS X, we get an error like the below
-//@ normalize-stderr-test: "failed to write bytecode to ./does-not-exist/output.non_ice_error_on_worker_io_fail.*" -> "io error modifying ./does-not-exist/"
+//@ normalize-stderr: "failed to write bytecode to ./does-not-exist/output.non_ice_error_on_worker_io_fail.*" -> "io error modifying ./does-not-exist/"
 
 // On Linux, we get an error like the below
-//@ normalize-stderr-test: "couldn't create a temp dir.*" -> "io error modifying ./does-not-exist/"
+//@ normalize-stderr: "couldn't create a temp dir.*" -> "io error modifying ./does-not-exist/"
 
 //@ ignore-windows - this is a unix-specific test
 //@ ignore-emscripten - the file-system issues do not replicate here
diff --git a/tests/ui/issues/issue-20413.rs b/tests/ui/issues/issue-20413.rs
index 0f602b32fab..7766f375599 100644
--- a/tests/ui/issues/issue-20413.rs
+++ b/tests/ui/issues/issue-20413.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 trait Foo {
     fn answer(self);
 }
diff --git a/tests/ui/issues/issue-21763.rs b/tests/ui/issues/issue-21763.rs
index 1d0a0705cbb..c1ed5d94f9b 100644
--- a/tests/ui/issues/issue-21763.rs
+++ b/tests/ui/issues/issue-21763.rs
@@ -1,6 +1,6 @@
 // Regression test for HashMap only impl'ing Send/Sync if its contents do
 
-//@ normalize-stderr-test: "\S+[\\/]hashbrown\S+" -> "$$HASHBROWN_SRC_LOCATION"
+//@ normalize-stderr: "\S+[\\/]hashbrown\S+" -> "$$HASHBROWN_SRC_LOCATION"
 
 use std::collections::HashMap;
 use std::rc::Rc;
diff --git a/tests/ui/issues/issue-28625.rs b/tests/ui/issues/issue-28625.rs
index 23f96d10bf2..54ed408e748 100644
--- a/tests/ui/issues/issue-28625.rs
+++ b/tests/ui/issues/issue-28625.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+//@ normalize-stderr: "\d+ bits" -> "N bits"
 
 trait Bar {
     type Bar;
diff --git a/tests/ui/issues/issue-32377.rs b/tests/ui/issues/issue-32377.rs
index 3a4942deb83..6737f9820ef 100644
--- a/tests/ui/issues/issue-32377.rs
+++ b/tests/ui/issues/issue-32377.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+//@ normalize-stderr: "\d+ bits" -> "N bits"
 
 use std::mem;
 use std::marker::PhantomData;
diff --git a/tests/ui/issues/issue-37311-type-length-limit/issue-37311.rs b/tests/ui/issues/issue-37311-type-length-limit/issue-37311.rs
index 96e2691164b..edf4f2fce26 100644
--- a/tests/ui/issues/issue-37311-type-length-limit/issue-37311.rs
+++ b/tests/ui/issues/issue-37311-type-length-limit/issue-37311.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-//@ normalize-stderr-test: ".nll/" -> "/"
+//@ normalize-stderr: ".nll/" -> "/"
 
 trait Mirror {
     type Image;
diff --git a/tests/ui/issues/issue-67552.rs b/tests/ui/issues/issue-67552.rs
index 26466bf838c..343ae4f262f 100644
--- a/tests/ui/issues/issue-67552.rs
+++ b/tests/ui/issues/issue-67552.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 //@ compile-flags: -Copt-level=0
-//@ normalize-stderr-test: ".nll/" -> "/"
+//@ normalize-stderr: ".nll/" -> "/"
 
 fn main() {
     rec(Empty);
diff --git a/tests/ui/issues/issue-8727.rs b/tests/ui/issues/issue-8727.rs
index 4ef66000374..b824be7c12f 100644
--- a/tests/ui/issues/issue-8727.rs
+++ b/tests/ui/issues/issue-8727.rs
@@ -2,7 +2,7 @@
 // recursions.
 
 //@ build-fail
-//@ normalize-stderr-test: ".nll/" -> "/"
+//@ normalize-stderr: ".nll/" -> "/"
 
 fn generic<T>() { //~ WARN function cannot return without recursing
     generic::<Option<T>>();
diff --git a/tests/ui/lang-items/duplicate.rs b/tests/ui/lang-items/duplicate.rs
index 3aa7dd2b0be..4594e9456a4 100644
--- a/tests/ui/lang-items/duplicate.rs
+++ b/tests/ui/lang-items/duplicate.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "loaded from .*libcore-.*.rlib" -> "loaded from SYSROOT/libcore-*.rlib"
+//@ normalize-stderr: "loaded from .*libcore-.*.rlib" -> "loaded from SYSROOT/libcore-*.rlib"
 #![feature(lang_items)]
 
 #[lang = "sized"]
diff --git a/tests/ui/layout/debug.rs b/tests/ui/layout/debug.rs
index 166321798de..5602c4e711f 100644
--- a/tests/ui/layout/debug.rs
+++ b/tests/ui/layout/debug.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
 #![feature(never_type, rustc_attrs, type_alias_impl_trait, repr_simd)]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/layout/enum-scalar-pair-int-ptr.rs b/tests/ui/layout/enum-scalar-pair-int-ptr.rs
index ebb3fdb1514..60cada5e05a 100644
--- a/tests/ui/layout/enum-scalar-pair-int-ptr.rs
+++ b/tests/ui/layout/enum-scalar-pair-int-ptr.rs
@@ -1,6 +1,6 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
-//@ normalize-stderr-test: "Int\(I[0-9]+," -> "Int(I?,"
-//@ normalize-stderr-test: "valid_range: 0..=[0-9]+" -> "valid_range: $$VALID_RANGE"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
+//@ normalize-stderr: "Int\(I[0-9]+," -> "Int(I?,"
+//@ normalize-stderr: "valid_range: 0..=[0-9]+" -> "valid_range: $$VALID_RANGE"
 
 //! Enum layout tests related to scalar pairs with an int/ptr common primitive.
 
diff --git a/tests/ui/layout/enum.rs b/tests/ui/layout/enum.rs
index b58d390a2ef..005faf8ee50 100644
--- a/tests/ui/layout/enum.rs
+++ b/tests/ui/layout/enum.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
 //! Various enum layout tests.
 
 #![feature(rustc_attrs)]
diff --git a/tests/ui/layout/ice-type-error-in-tail-124031.rs b/tests/ui/layout/ice-type-error-in-tail-124031.rs
index ecd6f3d56f3..ef5b27cd195 100644
--- a/tests/ui/layout/ice-type-error-in-tail-124031.rs
+++ b/tests/ui/layout/ice-type-error-in-tail-124031.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bits" -> "$$BITS bits"
+//@ normalize-stderr: "\d+ bits" -> "$$BITS bits"
 
 // Regression test for issue #124031
 // Checks that we don't ICE when the tail
diff --git a/tests/ui/layout/issue-96158-scalarpair-payload-might-be-uninit.rs b/tests/ui/layout/issue-96158-scalarpair-payload-might-be-uninit.rs
index 2c8179a63d8..328d204aa3c 100644
--- a/tests/ui/layout/issue-96158-scalarpair-payload-might-be-uninit.rs
+++ b/tests/ui/layout/issue-96158-scalarpair-payload-might-be-uninit.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
 #![crate_type = "lib"]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/layout/issue-96185-overaligned-enum.rs b/tests/ui/layout/issue-96185-overaligned-enum.rs
index 88863d14cb7..341233a7890 100644
--- a/tests/ui/layout/issue-96185-overaligned-enum.rs
+++ b/tests/ui/layout/issue-96185-overaligned-enum.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
 #![crate_type = "lib"]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/layout/struct.rs b/tests/ui/layout/struct.rs
index 309624e667c..5f652b3d570 100644
--- a/tests/ui/layout/struct.rs
+++ b/tests/ui/layout/struct.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
 //! Various struct layout tests.
 
 #![feature(rustc_attrs)]
diff --git a/tests/ui/layout/valid_range_oob.rs b/tests/ui/layout/valid_range_oob.rs
index 38ab5cec7a6..df816e74066 100644
--- a/tests/ui/layout/valid_range_oob.rs
+++ b/tests/ui/layout/valid_range_oob.rs
@@ -1,6 +1,6 @@
 //@ failure-status: 101
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
 //@ rustc-env:RUST_BACKTRACE=0
 
 #![feature(rustc_attrs)]
diff --git a/tests/ui/layout/zero-sized-array-enum-niche.rs b/tests/ui/layout/zero-sized-array-enum-niche.rs
index 433db46b7a0..152f44bd863 100644
--- a/tests/ui/layout/zero-sized-array-enum-niche.rs
+++ b/tests/ui/layout/zero-sized-array-enum-niche.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$PREF_ALIGN"
 #![crate_type = "lib"]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/limits/huge-enum.rs b/tests/ui/limits/huge-enum.rs
index 5664d0ba516..66c5be20693 100644
--- a/tests/ui/limits/huge-enum.rs
+++ b/tests/ui/limits/huge-enum.rs
@@ -1,6 +1,6 @@
 //@ build-fail
-//@ normalize-stderr-test: "std::option::Option<\[u32; \d+\]>" -> "TYPE"
-//@ normalize-stderr-test: "\[u32; \d+\]" -> "TYPE"
+//@ normalize-stderr: "std::option::Option<\[u32; \d+\]>" -> "TYPE"
+//@ normalize-stderr: "\[u32; \d+\]" -> "TYPE"
 
 #[cfg(target_pointer_width = "32")]
 type BIG = Option<[u32; (1<<29)-1]>;
diff --git a/tests/ui/limits/huge-struct.rs b/tests/ui/limits/huge-struct.rs
index bf132d359f5..296147015bf 100644
--- a/tests/ui/limits/huge-struct.rs
+++ b/tests/ui/limits/huge-struct.rs
@@ -1,8 +1,8 @@
 // ignore-tidy-linelength
 //@ build-fail
-//@ normalize-stderr-test: "S32" -> "SXX"
-//@ normalize-stderr-test: "S1M" -> "SXX"
-//@ normalize-stderr-test: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
+//@ normalize-stderr: "S32" -> "SXX"
+//@ normalize-stderr: "S1M" -> "SXX"
+//@ normalize-stderr: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
 
 struct S32<T> {
     v0: T,
diff --git a/tests/ui/limits/issue-17913.rs b/tests/ui/limits/issue-17913.rs
index 24fd3b542e6..5407902daba 100644
--- a/tests/ui/limits/issue-17913.rs
+++ b/tests/ui/limits/issue-17913.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-//@ normalize-stderr-test: "\[&usize; \d+\]" -> "[&usize; usize::MAX]"
+//@ normalize-stderr: "\[&usize; \d+\]" -> "[&usize; usize::MAX]"
 //@ error-pattern: too big for the target architecture
 
 #[cfg(target_pointer_width = "64")]
diff --git a/tests/ui/link-native-libs/msvc-non-utf8-output.rs b/tests/ui/link-native-libs/msvc-non-utf8-output.rs
index 659a832247a..03b1f6516ab 100644
--- a/tests/ui/link-native-libs/msvc-non-utf8-output.rs
+++ b/tests/ui/link-native-libs/msvc-non-utf8-output.rs
@@ -1,5 +1,5 @@
 //@ build-fail
 //@ compile-flags:-C link-arg=⦺ⅈ⽯⭏⽽◃⡽⚞
 //@ only-msvc
-//@ normalize-stderr-test: "(?:.|\n)*(⦺ⅈ⽯⭏⽽◃⡽⚞)(?:.|\n)*" -> "$1"
+//@ normalize-stderr: "(?:.|\n)*(⦺ⅈ⽯⭏⽽◃⡽⚞)(?:.|\n)*" -> "$1"
 pub fn main() {}
diff --git a/tests/ui/lint/lint-overflowing-ops.rs b/tests/ui/lint/lint-overflowing-ops.rs
index eec347010ad..116460f11cc 100644
--- a/tests/ui/lint/lint-overflowing-ops.rs
+++ b/tests/ui/lint/lint-overflowing-ops.rs
@@ -11,8 +11,8 @@
 //@ [opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O -Z deduplicate-diagnostics=yes
 //@ build-fail
 //@ ignore-pass (test tests codegen-time behaviour)
-//@ normalize-stderr-test: "shift left by `(64|32)_usize`, which" -> "shift left by `%BITS%`, which"
-//@ normalize-stderr-test: "shift right by `(64|32)_usize`, which" -> "shift right by `%BITS%`, which"
+//@ normalize-stderr: "shift left by `(64|32)_usize`, which" -> "shift left by `%BITS%`, which"
+//@ normalize-stderr: "shift right by `(64|32)_usize`, which" -> "shift right by `%BITS%`, which"
 
 #![deny(arithmetic_overflow)]
 
diff --git a/tests/ui/lto/lto-duplicate-symbols.rs b/tests/ui/lto/lto-duplicate-symbols.rs
index 679d44baae7..27bdde418f8 100644
--- a/tests/ui/lto/lto-duplicate-symbols.rs
+++ b/tests/ui/lto/lto-duplicate-symbols.rs
@@ -4,7 +4,7 @@
 //@ error-pattern:Linking globals named 'foo': symbol multiply defined!
 //@ compile-flags: -C lto
 //@ no-prefer-dynamic
-//@ normalize-stderr-test: "lto-duplicate-symbols2\.lto_duplicate_symbols2\.[0-9a-zA-Z]+-cgu" -> "lto-duplicate-symbols2.lto_duplicate_symbols2.HASH-cgu"
+//@ normalize-stderr: "lto-duplicate-symbols2\.lto_duplicate_symbols2\.[0-9a-zA-Z]+-cgu" -> "lto-duplicate-symbols2.lto_duplicate_symbols2.HASH-cgu"
 extern crate lto_duplicate_symbols1;
 extern crate lto_duplicate_symbols2;
 
diff --git a/tests/ui/macros/macros-nonfatal-errors.rs b/tests/ui/macros/macros-nonfatal-errors.rs
index 658455b1b5b..79beffbe986 100644
--- a/tests/ui/macros/macros-nonfatal-errors.rs
+++ b/tests/ui/macros/macros-nonfatal-errors.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "`: .*" -> "`: $$FILE_NOT_FOUND_MSG"
+//@ normalize-stderr: "`: .*" -> "`: $$FILE_NOT_FOUND_MSG"
 
 // test that errors in a (selection) of macros don't kill compilation
 // immediately, so that we get more errors listed at a time.
diff --git a/tests/ui/methods/inherent-bound-in-probe.rs b/tests/ui/methods/inherent-bound-in-probe.rs
index 265ef93425a..9b9eb91559b 100644
--- a/tests/ui/methods/inherent-bound-in-probe.rs
+++ b/tests/ui/methods/inherent-bound-in-probe.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 // Fixes #110131
 //
diff --git a/tests/ui/mir/lint/storage-live.rs b/tests/ui/mir/lint/storage-live.rs
index ded02150342..3e0cc4ee061 100644
--- a/tests/ui/mir/lint/storage-live.rs
+++ b/tests/ui/mir/lint/storage-live.rs
@@ -2,10 +2,10 @@
 //@ failure-status: 101
 //@ error-pattern: broken MIR in
 //@ error-pattern: StorageLive(_1) which already has storage here
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*\n" -> ""
-//@ normalize-stderr-test: "storage_live\[....\]" -> "storage_live[HASH]"
-//@ normalize-stderr-test: "(delayed at [^:]+):\d+:\d+ - " -> "$1:LL:CC - "
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "storage_live\[....\]" -> "storage_live[HASH]"
+//@ normalize-stderr: "(delayed at [^:]+):\d+:\d+ - " -> "$1:LL:CC - "
 //@ rustc-env:RUST_BACKTRACE=0
 
 #![feature(custom_mir, core_intrinsics)]
diff --git a/tests/ui/modules/path-no-file-name.rs b/tests/ui/modules/path-no-file-name.rs
index c36043686fc..23127346e02 100644
--- a/tests/ui/modules/path-no-file-name.rs
+++ b/tests/ui/modules/path-no-file-name.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "\.:.*\(" -> ".: $$ACCESS_DENIED_MSG ("
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ACCESS_DENIED_CODE"
+//@ normalize-stderr: "\.:.*\(" -> ".: $$ACCESS_DENIED_MSG ("
+//@ normalize-stderr: "os error \d+" -> "os error $$ACCESS_DENIED_CODE"
 
 #[path = "."]
 mod m; //~ ERROR couldn't read
diff --git a/tests/ui/packed/packed-struct-transmute.rs b/tests/ui/packed/packed-struct-transmute.rs
index 0a887e3886d..98feeea8871 100644
--- a/tests/ui/packed/packed-struct-transmute.rs
+++ b/tests/ui/packed/packed-struct-transmute.rs
@@ -3,7 +3,7 @@
 // the error points to the start of the file, not the line with the
 // transmute
 
-//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+//@ normalize-stderr: "\d+ bits" -> "N bits"
 //@ error-pattern: cannot transmute between types of different sizes, or dependently-sized types
 
 use std::mem;
diff --git a/tests/ui/panic-handler/panic-handler-std.rs b/tests/ui/panic-handler/panic-handler-std.rs
index 82e6de43a2e..4eb05b5365f 100644
--- a/tests/ui/panic-handler/panic-handler-std.rs
+++ b/tests/ui/panic-handler/panic-handler-std.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "loaded from .*libstd-.*.rlib" -> "loaded from SYSROOT/libstd-*.rlib"
+//@ normalize-stderr: "loaded from .*libstd-.*.rlib" -> "loaded from SYSROOT/libstd-*.rlib"
 //@ error-pattern: found duplicate lang item `panic_impl`
 
 extern crate core;
diff --git a/tests/ui/panics/default-backtrace-ice.rs b/tests/ui/panics/default-backtrace-ice.rs
index 7953283f028..c47f458f6e9 100644
--- a/tests/ui/panics/default-backtrace-ice.rs
+++ b/tests/ui/panics/default-backtrace-ice.rs
@@ -5,12 +5,12 @@
 //@ error-pattern:__rust_begin_short_backtrace
 //@ failure-status:101
 //@ ignore-msvc
-//@ normalize-stderr-test: "note: .*" -> ""
-//@ normalize-stderr-test: "thread 'rustc' .*" -> ""
-//@ normalize-stderr-test: " +\d+:.*__rust_begin_short_backtrace.*" -> "(begin_short_backtrace)"
-//@ normalize-stderr-test: " +\d+:.*__rust_end_short_backtrace.*" -> "(end_short_backtrace)"
-//@ normalize-stderr-test: " +\d+:.*\n" -> ""
-//@ normalize-stderr-test: " +at .*\n" -> ""
+//@ normalize-stderr: "note: .*" -> ""
+//@ normalize-stderr: "thread 'rustc' .*" -> ""
+//@ normalize-stderr: " +\d+:.*__rust_begin_short_backtrace.*" -> "(begin_short_backtrace)"
+//@ normalize-stderr: " +\d+:.*__rust_end_short_backtrace.*" -> "(end_short_backtrace)"
+//@ normalize-stderr: " +\d+:.*\n" -> ""
+//@ normalize-stderr: " +at .*\n" -> ""
 //
 // This test makes sure that full backtraces are used for ICEs when
 // RUST_BACKTRACE is not set. It does this by checking for the presence of
diff --git a/tests/ui/panics/issue-47429-short-backtraces.rs b/tests/ui/panics/issue-47429-short-backtraces.rs
index 56b9cfcd361..dff885af1b8 100644
--- a/tests/ui/panics/issue-47429-short-backtraces.rs
+++ b/tests/ui/panics/issue-47429-short-backtraces.rs
@@ -8,11 +8,11 @@
 
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
-//@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+//@ normalize-stderr: "begin_panic::<&str>" -> "begin_panic"
 // This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
-//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
+//@ normalize-stderr: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
 
 //@ ignore-msvc see #62897 and `backtrace-debuginfo.rs` test
 //@ ignore-android FIXME #17520
diff --git a/tests/ui/panics/panic-in-cleanup.rs b/tests/ui/panics/panic-in-cleanup.rs
index c3639c7034e..8cddeb37348 100644
--- a/tests/ui/panics/panic-in-cleanup.rs
+++ b/tests/ui/panics/panic-in-cleanup.rs
@@ -2,9 +2,9 @@
 //@ exec-env:RUST_BACKTRACE=0
 //@ check-run-results
 //@ error-pattern: panic in a destructor during cleanup
-//@ normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
-//@ normalize-stderr-test: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
+//@ normalize-stderr: "\n +[0-9]+:[^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
 //@ needs-unwind
 //@ ignore-emscripten "RuntimeError" junk in output
 //@ ignore-msvc SEH doesn't do panic-during-cleanup the same way as everyone else
diff --git a/tests/ui/panics/panic-in-ffi.rs b/tests/ui/panics/panic-in-ffi.rs
index c0ae1899f4c..6068e4fdc59 100644
--- a/tests/ui/panics/panic-in-ffi.rs
+++ b/tests/ui/panics/panic-in-ffi.rs
@@ -3,9 +3,9 @@
 //@ check-run-results
 //@ error-pattern: panic in a function that cannot unwind
 //@ error-pattern: Noisy Drop
-//@ normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
-//@ normalize-stderr-test: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
+//@ normalize-stderr: "\n +[0-9]+:[^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
 //@ needs-unwind
 //@ ignore-emscripten "RuntimeError" junk in output
 
diff --git a/tests/ui/panics/panic-in-message-fmt.rs b/tests/ui/panics/panic-in-message-fmt.rs
index e5bedf96b35..1e9bbaf45c5 100644
--- a/tests/ui/panics/panic-in-message-fmt.rs
+++ b/tests/ui/panics/panic-in-message-fmt.rs
@@ -4,9 +4,9 @@
 //@ exec-env:RUST_BACKTRACE=0
 //@ check-run-results
 //@ error-pattern: panicked while processing panic
-//@ normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
-//@ normalize-stderr-test: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
+//@ normalize-stderr: "\n +[0-9]+:[^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
 //@ ignore-emscripten "RuntimeError" junk in output
 
 use std::fmt::{Display, self};
diff --git a/tests/ui/panics/panic-short-backtrace-windows-x86_64.rs b/tests/ui/panics/panic-short-backtrace-windows-x86_64.rs
index 70c4a5aaf2b..a56214b73bf 100644
--- a/tests/ui/panics/panic-short-backtrace-windows-x86_64.rs
+++ b/tests/ui/panics/panic-short-backtrace-windows-x86_64.rs
@@ -17,7 +17,7 @@
 // We need to normalize out frame 5 because without debug info, dbghelp.dll doesn't know where CGU
 // internal functions like `main` start or end and so it will return whatever symbol happens
 // to be located near the address.
-//@ normalize-stderr-test: "5: .*" -> "5: some Rust fn"
+//@ normalize-stderr: "5: .*" -> "5: some Rust fn"
 
 // Backtraces are pretty broken in general on i686-pc-windows-msvc (#62897).
 //@ only-x86_64-pc-windows-msvc
diff --git a/tests/ui/panics/runtime-switch.rs b/tests/ui/panics/runtime-switch.rs
index e06f05d5fe8..ffd038f9535 100644
--- a/tests/ui/panics/runtime-switch.rs
+++ b/tests/ui/panics/runtime-switch.rs
@@ -8,11 +8,11 @@
 
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
-//@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+//@ normalize-stderr: "begin_panic::<&str>" -> "begin_panic"
 // This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
-//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
+//@ normalize-stderr: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
 
 //@ ignore-msvc see #62897 and `backtrace-debuginfo.rs` test
 //@ ignore-android FIXME #17520
diff --git a/tests/ui/panics/short-ice-remove-middle-frames-2.rs b/tests/ui/panics/short-ice-remove-middle-frames-2.rs
index 9b6d34d97b2..48f60b14170 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames-2.rs
+++ b/tests/ui/panics/short-ice-remove-middle-frames-2.rs
@@ -11,11 +11,11 @@
 //@ ignore-msvc the `__rust_{begin,end}_short_backtrace` symbols aren't reliable.
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
-//@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+//@ normalize-stderr: "begin_panic::<&str>" -> "begin_panic"
 // This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
-//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
+//@ normalize-stderr: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
 
 /// This test case make sure that we can have multiple pairs of `__rust_{begin,end}_short_backtrace`
 
diff --git a/tests/ui/panics/short-ice-remove-middle-frames.rs b/tests/ui/panics/short-ice-remove-middle-frames.rs
index b1af247130b..216c5127799 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames.rs
+++ b/tests/ui/panics/short-ice-remove-middle-frames.rs
@@ -12,11 +12,11 @@
 
 // This is needed to avoid test output differences across std being built with v0 symbols vs legacy
 // symbols.
-//@ normalize-stderr-test: "begin_panic::<&str>" -> "begin_panic"
+//@ normalize-stderr: "begin_panic::<&str>" -> "begin_panic"
 // This variant occurs on macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
-//@ normalize-stderr-test: " begin_panic<&str>" -> " std::panicking::begin_panic"
+//@ normalize-stderr: " begin_panic<&str>" -> " std::panicking::begin_panic"
 // And this is for differences between std with and without debuginfo.
-//@ normalize-stderr-test: "\n +at [^\n]+" -> ""
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
 
 #[inline(never)]
 fn __rust_begin_short_backtrace<T, F: FnOnce() -> T>(f: F) -> T {
diff --git a/tests/ui/parser/issues/issue-5806.rs b/tests/ui/parser/issues/issue-5806.rs
index 3f1b7cda931..dbd53a7adc4 100644
--- a/tests/ui/parser/issues/issue-5806.rs
+++ b/tests/ui/parser/issues/issue-5806.rs
@@ -1,5 +1,5 @@
-//@ normalize-stderr-test: "parser:.*\(" -> "parser: $$ACCESS_DENIED_MSG ("
-//@ normalize-stderr-test: "os error \d+" -> "os error $$ACCESS_DENIED_CODE"
+//@ normalize-stderr: "parser:.*\(" -> "parser: $$ACCESS_DENIED_MSG ("
+//@ normalize-stderr: "os error \d+" -> "os error $$ACCESS_DENIED_CODE"
 
 #[path = "../parser"]
 mod foo; //~ ERROR couldn't read
diff --git a/tests/ui/parser/mod_file_with_path_attr.rs b/tests/ui/parser/mod_file_with_path_attr.rs
index e2854f3cc8d..ff964f750e2 100644
--- a/tests/ui/parser/mod_file_with_path_attr.rs
+++ b/tests/ui/parser/mod_file_with_path_attr.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "not_a_real_file.rs:.*\(" -> "not_a_real_file.rs: $$FILE_NOT_FOUND_MSG ("
+//@ normalize-stderr: "not_a_real_file.rs:.*\(" -> "not_a_real_file.rs: $$FILE_NOT_FOUND_MSG ("
 
 #[path = "not_a_real_file.rs"]
 mod m; //~ ERROR not_a_real_file.rs
diff --git a/tests/ui/print-request/macos-target.rs b/tests/ui/print-request/macos-target.rs
index af74babbed4..70122a52580 100644
--- a/tests/ui/print-request/macos-target.rs
+++ b/tests/ui/print-request/macos-target.rs
@@ -1,8 +1,8 @@
 //@ only-apple
 //@ compile-flags: --print deployment-target
-//@ normalize-stdout-test: "\w*_DEPLOYMENT_TARGET" -> "$$OS_DEPLOYMENT_TARGET"
-//@ normalize-stdout-test: "\d+\." -> "$$CURRENT_MAJOR_VERSION."
-//@ normalize-stdout-test: "\d+" -> "$$CURRENT_MINOR_VERSION"
+//@ normalize-stdout: "\w*_DEPLOYMENT_TARGET" -> "$$OS_DEPLOYMENT_TARGET"
+//@ normalize-stdout: "\d+\." -> "$$CURRENT_MAJOR_VERSION."
+//@ normalize-stdout: "\d+" -> "$$CURRENT_MINOR_VERSION"
 //@ check-pass
 
 fn main() {}
diff --git a/tests/ui/proc-macro/load-panic-backtrace.rs b/tests/ui/proc-macro/load-panic-backtrace.rs
index 302bcaea75e..848bdaf9f37 100644
--- a/tests/ui/proc-macro/load-panic-backtrace.rs
+++ b/tests/ui/proc-macro/load-panic-backtrace.rs
@@ -1,8 +1,8 @@
 //@ proc-macro: test-macros.rs
 //@ compile-flags: -Z proc-macro-backtrace
 //@ rustc-env:RUST_BACKTRACE=0
-//@ normalize-stderr-test: "thread '.*' panicked " -> ""
-//@ normalize-stderr-test: "note:.*RUST_BACKTRACE=1.*\n" -> ""
+//@ normalize-stderr: "thread '.*' panicked " -> ""
+//@ normalize-stderr: "note:.*RUST_BACKTRACE=1.*\n" -> ""
 //@ needs-unwind proc macro panics to report errors
 
 #[macro_use]
diff --git a/tests/ui/proc-macro/meta-macro-hygiene.rs b/tests/ui/proc-macro/meta-macro-hygiene.rs
index 9fbe9763b44..afe0e1fb601 100644
--- a/tests/ui/proc-macro/meta-macro-hygiene.rs
+++ b/tests/ui/proc-macro/meta-macro-hygiene.rs
@@ -4,9 +4,9 @@
 //@ compile-flags: -Z span-debug -Z macro-backtrace -Z unpretty=expanded,hygiene -Z trim-diagnostic-paths=no
 //@ check-pass
 // ignore-tidy-linelength
-//@ normalize-stdout-test: "\d+#" -> "0#"
-//@ normalize-stdout-test: "expn\d{3,}" -> "expnNNN"
-//@ normalize-stdout-test: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
+//@ normalize-stdout: "\d+#" -> "0#"
+//@ normalize-stdout: "expn\d{3,}" -> "expnNNN"
+//@ normalize-stdout: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
 //
 // We don't care about symbol ids, so we set them all to 0
 // in the stdout
diff --git a/tests/ui/proc-macro/meta-macro-hygiene.stdout b/tests/ui/proc-macro/meta-macro-hygiene.stdout
index ae02b24e1d0..fae8446515a 100644
--- a/tests/ui/proc-macro/meta-macro-hygiene.stdout
+++ b/tests/ui/proc-macro/meta-macro-hygiene.stdout
@@ -8,9 +8,9 @@ Respanned: TokenStream [Ident { ident: "$crate", span: $DIR/auxiliary/make-macro
 //@ compile-flags: -Z span-debug -Z macro-backtrace -Z unpretty=expanded,hygiene -Z trim-diagnostic-paths=no
 //@ check-pass
 // ignore-tidy-linelength
-//@ normalize-stdout-test: "\d+#" -> "0#"
-//@ normalize-stdout-test: "expn\d{3,}" -> "expnNNN"
-//@ normalize-stdout-test: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
+//@ normalize-stdout: "\d+#" -> "0#"
+//@ normalize-stdout: "expn\d{3,}" -> "expnNNN"
+//@ normalize-stdout: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
 //
 // We don't care about symbol ids, so we set them all to 0
 // in the stdout
diff --git a/tests/ui/proc-macro/nonterminal-token-hygiene.rs b/tests/ui/proc-macro/nonterminal-token-hygiene.rs
index 76c71441c80..e2aedb245d0 100644
--- a/tests/ui/proc-macro/nonterminal-token-hygiene.rs
+++ b/tests/ui/proc-macro/nonterminal-token-hygiene.rs
@@ -4,9 +4,9 @@
 //@ compile-flags: -Z span-debug -Z macro-backtrace -Z unpretty=expanded,hygiene
 //@ compile-flags: -Z trim-diagnostic-paths=no
 // ignore-tidy-linelength
-//@ normalize-stdout-test: "\d+#" -> "0#"
-//@ normalize-stdout-test: "expn\d{3,}" -> "expnNNN"
-//@ normalize-stdout-test: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
+//@ normalize-stdout: "\d+#" -> "0#"
+//@ normalize-stdout: "expn\d{3,}" -> "expnNNN"
+//@ normalize-stdout: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
 //@ proc-macro: test-macros.rs
 
 #![feature(decl_macro)]
diff --git a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
index 1ad14059028..e7dda7d3c16 100644
--- a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
+++ b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
@@ -28,9 +28,9 @@ PRINT-BANG INPUT (DEBUG): TokenStream [
 //@ compile-flags: -Z span-debug -Z macro-backtrace -Z unpretty=expanded,hygiene
 //@ compile-flags: -Z trim-diagnostic-paths=no
 // ignore-tidy-linelength
-//@ normalize-stdout-test: "\d+#" -> "0#"
-//@ normalize-stdout-test: "expn\d{3,}" -> "expnNNN"
-//@ normalize-stdout-test: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
+//@ normalize-stdout: "\d+#" -> "0#"
+//@ normalize-stdout: "expn\d{3,}" -> "expnNNN"
+//@ normalize-stdout: "extern crate compiler_builtins /\* \d+ \*/" -> "extern crate compiler_builtins /* NNN */"
 //@ proc-macro: test-macros.rs
 
 #![feature /* 0#0 */(decl_macro)]
diff --git a/tests/ui/process/println-with-broken-pipe.rs b/tests/ui/process/println-with-broken-pipe.rs
index 4ac1f7c98cb..d88c6dcc12b 100644
--- a/tests/ui/process/println-with-broken-pipe.rs
+++ b/tests/ui/process/println-with-broken-pipe.rs
@@ -5,7 +5,7 @@
 //@ ignore-fuchsia
 //@ ignore-horizon
 //@ ignore-android
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 //@ compile-flags: -Zon-broken-pipe=error
 
 // Test what the error message looks like when `println!()` panics because of
diff --git a/tests/ui/recursion/issue-23122-2.rs b/tests/ui/recursion/issue-23122-2.rs
index 2880b956417..3e14fa92dd0 100644
--- a/tests/ui/recursion/issue-23122-2.rs
+++ b/tests/ui/recursion/issue-23122-2.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 trait Next {
     type Next: Next;
 }
diff --git a/tests/ui/recursion/issue-83150.rs b/tests/ui/recursion/issue-83150.rs
index e919a2d9309..ea1bef4fce3 100644
--- a/tests/ui/recursion/issue-83150.rs
+++ b/tests/ui/recursion/issue-83150.rs
@@ -1,7 +1,7 @@
 //~ ERROR overflow evaluating the requirement `Map<&mut std::ops::Range<u8>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>: Iterator`
 //@ build-fail
 //@ compile-flags: -Copt-level=0
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 fn main() {
     let mut iter = 0u8..1;
diff --git a/tests/ui/recursion/recursion.rs b/tests/ui/recursion/recursion.rs
index 074e9ed6947..f3c633983b1 100644
--- a/tests/ui/recursion/recursion.rs
+++ b/tests/ui/recursion/recursion.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 //@ compile-flags:-C overflow-checks=off
-//@ normalize-stderr-test: ".nll/" -> "/"
+//@ normalize-stderr: ".nll/" -> "/"
 
 enum Nil {NilValue}
 struct Cons<T> {head:isize, tail:T}
diff --git a/tests/ui/regions/issue-102374.rs b/tests/ui/regions/issue-102374.rs
index db2b38334b5..d640c29b2f4 100644
--- a/tests/ui/regions/issue-102374.rs
+++ b/tests/ui/regions/issue-102374.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 use std::cell::Cell;
 
 #[rustfmt::skip]
diff --git a/tests/ui/repr/repr-c-dead-variants.rs b/tests/ui/repr/repr-c-dead-variants.rs
index cc080b2e59a..3e8ae3d096d 100644
--- a/tests/ui/repr/repr-c-dead-variants.rs
+++ b/tests/ui/repr/repr-c-dead-variants.rs
@@ -6,7 +6,7 @@
 
 // See also: repr-c-int-dead-variants.rs
 
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
 
 // This test depends on the value of the `c_enum_min_bits` target option.
 // As there's no way to actually check it from UI test, we only run this test on a subset of archs.
diff --git a/tests/ui/repr/repr-c-int-dead-variants.rs b/tests/ui/repr/repr-c-int-dead-variants.rs
index ed26174343a..627569e080d 100644
--- a/tests/ui/repr/repr-c-int-dead-variants.rs
+++ b/tests/ui/repr/repr-c-int-dead-variants.rs
@@ -3,7 +3,7 @@
 
 // See also: repr-c-dead-variants.rs
 
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
 
 // A simple uninhabited type.
 enum Void {}
diff --git a/tests/ui/resolve/multiple_definitions_attribute_merging.rs b/tests/ui/resolve/multiple_definitions_attribute_merging.rs
index 7d649476ad2..155abafdd9d 100644
--- a/tests/ui/resolve/multiple_definitions_attribute_merging.rs
+++ b/tests/ui/resolve/multiple_definitions_attribute_merging.rs
@@ -4,9 +4,9 @@
 
 //@known-bug: #120873
 //@ failure-status: 101
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*\n" -> ""
-//@ normalize-stderr-test: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
 //@ rustc-env:RUST_BACKTRACE=0
 
 #[repr(packed)]
diff --git a/tests/ui/resolve/proc_macro_generated_packed.rs b/tests/ui/resolve/proc_macro_generated_packed.rs
index 8459fb79f1e..0cba3c1616d 100644
--- a/tests/ui/resolve/proc_macro_generated_packed.rs
+++ b/tests/ui/resolve/proc_macro_generated_packed.rs
@@ -4,9 +4,9 @@
 //@proc-macro: proc_macro_generate_packed.rs
 //@known-bug: #120873
 //@ failure-status: 101
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*\n" -> ""
-//@ normalize-stderr-test: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
 //@ rustc-env:RUST_BACKTRACE=0
 
 extern crate proc_macro_generate_packed;
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.rs b/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.rs
index ea9d48e7859..e69a4537935 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.rs
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.rs
@@ -2,12 +2,12 @@
 
 //@ needs-dlltool
 //@ compile-flags: --crate-type lib --emit link
-//@ normalize-stderr-test: "[^ ']*/dlltool.exe" -> "$$DLLTOOL"
-//@ normalize-stderr-test: "[^ ]*/foo.dll_imports.def" -> "$$DEF_FILE"
-//@ normalize-stderr-test: "[^ ]*/foo.dll_imports.lib" -> "$$LIB_FILE"
-//@ normalize-stderr-test: "-m [^ ]*" -> "$$TARGET_MACHINE"
-//@ normalize-stderr-test: "-f [^ ]*" -> "$$ASM_FLAGS"
-//@ normalize-stderr-test: "--temp-prefix [^ ]*/foo.dll" -> "$$TEMP_PREFIX"
+//@ normalize-stderr: "[^ ']*/dlltool.exe" -> "$$DLLTOOL"
+//@ normalize-stderr: "[^ ]*/foo.dll_imports.def" -> "$$DEF_FILE"
+//@ normalize-stderr: "[^ ]*/foo.dll_imports.lib" -> "$$LIB_FILE"
+//@ normalize-stderr: "-m [^ ]*" -> "$$TARGET_MACHINE"
+//@ normalize-stderr: "-f [^ ]*" -> "$$ASM_FLAGS"
+//@ normalize-stderr: "--temp-prefix [^ ]*/foo.dll" -> "$$TEMP_PREFIX"
 #[link(name = "foo", kind = "raw-dylib")]
 extern "C" {
     // `@1` is an invalid name to export, as it usually indicates that something
diff --git a/tests/ui/statics/mutable_memory_validation.rs b/tests/ui/statics/mutable_memory_validation.rs
index 032b903f64e..3bb572d38bc 100644
--- a/tests/ui/statics/mutable_memory_validation.rs
+++ b/tests/ui/statics/mutable_memory_validation.rs
@@ -1,8 +1,8 @@
 //issue: rust-lang/rust#122548
 
 // Strip out raw byte dumps to make comparison platform-independent:
-//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
-//@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 use std::cell::UnsafeCell;
 
diff --git a/tests/ui/svh/changing-crates.rs b/tests/ui/svh/changing-crates.rs
index 78075a5c75f..39a6473c8d9 100644
--- a/tests/ui/svh/changing-crates.rs
+++ b/tests/ui/svh/changing-crates.rs
@@ -2,7 +2,7 @@
 //@ aux-build:changing-crates-a1.rs
 //@ aux-build:changing-crates-b.rs
 //@ aux-build:changing-crates-a2.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-change-lit.rs b/tests/ui/svh/svh-change-lit.rs
index 6ecdd9f2c08..66f739e144e 100644
--- a/tests/ui/svh/svh-change-lit.rs
+++ b/tests/ui/svh/svh-change-lit.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-change-lit.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-change-significant-cfg.rs b/tests/ui/svh/svh-change-significant-cfg.rs
index c03560ee511..9e736788d13 100644
--- a/tests/ui/svh/svh-change-significant-cfg.rs
+++ b/tests/ui/svh/svh-change-significant-cfg.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-change-significant-cfg.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-change-trait-bound.rs b/tests/ui/svh/svh-change-trait-bound.rs
index 4bbbf45a886..1e0fa15b94a 100644
--- a/tests/ui/svh/svh-change-trait-bound.rs
+++ b/tests/ui/svh/svh-change-trait-bound.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-change-trait-bound.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-change-type-arg.rs b/tests/ui/svh/svh-change-type-arg.rs
index cdc5cf24272..f275a38acc4 100644
--- a/tests/ui/svh/svh-change-type-arg.rs
+++ b/tests/ui/svh/svh-change-type-arg.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-change-type-arg.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-change-type-ret.rs b/tests/ui/svh/svh-change-type-ret.rs
index f2a579fab63..76118dc9f69 100644
--- a/tests/ui/svh/svh-change-type-ret.rs
+++ b/tests/ui/svh/svh-change-type-ret.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-change-type-ret.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-change-type-static.rs b/tests/ui/svh/svh-change-type-static.rs
index 489923ddecf..6a658ca36dc 100644
--- a/tests/ui/svh/svh-change-type-static.rs
+++ b/tests/ui/svh/svh-change-type-static.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-change-type-static.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 extern crate a;
 extern crate b; //~ ERROR: found possibly newer version of crate `a` which `b` depends on
diff --git a/tests/ui/svh/svh-use-trait.rs b/tests/ui/svh/svh-use-trait.rs
index 8ac4cc42605..4791bfb5006 100644
--- a/tests/ui/svh/svh-use-trait.rs
+++ b/tests/ui/svh/svh-use-trait.rs
@@ -2,7 +2,7 @@
 //@ aux-build:svh-uta-base.rs
 //@ aux-build:svh-utb.rs
 //@ aux-build:svh-uta-change-use-trait.rs
-//@ normalize-stderr-test: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
+//@ normalize-stderr: "(crate `(\w+)`:) .*" -> "$1 $$PATH_$2"
 
 //! "svh-uta-trait.rs" is checking that we detect a
 //! change from `use foo::TraitB` to use `foo::TraitB` in the hash
diff --git a/tests/ui/symbol-names/const-generics-demangling.rs b/tests/ui/symbol-names/const-generics-demangling.rs
index 86f24f6af6a..9c078d4192a 100644
--- a/tests/ui/symbol-names/const-generics-demangling.rs
+++ b/tests/ui/symbol-names/const-generics-demangling.rs
@@ -3,8 +3,8 @@
 //@ compile-flags: --crate-name=c
 //@[legacy]compile-flags: -C symbol-mangling-version=legacy -Z unstable-options
 //@    [v0]compile-flags: -C symbol-mangling-version=v0
-//@[legacy]normalize-stderr-test: "h[[:xdigit:]]{16}" -> "h[HASH]"
-//@    [v0]normalize-stderr-test: "c\[.*?\]" -> "c[HASH]"
+//@[legacy]normalize-stderr: "h[[:xdigit:]]{16}" -> "h[HASH]"
+//@    [v0]normalize-stderr: "c\[.*?\]" -> "c[HASH]"
 #![feature(rustc_attrs)]
 
 pub struct Unsigned<const F: u8>;
diff --git a/tests/ui/symbol-names/const-generics-str-demangling.rs b/tests/ui/symbol-names/const-generics-str-demangling.rs
index 87b1fdf8a47..94c3b4c4448 100644
--- a/tests/ui/symbol-names/const-generics-str-demangling.rs
+++ b/tests/ui/symbol-names/const-generics-str-demangling.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 //@ compile-flags: -C symbol-mangling-version=v0 --crate-name=c
-//@ normalize-stderr-test: "c\[.*?\]" -> "c[HASH]"
+//@ normalize-stderr: "c\[.*?\]" -> "c[HASH]"
 #![feature(adt_const_params, unsized_const_params, rustc_attrs)]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/symbol-names/const-generics-structural-demangling.rs b/tests/ui/symbol-names/const-generics-structural-demangling.rs
index 9f5f31177b3..06e3ce51fa6 100644
--- a/tests/ui/symbol-names/const-generics-structural-demangling.rs
+++ b/tests/ui/symbol-names/const-generics-structural-demangling.rs
@@ -1,7 +1,7 @@
 //@ build-fail
 //@ compile-flags: -C symbol-mangling-version=v0 --crate-name=c
 
-//@ normalize-stderr-test: "c\[[0-9a-f]+\]" -> "c[HASH]"
+//@ normalize-stderr: "c\[[0-9a-f]+\]" -> "c[HASH]"
 
 #![feature(adt_const_params, unsized_const_params, decl_macro, rustc_attrs)]
 #![allow(incomplete_features)]
diff --git a/tests/ui/symbol-names/impl1.rs b/tests/ui/symbol-names/impl1.rs
index 9aefca47447..694cd89bd80 100644
--- a/tests/ui/symbol-names/impl1.rs
+++ b/tests/ui/symbol-names/impl1.rs
@@ -2,7 +2,7 @@
 //@ revisions: legacy v0
 //@[legacy]compile-flags: -Z unstable-options -C symbol-mangling-version=legacy
 //@[v0]compile-flags: -C symbol-mangling-version=v0
-//@[legacy]normalize-stderr-test: "h[\w]{16}E?\)" -> "<SYMBOL_HASH>)"
+//@[legacy]normalize-stderr: "h[\w]{16}E?\)" -> "<SYMBOL_HASH>)"
 
 #![feature(auto_traits, rustc_attrs)]
 #![allow(dead_code)]
diff --git a/tests/ui/symbol-names/issue-75326.rs b/tests/ui/symbol-names/issue-75326.rs
index a6aef3ddd7d..c60b872b0a2 100644
--- a/tests/ui/symbol-names/issue-75326.rs
+++ b/tests/ui/symbol-names/issue-75326.rs
@@ -2,7 +2,7 @@
 //@ revisions: legacy v0
 //@[legacy]compile-flags: -Z unstable-options -C symbol-mangling-version=legacy
 //@[v0]compile-flags: -C symbol-mangling-version=v0
-//@[legacy]normalize-stderr-test: "h[\w{16}]+" -> "SYMBOL_HASH"
+//@[legacy]normalize-stderr: "h[\w{16}]+" -> "SYMBOL_HASH"
 
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/symbol-names/trait-objects.rs b/tests/ui/symbol-names/trait-objects.rs
index d3fa40d1f39..da48190285d 100644
--- a/tests/ui/symbol-names/trait-objects.rs
+++ b/tests/ui/symbol-names/trait-objects.rs
@@ -3,7 +3,7 @@
 //@ build-fail
 //@ revisions: v0
 //@[v0]compile-flags: -C symbol-mangling-version=v0
-//@[v0]normalize-stderr-test: "core\[.*?\]" -> "core[HASH]"
+//@[v0]normalize-stderr: "core\[.*?\]" -> "core[HASH]"
 
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/symbol-names/types.rs b/tests/ui/symbol-names/types.rs
index 38735e1aa50..a4bbbaa02f2 100644
--- a/tests/ui/symbol-names/types.rs
+++ b/tests/ui/symbol-names/types.rs
@@ -4,8 +4,8 @@
 //@ [legacy] compile-flags: -Csymbol-mangling-version=legacy
 //@ [verbose-legacy] compile-flags: -Csymbol-mangling-version=legacy -Zverbose-internals
 //@ [v0] compile-flags: -Csymbol-mangling-version=v0
-//@ normalize-stderr-test: "h[[:xdigit:]]{16}" -> "h[HASH]"
-//@ [v0] normalize-stderr-test: "\[[[:xdigit:]]{16}\]" -> "[HASH]"
+//@ normalize-stderr: "h[[:xdigit:]]{16}" -> "h[HASH]"
+//@ [v0] normalize-stderr: "\[[[:xdigit:]]{16}\]" -> "[HASH]"
 
 #![feature(never_type)]
 #![feature(rustc_attrs)]
diff --git a/tests/ui/test-attrs/terse.rs b/tests/ui/test-attrs/terse.rs
index 74e18915857..6c3f29ed10f 100644
--- a/tests/ui/test-attrs/terse.rs
+++ b/tests/ui/test-attrs/terse.rs
@@ -3,7 +3,7 @@
 //@ run-flags: --test-threads=1 --quiet
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ ignore-emscripten no threads support
 //@ needs-unwind
 
diff --git a/tests/ui/test-attrs/test-filter-multiple.rs b/tests/ui/test-attrs/test-filter-multiple.rs
index c875929e672..49211c61e18 100644
--- a/tests/ui/test-attrs/test-filter-multiple.rs
+++ b/tests/ui/test-attrs/test-filter-multiple.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: --test
 //@ run-flags: --test-threads=1 test1 test2
 //@ check-run-results
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ needs-threads
 
 #[test]
diff --git a/tests/ui/test-attrs/test-panic-abort-nocapture.rs b/tests/ui/test-attrs/test-panic-abort-nocapture.rs
index f3485d9c1fa..4377ae1ac3b 100644
--- a/tests/ui/test-attrs/test-panic-abort-nocapture.rs
+++ b/tests/ui/test-attrs/test-panic-abort-nocapture.rs
@@ -4,7 +4,7 @@
 //@ run-fail
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 //@ ignore-android #120567
 //@ ignore-wasm no panic or subprocess support
diff --git a/tests/ui/test-attrs/test-panic-abort.rs b/tests/ui/test-attrs/test-panic-abort.rs
index 84740161a70..3d203e059a4 100644
--- a/tests/ui/test-attrs/test-panic-abort.rs
+++ b/tests/ui/test-attrs/test-panic-abort.rs
@@ -4,7 +4,7 @@
 //@ run-fail
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 //@ ignore-android #120567
 //@ ignore-wasm no panic or subprocess support
diff --git a/tests/ui/test-attrs/test-passed.rs b/tests/ui/test-attrs/test-passed.rs
index 2a3fca7f002..959470adcc4 100644
--- a/tests/ui/test-attrs/test-passed.rs
+++ b/tests/ui/test-attrs/test-passed.rs
@@ -3,7 +3,7 @@
 //@ run-flags: --test-threads=1
 //@ run-pass
 //@ check-run-results
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 // Tests the output of the test harness with only passed tests.
 
diff --git a/tests/ui/test-attrs/test-thread-capture.rs b/tests/ui/test-attrs/test-thread-capture.rs
index 75ff4e0ece6..c56f87f2dda 100644
--- a/tests/ui/test-attrs/test-thread-capture.rs
+++ b/tests/ui/test-attrs/test-thread-capture.rs
@@ -3,7 +3,7 @@
 //@ run-flags: --test-threads=1
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ ignore-emscripten no threads support
 //@ needs-unwind
 
diff --git a/tests/ui/test-attrs/test-thread-nocapture.rs b/tests/ui/test-attrs/test-thread-nocapture.rs
index 6a36ea8d7d1..5b82e9b2720 100644
--- a/tests/ui/test-attrs/test-thread-nocapture.rs
+++ b/tests/ui/test-attrs/test-thread-nocapture.rs
@@ -3,7 +3,7 @@
 //@ run-flags: --test-threads=1 --nocapture
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ ignore-emscripten no threads support
 //@ needs-unwind
 
diff --git a/tests/ui/test-attrs/test-type.rs b/tests/ui/test-attrs/test-type.rs
index 1b71ead55b0..51a6b9245cc 100644
--- a/tests/ui/test-attrs/test-type.rs
+++ b/tests/ui/test-attrs/test-type.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: --test -Zpanic-abort-tests
 //@ run-flags: --test-threads=1
 //@ check-run-results
-//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ needs-threads
 //@ run-pass
 
diff --git a/tests/ui/test-attrs/tests-listing-format-json.rs b/tests/ui/test-attrs/tests-listing-format-json.rs
index b735a82c166..9d57a6bc383 100644
--- a/tests/ui/test-attrs/tests-listing-format-json.rs
+++ b/tests/ui/test-attrs/tests-listing-format-json.rs
@@ -4,8 +4,8 @@
 //@ run-pass
 //@ check-run-results
 //@ only-nightly
-//@ normalize-stdout-test: "fake-test-src-base/test-attrs/" -> "$$DIR/"
-//@ normalize-stdout-test: "fake-test-src-base\\test-attrs\\" -> "$$DIR/"
+//@ normalize-stdout: "fake-test-src-base/test-attrs/" -> "$$DIR/"
+//@ normalize-stdout: "fake-test-src-base\\test-attrs\\" -> "$$DIR/"
 
 // Checks the listing of tests with --format json.
 
diff --git a/tests/ui/track-diagnostics/track.rs b/tests/ui/track-diagnostics/track.rs
index 5023f34e4c1..9e81cb53fc1 100644
--- a/tests/ui/track-diagnostics/track.rs
+++ b/tests/ui/track-diagnostics/track.rs
@@ -5,13 +5,13 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
-//@ normalize-stderr-test: "note: rustc .+ running on .+" -> "note: rustc $$VERSION running on $$TARGET"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: "note: rustc .+ running on .+" -> "note: rustc $$VERSION running on $$TARGET"
 
 // The test becomes too flaky if we care about exact args. If `-Z ui-testing`
 // from compiletest and `-Z track-diagnostics` from `// compile-flags` at the
 // top of this file are present, then assume all args are present.
-//@ normalize-stderr-test: "note: compiler flags: .*-Z ui-testing.*-Z track-diagnostics" -> "note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics"
+//@ normalize-stderr: "note: compiler flags: .*-Z ui-testing.*-Z track-diagnostics" -> "note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics"
 
 fn main() {
     break rust
diff --git a/tests/ui/track-diagnostics/track2.rs b/tests/ui/track-diagnostics/track2.rs
index 7466e9246ce..5805fd21220 100644
--- a/tests/ui/track-diagnostics/track2.rs
+++ b/tests/ui/track-diagnostics/track2.rs
@@ -3,7 +3,7 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 fn main() {
     let _moved @ _from = String::from("foo");
diff --git a/tests/ui/track-diagnostics/track3.rs b/tests/ui/track-diagnostics/track3.rs
index 43ad1dff8b8..bac1fc7e184 100644
--- a/tests/ui/track-diagnostics/track3.rs
+++ b/tests/ui/track-diagnostics/track3.rs
@@ -3,7 +3,7 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 fn main() {
     let _unimported = Blah { field: u8 };
diff --git a/tests/ui/track-diagnostics/track4.rs b/tests/ui/track-diagnostics/track4.rs
index bc76f6f1451..ec9e3efa481 100644
--- a/tests/ui/track-diagnostics/track4.rs
+++ b/tests/ui/track-diagnostics/track4.rs
@@ -3,7 +3,7 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 pub onion {
     Owo(u8),
diff --git a/tests/ui/track-diagnostics/track5.rs b/tests/ui/track-diagnostics/track5.rs
index bb82e9a62c8..e72e3482ad3 100644
--- a/tests/ui/track-diagnostics/track5.rs
+++ b/tests/ui/track-diagnostics/track5.rs
@@ -3,6 +3,6 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 }
diff --git a/tests/ui/track-diagnostics/track6.rs b/tests/ui/track-diagnostics/track6.rs
index fc8df68e6d9..e4d124a22e4 100644
--- a/tests/ui/track-diagnostics/track6.rs
+++ b/tests/ui/track-diagnostics/track6.rs
@@ -3,7 +3,7 @@
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-//@ normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 
 pub trait Foo {
diff --git a/tests/ui/traits/on_unimplemented_long_types.rs b/tests/ui/traits/on_unimplemented_long_types.rs
index 60c3327902e..98749b8db7a 100644
--- a/tests/ui/traits/on_unimplemented_long_types.rs
+++ b/tests/ui/traits/on_unimplemented_long_types.rs
@@ -1,5 +1,5 @@
 //@ compile-flags: --diagnostic-width=60 -Z write-long-types-to-disk=yes
-//@ normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
+//@ normalize-stderr: "long-type-\d+" -> "long-type-hash"
 
 pub fn foo() -> impl std::fmt::Display {
     //~^ ERROR doesn't implement `std::fmt::Display`
diff --git a/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs b/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs
index ef0a5a7adca..d0418e75fab 100644
--- a/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs
+++ b/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs
@@ -2,10 +2,10 @@
 //@[next] compile-flags: -Znext-solver
 //@[next] failure-status: 101
 //@[next] known-bug: unknown
-//@[next] normalize-stderr-test: "note: .*\n\n" -> ""
-//@[next] normalize-stderr-test: "thread 'rustc' panicked.*\n.*\n" -> ""
-//@[next] normalize-stderr-test: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
-//@[next] normalize-stderr-test: "delayed at .*" -> ""
+//@[next] normalize-stderr: "note: .*\n\n" -> ""
+//@[next] normalize-stderr: "thread 'rustc' panicked.*\n.*\n" -> ""
+//@[next] normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
+//@[next] normalize-stderr: "delayed at .*" -> ""
 //@[next] rustc-env:RUST_BACKTRACE=0
 //@ check-pass
 
diff --git a/tests/ui/transmute/transmute-different-sizes.rs b/tests/ui/transmute/transmute-different-sizes.rs
index b7fca2b3278..40197a6c53f 100644
--- a/tests/ui/transmute/transmute-different-sizes.rs
+++ b/tests/ui/transmute/transmute-different-sizes.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+//@ normalize-stderr: "\d+ bits" -> "N bits"
 
 // Tests that `transmute` cannot be called on types of different size.
 
diff --git a/tests/ui/transmute/transmute-fat-pointers.rs b/tests/ui/transmute/transmute-fat-pointers.rs
index d1340c5e860..f095b80dc2d 100644
--- a/tests/ui/transmute/transmute-fat-pointers.rs
+++ b/tests/ui/transmute/transmute-fat-pointers.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+//@ normalize-stderr: "\d+ bits" -> "N bits"
 
 // Tests that are conservative around thin/fat pointer mismatches.
 
diff --git a/tests/ui/transmute/transmute-impl.rs b/tests/ui/transmute/transmute-impl.rs
index 15d67483cc8..84951a0ee60 100644
--- a/tests/ui/transmute/transmute-impl.rs
+++ b/tests/ui/transmute/transmute-impl.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "\d+ bits" -> "N bits"
+//@ normalize-stderr: "\d+ bits" -> "N bits"
 
 // Tests that are conservative around thin/fat pointer mismatches.
 
diff --git a/tests/ui/treat-err-as-bug/err.rs b/tests/ui/treat-err-as-bug/err.rs
index 82683cdffef..9f0e293b4cb 100644
--- a/tests/ui/treat-err-as-bug/err.rs
+++ b/tests/ui/treat-err-as-bug/err.rs
@@ -2,8 +2,8 @@
 //@ failure-status: 101
 //@ error-pattern: aborting due to `-Z treat-err-as-bug=1`
 //@ error-pattern: [eval_static_initializer] evaluating initializer of static `C`
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*:\n.*\n" -> ""
 //@ rustc-env:RUST_BACKTRACE=0
 
 #![crate_type = "rlib"]
diff --git a/tests/ui/treat-err-as-bug/span_delayed_bug.rs b/tests/ui/treat-err-as-bug/span_delayed_bug.rs
index 97b8e4a3dda..296bdd7a12d 100644
--- a/tests/ui/treat-err-as-bug/span_delayed_bug.rs
+++ b/tests/ui/treat-err-as-bug/span_delayed_bug.rs
@@ -2,8 +2,8 @@
 //@ failure-status: 101
 //@ error-pattern: aborting due to `-Z treat-err-as-bug=1`
 //@ error-pattern: [trigger_delayed_bug] triggering a delayed bug for testing incremental
-//@ normalize-stderr-test: "note: .*\n\n" -> ""
-//@ normalize-stderr-test: "thread 'rustc' panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "note: .*\n\n" -> ""
+//@ normalize-stderr: "thread 'rustc' panicked.*:\n.*\n" -> ""
 //@ rustc-env:RUST_BACKTRACE=0
 
 #![feature(rustc_attrs)]
diff --git a/tests/ui/type/pattern_types/range_patterns.rs b/tests/ui/type/pattern_types/range_patterns.rs
index 7c25edb1c3f..ff87444b49e 100644
--- a/tests/ui/type/pattern_types/range_patterns.rs
+++ b/tests/ui/type/pattern_types/range_patterns.rs
@@ -2,7 +2,7 @@
 #![feature(pattern_type_macro)]
 #![allow(incomplete_features)]
 
-//@ normalize-stderr-test: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
+//@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
 
 use std::pat::pattern_type;
 
diff --git a/tests/ui/unknown-llvm-arg.rs b/tests/ui/unknown-llvm-arg.rs
index 17908d36417..a8fa55a220a 100644
--- a/tests/ui/unknown-llvm-arg.rs
+++ b/tests/ui/unknown-llvm-arg.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Cllvm-args=-not-a-real-llvm-arg
-//@ normalize-stderr-test: "--help" -> "-help"
-//@ normalize-stderr-test: "\n(\n|.)*" -> ""
+//@ normalize-stderr: "--help" -> "-help"
+//@ normalize-stderr: "\n(\n|.)*" -> ""
 
 // I'm seeing "--help" locally, but "-help" in CI, so I'm normalizing it to just "-help".
 
diff --git a/tests/ui/unpretty/avoid-crash.rs b/tests/ui/unpretty/avoid-crash.rs
index e2bde823622..7fcabfe6a8d 100644
--- a/tests/ui/unpretty/avoid-crash.rs
+++ b/tests/ui/unpretty/avoid-crash.rs
@@ -1,4 +1,4 @@
-//@ normalize-stderr-test: "error `.*`" -> "$$ERROR_MESSAGE"
+//@ normalize-stderr: "error `.*`" -> "$$ERROR_MESSAGE"
 //@ compile-flags: -o. -Zunpretty=ast-tree
 
 fn main() {}
diff --git a/tests/ui/unpretty/staged-api-invalid-path-108697.rs b/tests/ui/unpretty/staged-api-invalid-path-108697.rs
index 1b6ef249191..71bad213576 100644
--- a/tests/ui/unpretty/staged-api-invalid-path-108697.rs
+++ b/tests/ui/unpretty/staged-api-invalid-path-108697.rs
@@ -2,7 +2,7 @@
 // ICE: tcx.resolutions(()) is not supported for local crate -Zunpretty=mir
 // on invalid module path with staged_api
 //@ compile-flags: -Zunpretty=mir
-//@ normalize-stderr-test: "The system cannot find the file specified." -> "No such file or directory"
+//@ normalize-stderr: "The system cannot find the file specified." -> "No such file or directory"
 #![feature(staged_api)]
 #[path = "lol"]
 mod foo;
-- 
cgit 1.4.1-3-g733a5


From 454c09e355e0122fceaa770a3903c0ec9547bc0a Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Thu, 26 Dec 2024 14:09:27 +0100
Subject: Spruce up the docs of several queries related to the type/trait
 system and const eval

---
 .../rustc_const_eval/src/const_eval/fn_queries.rs  |  14 +-
 compiler/rustc_middle/src/query/mod.rs             | 311 ++++++++++++++-------
 .../bugs/cycle-iat-inside-of-adt.stderr            |   4 +-
 3 files changed, 223 insertions(+), 106 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
index babf99c4c1f..8af17d01b0a 100644
--- a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
@@ -15,20 +15,14 @@ fn parent_impl_constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness
     }
 }
 
-/// Checks whether an item is considered to be `const`. If it is a constructor, it is const.
-/// If it is an assoc method or function,
-/// return if it has a `const` modifier. If it is an intrinsic, report whether said intrinsic
-/// has a `rustc_const_{un,}stable` attribute. Otherwise, panic.
+/// Checks whether a function-like definition is considered to be `const`.
 fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {
     let node = tcx.hir_node_by_def_id(def_id);
 
     match node {
-        hir::Node::Ctor(hir::VariantData::Tuple(..))
-        | hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Const(..), .. }) => {
-            hir::Constness::Const
-        }
-        hir::Node::ForeignItem(_) => {
-            // Foreign items cannot be evaluated at compile-time.
+        hir::Node::Ctor(hir::VariantData::Tuple(..)) => hir::Constness::Const,
+        hir::Node::ForeignItem(item) if let hir::ForeignItemKind::Fn(..) = item.kind => {
+            // Foreign functions cannot be evaluated at compile-time.
             hir::Constness::NotConst
         }
         hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 2c2dffe8b88..7e7b602c560 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -132,6 +132,7 @@ rustc_queries! {
     }
 
     /// Return the span for a definition.
+    ///
     /// Contrary to `def_span` below, this query returns the full absolute span of the definition.
     /// This span is meant for dep-tracking rather than diagnostics. It should not be used outside
     /// of rustc_middle::hir::source_map.
@@ -142,6 +143,7 @@ rustc_queries! {
     }
 
     /// Represents crate as a whole (as distinct from the top-level crate module).
+    ///
     /// If you call `hir_crate` (e.g., indirectly by calling `tcx.hir().krate()`),
     /// we will have to assume that any change means that you need to be recompiled.
     /// This is because the `hir_crate` query gives you access to all other items.
@@ -202,28 +204,40 @@ rustc_queries! {
         feedable
     }
 
-    /// Given the def_id of a const-generic parameter, computes the associated default const
-    /// parameter. e.g. `fn example<const N: usize=3>` called on `N` would return `3`.
+    /// Returns the *default* of the const pararameter given by `DefId`.
+    ///
+    /// E.g., given `struct Ty<const N: usize = 3>;` this returns `3` for `N`.
     query const_param_default(param: DefId) -> ty::EarlyBinder<'tcx, ty::Const<'tcx>> {
-        desc { |tcx| "computing const default for a given parameter `{}`", tcx.def_path_str(param)  }
+        desc { |tcx| "computing the default for const parameter `{}`", tcx.def_path_str(param)  }
         cache_on_disk_if { param.is_local() }
         separate_provide_extern
     }
 
-    /// Returns the [`Ty`][rustc_middle::ty::Ty] of the given [`DefId`]. If the [`DefId`] points
-    /// to an alias, it will "skip" this alias to return the aliased type.
+    /// Returns the *type* of the definition given by `DefId`.
+    ///
+    /// For type aliases (whether eager or lazy) and associated types, this returns
+    /// the underlying aliased type (not the corresponding [alias type]).
+    ///
+    /// For opaque types, this returns and thus reveals the hidden type! If you
+    /// want to detect cycle errors use `type_of_opaque` instead.
+    ///
+    /// To clarify, for type definitions, this does *not* return the "type of a type"
+    /// (aka *kind* or *sort*) in the type-theoretical sense! It merely returns
+    /// the type primarily *associated with* it.
     ///
-    /// [`DefId`]: rustc_hir::def_id::DefId
+    /// # Panics
+    ///
+    /// This query will panic if the given definition doesn't (and can't
+    /// conceptually) have an (underlying) type.
+    ///
+    /// [alias type]: rustc_middle::ty::AliasTy
     query type_of(key: DefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
         desc { |tcx|
             "{action} `{path}`",
-            action = {
-                use rustc_hir::def::DefKind;
-                match tcx.def_kind(key) {
-                    DefKind::TyAlias => "expanding type alias",
-                    DefKind::TraitAlias => "expanding trait alias",
-                    _ => "computing type of",
-                }
+            action = match tcx.def_kind(key) {
+                DefKind::TyAlias => "expanding type alias",
+                DefKind::TraitAlias => "expanding trait alias",
+                _ => "computing type of",
             },
             path = tcx.def_path_str(key),
         }
@@ -232,9 +246,14 @@ rustc_queries! {
         feedable
     }
 
-    /// Specialized instance of `type_of` that detects cycles that are due to
-    /// revealing opaque because of an auto trait bound. Unless `CyclePlaceholder` needs
-    /// to be handled separately, call `type_of` instead.
+    /// Returns the *hidden type* of the opaque type given by `DefId` unless a cycle occurred.
+    ///
+    /// This is a specialized instance of [`Self::type_of`] that detects query cycles.
+    /// Unless `CyclePlaceholder` needs to be handled separately, call [`Self::type_of`] instead.
+    ///
+    /// # Panics
+    ///
+    /// This query will panic if the given definition is not an opaque type.
     query type_of_opaque(key: DefId) -> Result<ty::EarlyBinder<'tcx, Ty<'tcx>>, CyclePlaceholder> {
         desc { |tcx|
             "computing type of opaque `{path}`",
@@ -243,9 +262,22 @@ rustc_queries! {
         cycle_stash
     }
 
+    /// Returns whether the type alias given by `DefId` is lazy.
+    ///
+    /// I.e., if the type alias expands / ought to expand to a [weak] [alias type]
+    /// instead of the underyling aliased type.
+    ///
+    /// Relevant for features `lazy_type_alias` and `type_alias_impl_trait`.
+    ///
+    /// # Panics
+    ///
+    /// This query *may* panic if the given definition is not a type alias.
+    ///
+    /// [weak]: rustc_middle::ty::Weak
+    /// [alias type]: rustc_middle::ty::AliasTy
     query type_alias_is_lazy(key: DefId) -> bool {
         desc { |tcx|
-            "computing whether `{path}` is a lazy type alias",
+            "computing whether the type alias `{path}` is lazy",
             path = tcx.def_path_str(key),
         }
         separate_provide_extern
@@ -299,8 +331,7 @@ rustc_queries! {
         desc { "checking lint expectations (RFC 2383)" }
     }
 
-    /// Maps from the `DefId` of an item (trait/struct/enum/fn) to its
-    /// associated generics.
+    /// Returns the *generics* of the definition given by `DefId`.
     query generics_of(key: DefId) -> &'tcx ty::Generics {
         desc { |tcx| "computing generics of `{}`", tcx.def_path_str(key) }
         arena_cache
@@ -309,10 +340,13 @@ rustc_queries! {
         feedable
     }
 
-    /// Maps from the `DefId` of an item (trait/struct/enum/fn) to the
-    /// predicates (where-clauses) that must be proven true in order
-    /// to reference it. This is almost always the "predicates query"
-    /// that you want.
+    /// Returns the (elaborated) *predicates* of the definition given by `DefId`
+    /// that must be proven true at usage sites (and which can be assumed at definition site).
+    ///
+    /// This is almost always *the* "predicates query" that you want.
+    ///
+    /// **Tip**: You can use `#[rustc_dump_predicates]` on an item to basically print
+    /// the result of this query for use in UI tests or for debugging purposes.
     query predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
         desc { |tcx| "computing predicates of `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
@@ -328,25 +362,24 @@ rustc_queries! {
         }
     }
 
-    /// Returns the list of bounds that are required to be satisfied
-    /// by a implementation or definition. For associated types, these
-    /// must be satisfied for an implementation to be well-formed,
-    /// and for opaque types, these are required to be satisfied by
-    /// the hidden-type of the opaque.
+    /// Returns the explicitly user-written *bounds* on the associated or opaque type given by `DefId`
+    /// that must be proven true at definition site (and which can be assumed at usage sites).
     ///
-    /// Syntactially, these are the bounds written on the trait's type
-    /// definition, or those after the `impl` keyword for an opaque:
+    /// For associated types, these must be satisfied for an implementation
+    /// to be well-formed, and for opaque types, these are required to be
+    /// satisfied by the hidden type of the opaque.
     ///
-    /// ```ignore (incomplete)
-    /// type X: Bound + 'lt
-    /// //      ^^^^^^^^^^^
-    /// impl Debug + Display
-    /// //   ^^^^^^^^^^^^^^^
-    /// ```
+    /// Bounds from the parent (e.g. with nested `impl Trait`) are not included.
     ///
-    /// `key` is the `DefId` of the associated type or opaque type.
+    /// Syntactially, these are the bounds written on associated types in trait
+    /// definitions, or those after the `impl` keyword for an opaque:
     ///
-    /// Bounds from the parent (e.g. with nested impl trait) are not included.
+    /// ```ignore (illustrative)
+    /// trait Trait { type X: Bound + 'lt; }
+    /// //                    ^^^^^^^^^^^
+    /// fn function() -> impl Debug + Display { /*...*/ }
+    /// //                    ^^^^^^^^^^^^^^^
+    /// ```
     query explicit_item_bounds(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
         desc { |tcx| "finding item bounds for `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
@@ -354,10 +387,12 @@ rustc_queries! {
         feedable
     }
 
-    /// The set of item bounds (see [`TyCtxt::explicit_item_bounds`]) that
-    /// share the `Self` type of the item. These are a subset of the bounds
-    /// that may explicitly be used for things like closure signature
-    /// deduction.
+    /// Returns the explicitly user-written *bounds* that share the `Self` type of the item.
+    ///
+    /// These are a subset of the [explicit item bounds] that may explicitly be used for things
+    /// like closure signature deduction.
+    ///
+    /// [explicit item bounds]: Self::explicit_item_bounds
     query explicit_item_super_predicates(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
         desc { |tcx| "finding item bounds for `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
@@ -365,26 +400,29 @@ rustc_queries! {
         feedable
     }
 
-    /// Elaborated version of the predicates from `explicit_item_bounds`.
+    /// Returns the (elaborated) *bounds* on the associated or opaque type given by `DefId`
+    /// that must be proven true at definition site (and which can be assumed at usage sites).
     ///
-    /// For example:
+    /// Bounds from the parent (e.g. with nested `impl Trait`) are not included.
+    ///
+    /// **Tip**: You can use `#[rustc_dump_item_bounds]` on an item to basically print
+    /// the result of this query for use in UI tests or for debugging purposes.
+    ///
+    /// # Examples
     ///
     /// ```
-    /// trait MyTrait {
-    ///     type MyAType: Eq + ?Sized;
-    /// }
+    /// trait Trait { type Assoc: Eq + ?Sized; }
     /// ```
     ///
-    /// `explicit_item_bounds` returns `[<Self as MyTrait>::MyAType: Eq]`,
-    /// and `item_bounds` returns
+    /// While [`Self::explicit_item_bounds`] returns `[<Self as Trait>::Assoc: Eq]`
+    /// here, `item_bounds` returns:
+    ///
     /// ```text
     /// [
-    ///     <Self as Trait>::MyAType: Eq,
-    ///     <Self as Trait>::MyAType: PartialEq<<Self as Trait>::MyAType>
+    ///     <Self as Trait>::Assoc: Eq,
+    ///     <Self as Trait>::Assoc: PartialEq<<Self as Trait>::Assoc>
     /// ]
     /// ```
-    ///
-    /// Bounds from the parent (e.g. with nested impl trait) are not included.
     query item_bounds(key: DefId) -> ty::EarlyBinder<'tcx, ty::Clauses<'tcx>> {
         desc { |tcx| "elaborating item bounds for `{}`", tcx.def_path_str(key) }
     }
@@ -615,27 +653,35 @@ rustc_queries! {
         desc { "getting wasm import module map" }
     }
 
-    /// Returns everything that looks like a predicate written explicitly
-    /// by the user on a trait item.
+    /// Returns the explicitly user-written *predicates and bounds* of the trait given by `DefId`.
     ///
     /// Traits are unusual, because predicates on associated types are
     /// converted into bounds on that type for backwards compatibility:
     ///
+    /// ```
     /// trait X where Self::U: Copy { type U; }
+    /// ```
     ///
     /// becomes
     ///
+    /// ```
     /// trait X { type U: Copy; }
+    /// ```
     ///
-    /// `explicit_predicates_of` and `explicit_item_bounds` will then take
-    /// the appropriate subsets of the predicates here.
+    /// [`Self::explicit_predicates_of`] and [`Self::explicit_item_bounds`] will
+    /// then take the appropriate subsets of the predicates here.
+    ///
+    /// # Panics
+    ///
+    /// This query will panic if the given definition is not a trait.
     query trait_explicit_predicates_and_bounds(key: LocalDefId) -> ty::GenericPredicates<'tcx> {
         desc { |tcx| "computing explicit predicates of trait `{}`", tcx.def_path_str(key) }
     }
 
-    /// Returns the predicates written explicitly by the user.
+    /// Returns the explicitly user-written *predicates* of the definition given by `DefId`
+    /// that must be proven true at usage sites (and which can be assumed at definition site).
     ///
-    /// You should probably use `predicates_of` unless you're looking for
+    /// You should probably use [`Self::predicates_of`] unless you're looking for
     /// predicates with explicit spans for diagnostics purposes.
     query explicit_predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
         desc { |tcx| "computing explicit predicates of `{}`", tcx.def_path_str(key) }
@@ -644,18 +690,24 @@ rustc_queries! {
         feedable
     }
 
-    /// Returns the inferred outlives predicates (e.g., for `struct
-    /// Foo<'a, T> { x: &'a T }`, this would return `T: 'a`).
+    /// Returns the *inferred outlives-predicates* of the item given by `DefId`.
+    ///
+    /// E.g., for `struct Foo<'a, T> { x: &'a T }`, this would return `[T: 'a]`.
+    ///
+    /// **Tip**: You can use `#[rustc_outlives]` on an item to basically print the
+    /// result of this query for use in UI tests or for debugging purposes.
     query inferred_outlives_of(key: DefId) -> &'tcx [(ty::Clause<'tcx>, Span)] {
-        desc { |tcx| "computing inferred outlives predicates of `{}`", tcx.def_path_str(key) }
+        desc { |tcx| "computing inferred outlives-predicates of `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
         separate_provide_extern
         feedable
     }
 
-    /// Maps from the `DefId` of a trait to the list of super-predicates of the trait,
-    /// *before* elaboration (so it doesn't contain transitive super-predicates). This
-    /// is a subset of the full list of predicates. We store these in a separate map
+    /// Returns the explicitly user-written *super-predicates* of the trait given by `DefId`.
+    ///
+    /// These predicates are unelaborated and consequently don't contain transitive super-predicates.
+    ///
+    /// This is a subset of the full list of predicates. We store these in a separate map
     /// because we must evaluate them even during type conversion, often before the full
     /// predicates are available (note that super-predicates must not be cyclic).
     query explicit_super_predicates_of(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
@@ -664,8 +716,9 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    /// The predicates of the trait that are implied during elaboration. This is a
-    /// superset of the super-predicates of the trait, but a subset of the predicates
+    /// The predicates of the trait that are implied during elaboration.
+    ///
+    /// This is a superset of the super-predicates of the trait, but a subset of the predicates
     /// of the trait. For regular traits, this includes all super-predicates and their
     /// associated type bounds. For trait aliases, currently, this includes all of the
     /// predicates of the trait alias.
@@ -745,14 +798,27 @@ rustc_queries! {
         desc { |tcx| "computing drop-check constraints for `{}`", tcx.def_path_str(key) }
     }
 
-    /// Returns the constness of function-like things (tuple struct/variant constructors, functions,
-    /// methods)
+    /// Returns the constness of the function-like[^1] definition given by `DefId`.
+    ///
+    /// Tuple struct/variant constructors are *always* const, foreign functions are
+    /// *never* const. The rest is const iff marked with keyword `const` (or rather
+    /// its parent in the case of associated functions).
     ///
-    /// Will ICE if used on things that are always const or never const.
+    /// <div class="warning">
     ///
-    /// **Do not call this function manually.** It is only meant to cache the base data for the
+    /// **Do not call this query** directly. It is only meant to cache the base data for the
     /// higher-level functions. Consider using `is_const_fn` or `is_const_trait_impl` instead.
-    /// Also note that neither of them takes into account feature gates and stability.
+    ///
+    /// Also note that neither of them takes into account feature gates, stability and
+    /// const predicates/conditions!
+    ///
+    /// </div>
+    ///
+    /// # Panics
+    ///
+    /// This query will panic if the given definition is not function-like[^1].
+    ///
+    /// [^1]: Tuple struct/variant constructors, closures and free, associated and foreign functions.
     query constness(key: DefId) -> hir::Constness {
         desc { |tcx| "checking if item is const: `{}`", tcx.def_path_str(key) }
         separate_provide_extern
@@ -798,13 +864,25 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    /// Gets a map with the variance of every item; use `variances_of` instead.
+    /// Gets a map with the variances of every item in the local crate.
+    ///
+    /// <div class="warning">
+    ///
+    /// **Do not call this query** directly, use [`Self::variances_of`] instead.
+    ///
+    /// </div>
     query crate_variances(_: ()) -> &'tcx ty::CrateVariancesMap<'tcx> {
         arena_cache
         desc { "computing the variances for items in this crate" }
     }
 
-    /// Maps from the `DefId` of a type or region parameter to its (inferred) variance.
+    /// Returns the (inferred) variances of the item given by `DefId`.
+    ///
+    /// The list of variances corresponds to the list of (early-bound) generic
+    /// parameters of the item (including its parents).
+    ///
+    /// **Tip**: You can use `#[rustc_variance]` on an item to basically print the
+    /// result of this query for use in UI tests or for debugging purposes.
     query variances_of(def_id: DefId) -> &'tcx [ty::Variance] {
         desc { |tcx| "computing the variances of `{}`", tcx.def_path_str(def_id) }
         cache_on_disk_if { def_id.is_local() }
@@ -812,10 +890,16 @@ rustc_queries! {
         cycle_delay_bug
     }
 
-    /// Maps from thee `DefId` of a type to its (inferred) outlives.
+    /// Gets a map with the inferred outlives-predicates of every item in the local crate.
+    ///
+    /// <div class="warning">
+    ///
+    /// **Do not call this query** directly, use [`Self::inferred_outlives_of`] instead.
+    ///
+    /// </div>
     query inferred_outlives_crate(_: ()) -> &'tcx ty::CratePredicatesMap<'tcx> {
         arena_cache
-        desc { "computing the inferred outlives predicates for items in this crate" }
+        desc { "computing the inferred outlives-predicates for items in this crate" }
     }
 
     /// Maps from an impl/trait or struct/variant `DefId`
@@ -1038,20 +1122,35 @@ rustc_queries! {
     }
 
     /// Gets a complete map from all types to their inherent impls.
-    /// Not meant to be used directly outside of coherence.
+    ///
+    /// <div class="warning">
+    ///
+    /// **Not meant to be used** directly outside of coherence.
+    ///
+    /// </div>
     query crate_inherent_impls(k: ()) -> (&'tcx CrateInherentImpls, Result<(), ErrorGuaranteed>) {
         desc { "finding all inherent impls defined in crate" }
     }
 
     /// Checks all types in the crate for overlap in their inherent impls. Reports errors.
-    /// Not meant to be used directly outside of coherence.
+    ///
+    /// <div class="warning">
+    ///
+    /// **Not meant to be used** directly outside of coherence.
+    ///
+    /// </div>
     query crate_inherent_impls_validity_check(_: ()) -> Result<(), ErrorGuaranteed> {
         desc { "check for inherent impls that should not be defined in crate" }
         ensure_forwards_result_if_red
     }
 
     /// Checks all types in the crate for overlap in their inherent impls. Reports errors.
-    /// Not meant to be used directly outside of coherence.
+    ///
+    /// <div class="warning">
+    ///
+    /// **Not meant to be used** directly outside of coherence.
+    ///
+    /// </div>
     query crate_inherent_impls_overlap_check(_: ()) -> Result<(), ErrorGuaranteed> {
         desc { "check for overlap between inherent impls defined in this crate" }
         ensure_forwards_result_if_red
@@ -1089,8 +1188,12 @@ rustc_queries! {
     }
 
     /// Computes the tag (if any) for a given type and variant.
+    ///
     /// `None` means that the variant doesn't need a tag (because it is niched).
-    /// Will panic for uninhabited variants.
+    ///
+    /// # Panics
+    ///
+    /// This query will panic for uninhabited variants and if the passed type is not an enum.
     query tag_for_variant(
         key: (Ty<'tcx>, abi::VariantIdx)
     ) -> Option<ty::ScalarInt> {
@@ -1099,7 +1202,12 @@ rustc_queries! {
 
     /// Evaluates a constant and returns the computed allocation.
     ///
-    /// **Do not use this** directly, use the `eval_to_const_value` or `eval_to_valtree` instead.
+    /// <div class="warning">
+    ///
+    /// **Do not call this query** directly, use [`Self::eval_to_const_value_raw`] or
+    /// [`Self::eval_to_valtree`] instead.
+    ///
+    /// </div>
     query eval_to_allocation_raw(key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>)
         -> EvalToAllocationRawResult<'tcx> {
         desc { |tcx|
@@ -1120,12 +1228,18 @@ rustc_queries! {
         feedable
     }
 
-    /// Evaluates const items or anonymous constants
-    /// (such as enum variant explicit discriminants or array lengths)
-    /// into a representation suitable for the type system and const generics.
+    /// Evaluates const items or anonymous constants[^1] into a representation
+    /// suitable for the type system and const generics.
+    ///
+    /// <div class="warning">
+    ///
+    /// **Do not call this** directly, use one of the following wrappers:
+    /// [`TyCtxt::const_eval_poly`], [`TyCtxt::const_eval_resolve`],
+    /// [`TyCtxt::const_eval_instance`], or [`TyCtxt::const_eval_global_id`].
+    ///
+    /// </div>
     ///
-    /// **Do not use this** directly, use one of the following wrappers: `tcx.const_eval_poly`,
-    /// `tcx.const_eval_resolve`, `tcx.const_eval_instance`, or `tcx.const_eval_global_id`.
+    /// [^1]: Such as enum variant explicit discriminants or array lengths.
     query eval_to_const_value_raw(key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>)
         -> EvalToConstValueResult<'tcx> {
         desc { |tcx|
@@ -1252,13 +1366,13 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    /// Determines whether an item is annotated with `doc(hidden)`.
+    /// Determines whether an item is annotated with `#[doc(hidden)]`.
     query is_doc_hidden(def_id: DefId) -> bool {
         desc { |tcx| "checking whether `{}` is `doc(hidden)`", tcx.def_path_str(def_id) }
         separate_provide_extern
     }
 
-    /// Determines whether an item is annotated with `doc(notable_trait)`.
+    /// Determines whether an item is annotated with `#[doc(notable_trait)]`.
     query is_doc_notable_trait(def_id: DefId) -> bool {
         desc { |tcx| "checking whether `{}` is `doc(notable_trait)`", tcx.def_path_str(def_id) }
     }
@@ -1796,13 +1910,22 @@ rustc_queries! {
     query is_late_bound_map(owner_id: hir::OwnerId) -> Option<&'tcx FxIndexSet<ItemLocalId>> {
         desc { |tcx| "testing if a region is late bound inside `{}`", tcx.def_path_str(owner_id) }
     }
-    /// For a given item's generic parameter, gets the default lifetimes to be used
-    /// for each parameter if a trait object were to be passed for that parameter.
-    /// For example, for `T` in `struct Foo<'a, T>`, this would be `'static`.
-    /// For `T` in `struct Foo<'a, T: 'a>`, this would instead be `'a`.
-    /// This query will panic if passed something that is not a type parameter.
+    /// Returns the *default lifetime* to be used if a trait object type were to be passed for
+    /// the type parameter given by `DefId`.
+    ///
+    /// **Tip**: You can use `#[rustc_object_lifetime_default]` on an item to basically
+    /// print the result of this query for use in UI tests or for debugging purposes.
+    ///
+    /// # Examples
+    ///
+    /// - For `T` in `struct Foo<'a, T: 'a>(&'a T);`, this would be `Param('a)`
+    /// - For `T` in `struct Bar<'a, T>(&'a T);`, this would be `Empty`
+    ///
+    /// # Panics
+    ///
+    /// This query will panic if the given definition is not a type parameter.
     query object_lifetime_default(def_id: DefId) -> ObjectLifetimeDefault {
-        desc { "looking up lifetime defaults for generic parameter `{}`", tcx.def_path_str(def_id) }
+        desc { "looking up lifetime defaults for type parameter `{}`", tcx.def_path_str(def_id) }
         separate_provide_extern
     }
     query late_bound_vars_map(owner_id: hir::OwnerId)
diff --git a/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr b/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr
index cf5d8f614dd..7f8ed898525 100644
--- a/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr
+++ b/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr
@@ -4,12 +4,12 @@ error[E0391]: cycle detected when computing predicates of `Foo`
 LL | struct Foo {
    | ^^^^^^^^^^
    |
-note: ...which requires computing inferred outlives predicates of `Foo`...
+note: ...which requires computing inferred outlives-predicates of `Foo`...
   --> $DIR/cycle-iat-inside-of-adt.rs:7:1
    |
 LL | struct Foo {
    | ^^^^^^^^^^
-   = note: ...which requires computing the inferred outlives predicates for items in this crate...
+   = note: ...which requires computing the inferred outlives-predicates for items in this crate...
 note: ...which requires computing type of `Foo::bar`...
   --> $DIR/cycle-iat-inside-of-adt.rs:8:5
    |
-- 
cgit 1.4.1-3-g733a5


From 11f7e302e154cdb378a8ae4b0ca8332c40218b20 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Fri, 4 Oct 2024 14:59:07 +0000
Subject: Add diff test for MatchBranchSimplification

---
 ...nches.my_is_some.MatchBranchSimplification.diff | 32 ++++++++++++++++++++++
 tests/mir-opt/matches_reduce_branches.rs           | 14 ++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff

(limited to 'tests')

diff --git a/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..d55e764e1c2
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff
@@ -0,0 +1,32 @@
+- // MIR for `my_is_some` before MatchBranchSimplification
++ // MIR for `my_is_some` after MatchBranchSimplification
+  
+  fn my_is_some(_1: Option<()>) -> bool {
+      debug bar => _1;
+      let mut _0: bool;
+      let mut _2: isize;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [0: bb2, 1: bb3, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const false;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const true;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.rs b/tests/mir-opt/matches_reduce_branches.rs
index 6787e5816a3..e2bd7b3459c 100644
--- a/tests/mir-opt/matches_reduce_branches.rs
+++ b/tests/mir-opt/matches_reduce_branches.rs
@@ -19,6 +19,18 @@ fn foo(bar: Option<()>) {
     }
 }
 
+// EMIT_MIR matches_reduce_branches.my_is_some.MatchBranchSimplification.diff
+// Test for #131219.
+fn my_is_some(bar: Option<()>) -> bool {
+    // CHECK-LABEL: fn my_is_some(
+    // CHECK: switchInt
+    // CHECK: return
+    match bar {
+        Some(_) => true,
+        None => false,
+    }
+}
+
 // EMIT_MIR matches_reduce_branches.bar.MatchBranchSimplification.diff
 fn bar(i: i32) -> (bool, bool, bool, bool) {
     // CHECK-LABEL: fn bar(
@@ -651,4 +663,6 @@ fn main() {
     let _: u8 = match_trunc_u16_u8_failed(EnumAu16::u0_0x0000);
 
     let _ = match_i128_u128(EnumAi128::A);
+
+    let _ = my_is_some(None);
 }
-- 
cgit 1.4.1-3-g733a5


From e32ec45c02d890e46e55af86163a6d1ba10a4b41 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Fri, 4 Oct 2024 20:26:41 +0000
Subject: MatchBranchSimplification: Consider empty-unreachable otherwise
 branch

---
 compiler/rustc_data_structures/src/packed.rs       |  7 ++++
 compiler/rustc_middle/src/mir/terminator.rs        | 11 ++++++
 compiler/rustc_mir_transform/src/match_branches.rs | 30 +++++++++++-----
 ...2.num_to_digit.PreCodegen.after.panic-abort.mir | 19 +++++-----
 ....num_to_digit.PreCodegen.after.panic-unwind.mir | 19 +++++-----
 ...nches.my_is_some.MatchBranchSimplification.diff | 41 ++++++++++++----------
 tests/mir-opt/matches_reduce_branches.rs           |  2 +-
 7 files changed, 81 insertions(+), 48 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_data_structures/src/packed.rs b/compiler/rustc_data_structures/src/packed.rs
index f54b12b5b53..c8921536530 100644
--- a/compiler/rustc_data_structures/src/packed.rs
+++ b/compiler/rustc_data_structures/src/packed.rs
@@ -18,6 +18,13 @@ impl Pu128 {
     }
 }
 
+impl From<Pu128> for u128 {
+    #[inline]
+    fn from(value: Pu128) -> Self {
+        value.get()
+    }
+}
+
 impl From<u128> for Pu128 {
     #[inline]
     fn from(value: u128) -> Self {
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index b919f5726db..473b817aed0 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -67,6 +67,17 @@ impl SwitchTargets {
         &mut self.targets
     }
 
+    /// Returns a slice with all considered values (not including the fallback).
+    #[inline]
+    pub fn all_values(&self) -> &[Pu128] {
+        &self.values
+    }
+
+    #[inline]
+    pub fn all_values_mut(&mut self) -> &mut [Pu128] {
+        &mut self.values
+    }
+
     /// Finds the `BasicBlock` to which this `SwitchInt` will branch given the
     /// specific value. This cannot fail, as it'll return the `otherwise`
     /// branch if there's not a specific match for the value.
diff --git a/compiler/rustc_mir_transform/src/match_branches.rs b/compiler/rustc_mir_transform/src/match_branches.rs
index 20e2a65b311..534ba991780 100644
--- a/compiler/rustc_mir_transform/src/match_branches.rs
+++ b/compiler/rustc_mir_transform/src/match_branches.rs
@@ -7,6 +7,7 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
 use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt};
 use rustc_type_ir::TyKind::*;
+use tracing::instrument;
 
 use super::simplify::simplify_cfg;
 
@@ -51,7 +52,7 @@ impl<'tcx> crate::MirPass<'tcx> for MatchBranchSimplification {
 }
 
 trait SimplifyMatch<'tcx> {
-    /// Simplifies a match statement, returning true if the simplification succeeds, false
+    /// Simplifies a match statement, returning `Some` if the simplification succeeds, `None`
     /// otherwise. Generic code is written here, and we generally don't need a custom
     /// implementation.
     fn simplify(
@@ -159,6 +160,7 @@ struct SimplifyToIf;
 /// }
 /// ```
 impl<'tcx> SimplifyMatch<'tcx> for SimplifyToIf {
+    #[instrument(level = "debug", skip(self, tcx), ret)]
     fn can_simplify(
         &mut self,
         tcx: TyCtxt<'tcx>,
@@ -167,12 +169,15 @@ impl<'tcx> SimplifyMatch<'tcx> for SimplifyToIf {
         bbs: &IndexSlice<BasicBlock, BasicBlockData<'tcx>>,
         _discr_ty: Ty<'tcx>,
     ) -> Option<()> {
-        if targets.iter().len() != 1 {
-            return None;
-        }
+        let (first, second) = match targets.all_targets() {
+            &[first, otherwise] => (first, otherwise),
+            &[first, second, otherwise] if bbs[otherwise].is_empty_unreachable() => (first, second),
+            _ => {
+                return None;
+            }
+        };
+
         // We require that the possible target blocks all be distinct.
-        let (_, first) = targets.iter().next().unwrap();
-        let second = targets.otherwise();
         if first == second {
             return None;
         }
@@ -221,8 +226,14 @@ impl<'tcx> SimplifyMatch<'tcx> for SimplifyToIf {
         discr_local: Local,
         discr_ty: Ty<'tcx>,
     ) {
-        let (val, first) = targets.iter().next().unwrap();
-        let second = targets.otherwise();
+        let ((val, first), second) = match (targets.all_targets(), targets.all_values()) {
+            (&[first, otherwise], &[val]) => ((val, first), otherwise),
+            (&[first, second, otherwise], &[val, _]) if bbs[otherwise].is_empty_unreachable() => {
+                ((val, first), second)
+            }
+            _ => unreachable!(),
+        };
+
         // We already checked that first and second are different blocks,
         // and bb_idx has a different terminator from both of them.
         let first = &bbs[first];
@@ -297,7 +308,7 @@ struct SimplifyToExp {
     transform_kinds: Vec<TransformKind>,
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 enum ExpectedTransformKind<'a, 'tcx> {
     /// Identical statements.
     Same(&'a StatementKind<'tcx>),
@@ -362,6 +373,7 @@ impl From<ExpectedTransformKind<'_, '_>> for TransformKind {
 /// }
 /// ```
 impl<'tcx> SimplifyMatch<'tcx> for SimplifyToExp {
+    #[instrument(level = "debug", skip(self, tcx), ret)]
     fn can_simplify(
         &mut self,
         tcx: TyCtxt<'tcx>,
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir
index 573c0a12bc1..5876c55c52b 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir
@@ -25,12 +25,12 @@ fn num_to_digit(_1: char) -> u32 {
     bb1: {
         StorageLive(_3);
         _3 = discriminant(_2);
-        switchInt(move _3) -> [1: bb2, 0: bb6, otherwise: bb8];
+        StorageDead(_2);
+        switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
     bb2: {
         StorageDead(_3);
-        StorageDead(_2);
         StorageLive(_4);
         _4 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable];
     }
@@ -38,7 +38,7 @@ fn num_to_digit(_1: char) -> u32 {
     bb3: {
         StorageLive(_5);
         _5 = discriminant(_4);
-        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb8];
+        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6];
     }
 
     bb4: {
@@ -49,21 +49,20 @@ fn num_to_digit(_1: char) -> u32 {
         _0 = move ((_4 as Some).0: u32);
         StorageDead(_5);
         StorageDead(_4);
-        goto -> bb7;
+        goto -> bb8;
     }
 
     bb6: {
-        StorageDead(_3);
-        StorageDead(_2);
-        _0 = const 0_u32;
-        goto -> bb7;
+        unreachable;
     }
 
     bb7: {
-        return;
+        StorageDead(_3);
+        _0 = const 0_u32;
+        goto -> bb8;
     }
 
     bb8: {
-        unreachable;
+        return;
     }
 }
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir
index 049803041d4..f1185353a43 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir
@@ -25,12 +25,12 @@ fn num_to_digit(_1: char) -> u32 {
     bb1: {
         StorageLive(_3);
         _3 = discriminant(_2);
-        switchInt(move _3) -> [1: bb2, 0: bb6, otherwise: bb8];
+        StorageDead(_2);
+        switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
     bb2: {
         StorageDead(_3);
-        StorageDead(_2);
         StorageLive(_4);
         _4 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue];
     }
@@ -38,7 +38,7 @@ fn num_to_digit(_1: char) -> u32 {
     bb3: {
         StorageLive(_5);
         _5 = discriminant(_4);
-        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb8];
+        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6];
     }
 
     bb4: {
@@ -49,21 +49,20 @@ fn num_to_digit(_1: char) -> u32 {
         _0 = move ((_4 as Some).0: u32);
         StorageDead(_5);
         StorageDead(_4);
-        goto -> bb7;
+        goto -> bb8;
     }
 
     bb6: {
-        StorageDead(_3);
-        StorageDead(_2);
-        _0 = const 0_u32;
-        goto -> bb7;
+        unreachable;
     }
 
     bb7: {
-        return;
+        StorageDead(_3);
+        _0 = const 0_u32;
+        goto -> bb8;
     }
 
     bb8: {
-        unreachable;
+        return;
     }
 }
diff --git a/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff
index d55e764e1c2..d255278ed30 100644
--- a/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.my_is_some.MatchBranchSimplification.diff
@@ -5,27 +5,32 @@
       debug bar => _1;
       let mut _0: bool;
       let mut _2: isize;
++     let mut _3: isize;
   
       bb0: {
           _2 = discriminant(_1);
-          switchInt(move _2) -> [0: bb2, 1: bb3, otherwise: bb1];
-      }
-  
-      bb1: {
-          unreachable;
-      }
-  
-      bb2: {
-          _0 = const false;
-          goto -> bb4;
-      }
-  
-      bb3: {
-          _0 = const true;
-          goto -> bb4;
-      }
-  
-      bb4: {
+-         switchInt(move _2) -> [0: bb2, 1: bb3, otherwise: bb1];
+-     }
+- 
+-     bb1: {
+-         unreachable;
+-     }
+- 
+-     bb2: {
+-         _0 = const false;
+-         goto -> bb4;
+-     }
+- 
+-     bb3: {
+-         _0 = const true;
+-         goto -> bb4;
+-     }
+- 
+-     bb4: {
++         StorageLive(_3);
++         _3 = move _2;
++         _0 = Ne(copy _3, const 0_isize);
++         StorageDead(_3);
           return;
       }
   }
diff --git a/tests/mir-opt/matches_reduce_branches.rs b/tests/mir-opt/matches_reduce_branches.rs
index e2bd7b3459c..3372ae2f2a6 100644
--- a/tests/mir-opt/matches_reduce_branches.rs
+++ b/tests/mir-opt/matches_reduce_branches.rs
@@ -23,7 +23,7 @@ fn foo(bar: Option<()>) {
 // Test for #131219.
 fn my_is_some(bar: Option<()>) -> bool {
     // CHECK-LABEL: fn my_is_some(
-    // CHECK: switchInt
+    // CHECK: = Ne
     // CHECK: return
     match bar {
         Some(_) => true,
-- 
cgit 1.4.1-3-g733a5


From 4669c0d756ddfbd3df0ee1d5c7a4b1cdaabf5945 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 29 Nov 2024 22:51:46 -0800
Subject: Override `carrying_mul_add` in cg_llvm

---
 compiler/rustc_codegen_llvm/src/intrinsic.rs |  31 ++++++
 compiler/rustc_codegen_llvm/src/lib.rs       |   1 +
 library/core/src/intrinsics/fallback.rs      |   4 +-
 library/core/tests/intrinsics.rs             |  10 ++
 tests/codegen/intrinsics/carrying_mul_add.rs | 137 +++++++++++++++++++++++++++
 5 files changed, 181 insertions(+), 2 deletions(-)
 create mode 100644 tests/codegen/intrinsics/carrying_mul_add.rs

(limited to 'tests')

diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index c38c5d4c644..cabcfc9b42b 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -340,6 +340,37 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     self.const_i32(cache_type),
                 ])
             }
+            sym::carrying_mul_add => {
+                let (size, signed) = fn_args.type_at(0).int_size_and_signed(self.tcx);
+
+                let wide_llty = self.type_ix(size.bits() * 2);
+                let args = args.as_array().unwrap();
+                let [a, b, c, d] = args.map(|a| self.intcast(a.immediate(), wide_llty, signed));
+
+                let wide = if signed {
+                    let prod = self.unchecked_smul(a, b);
+                    let acc = self.unchecked_sadd(prod, c);
+                    self.unchecked_sadd(acc, d)
+                } else {
+                    let prod = self.unchecked_umul(a, b);
+                    let acc = self.unchecked_uadd(prod, c);
+                    self.unchecked_uadd(acc, d)
+                };
+
+                let narrow_llty = self.type_ix(size.bits());
+                let low = self.trunc(wide, narrow_llty);
+                let bits_const = self.const_uint(wide_llty, size.bits());
+                // No need for ashr when signed; LLVM changes it to lshr anyway.
+                let high = self.lshr(wide, bits_const);
+                // FIXME: could be `trunc nuw`, even for signed.
+                let high = self.trunc(high, narrow_llty);
+
+                let pair_llty = self.type_struct(&[narrow_llty, narrow_llty], false);
+                let pair = self.const_poison(pair_llty);
+                let pair = self.insert_value(pair, low, 0);
+                let pair = self.insert_value(pair, high, 1);
+                pair
+            }
             sym::ctlz
             | sym::ctlz_nonzero
             | sym::cttz
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 0de0c6a7a89..dca7738daf7 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -17,6 +17,7 @@
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
+#![feature(slice_as_array)]
 #![feature(try_blocks)]
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
diff --git a/library/core/src/intrinsics/fallback.rs b/library/core/src/intrinsics/fallback.rs
index d87331f7262..1779126b180 100644
--- a/library/core/src/intrinsics/fallback.rs
+++ b/library/core/src/intrinsics/fallback.rs
@@ -100,8 +100,8 @@ impl const CarryingMulAdd for i128 {
     fn carrying_mul_add(self, b: i128, c: i128, d: i128) -> (u128, i128) {
         let (low, high) = wide_mul_u128(self as u128, b as u128);
         let mut high = high as i128;
-        high = high.wrapping_add((self >> 127) * b);
-        high = high.wrapping_add(self * (b >> 127));
+        high = high.wrapping_add(i128::wrapping_mul(self >> 127, b));
+        high = high.wrapping_add(i128::wrapping_mul(self, b >> 127));
         let (low, carry) = u128::overflowing_add(low, c as u128);
         high = high.wrapping_add((carry as i128) + (c >> 127));
         let (low, carry) = u128::overflowing_add(low, d as u128);
diff --git a/library/core/tests/intrinsics.rs b/library/core/tests/intrinsics.rs
index 76f42594091..744a6a0d2dd 100644
--- a/library/core/tests/intrinsics.rs
+++ b/library/core/tests/intrinsics.rs
@@ -153,6 +153,7 @@ fn carrying_mul_add_fallback_i32() {
 
 #[test]
 fn carrying_mul_add_fallback_u128() {
+    assert_eq!(fallback_cma::<u128>(u128::MAX, u128::MAX, 0, 0), (1, u128::MAX - 1));
     assert_eq!(fallback_cma::<u128>(1, 1, 1, 1), (3, 0));
     assert_eq!(fallback_cma::<u128>(0, 0, u128::MAX, u128::MAX), (u128::MAX - 1, 1));
     assert_eq!(
@@ -178,8 +179,17 @@ fn carrying_mul_add_fallback_u128() {
 
 #[test]
 fn carrying_mul_add_fallback_i128() {
+    assert_eq!(fallback_cma::<i128>(-1, -1, 0, 0), (1, 0));
     let r = fallback_cma::<i128>(-1, -1, -1, -1);
     assert_eq!(r, (u128::MAX, -1));
     let r = fallback_cma::<i128>(1, -1, 1, 1);
     assert_eq!(r, (1, 0));
+    assert_eq!(
+        fallback_cma::<i128>(i128::MAX, i128::MAX, i128::MAX, i128::MAX),
+        (u128::MAX, i128::MAX / 2),
+    );
+    assert_eq!(
+        fallback_cma::<i128>(i128::MIN, i128::MIN, i128::MAX, i128::MAX),
+        (u128::MAX - 1, -(i128::MIN / 2)),
+    );
 }
diff --git a/tests/codegen/intrinsics/carrying_mul_add.rs b/tests/codegen/intrinsics/carrying_mul_add.rs
new file mode 100644
index 00000000000..174c4077f09
--- /dev/null
+++ b/tests/codegen/intrinsics/carrying_mul_add.rs
@@ -0,0 +1,137 @@
+//@ revisions: RAW OPT
+//@ compile-flags: -C opt-level=1
+//@[RAW] compile-flags: -C no-prepopulate-passes
+//@[OPT] min-llvm-version: 19
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+#![feature(core_intrinsics_fallbacks)]
+
+// Note that LLVM seems to sometimes permute the order of arguments to mul and add,
+// so these tests don't check the arguments in the optimized revision.
+
+use std::intrinsics::{carrying_mul_add, fallback};
+
+// The fallbacks are emitted even when they're never used, but optimize out.
+
+// RAW: wide_mul_u128
+// OPT-NOT: wide_mul_u128
+
+// CHECK-LABEL: @cma_u8
+#[no_mangle]
+pub unsafe fn cma_u8(a: u8, b: u8, c: u8, d: u8) -> (u8, u8) {
+    // CHECK: [[A:%.+]] = zext i8 %a to i16
+    // CHECK: [[B:%.+]] = zext i8 %b to i16
+    // CHECK: [[C:%.+]] = zext i8 %c to i16
+    // CHECK: [[D:%.+]] = zext i8 %d to i16
+    // CHECK: [[AB:%.+]] = mul nuw i16
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nuw i16
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nuw i16
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i16 [[ABCD]] to i8
+    // CHECK: [[HIGHW:%.+]] = lshr i16 [[ABCD]], 8
+    // RAW: [[HIGH:%.+]] = trunc i16 [[HIGHW]] to i8
+    // OPT: [[HIGH:%.+]] = trunc nuw i16 [[HIGHW]] to i8
+    // CHECK: [[PAIR0:%.+]] = insertvalue { i8, i8 } poison, i8 [[LOW]], 0
+    // CHECK: [[PAIR1:%.+]] = insertvalue { i8, i8 } [[PAIR0]], i8 [[HIGH]], 1
+    // OPT: ret { i8, i8 } [[PAIR1]]
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @cma_u32
+#[no_mangle]
+pub unsafe fn cma_u32(a: u32, b: u32, c: u32, d: u32) -> (u32, u32) {
+    // CHECK: [[A:%.+]] = zext i32 %a to i64
+    // CHECK: [[B:%.+]] = zext i32 %b to i64
+    // CHECK: [[C:%.+]] = zext i32 %c to i64
+    // CHECK: [[D:%.+]] = zext i32 %d to i64
+    // CHECK: [[AB:%.+]] = mul nuw i64
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nuw i64
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nuw i64
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i64 [[ABCD]] to i32
+    // CHECK: [[HIGHW:%.+]] = lshr i64 [[ABCD]], 32
+    // RAW: [[HIGH:%.+]] = trunc i64 [[HIGHW]] to i32
+    // OPT: [[HIGH:%.+]] = trunc nuw i64 [[HIGHW]] to i32
+    // CHECK: [[PAIR0:%.+]] = insertvalue { i32, i32 } poison, i32 [[LOW]], 0
+    // CHECK: [[PAIR1:%.+]] = insertvalue { i32, i32 } [[PAIR0]], i32 [[HIGH]], 1
+    // OPT: ret { i32, i32 } [[PAIR1]]
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @cma_u128
+// CHECK-SAME: sret{{.+}}dereferenceable(32){{.+}}%_0,{{.+}}%a,{{.+}}%b,{{.+}}%c,{{.+}}%d
+#[no_mangle]
+pub unsafe fn cma_u128(a: u128, b: u128, c: u128, d: u128) -> (u128, u128) {
+    // CHECK: [[A:%.+]] = zext i128 %a to i256
+    // CHECK: [[B:%.+]] = zext i128 %b to i256
+    // CHECK: [[C:%.+]] = zext i128 %c to i256
+    // CHECK: [[D:%.+]] = zext i128 %d to i256
+    // CHECK: [[AB:%.+]] = mul nuw i256
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nuw i256
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nuw i256
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i256 [[ABCD]] to i128
+    // CHECK: [[HIGHW:%.+]] = lshr i256 [[ABCD]], 128
+    // RAW: [[HIGH:%.+]] = trunc i256 [[HIGHW]] to i128
+    // OPT: [[HIGH:%.+]] = trunc nuw i256 [[HIGHW]] to i128
+    // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
+    // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
+    // OPT: store i128 [[LOW]], ptr %_0
+    // OPT: [[P1:%.+]] = getelementptr inbounds i8, ptr %_0, {{i32|i64}} 16
+    // OPT: store i128 [[HIGH]], ptr [[P1]]
+    // CHECK: ret void
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @cma_i128
+// CHECK-SAME: sret{{.+}}dereferenceable(32){{.+}}%_0,{{.+}}%a,{{.+}}%b,{{.+}}%c,{{.+}}%d
+#[no_mangle]
+pub unsafe fn cma_i128(a: i128, b: i128, c: i128, d: i128) -> (u128, i128) {
+    // CHECK: [[A:%.+]] = sext i128 %a to i256
+    // CHECK: [[B:%.+]] = sext i128 %b to i256
+    // CHECK: [[C:%.+]] = sext i128 %c to i256
+    // CHECK: [[D:%.+]] = sext i128 %d to i256
+    // CHECK: [[AB:%.+]] = mul nsw i256
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nsw i256
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nsw i256
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i256 [[ABCD]] to i128
+    // CHECK: [[HIGHW:%.+]] = lshr i256 [[ABCD]], 128
+    // RAW: [[HIGH:%.+]] = trunc i256 [[HIGHW]] to i128
+    // OPT: [[HIGH:%.+]] = trunc nuw i256 [[HIGHW]] to i128
+    // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
+    // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
+    // OPT: store i128 [[LOW]], ptr %_0
+    // OPT: [[P1:%.+]] = getelementptr inbounds i8, ptr %_0, {{i32|i64}} 16
+    // OPT: store i128 [[HIGH]], ptr [[P1]]
+    // CHECK: ret void
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @fallback_cma_u32
+#[no_mangle]
+pub unsafe fn fallback_cma_u32(a: u32, b: u32, c: u32, d: u32) -> (u32, u32) {
+    // OPT-DAG: [[A:%.+]] = zext i32 %a to i64
+    // OPT-DAG: [[B:%.+]] = zext i32 %b to i64
+    // OPT-DAG: [[AB:%.+]] = mul nuw i64
+    // OPT-DAG: [[C:%.+]] = zext i32 %c to i64
+    // OPT-DAG: [[ABC:%.+]] = add nuw i64{{.+}}[[C]]
+    // OPT-DAG: [[D:%.+]] = zext i32 %d to i64
+    // OPT-DAG: [[ABCD:%.+]] = add nuw i64{{.+}}[[D]]
+    // OPT-DAG: [[LOW:%.+]] = trunc i64 [[ABCD]] to i32
+    // OPT-DAG: [[HIGHW:%.+]] = lshr i64 [[ABCD]], 32
+    // OPT-DAG: [[HIGH:%.+]] = trunc nuw i64 [[HIGHW]] to i32
+    // OPT-DAG: [[PAIR0:%.+]] = insertvalue { i32, i32 } poison, i32 [[LOW]], 0
+    // OPT-DAG: [[PAIR1:%.+]] = insertvalue { i32, i32 } [[PAIR0]], i32 [[HIGH]], 1
+    // OPT-DAG: ret { i32, i32 } [[PAIR1]]
+    fallback::CarryingMulAdd::carrying_mul_add(a, b, c, d)
+}
-- 
cgit 1.4.1-3-g733a5


From fef8ec5ad9ccd3249d616520e22e43602fa47883 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 27 Dec 2024 13:41:46 -0800
Subject: Add test of dot after eager statement boundary expr

---
 tests/ui-fulldeps/pprust-parenthesis-insertion.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'tests')

diff --git a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
index 94c7964392d..8cef9fa13f9 100644
--- a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
+++ b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
@@ -108,6 +108,10 @@ static EXPRS: &[&str] = &[
     "{ (match 2 {})() - 1 }",
     "{ (match 2 {})[0] - 1 }",
     "{ (loop {}) - 1 }",
+    "match 2 { _ => (loop {}) - 1 }",
+    // No eager statement boundary if followed by `.` or `?`.
+    "{ (loop {}).to_string() - 1 }",  // FIXME: no parenthesis needed.
+    "match 2 { _ => (loop {}).to_string() - 1 }",  // FIXME: no parenthesis needed.
     // Angle bracket is eagerly parsed as a path's generic argument list.
     "(2 as T) < U",
     "(2 as T<U>) < V", // FIXME: no parentheses needed.
-- 
cgit 1.4.1-3-g733a5


From e67fe3698bfd0f3957abb84c2b396c50822a5b67 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 27 Dec 2024 13:42:25 -0800
Subject: Skip parenthesis if `.` makes statement boundary unambiguous

---
 compiler/rustc_ast_pretty/src/pprust/state/expr.rs | 28 +++++++++++++---------
 .../rustc_ast_pretty/src/pprust/state/fixup.rs     | 14 +++++++++++
 tests/ui-fulldeps/pprust-parenthesis-insertion.rs  |  4 ++--
 3 files changed, 33 insertions(+), 13 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index dce76fb1e77..ab1dd46fe33 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -245,19 +245,21 @@ impl<'a> State<'a> {
         base_args: &[P<ast::Expr>],
         fixup: FixupContext,
     ) {
-        // Unlike in `print_expr_call`, no change to fixup here because
+        // The fixup here is different than in `print_expr_call` because
         // statement boundaries never occur in front of a `.` (or `?`) token.
         //
-        //     match () { _ => f }.method();
+        // Needs parens:
+        //
+        //     (loop { break x; })();
+        //
+        // Does not need parens:
+        //
+        //     loop { break x; }.method();
         //
-        // Parenthesizing only for precedence and not with regard to statement
-        // boundaries, `$receiver.method()` can be parsed back as a statement
-        // containing an expression if and only if `$receiver` can be parsed as
-        // a statement containing an expression.
         self.print_expr_cond_paren(
             receiver,
             receiver.precedence() < ExprPrecedence::Unambiguous,
-            fixup,
+            fixup.leftmost_subexpression_with_dot(),
         );
 
         self.word(".");
@@ -503,7 +505,7 @@ impl<'a> State<'a> {
                         self.print_expr_cond_paren(
                             expr,
                             expr.precedence() < ExprPrecedence::Unambiguous,
-                            fixup,
+                            fixup.leftmost_subexpression_with_dot(),
                         );
                         self.word_nbsp(".match");
                     }
@@ -567,7 +569,7 @@ impl<'a> State<'a> {
                 self.print_expr_cond_paren(
                     expr,
                     expr.precedence() < ExprPrecedence::Unambiguous,
-                    fixup,
+                    fixup.leftmost_subexpression_with_dot(),
                 );
                 self.word(".await");
             }
@@ -606,7 +608,7 @@ impl<'a> State<'a> {
                 self.print_expr_cond_paren(
                     expr,
                     expr.precedence() < ExprPrecedence::Unambiguous,
-                    fixup,
+                    fixup.leftmost_subexpression_with_dot(),
                 );
                 self.word(".");
                 self.print_ident(*ident);
@@ -763,7 +765,11 @@ impl<'a> State<'a> {
                 }
             }
             ast::ExprKind::Try(e) => {
-                self.print_expr_cond_paren(e, e.precedence() < ExprPrecedence::Unambiguous, fixup);
+                self.print_expr_cond_paren(
+                    e,
+                    e.precedence() < ExprPrecedence::Unambiguous,
+                    fixup.leftmost_subexpression_with_dot(),
+                );
                 self.word("?")
             }
             ast::ExprKind::TryBlock(blk) => {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs b/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs
index ff466703f73..3ef21f5cb29 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs
@@ -138,6 +138,20 @@ impl FixupContext {
         }
     }
 
+    /// Transform this fixup into the one that should apply when printing a
+    /// leftmost subexpression followed by a `.` or `?` token, which confer
+    /// different statement boundary rules compared to other leftmost
+    /// subexpressions.
+    pub(crate) fn leftmost_subexpression_with_dot(self) -> Self {
+        FixupContext {
+            stmt: self.stmt || self.leftmost_subexpression_in_stmt,
+            leftmost_subexpression_in_stmt: false,
+            match_arm: self.match_arm || self.leftmost_subexpression_in_match_arm,
+            leftmost_subexpression_in_match_arm: false,
+            ..self
+        }
+    }
+
     /// Transform this fixup into the one that should apply when printing any
     /// subexpression that is neither a leftmost subexpression nor surrounded in
     /// delimiters.
diff --git a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
index 8cef9fa13f9..dc45731dce7 100644
--- a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
+++ b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
@@ -110,8 +110,8 @@ static EXPRS: &[&str] = &[
     "{ (loop {}) - 1 }",
     "match 2 { _ => (loop {}) - 1 }",
     // No eager statement boundary if followed by `.` or `?`.
-    "{ (loop {}).to_string() - 1 }",  // FIXME: no parenthesis needed.
-    "match 2 { _ => (loop {}).to_string() - 1 }",  // FIXME: no parenthesis needed.
+    "{ loop {}.to_string() - 1 }",
+    "match 2 { _ => loop {}.to_string() - 1 }",
     // Angle bracket is eagerly parsed as a path's generic argument list.
     "(2 as T) < U",
     "(2 as T<U>) < V", // FIXME: no parentheses needed.
-- 
cgit 1.4.1-3-g733a5


From c95f9f50de555454cbd931c026814e46793a820a Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 27 Dec 2024 14:18:39 -0800
Subject: Add pretty-printer test of tuple field function call

---
 tests/ui-fulldeps/pprust-parenthesis-insertion.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'tests')

diff --git a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
index 94c7964392d..fa9b0300743 100644
--- a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
+++ b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
@@ -77,6 +77,9 @@ static EXPRS: &[&str] = &[
     // These mean different things.
     "if let _ = true && false {}",
     "if let _ = (true && false) {}",
+    // Parentheses to call a named field, but not an unnamed field.
+    "(self.fun)()",
+    "(self.0)()",  // FIXME: no parenthesis needed.
     // Conditions end at the first curly brace, so struct expressions need to be
     // parenthesized. Except in a match guard, where conditions end at arrow.
     "if let _ = (Struct {}) {}",
-- 
cgit 1.4.1-3-g733a5


From 26bb4e64645d3f3e0ed0b2921738e56888f96fd1 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 27 Dec 2024 14:25:08 -0800
Subject: Skip parenthesis around tuple struct field calls

---
 compiler/rustc_ast_pretty/src/pprust/state/expr.rs | 4 +++-
 compiler/rustc_parse/src/parser/diagnostics.rs     | 2 +-
 compiler/rustc_span/src/symbol.rs                  | 6 ++++++
 tests/ui-fulldeps/pprust-parenthesis-insertion.rs  | 2 +-
 4 files changed, 11 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index dce76fb1e77..f7d8edc4743 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -213,7 +213,9 @@ impl<'a> State<'a> {
 
     fn print_expr_call(&mut self, func: &ast::Expr, args: &[P<ast::Expr>], fixup: FixupContext) {
         let needs_paren = match func.kind {
-            ast::ExprKind::Field(..) => true,
+            // In order to call a named field, needs parens: `(self.fun)()`
+            // But not for an unnamed field: `self.0()`
+            ast::ExprKind::Field(_, name) => !name.is_numeric(),
             _ => func.precedence() < ExprPrecedence::Unambiguous,
         };
 
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index aab4e1b1afc..7df7e732925 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -1336,7 +1336,7 @@ impl<'a> Parser<'a> {
     ) -> bool {
         if let ExprKind::Binary(op, l1, r1) = &inner_op.kind {
             if let ExprKind::Field(_, ident) = l1.kind
-                && ident.as_str().parse::<i32>().is_err()
+                && !ident.is_numeric()
                 && !matches!(r1.kind, ExprKind::Lit(_))
             {
                 // The parser has encountered `foo.bar<baz`, the likelihood of the turbofish
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 3d202f11722..829127e7a62 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2707,6 +2707,12 @@ impl Ident {
     pub fn is_raw_guess(self) -> bool {
         self.name.can_be_raw() && self.is_reserved()
     }
+
+    /// Whether this would be the identifier for a tuple field like `self.0`, as
+    /// opposed to a named field like `self.thing`.
+    pub fn is_numeric(self) -> bool {
+        !self.name.is_empty() && self.as_str().bytes().all(|b| b.is_ascii_digit())
+    }
 }
 
 /// Collect all the keywords in a given edition into a vector.
diff --git a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
index fa9b0300743..2697c5f66ce 100644
--- a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
+++ b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
@@ -79,7 +79,7 @@ static EXPRS: &[&str] = &[
     "if let _ = (true && false) {}",
     // Parentheses to call a named field, but not an unnamed field.
     "(self.fun)()",
-    "(self.0)()",  // FIXME: no parenthesis needed.
+    "self.0()",
     // Conditions end at the first curly brace, so struct expressions need to be
     // parenthesized. Except in a match guard, where conditions end at arrow.
     "if let _ = (Struct {}) {}",
-- 
cgit 1.4.1-3-g733a5


From ef19017f7ca29450efff332db297851933f21844 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 28 Dec 2024 13:12:36 +1100
Subject: compiletest: Self-test for `normalize-*` with revisions

---
 .../normalize-with-revision.a.run.stderr             |  2 ++
 .../normalize-with-revision.b.run.stderr             |  2 ++
 .../compiletest-self-test/normalize-with-revision.rs | 20 ++++++++++++++++++++
 3 files changed, 24 insertions(+)
 create mode 100644 tests/ui/compiletest-self-test/normalize-with-revision.a.run.stderr
 create mode 100644 tests/ui/compiletest-self-test/normalize-with-revision.b.run.stderr
 create mode 100644 tests/ui/compiletest-self-test/normalize-with-revision.rs

(limited to 'tests')

diff --git a/tests/ui/compiletest-self-test/normalize-with-revision.a.run.stderr b/tests/ui/compiletest-self-test/normalize-with-revision.a.run.stderr
new file mode 100644
index 00000000000..3eb3f6b4e57
--- /dev/null
+++ b/tests/ui/compiletest-self-test/normalize-with-revision.a.run.stderr
@@ -0,0 +1,2 @@
+1st emitted line
+second emitted line
diff --git a/tests/ui/compiletest-self-test/normalize-with-revision.b.run.stderr b/tests/ui/compiletest-self-test/normalize-with-revision.b.run.stderr
new file mode 100644
index 00000000000..8d9156480ab
--- /dev/null
+++ b/tests/ui/compiletest-self-test/normalize-with-revision.b.run.stderr
@@ -0,0 +1,2 @@
+first emitted line
+2nd emitted line
diff --git a/tests/ui/compiletest-self-test/normalize-with-revision.rs b/tests/ui/compiletest-self-test/normalize-with-revision.rs
new file mode 100644
index 00000000000..e1bbbb3eabb
--- /dev/null
+++ b/tests/ui/compiletest-self-test/normalize-with-revision.rs
@@ -0,0 +1,20 @@
+//! Checks that `[rev] normalize-*` directives affect the specified revision,
+//! and don't affect other revisions.
+//!
+//! This currently relies on the fact that `normalize-*` directives are
+//! applied to run output, not just compiler output. If that ever changes,
+//! this test might need to be adjusted.
+
+//@ edition: 2021
+//@ revisions: a b
+//@ run-pass
+//@ check-run-results
+
+//@ normalize-stderr: "output" -> "emitted"
+//@[a] normalize-stderr: "first" -> "1st"
+//@[b] normalize-stderr: "second" -> "2nd"
+
+fn main() {
+    eprintln!("first output line");
+    eprintln!("second output line");
+}
-- 
cgit 1.4.1-3-g733a5


From 378dc0357dd9aba1527c54faf983c44b121a85b0 Mon Sep 17 00:00:00 2001
From: "许杰友 Jieyou Xu (Joe)" <39484203+jieyouxu@users.noreply.github.com>
Date: Sat, 28 Dec 2024 11:19:16 +0800
Subject: Disable `backtrace-debuginfo.rs` on windows-gnu

---
 tests/ui/runtime/backtrace-debuginfo.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'tests')

diff --git a/tests/ui/runtime/backtrace-debuginfo.rs b/tests/ui/runtime/backtrace-debuginfo.rs
index 9c4b15e64f5..da747ded44f 100644
--- a/tests/ui/runtime/backtrace-debuginfo.rs
+++ b/tests/ui/runtime/backtrace-debuginfo.rs
@@ -13,6 +13,10 @@
 //@ ignore-sgx no processes
 //@ ignore-fuchsia Backtrace not symbolized, trace different line alignment
 
+// FIXME(#117097): backtrace (possibly unwinding mechanism) seems to be different on at least
+// `i686-mingw` (32-bit windows-gnu)? cc #128911.
+//@ ignore-windows-gnu
+
 use std::env;
 
 #[path = "backtrace-debuginfo-aux.rs"] mod aux;
-- 
cgit 1.4.1-3-g733a5


From b77ab2dd90b8636a38cb34a3e6fe73dbb1e7b0f1 Mon Sep 17 00:00:00 2001
From: "许杰友 Jieyou Xu (Joe)" <39484203+jieyouxu@users.noreply.github.com>
Date: Sat, 28 Dec 2024 02:20:26 +0800
Subject: tests: migrate `libs-through-symlink` to rmake.rs

- Document test intent, backlink to #13890 and fix PR #13903.
- Fix the test logic: the `Makefile` version seems to not actually be
  exercising the "library search traverses symlink" logic, because the
  actual symlinked-to-library is present under the directory tree when
  `bar.rs` is compiled, because the `$(RUSTC)` invocation has an
  implicit `-L $(TMPDIR)`. The symlink itself was actually broken, i.e.
  it should've been `ln -nsf $(TMPDIR)/outdir/$(NAME) $(TMPDIR)` but it
  used `ln -nsf outdir/$(NAME) $(TMPDIR)`.

Co-authored-by: Oneirical <manchot@videotron.ca>
---
 src/tools/tidy/src/allowed_run_make_makefiles.txt |  1 -
 tests/run-make/libs-through-symlinks/Makefile     | 22 -----------
 tests/run-make/libs-through-symlinks/rmake.rs     | 48 +++++++++++++++++++++++
 3 files changed, 48 insertions(+), 23 deletions(-)
 delete mode 100644 tests/run-make/libs-through-symlinks/Makefile
 create mode 100644 tests/run-make/libs-through-symlinks/rmake.rs

(limited to 'tests')

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index f7ecb485152..7ab27667e28 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -2,7 +2,6 @@ run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/extern-fn-reachable/Makefile
 run-make/jobserver-error/Makefile
-run-make/libs-through-symlinks/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
 run-make/translation/Makefile
diff --git a/tests/run-make/libs-through-symlinks/Makefile b/tests/run-make/libs-through-symlinks/Makefile
deleted file mode 100644
index c6ff566a0e8..00000000000
--- a/tests/run-make/libs-through-symlinks/Makefile
+++ /dev/null
@@ -1,22 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# ignore-windows
-
-# The option -n for the AIX ln command has a different purpose than it does
-# on Linux. On Linux, the -n option is used to treat the destination path as
-# normal file if it is a symbolic link to a directory, which is the default
-# behavior of the AIX ln command.
-ifeq ($(UNAME),AIX)
-LN_FLAGS := -sf
-else
-LN_FLAGS := -nsf
-endif
-
-NAME := $(shell $(RUSTC) --print file-names foo.rs)
-
-all:
-	mkdir -p $(TMPDIR)/outdir
-	$(RUSTC) foo.rs -o $(TMPDIR)/outdir/$(NAME)
-	ln $(LN_FLAGS) outdir/$(NAME) $(TMPDIR)
-	RUSTC_LOG=rustc_metadata::loader $(RUSTC) bar.rs
diff --git a/tests/run-make/libs-through-symlinks/rmake.rs b/tests/run-make/libs-through-symlinks/rmake.rs
new file mode 100644
index 00000000000..4bb3d05abb7
--- /dev/null
+++ b/tests/run-make/libs-through-symlinks/rmake.rs
@@ -0,0 +1,48 @@
+//! Regression test for [rustc doesn't handle relative symlinks to libraries
+//! #13890](https://github.com/rust-lang/rust/issues/13890).
+//!
+//! This smoke test checks that for a given library search path `P`:
+//!
+//! - `rustc` is able to locate a library available via a symlink, where:
+//!     - the symlink is under the directory subtree of `P`,
+//!     - but the actual library is not (it's in a different directory subtree).
+//!
+//! For example:
+//!
+//! ```text
+//! actual_dir/
+//!     libfoo.rlib
+//! symlink_dir/  # $CWD set; rustc -L . bar.rs that depends on foo
+//!     libfoo.rlib --> ../actual_dir/libfoo.rlib
+//! ```
+//!
+//! Previously, if `rustc` was invoked with CWD set to `symlink_dir/`, it would fail to traverse the
+//! symlink to locate `actual_dir/libfoo.rlib`. This was originally fixed in
+//! <https://github.com/rust-lang/rust/pull/13903>.
+
+//@ ignore-cross-compile
+
+use run_make_support::{bare_rustc, cwd, path, rfs, rust_lib_name};
+
+fn main() {
+    let actual_lib_dir = path("actual_lib_dir");
+    let symlink_lib_dir = path("symlink_lib_dir");
+    rfs::create_dir_all(&actual_lib_dir);
+    rfs::create_dir_all(&symlink_lib_dir);
+
+    // NOTE: `bare_rustc` is used because it does not introduce an implicit `-L .` library search
+    // flag.
+    bare_rustc().input("foo.rs").output(actual_lib_dir.join(rust_lib_name("foo"))).run();
+
+    rfs::symlink_file(
+        actual_lib_dir.join(rust_lib_name("foo")),
+        symlink_lib_dir.join(rust_lib_name("foo")),
+    );
+
+    // Make rustc's $CWD be in the directory containing the symlink-to-lib.
+    bare_rustc()
+        .current_dir(&symlink_lib_dir)
+        .library_search_path(".")
+        .input(cwd().join("bar.rs"))
+        .run();
+}
-- 
cgit 1.4.1-3-g733a5


From b32591e5808ce7c59b58bd807dc1d26670cedb68 Mon Sep 17 00:00:00 2001
From: "许杰友 Jieyou Xu (Joe)" <39484203+jieyouxu@users.noreply.github.com>
Date: Wed, 25 Dec 2024 20:15:49 +0800
Subject: tests: migrate `branch-protection-check-IBT` to rmake.rs

- The Makefile version *never* ran because of Makefile syntax confusion.
- The test would've always failed because precompiled std is not built
  with `-Z cf-protection=branch`, but linkers require all input object
  files to indicate IBT support in order to enable IBT for the
  executable, which is not the case for std.
- Thus, the test input file is instead changed to a `no_std` + `no_core`
  program.

Co-authored-by: Jerry Wang <jerrylwang123@gmail.com>
Co-authored-by: Oneirical <manchot@videotron.ca>
---
 src/tools/tidy/src/allowed_run_make_makefiles.txt  |  1 -
 .../run-make/branch-protection-check-IBT/Makefile  | 21 ---------
 .../run-make/branch-protection-check-IBT/_rmake.rs | 29 ------------
 tests/run-make/branch-protection-check-IBT/main.rs |  8 ++--
 .../run-make/branch-protection-check-IBT/rmake.rs  | 53 ++++++++++++++++++++++
 5 files changed, 58 insertions(+), 54 deletions(-)
 delete mode 100644 tests/run-make/branch-protection-check-IBT/Makefile
 delete mode 100644 tests/run-make/branch-protection-check-IBT/_rmake.rs
 create mode 100644 tests/run-make/branch-protection-check-IBT/rmake.rs

(limited to 'tests')

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index f7ecb485152..2f898187022 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -1,4 +1,3 @@
-run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/extern-fn-reachable/Makefile
 run-make/jobserver-error/Makefile
diff --git a/tests/run-make/branch-protection-check-IBT/Makefile b/tests/run-make/branch-protection-check-IBT/Makefile
deleted file mode 100644
index ee0e034627f..00000000000
--- a/tests/run-make/branch-protection-check-IBT/Makefile
+++ /dev/null
@@ -1,21 +0,0 @@
-# Check for GNU Property Note
-
-include ../tools.mk
-
-# How to run this
-# python3 x.py test --target x86_64-unknown-linux-gnu  tests/run-make/branch-protection-check-IBT/
-
-# only-x86_64
-
-# ignore-test
-# FIXME(jieyouxu): This test never runs because the `ifeq` check on line 17
-# compares `x86` to `x86_64`, which always evaluates to false.
-# When the test does run, the compilation does not include `.note.gnu.property`.
-# See https://github.com/rust-lang/rust/pull/126720 for more information.
-
-all:
-ifeq ($(filter x86,$(LLVM_COMPONENTS)),x86_64)
-	$(RUSTC) --target x86_64-unknown-linux-gnu -Z cf-protection=branch -L$(TMPDIR) -C link-args='-nostartfiles'  -C save-temps  ./main.rs -o $(TMPDIR)/rsmain
-	 readelf -nW $(TMPDIR)/rsmain | $(CGREP) -e ".note.gnu.property"
-endif
-
diff --git a/tests/run-make/branch-protection-check-IBT/_rmake.rs b/tests/run-make/branch-protection-check-IBT/_rmake.rs
deleted file mode 100644
index 91151408785..00000000000
--- a/tests/run-make/branch-protection-check-IBT/_rmake.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Check for GNU Property Note
-
-// How to run this
-// python3 x.py test --target x86_64-unknown-linux-gnu  tests/run-make/branch-protection-check-IBT/
-
-//@ only-x86_64
-
-//@ ignore-test
-// FIXME(jieyouxu): see the FIXME in the Makefile
-
-use run_make_support::{cwd, env_var, llvm_readobj, rustc};
-
-fn main() {
-    let llvm_components = env_var("LLVM_COMPONENTS");
-    if !format!(" {llvm_components} ").contains(" x86 ") {
-        return;
-    }
-
-    rustc()
-        .input("main.rs")
-        .target("x86_64-unknown-linux-gnu")
-        .arg("-Zcf-protection=branch")
-        .arg(format!("-L{}", cwd().display()))
-        .arg("-Clink-args=-nostartfiles")
-        .arg("-Csave-temps")
-        .run();
-
-    llvm_readobj().arg("-nW").input("main").run().assert_stdout_contains(".note.gnu.property");
-}
diff --git a/tests/run-make/branch-protection-check-IBT/main.rs b/tests/run-make/branch-protection-check-IBT/main.rs
index ad379d6ea43..445b8795134 100644
--- a/tests/run-make/branch-protection-check-IBT/main.rs
+++ b/tests/run-make/branch-protection-check-IBT/main.rs
@@ -1,3 +1,5 @@
-fn main() {
-    println!("hello world");
-}
+#![feature(no_core)]
+#![allow(internal_features)]
+#![no_core]
+#![no_std]
+#![no_main]
diff --git a/tests/run-make/branch-protection-check-IBT/rmake.rs b/tests/run-make/branch-protection-check-IBT/rmake.rs
new file mode 100644
index 00000000000..73109df12ae
--- /dev/null
+++ b/tests/run-make/branch-protection-check-IBT/rmake.rs
@@ -0,0 +1,53 @@
+// ignore-tidy-linelength
+//! A basic smoke test to check for GNU Property Note to see that for `x86_64` targets when [`-Z
+//! cf-protection=branch`][intel-cet-tracking-issue] is requested, that the
+//!
+//! ```text
+//! NT_GNU_PROPERTY_TYPE_0 Properties: x86 feature: IBT
+//! ```
+//!
+//! Intel Indirect Branch Tracking (IBT) property is emitted. This was generated in
+//! <https://github.com/rust-lang/rust/pull/110304> in order to address
+//! <https://github.com/rust-lang/rust/issues/103001>.
+//!
+//! Note that the precompiled std currently is not compiled with `-Z cf-protection=branch`!
+//!
+//! In particular, it is expected that:
+//!
+//! > IBT to only be enabled for the process if `.note.gnu.property` indicates that the executable
+//! > was compiled with IBT support and the linker to only tell that IBT is supported if all input
+//! > object files indicate that they support IBT, which in turn requires the standard library to be
+//! > compiled with IBT enabled.
+//!
+//! Note that Intel IBT (Indirect Branch Tracking) is not to be confused with Arm's BTI (Branch
+//! Target Identification). See below for link to Intel IBT docs.
+//!
+//! ## Related links
+//!
+//! - [Tracking Issue for Intel Control Enforcement Technology (CET)][intel-cet-tracking-issue]
+//! - Zulip question about this test:
+//! <https://rust-lang.zulipchat.com/#narrow/channel/182449-t-compiler.2Fhelp/topic/.E2.9C.94.20Branch.20protection.20and.20.60.2Enote.2Egnu.2Eproperty.60>
+//! - Intel IBT docs:
+//!   <https://edc.intel.com/content/www/us/en/design/ipla/software-development-platforms/client/platforms/alder-lake-desktop/12th-generation-intel-core-processors-datasheet-volume-1-of-2/006/indirect-branch-tracking/>
+//!
+//! [intel-cet-tracking-issue]: https://github.com/rust-lang/rust/issues/93754
+
+//@ needs-llvm-components: x86
+
+// FIXME(#93754): increase the test coverage of this test.
+//@ only-x86_64-unknown-linux-gnu
+//@ ignore-cross-compile
+
+use run_make_support::{bare_rustc, llvm_readobj};
+
+fn main() {
+    // `main.rs` is `#![no_std]` to not pull in the currently not-compiled-with-IBT precompiled std.
+    bare_rustc()
+        .input("main.rs")
+        .target("x86_64-unknown-linux-gnu")
+        .arg("-Zcf-protection=branch")
+        .arg("-Clink-args=-nostartfiles")
+        .run();
+
+    llvm_readobj().arg("-nW").input("main").run().assert_stdout_contains(".note.gnu.property");
+}
-- 
cgit 1.4.1-3-g733a5


From d6c73ebbf3df1331eb60a6fba1f4b0bd03274f49 Mon Sep 17 00:00:00 2001
From: Alex Gaynor <alex.gaynor@gmail.com>
Date: Sat, 28 Dec 2024 10:14:46 -0500
Subject: Added a codegen test for optimization with const arrays

Closes #107208
---
 tests/codegen/const-array.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 tests/codegen/const-array.rs

(limited to 'tests')

diff --git a/tests/codegen/const-array.rs b/tests/codegen/const-array.rs
new file mode 100644
index 00000000000..f2b331c315d
--- /dev/null
+++ b/tests/codegen/const-array.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -O
+
+#![crate_type = "lib"]
+
+const LUT: [u8; 2] = [1, 1];
+
+// CHECK-LABEL: @decode
+#[no_mangle]
+pub fn decode(i: u8) -> u8 {
+    // CHECK: start:
+    // CHECK-NEXT: icmp
+    // CHECK-NEXT: select
+    // CHECK-NEXT: ret
+    if i < 2 { LUT[i as usize] } else { 2 }
+}
-- 
cgit 1.4.1-3-g733a5


From 00bf8717e3ab5273b3ec587e3a241408cca23935 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 28 Dec 2024 20:54:00 +0100
Subject: Add GUI test for item info elements color

---
 tests/rustdoc-gui/item-info.goml | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

(limited to 'tests')

diff --git a/tests/rustdoc-gui/item-info.goml b/tests/rustdoc-gui/item-info.goml
index b5b0052fe61..647a2fd290d 100644
--- a/tests/rustdoc-gui/item-info.goml
+++ b/tests/rustdoc-gui/item-info.goml
@@ -45,3 +45,26 @@ compare-elements-css: (
     "#main-content > .item-info .stab:nth-of-type(2)",
     ["height"],
 )
+
+// Now checking the text color and the links color.
+show-text: true
+include: "utils.goml"
+go-to: "file://" + |DOC_PATH| + "/lib2/trait.Trait.html"
+
+call-function: ("switch-theme", {"theme": "ayu"})
+assert-css: (".item-info .stab", {"color": "rgb(197, 197, 197)"}, ALL)
+assert-css: (".item-info .stab strong", {"color": "rgb(197, 197, 197)"}, ALL)
+assert-css: (".item-info .stab span", {"color": "rgb(197, 197, 197)"}, ALL)
+assert-css: (".item-info .stab a", {"color": "rgb(57, 175, 215)"}, ALL)
+
+call-function: ("switch-theme", {"theme": "dark"})
+assert-css: (".item-info .stab", {"color": "rgb(221, 221, 221)"}, ALL)
+assert-css: (".item-info .stab strong", {"color": "rgb(221, 221, 221)"}, ALL)
+assert-css: (".item-info .stab span", {"color": "rgb(221, 221, 221)"}, ALL)
+assert-css: (".item-info .stab a", {"color": "rgb(210, 153, 29)"}, ALL)
+
+call-function: ("switch-theme", {"theme": "light"})
+assert-css: (".item-info .stab", {"color": "rgb(0, 0, 0)"}, ALL)
+assert-css: (".item-info .stab strong", {"color": "rgb(0, 0, 0)"}, ALL)
+assert-css: (".item-info .stab span", {"color": "rgb(0, 0, 0)"}, ALL)
+assert-css: (".item-info .stab a", {"color": "rgb(56, 115, 173)"}, ALL)
-- 
cgit 1.4.1-3-g733a5


From 71e3ea35b175fa50e5fcd033980666548b718081 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Sun, 29 Dec 2024 03:31:37 +0000
Subject: Add codegen test for issue 63646

---
 tests/codegen/range_to_inclusive.rs | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 tests/codegen/range_to_inclusive.rs

(limited to 'tests')

diff --git a/tests/codegen/range_to_inclusive.rs b/tests/codegen/range_to_inclusive.rs
new file mode 100644
index 00000000000..f3001897f88
--- /dev/null
+++ b/tests/codegen/range_to_inclusive.rs
@@ -0,0 +1,28 @@
+//! Test that `RangeTo` and `RangeToInclusive` generate identical
+//! (and optimal) code; #63646
+//@ compile-flags: -O -Zmerge-functions=disabled
+#![crate_type = "lib"]
+
+#[no_mangle]
+// CHECK-LABEL: range_to(
+pub fn range_to(a: i32, mut b: i32) -> i32 {
+    // CHECK: %1 = and i32 %0, %a
+    // CHECK-NEXT: ret i32 %1
+    for _ in 0..65 {
+        b &= a;
+    }
+
+    b
+}
+
+#[no_mangle]
+// CHECK-LABEL: range_to_inclusive(
+pub fn range_to_inclusive(a: i32, mut b: i32) -> i32 {
+    // CHECK: %1 = and i32 %0, %a
+    // CHECK-NEXT: ret i32 %1
+    for _ in 0..=64 {
+        b &= a;
+    }
+
+    b
+}
-- 
cgit 1.4.1-3-g733a5


From dab1c57723d4ab53b9279801f6a27db94bdec98a Mon Sep 17 00:00:00 2001
From: Alex Gaynor <alex.gaynor@gmail.com>
Date: Sun, 29 Dec 2024 08:02:40 -0600
Subject: Added codegen test for elidings bounds check when indexes are
 manually checked

Closes #55147
---
 tests/codegen/slice-indexing.rs | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

(limited to 'tests')

diff --git a/tests/codegen/slice-indexing.rs b/tests/codegen/slice-indexing.rs
index 3d284148db2..75112bb0c24 100644
--- a/tests/codegen/slice-indexing.rs
+++ b/tests/codegen/slice-indexing.rs
@@ -60,3 +60,40 @@ pub unsafe fn str_get_unchecked_mut_by_range(x: &mut str, r: Range<usize>) -> &m
     // CHECK: sub nuw i64
     x.get_unchecked_mut(r)
 }
+
+// CHECK-LABEL: @slice_repeated_indexing(
+#[no_mangle]
+pub fn slice_repeated_indexing(dst: &mut [u8], offset: usize) {
+    let mut i = offset;
+    // CHECK: panic_bounds_check
+    dst[i] = 1;
+    i += 1;
+    // CHECK: panic_bounds_check
+    dst[i] = 2;
+    i += 1;
+    // CHECK: panic_bounds_check
+    dst[i] = 3;
+    i += 1;
+    // CHECK: panic_bounds_check
+    dst[i] = 4;
+}
+
+// CHECK-LABEL: @slice_repeated_indexing_coalesced(
+#[no_mangle]
+pub fn slice_repeated_indexing_coalesced(dst: &mut [u8], offset: usize) {
+    let mut i = offset;
+    if i.checked_add(4).unwrap() <= dst.len() {
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 1;
+        i += 1;
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 2;
+        i += 1;
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 3;
+        i += 1;
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 4;
+    }
+    // CHECK: ret
+}
-- 
cgit 1.4.1-3-g733a5


From 4c279fb7af22ac24833464a5d7ffa56ca79a251d Mon Sep 17 00:00:00 2001
From: Horu <73709188+HigherOrderLogic@users.noreply.github.com>
Date: Mon, 30 Dec 2024 14:56:21 +0700
Subject: chore: fix typos

---
 src/bootstrap/src/core/build_steps/test.rs             | 2 +-
 src/bootstrap/src/lib.rs                               | 2 +-
 src/bootstrap/src/utils/tarball.rs                     | 2 +-
 src/ci/scripts/install-clang.sh                        | 2 +-
 src/tools/linkchecker/main.rs                          | 2 +-
 src/tools/nix-dev-shell/envrc-flake                    | 2 +-
 src/tools/nix-dev-shell/envrc-shell                    | 2 +-
 tests/ui/associated-types/associated-types-eq-2.rs     | 2 +-
 tests/ui/associated-types/project-defer-unification.rs | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'tests')

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index fe2dd9cc5f3..6aa6e4e277d 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -2637,7 +2637,7 @@ fn prepare_cargo_test(
 ) -> BootstrapCommand {
     let mut cargo = cargo.into();
 
-    // Propegate `--bless` if it has not already been set/unset
+    // Propagate `--bless` if it has not already been set/unset
     // Any tools that want to use this should bless if `RUSTC_BLESS` is set to
     // anything other than `0`.
     if builder.config.cmd.bless() && !cargo.get_envs().any(|v| v.0 == "RUSTC_BLESS") {
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index eff259212c5..4cc812829f9 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -1691,7 +1691,7 @@ Executed at: {executed_at}"#,
             }
         }
         if let Ok(()) = fs::hard_link(&src, dst) {
-            // Attempt to "easy copy" by creating a hard link (symlinks are priviledged on windows),
+            // Attempt to "easy copy" by creating a hard link (symlinks are privileged on windows),
             // but if that fails just fall back to a slow `copy` operation.
         } else {
             if let Err(e) = fs::copy(&src, dst) {
diff --git a/src/bootstrap/src/utils/tarball.rs b/src/bootstrap/src/utils/tarball.rs
index 3c6c7a7fa18..843ea65e838 100644
--- a/src/bootstrap/src/utils/tarball.rs
+++ b/src/bootstrap/src/utils/tarball.rs
@@ -1,7 +1,7 @@
 //! Facilitates the management and generation of tarballs.
 //!
 //! Tarballs efficiently hold Rust compiler build artifacts and
-//! capture a snapshot of each boostrap stage.
+//! capture a snapshot of each bootstrap stage.
 //! In uplifting, a tarball from Stage N captures essential components
 //! to assemble Stage N + 1 compiler.
 
diff --git a/src/ci/scripts/install-clang.sh b/src/ci/scripts/install-clang.sh
index 6103aa61248..5522095e304 100755
--- a/src/ci/scripts/install-clang.sh
+++ b/src/ci/scripts/install-clang.sh
@@ -15,7 +15,7 @@ LLVM_VERSION="18.1.4"
 
 if isMacOS; then
     # FIXME: This is the latest pre-built version of LLVM that's available for
-    # x86_64 MacOS. We may want to consider bulding our own LLVM binaries
+    # x86_64 MacOS. We may want to consider building our own LLVM binaries
     # instead, or set `USE_XCODE_CLANG` like AArch64 does.
     LLVM_VERSION="15.0.7"
 
diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs
index 833e41df537..570b2c374c0 100644
--- a/src/tools/linkchecker/main.rs
+++ b/src/tools/linkchecker/main.rs
@@ -8,7 +8,7 @@
 //!
 //! Currently uses a combination of HTML parsing to
 //! extract the `href` and `id` attributes,
-//! and regex search on the orignal markdown to handle intra-doc links.
+//! and regex search on the original markdown to handle intra-doc links.
 //!
 //! These values are then translated to file URLs if possible and then the
 //! destination is asserted to exist.
diff --git a/src/tools/nix-dev-shell/envrc-flake b/src/tools/nix-dev-shell/envrc-flake
index 849ed1f4fc5..f3e5442b86b 100644
--- a/src/tools/nix-dev-shell/envrc-flake
+++ b/src/tools/nix-dev-shell/envrc-flake
@@ -1,4 +1,4 @@
-# If you want to use this as an .envrc file to create a shell with necessery components 
+# If you want to use this as an .envrc file to create a shell with necessary components 
 # to develop rustc, use the following command in the root of the rusr checkout:
 #	
 # ln -s ./src/tools/nix-dev-shell/envrc-flake ./.envrc && nix flake update --flake ./src/tools/nix-dev-shell
diff --git a/src/tools/nix-dev-shell/envrc-shell b/src/tools/nix-dev-shell/envrc-shell
index d8f900fe86a..4080d7d5384 100644
--- a/src/tools/nix-dev-shell/envrc-shell
+++ b/src/tools/nix-dev-shell/envrc-shell
@@ -1,4 +1,4 @@
-# If you want to use this as an .envrc file to create a shell with necessery components 
+# If you want to use this as an .envrc file to create a shell with necessary components 
 # to develop rustc, use the following command in the root of the rusr checkout:
 #	
 # ln -s ./src/tools/nix-dev-shell/envrc-shell ./.envrc
diff --git a/tests/ui/associated-types/associated-types-eq-2.rs b/tests/ui/associated-types/associated-types-eq-2.rs
index 88eb2981061..9d2860d1b30 100644
--- a/tests/ui/associated-types/associated-types-eq-2.rs
+++ b/tests/ui/associated-types/associated-types-eq-2.rs
@@ -33,7 +33,7 @@ fn baz<I: Tr1>(_x: &<I as Tr1<A=Bar>>::A) {}
 trait Tr2<T1, T2, T3> {
 }
 
-// Test for when wrongly specifed equality constraint's ident
+// Test for when wrongly specified equality constraint's ident
 // matches some generic param's ident
 // (Note: E0229 is emitted only for the first erroneous equality
 // constraint (T2) not for any subequent ones (e.g. T3))
diff --git a/tests/ui/associated-types/project-defer-unification.rs b/tests/ui/associated-types/project-defer-unification.rs
index cec088496fd..b51228ef411 100644
--- a/tests/ui/associated-types/project-defer-unification.rs
+++ b/tests/ui/associated-types/project-defer-unification.rs
@@ -93,7 +93,7 @@ where Pix: Pixel<Subpixel=u8> + 'static,
 
     let mut indices: ImageBuffer<_,Vec<_>> = loop { };
     for (pixel, idx) in image.pixels().zip(indices.pixels_mut()) {
-        // failured occurred here ^^ because we were requiring that we
+        // failure occurred here ^^ because we were requiring that we
         // could project Pixel or Subpixel from `T_indices` (type of
         // `indices`), but the type is insufficiently constrained
         // until we reach the return below.
-- 
cgit 1.4.1-3-g733a5


From 92e8e84e7d85a17e8c32a9c6874fa5e655c16872 Mon Sep 17 00:00:00 2001
From: "许杰友 Jieyou Xu (Joe)" <39484203+jieyouxu@users.noreply.github.com>
Date: Mon, 30 Dec 2024 05:55:57 +0800
Subject: tests: add basic test coverage for cli flag `--crate-type`

---
 .../crate-type-flag.empty_crate_type.stderr        |  2 +
 .../crate-type-flag.proc_underscore_macro.stderr   |  2 +
 tests/ui/invalid-compile-flags/crate-type-flag.rs  | 61 ++++++++++++++++++++++
 .../crate-type-flag.unknown.stderr                 |  2 +
 4 files changed, 67 insertions(+)
 create mode 100644 tests/ui/invalid-compile-flags/crate-type-flag.empty_crate_type.stderr
 create mode 100644 tests/ui/invalid-compile-flags/crate-type-flag.proc_underscore_macro.stderr
 create mode 100644 tests/ui/invalid-compile-flags/crate-type-flag.rs
 create mode 100644 tests/ui/invalid-compile-flags/crate-type-flag.unknown.stderr

(limited to 'tests')

diff --git a/tests/ui/invalid-compile-flags/crate-type-flag.empty_crate_type.stderr b/tests/ui/invalid-compile-flags/crate-type-flag.empty_crate_type.stderr
new file mode 100644
index 00000000000..0f8772024df
--- /dev/null
+++ b/tests/ui/invalid-compile-flags/crate-type-flag.empty_crate_type.stderr
@@ -0,0 +1,2 @@
+error: unknown crate type: ``
+
diff --git a/tests/ui/invalid-compile-flags/crate-type-flag.proc_underscore_macro.stderr b/tests/ui/invalid-compile-flags/crate-type-flag.proc_underscore_macro.stderr
new file mode 100644
index 00000000000..a4a97416996
--- /dev/null
+++ b/tests/ui/invalid-compile-flags/crate-type-flag.proc_underscore_macro.stderr
@@ -0,0 +1,2 @@
+error: unknown crate type: `proc_macro`
+
diff --git a/tests/ui/invalid-compile-flags/crate-type-flag.rs b/tests/ui/invalid-compile-flags/crate-type-flag.rs
new file mode 100644
index 00000000000..42bd72cbfbf
--- /dev/null
+++ b/tests/ui/invalid-compile-flags/crate-type-flag.rs
@@ -0,0 +1,61 @@
+//! Check that `rustc`'s `--crate-type` flag accepts `--crate-type=<valid_type>` as well as the
+//! multi-value version `--crate-type=<valid_type_1>,<valid_type_2>`.
+//!
+//! This test does not try to check if the output artifacts are valid.
+
+// FIXME(#132309): add a proper `supports-crate-type` directive.
+
+// Single valid crate types should pass
+//@ revisions: lib rlib staticlib dylib cdylib bin proc_dash_macro
+
+//@[lib] compile-flags: --crate-type=lib
+//@[lib] check-pass
+
+//@[rlib] compile-flags: --crate-type=rlib
+//@[rlib] check-pass
+
+//@[staticlib] compile-flags: --crate-type=staticlib
+//@[staticlib] check-pass
+
+//@[dylib] ignore-musl (dylibs are not supported)
+//@[dylib] ignore-wasm (dylibs are not supported)
+//@[dylib] compile-flags: --crate-type=dylib
+//@[dylib] check-pass
+
+//@[cdylib] ignore-musl (cdylibs are not supported)
+//@[cdylib] compile-flags: --crate-type=cdylib
+//@[cdylib] check-pass
+
+//@[bin] compile-flags: --crate-type=bin
+//@[bin] check-pass
+
+//@[proc_dash_macro] ignore-wasm (proc-macro is not supported)
+//@[proc_dash_macro] compile-flags: --crate-type=proc-macro
+//@[proc_dash_macro] check-pass
+
+//@ revisions: multivalue multivalue_combined
+
+//@[multivalue] compile-flags: --crate-type=lib,rlib,staticlib
+//@[multivalue] check-pass
+
+//@[multivalue_combined] ignore-musl (dylibs are not supported)
+//@[multivalue_combined] ignore-wasm (dylibs are not supported)
+//@[multivalue_combined] compile-flags: --crate-type=lib,rlib,staticlib --crate-type=dylib
+//@[multivalue_combined] check-pass
+
+// `proc-macro` is accepted, but `proc_macro` is not.
+//@ revisions: proc_underscore_macro
+//@[proc_underscore_macro] compile-flags: --crate-type=proc_macro
+//@[proc_underscore_macro] error-pattern: "unknown crate type: `proc_macro`"
+
+// Empty `--crate-type` not accepted.
+//@ revisions: empty_crate_type
+//@[empty_crate_type] compile-flags: --crate-type=
+//@[empty_crate_type] error-pattern: "unknown crate type: ``"
+
+// Random unknown crate type. Also check that we can handle non-ASCII.
+//@ revisions: unknown
+//@[unknown] compile-flags: --crate-type=🤡
+//@[unknown] error-pattern: "unknown crate type: `🤡`"
+
+fn main() {}
diff --git a/tests/ui/invalid-compile-flags/crate-type-flag.unknown.stderr b/tests/ui/invalid-compile-flags/crate-type-flag.unknown.stderr
new file mode 100644
index 00000000000..7fb0f09a1af
--- /dev/null
+++ b/tests/ui/invalid-compile-flags/crate-type-flag.unknown.stderr
@@ -0,0 +1,2 @@
+error: unknown crate type: `🤡`
+
-- 
cgit 1.4.1-3-g733a5


From 62c3c9a5ae2072a04ba5f5d84055d38dcd043427 Mon Sep 17 00:00:00 2001
From: Davis Muro <davis.ray.muro@gmail.com>
Date: Sat, 28 Dec 2024 20:47:07 -0800
Subject: add suggestion for wrongly ordered format parameters

---
 compiler/rustc_builtin_macros/messages.ftl         |  2 ++
 compiler/rustc_builtin_macros/src/errors.rs        | 11 +++++++
 compiler/rustc_builtin_macros/src/format.rs        |  7 +++++
 compiler/rustc_parse_format/src/lib.rs             | 35 ++++++++++++++++++++++
 .../suggest-wrongly-order-format-parameter.fixed   | 25 ++++++++++++++++
 .../fmt/suggest-wrongly-order-format-parameter.rs  | 25 ++++++++++++++++
 .../suggest-wrongly-order-format-parameter.stderr  | 35 ++++++++++++++++++++++
 7 files changed, 140 insertions(+)
 create mode 100644 tests/ui/fmt/suggest-wrongly-order-format-parameter.fixed
 create mode 100644 tests/ui/fmt/suggest-wrongly-order-format-parameter.rs
 create mode 100644 tests/ui/fmt/suggest-wrongly-order-format-parameter.stderr

(limited to 'tests')

diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 7a31d2a2239..4cac7cb93f5 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -197,6 +197,8 @@ builtin_macros_format_redundant_args = redundant {$n ->
 
 builtin_macros_format_remove_raw_ident = remove the `r#`
 
+builtin_macros_format_reorder_format_parameter = did you mean `{$replacement}`?
+
 builtin_macros_format_requires_string = requires at least a format string argument
 
 builtin_macros_format_string_invalid = invalid format string: {$desc}
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index 1abdfdb9c65..6213bd802c7 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -618,6 +618,17 @@ pub(crate) enum InvalidFormatStringSuggestion {
         #[primary_span]
         span: Span,
     },
+    #[suggestion(
+        builtin_macros_format_reorder_format_parameter,
+        code = "{replacement}",
+        style = "verbose",
+        applicability = "machine-applicable"
+    )]
+    ReorderFormatParameter {
+        #[primary_span]
+        span: Span,
+        replacement: String,
+    },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index 528eb7725f5..d07a0c3a51b 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -316,6 +316,13 @@ fn make_format_args(
                     e.sugg_ = Some(errors::InvalidFormatStringSuggestion::RemoveRawIdent { span })
                 }
             }
+            parse::Suggestion::ReorderFormatParameter(span, replacement) => {
+                let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
+                e.sugg_ = Some(errors::InvalidFormatStringSuggestion::ReorderFormatParameter {
+                    span,
+                    replacement,
+                });
+            }
         }
         let guar = ecx.dcx().emit_err(e);
         return ExpandResult::Ready(Err(guar));
diff --git a/compiler/rustc_parse_format/src/lib.rs b/compiler/rustc_parse_format/src/lib.rs
index 1716f417969..9eb335cb34c 100644
--- a/compiler/rustc_parse_format/src/lib.rs
+++ b/compiler/rustc_parse_format/src/lib.rs
@@ -221,6 +221,11 @@ pub enum Suggestion {
     /// Remove `r#` from identifier:
     /// `format!("{r#foo}")` -> `format!("{foo}")`
     RemoveRawIdent(InnerSpan),
+    /// Reorder format parameter:
+    /// `format!("{foo:?#}")` -> `format!("{foo:#?}")`
+    /// `format!("{foo:?x}")` -> `format!("{foo:x?}")`
+    /// `format!("{foo:?X}")` -> `format!("{foo:X?}")`
+    ReorderFormatParameter(InnerSpan, string::String),
 }
 
 /// The parser structure for interpreting the input format string. This is
@@ -731,6 +736,12 @@ impl<'a> Parser<'a> {
             }
         } else if self.consume('?') {
             spec.ty = "?";
+            if let Some(&(_, maybe)) = self.cur.peek() {
+                match maybe {
+                    '#' | 'x' | 'X' => self.suggest_format_parameter(maybe),
+                    _ => (),
+                }
+            }
         } else {
             spec.ty = self.word();
             if !spec.ty.is_empty() {
@@ -932,6 +943,30 @@ impl<'a> Parser<'a> {
             }
         }
     }
+
+    fn suggest_format_parameter(&mut self, c: char) {
+        let replacement = match c {
+            '#' => "#?",
+            'x' => "x?",
+            'X' => "X?",
+            _ => return,
+        };
+        let Some(pos) = self.consume_pos(c) else {
+            return;
+        };
+
+        let span = self.span(pos - 1, pos + 1);
+        let pos = self.to_span_index(pos);
+
+        self.errors.insert(0, ParseError {
+            description: format!("expected `}}`, found `{c}`"),
+            note: None,
+            label: "expected `'}'`".into(),
+            span: pos.to(pos),
+            secondary_label: None,
+            suggestion: Suggestion::ReorderFormatParameter(span, format!("{replacement}")),
+        })
+    }
 }
 
 /// Finds the indices of all characters that have been processed and differ between the actual
diff --git a/tests/ui/fmt/suggest-wrongly-order-format-parameter.fixed b/tests/ui/fmt/suggest-wrongly-order-format-parameter.fixed
new file mode 100644
index 00000000000..a080a65854a
--- /dev/null
+++ b/tests/ui/fmt/suggest-wrongly-order-format-parameter.fixed
@@ -0,0 +1,25 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/129966
+//!
+//! Ensure we provide suggestion for wrongly ordered format parameters.
+
+//@ run-rustfix
+#![allow(dead_code)]
+
+#[derive(Debug)]
+struct Foo(u8, u8);
+
+fn main() {
+    let f = Foo(1, 2);
+
+    println!("{f:#?}");
+    //~^ ERROR invalid format string: expected `}`, found `#`
+    //~| HELP did you mean `#?`?
+
+    println!("{f:x?}");
+    //~^ ERROR invalid format string: expected `}`, found `x`
+    //~| HELP did you mean `x?`?
+
+    println!("{f:X?}");
+    //~^ ERROR invalid format string: expected `}`, found `X`
+    //~| HELP did you mean `X?`?
+}
diff --git a/tests/ui/fmt/suggest-wrongly-order-format-parameter.rs b/tests/ui/fmt/suggest-wrongly-order-format-parameter.rs
new file mode 100644
index 00000000000..830dafd4479
--- /dev/null
+++ b/tests/ui/fmt/suggest-wrongly-order-format-parameter.rs
@@ -0,0 +1,25 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/129966
+//!
+//! Ensure we provide suggestion for wrongly ordered format parameters.
+
+//@ run-rustfix
+#![allow(dead_code)]
+
+#[derive(Debug)]
+struct Foo(u8, u8);
+
+fn main() {
+    let f = Foo(1, 2);
+
+    println!("{f:?#}");
+    //~^ ERROR invalid format string: expected `}`, found `#`
+    //~| HELP did you mean `#?`?
+
+    println!("{f:?x}");
+    //~^ ERROR invalid format string: expected `}`, found `x`
+    //~| HELP did you mean `x?`?
+
+    println!("{f:?X}");
+    //~^ ERROR invalid format string: expected `}`, found `X`
+    //~| HELP did you mean `X?`?
+}
diff --git a/tests/ui/fmt/suggest-wrongly-order-format-parameter.stderr b/tests/ui/fmt/suggest-wrongly-order-format-parameter.stderr
new file mode 100644
index 00000000000..fe693d2e904
--- /dev/null
+++ b/tests/ui/fmt/suggest-wrongly-order-format-parameter.stderr
@@ -0,0 +1,35 @@
+error: invalid format string: expected `}`, found `#`
+  --> $DIR/suggest-wrongly-order-format-parameter.rs:14:19
+   |
+LL |     println!("{f:?#}");
+   |                   ^ expected `'}'` in format string
+   |
+help: did you mean `#?`?
+   |
+LL |     println!("{f:#?}");
+   |                  ~~
+
+error: invalid format string: expected `}`, found `x`
+  --> $DIR/suggest-wrongly-order-format-parameter.rs:18:19
+   |
+LL |     println!("{f:?x}");
+   |                   ^ expected `'}'` in format string
+   |
+help: did you mean `x?`?
+   |
+LL |     println!("{f:x?}");
+   |                  ~~
+
+error: invalid format string: expected `}`, found `X`
+  --> $DIR/suggest-wrongly-order-format-parameter.rs:22:19
+   |
+LL |     println!("{f:?X}");
+   |                   ^ expected `'}'` in format string
+   |
+help: did you mean `X?`?
+   |
+LL |     println!("{f:X?}");
+   |                  ~~
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7d5ff8b8bd5b1bf4721fd9a3e34b2e90e670be09 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Mon, 30 Dec 2024 11:25:00 +0000
Subject: Windows: Enable issue 70093 link tests

---
 src/tools/tidy/src/issues.txt                        |  2 --
 .../issue-70093/issue-70093-link-directives.rs       | 10 ----------
 tests/ui/link-native-libs/issue-70093/issue-70093.rs | 10 ----------
 .../link-native-libs/issue-70093/link-directives.rs  |  9 +++++++++
 .../issue-70093/link-native-libraries.rs             | 20 ++++++++++++++++++++
 5 files changed, 29 insertions(+), 22 deletions(-)
 delete mode 100644 tests/ui/link-native-libs/issue-70093/issue-70093-link-directives.rs
 delete mode 100644 tests/ui/link-native-libs/issue-70093/issue-70093.rs
 create mode 100644 tests/ui/link-native-libs/issue-70093/link-directives.rs
 create mode 100644 tests/ui/link-native-libs/issue-70093/link-native-libraries.rs

(limited to 'tests')

diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 25cd32063aa..54de2ef8314 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -2710,8 +2710,6 @@ ui/limits/issue-75158-64.rs
 ui/link-native-libs/issue-109144.rs
 ui/link-native-libs/issue-43925.rs
 ui/link-native-libs/issue-43926.rs
-ui/link-native-libs/issue-70093/issue-70093-link-directives.rs
-ui/link-native-libs/issue-70093/issue-70093.rs
 ui/linkage-attr/auxiliary/issue-12133-dylib.rs
 ui/linkage-attr/auxiliary/issue-12133-dylib2.rs
 ui/linkage-attr/auxiliary/issue-12133-rlib.rs
diff --git a/tests/ui/link-native-libs/issue-70093/issue-70093-link-directives.rs b/tests/ui/link-native-libs/issue-70093/issue-70093-link-directives.rs
deleted file mode 100644
index 9c60affbccd..00000000000
--- a/tests/ui/link-native-libs/issue-70093/issue-70093-link-directives.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-//@ compile-flags: -Zlink-directives=no
-//@ ignore-windows - this will probably only work on unixish systems
-//@ ignore-fuchsia - missing __libc_start_main for some reason (#84733)
-//@ ignore-cross-compile - default-linker-libraries=yes doesn't play well with cross compiling
-
-#[link(name = "some-random-non-existent-library", kind = "static")]
-extern "C" {}
-
-fn main() {}
diff --git a/tests/ui/link-native-libs/issue-70093/issue-70093.rs b/tests/ui/link-native-libs/issue-70093/issue-70093.rs
deleted file mode 100644
index 86974239338..00000000000
--- a/tests/ui/link-native-libs/issue-70093/issue-70093.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-//@ compile-flags: -Zlink-native-libraries=no -Cdefault-linker-libraries=yes
-//@ ignore-windows - this will probably only work on unixish systems
-//@ ignore-fuchsia - missing __libc_start_main for some reason (#84733)
-//@ ignore-cross-compile - default-linker-libraries=yes doesn't play well with cross compiling
-
-#[link(name = "some-random-non-existent-library", kind = "static")]
-extern "C" {}
-
-fn main() {}
diff --git a/tests/ui/link-native-libs/issue-70093/link-directives.rs b/tests/ui/link-native-libs/issue-70093/link-directives.rs
new file mode 100644
index 00000000000..c67536d39e7
--- /dev/null
+++ b/tests/ui/link-native-libs/issue-70093/link-directives.rs
@@ -0,0 +1,9 @@
+//@ run-pass
+//@ compile-flags: -Zlink-directives=no
+//@ ignore-fuchsia - missing __libc_start_main for some reason (#84733)
+//@ ignore-cross-compile - default-linker-libraries=yes doesn't play well with cross compiling
+
+#[link(name = "some-random-non-existent-library", kind = "static")]
+extern "C" {}
+
+fn main() {}
diff --git a/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs b/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs
new file mode 100644
index 00000000000..3e14e33ba39
--- /dev/null
+++ b/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs
@@ -0,0 +1,20 @@
+//@ run-pass
+//@ compile-flags: -Zlink-native-libraries=no -Cdefault-linker-libraries=yes
+//@ ignore-fuchsia - missing __libc_start_main for some reason (#84733)
+//@ ignore-cross-compile - default-linker-libraries=yes doesn't play well with cross compiling
+
+//@ revisions: other
+//@[other] ignore-msvc
+
+//@ revisions: msvc
+// On Windows MSVC, default-linker-libraries=yes doesn't work because
+// rustc drives the linker directly instead of going through another compiler.
+// Therefore rustc would need to implement default-linker-libraries itself but doesn't.
+// So instead we use -Clink-arg to directly set the required msvcrt.lib as a link arg.
+//@[msvc] compile-flags: -Clink-arg=msvcrt.lib
+//@[msvc] only-msvc
+
+#[link(name = "some-random-non-existent-library", kind = "static")]
+extern "C" {}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ed9a4cfdeb0c81f26c7f6d8b8e56e36aa23cf420 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 30 Dec 2024 18:59:49 +0000
Subject: Make sure we check the future type is Sized in AsyncFn*

---
 .../src/traits/select/confirmation.rs              | 23 +++++++++++++---
 .../async-future-out-must-be-sized.rs              | 20 ++++++++++++++
 .../async-future-out-must-be-sized.stderr          | 31 ++++++++++++++++++++++
 3 files changed, 71 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/async-await/async-closures/async-future-out-must-be-sized.rs
 create mode 100644 tests/ui/async-await/async-closures/async-future-out-must-be-sized.stderr

(limited to 'tests')

diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 962b6b94fa6..3619d16cde2 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -896,6 +896,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         sig.tupled_inputs_ty,
                     ])
                 });
+
+                // Note that unlike below, we don't need to check `Future + Sized` for
+                // the output coroutine because they are `Future + Sized` by construction.
+
                 (trait_ref, args.kind_ty())
             }
             ty::FnDef(..) | ty::FnPtr(..) => {
@@ -907,7 +911,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     ])
                 });
 
-                // We must additionally check that the return type impls `Future`.
+                // We must additionally check that the return type impls `Future + Sized`.
                 let future_trait_def_id = tcx.require_lang_item(LangItem::Future, None);
                 nested.push(obligation.with(
                     tcx,
@@ -915,6 +919,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         ty::TraitRef::new(tcx, future_trait_def_id, [output_ty])
                     }),
                 ));
+                let sized_trait_def_id = tcx.require_lang_item(LangItem::Sized, None);
+                nested.push(obligation.with(
+                    tcx,
+                    sig.output().map_bound(|output_ty| {
+                        ty::TraitRef::new(tcx, sized_trait_def_id, [output_ty])
+                    }),
+                ));
 
                 (trait_ref, Ty::from_closure_kind(tcx, ty::ClosureKind::Fn))
             }
@@ -928,14 +939,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     ])
                 });
 
-                // We must additionally check that the return type impls `Future`.
-                // See FIXME in last branch for why we instantiate the binder eagerly.
+                // We must additionally check that the return type impls `Future + Sized`.
                 let future_trait_def_id = tcx.require_lang_item(LangItem::Future, None);
                 let placeholder_output_ty = self.infcx.enter_forall_and_leak_universe(sig.output());
                 nested.push(obligation.with(
                     tcx,
                     ty::TraitRef::new(tcx, future_trait_def_id, [placeholder_output_ty]),
                 ));
+                let sized_trait_def_id = tcx.require_lang_item(LangItem::Sized, None);
+                nested.push(obligation.with(
+                    tcx,
+                    sig.output().map_bound(|output_ty| {
+                        ty::TraitRef::new(tcx, sized_trait_def_id, [output_ty])
+                    }),
+                ));
 
                 (trait_ref, args.kind_ty())
             }
diff --git a/tests/ui/async-await/async-closures/async-future-out-must-be-sized.rs b/tests/ui/async-await/async-closures/async-future-out-must-be-sized.rs
new file mode 100644
index 00000000000..e5d70e30eb5
--- /dev/null
+++ b/tests/ui/async-await/async-closures/async-future-out-must-be-sized.rs
@@ -0,0 +1,20 @@
+//@ edition: 2021
+
+// Ensure that the output of a `fn` pointer that implements `AsyncFn*` is `Sized`,
+// like other built-in impls of an fn pointer, like `Fn*`.
+
+use std::future::Future;
+
+fn foo() -> fn() -> dyn Future<Output = ()> {
+    todo!()
+}
+
+async fn is_async_fn(f: impl AsyncFn()) {
+    f().await;
+}
+
+fn main() {
+    is_async_fn(foo());
+    //~^ ERROR the size for values of type `dyn Future<Output = ()>` cannot be known at compilation time
+    //~| ERROR the size for values of type `dyn Future<Output = ()>` cannot be known at compilation time
+}
diff --git a/tests/ui/async-await/async-closures/async-future-out-must-be-sized.stderr b/tests/ui/async-await/async-closures/async-future-out-must-be-sized.stderr
new file mode 100644
index 00000000000..f993247d8b9
--- /dev/null
+++ b/tests/ui/async-await/async-closures/async-future-out-must-be-sized.stderr
@@ -0,0 +1,31 @@
+error[E0277]: the size for values of type `dyn Future<Output = ()>` cannot be known at compilation time
+  --> $DIR/async-future-out-must-be-sized.rs:17:17
+   |
+LL |     is_async_fn(foo());
+   |     ----------- ^^^^^ doesn't have a size known at compile-time
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the trait `Sized` is not implemented for `dyn Future<Output = ()>`
+note: required by a bound in `is_async_fn`
+  --> $DIR/async-future-out-must-be-sized.rs:12:30
+   |
+LL | async fn is_async_fn(f: impl AsyncFn()) {
+   |                              ^^^^^^^^^ required by this bound in `is_async_fn`
+
+error[E0277]: the size for values of type `dyn Future<Output = ()>` cannot be known at compilation time
+  --> $DIR/async-future-out-must-be-sized.rs:17:5
+   |
+LL |     is_async_fn(foo());
+   |     ^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `dyn Future<Output = ()>`
+note: required by a bound in `is_async_fn`
+  --> $DIR/async-future-out-must-be-sized.rs:12:30
+   |
+LL | async fn is_async_fn(f: impl AsyncFn()) {
+   |                              ^^^^^^^^^ required by this bound in `is_async_fn`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From aac741a465a865576ce7ff0ddde4c16f1da64f62 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 28 Dec 2024 18:42:04 +0000
Subject: Unsafe binder support in rustdoc

---
 src/librustdoc/clean/mod.rs                  | 25 ++++++++++++++++++++++---
 src/librustdoc/clean/types.rs                | 12 ++++++++++--
 src/librustdoc/html/format.rs                | 17 ++++++++++++-----
 src/librustdoc/html/render/search_index.rs   |  3 ++-
 src/librustdoc/json/conversions.rs           |  4 +++-
 tests/rustdoc/auxiliary/unsafe-binder-dep.rs |  4 ++++
 tests/rustdoc/unsafe-binder.rs               | 15 +++++++++++++++
 7 files changed, 68 insertions(+), 12 deletions(-)
 create mode 100644 tests/rustdoc/auxiliary/unsafe-binder-dep.rs
 create mode 100644 tests/rustdoc/unsafe-binder.rs

(limited to 'tests')

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 3c9e0914b59..0f84b438662 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1844,8 +1844,8 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
             DynTrait(bounds, lifetime)
         }
         TyKind::BareFn(barefn) => BareFunction(Box::new(clean_bare_fn_ty(barefn, cx))),
-        TyKind::UnsafeBinder(..) => {
-            unimplemented!("unsafe binders are not supported yet")
+        TyKind::UnsafeBinder(unsafe_binder_ty) => {
+            UnsafeBinder(Box::new(clean_unsafe_binder_ty(unsafe_binder_ty, cx)))
         }
         // Rustdoc handles `TyKind::Err`s by turning them into `Type::Infer`s.
         TyKind::Infer
@@ -2075,6 +2075,11 @@ pub(crate) fn clean_middle_ty<'tcx>(
                 abi: sig.abi(),
             }))
         }
+        ty::UnsafeBinder(inner) => {
+            let generic_params = clean_bound_vars(inner.bound_vars());
+            let ty = clean_middle_ty(inner.into(), cx, None, None);
+            UnsafeBinder(Box::new(UnsafeBinderTy { generic_params, ty }))
+        }
         ty::Adt(def, args) => {
             let did = def.did();
             let kind = match def.adt_kind() {
@@ -2253,7 +2258,6 @@ pub(crate) fn clean_middle_ty<'tcx>(
             }
         }
 
-        ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binders)"),
         ty::Closure(..) => panic!("Closure"),
         ty::CoroutineClosure(..) => panic!("CoroutineClosure"),
         ty::Coroutine(..) => panic!("Coroutine"),
@@ -2564,6 +2568,21 @@ fn clean_bare_fn_ty<'tcx>(
     BareFunctionDecl { safety: bare_fn.safety, abi: bare_fn.abi, decl, generic_params }
 }
 
+fn clean_unsafe_binder_ty<'tcx>(
+    unsafe_binder_ty: &hir::UnsafeBinderTy<'tcx>,
+    cx: &mut DocContext<'tcx>,
+) -> UnsafeBinderTy {
+    // NOTE: generics must be cleaned before args
+    let generic_params = unsafe_binder_ty
+        .generic_params
+        .iter()
+        .filter(|p| !is_elided_lifetime(p))
+        .map(|x| clean_generic_param(cx, None, x))
+        .collect();
+    let ty = clean_ty(unsafe_binder_ty.inner_ty, cx);
+    UnsafeBinderTy { generic_params, ty }
+}
+
 pub(crate) fn reexport_chain(
     tcx: TyCtxt<'_>,
     import_def_id: LocalDefId,
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 8c7ab925577..3c4fad4bca9 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -32,7 +32,7 @@ use {rustc_ast as ast, rustc_hir as hir};
 pub(crate) use self::ItemKind::*;
 pub(crate) use self::Type::{
     Array, BareFunction, BorrowedRef, DynTrait, Generic, ImplTrait, Infer, Primitive, QPath,
-    RawPointer, SelfTy, Slice, Tuple,
+    RawPointer, SelfTy, Slice, Tuple, UnsafeBinder,
 };
 use crate::clean::cfg::Cfg;
 use crate::clean::clean_middle_path;
@@ -1511,6 +1511,8 @@ pub(crate) enum Type {
 
     /// An `impl Trait`: `impl TraitA + TraitB + ...`
     ImplTrait(Vec<GenericBound>),
+
+    UnsafeBinder(Box<UnsafeBinderTy>),
 }
 
 impl Type {
@@ -1703,7 +1705,7 @@ impl Type {
             Type::Pat(..) => PrimitiveType::Pat,
             RawPointer(..) => PrimitiveType::RawPointer,
             QPath(box QPathData { ref self_type, .. }) => return self_type.def_id(cache),
-            Generic(_) | SelfTy | Infer | ImplTrait(_) => return None,
+            Generic(_) | SelfTy | Infer | ImplTrait(_) | UnsafeBinder(_) => return None,
         };
         Primitive(t).def_id(cache)
     }
@@ -2343,6 +2345,12 @@ pub(crate) struct BareFunctionDecl {
     pub(crate) abi: ExternAbi,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub(crate) struct UnsafeBinderTy {
+    pub(crate) generic_params: Vec<GenericParamDef>,
+    pub(crate) ty: Type,
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct Static {
     pub(crate) type_: Box<Type>,
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 136002b8e15..621abd53501 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -282,7 +282,8 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
 
                     match pred {
                         clean::WherePredicate::BoundPredicate { ty, bounds, bound_params } => {
-                            print_higher_ranked_params_with_space(bound_params, cx).fmt(f)?;
+                            print_higher_ranked_params_with_space(bound_params, cx, "for")
+                                .fmt(f)?;
                             ty.print(cx).fmt(f)?;
                             f.write_str(":")?;
                             if !bounds.is_empty() {
@@ -386,7 +387,7 @@ impl clean::ConstantKind {
 impl clean::PolyTrait {
     fn print<'a, 'tcx: 'a>(&'a self, cx: &'a Context<'tcx>) -> impl Display + 'a + Captures<'tcx> {
         display_fn(move |f| {
-            print_higher_ranked_params_with_space(&self.generic_params, cx).fmt(f)?;
+            print_higher_ranked_params_with_space(&self.generic_params, cx, "for").fmt(f)?;
             self.trait_.print(cx).fmt(f)
         })
     }
@@ -968,10 +969,12 @@ fn tybounds<'a, 'tcx: 'a>(
 fn print_higher_ranked_params_with_space<'a, 'tcx: 'a>(
     params: &'a [clean::GenericParamDef],
     cx: &'a Context<'tcx>,
+    keyword: &'static str,
 ) -> impl Display + 'a + Captures<'tcx> {
     display_fn(move |f| {
         if !params.is_empty() {
-            f.write_str(if f.alternate() { "for<" } else { "for&lt;" })?;
+            f.write_str(keyword)?;
+            f.write_str(if f.alternate() { "<" } else { "&lt;" })?;
             comma_sep(params.iter().map(|lt| lt.print(cx)), true).fmt(f)?;
             f.write_str(if f.alternate() { "> " } else { "&gt; " })?;
         }
@@ -1027,7 +1030,7 @@ fn fmt_type(
             primitive_link(f, prim, format_args!("{}", prim.as_sym().as_str()), cx)
         }
         clean::BareFunction(ref decl) => {
-            print_higher_ranked_params_with_space(&decl.generic_params, cx).fmt(f)?;
+            print_higher_ranked_params_with_space(&decl.generic_params, cx, "for").fmt(f)?;
             decl.safety.print_with_space().fmt(f)?;
             print_abi_with_space(decl.abi).fmt(f)?;
             if f.alternate() {
@@ -1037,6 +1040,10 @@ fn fmt_type(
             }
             decl.decl.print(cx).fmt(f)
         }
+        clean::UnsafeBinder(ref binder) => {
+            print_higher_ranked_params_with_space(&binder.generic_params, cx, "unsafe").fmt(f)?;
+            binder.ty.print(cx).fmt(f)
+        }
         clean::Tuple(ref typs) => match &typs[..] {
             &[] => primitive_link(f, PrimitiveType::Unit, format_args!("()"), cx),
             [one] => {
@@ -1354,7 +1361,7 @@ impl clean::Impl {
             // Hardcoded anchor library/core/src/primitive_docs.rs
             // Link should match `# Trait implementations`
 
-            print_higher_ranked_params_with_space(&bare_fn.generic_params, cx).fmt(f)?;
+            print_higher_ranked_params_with_space(&bare_fn.generic_params, cx, "for").fmt(f)?;
             bare_fn.safety.print_with_space().fmt(f)?;
             print_abi_with_space(bare_fn.abi).fmt(f)?;
             let ellipsis = if bare_fn.decl.c_variadic { ", ..." } else { "" };
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index fe2e155c9ba..66c52bec4ba 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -900,7 +900,8 @@ fn get_index_type_id(
         | clean::Generic(_)
         | clean::SelfTy
         | clean::ImplTrait(_)
-        | clean::Infer => None,
+        | clean::Infer
+        | clean::UnsafeBinder(_) => None,
     }
 }
 
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 7f072aa7e2f..7fcdfe3fb22 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -573,7 +573,7 @@ impl FromClean<clean::Type> for Type {
     fn from_clean(ty: clean::Type, renderer: &JsonRenderer<'_>) -> Self {
         use clean::Type::{
             Array, BareFunction, BorrowedRef, Generic, ImplTrait, Infer, Primitive, QPath,
-            RawPointer, SelfTy, Slice, Tuple,
+            RawPointer, SelfTy, Slice, Tuple, UnsafeBinder,
         };
 
         match ty {
@@ -613,6 +613,8 @@ impl FromClean<clean::Type> for Type {
                 self_type: Box::new(self_type.into_json(renderer)),
                 trait_: trait_.map(|trait_| trait_.into_json(renderer)),
             },
+            // FIXME(unsafe_binder): Implement rustdoc-json.
+            UnsafeBinder(_) => todo!(),
         }
     }
 }
diff --git a/tests/rustdoc/auxiliary/unsafe-binder-dep.rs b/tests/rustdoc/auxiliary/unsafe-binder-dep.rs
new file mode 100644
index 00000000000..65aa9032fed
--- /dev/null
+++ b/tests/rustdoc/auxiliary/unsafe-binder-dep.rs
@@ -0,0 +1,4 @@
+#![feature(unsafe_binders)]
+#![allow(incomplete_features)]
+
+pub fn woof() -> unsafe<'a> &'a str { todo!() }
diff --git a/tests/rustdoc/unsafe-binder.rs b/tests/rustdoc/unsafe-binder.rs
new file mode 100644
index 00000000000..621c3dadc72
--- /dev/null
+++ b/tests/rustdoc/unsafe-binder.rs
@@ -0,0 +1,15 @@
+//@ aux-build:unsafe-binder-dep.rs
+
+#![feature(unsafe_binders)]
+#![allow(incomplete_features)]
+
+extern crate unsafe_binder_dep;
+
+//@ has 'unsafe_binder/fn.woof.html' //pre "fn woof() -> unsafe<'a> &'a str"
+pub use unsafe_binder_dep::woof;
+
+//@ has 'unsafe_binder/fn.meow.html' //pre "fn meow() -> unsafe<'a> &'a str"
+pub fn meow() -> unsafe<'a> &'a str { todo!() }
+
+//@ has 'unsafe_binder/fn.meow_squared.html' //pre "fn meow_squared() -> unsafe<'b, 'a> &'a &'b str"
+pub fn meow_squared() -> unsafe<'b, 'a> &'a &'b str { todo!() }
-- 
cgit 1.4.1-3-g733a5


From b994124778907b5732f5453484b8b7a6812cf0f7 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 31 Dec 2024 01:03:18 +0000
Subject: Explain how to mutate a HashMap/BTreeMap with more nuance

---
 compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs | 2 +-
 tests/ui/borrowck/index-mut-help.stderr                      | 2 +-
 tests/ui/btreemap/btreemap-index-mut-2.stderr                | 2 +-
 tests/ui/btreemap/btreemap-index-mut.stderr                  | 2 +-
 tests/ui/hashmap/hashmap-index-mut.stderr                    | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 2484f817a06..4f82dfeb18b 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -575,7 +575,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         // ---------- place
                         self.err.multipart_suggestions(
                             format!(
-                                "to modify a `{}`, use `.get_mut()`, `.insert()` or the entry API",
+                                "use `.insert()` to insert a value into a `{}`, `.get_mut()` to modify it, or the entry API for more flexibility",
                                 self.ty,
                             ),
                             vec![
diff --git a/tests/ui/borrowck/index-mut-help.stderr b/tests/ui/borrowck/index-mut-help.stderr
index fde2b5dc076..449fe42353a 100644
--- a/tests/ui/borrowck/index-mut-help.stderr
+++ b/tests/ui/borrowck/index-mut-help.stderr
@@ -14,7 +14,7 @@ LL |     map["peter"] = "0".to_string();
    |     ^^^^^^^^^^^^ cannot assign
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `HashMap<&str, String>`
-help: to modify a `HashMap<&str, String>`, use `.get_mut()`, `.insert()` or the entry API
+help: use `.insert()` to insert a value into a `HashMap<&str, String>`, `.get_mut()` to modify it, or the entry API for more flexibility
    |
 LL |     map.insert("peter", "0".to_string());
    |        ~~~~~~~~       ~                +
diff --git a/tests/ui/btreemap/btreemap-index-mut-2.stderr b/tests/ui/btreemap/btreemap-index-mut-2.stderr
index 0b8c77cb9e1..4589416b319 100644
--- a/tests/ui/btreemap/btreemap-index-mut-2.stderr
+++ b/tests/ui/btreemap/btreemap-index-mut-2.stderr
@@ -5,7 +5,7 @@ LL |         map[&0] = 1;
    |         ^^^^^^^^^^^ cannot assign
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `BTreeMap<u32, u32>`
-help: to modify a `BTreeMap<u32, u32>`, use `.get_mut()`, `.insert()` or the entry API
+help: use `.insert()` to insert a value into a `BTreeMap<u32, u32>`, `.get_mut()` to modify it, or the entry API for more flexibility
    |
 LL |         map.insert(&0, 1);
    |            ~~~~~~~~  ~  +
diff --git a/tests/ui/btreemap/btreemap-index-mut.stderr b/tests/ui/btreemap/btreemap-index-mut.stderr
index cc465fbf3de..2f53296d630 100644
--- a/tests/ui/btreemap/btreemap-index-mut.stderr
+++ b/tests/ui/btreemap/btreemap-index-mut.stderr
@@ -5,7 +5,7 @@ LL |     map[&0] = 1;
    |     ^^^^^^^^^^^ cannot assign
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `BTreeMap<u32, u32>`
-help: to modify a `BTreeMap<u32, u32>`, use `.get_mut()`, `.insert()` or the entry API
+help: use `.insert()` to insert a value into a `BTreeMap<u32, u32>`, `.get_mut()` to modify it, or the entry API for more flexibility
    |
 LL |     map.insert(&0, 1);
    |        ~~~~~~~~  ~  +
diff --git a/tests/ui/hashmap/hashmap-index-mut.stderr b/tests/ui/hashmap/hashmap-index-mut.stderr
index 2381b8ecb96..6b294823f6f 100644
--- a/tests/ui/hashmap/hashmap-index-mut.stderr
+++ b/tests/ui/hashmap/hashmap-index-mut.stderr
@@ -5,7 +5,7 @@ LL |     map[&0] = 1;
    |     ^^^^^^^^^^^ cannot assign
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `HashMap<u32, u32>`
-help: to modify a `HashMap<u32, u32>`, use `.get_mut()`, `.insert()` or the entry API
+help: use `.insert()` to insert a value into a `HashMap<u32, u32>`, `.get_mut()` to modify it, or the entry API for more flexibility
    |
 LL |     map.insert(&0, 1);
    |        ~~~~~~~~  ~  +
-- 
cgit 1.4.1-3-g733a5


From 6a3474e653cbd77941f540852027f136c1d741c4 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 31 Dec 2024 01:11:38 +0000
Subject: Use if-let in structured suggestion instead of Option::map

---
 .../rustc_borrowck/src/diagnostics/mutability_errors.rs   | 15 +++++++++------
 tests/ui/borrowck/index-mut-help.stderr                   |  4 ++--
 tests/ui/btreemap/btreemap-index-mut-2.stderr             |  4 ++--
 tests/ui/btreemap/btreemap-index-mut.stderr               |  4 ++--
 tests/ui/hashmap/hashmap-index-mut.stderr                 |  4 ++--
 5 files changed, 17 insertions(+), 14 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 4f82dfeb18b..109ec096417 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -575,7 +575,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         // ---------- place
                         self.err.multipart_suggestions(
                             format!(
-                                "use `.insert()` to insert a value into a `{}`, `.get_mut()` to modify it, or the entry API for more flexibility",
+                                "use `.insert()` to insert a value into a `{}`, `.get_mut()` \
+                                to modify it, or the entry API for more flexibility",
                                 self.ty,
                             ),
                             vec![
@@ -592,16 +593,17 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                                     (rv.span.shrink_to_hi(), ")".to_string()),
                                 ],
                                 vec![
-                                    // val.get_mut(index).map(|v| { *v = rv; });
+                                    // if let Some(v) = val.get_mut(index) { *v = rv; }
+                                    (val.span.shrink_to_lo(), "if let Some(val) = ".to_string()),
                                     (
                                         val.span.shrink_to_hi().with_hi(index.span.lo()),
                                         ".get_mut(".to_string(),
                                     ),
                                     (
                                         index.span.shrink_to_hi().with_hi(place.span.hi()),
-                                        ").map(|val| { *val".to_string(),
+                                        ") { *val".to_string(),
                                     ),
-                                    (rv.span.shrink_to_hi(), "; })".to_string()),
+                                    (rv.span.shrink_to_hi(), "; }".to_string()),
                                 ],
                                 vec![
                                     // let x = val.entry(index).or_insert(rv);
@@ -628,15 +630,16 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         self.err.multipart_suggestion(
                             format!("to modify a `{}` use `.get_mut()`", self.ty),
                             vec![
+                                (val.span.shrink_to_lo(), "if let Some(val) = ".to_string()),
                                 (
                                     val.span.shrink_to_hi().with_hi(index.span.lo()),
                                     ".get_mut(".to_string(),
                                 ),
                                 (
                                     index.span.shrink_to_hi().with_hi(receiver.span.hi()),
-                                    ").map(|val| val".to_string(),
+                                    ") { val".to_string(),
                                 ),
-                                (sp.shrink_to_hi(), ")".to_string()),
+                                (sp.shrink_to_hi(), "); }".to_string()),
                             ],
                             Applicability::MachineApplicable,
                         );
diff --git a/tests/ui/borrowck/index-mut-help.stderr b/tests/ui/borrowck/index-mut-help.stderr
index 449fe42353a..8766ff4a6c4 100644
--- a/tests/ui/borrowck/index-mut-help.stderr
+++ b/tests/ui/borrowck/index-mut-help.stderr
@@ -18,8 +18,8 @@ help: use `.insert()` to insert a value into a `HashMap<&str, String>`, `.get_mu
    |
 LL |     map.insert("peter", "0".to_string());
    |        ~~~~~~~~       ~                +
-LL |     map.get_mut("peter").map(|val| { *val = "0".to_string(); });
-   |        ~~~~~~~~~       ~~~~~~~~~~~~~~~~~~                  ++++
+LL |     if let Some(val) = map.get_mut("peter") { *val = "0".to_string(); };
+   |     ++++++++++++++++++    ~~~~~~~~~       ~~~~~~~~                  +++
 LL |     let val = map.entry("peter").or_insert("0".to_string());
    |     +++++++++    ~~~~~~~       ~~~~~~~~~~~~               +
 
diff --git a/tests/ui/btreemap/btreemap-index-mut-2.stderr b/tests/ui/btreemap/btreemap-index-mut-2.stderr
index 4589416b319..c42462ee1eb 100644
--- a/tests/ui/btreemap/btreemap-index-mut-2.stderr
+++ b/tests/ui/btreemap/btreemap-index-mut-2.stderr
@@ -9,8 +9,8 @@ help: use `.insert()` to insert a value into a `BTreeMap<u32, u32>`, `.get_mut()
    |
 LL |         map.insert(&0, 1);
    |            ~~~~~~~~  ~  +
-LL |         map.get_mut(&0).map(|val| { *val = 1; });
-   |            ~~~~~~~~~  ~~~~~~~~~~~~~~~~~~    ++++
+LL |         if let Some(val) = map.get_mut(&0) { *val = 1; };
+   |         ++++++++++++++++++    ~~~~~~~~~  ~~~~~~~~    +++
 LL |         let val = map.entry(&0).or_insert(1);
    |         +++++++++    ~~~~~~~  ~~~~~~~~~~~~ +
 
diff --git a/tests/ui/btreemap/btreemap-index-mut.stderr b/tests/ui/btreemap/btreemap-index-mut.stderr
index 2f53296d630..f402f503c15 100644
--- a/tests/ui/btreemap/btreemap-index-mut.stderr
+++ b/tests/ui/btreemap/btreemap-index-mut.stderr
@@ -9,8 +9,8 @@ help: use `.insert()` to insert a value into a `BTreeMap<u32, u32>`, `.get_mut()
    |
 LL |     map.insert(&0, 1);
    |        ~~~~~~~~  ~  +
-LL |     map.get_mut(&0).map(|val| { *val = 1; });
-   |        ~~~~~~~~~  ~~~~~~~~~~~~~~~~~~    ++++
+LL |     if let Some(val) = map.get_mut(&0) { *val = 1; };
+   |     ++++++++++++++++++    ~~~~~~~~~  ~~~~~~~~    +++
 LL |     let val = map.entry(&0).or_insert(1);
    |     +++++++++    ~~~~~~~  ~~~~~~~~~~~~ +
 
diff --git a/tests/ui/hashmap/hashmap-index-mut.stderr b/tests/ui/hashmap/hashmap-index-mut.stderr
index 6b294823f6f..ad33c6f9b15 100644
--- a/tests/ui/hashmap/hashmap-index-mut.stderr
+++ b/tests/ui/hashmap/hashmap-index-mut.stderr
@@ -9,8 +9,8 @@ help: use `.insert()` to insert a value into a `HashMap<u32, u32>`, `.get_mut()`
    |
 LL |     map.insert(&0, 1);
    |        ~~~~~~~~  ~  +
-LL |     map.get_mut(&0).map(|val| { *val = 1; });
-   |        ~~~~~~~~~  ~~~~~~~~~~~~~~~~~~    ++++
+LL |     if let Some(val) = map.get_mut(&0) { *val = 1; };
+   |     ++++++++++++++++++    ~~~~~~~~~  ~~~~~~~~    +++
 LL |     let val = map.entry(&0).or_insert(1);
    |     +++++++++    ~~~~~~~  ~~~~~~~~~~~~ +
 
-- 
cgit 1.4.1-3-g733a5


From f28e13b0552ab7b95e0cc764c5285ebac23fcaa2 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 31 Dec 2024 01:20:45 +0000
Subject: Fix span for IndexMut method call on HashMap/BTreeMap

---
 compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs | 4 ++--
 tests/ui/borrowck/index-mut-help.stderr                      | 5 ++++-
 tests/ui/issues/issue-41726.stderr                           | 5 ++++-
 3 files changed, 10 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 109ec096417..c690789b587 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -624,7 +624,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         self.suggested = true;
                     } else if let hir::ExprKind::MethodCall(_path, receiver, _, sp) = expr.kind
                         && let hir::ExprKind::Index(val, index, _) = receiver.kind
-                        && expr.span == self.assign_span
+                        && receiver.span == self.assign_span
                     {
                         // val[index].path(args..);
                         self.err.multipart_suggestion(
@@ -639,7 +639,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                                     index.span.shrink_to_hi().with_hi(receiver.span.hi()),
                                     ") { val".to_string(),
                                 ),
-                                (sp.shrink_to_hi(), "); }".to_string()),
+                                (sp.shrink_to_hi(), "; }".to_string()),
                             ],
                             Applicability::MachineApplicable,
                         );
diff --git a/tests/ui/borrowck/index-mut-help.stderr b/tests/ui/borrowck/index-mut-help.stderr
index 8766ff4a6c4..c4c9c1c5313 100644
--- a/tests/ui/borrowck/index-mut-help.stderr
+++ b/tests/ui/borrowck/index-mut-help.stderr
@@ -5,7 +5,10 @@ LL |     map["peter"].clear();
    |     ^^^^^^^^^^^^ cannot borrow as mutable
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `HashMap<&str, String>`
-   = help: to modify a `HashMap<&str, String>`, use `.get_mut()`, `.insert()` or the entry API
+help: to modify a `HashMap<&str, String>` use `.get_mut()`
+   |
+LL |     if let Some(val) = map.get_mut("peter") { val.clear(); };
+   |     ++++++++++++++++++    ~~~~~~~~~       ~~~~~~~        +++
 
 error[E0594]: cannot assign to data in an index of `HashMap<&str, String>`
   --> $DIR/index-mut-help.rs:11:5
diff --git a/tests/ui/issues/issue-41726.stderr b/tests/ui/issues/issue-41726.stderr
index fe7d4df7067..250bba222bf 100644
--- a/tests/ui/issues/issue-41726.stderr
+++ b/tests/ui/issues/issue-41726.stderr
@@ -5,7 +5,10 @@ LL |         things[src.as_str()].sort();
    |         ^^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `HashMap<String, Vec<String>>`
-   = help: to modify a `HashMap<String, Vec<String>>`, use `.get_mut()`, `.insert()` or the entry API
+help: to modify a `HashMap<String, Vec<String>>` use `.get_mut()`
+   |
+LL |         if let Some(val) = things.get_mut(src.as_str()) { val.sort(); };
+   |         ++++++++++++++++++       ~~~~~~~~~            ~~~~~~~       +++
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From dc1f2be449d5452f2f89855b7476b716bed7f671 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Tue, 31 Dec 2024 02:25:35 +0000
Subject: Add comments to -Zlink-* tests

---
 tests/ui/link-native-libs/issue-70093/link-directives.rs       | 5 +++++
 tests/ui/link-native-libs/issue-70093/link-native-libraries.rs | 6 ++++++
 2 files changed, 11 insertions(+)

(limited to 'tests')

diff --git a/tests/ui/link-native-libs/issue-70093/link-directives.rs b/tests/ui/link-native-libs/issue-70093/link-directives.rs
index c67536d39e7..1dc44c996fc 100644
--- a/tests/ui/link-native-libs/issue-70093/link-directives.rs
+++ b/tests/ui/link-native-libs/issue-70093/link-directives.rs
@@ -1,8 +1,13 @@
+// Ensure that `#[link]` attributes are entirely ignore when using `-Zlink-directives=no`.
+
 //@ run-pass
 //@ compile-flags: -Zlink-directives=no
 //@ ignore-fuchsia - missing __libc_start_main for some reason (#84733)
 //@ ignore-cross-compile - default-linker-libraries=yes doesn't play well with cross compiling
 
+// Usually these `#[link]` attribute would cause `libsome-random-non-existent-library`
+// to be passed to the linker, causing it to fail because the file doesn't exist.
+// However, with -Zlink-directives=no, the `#[link]` is ignored.
 #[link(name = "some-random-non-existent-library", kind = "static")]
 extern "C" {}
 
diff --git a/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs b/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs
index 3e14e33ba39..b4dc9fb5cde 100644
--- a/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs
+++ b/tests/ui/link-native-libs/issue-70093/link-native-libraries.rs
@@ -1,3 +1,6 @@
+// Ensure that rust does not pass native libraries to the linker when
+// `-Zlink-native-libraries=no` is used.
+
 //@ run-pass
 //@ compile-flags: -Zlink-native-libraries=no -Cdefault-linker-libraries=yes
 //@ ignore-fuchsia - missing __libc_start_main for some reason (#84733)
@@ -14,6 +17,9 @@
 //@[msvc] compile-flags: -Clink-arg=msvcrt.lib
 //@[msvc] only-msvc
 
+// Usually these `#[link]` attribute would cause `libsome-random-non-existent-library`
+// to be passed to the linker, causing it to fail because the file doesn't exist.
+// However, -Zlink-native-libraries=no disables that.
 #[link(name = "some-random-non-existent-library", kind = "static")]
 extern "C" {}
 
-- 
cgit 1.4.1-3-g733a5


From 899d9e67692012b665755824b027adeb014497be Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 31 Dec 2024 03:08:55 +0000
Subject: Suppress host effect predicates if underlying trait doesn't hold

---
 .../error_reporting/traits/fulfillment_errors.rs   | 53 +++++++++++++++-------
 .../double-error-for-unimplemented-trait.rs        | 22 +++++++++
 .../double-error-for-unimplemented-trait.stderr    | 41 +++++++++++++++++
 3 files changed, 99 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/traits/const-traits/double-error-for-unimplemented-trait.rs
 create mode 100644 tests/ui/traits/const-traits/double-error-for-unimplemented-trait.stderr

(limited to 'tests')

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 885b606326c..163c453bdbe 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -538,23 +538,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     }
 
                     ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(predicate)) => {
-                        // FIXME(const_trait_impl): We should recompute the predicate with `~const`
-                        // if it's `const`, and if it holds, explain that this bound only
-                        // *conditionally* holds. If that fails, we should also do selection
-                        // to drill this down to an impl or built-in source, so we can
-                        // point at it and explain that while the trait *is* implemented,
-                        // that implementation is not const.
-                        let err_msg = self.get_standard_error_message(
-                            bound_predicate.rebind(ty::TraitPredicate {
-                                trait_ref: predicate.trait_ref,
-                                polarity: ty::PredicatePolarity::Positive,
-                            }),
-                            None,
-                            Some(predicate.constness),
-                            None,
-                            String::new(),
-                        );
-                        struct_span_code_err!(self.dcx(), span, E0277, "{}", err_msg)
+                        self.report_host_effect_error(bound_predicate.rebind(predicate), obligation.param_env, span)
                     }
 
                     ty::PredicateKind::Subtype(predicate) => {
@@ -763,6 +747,41 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         applied_do_not_recommend
     }
 
+    fn report_host_effect_error(
+        &self,
+        predicate: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+        param_env: ty::ParamEnv<'tcx>,
+        span: Span,
+    ) -> Diag<'a> {
+        // FIXME(const_trait_impl): We should recompute the predicate with `~const`
+        // if it's `const`, and if it holds, explain that this bound only
+        // *conditionally* holds. If that fails, we should also do selection
+        // to drill this down to an impl or built-in source, so we can
+        // point at it and explain that while the trait *is* implemented,
+        // that implementation is not const.
+        let trait_ref = predicate.map_bound(|predicate| ty::TraitPredicate {
+            trait_ref: predicate.trait_ref,
+            polarity: ty::PredicatePolarity::Positive,
+        });
+        let err_msg = self.get_standard_error_message(
+            trait_ref,
+            None,
+            Some(predicate.constness()),
+            None,
+            String::new(),
+        );
+        let mut diag = struct_span_code_err!(self.dcx(), span, E0277, "{}", err_msg);
+        if !self.predicate_may_hold(&Obligation::new(
+            self.tcx,
+            ObligationCause::dummy(),
+            param_env,
+            trait_ref,
+        )) {
+            diag.downgrade_to_delayed_bug();
+        }
+        diag
+    }
+
     fn emit_specialized_closure_kind_error(
         &self,
         obligation: &PredicateObligation<'tcx>,
diff --git a/tests/ui/traits/const-traits/double-error-for-unimplemented-trait.rs b/tests/ui/traits/const-traits/double-error-for-unimplemented-trait.rs
new file mode 100644
index 00000000000..f4b01efe959
--- /dev/null
+++ b/tests/ui/traits/const-traits/double-error-for-unimplemented-trait.rs
@@ -0,0 +1,22 @@
+// Make sure we don't issue *two* error messages for the trait predicate *and* host predicate.
+
+#![feature(const_trait_impl)]
+
+#[const_trait]
+trait Trait {
+  type Out;
+}
+
+const fn needs_const<T: ~const Trait>(_: &T) {}
+
+const IN_CONST: () = {
+  needs_const(&());
+  //~^ ERROR the trait bound `(): Trait` is not satisfied
+};
+
+const fn conditionally_const() {
+  needs_const(&());
+  //~^ ERROR the trait bound `(): Trait` is not satisfied
+}
+
+fn main() {}
diff --git a/tests/ui/traits/const-traits/double-error-for-unimplemented-trait.stderr b/tests/ui/traits/const-traits/double-error-for-unimplemented-trait.stderr
new file mode 100644
index 00000000000..cd68cdaf8a2
--- /dev/null
+++ b/tests/ui/traits/const-traits/double-error-for-unimplemented-trait.stderr
@@ -0,0 +1,41 @@
+error[E0277]: the trait bound `(): Trait` is not satisfied
+  --> $DIR/double-error-for-unimplemented-trait.rs:13:15
+   |
+LL |   needs_const(&());
+   |   ----------- ^^^ the trait `Trait` is not implemented for `()`
+   |   |
+   |   required by a bound introduced by this call
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/double-error-for-unimplemented-trait.rs:6:1
+   |
+LL | trait Trait {
+   | ^^^^^^^^^^^
+note: required by a bound in `needs_const`
+  --> $DIR/double-error-for-unimplemented-trait.rs:10:25
+   |
+LL | const fn needs_const<T: ~const Trait>(_: &T) {}
+   |                         ^^^^^^^^^^^^ required by this bound in `needs_const`
+
+error[E0277]: the trait bound `(): Trait` is not satisfied
+  --> $DIR/double-error-for-unimplemented-trait.rs:18:15
+   |
+LL |   needs_const(&());
+   |   ----------- ^^^ the trait `Trait` is not implemented for `()`
+   |   |
+   |   required by a bound introduced by this call
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/double-error-for-unimplemented-trait.rs:6:1
+   |
+LL | trait Trait {
+   | ^^^^^^^^^^^
+note: required by a bound in `needs_const`
+  --> $DIR/double-error-for-unimplemented-trait.rs:10:25
+   |
+LL | const fn needs_const<T: ~const Trait>(_: &T) {}
+   |                         ^^^^^^^^^^^^ required by this bound in `needs_const`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 54e33bbdeca62508a71c0e445f1d1c82eb0b48c3 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 31 Dec 2024 04:53:00 +0000
Subject: Account for C string literals in HiddenUnicodeCodepoints lint

---
 .../rustc_lint/src/hidden_unicode_codepoints.rs    | 24 ++++++--
 tests/ui/parser/unicode-control-codepoints.rs      |  7 +++
 tests/ui/parser/unicode-control-codepoints.stderr  | 68 ++++++++++++++++------
 3 files changed, 76 insertions(+), 23 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_lint/src/hidden_unicode_codepoints.rs b/compiler/rustc_lint/src/hidden_unicode_codepoints.rs
index 28368e1ab46..4a7e4bf75cf 100644
--- a/compiler/rustc_lint/src/hidden_unicode_codepoints.rs
+++ b/compiler/rustc_lint/src/hidden_unicode_codepoints.rs
@@ -101,14 +101,28 @@ impl EarlyLintPass for HiddenUnicodeCodepoints {
                 if !contains_text_flow_control_chars(text.as_str()) {
                     return;
                 }
-                let padding = match token_lit.kind {
+                let (padding, point_at_inner_spans) = match token_lit.kind {
                     // account for `"` or `'`
-                    ast::token::LitKind::Str | ast::token::LitKind::Char => 1,
+                    ast::token::LitKind::Str | ast::token::LitKind::Char => (1, true),
+                    // account for `c"`
+                    ast::token::LitKind::CStr => (2, true),
                     // account for `r###"`
-                    ast::token::LitKind::StrRaw(n) => n as u32 + 2,
-                    _ => return,
+                    ast::token::LitKind::StrRaw(n) => (n as u32 + 2, true),
+                    // account for `cr###"`
+                    ast::token::LitKind::CStrRaw(n) => (n as u32 + 3, true),
+                    // suppress bad literals.
+                    ast::token::LitKind::Err(_) => return,
+                    // Be conservative just in case new literals do support these.
+                    _ => (0, false),
                 };
-                self.lint_text_direction_codepoint(cx, text, expr.span, padding, true, "literal");
+                self.lint_text_direction_codepoint(
+                    cx,
+                    text,
+                    expr.span,
+                    padding,
+                    point_at_inner_spans,
+                    "literal",
+                );
             }
             _ => {}
         };
diff --git a/tests/ui/parser/unicode-control-codepoints.rs b/tests/ui/parser/unicode-control-codepoints.rs
index df099bb62ad..c2b9a9911ac 100644
--- a/tests/ui/parser/unicode-control-codepoints.rs
+++ b/tests/ui/parser/unicode-control-codepoints.rs
@@ -1,3 +1,5 @@
+//@ edition: 2021
+
 fn main() {
     // if access_level != "us‫e‪r" { // Check if admin
     //~^ ERROR unicode codepoint changing visible direction of text present in comment
@@ -25,6 +27,11 @@ fn main() {
     //~| ERROR non-ASCII character in raw byte string literal
     println!("{:?}", '‮');
     //~^ ERROR unicode codepoint changing visible direction of text present in literal
+
+    let _ = c"‮";
+    //~^ ERROR unicode codepoint changing visible direction of text present in literal
+    let _ = cr#"‮"#;
+    //~^ ERROR unicode codepoint changing visible direction of text present in literal
 }
 
 //"/*‮ } ⁦if isAdmin⁩ ⁦ begin admins only */"
diff --git a/tests/ui/parser/unicode-control-codepoints.stderr b/tests/ui/parser/unicode-control-codepoints.stderr
index 28de4ae72ab..fa75df6a443 100644
--- a/tests/ui/parser/unicode-control-codepoints.stderr
+++ b/tests/ui/parser/unicode-control-codepoints.stderr
@@ -1,5 +1,5 @@
 error: unicode escape in byte string
-  --> $DIR/unicode-control-codepoints.rs:6:26
+  --> $DIR/unicode-control-codepoints.rs:8:26
    |
 LL |     println!("{:?}", b"us\u{202B}e\u{202A}r");
    |                          ^^^^^^^^ unicode escape in byte string
@@ -7,7 +7,7 @@ LL |     println!("{:?}", b"us\u{202B}e\u{202A}r");
    = help: unicode escape sequences cannot be used as a byte or in a byte string
 
 error: unicode escape in byte string
-  --> $DIR/unicode-control-codepoints.rs:6:35
+  --> $DIR/unicode-control-codepoints.rs:8:35
    |
 LL |     println!("{:?}", b"us\u{202B}e\u{202A}r");
    |                                   ^^^^^^^^ unicode escape in byte string
@@ -15,7 +15,7 @@ LL |     println!("{:?}", b"us\u{202B}e\u{202A}r");
    = help: unicode escape sequences cannot be used as a byte or in a byte string
 
 error: non-ASCII character in byte string literal
-  --> $DIR/unicode-control-codepoints.rs:16:26
+  --> $DIR/unicode-control-codepoints.rs:18:26
    |
 LL |     println!("{:?}", b"/*� } �if isAdmin� � begin admins only ");
    |                          ^ must be ASCII but is '\u{202e}'
@@ -26,7 +26,7 @@ LL |     println!("{:?}", b"/*\xE2\x80\xAE } �if isAdmin� � begin admins o
    |                          ~~~~~~~~~~~~
 
 error: non-ASCII character in byte string literal
-  --> $DIR/unicode-control-codepoints.rs:16:30
+  --> $DIR/unicode-control-codepoints.rs:18:30
    |
 LL |     println!("{:?}", b"/*� } �if isAdmin� � begin admins only ");
    |                              ^ must be ASCII but is '\u{2066}'
@@ -37,7 +37,7 @@ LL |     println!("{:?}", b"/*� } \xE2\x81\xA6if isAdmin� � begin admins o
    |                              ~~~~~~~~~~~~
 
 error: non-ASCII character in byte string literal
-  --> $DIR/unicode-control-codepoints.rs:16:41
+  --> $DIR/unicode-control-codepoints.rs:18:41
    |
 LL |     println!("{:?}", b"/*� } �if isAdmin� � begin admins only ");
    |                                         ^ must be ASCII but is '\u{2069}'
@@ -48,7 +48,7 @@ LL |     println!("{:?}", b"/*� } �if isAdmin\xE2\x81\xA9 � begin admins o
    |                                         ~~~~~~~~~~~~
 
 error: non-ASCII character in byte string literal
-  --> $DIR/unicode-control-codepoints.rs:16:43
+  --> $DIR/unicode-control-codepoints.rs:18:43
    |
 LL |     println!("{:?}", b"/*� } �if isAdmin� � begin admins only ");
    |                                           ^ must be ASCII but is '\u{2066}'
@@ -59,31 +59,31 @@ LL |     println!("{:?}", b"/*� } �if isAdmin� \xE2\x81\xA6 begin admins o
    |                                           ~~~~~~~~~~~~
 
 error: non-ASCII character in raw byte string literal
-  --> $DIR/unicode-control-codepoints.rs:21:29
+  --> $DIR/unicode-control-codepoints.rs:23:29
    |
 LL |     println!("{:?}", br##"/*� } �if isAdmin� � begin admins only "##);
    |                             ^ must be ASCII but is '\u{202e}'
 
 error: non-ASCII character in raw byte string literal
-  --> $DIR/unicode-control-codepoints.rs:21:33
+  --> $DIR/unicode-control-codepoints.rs:23:33
    |
 LL |     println!("{:?}", br##"/*� } �if isAdmin� � begin admins only "##);
    |                                 ^ must be ASCII but is '\u{2066}'
 
 error: non-ASCII character in raw byte string literal
-  --> $DIR/unicode-control-codepoints.rs:21:44
+  --> $DIR/unicode-control-codepoints.rs:23:44
    |
 LL |     println!("{:?}", br##"/*� } �if isAdmin� � begin admins only "##);
    |                                            ^ must be ASCII but is '\u{2069}'
 
 error: non-ASCII character in raw byte string literal
-  --> $DIR/unicode-control-codepoints.rs:21:46
+  --> $DIR/unicode-control-codepoints.rs:23:46
    |
 LL |     println!("{:?}", br##"/*� } �if isAdmin� � begin admins only "##);
    |                                              ^ must be ASCII but is '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in comment
-  --> $DIR/unicode-control-codepoints.rs:2:5
+  --> $DIR/unicode-control-codepoints.rs:4:5
    |
 LL |     // if access_level != "us�e�r" { // Check if admin
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^-^-^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     // if access_level != "us�e�r" { // Check if admin
    = help: if their presence wasn't intentional, you can remove them
 
 error: unicode codepoint changing visible direction of text present in comment
-  --> $DIR/unicode-control-codepoints.rs:30:1
+  --> $DIR/unicode-control-codepoints.rs:37:1
    |
 LL | //"/*� } �if isAdmin� � begin admins only */"
    | ^^^^^-^^^-^^^^^^^^^^-^-^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL | //"/*� } �if isAdmin� � begin admins only */"
    = help: if their presence wasn't intentional, you can remove them
 
 error: unicode codepoint changing visible direction of text present in literal
-  --> $DIR/unicode-control-codepoints.rs:11:22
+  --> $DIR/unicode-control-codepoints.rs:13:22
    |
 LL |     println!("{:?}", "/*� } �if isAdmin� � begin admins only ");
    |                      ^^^-^^^-^^^^^^^^^^-^-^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     println!("{:?}", "/*\u{202e} } \u{2066}if isAdmin\u{2069} \u{2066} begi
    |                         ~~~~~~~~   ~~~~~~~~          ~~~~~~~~ ~~~~~~~~
 
 error: unicode codepoint changing visible direction of text present in literal
-  --> $DIR/unicode-control-codepoints.rs:14:22
+  --> $DIR/unicode-control-codepoints.rs:16:22
    |
 LL |     println!("{:?}", r##"/*� } �if isAdmin� � begin admins only "##);
    |                      ^^^^^^-^^^-^^^^^^^^^^-^-^^^^^^^^^^^^^^^^^^^^^^
@@ -151,7 +151,7 @@ LL |     println!("{:?}", r##"/*\u{202e} } \u{2066}if isAdmin\u{2069} \u{2066} b
    |                            ~~~~~~~~   ~~~~~~~~          ~~~~~~~~ ~~~~~~~~
 
 error: unicode codepoint changing visible direction of text present in literal
-  --> $DIR/unicode-control-codepoints.rs:26:22
+  --> $DIR/unicode-control-codepoints.rs:28:22
    |
 LL |     println!("{:?}", '�');
    |                      ^-^
@@ -166,8 +166,40 @@ help: if you want to keep them but make them visible in your source code, you ca
 LL |     println!("{:?}", '\u{202e}');
    |                       ~~~~~~~~
 
+error: unicode codepoint changing visible direction of text present in literal
+  --> $DIR/unicode-control-codepoints.rs:31:13
+   |
+LL |     let _ = c"�";
+   |             ^^-^
+   |             | |
+   |             | '\u{202e}'
+   |             this literal contains an invisible unicode text flow control codepoint
+   |
+   = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
+   = help: if their presence wasn't intentional, you can remove them
+help: if you want to keep them but make them visible in your source code, you can escape them
+   |
+LL |     let _ = c"\u{202e}";
+   |               ~~~~~~~~
+
+error: unicode codepoint changing visible direction of text present in literal
+  --> $DIR/unicode-control-codepoints.rs:33:13
+   |
+LL |     let _ = cr#"�"#;
+   |             ^^^^-^^
+   |             |   |
+   |             |   '\u{202e}'
+   |             this literal contains an invisible unicode text flow control codepoint
+   |
+   = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
+   = help: if their presence wasn't intentional, you can remove them
+help: if you want to keep them but make them visible in your source code, you can escape them
+   |
+LL |     let _ = cr#"\u{202e}"#;
+   |                 ~~~~~~~~
+
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints.rs:33:1
+  --> $DIR/unicode-control-codepoints.rs:40:1
    |
 LL | /**  '�'); */fn foo() {}
    | ^^^^^^^^^^^^^ this doc comment contains an invisible unicode text flow control codepoint
@@ -177,7 +209,7 @@ LL | /**  '�'); */fn foo() {}
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints.rs:36:1
+  --> $DIR/unicode-control-codepoints.rs:43:1
    |
 LL | / /**
 LL | |  *
@@ -188,5 +220,5 @@ LL | |  *  '�'); */fn bar() {}
    = note: if their presence wasn't intentional, you can remove them
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}'
 
-error: aborting due to 17 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ea291e5b5f5c2562fec89a11444e0dc4388565cf Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 31 Dec 2024 05:03:22 +0000
Subject: Account for format_args in HiddenUnicodeCodepoints lint

---
 compiler/rustc_ast/src/format.rs                   |  5 ++
 compiler/rustc_ast/src/mut_visit.rs                |  2 +-
 compiler/rustc_ast/src/visit.rs                    |  2 +-
 compiler/rustc_builtin_macros/src/asm.rs           |  1 +
 compiler/rustc_builtin_macros/src/format.rs        | 14 ++++-
 compiler/rustc_builtin_macros/src/util.rs          |  5 ++
 .../rustc_lint/src/hidden_unicode_codepoints.rs    | 60 ++++++++++++----------
 tests/ui/parser/unicode-control-codepoints.rs      |  3 ++
 tests/ui/parser/unicode-control-codepoints.stderr  | 24 +++++++--
 9 files changed, 82 insertions(+), 34 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_ast/src/format.rs b/compiler/rustc_ast/src/format.rs
index de628f09853..b93846c1fe6 100644
--- a/compiler/rustc_ast/src/format.rs
+++ b/compiler/rustc_ast/src/format.rs
@@ -4,6 +4,7 @@ use rustc_span::{Ident, Span, Symbol};
 
 use crate::Expr;
 use crate::ptr::P;
+use crate::token::LitKind;
 
 // Definitions:
 //
@@ -45,6 +46,10 @@ pub struct FormatArgs {
     pub span: Span,
     pub template: Vec<FormatArgsPiece>,
     pub arguments: FormatArguments,
+    /// The raw, un-split format string literal, with no escaping or processing.
+    ///
+    /// Generally only useful for lints that care about the raw bytes the user wrote.
+    pub uncooked_fmt_str: (LitKind, Symbol),
 }
 
 /// A piece of a format template string.
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index 995924c2a29..04cdfc93dcb 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -1596,7 +1596,7 @@ fn walk_inline_asm_sym<T: MutVisitor>(
 
 fn walk_format_args<T: MutVisitor>(vis: &mut T, fmt: &mut FormatArgs) {
     // FIXME: visit the template exhaustively.
-    let FormatArgs { span, template: _, arguments } = fmt;
+    let FormatArgs { span, template: _, arguments, uncooked_fmt_str: _ } = fmt;
     for FormatArgument { kind, expr } in arguments.all_args_mut() {
         match kind {
             FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => {
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index c7cc772dabb..e99fc7b604e 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -1061,7 +1061,7 @@ pub fn walk_inline_asm_sym<'a, V: Visitor<'a>>(
 }
 
 pub fn walk_format_args<'a, V: Visitor<'a>>(visitor: &mut V, fmt: &'a FormatArgs) -> V::Result {
-    let FormatArgs { span: _, template: _, arguments } = fmt;
+    let FormatArgs { span: _, template: _, arguments, uncooked_fmt_str: _ } = fmt;
     for FormatArgument { kind, expr } in arguments.all_args() {
         match kind {
             FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => {
diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index 238cc14ff0b..5062cf55bb9 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -531,6 +531,7 @@ fn expand_preparsed_asm(
             symbol: template_str,
             style: template_style,
             span: template_span,
+            ..
         } = {
             let ExpandResult::Ready(mac) = expr_to_spanned_string(ecx, template_expr, msg) else {
                 return ExpandResult::Retry(());
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index 5b3f08948a9..0112499c509 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -166,7 +166,12 @@ fn make_format_args(
 
     let MacroInput { fmtstr: efmt, mut args, is_direct_literal } = input;
 
-    let ExprToSpannedString { symbol: fmt_str, span: fmt_span, style: fmt_style } = {
+    let ExprToSpannedString {
+        symbol: fmt_str,
+        span: fmt_span,
+        style: fmt_style,
+        uncooked_symbol: uncooked_fmt_str,
+    } = {
         let ExpandResult::Ready(mac) = expr_to_spanned_string(ecx, efmt.clone(), msg) else {
             return ExpandResult::Retry(());
         };
@@ -584,7 +589,12 @@ fn make_format_args(
         }
     }
 
-    ExpandResult::Ready(Ok(FormatArgs { span: fmt_span, template, arguments: args }))
+    ExpandResult::Ready(Ok(FormatArgs {
+        span: fmt_span,
+        template,
+        arguments: args,
+        uncooked_fmt_str,
+    }))
 }
 
 fn invalid_placeholder_type_error(
diff --git a/compiler/rustc_builtin_macros/src/util.rs b/compiler/rustc_builtin_macros/src/util.rs
index 9162e94eddb..38fec2bff14 100644
--- a/compiler/rustc_builtin_macros/src/util.rs
+++ b/compiler/rustc_builtin_macros/src/util.rs
@@ -63,6 +63,10 @@ pub(crate) struct ExprToSpannedString {
     pub symbol: Symbol,
     pub style: ast::StrStyle,
     pub span: Span,
+    /// The raw string literal, with no escaping or processing.
+    ///
+    /// Generally only useful for lints that care about the raw bytes the user wrote.
+    pub uncooked_symbol: (ast::token::LitKind, Symbol),
 }
 
 /// - `Ok` is returned when the conversion to a string literal is unsuccessful,
@@ -100,6 +104,7 @@ pub(crate) fn expr_to_spanned_string<'a>(
                     symbol: s,
                     style,
                     span: expr.span,
+                    uncooked_symbol: (token_lit.kind, token_lit.symbol),
                 }));
             }
             Ok(ast::LitKind::ByteStr(..)) => {
diff --git a/compiler/rustc_lint/src/hidden_unicode_codepoints.rs b/compiler/rustc_lint/src/hidden_unicode_codepoints.rs
index 4a7e4bf75cf..406aa1005df 100644
--- a/compiler/rustc_lint/src/hidden_unicode_codepoints.rs
+++ b/compiler/rustc_lint/src/hidden_unicode_codepoints.rs
@@ -82,7 +82,36 @@ impl HiddenUnicodeCodepoints {
             sub,
         });
     }
+
+    fn check_literal(
+        &mut self,
+        cx: &EarlyContext<'_>,
+        text: Symbol,
+        lit_kind: ast::token::LitKind,
+        span: Span,
+        label: &'static str,
+    ) {
+        if !contains_text_flow_control_chars(text.as_str()) {
+            return;
+        }
+        let (padding, point_at_inner_spans) = match lit_kind {
+            // account for `"` or `'`
+            ast::token::LitKind::Str | ast::token::LitKind::Char => (1, true),
+            // account for `c"`
+            ast::token::LitKind::CStr => (2, true),
+            // account for `r###"`
+            ast::token::LitKind::StrRaw(n) => (n as u32 + 2, true),
+            // account for `cr###"`
+            ast::token::LitKind::CStrRaw(n) => (n as u32 + 3, true),
+            // suppress bad literals.
+            ast::token::LitKind::Err(_) => return,
+            // Be conservative just in case new literals do support these.
+            _ => (0, false),
+        };
+        self.lint_text_direction_codepoint(cx, text, span, padding, point_at_inner_spans, label);
+    }
 }
+
 impl EarlyLintPass for HiddenUnicodeCodepoints {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
         if let ast::AttrKind::DocComment(_, comment) = attr.kind {
@@ -97,32 +126,11 @@ impl EarlyLintPass for HiddenUnicodeCodepoints {
         // byte strings are already handled well enough by `EscapeError::NonAsciiCharInByteString`
         match &expr.kind {
             ast::ExprKind::Lit(token_lit) => {
-                let text = token_lit.symbol;
-                if !contains_text_flow_control_chars(text.as_str()) {
-                    return;
-                }
-                let (padding, point_at_inner_spans) = match token_lit.kind {
-                    // account for `"` or `'`
-                    ast::token::LitKind::Str | ast::token::LitKind::Char => (1, true),
-                    // account for `c"`
-                    ast::token::LitKind::CStr => (2, true),
-                    // account for `r###"`
-                    ast::token::LitKind::StrRaw(n) => (n as u32 + 2, true),
-                    // account for `cr###"`
-                    ast::token::LitKind::CStrRaw(n) => (n as u32 + 3, true),
-                    // suppress bad literals.
-                    ast::token::LitKind::Err(_) => return,
-                    // Be conservative just in case new literals do support these.
-                    _ => (0, false),
-                };
-                self.lint_text_direction_codepoint(
-                    cx,
-                    text,
-                    expr.span,
-                    padding,
-                    point_at_inner_spans,
-                    "literal",
-                );
+                self.check_literal(cx, token_lit.symbol, token_lit.kind, expr.span, "literal");
+            }
+            ast::ExprKind::FormatArgs(args) => {
+                let (lit_kind, text) = args.uncooked_fmt_str;
+                self.check_literal(cx, text, lit_kind, args.span, "format string");
             }
             _ => {}
         };
diff --git a/tests/ui/parser/unicode-control-codepoints.rs b/tests/ui/parser/unicode-control-codepoints.rs
index c2b9a9911ac..14e1cfe59d3 100644
--- a/tests/ui/parser/unicode-control-codepoints.rs
+++ b/tests/ui/parser/unicode-control-codepoints.rs
@@ -32,6 +32,9 @@ fn main() {
     //~^ ERROR unicode codepoint changing visible direction of text present in literal
     let _ = cr#"‮"#;
     //~^ ERROR unicode codepoint changing visible direction of text present in literal
+
+    println!("{{‮}}");
+    //~^ ERROR unicode codepoint changing visible direction of text present in format string
 }
 
 //"/*‮ } ⁦if isAdmin⁩ ⁦ begin admins only */"
diff --git a/tests/ui/parser/unicode-control-codepoints.stderr b/tests/ui/parser/unicode-control-codepoints.stderr
index fa75df6a443..2893194308e 100644
--- a/tests/ui/parser/unicode-control-codepoints.stderr
+++ b/tests/ui/parser/unicode-control-codepoints.stderr
@@ -97,7 +97,7 @@ LL |     // if access_level != "us�e�r" { // Check if admin
    = help: if their presence wasn't intentional, you can remove them
 
 error: unicode codepoint changing visible direction of text present in comment
-  --> $DIR/unicode-control-codepoints.rs:37:1
+  --> $DIR/unicode-control-codepoints.rs:40:1
    |
 LL | //"/*� } �if isAdmin� � begin admins only */"
    | ^^^^^-^^^-^^^^^^^^^^-^-^^^^^^^^^^^^^^^^^^^^^^
@@ -198,8 +198,24 @@ help: if you want to keep them but make them visible in your source code, you ca
 LL |     let _ = cr#"\u{202e}"#;
    |                 ~~~~~~~~
 
+error: unicode codepoint changing visible direction of text present in format string
+  --> $DIR/unicode-control-codepoints.rs:36:14
+   |
+LL |     println!("{{�}}");
+   |              ^^^-^^^
+   |              |  |
+   |              |  '\u{202e}'
+   |              this format string contains an invisible unicode text flow control codepoint
+   |
+   = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
+   = help: if their presence wasn't intentional, you can remove them
+help: if you want to keep them but make them visible in your source code, you can escape them
+   |
+LL |     println!("{{\u{202e}}}");
+   |                 ~~~~~~~~
+
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints.rs:40:1
+  --> $DIR/unicode-control-codepoints.rs:43:1
    |
 LL | /**  '�'); */fn foo() {}
    | ^^^^^^^^^^^^^ this doc comment contains an invisible unicode text flow control codepoint
@@ -209,7 +225,7 @@ LL | /**  '�'); */fn foo() {}
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints.rs:43:1
+  --> $DIR/unicode-control-codepoints.rs:46:1
    |
 LL | / /**
 LL | |  *
@@ -220,5 +236,5 @@ LL | |  *  '�'); */fn bar() {}
    = note: if their presence wasn't intentional, you can remove them
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}'
 
-error: aborting due to 19 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 09541c263e658da57fe3c220f3d15a45bfc63986 Mon Sep 17 00:00:00 2001
From: peicuiping <ezc5@sina.cn>
Date: Tue, 31 Dec 2024 15:11:18 +0800
Subject: chore: fix some typos

Signed-off-by: peicuiping <ezc5@sina.cn>
---
 tests/rustdoc-ui/doctest/non-local-defs-impl.rs         | 2 +-
 tests/ui/closures/2229_closure_analysis/issue-118144.rs | 2 +-
 tests/ui/coroutine/issue-53548.rs                       | 2 +-
 tests/ui/panics/default-backtrace-ice.rs                | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/rustdoc-ui/doctest/non-local-defs-impl.rs b/tests/rustdoc-ui/doctest/non-local-defs-impl.rs
index 04fdd285506..f2540574f15 100644
--- a/tests/rustdoc-ui/doctest/non-local-defs-impl.rs
+++ b/tests/rustdoc-ui/doctest/non-local-defs-impl.rs
@@ -21,7 +21,7 @@
 /// }
 /// ```
 ///
-/// But this shoudln't produce a warning:
+/// But this shouldn't produce a warning:
 /// ```rust,no_run
 /// # extern crate pub_trait;
 /// # use pub_trait::Trait;
diff --git a/tests/ui/closures/2229_closure_analysis/issue-118144.rs b/tests/ui/closures/2229_closure_analysis/issue-118144.rs
index 3e5d9f9739a..5747cc75e98 100644
--- a/tests/ui/closures/2229_closure_analysis/issue-118144.rs
+++ b/tests/ui/closures/2229_closure_analysis/issue-118144.rs
@@ -6,7 +6,7 @@ fn func(func_arg: &mut V) {
     || {
         // Declaring `x` separately instead of using
         // a destructuring binding like `let V(x) = ...`
-        // becaue only `V(x) = ...` triggers the ICE
+        // because only `V(x) = ...` triggers the ICE
         let x;
         V(x) = func_arg; //~ ERROR: mismatched types
         func_arg.0 = 0;
diff --git a/tests/ui/coroutine/issue-53548.rs b/tests/ui/coroutine/issue-53548.rs
index 3b8dff2be28..c70f3e5a0d0 100644
--- a/tests/ui/coroutine/issue-53548.rs
+++ b/tests/ui/coroutine/issue-53548.rs
@@ -6,7 +6,7 @@
 // to process this `'r` region bound. In particular, to be WF, the
 // region bound must meet the requirements of the trait, and hence we
 // got `for<'r> { 'r: 'static }`. This would ICE because the `Binder`
-// constructor we were using was assering that no higher-ranked
+// constructor we were using was asserting that no higher-ranked
 // regions were involved (because the WF code is supposed to skip
 // those). The error (if debug-asserions were disabled) came because
 // we obviously cannot prove that `'r: 'static` for any region `'r`.
diff --git a/tests/ui/panics/default-backtrace-ice.rs b/tests/ui/panics/default-backtrace-ice.rs
index c47f458f6e9..9933f548758 100644
--- a/tests/ui/panics/default-backtrace-ice.rs
+++ b/tests/ui/panics/default-backtrace-ice.rs
@@ -17,7 +17,7 @@
 // `__rust_{begin,end}_short_backtrace` markers, which only appear in full
 // backtraces. The rest of the backtrace is filtered out.
 //
-// Ignored on msvc becaue the `__rust_{begin,end}_short_backtrace` symbols
+// Ignored on msvc because the `__rust_{begin,end}_short_backtrace` symbols
 // aren't reliable.
 
 fn main() { missing_ident; }
-- 
cgit 1.4.1-3-g733a5


From 2bf27e09beb4cd1c5f01369e7086e36b3de04f5c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 26 Dec 2024 18:32:22 +0100
Subject: explicitly model that certain ABIs require/forbid certain target
 features

---
 compiler/rustc_codegen_llvm/messages.ftl           |   4 +-
 compiler/rustc_codegen_llvm/src/errors.rs          |   7 +-
 compiler/rustc_codegen_llvm/src/llvm_util.rs       | 220 ++++++++++++---------
 compiler/rustc_codegen_ssa/messages.ftl            |   2 +-
 compiler/rustc_codegen_ssa/src/target_features.rs  |  52 +++--
 .../rustc_middle/src/middle/codegen_fn_attrs.rs    |   1 +
 compiler/rustc_target/src/spec/mod.rs              |  30 ++-
 compiler/rustc_target/src/target_features.rs       | 208 +++++++++----------
 tests/codegen/tied-features-strength.rs            |   7 +-
 .../feature-hierarchy.aarch64-sve2.stderr          |   2 +-
 ...forbidden-hardfloat-target-feature-attribute.rs |  10 +-
 ...idden-hardfloat-target-feature-attribute.stderr |   6 +-
 ...rdfloat-target-feature-flag-disable-neon.stderr |   2 +-
 ...en-hardfloat-target-feature-flag-disable.stderr |   8 +-
 .../forbidden-target-feature-attribute.rs          |   2 +-
 .../forbidden-target-feature-attribute.stderr      |   2 +-
 .../forbidden-target-feature-flag-disable.stderr   |   2 +-
 .../forbidden-target-feature-flag.stderr           |   2 +-
 18 files changed, 299 insertions(+), 268 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl
index 63c64269eb8..22445448907 100644
--- a/compiler/rustc_codegen_llvm/messages.ftl
+++ b/compiler/rustc_codegen_llvm/messages.ftl
@@ -8,7 +8,7 @@ codegen_llvm_dynamic_linking_with_lto =
 codegen_llvm_fixed_x18_invalid_arch = the `-Zfixed-x18` flag is not supported on the `{$arch}` architecture
 
 codegen_llvm_forbidden_ctarget_feature =
-    target feature `{$feature}` cannot be toggled with `-Ctarget-feature`: {$reason}
+    target feature `{$feature}` cannot be {$enabled} with `-Ctarget-feature`: {$reason}
     .note = this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 codegen_llvm_forbidden_ctarget_feature_issue = for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
 
@@ -22,8 +22,6 @@ codegen_llvm_invalid_minimum_alignment_not_power_of_two =
 codegen_llvm_invalid_minimum_alignment_too_large =
     invalid minimum global alignment: {$align} is too large
 
-codegen_llvm_invalid_target_feature_prefix = target feature `{$feature}` must begin with a `+` or `-`"
-
 codegen_llvm_load_bitcode = failed to load bitcode of module "{$name}"
 codegen_llvm_load_bitcode_with_llvm_err = failed to load bitcode of module "{$name}": {$llvm_err}
 
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index 3cdb5b971d9..843d0d6c39f 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -37,6 +37,7 @@ pub(crate) struct UnstableCTargetFeature<'a> {
 #[note(codegen_llvm_forbidden_ctarget_feature_issue)]
 pub(crate) struct ForbiddenCTargetFeature<'a> {
     pub feature: &'a str,
+    pub enabled: &'a str,
     pub reason: &'a str,
 }
 
@@ -205,12 +206,6 @@ pub(crate) struct MismatchedDataLayout<'a> {
     pub llvm_layout: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_invalid_target_feature_prefix)]
-pub(crate) struct InvalidTargetFeaturePrefix<'a> {
-    pub feature: &'a str,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_fixed_x18_invalid_arch)]
 pub(crate) struct FixedX18InvalidArch<'a> {
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 628c0b1c29c..0486ae84b82 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -21,8 +21,8 @@ use rustc_target::target_features::{RUSTC_SPECIAL_FEATURES, RUSTC_SPECIFIC_FEATU
 
 use crate::back::write::create_informational_target_machine;
 use crate::errors::{
-    FixedX18InvalidArch, ForbiddenCTargetFeature, InvalidTargetFeaturePrefix, PossibleFeature,
-    UnknownCTargetFeature, UnknownCTargetFeaturePrefix, UnstableCTargetFeature,
+    FixedX18InvalidArch, ForbiddenCTargetFeature, PossibleFeature, UnknownCTargetFeature,
+    UnknownCTargetFeaturePrefix, UnstableCTargetFeature,
 };
 use crate::llvm;
 
@@ -348,7 +348,16 @@ pub fn target_features_cfg(sess: &Session, allow_unstable: bool) -> Vec<Symbol>
     {
         if enabled {
             // Also add all transitively implied features.
-            features.extend(sess.target.implied_target_features(std::iter::once(feature)));
+
+            // We don't care about the order in `features` since the only thing we use it for is the
+            // `features.contains` below.
+            #[allow(rustc::potential_query_instability)]
+            features.extend(
+                sess.target
+                    .implied_target_features(std::iter::once(feature.as_str()))
+                    .iter()
+                    .map(|s| Symbol::intern(s)),
+            );
         } else {
             // Remove transitively reverse-implied features.
 
@@ -356,7 +365,11 @@ pub fn target_features_cfg(sess: &Session, allow_unstable: bool) -> Vec<Symbol>
             // `features.contains` below.
             #[allow(rustc::potential_query_instability)]
             features.retain(|f| {
-                if sess.target.implied_target_features(std::iter::once(*f)).contains(&feature) {
+                if sess
+                    .target
+                    .implied_target_features(std::iter::once(f.as_str()))
+                    .contains(&feature.as_str())
+                {
                     // If `f` if implies `feature`, then `!feature` implies `!f`, so we have to
                     // remove `f`. (This is the standard logical contraposition principle.)
                     false
@@ -638,7 +651,7 @@ pub(crate) fn global_llvm_features(
         sess.target
             .features
             .split(',')
-            .filter(|v| !v.is_empty() && backend_feature_name(sess, v).is_some())
+            .filter(|v| !v.is_empty())
             // Drop +v8plus feature introduced in LLVM 20.
             .filter(|v| *v != "+v8plus" || get_version() >= (20, 0, 0))
             .map(String::from),
@@ -651,89 +664,126 @@ pub(crate) fn global_llvm_features(
     // -Ctarget-features
     if !only_base_features {
         let known_features = sess.target.rust_target_features();
+        // Will only be filled when `diagnostics` is set!
         let mut featsmap = FxHashMap::default();
 
-        // insert implied features
+        // Ensure that all ABI-required features are enabled, and the ABI-forbidden ones
+        // are disabled.
+        let (abi_enable, abi_disable) = sess.target.abi_required_features();
+        let abi_enable_set = FxHashSet::from_iter(abi_enable.iter().copied());
+        let abi_disable_set = FxHashSet::from_iter(abi_disable.iter().copied());
+
+        // Compute implied features
         let mut all_rust_features = vec![];
         for feature in sess.opts.cg.target_feature.split(',') {
-            match feature.strip_prefix('+') {
-                Some(feature) => all_rust_features.extend(
-                    UnordSet::from(
-                        sess.target
-                            .implied_target_features(std::iter::once(Symbol::intern(feature))),
-                    )
-                    .to_sorted_stable_ord()
-                    .iter()
-                    .map(|s| format!("+{}", s.as_str())),
-                ),
-                _ => all_rust_features.push(feature.to_string()),
+            if let Some(feature) = feature.strip_prefix('+') {
+                all_rust_features.extend(
+                    UnordSet::from(sess.target.implied_target_features(std::iter::once(feature)))
+                        .to_sorted_stable_ord()
+                        .iter()
+                        .map(|&&s| (true, s)),
+                )
+            } else if let Some(feature) = feature.strip_prefix('-') {
+                // FIXME: Why do we not remove implied features on "-" here?
+                // We do the equivalent above in `target_features_cfg`.
+                // See <https://github.com/rust-lang/rust/issues/134792>.
+                all_rust_features.push((false, feature));
+            } else if !feature.is_empty() {
+                if diagnostics {
+                    sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature });
+                }
             }
         }
+        // Remove features that are meant for rustc, not LLVM.
+        all_rust_features.retain(|(_, feature)| {
+            // Retain if it is not a rustc feature
+            !RUSTC_SPECIFIC_FEATURES.contains(feature)
+        });
 
-        let feats = all_rust_features
-            .iter()
-            .filter_map(|s| {
-                let enable_disable = match s.chars().next() {
-                    None => return None,
-                    Some(c @ ('+' | '-')) => c,
-                    Some(_) => {
-                        if diagnostics {
-                            sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });
-                        }
-                        return None;
-                    }
-                };
-
-                // Get the backend feature name, if any.
-                // This excludes rustc-specific features, which do not get passed to LLVM.
-                let feature = backend_feature_name(sess, s)?;
-                // Warn against use of LLVM specific feature names and unstable features on the CLI.
-                if diagnostics {
-                    let feature_state = known_features.iter().find(|&&(v, _, _)| v == feature);
-                    match feature_state {
-                        None => {
-                            let rust_feature =
-                                known_features.iter().find_map(|&(rust_feature, _, _)| {
-                                    let llvm_features = to_llvm_features(sess, rust_feature)?;
-                                    if llvm_features.contains(feature)
-                                        && !llvm_features.contains(rust_feature)
-                                    {
-                                        Some(rust_feature)
-                                    } else {
-                                        None
-                                    }
-                                });
-                            let unknown_feature = if let Some(rust_feature) = rust_feature {
-                                UnknownCTargetFeature {
-                                    feature,
-                                    rust_feature: PossibleFeature::Some { rust_feature },
-                                }
-                            } else {
-                                UnknownCTargetFeature {
-                                    feature,
-                                    rust_feature: PossibleFeature::None,
+        // Check feature validity.
+        if diagnostics {
+            for &(enable, feature) in &all_rust_features {
+                let feature_state = known_features.iter().find(|&&(v, _, _)| v == feature);
+                match feature_state {
+                    None => {
+                        let rust_feature =
+                            known_features.iter().find_map(|&(rust_feature, _, _)| {
+                                let llvm_features = to_llvm_features(sess, rust_feature)?;
+                                if llvm_features.contains(feature)
+                                    && !llvm_features.contains(rust_feature)
+                                {
+                                    Some(rust_feature)
+                                } else {
+                                    None
                                 }
-                            };
-                            sess.dcx().emit_warn(unknown_feature);
-                        }
-                        Some((_, stability, _)) => {
-                            if let Err(reason) =
-                                stability.toggle_allowed(&sess.target, enable_disable == '+')
-                            {
-                                sess.dcx().emit_warn(ForbiddenCTargetFeature { feature, reason });
-                            } else if stability.requires_nightly().is_some() {
-                                // An unstable feature. Warn about using it. It makes little sense
-                                // to hard-error here since we just warn about fully unknown
-                                // features above.
-                                sess.dcx().emit_warn(UnstableCTargetFeature { feature });
+                            });
+                        let unknown_feature = if let Some(rust_feature) = rust_feature {
+                            UnknownCTargetFeature {
+                                feature,
+                                rust_feature: PossibleFeature::Some { rust_feature },
                             }
+                        } else {
+                            UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
+                        };
+                        sess.dcx().emit_warn(unknown_feature);
+                    }
+                    Some((_, stability, _)) => {
+                        if let Err(reason) = stability.toggle_allowed(&sess.target, enable) {
+                            sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                                feature,
+                                enabled: if enable { "enabled" } else { "disabled" },
+                                reason,
+                            });
+                        } else if stability.requires_nightly().is_some() {
+                            // An unstable feature. Warn about using it. It makes little sense
+                            // to hard-error here since we just warn about fully unknown
+                            // features above.
+                            sess.dcx().emit_warn(UnstableCTargetFeature { feature });
                         }
                     }
+                }
 
-                    // FIXME(nagisa): figure out how to not allocate a full hashset here.
-                    featsmap.insert(feature, enable_disable == '+');
+                // Ensure that the features we enable/disable are compatible with the ABI.
+                if enable {
+                    if abi_disable_set.contains(feature) {
+                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                            feature,
+                            enabled: "enabled",
+                            reason: "this feature is incompatible with the target ABI",
+                        });
+                    }
+                } else {
+                    if abi_enable_set.contains(feature) {
+                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                            feature,
+                            enabled: "disabled",
+                            reason: "this feature is required by the target ABI",
+                        });
+                    }
                 }
 
+                // FIXME(nagisa): figure out how to not allocate a full hashset here.
+                featsmap.insert(feature, enable);
+            }
+        }
+
+        // To be sure the ABI-relevant features are all in the right state, we explicitly
+        // (un)set them here. This means if the target spec sets those features wrong,
+        // we will silently correct them rather than silently producing wrong code.
+        // (The target sanity check tries to catch this, but we can't know which features are
+        // enabled in LLVM by default so we can't be fully sure about that check.)
+        for feature in abi_enable {
+            all_rust_features.push((true, feature));
+        }
+        for feature in abi_disable {
+            all_rust_features.push((false, feature));
+        }
+
+        // Translate this into LLVM features.
+        let feats = all_rust_features
+            .iter()
+            .filter_map(|&(enable, feature)| {
+                let enable_disable = if enable { '+' } else { '-' };
                 // We run through `to_llvm_features` when
                 // passing requests down to LLVM. This means that all in-language
                 // features also work on the command line instead of having two
@@ -746,9 +796,9 @@ pub(crate) fn global_llvm_features(
                         enable_disable, llvm_feature.llvm_feature_name
                     ))
                     .chain(llvm_feature.dependency.into_iter().filter_map(
-                        move |feat| match (enable_disable, feat) {
-                            ('-' | '+', TargetFeatureFoldStrength::Both(f))
-                            | ('+', TargetFeatureFoldStrength::EnableOnly(f)) => {
+                        move |feat| match (enable, feat) {
+                            (_, TargetFeatureFoldStrength::Both(f))
+                            | (true, TargetFeatureFoldStrength::EnableOnly(f)) => {
                                 Some(format!("{enable_disable}{f}"))
                             }
                             _ => None,
@@ -780,22 +830,6 @@ pub(crate) fn global_llvm_features(
     features
 }
 
-/// Returns a feature name for the given `+feature` or `-feature` string.
-///
-/// Only allows features that are backend specific (i.e. not [`RUSTC_SPECIFIC_FEATURES`].)
-fn backend_feature_name<'a>(sess: &Session, s: &'a str) -> Option<&'a str> {
-    // features must start with a `+` or `-`.
-    let feature = s
-        .strip_prefix(&['+', '-'][..])
-        .unwrap_or_else(|| sess.dcx().emit_fatal(InvalidTargetFeaturePrefix { feature: s }));
-    // Rustc-specific feature requests like `+crt-static` or `-crt-static`
-    // are not passed down to LLVM.
-    if s.is_empty() || RUSTC_SPECIFIC_FEATURES.contains(&feature) {
-        return None;
-    }
-    Some(feature)
-}
-
 pub(crate) fn tune_cpu(sess: &Session) -> Option<&str> {
     let name = sess.opts.unstable_opts.tune_cpu.as_ref()?;
     Some(handle_native(name))
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 56188714b44..484f467068a 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -67,7 +67,7 @@ codegen_ssa_failed_to_write = failed to write {$path}: {$error}
 codegen_ssa_field_associated_value_expected = associated value expected for `{$name}`
 
 codegen_ssa_forbidden_target_feature_attr =
-    target feature `{$feature}` cannot be toggled with `#[target_feature]`: {$reason}
+    target feature `{$feature}` cannot be enabled with `#[target_feature]`: {$reason}
 
 codegen_ssa_ignoring_emit_path = ignoring emit path because multiple .{$extension} files were produced
 
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index 7e80d014ea2..af9ff311061 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -32,7 +32,7 @@ pub(crate) fn from_target_feature_attr(
             .emit();
     };
     let rust_features = tcx.features();
-    let mut added_target_features = Vec::new();
+    let (_abi_enable, abi_disable) = tcx.sess.target.abi_required_features();
     for item in list {
         // Only `enable = ...` is accepted in the meta-item list.
         if !item.has_name(sym::enable) {
@@ -47,7 +47,7 @@ pub(crate) fn from_target_feature_attr(
         };
 
         // We allow comma separation to enable multiple features.
-        added_target_features.extend(value.as_str().split(',').filter_map(|feature| {
+        for feature in value.as_str().split(',') {
             let Some(stability) = rust_target_features.get(feature) else {
                 let msg = format!("the feature named `{feature}` is not valid for this target");
                 let mut err = tcx.dcx().struct_span_err(item.span(), msg);
@@ -59,7 +59,7 @@ pub(crate) fn from_target_feature_attr(
                     }
                 }
                 err.emit();
-                return None;
+                continue;
             };
 
             // Only allow target features whose feature gates have been enabled
@@ -80,31 +80,25 @@ pub(crate) fn from_target_feature_attr(
                     format!("the target feature `{feature}` is currently unstable"),
                 )
                 .emit();
+            } else {
+                // Add this and the implied features.
+                let feature_sym = Symbol::intern(feature);
+                for &name in tcx.implied_target_features(feature_sym) {
+                    // But ensure the ABI does not forbid enabling this.
+                    // Here we do assume that LLVM doesn't add even more implied features
+                    // we don't know about, at least no features that would have ABI effects!
+                    if abi_disable.contains(&name.as_str()) {
+                        tcx.dcx().emit_err(errors::ForbiddenTargetFeatureAttr {
+                            span: item.span(),
+                            feature: name.as_str(),
+                            reason: "this feature is incompatible with the target ABI",
+                        });
+                    }
+                    target_features.push(TargetFeature { name, implied: name != feature_sym })
+                }
             }
-            Some(Symbol::intern(feature))
-        }));
-    }
-
-    // Add explicit features
-    target_features.extend(
-        added_target_features.iter().copied().map(|name| TargetFeature { name, implied: false }),
-    );
-
-    // Add implied features
-    let mut implied_target_features = UnordSet::new();
-    for feature in added_target_features.iter() {
-        implied_target_features.extend(tcx.implied_target_features(*feature).clone());
-    }
-    for feature in added_target_features.iter() {
-        implied_target_features.remove(feature);
+        }
     }
-    target_features.extend(
-        implied_target_features
-            .into_sorted_stable_ord()
-            .iter()
-            .copied()
-            .map(|name| TargetFeature { name, implied: true }),
-    )
 }
 
 /// Computes the set of target features used in a function for the purposes of
@@ -163,9 +157,13 @@ pub(crate) fn provide(providers: &mut Providers) {
                     .collect()
             }
         },
-        implied_target_features: |tcx, feature| {
+        implied_target_features: |tcx, feature: Symbol| {
+            let feature = feature.as_str();
             UnordSet::from(tcx.sess.target.implied_target_features(std::iter::once(feature)))
                 .into_sorted_stable_ord()
+                .into_iter()
+                .map(|s| Symbol::intern(s))
+                .collect()
         },
         asm_target_features,
         ..*providers
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 241767fe249..16d868300db 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -28,6 +28,7 @@ pub struct CodegenFnAttrs {
     pub link_ordinal: Option<u16>,
     /// The `#[target_feature(enable = "...")]` attribute and the enabled
     /// features (only enabled features are supported right now).
+    /// Implied target features have already been applied.
     pub target_features: Vec<TargetFeature>,
     /// The `#[linkage = "..."]` attribute on Rust-defined items and the value we found.
     pub linkage: Option<Linkage>,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 02962d55a60..28011f632b3 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -2651,10 +2651,6 @@ impl TargetOptions {
     pub(crate) fn has_feature(&self, search_feature: &str) -> bool {
         self.features.split(',').any(|f| f.strip_prefix('+').is_some_and(|f| f == search_feature))
     }
-
-    pub(crate) fn has_neg_feature(&self, search_feature: &str) -> bool {
-        self.features.split(',').any(|f| f.strip_prefix('-').is_some_and(|f| f == search_feature))
-    }
 }
 
 impl Default for TargetOptions {
@@ -3201,7 +3197,8 @@ impl Target {
                 check_matches!(
                     &*self.llvm_abiname,
                     "ilp32" | "ilp32f" | "ilp32d" | "ilp32e",
-                    "invalid RISC-V ABI name"
+                    "invalid RISC-V ABI name: {}",
+                    self.llvm_abiname,
                 );
             }
             "riscv64" => {
@@ -3209,7 +3206,8 @@ impl Target {
                 check_matches!(
                     &*self.llvm_abiname,
                     "lp64" | "lp64f" | "lp64d" | "lp64e",
-                    "invalid RISC-V ABI name"
+                    "invalid RISC-V ABI name: {}",
+                    self.llvm_abiname,
                 );
             }
             "arm" => {
@@ -3243,6 +3241,26 @@ impl Target {
                     ));
                 }
             }
+            // Check that we don't mis-set any of the ABI-relevant features.
+            let (abi_enable, abi_disable) = self.abi_required_features();
+            for feat in abi_enable {
+                // The feature might be enabled by default so we can't *require* it to show up.
+                // But it must not be *disabled*.
+                if features_disabled.contains(feat) {
+                    return Err(format!(
+                        "target feature `{feat}` is required by the ABI but gets disabled in target spec"
+                    ));
+                }
+            }
+            for feat in abi_disable {
+                // The feature might be disable by default so we can't *require* it to show up.
+                // But it must not be *enabled*.
+                if features_enabled.contains(feat) {
+                    return Err(format!(
+                        "target feature `{feat}` is incompatible with the ABI but gets enabled in target spec"
+                    ));
+                }
+            }
         }
 
         Ok(())
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 5372437b0d2..dd9c3921fc2 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -213,22 +213,7 @@ const ARM_FEATURES: &[(&str, StabilityUncomputed, ImpliedFeatures)] = &[
     ("dotprod", unstable(sym::arm_target_feature), &["neon"]),
     ("dsp", unstable(sym::arm_target_feature), &[]),
     ("fp-armv8", unstable(sym::arm_target_feature), &["vfp4"]),
-    (
-        "fpregs",
-        Stability::Unstable {
-            nightly_feature: sym::arm_target_feature,
-            allow_toggle: |target: &Target, _enable| {
-                // Only allow toggling this if the target has `soft-float` set. With `soft-float`,
-                // `fpregs` isn't needed so changing it cannot affect the ABI.
-                if target.has_feature("soft-float") {
-                    Ok(())
-                } else {
-                    Err("unsound on hard-float targets because it changes float ABI")
-                }
-            },
-        },
-        &[],
-    ),
+    ("fpregs", unstable(sym::arm_target_feature), &[]),
     ("i8mm", unstable(sym::arm_target_feature), &["neon"]),
     ("mclass", unstable(sym::arm_target_feature), &[]),
     ("neon", unstable(sym::arm_target_feature), &["vfp3"]),
@@ -326,28 +311,7 @@ const AARCH64_FEATURES: &[(&str, StabilityUncomputed, ImpliedFeatures)] = &[
     // FEAT_MTE & FEAT_MTE2
     ("mte", STABLE, &[]),
     // FEAT_AdvSimd & FEAT_FP
-    (
-        "neon",
-        Stability::Stable {
-            allow_toggle: |target, enable| {
-                if target.abi == "softfloat" {
-                    // `neon` has no ABI implications for softfloat targets, we can allow this.
-                    Ok(())
-                } else if enable
-                    && !target.has_neg_feature("fp-armv8")
-                    && !target.has_neg_feature("neon")
-                {
-                    // neon is enabled by default, and has not been disabled, so enabling it again
-                    // is redundant and we can permit it. Forbidding this would be a breaking change
-                    // since this feature is stable.
-                    Ok(())
-                } else {
-                    Err("unsound on hard-float targets because it changes float ABI")
-                }
-            },
-        },
-        &[],
-    ),
+    ("neon", STABLE, &[]),
     // FEAT_PAUTH (address authentication)
     ("paca", STABLE, &[]),
     // FEAT_PAUTH (generic authentication)
@@ -532,22 +496,7 @@ const X86_FEATURES: &[(&str, StabilityUncomputed, ImpliedFeatures)] = &[
     ("tbm", unstable(sym::tbm_target_feature), &[]),
     ("vaes", unstable(sym::avx512_target_feature), &["avx2", "aes"]),
     ("vpclmulqdq", unstable(sym::avx512_target_feature), &["avx", "pclmulqdq"]),
-    (
-        "x87",
-        Stability::Unstable {
-            nightly_feature: sym::x87_target_feature,
-            allow_toggle: |target: &Target, _enable| {
-                // Only allow toggling this if the target has `soft-float` set. With `soft-float`,
-                // `fpregs` isn't needed so changing it cannot affect the ABI.
-                if target.has_feature("soft-float") {
-                    Ok(())
-                } else {
-                    Err("unsound on hard-float targets because it changes float ABI")
-                }
-            },
-        },
-        &[],
-    ),
+    ("x87", unstable(sym::x87_target_feature), &[]),
     ("xop", unstable(sym::xop_target_feature), &[/*"fma4", */ "avx", "sse4a"]),
     ("xsave", STABLE, &[]),
     ("xsavec", STABLE, &["xsave"]),
@@ -590,55 +539,8 @@ const RISCV_FEATURES: &[(&str, StabilityUncomputed, ImpliedFeatures)] = &[
     // tidy-alphabetical-start
     ("a", STABLE, &["zaamo", "zalrsc"]),
     ("c", STABLE, &[]),
-    (
-        "d",
-        Stability::Unstable {
-            nightly_feature: sym::riscv_target_feature,
-            allow_toggle: |target, enable| match &*target.llvm_abiname {
-                "ilp32d" | "lp64d" if !enable => {
-                    // The ABI requires the `d` feature, so it cannot be disabled.
-                    Err("feature is required by ABI")
-                }
-                "ilp32e" if enable => {
-                    // ilp32e is incompatible with features that need aligned load/stores > 32 bits,
-                    // like `d`.
-                    Err("feature is incompatible with ABI")
-                }
-                _ => Ok(()),
-            },
-        },
-        &["f"],
-    ),
-    (
-        "e",
-        Stability::Unstable {
-            // Given that this is a negative feature, consider this before stabilizing:
-            // does it really make sense to enable this feature in an individual
-            // function with `#[target_feature]`?
-            nightly_feature: sym::riscv_target_feature,
-            allow_toggle: |target, enable| {
-                match &*target.llvm_abiname {
-                    _ if !enable => {
-                        // Disabling this feature means we can use more registers (x16-x31).
-                        // The "e" ABIs treat them as caller-save, so it is safe to use them only
-                        // in some parts of a program while the rest doesn't know they even exist.
-                        // On other ABIs, the feature is already disabled anyway.
-                        Ok(())
-                    }
-                    "ilp32e" | "lp64e" => {
-                        // Embedded ABIs should already have the feature anyway, it's fine to enable
-                        // it again from an ABI perspective.
-                        Ok(())
-                    }
-                    _ => {
-                        // *Not* an embedded ABI. Enabling `e` is invalid.
-                        Err("feature is incompatible with ABI")
-                    }
-                }
-            },
-        },
-        &[],
-    ),
+    ("d", unstable(sym::riscv_target_feature), &["f"]),
+    ("e", unstable(sym::riscv_target_feature), &[]),
     (
         "f",
         Stability::Unstable {
@@ -904,27 +806,107 @@ impl Target {
         }
     }
 
-    pub fn implied_target_features(
+    pub fn implied_target_features<'a>(
         &self,
-        base_features: impl Iterator<Item = Symbol>,
-    ) -> FxHashSet<Symbol> {
-        let implied_features = self
-            .rust_target_features()
-            .iter()
-            .map(|(f, _, i)| (Symbol::intern(f), i))
-            .collect::<FxHashMap<_, _>>();
+        base_features: impl Iterator<Item = &'a str>,
+    ) -> FxHashSet<&'a str> {
+        let implied_features =
+            self.rust_target_features().iter().map(|(f, _, i)| (f, i)).collect::<FxHashMap<_, _>>();
 
         // implied target features have their own implied target features, so we traverse the
         // map until there are no more features to add
         let mut features = FxHashSet::default();
-        let mut new_features = base_features.collect::<Vec<Symbol>>();
+        let mut new_features = base_features.collect::<Vec<&str>>();
         while let Some(new_feature) = new_features.pop() {
             if features.insert(new_feature) {
                 if let Some(implied_features) = implied_features.get(&new_feature) {
-                    new_features.extend(implied_features.iter().copied().map(Symbol::intern))
+                    new_features.extend(implied_features.iter().copied())
                 }
             }
         }
         features
     }
+
+    /// Returns two lists of features:
+    /// the first list contains target features that must be enabled for ABI reasons,
+    /// and the second list contains target feature that must be disabled for ABI reasons.
+    ///
+    /// All features enabled/disabled via `-Ctarget-features` and `#[target_features]` are checked
+    /// against this. We also check any implied features, based on the information above. If LLVM
+    /// implicitly enables more implied features than we do, that could bypass this check!
+    pub fn abi_required_features(&self) -> (&'static [&'static str], &'static [&'static str]) {
+        const NOTHING: (&'static [&'static str], &'static [&'static str]) = (&[], &[]);
+        // Some architectures don't have a clean explicit ABI designation; instead, the ABI is
+        // defined by target features. When that is the case, those target features must be
+        // "forbidden" in the list above to ensure that there is a consistent answer to the
+        // questions "which ABI is used".
+        match &*self.arch {
+            "x86" | "x86_64" => {
+                // We support 2 ABIs, hardfloat (default) and softfloat.
+                if self.has_feature("soft-float") {
+                    NOTHING
+                } else {
+                    // Hardfloat ABI. x87 must be enabled.
+                    (&["x87"], &[])
+                }
+            }
+            "arm" => {
+                // We support 2 ABIs, hardfloat (default) and softfloat.
+                if self.has_feature("soft-float") {
+                    NOTHING
+                } else {
+                    // Hardfloat ABI. x87 must be enabled.
+                    (&["fpregs"], &[])
+                }
+            }
+            "aarch64" | "arm64ec" => {
+                match &*self.abi {
+                    "softfloat" => {
+                        // This is not fully correct, LLVM actually doesn't let us enforce the softfloat
+                        // ABI properly... see <https://github.com/rust-lang/rust/issues/134375>.
+                        // FIXME: should be forbid "neon" here? But that would be a breaking change.
+                        NOTHING
+                    }
+                    _ => {
+                        // Everything else is assumed to use a hardfloat ABI. neon and fp-armv8 must be enabled.
+                        // These are Rust feature names and we use "neon" to control both of them.
+                        (&["neon"], &[])
+                    }
+                }
+            }
+            "riscv32" | "riscv64" => {
+                match &*self.llvm_abiname {
+                    "ilp32d" | "lp64d" => {
+                        // Requires d (which implies f), incompatible with e.
+                        (&["d"], &["e"])
+                    }
+                    "ilp32f" | "lp64f" => {
+                        // Requires f, incompatible with e.
+                        (&["f"], &["e"])
+                    }
+                    "ilp32" | "lp64" => {
+                        // Requires nothing, incompatible with e.
+                        (&[], &["e"])
+                    }
+                    "ilp32e" => {
+                        // ilp32e is documented to be incompatible with features that need aligned
+                        // load/stores > 32 bits, like `d`. (One could also just generate more
+                        // complicated code to align the stack when needed, but the RISCV
+                        // architecture manual just explicitly rules out this combination so we
+                        // might as well.)
+                        // Note that the `e` feature is not required: the ABI treats the extra
+                        // registers as caller-save, so it is safe to use them only in some parts of
+                        // a program while the rest doesn't know they even exist.
+                        (&[], &["d"])
+                    }
+                    "lp64e" => {
+                        // As above, `e` is not required.
+                        NOTHING
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            _ => NOTHING,
+        }
+    }
 }
diff --git a/tests/codegen/tied-features-strength.rs b/tests/codegen/tied-features-strength.rs
index 1b2b63c3d1a..4d96a7cde78 100644
--- a/tests/codegen/tied-features-strength.rs
+++ b/tests/codegen/tied-features-strength.rs
@@ -1,5 +1,5 @@
 // ignore-tidy-linelength
-//@ revisions: ENABLE_SVE DISABLE_SVE DISABLE_NEON ENABLE_NEON
+//@ revisions: ENABLE_SVE DISABLE_SVE ENABLE_NEON
 //@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
 //@ needs-llvm-components: aarch64
 
@@ -11,9 +11,10 @@
 // ENABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(\+sve,?)|(\+neon,?)|(\+fp-armv8,?))*}}" }
 
 //@ [DISABLE_SVE] compile-flags: -C target-feature=-sve -Copt-level=0
-// DISABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-sve,?)|(\+neon,?))*}}" }
+// DISABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-sve,?)|(\+neon,?)|(\+fp-armv8,?))*}}" }
 
-//@ [DISABLE_NEON] compile-flags: -C target-feature=-neon -Copt-level=0
+// The DISABLE_NEON is disabled since neon is a required target feature for this targt, it cannot be disabled.
+// it would have: compile-flags: -C target-feature=-neon -Copt-level=0
 // DISABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-fp-armv8,?)|(-neon,?))*}}" }
 
 //@ [ENABLE_NEON] compile-flags: -C target-feature=+neon -Copt-level=0
diff --git a/tests/ui/target-feature/feature-hierarchy.aarch64-sve2.stderr b/tests/ui/target-feature/feature-hierarchy.aarch64-sve2.stderr
index d5d7d7aa627..b6c3ccdedfb 100644
--- a/tests/ui/target-feature/feature-hierarchy.aarch64-sve2.stderr
+++ b/tests/ui/target-feature/feature-hierarchy.aarch64-sve2.stderr
@@ -1,4 +1,4 @@
-warning: target feature `neon` cannot be toggled with `-Ctarget-feature`: unsound on hard-float targets because it changes float ABI
+warning: target feature `neon` cannot be disabled with `-Ctarget-feature`: this feature is required by the target ABI
    |
    = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.rs b/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.rs
index b3171d52c51..dab01179c0b 100644
--- a/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.rs
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.rs
@@ -1,11 +1,11 @@
-//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=lib
-//@ needs-llvm-components: x86
-#![feature(no_core, lang_items)]
+//@ compile-flags: --target=riscv32e-unknown-none-elf --crate-type=lib
+//@ needs-llvm-components: riscv
+#![feature(no_core, lang_items, riscv_target_feature)]
 #![no_core]
 
 #[lang = "sized"]
 pub trait Sized {}
 
-#[target_feature(enable = "x87")]
-//~^ERROR: cannot be toggled with
+#[target_feature(enable = "d")]
+//~^ERROR: cannot be enabled with
 pub unsafe fn my_fun() {}
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.stderr b/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.stderr
index 3ebbe69d8ae..9df56d86729 100644
--- a/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.stderr
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-attribute.stderr
@@ -1,8 +1,8 @@
-error: target feature `x87` cannot be toggled with `#[target_feature]`: unsound on hard-float targets because it changes float ABI
+error: target feature `d` cannot be enabled with `#[target_feature]`: this feature is incompatible with the target ABI
   --> $DIR/forbidden-hardfloat-target-feature-attribute.rs:9:18
    |
-LL | #[target_feature(enable = "x87")]
-   |                  ^^^^^^^^^^^^^^
+LL | #[target_feature(enable = "d")]
+   |                  ^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-neon.stderr b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-neon.stderr
index d5d7d7aa627..b6c3ccdedfb 100644
--- a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-neon.stderr
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-neon.stderr
@@ -1,4 +1,4 @@
-warning: target feature `neon` cannot be toggled with `-Ctarget-feature`: unsound on hard-float targets because it changes float ABI
+warning: target feature `neon` cannot be disabled with `-Ctarget-feature`: this feature is required by the target ABI
    |
    = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable.stderr b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable.stderr
index 604ad2f991a..6191681286a 100644
--- a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable.stderr
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable.stderr
@@ -1,7 +1,11 @@
-warning: target feature `x87` cannot be toggled with `-Ctarget-feature`: unsound on hard-float targets because it changes float ABI
+warning: unstable feature specified for `-Ctarget-feature`: `x87`
+   |
+   = note: this feature is not stably supported; its behavior can change in the future
+
+warning: target feature `x87` cannot be disabled with `-Ctarget-feature`: this feature is required by the target ABI
    |
    = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
 
-warning: 1 warning emitted
+warning: 2 warnings emitted
 
diff --git a/tests/ui/target-feature/forbidden-target-feature-attribute.rs b/tests/ui/target-feature/forbidden-target-feature-attribute.rs
index f13cdd17da6..2ba5f2215c7 100644
--- a/tests/ui/target-feature/forbidden-target-feature-attribute.rs
+++ b/tests/ui/target-feature/forbidden-target-feature-attribute.rs
@@ -7,5 +7,5 @@
 pub trait Sized {}
 
 #[target_feature(enable = "soft-float")]
-//~^ERROR: cannot be toggled with
+//~^ERROR: cannot be enabled with
 pub unsafe fn my_fun() {}
diff --git a/tests/ui/target-feature/forbidden-target-feature-attribute.stderr b/tests/ui/target-feature/forbidden-target-feature-attribute.stderr
index 27ac4aaf960..f3d54cc19d3 100644
--- a/tests/ui/target-feature/forbidden-target-feature-attribute.stderr
+++ b/tests/ui/target-feature/forbidden-target-feature-attribute.stderr
@@ -1,4 +1,4 @@
-error: target feature `soft-float` cannot be toggled with `#[target_feature]`: unsound because it changes float ABI
+error: target feature `soft-float` cannot be enabled with `#[target_feature]`: unsound because it changes float ABI
   --> $DIR/forbidden-target-feature-attribute.rs:9:18
    |
 LL | #[target_feature(enable = "soft-float")]
diff --git a/tests/ui/target-feature/forbidden-target-feature-flag-disable.stderr b/tests/ui/target-feature/forbidden-target-feature-flag-disable.stderr
index 508e1fe0cf4..797cd4be5c2 100644
--- a/tests/ui/target-feature/forbidden-target-feature-flag-disable.stderr
+++ b/tests/ui/target-feature/forbidden-target-feature-flag-disable.stderr
@@ -1,4 +1,4 @@
-warning: target feature `soft-float` cannot be toggled with `-Ctarget-feature`: unsound because it changes float ABI
+warning: target feature `soft-float` cannot be disabled with `-Ctarget-feature`: unsound because it changes float ABI
    |
    = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
diff --git a/tests/ui/target-feature/forbidden-target-feature-flag.stderr b/tests/ui/target-feature/forbidden-target-feature-flag.stderr
index 508e1fe0cf4..075666fbf66 100644
--- a/tests/ui/target-feature/forbidden-target-feature-flag.stderr
+++ b/tests/ui/target-feature/forbidden-target-feature-flag.stderr
@@ -1,4 +1,4 @@
-warning: target feature `soft-float` cannot be toggled with `-Ctarget-feature`: unsound because it changes float ABI
+warning: target feature `soft-float` cannot be enabled with `-Ctarget-feature`: unsound because it changes float ABI
    |
    = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
-- 
cgit 1.4.1-3-g733a5


From eb527424a5f0206a464d0968387d85636ac9d305 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 26 Dec 2024 19:47:41 +0100
Subject: x86-64 hardfloat actually requires sse2

---
 compiler/rustc_codegen_gcc/src/gcc_util.rs            | 18 ++++++++++++------
 compiler/rustc_codegen_llvm/src/llvm_util.rs          | 19 +++++++++++++------
 compiler/rustc_target/src/target_features.rs          | 11 ++++++++++-
 tests/codegen/target-feature-overrides.rs             |  4 ++--
 ...n-hardfloat-target-feature-flag-disable-implied.rs | 10 ++++++++++
 ...rdfloat-target-feature-flag-disable-implied.stderr |  7 +++++++
 6 files changed, 54 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs
 create mode 100644 tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr

(limited to 'tests')

diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index b0fd07827d6..3e579d75d86 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -129,12 +129,18 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
                     });
                 }
             } else {
-                if abi_enable_set.contains(feature) {
-                    sess.dcx().emit_warn(ForbiddenCTargetFeature {
-                        feature,
-                        enabled: "disabled",
-                        reason: "this feature is required by the target ABI",
-                    });
+                // FIXME: we have to request implied features here since
+                // negative features do not handle implied features above.
+                #[allow(rustc::potential_query_instability)] // order does not matter
+                for &required in abi_enable_set.iter() {
+                    let implied = sess.target.implied_target_features(std::iter::once(required));
+                    if implied.contains(feature) {
+                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                            feature,
+                            enabled: "disabled",
+                            reason: "this feature is required by the target ABI",
+                        });
+                    }
                 }
             }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index d4b2260123b..7fe0624e166 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -753,12 +753,19 @@ pub(crate) fn global_llvm_features(
                         });
                     }
                 } else {
-                    if abi_enable_set.contains(feature) {
-                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
-                            feature,
-                            enabled: "disabled",
-                            reason: "this feature is required by the target ABI",
-                        });
+                    // FIXME: we have to request implied features here since
+                    // negative features do not handle implied features above.
+                    #[allow(rustc::potential_query_instability)] // order does not matter
+                    for &required in abi_enable_set.iter() {
+                        let implied =
+                            sess.target.implied_target_features(std::iter::once(required));
+                        if implied.contains(feature) {
+                            sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                                feature,
+                                enabled: "disabled",
+                                reason: "this feature is required by the target ABI",
+                            });
+                        }
                     }
                 }
 
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 31e2cabed62..75055144c8f 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -753,7 +753,7 @@ impl Target {
         // "forbidden" in the list above to ensure that there is a consistent answer to the
         // questions "which ABI is used".
         match &*self.arch {
-            "x86" | "x86_64" => {
+            "x86" => {
                 // We support 2 ABIs, hardfloat (default) and softfloat.
                 if self.has_feature("soft-float") {
                     NOTHING
@@ -762,6 +762,15 @@ impl Target {
                     (&["x87"], &[])
                 }
             }
+            "x86_64" => {
+                // We support 2 ABIs, hardfloat (default) and softfloat.
+                if self.has_feature("soft-float") {
+                    NOTHING
+                } else {
+                    // Hardfloat ABI. x87 and SSE2 must be enabled.
+                    (&["x87", "sse2"], &[])
+                }
+            }
             "arm" => {
                 // We support 2 ABIs, hardfloat (default) and softfloat.
                 if self.has_feature("soft-float") {
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
index f38a1ae72de..c4f9a8898a1 100644
--- a/tests/codegen/target-feature-overrides.rs
+++ b/tests/codegen/target-feature-overrides.rs
@@ -40,7 +40,7 @@ pub unsafe fn banana() -> u32 {
 
 // CHECK: attributes [[APPLEATTRS]]
 // COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx,+avx,{{.*}}"
+// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2,+avx,{{.*}}"
 // CHECK: attributes [[BANANAATTRS]]
 // COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx"
+// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2"
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs
new file mode 100644
index 00000000000..3d09217327a
--- /dev/null
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=lib
+//@ needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-sse
+// For now this is just a warning.
+//@ build-pass
+#![feature(no_core, lang_items)]
+#![no_core]
+
+#[lang = "sized"]
+pub trait Sized {}
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr
new file mode 100644
index 00000000000..72b2d03fe20
--- /dev/null
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr
@@ -0,0 +1,7 @@
+warning: target feature `sse` cannot be disabled with `-Ctarget-feature`: this feature is required by the target ABI
+   |
+   = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
+
+warning: 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From 912b7291d0f8f477388282a04ccf085d1b3715b0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 27 Dec 2024 22:19:55 +0100
Subject: add ABI target features *before* -Ctarget-features

---
 compiler/rustc_codegen_gcc/src/gcc_util.rs   | 12 ++++++------
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 12 ++++++------
 compiler/rustc_target/src/target_features.rs |  3 +++
 tests/codegen/target-feature-overrides.rs    |  8 ++++----
 4 files changed, 19 insertions(+), 16 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index 3e579d75d86..e9dfb4e4cf4 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -154,12 +154,12 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
     // we will silently correct them rather than silently producing wrong code.
     // (The target sanity check tries to catch this, but we can't know which features are
     // enabled in GCC by default so we can't be fully sure about that check.)
-    for feature in abi_enable {
-        all_rust_features.push((true, feature));
-    }
-    for feature in abi_disable {
-        all_rust_features.push((false, feature));
-    }
+    // We add these at the beginning of the list so that `-Ctarget-features` can
+    // still override it... that's unsound, but more compatible with past behavior.
+    all_rust_features.splice(
+        0..0,
+        abi_enable.iter().map(|&f| (true, f)).chain(abi_disable.iter().map(|&f| (false, f))),
+    );
 
     // Translate this into GCC features.
     let feats = all_rust_features
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 7fe0624e166..6ec09b29649 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -779,12 +779,12 @@ pub(crate) fn global_llvm_features(
         // we will silently correct them rather than silently producing wrong code.
         // (The target sanity check tries to catch this, but we can't know which features are
         // enabled in LLVM by default so we can't be fully sure about that check.)
-        for feature in abi_enable {
-            all_rust_features.push((true, feature));
-        }
-        for feature in abi_disable {
-            all_rust_features.push((false, feature));
-        }
+        // We add these at the beginning of the list so that `-Ctarget-features` can
+        // still override it... that's unsound, but more compatible with past behavior.
+        all_rust_features.splice(
+            0..0,
+            abi_enable.iter().map(|&f| (true, f)).chain(abi_disable.iter().map(|&f| (false, f))),
+        );
 
         // Translate this into LLVM features.
         let feats = all_rust_features
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 75055144c8f..b5e30c4d5c9 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -743,6 +743,9 @@ impl Target {
     /// the first list contains target features that must be enabled for ABI reasons,
     /// and the second list contains target feature that must be disabled for ABI reasons.
     ///
+    /// These features are automatically appended to whatever the target spec sats as default
+    /// features for the target.
+    ///
     /// All features enabled/disabled via `-Ctarget-features` and `#[target_features]` are checked
     /// against this. We also check any implied features, based on the information above. If LLVM
     /// implicitly enables more implied features than we do, that could bypass this check!
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
index c4f9a8898a1..e7f70a1e24a 100644
--- a/tests/codegen/target-feature-overrides.rs
+++ b/tests/codegen/target-feature-overrides.rs
@@ -39,8 +39,8 @@ pub unsafe fn banana() -> u32 {
 }
 
 // CHECK: attributes [[APPLEATTRS]]
-// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2,+avx,{{.*}}"
+// COMPAT-SAME: "target-features"="+x87,+sse2,+avx,+avx2,{{.*}}"
+// INCOMPAT-SAME: "target-features"="+x87,+sse2,-avx2,-avx,+avx,{{.*}}"
 // CHECK: attributes [[BANANAATTRS]]
-// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2"
+// COMPAT-SAME: "target-features"="+x87,+sse2,+avx,+avx2,{{.*}}"
+// INCOMPAT-SAME: "target-features"="+x87,+sse2,-avx2,-avx"
-- 
cgit 1.4.1-3-g733a5


From 43ede97ebf7d874c9076723840c945b051b10ee2 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 31 Dec 2024 12:20:30 +0100
Subject: arm: use target.llvm_floatabi over soft-float target feature

---
 compiler/rustc_target/src/target_features.rs | 29 +++++++++++++++++++---------
 tests/codegen/tied-features-strength.rs      |  8 ++++----
 tests/run-make/simd-ffi/rmake.rs             |  2 +-
 3 files changed, 25 insertions(+), 14 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index b5e30c4d5c9..142ac0ff3d3 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -5,7 +5,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_span::{Symbol, sym};
 
-use crate::spec::Target;
+use crate::spec::{FloatAbi, Target};
 
 /// Features that control behaviour of rustc, rather than the codegen.
 /// These exist globally and are not in the target-specific lists below.
@@ -148,7 +148,6 @@ const ARM_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("neon", Unstable(sym::arm_target_feature), &["vfp3"]),
     ("rclass", Unstable(sym::arm_target_feature), &[]),
     ("sha2", Unstable(sym::arm_target_feature), &["neon"]),
-    ("soft-float", Stability::Forbidden { reason: "unsound because it changes float ABI" }, &[]),
     // This is needed for inline assembly, but shouldn't be stabilized as-is
     // since it should be enabled per-function using #[instruction_set], not
     // #[target_feature].
@@ -204,6 +203,7 @@ const AARCH64_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("flagm", Stable, &[]),
     // FEAT_FLAGM2
     ("flagm2", Unstable(sym::aarch64_unstable_target_feature), &[]),
+    // We forbid directly toggling just `fp-armv8`; it must be toggled with `neon`.
     ("fp-armv8", Stability::Forbidden { reason: "Rust ties `fp-armv8` to `neon`" }, &[]),
     // FEAT_FP16
     // Rust ties FP and Neon: https://github.com/rust-lang/rust/pull/91608
@@ -758,6 +758,7 @@ impl Target {
         match &*self.arch {
             "x86" => {
                 // We support 2 ABIs, hardfloat (default) and softfloat.
+                // x86 has no sane ABI indicator so we have to use the target feature.
                 if self.has_feature("soft-float") {
                     NOTHING
                 } else {
@@ -767,6 +768,7 @@ impl Target {
             }
             "x86_64" => {
                 // We support 2 ABIs, hardfloat (default) and softfloat.
+                // x86 has no sane ABI indicator so we have to use the target feature.
                 if self.has_feature("soft-float") {
                     NOTHING
                 } else {
@@ -775,20 +777,27 @@ impl Target {
                 }
             }
             "arm" => {
-                // We support 2 ABIs, hardfloat (default) and softfloat.
-                if self.has_feature("soft-float") {
-                    NOTHING
-                } else {
-                    // Hardfloat ABI. x87 must be enabled.
-                    (&["fpregs"], &[])
+                // On ARM, ABI handling is reasonably sane; we use `llvm_floatabi` to indicate
+                // to LLVM which ABI we are going for.
+                match self.llvm_floatabi.unwrap() {
+                    FloatAbi::Soft => {
+                        // Nothing special required, will use soft-float ABI throughout.
+                        NOTHING
+                    }
+                    FloatAbi::Hard => {
+                        // Must have `fpregs` and must not have `soft-float`.
+                        (&["fpregs"], &["soft-float"])
+                    }
                 }
             }
             "aarch64" | "arm64ec" => {
+                // Aarch64 has no sane ABI specifier, and LLVM doesn't even have a way to force
+                // the use of soft-float, so all we can do here is some crude hacks.
                 match &*self.abi {
                     "softfloat" => {
                         // This is not fully correct, LLVM actually doesn't let us enforce the softfloat
                         // ABI properly... see <https://github.com/rust-lang/rust/issues/134375>.
-                        // FIXME: should be forbid "neon" here? But that would be a breaking change.
+                        // FIXME: should we forbid "neon" here? But that would be a breaking change.
                         NOTHING
                     }
                     _ => {
@@ -799,6 +808,8 @@ impl Target {
                 }
             }
             "riscv32" | "riscv64" => {
+                // RISC-V handles ABI in a very sane way, being fully explicit via `llvm_abiname`
+                // about what the intended ABI is.
                 match &*self.llvm_abiname {
                     "ilp32d" | "lp64d" => {
                         // Requires d (which implies f), incompatible with e.
diff --git a/tests/codegen/tied-features-strength.rs b/tests/codegen/tied-features-strength.rs
index 4d96a7cde78..6daa5cd7d5e 100644
--- a/tests/codegen/tied-features-strength.rs
+++ b/tests/codegen/tied-features-strength.rs
@@ -1,5 +1,5 @@
 // ignore-tidy-linelength
-//@ revisions: ENABLE_SVE DISABLE_SVE ENABLE_NEON
+//@ revisions: ENABLE_SVE DISABLE_SVE DISABLE_NEON ENABLE_NEON
 //@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
 //@ needs-llvm-components: aarch64
 
@@ -13,9 +13,9 @@
 //@ [DISABLE_SVE] compile-flags: -C target-feature=-sve -Copt-level=0
 // DISABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-sve,?)|(\+neon,?)|(\+fp-armv8,?))*}}" }
 
-// The DISABLE_NEON is disabled since neon is a required target feature for this targt, it cannot be disabled.
-// it would have: compile-flags: -C target-feature=-neon -Copt-level=0
-// DISABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-fp-armv8,?)|(-neon,?))*}}" }
+//@ [DISABLE_NEON] compile-flags: -C target-feature=-neon -Copt-level=0
+// `neon` and `fp-armv8` get enabled as target base features, but then disabled again at the end of the list.
+// DISABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fp-armv8,?)|(\+neon,?))*}},-neon,-fp-armv8{{(,\+fpmr)?}}" }
 
 //@ [ENABLE_NEON] compile-flags: -C target-feature=+neon -Copt-level=0
 // ENABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(\+fp-armv8,?)|(\+neon,?))*}}" }
diff --git a/tests/run-make/simd-ffi/rmake.rs b/tests/run-make/simd-ffi/rmake.rs
index 04990c8bdf4..ef71dfa4c30 100644
--- a/tests/run-make/simd-ffi/rmake.rs
+++ b/tests/run-make/simd-ffi/rmake.rs
@@ -56,7 +56,7 @@ fn main() {
             .target(&target)
             .emit("llvm-ir,asm")
             .input("simd.rs")
-            .arg("-Ctarget-feature=+neon,+sse")
+            .arg("-Ctarget-feature=-soft-float,+neon,+sse")
             .arg(&format!("-Cextra-filename=-{target}"))
             .run();
     }
-- 
cgit 1.4.1-3-g733a5


From bb16267a65f00defdc5d484375c59f9d93dfa50e Mon Sep 17 00:00:00 2001
From: dxsullivan <193140725+dxsullivan@users.noreply.github.com>
Date: Tue, 31 Dec 2024 23:46:39 +0800
Subject: chore: fix typos

Signed-off-by: dxsullivan <193140725+dxsullivan@users.noreply.github.com>
---
 tests/rustdoc/type-alias/deeply-nested-112515.rs                        | 2 +-
 tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs          | 2 +-
 tests/ui/incoherent-inherent-impls/no-other-unrelated-errors.rs         | 2 +-
 tests/ui/indexing/indexing-spans-caller-location.rs                     | 2 +-
 .../need_type_info/issue-107745-avoid-expr-from-macro-expansion.rs      | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/tests/rustdoc/type-alias/deeply-nested-112515.rs b/tests/rustdoc/type-alias/deeply-nested-112515.rs
index 161188ee576..9530feb78de 100644
--- a/tests/rustdoc/type-alias/deeply-nested-112515.rs
+++ b/tests/rustdoc/type-alias/deeply-nested-112515.rs
@@ -1,6 +1,6 @@
 // Regression test for <https://github.com/rust-lang/rust/issues/112515>.
 // It's to ensure that this code doesn't have infinite loop in rustdoc when
-// trying to retrive type alias implementations.
+// trying to retrieve type alias implementations.
 
 // ignore-tidy-linelength
 
diff --git a/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs b/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs
index 8d36981b41b..72375eb0b3e 100644
--- a/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs
+++ b/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs
@@ -1,6 +1,6 @@
 // Here, there are two types with the same name. One of these has a `derive` annotation, but in the
 // expansion these `impl`s are associated to the the *other* type. There is a suggestion to remove
-// unneded type parameters, but because we're now point at a type with no type parameters, the
+// unneeded type parameters, but because we're now point at a type with no type parameters, the
 // suggestion would suggest removing code from an empty span, which would ICE in nightly.
 //
 // issue: rust-lang/rust#108748
diff --git a/tests/ui/incoherent-inherent-impls/no-other-unrelated-errors.rs b/tests/ui/incoherent-inherent-impls/no-other-unrelated-errors.rs
index 8eaa0c9194a..cef017e79a4 100644
--- a/tests/ui/incoherent-inherent-impls/no-other-unrelated-errors.rs
+++ b/tests/ui/incoherent-inherent-impls/no-other-unrelated-errors.rs
@@ -1,4 +1,4 @@
-// E0116 caused other unrelated errors, so check no unrelated errors are emmitted.
+// E0116 caused other unrelated errors, so check no unrelated errors are emitted.
 
 fn main() {
     let x = "hello";
diff --git a/tests/ui/indexing/indexing-spans-caller-location.rs b/tests/ui/indexing/indexing-spans-caller-location.rs
index 02d8b853734..b01e3894ac1 100644
--- a/tests/ui/indexing/indexing-spans-caller-location.rs
+++ b/tests/ui/indexing/indexing-spans-caller-location.rs
@@ -20,7 +20,7 @@ impl std::ops::Index<usize> for A {
     type Output = ();
 
     fn index(&self, _idx: usize) -> &() {
-        // Use the relative number to make it resistent to header changes.
+        // Use the relative number to make it resistant to header changes.
         assert_eq!(caller_line(), self.prev_line + 2);
         &()
     }
diff --git a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.rs b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.rs
index 7f6758f47f8..3cdb488e7a5 100644
--- a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.rs
+++ b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.rs
@@ -2,7 +2,7 @@
 
 // Regression test for #107745.
 // Previously need_type_info::update_infer_source will consider expressions originating from
-// macro expressions as candiate "previous sources". This unfortunately can mean that
+// macro expressions as candidate "previous sources". This unfortunately can mean that
 // for macros expansions such as `format!()` internal implementation details can leak, such as:
 //
 // ```
-- 
cgit 1.4.1-3-g733a5


From 2b2ea9e875dc9ae6c2d351078f1f43e533c9d780 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Tue, 31 Dec 2024 18:06:01 +0000
Subject: Provide structured suggestion for `impl Default` of type where all
 fields have defaults

```
error: `Default` impl doesn't use the declared default field values
  --> $DIR/manual-default-impl-could-be-derived.rs:28:1
   |
LL | / impl Default for B {
LL | |     fn default() -> Self {
LL | |         B {
LL | |             x: s(),
   | |                --- this field has a default value
LL | |             y: 0,
   | |                - this field has a default value
...  |
LL | | }
   | |_^
   |
help: to avoid divergence in behavior between `Struct { .. }` and `<Struct as Default>::default()`, derive the `Default`
   |
LL ~ #[derive(Default)] struct B {
   |
```

Note that above the structured suggestion also includes completely removing the manual `impl`, but the rendering doesn't.
---
 .../rustc_lint/src/default_could_be_derived.rs     | 34 +++++++++++++++++-----
 .../manual-default-impl-could-be-derived.stderr    |  5 +++-
 2 files changed, 30 insertions(+), 9 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_lint/src/default_could_be_derived.rs b/compiler/rustc_lint/src/default_could_be_derived.rs
index d95cbb05158..bae9defa687 100644
--- a/compiler/rustc_lint/src/default_could_be_derived.rs
+++ b/compiler/rustc_lint/src/default_could_be_derived.rs
@@ -1,9 +1,11 @@
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::Diag;
+use rustc_errors::{Applicability, Diag};
 use rustc_hir as hir;
 use rustc_middle::ty;
+use rustc_middle::ty::TyCtxt;
 use rustc_session::{declare_lint, impl_lint_pass};
 use rustc_span::Symbol;
+use rustc_span::def_id::DefId;
 use rustc_span::symbol::sym;
 
 use crate::{LateContext, LateLintPass};
@@ -149,13 +151,16 @@ impl<'tcx> LateLintPass<'tcx> for DefaultCouldBeDerived {
         let hir_id = cx.tcx.local_def_id_to_hir_id(local);
         let hir::Node::Item(item) = cx.tcx.hir_node(hir_id) else { return };
         cx.tcx.node_span_lint(DEFAULT_OVERRIDES_DEFAULT_FIELDS, hir_id, item.span, |diag| {
-            mk_lint(diag, orig_fields, fields);
+            mk_lint(cx.tcx, diag, type_def_id, parent, orig_fields, fields);
         });
     }
 }
 
 fn mk_lint(
+    tcx: TyCtxt<'_>,
     diag: &mut Diag<'_, ()>,
+    type_def_id: DefId,
+    impl_def_id: DefId,
     orig_fields: FxHashMap<Symbol, &hir::FieldDef<'_>>,
     fields: &[hir::ExprField<'_>],
 ) {
@@ -175,11 +180,24 @@ fn mk_lint(
         }
     }
 
-    diag.help(if removed_all_fields {
-        "to avoid divergence in behavior between `Struct { .. }` and \
-         `<Struct as Default>::default()`, derive the `Default`"
+    if removed_all_fields {
+        let msg = "to avoid divergence in behavior between `Struct { .. }` and \
+                   `<Struct as Default>::default()`, derive the `Default`";
+        if let Some(hir::Node::Item(impl_)) = tcx.hir().get_if_local(impl_def_id) {
+            diag.multipart_suggestion_verbose(
+                msg,
+                vec![
+                    (tcx.def_span(type_def_id).shrink_to_lo(), "#[derive(Default)] ".to_string()),
+                    (impl_.span, String::new()),
+                ],
+                Applicability::MachineApplicable,
+            );
+        } else {
+            diag.help(msg);
+        }
     } else {
-        "use the default values in the `impl` with `Struct { mandatory_field, .. }` to avoid them \
-         diverging over time"
-    });
+        let msg = "use the default values in the `impl` with `Struct { mandatory_field, .. }` to \
+                   avoid them diverging over time";
+        diag.help(msg);
+    }
 }
diff --git a/tests/ui/structs/manual-default-impl-could-be-derived.stderr b/tests/ui/structs/manual-default-impl-could-be-derived.stderr
index e8f607fac7e..cf06d5418e1 100644
--- a/tests/ui/structs/manual-default-impl-could-be-derived.stderr
+++ b/tests/ui/structs/manual-default-impl-could-be-derived.stderr
@@ -31,7 +31,10 @@ LL | |             y: 0,
 LL | | }
    | |_^
    |
-   = help: to avoid divergence in behavior between `Struct { .. }` and `<Struct as Default>::default()`, derive the `Default`
+help: to avoid divergence in behavior between `Struct { .. }` and `<Struct as Default>::default()`, derive the `Default`
+   |
+LL ~ #[derive(Default)] struct B {
+   |
 
 error: `Default` impl doesn't use the declared default field values
   --> $DIR/manual-default-impl-could-be-derived.rs:43:1
-- 
cgit 1.4.1-3-g733a5


From 4bf85c25eceee6172ed3892570f36b5d06d5177f Mon Sep 17 00:00:00 2001
From: John Kåre Alsaker <john.kare.alsaker@gmail.com>
Date: Fri, 15 Mar 2024 19:09:24 +0100
Subject: Try to write the panic message with a single `write_all` call

---
 library/std/src/panicking.rs                       | 18 +++++++++++-
 .../exported_symbol_bad_unwind1.stderr             |  1 +
 .../exported_symbol_bad_unwind2.both.stderr        |  2 ++
 .../exported_symbol_bad_unwind2.definition.stderr  |  2 ++
 ...exported_symbol_bad_unwind2.extern_block.stderr |  1 +
 .../function_calls/return_pointer_on_unwind.stderr |  1 +
 .../fail/intrinsics/uninit_uninhabited_type.stderr |  1 +
 .../miri/tests/fail/intrinsics/zero_fn_ptr.stderr  |  1 +
 .../miri/tests/fail/panic/abort_unwind.stderr      |  2 ++
 src/tools/miri/tests/fail/panic/bad_unwind.stderr  |  1 +
 .../miri/tests/fail/panic/double_panic.stderr      |  3 ++
 .../miri/tests/fail/panic/panic_abort1.stderr      |  1 +
 .../miri/tests/fail/panic/panic_abort2.stderr      |  1 +
 .../miri/tests/fail/panic/panic_abort3.stderr      |  1 +
 .../miri/tests/fail/panic/panic_abort4.stderr      |  1 +
 .../fail/panic/tls_macro_const_drop_panic.stderr   |  1 +
 .../tests/fail/panic/tls_macro_drop_panic.stderr   |  1 +
 .../miri/tests/fail/terminate-terminator.stderr    |  2 ++
 .../miri/tests/fail/unwind-action-terminate.stderr |  2 ++
 .../tests/panic/alloc_error_handler_hook.stderr    |  1 +
 .../tests/panic/alloc_error_handler_panic.stderr   |  1 +
 src/tools/miri/tests/panic/div-by-zero-2.stderr    |  1 +
 .../exported_symbol_good_unwind.stderr             |  3 ++
 src/tools/miri/tests/panic/mir-validation.stderr   |  1 +
 src/tools/miri/tests/panic/oob_subslice.stderr     |  1 +
 .../miri/tests/panic/overflowing-lsh-neg.stderr    |  1 +
 .../miri/tests/panic/overflowing-rsh-1.stderr      |  1 +
 .../miri/tests/panic/overflowing-rsh-2.stderr      |  1 +
 src/tools/miri/tests/panic/panic1.stderr           |  1 +
 src/tools/miri/tests/panic/panic2.stderr           |  1 +
 src/tools/miri/tests/panic/panic3.stderr           |  1 +
 src/tools/miri/tests/panic/panic4.stderr           |  1 +
 src/tools/miri/tests/panic/transmute_fat2.stderr   |  1 +
 src/tools/miri/tests/pass/panic/catch_panic.stderr | 11 ++++++++
 .../miri/tests/pass/panic/concurrent-panic.stderr  |  2 ++
 .../tests/pass/panic/nested_panic_caught.stderr    |  2 ++
 .../miri/tests/pass/panic/thread_panic.stderr      |  2 ++
 tests/run-make/libtest-json/output-default.json    |  2 +-
 .../libtest-json/output-stdout-success.json        |  4 +--
 tests/run-make/libtest-junit/output-default.xml    |  2 +-
 .../libtest-junit/output-stdout-success.xml        |  2 +-
 .../doctest/failed-doctest-output-windows.stdout   |  1 +
 .../doctest/failed-doctest-output.stdout           |  1 +
 tests/rustdoc-ui/ice-bug-report-url.stderr         |  1 +
 .../remap-path-prefix-failed-doctest-output.stdout |  1 +
 .../synchronized-panic-handler.run.stderr          |  2 ++
 .../generic_const_exprs/issue-80742.stderr         |  1 +
 .../const-eval/const-eval-query-stack.stderr       |  1 +
 .../ui/extern/extern-types-field-offset.run.stderr |  1 +
 .../extern-types-size_of_val.align.run.stderr      |  1 +
 .../extern-types-size_of_val.size.run.stderr       |  1 +
 tests/ui/hygiene/panic-location.run.stderr         |  1 +
 .../const-eval-select-backtrace-std.run.stderr     |  1 +
 .../const-eval-select-backtrace.run.stderr         |  1 +
 tests/ui/intrinsics/not-overridden.stderr          |  1 +
 tests/ui/issues/issue-87707.run.stderr             |  2 ++
 tests/ui/layout/valid_range_oob.stderr             |  1 +
 tests/ui/macros/assert-long-condition.run.stderr   |  1 +
 tests/ui/mir/lint/storage-live.stderr              |  1 +
 tests/ui/panics/default-backtrace-ice.stderr       |  1 +
 tests/ui/panics/fmt-only-once.run.stderr           |  1 +
 .../panics/issue-47429-short-backtraces.run.stderr |  1 +
 .../location-detail-panic-no-column.run.stderr     |  1 +
 .../location-detail-panic-no-file.run.stderr       |  1 +
 .../location-detail-panic-no-line.run.stderr       |  1 +
 ...cation-detail-panic-no-location-info.run.stderr |  1 +
 .../location-detail-unwrap-no-file.run.stderr      |  1 +
 tests/ui/panics/panic-in-cleanup.run.stderr        |  3 ++
 tests/ui/panics/panic-in-ffi.run.stderr            |  2 ++
 tests/ui/panics/runtime-switch.run.stderr          |  1 +
 .../short-ice-remove-middle-frames-2.run.stderr    |  1 +
 .../short-ice-remove-middle-frames.run.stderr      |  1 +
 tests/ui/proc-macro/load-panic-backtrace.stderr    |  1 +
 tests/ui/process/multi-panic.rs                    | 32 ++++++++++++++--------
 .../ui/process/println-with-broken-pipe.run.stderr |  1 +
 .../multiple_definitions_attribute_merging.stderr  |  3 +-
 .../ui/resolve/proc_macro_generated_packed.stderr  |  3 +-
 tests/ui/test-attrs/terse.run.stdout               |  3 ++
 .../test-panic-abort-nocapture.run.stderr          |  2 ++
 tests/ui/test-attrs/test-panic-abort.run.stdout    |  1 +
 tests/ui/test-attrs/test-thread-capture.run.stdout |  1 +
 .../ui/test-attrs/test-thread-nocapture.run.stderr |  1 +
 tests/ui/track-diagnostics/track.stderr            |  1 +
 tests/ui/treat-err-as-bug/err.stderr               |  1 +
 tests/ui/treat-err-as-bug/span_delayed_bug.stderr  |  1 +
 85 files changed, 153 insertions(+), 20 deletions(-)

(limited to 'tests')

diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
index e7ce5bc6140..3b02254548b 100644
--- a/library/std/src/panicking.rs
+++ b/library/std/src/panicking.rs
@@ -266,7 +266,23 @@ fn default_hook(info: &PanicHookInfo<'_>) {
         // Use a lock to prevent mixed output in multithreading context.
         // Some platforms also require it when printing a backtrace, like `SymFromAddr` on Windows.
         let mut lock = backtrace::lock();
-        let _ = writeln!(err, "thread '{name}' panicked at {location}:\n{msg}");
+        // Try to write the panic message to a buffer first to prevent other concurrent outputs
+        // interleaving with it.
+        let mut buffer = [0u8; 512];
+        let mut cursor = crate::io::Cursor::new(&mut buffer[..]);
+
+        let write_msg = |dst: &mut dyn crate::io::Write| {
+            // We add a newline to ensure the panic message appears at the start of a line.
+            writeln!(dst, "\nthread '{name}' panicked at {location}:\n{msg}")
+        };
+
+        if write_msg(&mut cursor).is_ok() {
+            let pos = cursor.position() as usize;
+            let _ = err.write_all(&buffer[0..pos]);
+        } else {
+            // The message did not fit into the buffer, write it directly instead.
+            let _ = write_msg(err);
+        };
 
         static FIRST_PANIC: AtomicBool = AtomicBool::new(true);
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
index 5f306cc8ab1..8e63d78d759 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind1.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
index aef45042e8b..b2a501db776 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
@@ -1,7 +1,9 @@
+
 thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
index aef45042e8b..b2a501db776 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
@@ -1,7 +1,9 @@
+
 thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
index a81e8226e5a..767fd929fd4 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
index db876cb5ce6..e2a3d1600ea 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
index ffc3a3eae96..2c9bea1724d 100644
--- a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 aborted execution: attempted to instantiate uninhabited type `!`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
index 49cfc473bdf..0634298a38f 100644
--- a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 aborted execution: attempted to zero-initialize type `fn()`, which is invalid
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/panic/abort_unwind.stderr b/src/tools/miri/tests/fail/panic/abort_unwind.stderr
index e9c5413693e..3a63cb38ad0 100644
--- a/src/tools/miri/tests/fail/panic/abort_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/abort_unwind.stderr
@@ -1,7 +1,9 @@
+
 thread 'main' panicked at tests/fail/panic/abort_unwind.rs:LL:CC:
 PANIC!!!
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/fail/panic/bad_unwind.stderr b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
index c152d1a9605..6ba39e8f7e2 100644
--- a/src/tools/miri/tests/fail/panic/bad_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/panic/bad_unwind.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/panic/double_panic.stderr b/src/tools/miri/tests/fail/panic/double_panic.stderr
index 3e00821796e..16e933be434 100644
--- a/src/tools/miri/tests/fail/panic/double_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/double_panic.stderr
@@ -1,10 +1,13 @@
+
 thread 'main' panicked at tests/fail/panic/double_panic.rs:LL:CC:
 first
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at tests/fail/panic/double_panic.rs:LL:CC:
 second
 stack backtrace:
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a destructor during cleanup
 thread caused non-unwinding panic. aborting.
diff --git a/src/tools/miri/tests/fail/panic/panic_abort1.stderr b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
index c5f04d581ca..ca32722942f 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort1.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/panic/panic_abort1.rs:LL:CC:
 panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/panic/panic_abort2.stderr b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
index 535cddfd4d4..8d113d80588 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort2.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/panic/panic_abort2.rs:LL:CC:
 42-panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/panic/panic_abort3.stderr b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
index e74cf342e3f..2ce753ba689 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort3.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/panic/panic_abort3.rs:LL:CC:
 panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/panic/panic_abort4.stderr b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
index 3983d169bdd..c9c5ae107b7 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort4.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/fail/panic/panic_abort4.rs:LL:CC:
 42-panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr b/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
index d93062b4bdc..aadb9976609 100644
--- a/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
@@ -1,3 +1,4 @@
+
 thread $NAME panicked at tests/fail/panic/tls_macro_const_drop_panic.rs:LL:CC:
 ow
 fatal runtime error: thread local panicked on drop
diff --git a/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr b/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
index c0a2a30dbe1..546ee7e1ed2 100644
--- a/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
@@ -1,3 +1,4 @@
+
 thread $NAME panicked at tests/fail/panic/tls_macro_drop_panic.rs:LL:CC:
 ow
 fatal runtime error: thread local panicked on drop
diff --git a/src/tools/miri/tests/fail/terminate-terminator.stderr b/src/tools/miri/tests/fail/terminate-terminator.stderr
index e1c0fabd03d..f2548bf5cdb 100644
--- a/src/tools/miri/tests/fail/terminate-terminator.stderr
+++ b/src/tools/miri/tests/fail/terminate-terminator.stderr
@@ -1,9 +1,11 @@
 warning: You have explicitly enabled MIR optimizations, overriding Miri's default which is to completely disable them. Any optimizations may hide UB that Miri would otherwise detect, and it is not necessarily possible to predict what kind of UB will be missed. If you are enabling optimizations to make Miri run faster, we advise using cfg(miri) to shrink your workload instead. The performance benefit of enabling MIR optimizations is usually marginal at best.
 
+
 thread 'main' panicked at tests/fail/terminate-terminator.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/fail/unwind-action-terminate.stderr b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
index 81837122051..7b9a4383fc4 100644
--- a/src/tools/miri/tests/fail/unwind-action-terminate.stderr
+++ b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
@@ -1,7 +1,9 @@
+
 thread 'main' panicked at tests/fail/unwind-action-terminate.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr b/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
index 363298e49d9..2be06968321 100644
--- a/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
+++ b/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/alloc_error_handler_hook.rs:LL:CC:
 alloc error hook called
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr b/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
index 2cdff03f10f..ddee4fd6ce3 100644
--- a/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
+++ b/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at RUSTLIB/std/src/alloc.rs:LL:CC:
 memory allocation of 4 bytes failed
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/div-by-zero-2.stderr b/src/tools/miri/tests/panic/div-by-zero-2.stderr
index e47a754d38d..4d4b0062d5e 100644
--- a/src/tools/miri/tests/panic/div-by-zero-2.stderr
+++ b/src/tools/miri/tests/panic/div-by-zero-2.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/div-by-zero-2.rs:LL:CC:
 attempt to divide by zero
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr b/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
index ec75b6201c2..8bcd635e8be 100644
--- a/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
+++ b/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
@@ -1,8 +1,11 @@
+
 thread 'main' panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
 explicit panic
+
 thread 'main' panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
 explicit panic
diff --git a/src/tools/miri/tests/panic/mir-validation.stderr b/src/tools/miri/tests/panic/mir-validation.stderr
index 534e2d5881f..dc70d129da3 100644
--- a/src/tools/miri/tests/panic/mir-validation.stderr
+++ b/src/tools/miri/tests/panic/mir-validation.stderr
@@ -1,3 +1,4 @@
+
 thread 'rustc' panicked at compiler/rustc_mir_transform/src/validate.rs:LL:CC:
 broken MIR in Item(DefId) (after phase change to runtime-optimized) at bb0[1]:
 place (*(_2.0: *mut i32)) has deref as a later projection (it is only permitted as the first projection)
diff --git a/src/tools/miri/tests/panic/oob_subslice.stderr b/src/tools/miri/tests/panic/oob_subslice.stderr
index d608cec20a4..c0dabaff772 100644
--- a/src/tools/miri/tests/panic/oob_subslice.stderr
+++ b/src/tools/miri/tests/panic/oob_subslice.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/oob_subslice.rs:LL:CC:
 range end index 5 out of range for slice of length 4
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr b/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
index 29150052b30..d674e2beb8d 100644
--- a/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
+++ b/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/overflowing-lsh-neg.rs:LL:CC:
 attempt to shift left with overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/overflowing-rsh-1.stderr b/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
index 9a71a797dae..bb94f2e12c4 100644
--- a/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
+++ b/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/overflowing-rsh-1.rs:LL:CC:
 attempt to shift right with overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/overflowing-rsh-2.stderr b/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
index b671c53c611..0a29a57f3e1 100644
--- a/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
+++ b/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/overflowing-rsh-2.rs:LL:CC:
 attempt to shift right with overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/panic1.stderr b/src/tools/miri/tests/panic/panic1.stderr
index 7e011bfd53b..130bc7737a4 100644
--- a/src/tools/miri/tests/panic/panic1.stderr
+++ b/src/tools/miri/tests/panic/panic1.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/panic1.rs:LL:CC:
 panicking from libstd
 stack backtrace:
diff --git a/src/tools/miri/tests/panic/panic2.stderr b/src/tools/miri/tests/panic/panic2.stderr
index 5640bd0b8d6..157ffdb6b5d 100644
--- a/src/tools/miri/tests/panic/panic2.stderr
+++ b/src/tools/miri/tests/panic/panic2.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/panic2.rs:LL:CC:
 42-panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/panic3.stderr b/src/tools/miri/tests/panic/panic3.stderr
index 0114320503b..529ef70870b 100644
--- a/src/tools/miri/tests/panic/panic3.stderr
+++ b/src/tools/miri/tests/panic/panic3.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/panic3.rs:LL:CC:
 panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/panic4.stderr b/src/tools/miri/tests/panic/panic4.stderr
index f13b355ea45..ecd07dd7ded 100644
--- a/src/tools/miri/tests/panic/panic4.stderr
+++ b/src/tools/miri/tests/panic/panic4.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/panic4.rs:LL:CC:
 42-panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/panic/transmute_fat2.stderr b/src/tools/miri/tests/panic/transmute_fat2.stderr
index a9bc0eb9d01..71e2d7a8208 100644
--- a/src/tools/miri/tests/panic/transmute_fat2.stderr
+++ b/src/tools/miri/tests/panic/transmute_fat2.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at tests/panic/transmute_fat2.rs:LL:CC:
 index out of bounds: the len is 0 but the index is 0
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/tools/miri/tests/pass/panic/catch_panic.stderr b/src/tools/miri/tests/pass/panic/catch_panic.stderr
index cb74312a83a..bc745fca578 100644
--- a/src/tools/miri/tests/pass/panic/catch_panic.stderr
+++ b/src/tools/miri/tests/pass/panic/catch_panic.stderr
@@ -1,35 +1,46 @@
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 Hello from std::panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 Caught panic message (&str): Hello from std::panic
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 Hello from std::panic: 1
 Caught panic message (String): Hello from std::panic: 1
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 Hello from std::panic_any: 2
 Caught panic message (String): Hello from std::panic_any: 2
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 Box<dyn Any>
 Failed to get caught panic message.
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 Hello from core::panic
 Caught panic message (&str): Hello from core::panic
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 Hello from core::panic: 5
 Caught panic message (String): Hello from core::panic: 5
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 index out of bounds: the len is 3 but the index is 4
 Caught panic message (String): index out of bounds: the len is 3 but the index is 4
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 attempt to divide by zero
 Caught panic message (&str): attempt to divide by zero
+
 thread 'main' panicked at RUSTLIB/core/src/ptr/const_ptr.rs:LL:CC:
 align_offset: align is not a power-of-two
 Caught panic message (&str): align_offset: align is not a power-of-two
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 assertion failed: false
 Caught panic message (&str): assertion failed: false
+
 thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
 assertion failed: false
 Caught panic message (&str): assertion failed: false
diff --git a/src/tools/miri/tests/pass/panic/concurrent-panic.stderr b/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
index 9c87489e8db..4a3ac16debc 100644
--- a/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
+++ b/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
@@ -1,5 +1,6 @@
 Thread 1 starting, will block on mutex
 Thread 1 reported it has started
+
 thread '<unnamed>' panicked at tests/pass/panic/concurrent-panic.rs:LL:CC:
 panic in thread 2
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
@@ -7,6 +8,7 @@ note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE`
 Thread 2 blocking on thread 1
 Thread 2 reported it has started
 Unlocking mutex
+
 thread '<unnamed>' panicked at tests/pass/panic/concurrent-panic.rs:LL:CC:
 panic in thread 1
 Thread 1 has exited
diff --git a/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr b/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
index e066f7dfce1..8aff8f6ec55 100644
--- a/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
+++ b/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
@@ -1,7 +1,9 @@
+
 thread 'main' panicked at tests/pass/panic/nested_panic_caught.rs:LL:CC:
 once
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'main' panicked at tests/pass/panic/nested_panic_caught.rs:LL:CC:
 twice
 stack backtrace:
diff --git a/src/tools/miri/tests/pass/panic/thread_panic.stderr b/src/tools/miri/tests/pass/panic/thread_panic.stderr
index 9464e76b6c9..3bb2991805c 100644
--- a/src/tools/miri/tests/pass/panic/thread_panic.stderr
+++ b/src/tools/miri/tests/pass/panic/thread_panic.stderr
@@ -1,6 +1,8 @@
+
 thread '<unnamed>' panicked at tests/pass/panic/thread_panic.rs:LL:CC:
 Hello!
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+
 thread 'childthread' panicked at tests/pass/panic/thread_panic.rs:LL:CC:
 Hello, world!
diff --git a/tests/run-make/libtest-json/output-default.json b/tests/run-make/libtest-json/output-default.json
index a2293a032d0..a6a8a9f3b47 100644
--- a/tests/run-make/libtest-json/output-default.json
+++ b/tests/run-make/libtest-json/output-default.json
@@ -2,7 +2,7 @@
 { "type": "test", "event": "started", "name": "a" }
 { "type": "test", "name": "a", "event": "ok" }
 { "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'b' panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "\nthread 'b' panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
 { "type": "test", "event": "started", "name": "c" }
 { "type": "test", "name": "c", "event": "ok" }
 { "type": "test", "event": "started", "name": "d" }
diff --git a/tests/run-make/libtest-json/output-stdout-success.json b/tests/run-make/libtest-json/output-stdout-success.json
index cf92f01f63a..a6c36e746b3 100644
--- a/tests/run-make/libtest-json/output-stdout-success.json
+++ b/tests/run-make/libtest-json/output-stdout-success.json
@@ -2,9 +2,9 @@
 { "type": "test", "event": "started", "name": "a" }
 { "type": "test", "name": "a", "event": "ok", "stdout": "print from successful test\n" }
 { "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'b' panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "\nthread 'b' panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
 { "type": "test", "event": "started", "name": "c" }
-{ "type": "test", "name": "c", "event": "ok", "stdout": "thread 'c' panicked at f.rs:15:5:\nassertion failed: false\n" }
+{ "type": "test", "name": "c", "event": "ok", "stdout": "\nthread 'c' panicked at f.rs:15:5:\nassertion failed: false\n" }
 { "type": "test", "event": "started", "name": "d" }
 { "type": "test", "name": "d", "event": "ignored", "message": "msg" }
 { "type": "suite", "event": "failed", "passed": 2, "failed": 1, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": "$EXEC_TIME" }
diff --git a/tests/run-make/libtest-junit/output-default.xml b/tests/run-make/libtest-junit/output-default.xml
index 58a9a28744f..aa1b8c855aa 100644
--- a/tests/run-make/libtest-junit/output-default.xml
+++ b/tests/run-make/libtest-junit/output-default.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"/><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>&#xA;<![CDATA[thread 'b' panicked at f.rs:10:5:]]>&#xA;<![CDATA[assertion failed: false]]>&#xA;<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>&#xA;<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"/><system-out/><system-err/></testsuite></testsuites>
+<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"/><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>&#xA;&#xA;<![CDATA[thread 'b' panicked at f.rs:10:5:]]>&#xA;<![CDATA[assertion failed: false]]>&#xA;<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>&#xA;<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"/><system-out/><system-err/></testsuite></testsuites>
diff --git a/tests/run-make/libtest-junit/output-stdout-success.xml b/tests/run-make/libtest-junit/output-stdout-success.xml
index 723816a4acd..2592ec7efb1 100644
--- a/tests/run-make/libtest-junit/output-stdout-success.xml
+++ b/tests/run-make/libtest-junit/output-stdout-success.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"><system-out><![CDATA[print from successful test]]>&#xA;<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>&#xA;<![CDATA[thread 'b' panicked at f.rs:10:5:]]>&#xA;<![CDATA[assertion failed: false]]>&#xA;<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>&#xA;<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"><system-out><![CDATA[thread 'c' panicked at f.rs:16:5:]]>&#xA;<![CDATA[assertion failed: false]]>&#xA;<![CDATA[]]></system-out></testcase><system-out/><system-err/></testsuite></testsuites>
+<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"><system-out><![CDATA[print from successful test]]>&#xA;<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>&#xA;&#xA;<![CDATA[thread 'b' panicked at f.rs:10:5:]]>&#xA;<![CDATA[assertion failed: false]]>&#xA;<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>&#xA;<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"><system-out><![CDATA[]]>&#xA;<![CDATA[thread 'c' panicked at f.rs:16:5:]]>&#xA;<![CDATA[assertion failed: false]]>&#xA;<![CDATA[]]></system-out></testcase><system-out/><system-err/></testsuite></testsuites>
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
index 1b37249dd60..7aa965d543b 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
@@ -26,6 +26,7 @@ stdout 2
 stderr:
 stderr 1
 stderr 2
+
 thread 'main' panicked at $DIR/failed-doctest-output-windows.rs:7:1:
 oh no
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output.stdout b/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
index 7b0cf9a432d..a333f341ce5 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
@@ -26,6 +26,7 @@ stdout 2
 stderr:
 stderr 1
 stderr 2
+
 thread 'main' panicked at $DIR/failed-doctest-output.rs:7:1:
 oh no
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/rustdoc-ui/ice-bug-report-url.stderr b/tests/rustdoc-ui/ice-bug-report-url.stderr
index 66622a7654c..14a961c2ce0 100644
--- a/tests/rustdoc-ui/ice-bug-report-url.stderr
+++ b/tests/rustdoc-ui/ice-bug-report-url.stderr
@@ -5,6 +5,7 @@ LL | fn wrong()
    |          ^ expected one of `->`, `where`, or `{`
 
 
+
 aborting due to `-Z treat-err-as-bug=1`
 stack backtrace:
 
diff --git a/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout b/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout
index 2102e2c3891..87d1e772b80 100644
--- a/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout
+++ b/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout
@@ -8,6 +8,7 @@ failures:
 Test executable failed (exit status: 101).
 
 stderr:
+
 thread 'main' panicked at remapped_path/remap-path-prefix-failed-doctest-output.rs:3:1:
 oh no
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/backtrace/synchronized-panic-handler.run.stderr b/tests/ui/backtrace/synchronized-panic-handler.run.stderr
index 8a06d00ea59..7a60ef2da60 100644
--- a/tests/ui/backtrace/synchronized-panic-handler.run.stderr
+++ b/tests/ui/backtrace/synchronized-panic-handler.run.stderr
@@ -1,5 +1,7 @@
+
 thread '<unnamed>' panicked at $DIR/synchronized-panic-handler.rs:11:5:
 oops oh no woe is me
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
 thread '<unnamed>' panicked at $DIR/synchronized-panic-handler.rs:11:5:
 oops oh no woe is me
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr b/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
index 01529599d37..c851a8380f2 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
@@ -1,6 +1,7 @@
 error: internal compiler error: compiler/rustc_const_eval/src/interpret/operator.rs:LL:CC: unsized type for `NullaryOp::SizeOf`
   --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
 
+
 Box<dyn Any>
 query stack during panic:
 #0 [eval_to_allocation_raw] const-evaluating + checking `<impl at $DIR/issue-80742.rs:26:1: 28:32>::{constant#0}`
diff --git a/tests/ui/consts/const-eval/const-eval-query-stack.stderr b/tests/ui/consts/const-eval/const-eval-query-stack.stderr
index 0a28c5b80bf..5a71c770fdc 100644
--- a/tests/ui/consts/const-eval/const-eval-query-stack.stderr
+++ b/tests/ui/consts/const-eval/const-eval-query-stack.stderr
@@ -4,6 +4,7 @@ error: internal compiler error[E0080]: evaluation of constant value failed
 LL | const X: i32 = 1 / 0;
    |                ^^^^^ attempt to divide `1_i32` by zero
 
+
 note: please make sure that you have updated to the latest nightly
 
 query stack during panic:
diff --git a/tests/ui/extern/extern-types-field-offset.run.stderr b/tests/ui/extern/extern-types-field-offset.run.stderr
index 1b04b860db5..07bd4fcb13f 100644
--- a/tests/ui/extern/extern-types-field-offset.run.stderr
+++ b/tests/ui/extern/extern-types-field-offset.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
 attempted to compute the size or alignment of extern type `Opaque`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/extern/extern-types-size_of_val.align.run.stderr b/tests/ui/extern/extern-types-size_of_val.align.run.stderr
index 20c4d8785e8..5ba372d60fa 100644
--- a/tests/ui/extern/extern-types-size_of_val.align.run.stderr
+++ b/tests/ui/extern/extern-types-size_of_val.align.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
 attempted to compute the size or alignment of extern type `A`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/extern/extern-types-size_of_val.size.run.stderr b/tests/ui/extern/extern-types-size_of_val.size.run.stderr
index 20c4d8785e8..5ba372d60fa 100644
--- a/tests/ui/extern/extern-types-size_of_val.size.run.stderr
+++ b/tests/ui/extern/extern-types-size_of_val.size.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
 attempted to compute the size or alignment of extern type `A`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/hygiene/panic-location.run.stderr b/tests/ui/hygiene/panic-location.run.stderr
index b9086ecef81..5cd07dcda4c 100644
--- a/tests/ui/hygiene/panic-location.run.stderr
+++ b/tests/ui/hygiene/panic-location.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/panic-location.rs:LL:CC:
 capacity overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr b/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
index a0024c0920f..71d792b7f77 100644
--- a/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
+++ b/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/const-eval-select-backtrace-std.rs:6:8:
 byte index 1 is out of bounds of ``
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr b/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr
index 8f38d54146b..4f11f5966ed 100644
--- a/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr
+++ b/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/const-eval-select-backtrace.rs:15:5:
 Aaah!
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/intrinsics/not-overridden.stderr b/tests/ui/intrinsics/not-overridden.stderr
index 9b8849cea1c..b5273a4fa47 100644
--- a/tests/ui/intrinsics/not-overridden.stderr
+++ b/tests/ui/intrinsics/not-overridden.stderr
@@ -4,6 +4,7 @@ error: must be overridden by codegen backend, but isn't
 LL |     unsafe { const_deallocate(std::ptr::null_mut(), 0, 0) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+
 query stack during panic:
 end of query stack
 error: aborting due to 1 previous error
diff --git a/tests/ui/issues/issue-87707.run.stderr b/tests/ui/issues/issue-87707.run.stderr
index 255a77a6ab1..eb1d65a081f 100644
--- a/tests/ui/issues/issue-87707.run.stderr
+++ b/tests/ui/issues/issue-87707.run.stderr
@@ -1,5 +1,7 @@
+
 thread 'main' panicked at $DIR/issue-87707.rs:14:24:
 Here Once instance is poisoned.
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
 thread 'main' panicked at $DIR/issue-87707.rs:16:7:
 Once instance has previously been poisoned
diff --git a/tests/ui/layout/valid_range_oob.stderr b/tests/ui/layout/valid_range_oob.stderr
index d56804a35a7..9c360b2cd6e 100644
--- a/tests/ui/layout/valid_range_oob.stderr
+++ b/tests/ui/layout/valid_range_oob.stderr
@@ -1,3 +1,4 @@
+
 257 > 255
 error: the compiler unexpectedly panicked. this is a bug.
 
diff --git a/tests/ui/macros/assert-long-condition.run.stderr b/tests/ui/macros/assert-long-condition.run.stderr
index 5c0ff357cb7..c2c5fe5d7d5 100644
--- a/tests/ui/macros/assert-long-condition.run.stderr
+++ b/tests/ui/macros/assert-long-condition.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/assert-long-condition.rs:7:5:
 assertion failed: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18
                                 + 19 + 20 + 21 + 22 + 23 + 24 + 25 == 0
diff --git a/tests/ui/mir/lint/storage-live.stderr b/tests/ui/mir/lint/storage-live.stderr
index 7d4c3f0832a..c7012319512 100644
--- a/tests/ui/mir/lint/storage-live.stderr
+++ b/tests/ui/mir/lint/storage-live.stderr
@@ -11,6 +11,7 @@ note: delayed at compiler/rustc_mir_transform/src/lint.rs:LL:CC - disabled backt
 LL |             StorageLive(a);
    |             ^^^^^^^^^^^^^^
 
+
 aborting due to `-Z treat-err-as-bug=1`
 error: the compiler unexpectedly panicked. this is a bug.
 
diff --git a/tests/ui/panics/default-backtrace-ice.stderr b/tests/ui/panics/default-backtrace-ice.stderr
index 046b2cca7f9..2147b0971b5 100644
--- a/tests/ui/panics/default-backtrace-ice.stderr
+++ b/tests/ui/panics/default-backtrace-ice.stderr
@@ -5,6 +5,7 @@ LL | fn main() { missing_ident; }
    |             ^^^^^^^^^^^^^ not found in this scope
 
 
+
 aborting due to `-Z treat-err-as-bug=1`
 stack backtrace:
 (end_short_backtrace)
diff --git a/tests/ui/panics/fmt-only-once.run.stderr b/tests/ui/panics/fmt-only-once.run.stderr
index a991706d34e..faa3cc91151 100644
--- a/tests/ui/panics/fmt-only-once.run.stderr
+++ b/tests/ui/panics/fmt-only-once.run.stderr
@@ -1,4 +1,5 @@
 fmt
+
 thread 'main' panicked at $DIR/fmt-only-once.rs:20:5:
 PrintOnFmt
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/issue-47429-short-backtraces.run.stderr b/tests/ui/panics/issue-47429-short-backtraces.run.stderr
index 6a22e0215fe..c6e2d13fb5d 100644
--- a/tests/ui/panics/issue-47429-short-backtraces.run.stderr
+++ b/tests/ui/panics/issue-47429-short-backtraces.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/issue-47429-short-backtraces.rs:26:5:
 explicit panic
 stack backtrace:
diff --git a/tests/ui/panics/location-detail-panic-no-column.run.stderr b/tests/ui/panics/location-detail-panic-no-column.run.stderr
index 6d8d02a3a55..f63c09652b8 100644
--- a/tests/ui/panics/location-detail-panic-no-column.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-column.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/location-detail-panic-no-column.rs:7:0:
 column-redacted
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-panic-no-file.run.stderr b/tests/ui/panics/location-detail-panic-no-file.run.stderr
index 492ad37f5c7..3d1c6defa31 100644
--- a/tests/ui/panics/location-detail-panic-no-file.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-file.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at <redacted>:7:5:
 file-redacted
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-panic-no-line.run.stderr b/tests/ui/panics/location-detail-panic-no-line.run.stderr
index fdbc43c4311..9809ab5e2b4 100644
--- a/tests/ui/panics/location-detail-panic-no-line.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-line.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/location-detail-panic-no-line.rs:0:5:
 line-redacted
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-panic-no-location-info.run.stderr b/tests/ui/panics/location-detail-panic-no-location-info.run.stderr
index 1e9002df955..f68a0d663c0 100644
--- a/tests/ui/panics/location-detail-panic-no-location-info.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-location-info.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at <redacted>:0:0:
 no location info
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-unwrap-no-file.run.stderr b/tests/ui/panics/location-detail-unwrap-no-file.run.stderr
index 52019f62233..af4a4997fae 100644
--- a/tests/ui/panics/location-detail-unwrap-no-file.run.stderr
+++ b/tests/ui/panics/location-detail-unwrap-no-file.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at <redacted>:8:9:
 called `Option::unwrap()` on a `None` value
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/panic-in-cleanup.run.stderr b/tests/ui/panics/panic-in-cleanup.run.stderr
index e7def11b0e9..34383562c36 100644
--- a/tests/ui/panics/panic-in-cleanup.run.stderr
+++ b/tests/ui/panics/panic-in-cleanup.run.stderr
@@ -1,9 +1,12 @@
+
 thread 'main' panicked at $DIR/panic-in-cleanup.rs:22:5:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
 thread 'main' panicked at $DIR/panic-in-cleanup.rs:16:9:
 BOOM
 stack backtrace:
+
 thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
 panic in a destructor during cleanup
 thread caused non-unwinding panic. aborting.
diff --git a/tests/ui/panics/panic-in-ffi.run.stderr b/tests/ui/panics/panic-in-ffi.run.stderr
index fe8c2b04b91..a6f3ebe5657 100644
--- a/tests/ui/panics/panic-in-ffi.run.stderr
+++ b/tests/ui/panics/panic-in-ffi.run.stderr
@@ -1,7 +1,9 @@
+
 thread 'main' panicked at $DIR/panic-in-ffi.rs:21:5:
 Test
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 Noisy Drop
+
 thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/tests/ui/panics/runtime-switch.run.stderr b/tests/ui/panics/runtime-switch.run.stderr
index 35be010d6be..458a0ee534a 100644
--- a/tests/ui/panics/runtime-switch.run.stderr
+++ b/tests/ui/panics/runtime-switch.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/runtime-switch.rs:29:5:
 explicit panic
 stack backtrace:
diff --git a/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr b/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
index ab23ce78062..1fddcca6951 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
+++ b/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/short-ice-remove-middle-frames-2.rs:63:5:
 debug!!!
 stack backtrace:
diff --git a/tests/ui/panics/short-ice-remove-middle-frames.run.stderr b/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
index d2616911e3b..630b09d8d1e 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
+++ b/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at $DIR/short-ice-remove-middle-frames.rs:59:5:
 debug!!!
 stack backtrace:
diff --git a/tests/ui/proc-macro/load-panic-backtrace.stderr b/tests/ui/proc-macro/load-panic-backtrace.stderr
index 0f3db6c831e..a1049f5a324 100644
--- a/tests/ui/proc-macro/load-panic-backtrace.stderr
+++ b/tests/ui/proc-macro/load-panic-backtrace.stderr
@@ -1,3 +1,4 @@
+
 at $DIR/auxiliary/test-macros.rs:38:5:
 panic-derive
 error: proc-macro derive panicked
diff --git a/tests/ui/process/multi-panic.rs b/tests/ui/process/multi-panic.rs
index 02b69903654..ad47925a149 100644
--- a/tests/ui/process/multi-panic.rs
+++ b/tests/ui/process/multi-panic.rs
@@ -6,12 +6,17 @@
 fn check_for_no_backtrace(test: std::process::Output) {
     assert!(!test.status.success());
     let err = String::from_utf8_lossy(&test.stderr);
-    let mut it = err.lines();
+    let mut it = err.lines().filter(|l| !l.is_empty());
 
     assert_eq!(it.next().map(|l| l.starts_with("thread '<unnamed>' panicked")), Some(true));
     assert_eq!(it.next().is_some(), true);
-    assert_eq!(it.next(), Some("note: run with `RUST_BACKTRACE=1` \
-                                environment variable to display a backtrace"));
+    assert_eq!(
+        it.next(),
+        Some(
+            "note: run with `RUST_BACKTRACE=1` \
+                                environment variable to display a backtrace"
+        )
+    );
     assert_eq!(it.next().map(|l| l.starts_with("thread 'main' panicked at")), Some(true));
     assert_eq!(it.next().is_some(), true);
     assert_eq!(it.next(), None);
@@ -22,19 +27,22 @@ fn main() {
     if args.len() > 1 && args[1] == "run_test" {
         let _ = std::thread::spawn(|| {
             panic!();
-        }).join();
+        })
+        .join();
 
         panic!();
     } else {
-        let test = std::process::Command::new(&args[0]).arg("run_test")
-                                                       .env_remove("RUST_BACKTRACE")
-                                                       .output()
-                                                       .unwrap();
+        let test = std::process::Command::new(&args[0])
+            .arg("run_test")
+            .env_remove("RUST_BACKTRACE")
+            .output()
+            .unwrap();
         check_for_no_backtrace(test);
-        let test = std::process::Command::new(&args[0]).arg("run_test")
-                                                       .env("RUST_BACKTRACE","0")
-                                                       .output()
-                                                       .unwrap();
+        let test = std::process::Command::new(&args[0])
+            .arg("run_test")
+            .env("RUST_BACKTRACE", "0")
+            .output()
+            .unwrap();
         check_for_no_backtrace(test);
     }
 }
diff --git a/tests/ui/process/println-with-broken-pipe.run.stderr b/tests/ui/process/println-with-broken-pipe.run.stderr
index a334c0ad204..ab414994b56 100644
--- a/tests/ui/process/println-with-broken-pipe.run.stderr
+++ b/tests/ui/process/println-with-broken-pipe.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'main' panicked at library/std/src/io/stdio.rs:LL:CC:
 failed printing to stdout: Broken pipe (os error 32)
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/resolve/multiple_definitions_attribute_merging.stderr b/tests/ui/resolve/multiple_definitions_attribute_merging.stderr
index 98cad18d442..804fa079bb9 100644
--- a/tests/ui/resolve/multiple_definitions_attribute_merging.stderr
+++ b/tests/ui/resolve/multiple_definitions_attribute_merging.stderr
@@ -16,7 +16,8 @@ LL | #[repr(C)]
 LL | struct Dealigned<T>(u8, T);
    |                         ^
    |
-   = Box<dyn Any>
+   = 
+Box<dyn Any>
 query stack during panic:
 #0 [mir_built] building MIR for `<impl at $DIR/multiple_definitions_attribute_merging.rs:15:10: 15:19>::eq`
 #1 [check_unsafety] unsafety-checking `<impl at $DIR/multiple_definitions_attribute_merging.rs:15:10: 15:19>::eq`
diff --git a/tests/ui/resolve/proc_macro_generated_packed.stderr b/tests/ui/resolve/proc_macro_generated_packed.stderr
index 4e716704610..a5a02c9c393 100644
--- a/tests/ui/resolve/proc_macro_generated_packed.stderr
+++ b/tests/ui/resolve/proc_macro_generated_packed.stderr
@@ -7,7 +7,8 @@ LL | #[derive(PartialEq)]
 LL | struct Dealigned<T>(u8, T);
    |                         ^
    |
-   = Box<dyn Any>
+   = 
+Box<dyn Any>
 query stack during panic:
 #0 [mir_built] building MIR for `<impl at $DIR/proc_macro_generated_packed.rs:15:10: 15:19>::eq`
 #1 [check_unsafety] unsafety-checking `<impl at $DIR/proc_macro_generated_packed.rs:15:10: 15:19>::eq`
diff --git a/tests/ui/test-attrs/terse.run.stdout b/tests/ui/test-attrs/terse.run.stdout
index 2b361361ae8..ac1ac28c98d 100644
--- a/tests/ui/test-attrs/terse.run.stdout
+++ b/tests/ui/test-attrs/terse.run.stdout
@@ -9,15 +9,18 @@ foo2 --- FAILED
 failures:
 
 ---- abc stdout ----
+
 thread 'abc' panicked at $DIR/terse.rs:12:5:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
 ---- foo stdout ----
+
 thread 'foo' panicked at $DIR/terse.rs:17:5:
 explicit panic
 
 ---- foo2 stdout ----
+
 thread 'foo2' panicked at $DIR/terse.rs:22:5:
 explicit panic
 
diff --git a/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr b/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
index 16001b3eecd..25681171170 100644
--- a/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
+++ b/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
@@ -1,8 +1,10 @@
+
 thread 'main' panicked at $DIR/test-panic-abort-nocapture.rs:34:5:
 assertion `left == right` failed
   left: 2
  right: 4
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
 thread 'main' panicked at $DIR/test-panic-abort-nocapture.rs:28:5:
 assertion `left == right` failed
   left: 2
diff --git a/tests/ui/test-attrs/test-panic-abort.run.stdout b/tests/ui/test-attrs/test-panic-abort.run.stdout
index f5d14e77da9..844808e8637 100644
--- a/tests/ui/test-attrs/test-panic-abort.run.stdout
+++ b/tests/ui/test-attrs/test-panic-abort.run.stdout
@@ -17,6 +17,7 @@ hello, world
 testing123
 ---- it_fails stderr ----
 testing321
+
 thread 'main' panicked at $DIR/test-panic-abort.rs:39:5:
 assertion `left == right` failed
   left: 2
diff --git a/tests/ui/test-attrs/test-thread-capture.run.stdout b/tests/ui/test-attrs/test-thread-capture.run.stdout
index 31261aaa230..f9b9757f861 100644
--- a/tests/ui/test-attrs/test-thread-capture.run.stdout
+++ b/tests/ui/test-attrs/test-thread-capture.run.stdout
@@ -10,6 +10,7 @@ fee
 fie
 foe
 fum
+
 thread 'thready_fail' panicked at $DIR/test-thread-capture.rs:32:5:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/test-attrs/test-thread-nocapture.run.stderr b/tests/ui/test-attrs/test-thread-nocapture.run.stderr
index 9266fe84197..59560015fca 100644
--- a/tests/ui/test-attrs/test-thread-nocapture.run.stderr
+++ b/tests/ui/test-attrs/test-thread-nocapture.run.stderr
@@ -1,3 +1,4 @@
+
 thread 'thready_fail' panicked at $DIR/test-thread-nocapture.rs:32:5:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/track-diagnostics/track.stderr b/tests/ui/track-diagnostics/track.stderr
index 436f9ecf93d..d2908bb9177 100644
--- a/tests/ui/track-diagnostics/track.stderr
+++ b/tests/ui/track-diagnostics/track.stderr
@@ -24,6 +24,7 @@ LL |     break rust
    = note: rustc $VERSION running on $TARGET
    = note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics
 
+
 thread 'rustc' panicked at compiler/rustc_hir_typeck/src/lib.rs:LL:CC:
 Box<dyn Any>
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/treat-err-as-bug/err.stderr b/tests/ui/treat-err-as-bug/err.stderr
index eb7b50b4210..df5fed3fb8e 100644
--- a/tests/ui/treat-err-as-bug/err.stderr
+++ b/tests/ui/treat-err-as-bug/err.stderr
@@ -4,6 +4,7 @@ error: internal compiler error[E0080]: could not evaluate static initializer
 LL | pub static C: u32 = 0 - 1;
    |                     ^^^^^ attempt to compute `0_u32 - 1_u32`, which would overflow
 
+
 error: the compiler unexpectedly panicked. this is a bug.
 
 query stack during panic:
diff --git a/tests/ui/treat-err-as-bug/span_delayed_bug.stderr b/tests/ui/treat-err-as-bug/span_delayed_bug.stderr
index f0e8cd0ddb9..aec1b89c766 100644
--- a/tests/ui/treat-err-as-bug/span_delayed_bug.stderr
+++ b/tests/ui/treat-err-as-bug/span_delayed_bug.stderr
@@ -4,6 +4,7 @@ error: internal compiler error: delayed bug triggered by #[rustc_error(delayed_b
 LL | fn main() {}
    | ^^^^^^^^^
 
+
 error: the compiler unexpectedly panicked. this is a bug.
 
 query stack during panic:
-- 
cgit 1.4.1-3-g733a5


From d3c60672755fd7c5bfaabaac3af88961712a2b9a Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 1 Jan 2025 16:55:10 +0000
Subject: Fix ICE when opaque captures a duplicated/invalid lifetime

---
 compiler/rustc_ast_lowering/src/lib.rs               |  4 ++--
 compiler/rustc_hir/src/hir.rs                        | 16 +++++++++-------
 compiler/rustc_hir/src/intravisit.rs                 |  4 ++--
 compiler/rustc_hir_analysis/src/check/wfcheck.rs     |  5 ++++-
 tests/crashes/132766.rs                              |  9 ---------
 tests/ui/impl-trait/captured-invalid-lifetime.rs     | 19 +++++++++++++++++++
 tests/ui/impl-trait/captured-invalid-lifetime.stderr | 11 +++++++++++
 tests/ui/stats/input-stats.stderr                    | 12 ++++++------
 8 files changed, 53 insertions(+), 27 deletions(-)
 delete mode 100644 tests/crashes/132766.rs
 create mode 100644 tests/ui/impl-trait/captured-invalid-lifetime.rs
 create mode 100644 tests/ui/impl-trait/captured-invalid-lifetime.stderr

(limited to 'tests')

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 8438a421226..46e91636cfb 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1845,11 +1845,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             GenericParamKind::Lifetime => {
                 // AST resolution emitted an error on those parameters, so we lower them using
                 // `ParamName::Error`.
+                let ident = self.lower_ident(param.ident);
                 let param_name =
                     if let Some(LifetimeRes::Error) = self.resolver.get_lifetime_res(param.id) {
-                        ParamName::Error
+                        ParamName::Error(ident)
                     } else {
-                        let ident = self.lower_ident(param.ident);
                         ParamName::Plain(ident)
                     };
                 let kind =
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 8cea269f298..9218d515bfc 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -52,6 +52,13 @@ pub enum ParamName {
     /// Some user-given name like `T` or `'x`.
     Plain(Ident),
 
+    /// Indicates an illegal name was given and an error has been
+    /// reported (so we should squelch other derived errors).
+    ///
+    /// Occurs when, e.g., `'_` is used in the wrong place, or a
+    /// lifetime name is duplicated.
+    Error(Ident),
+
     /// Synthetic name generated when user elided a lifetime in an impl header.
     ///
     /// E.g., the lifetimes in cases like these:
@@ -67,18 +74,13 @@ pub enum ParamName {
     /// where `'f` is something like `Fresh(0)`. The indices are
     /// unique per impl, but not necessarily continuous.
     Fresh,
-
-    /// Indicates an illegal name was given and an error has been
-    /// reported (so we should squelch other derived errors). Occurs
-    /// when, e.g., `'_` is used in the wrong place.
-    Error,
 }
 
 impl ParamName {
     pub fn ident(&self) -> Ident {
         match *self {
-            ParamName::Plain(ident) => ident,
-            ParamName::Fresh | ParamName::Error => Ident::with_dummy_span(kw::UnderscoreLifetime),
+            ParamName::Plain(ident) | ParamName::Error(ident) => ident,
+            ParamName::Fresh => Ident::with_dummy_span(kw::UnderscoreLifetime),
         }
     }
 }
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 387a195cb29..a73cf367c0e 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -928,8 +928,8 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(
 ) -> V::Result {
     try_visit!(visitor.visit_id(param.hir_id));
     match param.name {
-        ParamName::Plain(ident) => try_visit!(visitor.visit_ident(ident)),
-        ParamName::Error | ParamName::Fresh => {}
+        ParamName::Plain(ident) | ParamName::Error(ident) => try_visit!(visitor.visit_ident(ident)),
+        ParamName::Fresh => {}
     }
     match param.kind {
         GenericParamKind::Lifetime { .. } => {}
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 3cddc9642ba..efffb24c81d 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -2007,7 +2007,10 @@ fn check_variances_for_type_defn<'tcx>(
         }
 
         match hir_param.name {
-            hir::ParamName::Error => {}
+            hir::ParamName::Error(_) => {
+                // Don't report a bivariance error for a lifetime that isn't
+                // even valid to name.
+            }
             _ => {
                 let has_explicit_bounds = explicitly_bounded_params.contains(&parameter);
                 report_bivariance(tcx, hir_param, has_explicit_bounds, item);
diff --git a/tests/crashes/132766.rs b/tests/crashes/132766.rs
deleted file mode 100644
index 5f5117d77a5..00000000000
--- a/tests/crashes/132766.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ known-bug: #132766
-
-trait Trait {}
-impl<'a> Trait for () {
-    fn pass2<'a>() -> impl Trait2 {}
-}
-
-trait Trait2 {}
-impl Trait2 for () {}
diff --git a/tests/ui/impl-trait/captured-invalid-lifetime.rs b/tests/ui/impl-trait/captured-invalid-lifetime.rs
new file mode 100644
index 00000000000..57cd2e85dd0
--- /dev/null
+++ b/tests/ui/impl-trait/captured-invalid-lifetime.rs
@@ -0,0 +1,19 @@
+// This uses edition 2024 for new lifetime capture rules.
+//@ edition: 2024
+
+// The problem here is that the presence of the opaque which captures all lifetimes in scope
+// means that the duplicated `'a` (which I'll call the dupe) is considered to be *early-bound*
+// since it shows up in the output but not the inputs. This is paired with the fact that we
+// were previously setting the name of the dupe to `'_` in the generic param definition, which
+// means that the identity args for the function were `['a#0, '_#1]` even though the lifetime
+// for the dupe should've been `'a#1`. This difference in symbol meant that NLL couldn't
+// actually match the lifetime against the identity lifetimes, leading to an ICE.
+
+struct Foo<'a>(&'a ());
+
+impl<'a> Foo<'a> {
+    fn pass<'a>() -> impl Sized {}
+    //~^ ERROR lifetime name `'a` shadows a lifetime name that is already in scope
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/captured-invalid-lifetime.stderr b/tests/ui/impl-trait/captured-invalid-lifetime.stderr
new file mode 100644
index 00000000000..c1315e34241
--- /dev/null
+++ b/tests/ui/impl-trait/captured-invalid-lifetime.stderr
@@ -0,0 +1,11 @@
+error[E0496]: lifetime name `'a` shadows a lifetime name that is already in scope
+  --> $DIR/captured-invalid-lifetime.rs:15:13
+   |
+LL | impl<'a> Foo<'a> {
+   |      -- first declared here
+LL |     fn pass<'a>() -> impl Sized {}
+   |             ^^ lifetime `'a` already in scope
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0496`.
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index 7183073d665..9b1568fa116 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -146,13 +146,13 @@ hir-stats Variant                  144 ( 1.6%)             2            72
 hir-stats GenericBound             256 ( 2.9%)             4            64
 hir-stats - Trait                    256 ( 2.9%)             4
 hir-stats Block                    288 ( 3.2%)             6            48
-hir-stats GenericParam             360 ( 4.0%)             5            72
 hir-stats Pat                      360 ( 4.0%)             5            72
 hir-stats - Struct                    72 ( 0.8%)             1
 hir-stats - Wild                      72 ( 0.8%)             1
 hir-stats - Binding                  216 ( 2.4%)             3
-hir-stats Generics                 560 ( 6.3%)            10            56
-hir-stats Ty                       720 ( 8.1%)            15            48
+hir-stats GenericParam             400 ( 4.5%)             5            80
+hir-stats Generics                 560 ( 6.2%)            10            56
+hir-stats Ty                       720 ( 8.0%)            15            48
 hir-stats - Ptr                       48 ( 0.5%)             1
 hir-stats - Ref                       48 ( 0.5%)             1
 hir-stats - Path                     624 ( 7.0%)            13
@@ -171,8 +171,8 @@ hir-stats - Impl                      88 ( 1.0%)             1
 hir-stats - Trait                     88 ( 1.0%)             1
 hir-stats - Fn                       176 ( 2.0%)             2
 hir-stats - Use                      352 ( 3.9%)             4
-hir-stats Path                   1_240 (13.9%)            31            40
-hir-stats PathSegment            1_920 (21.5%)            40            48
+hir-stats Path                   1_240 (13.8%)            31            40
+hir-stats PathSegment            1_920 (21.4%)            40            48
 hir-stats ----------------------------------------------------------------
-hir-stats Total                  8_936                   180
+hir-stats Total                  8_976                   180
 hir-stats
-- 
cgit 1.4.1-3-g733a5


From ee2ad4dfb1b7d3a07604efc6d9eb618d0fe3bf7d Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Mon, 23 Dec 2024 19:36:41 +0300
Subject: Move some things to `std::sync::poison` and reexport them in
 `std::sync`

---
 library/std/src/sync/barrier.rs                    |    1 +
 library/std/src/sync/condvar.rs                    |  569 ---------
 library/std/src/sync/condvar/tests.rs              |  190 ---
 library/std/src/sync/lazy_lock.rs                  |    3 +-
 library/std/src/sync/mod.rs                        |   56 +-
 library/std/src/sync/mutex.rs                      |  849 --------------
 library/std/src/sync/mutex/tests.rs                |  442 -------
 library/std/src/sync/once.rs                       |  390 -------
 library/std/src/sync/once/tests.rs                 |  162 ---
 library/std/src/sync/once_lock.rs                  |    1 +
 library/std/src/sync/poison.rs                     |   87 +-
 library/std/src/sync/poison/condvar.rs             |  571 ++++++++++
 library/std/src/sync/poison/condvar/tests.rs       |  190 +++
 library/std/src/sync/poison/mutex.rs               |  849 ++++++++++++++
 library/std/src/sync/poison/mutex/tests.rs         |  442 +++++++
 library/std/src/sync/poison/once.rs                |  390 +++++++
 library/std/src/sync/poison/once/tests.rs          |  162 +++
 library/std/src/sync/poison/rwlock.rs              | 1205 ++++++++++++++++++++
 library/std/src/sync/poison/rwlock/tests.rs        |  729 ++++++++++++
 library/std/src/sync/rwlock.rs                     | 1205 --------------------
 library/std/src/sync/rwlock/tests.rs               |  729 ------------
 library/std/src/sys/sync/once/futex.rs             |    2 +-
 library/std/src/sys/sync/once/no_threads.rs        |    2 +-
 library/std/src/sys/sync/once/queue.rs             |    2 +-
 tests/debuginfo/mutex.rs                           |    6 +-
 tests/debuginfo/rwlock-read.rs                     |    4 +-
 tests/debuginfo/rwlock-write.rs                    |    4 +-
 .../const-traits/span-bug-issue-121418.stderr      |    2 +-
 tests/ui/typeck/assign-non-lval-derefmut.stderr    |    4 +-
 29 files changed, 4676 insertions(+), 4572 deletions(-)
 delete mode 100644 library/std/src/sync/condvar.rs
 delete mode 100644 library/std/src/sync/condvar/tests.rs
 delete mode 100644 library/std/src/sync/mutex.rs
 delete mode 100644 library/std/src/sync/mutex/tests.rs
 delete mode 100644 library/std/src/sync/once.rs
 delete mode 100644 library/std/src/sync/once/tests.rs
 create mode 100644 library/std/src/sync/poison/condvar.rs
 create mode 100644 library/std/src/sync/poison/condvar/tests.rs
 create mode 100644 library/std/src/sync/poison/mutex.rs
 create mode 100644 library/std/src/sync/poison/mutex/tests.rs
 create mode 100644 library/std/src/sync/poison/once.rs
 create mode 100644 library/std/src/sync/poison/once/tests.rs
 create mode 100644 library/std/src/sync/poison/rwlock.rs
 create mode 100644 library/std/src/sync/poison/rwlock/tests.rs
 delete mode 100644 library/std/src/sync/rwlock.rs
 delete mode 100644 library/std/src/sync/rwlock/tests.rs

(limited to 'tests')

diff --git a/library/std/src/sync/barrier.rs b/library/std/src/sync/barrier.rs
index 14e4a9abe6f..862753e4765 100644
--- a/library/std/src/sync/barrier.rs
+++ b/library/std/src/sync/barrier.rs
@@ -2,6 +2,7 @@
 mod tests;
 
 use crate::fmt;
+// FIXME(nonpoison_mutex,nonpoison_condvar): switch to nonpoison versions once they are available
 use crate::sync::{Condvar, Mutex};
 
 /// A barrier enables multiple threads to synchronize the beginning
diff --git a/library/std/src/sync/condvar.rs b/library/std/src/sync/condvar.rs
deleted file mode 100644
index 44ffcb528d9..00000000000
--- a/library/std/src/sync/condvar.rs
+++ /dev/null
@@ -1,569 +0,0 @@
-#[cfg(test)]
-mod tests;
-
-use crate::fmt;
-use crate::sync::{LockResult, MutexGuard, PoisonError, mutex, poison};
-use crate::sys::sync as sys;
-use crate::time::{Duration, Instant};
-
-/// A type indicating whether a timed wait on a condition variable returned
-/// due to a time out or not.
-///
-/// It is returned by the [`wait_timeout`] method.
-///
-/// [`wait_timeout`]: Condvar::wait_timeout
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-#[stable(feature = "wait_timeout", since = "1.5.0")]
-pub struct WaitTimeoutResult(bool);
-
-impl WaitTimeoutResult {
-    /// Returns `true` if the wait was known to have timed out.
-    ///
-    /// # Examples
-    ///
-    /// This example spawns a thread which will sleep 20 milliseconds before
-    /// updating a boolean value and then notifying the condvar.
-    ///
-    /// The main thread will wait with a 10 millisecond timeout on the condvar
-    /// and will leave the loop upon timeout.
-    ///
-    /// ```
-    /// use std::sync::{Arc, Condvar, Mutex};
-    /// use std::thread;
-    /// use std::time::Duration;
-    ///
-    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// # let handle =
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///
-    ///     // Let's wait 20 milliseconds before notifying the condvar.
-    ///     thread::sleep(Duration::from_millis(20));
-    ///
-    ///     let mut started = lock.lock().unwrap();
-    ///     // We update the boolean value.
-    ///     *started = true;
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // Wait for the thread to start up.
-    /// let (lock, cvar) = &*pair;
-    /// loop {
-    ///     // Let's put a timeout on the condvar's wait.
-    ///     let result = cvar.wait_timeout(lock.lock().unwrap(), Duration::from_millis(10)).unwrap();
-    ///     // 10 milliseconds have passed.
-    ///     if result.1.timed_out() {
-    ///         // timed out now and we can leave.
-    ///         break
-    ///     }
-    /// }
-    /// # // Prevent leaks for Miri.
-    /// # let _ = handle.join();
-    /// ```
-    #[must_use]
-    #[stable(feature = "wait_timeout", since = "1.5.0")]
-    pub fn timed_out(&self) -> bool {
-        self.0
-    }
-}
-
-/// A Condition Variable
-///
-/// Condition variables represent the ability to block a thread such that it
-/// consumes no CPU time while waiting for an event to occur. Condition
-/// variables are typically associated with a boolean predicate (a condition)
-/// and a mutex. The predicate is always verified inside of the mutex before
-/// determining that a thread must block.
-///
-/// Functions in this module will block the current **thread** of execution.
-/// Note that any attempt to use multiple mutexes on the same condition
-/// variable may result in a runtime panic.
-///
-/// # Examples
-///
-/// ```
-/// use std::sync::{Arc, Mutex, Condvar};
-/// use std::thread;
-///
-/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-/// let pair2 = Arc::clone(&pair);
-///
-/// // Inside of our lock, spawn a new thread, and then wait for it to start.
-/// thread::spawn(move || {
-///     let (lock, cvar) = &*pair2;
-///     let mut started = lock.lock().unwrap();
-///     *started = true;
-///     // We notify the condvar that the value has changed.
-///     cvar.notify_one();
-/// });
-///
-/// // Wait for the thread to start up.
-/// let (lock, cvar) = &*pair;
-/// let mut started = lock.lock().unwrap();
-/// while !*started {
-///     started = cvar.wait(started).unwrap();
-/// }
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Condvar {
-    inner: sys::Condvar,
-}
-
-impl Condvar {
-    /// Creates a new condition variable which is ready to be waited on and
-    /// notified.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Condvar;
-    ///
-    /// let condvar = Condvar::new();
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
-    #[must_use]
-    #[inline]
-    pub const fn new() -> Condvar {
-        Condvar { inner: sys::Condvar::new() }
-    }
-
-    /// Blocks the current thread until this condition variable receives a
-    /// notification.
-    ///
-    /// This function will atomically unlock the mutex specified (represented by
-    /// `guard`) and block the current thread. This means that any calls
-    /// to [`notify_one`] or [`notify_all`] which happen logically after the
-    /// mutex is unlocked are candidates to wake this thread up. When this
-    /// function call returns, the lock specified will have been re-acquired.
-    ///
-    /// Note that this function is susceptible to spurious wakeups. Condition
-    /// variables normally have a boolean predicate associated with them, and
-    /// the predicate must always be checked each time this function returns to
-    /// protect against spurious wakeups.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the mutex being waited on is
-    /// poisoned when this thread re-acquires the lock. For more information,
-    /// see information about [poisoning] on the [`Mutex`] type.
-    ///
-    /// # Panics
-    ///
-    /// This function may [`panic!`] if it is used with more than one mutex
-    /// over time.
-    ///
-    /// [`notify_one`]: Self::notify_one
-    /// [`notify_all`]: Self::notify_all
-    /// [poisoning]: super::Mutex#poisoning
-    /// [`Mutex`]: super::Mutex
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    ///
-    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut started = lock.lock().unwrap();
-    ///     *started = true;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // Wait for the thread to start up.
-    /// let (lock, cvar) = &*pair;
-    /// let mut started = lock.lock().unwrap();
-    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
-    /// while !*started {
-    ///     started = cvar.wait(started).unwrap();
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> {
-        let poisoned = unsafe {
-            let lock = mutex::guard_lock(&guard);
-            self.inner.wait(lock);
-            mutex::guard_poison(&guard).get()
-        };
-        if poisoned { Err(PoisonError::new(guard)) } else { Ok(guard) }
-    }
-
-    /// Blocks the current thread until the provided condition becomes false.
-    ///
-    /// `condition` is checked immediately; if not met (returns `true`), this
-    /// will [`wait`] for the next notification then check again. This repeats
-    /// until `condition` returns `false`, in which case this function returns.
-    ///
-    /// This function will atomically unlock the mutex specified (represented by
-    /// `guard`) and block the current thread. This means that any calls
-    /// to [`notify_one`] or [`notify_all`] which happen logically after the
-    /// mutex is unlocked are candidates to wake this thread up. When this
-    /// function call returns, the lock specified will have been re-acquired.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the mutex being waited on is
-    /// poisoned when this thread re-acquires the lock. For more information,
-    /// see information about [poisoning] on the [`Mutex`] type.
-    ///
-    /// [`wait`]: Self::wait
-    /// [`notify_one`]: Self::notify_one
-    /// [`notify_all`]: Self::notify_all
-    /// [poisoning]: super::Mutex#poisoning
-    /// [`Mutex`]: super::Mutex
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    ///
-    /// let pair = Arc::new((Mutex::new(true), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut pending = lock.lock().unwrap();
-    ///     *pending = false;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // Wait for the thread to start up.
-    /// let (lock, cvar) = &*pair;
-    /// // As long as the value inside the `Mutex<bool>` is `true`, we wait.
-    /// let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();
-    /// ```
-    #[stable(feature = "wait_until", since = "1.42.0")]
-    pub fn wait_while<'a, T, F>(
-        &self,
-        mut guard: MutexGuard<'a, T>,
-        mut condition: F,
-    ) -> LockResult<MutexGuard<'a, T>>
-    where
-        F: FnMut(&mut T) -> bool,
-    {
-        while condition(&mut *guard) {
-            guard = self.wait(guard)?;
-        }
-        Ok(guard)
-    }
-
-    /// Waits on this condition variable for a notification, timing out after a
-    /// specified duration.
-    ///
-    /// The semantics of this function are equivalent to [`wait`]
-    /// except that the thread will be blocked for roughly no longer
-    /// than `ms` milliseconds. This method should not be used for
-    /// precise timing due to anomalies such as preemption or platform
-    /// differences that might not cause the maximum amount of time
-    /// waited to be precisely `ms`.
-    ///
-    /// Note that the best effort is made to ensure that the time waited is
-    /// measured with a monotonic clock, and not affected by the changes made to
-    /// the system time.
-    ///
-    /// The returned boolean is `false` only if the timeout is known
-    /// to have elapsed.
-    ///
-    /// Like [`wait`], the lock specified will be re-acquired when this function
-    /// returns, regardless of whether the timeout elapsed or not.
-    ///
-    /// [`wait`]: Self::wait
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    ///
-    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut started = lock.lock().unwrap();
-    ///     *started = true;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // Wait for the thread to start up.
-    /// let (lock, cvar) = &*pair;
-    /// let mut started = lock.lock().unwrap();
-    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
-    /// loop {
-    ///     let result = cvar.wait_timeout_ms(started, 10).unwrap();
-    ///     // 10 milliseconds have passed, or maybe the value changed!
-    ///     started = result.0;
-    ///     if *started == true {
-    ///         // We received the notification and the value has been updated, we can leave.
-    ///         break
-    ///     }
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.6.0", note = "replaced by `std::sync::Condvar::wait_timeout`")]
-    pub fn wait_timeout_ms<'a, T>(
-        &self,
-        guard: MutexGuard<'a, T>,
-        ms: u32,
-    ) -> LockResult<(MutexGuard<'a, T>, bool)> {
-        let res = self.wait_timeout(guard, Duration::from_millis(ms as u64));
-        poison::map_result(res, |(a, b)| (a, !b.timed_out()))
-    }
-
-    /// Waits on this condition variable for a notification, timing out after a
-    /// specified duration.
-    ///
-    /// The semantics of this function are equivalent to [`wait`] except that
-    /// the thread will be blocked for roughly no longer than `dur`. This
-    /// method should not be used for precise timing due to anomalies such as
-    /// preemption or platform differences that might not cause the maximum
-    /// amount of time waited to be precisely `dur`.
-    ///
-    /// Note that the best effort is made to ensure that the time waited is
-    /// measured with a monotonic clock, and not affected by the changes made to
-    /// the system time. This function is susceptible to spurious wakeups.
-    /// Condition variables normally have a boolean predicate associated with
-    /// them, and the predicate must always be checked each time this function
-    /// returns to protect against spurious wakeups. Additionally, it is
-    /// typically desirable for the timeout to not exceed some duration in
-    /// spite of spurious wakes, thus the sleep-duration is decremented by the
-    /// amount slept. Alternatively, use the `wait_timeout_while` method
-    /// to wait with a timeout while a predicate is true.
-    ///
-    /// The returned [`WaitTimeoutResult`] value indicates if the timeout is
-    /// known to have elapsed.
-    ///
-    /// Like [`wait`], the lock specified will be re-acquired when this function
-    /// returns, regardless of whether the timeout elapsed or not.
-    ///
-    /// [`wait`]: Self::wait
-    /// [`wait_timeout_while`]: Self::wait_timeout_while
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    /// use std::time::Duration;
-    ///
-    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut started = lock.lock().unwrap();
-    ///     *started = true;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // wait for the thread to start up
-    /// let (lock, cvar) = &*pair;
-    /// let mut started = lock.lock().unwrap();
-    /// // as long as the value inside the `Mutex<bool>` is `false`, we wait
-    /// loop {
-    ///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();
-    ///     // 10 milliseconds have passed, or maybe the value changed!
-    ///     started = result.0;
-    ///     if *started == true {
-    ///         // We received the notification and the value has been updated, we can leave.
-    ///         break
-    ///     }
-    /// }
-    /// ```
-    #[stable(feature = "wait_timeout", since = "1.5.0")]
-    pub fn wait_timeout<'a, T>(
-        &self,
-        guard: MutexGuard<'a, T>,
-        dur: Duration,
-    ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)> {
-        let (poisoned, result) = unsafe {
-            let lock = mutex::guard_lock(&guard);
-            let success = self.inner.wait_timeout(lock, dur);
-            (mutex::guard_poison(&guard).get(), WaitTimeoutResult(!success))
-        };
-        if poisoned { Err(PoisonError::new((guard, result))) } else { Ok((guard, result)) }
-    }
-
-    /// Waits on this condition variable for a notification, timing out after a
-    /// specified duration.
-    ///
-    /// The semantics of this function are equivalent to [`wait_while`] except
-    /// that the thread will be blocked for roughly no longer than `dur`. This
-    /// method should not be used for precise timing due to anomalies such as
-    /// preemption or platform differences that might not cause the maximum
-    /// amount of time waited to be precisely `dur`.
-    ///
-    /// Note that the best effort is made to ensure that the time waited is
-    /// measured with a monotonic clock, and not affected by the changes made to
-    /// the system time.
-    ///
-    /// The returned [`WaitTimeoutResult`] value indicates if the timeout is
-    /// known to have elapsed without the condition being met.
-    ///
-    /// Like [`wait_while`], the lock specified will be re-acquired when this
-    /// function returns, regardless of whether the timeout elapsed or not.
-    ///
-    /// [`wait_while`]: Self::wait_while
-    /// [`wait_timeout`]: Self::wait_timeout
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    /// use std::time::Duration;
-    ///
-    /// let pair = Arc::new((Mutex::new(true), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut pending = lock.lock().unwrap();
-    ///     *pending = false;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // wait for the thread to start up
-    /// let (lock, cvar) = &*pair;
-    /// let result = cvar.wait_timeout_while(
-    ///     lock.lock().unwrap(),
-    ///     Duration::from_millis(100),
-    ///     |&mut pending| pending,
-    /// ).unwrap();
-    /// if result.1.timed_out() {
-    ///     // timed-out without the condition ever evaluating to false.
-    /// }
-    /// // access the locked mutex via result.0
-    /// ```
-    #[stable(feature = "wait_timeout_until", since = "1.42.0")]
-    pub fn wait_timeout_while<'a, T, F>(
-        &self,
-        mut guard: MutexGuard<'a, T>,
-        dur: Duration,
-        mut condition: F,
-    ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)>
-    where
-        F: FnMut(&mut T) -> bool,
-    {
-        let start = Instant::now();
-        loop {
-            if !condition(&mut *guard) {
-                return Ok((guard, WaitTimeoutResult(false)));
-            }
-            let timeout = match dur.checked_sub(start.elapsed()) {
-                Some(timeout) => timeout,
-                None => return Ok((guard, WaitTimeoutResult(true))),
-            };
-            guard = self.wait_timeout(guard, timeout)?.0;
-        }
-    }
-
-    /// Wakes up one blocked thread on this condvar.
-    ///
-    /// If there is a blocked thread on this condition variable, then it will
-    /// be woken up from its call to [`wait`] or [`wait_timeout`]. Calls to
-    /// `notify_one` are not buffered in any way.
-    ///
-    /// To wake up all threads, see [`notify_all`].
-    ///
-    /// [`wait`]: Self::wait
-    /// [`wait_timeout`]: Self::wait_timeout
-    /// [`notify_all`]: Self::notify_all
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    ///
-    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut started = lock.lock().unwrap();
-    ///     *started = true;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_one();
-    /// });
-    ///
-    /// // Wait for the thread to start up.
-    /// let (lock, cvar) = &*pair;
-    /// let mut started = lock.lock().unwrap();
-    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
-    /// while !*started {
-    ///     started = cvar.wait(started).unwrap();
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn notify_one(&self) {
-        self.inner.notify_one()
-    }
-
-    /// Wakes up all blocked threads on this condvar.
-    ///
-    /// This method will ensure that any current waiters on the condition
-    /// variable are awoken. Calls to `notify_all()` are not buffered in any
-    /// way.
-    ///
-    /// To wake up only one thread, see [`notify_one`].
-    ///
-    /// [`notify_one`]: Self::notify_one
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex, Condvar};
-    /// use std::thread;
-    ///
-    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    /// let pair2 = Arc::clone(&pair);
-    ///
-    /// thread::spawn(move || {
-    ///     let (lock, cvar) = &*pair2;
-    ///     let mut started = lock.lock().unwrap();
-    ///     *started = true;
-    ///     // We notify the condvar that the value has changed.
-    ///     cvar.notify_all();
-    /// });
-    ///
-    /// // Wait for the thread to start up.
-    /// let (lock, cvar) = &*pair;
-    /// let mut started = lock.lock().unwrap();
-    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
-    /// while !*started {
-    ///     started = cvar.wait(started).unwrap();
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn notify_all(&self) {
-        self.inner.notify_all()
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl fmt::Debug for Condvar {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Condvar").finish_non_exhaustive()
-    }
-}
-
-#[stable(feature = "condvar_default", since = "1.10.0")]
-impl Default for Condvar {
-    /// Creates a `Condvar` which is ready to be waited on and notified.
-    fn default() -> Condvar {
-        Condvar::new()
-    }
-}
diff --git a/library/std/src/sync/condvar/tests.rs b/library/std/src/sync/condvar/tests.rs
deleted file mode 100644
index f9e9066bc92..00000000000
--- a/library/std/src/sync/condvar/tests.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-use crate::sync::atomic::{AtomicBool, Ordering};
-use crate::sync::mpsc::channel;
-use crate::sync::{Arc, Condvar, Mutex};
-use crate::thread;
-use crate::time::Duration;
-
-#[test]
-fn smoke() {
-    let c = Condvar::new();
-    c.notify_one();
-    c.notify_all();
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
-fn notify_one() {
-    let m = Arc::new(Mutex::new(()));
-    let m2 = m.clone();
-    let c = Arc::new(Condvar::new());
-    let c2 = c.clone();
-
-    let g = m.lock().unwrap();
-    let _t = thread::spawn(move || {
-        let _g = m2.lock().unwrap();
-        c2.notify_one();
-    });
-    let g = c.wait(g).unwrap();
-    drop(g);
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
-fn notify_all() {
-    const N: usize = 10;
-
-    let data = Arc::new((Mutex::new(0), Condvar::new()));
-    let (tx, rx) = channel();
-    for _ in 0..N {
-        let data = data.clone();
-        let tx = tx.clone();
-        thread::spawn(move || {
-            let &(ref lock, ref cond) = &*data;
-            let mut cnt = lock.lock().unwrap();
-            *cnt += 1;
-            if *cnt == N {
-                tx.send(()).unwrap();
-            }
-            while *cnt != 0 {
-                cnt = cond.wait(cnt).unwrap();
-            }
-            tx.send(()).unwrap();
-        });
-    }
-    drop(tx);
-
-    let &(ref lock, ref cond) = &*data;
-    rx.recv().unwrap();
-    let mut cnt = lock.lock().unwrap();
-    *cnt = 0;
-    cond.notify_all();
-    drop(cnt);
-
-    for _ in 0..N {
-        rx.recv().unwrap();
-    }
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
-fn wait_while() {
-    let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    let pair2 = pair.clone();
-
-    // Inside of our lock, spawn a new thread, and then wait for it to start.
-    thread::spawn(move || {
-        let &(ref lock, ref cvar) = &*pair2;
-        let mut started = lock.lock().unwrap();
-        *started = true;
-        // We notify the condvar that the value has changed.
-        cvar.notify_one();
-    });
-
-    // Wait for the thread to start up.
-    let &(ref lock, ref cvar) = &*pair;
-    let guard = cvar.wait_while(lock.lock().unwrap(), |started| !*started);
-    assert!(*guard.unwrap());
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // condvar wait not supported
-fn wait_timeout_wait() {
-    let m = Arc::new(Mutex::new(()));
-    let c = Arc::new(Condvar::new());
-
-    loop {
-        let g = m.lock().unwrap();
-        let (_g, no_timeout) = c.wait_timeout(g, Duration::from_millis(1)).unwrap();
-        // spurious wakeups mean this isn't necessarily true
-        // so execute test again, if not timeout
-        if !no_timeout.timed_out() {
-            continue;
-        }
-
-        break;
-    }
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // condvar wait not supported
-fn wait_timeout_while_wait() {
-    let m = Arc::new(Mutex::new(()));
-    let c = Arc::new(Condvar::new());
-
-    let g = m.lock().unwrap();
-    let (_g, wait) = c.wait_timeout_while(g, Duration::from_millis(1), |_| true).unwrap();
-    // no spurious wakeups. ensure it timed-out
-    assert!(wait.timed_out());
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // condvar wait not supported
-fn wait_timeout_while_instant_satisfy() {
-    let m = Arc::new(Mutex::new(()));
-    let c = Arc::new(Condvar::new());
-
-    let g = m.lock().unwrap();
-    let (_g, wait) = c.wait_timeout_while(g, Duration::from_millis(0), |_| false).unwrap();
-    // ensure it didn't time-out even if we were not given any time.
-    assert!(!wait.timed_out());
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
-fn wait_timeout_while_wake() {
-    let pair = Arc::new((Mutex::new(false), Condvar::new()));
-    let pair_copy = pair.clone();
-
-    let &(ref m, ref c) = &*pair;
-    let g = m.lock().unwrap();
-    let _t = thread::spawn(move || {
-        let &(ref lock, ref cvar) = &*pair_copy;
-        let mut started = lock.lock().unwrap();
-        thread::sleep(Duration::from_millis(1));
-        *started = true;
-        cvar.notify_one();
-    });
-    let (g2, wait) = c
-        .wait_timeout_while(g, Duration::from_millis(u64::MAX), |&mut notified| !notified)
-        .unwrap();
-    // ensure it didn't time-out even if we were not given any time.
-    assert!(!wait.timed_out());
-    assert!(*g2);
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
-fn wait_timeout_wake() {
-    let m = Arc::new(Mutex::new(()));
-    let c = Arc::new(Condvar::new());
-
-    loop {
-        let g = m.lock().unwrap();
-
-        let c2 = c.clone();
-        let m2 = m.clone();
-
-        let notified = Arc::new(AtomicBool::new(false));
-        let notified_copy = notified.clone();
-
-        let t = thread::spawn(move || {
-            let _g = m2.lock().unwrap();
-            thread::sleep(Duration::from_millis(1));
-            notified_copy.store(true, Ordering::Relaxed);
-            c2.notify_one();
-        });
-        let (g, timeout_res) = c.wait_timeout(g, Duration::from_millis(u64::MAX)).unwrap();
-        assert!(!timeout_res.timed_out());
-        // spurious wakeups mean this isn't necessarily true
-        // so execute test again, if not notified
-        if !notified.load(Ordering::Relaxed) {
-            t.join().unwrap();
-            continue;
-        }
-        drop(g);
-
-        t.join().unwrap();
-
-        break;
-    }
-}
diff --git a/library/std/src/sync/lazy_lock.rs b/library/std/src/sync/lazy_lock.rs
index 40510f56134..1e4f9b79e0f 100644
--- a/library/std/src/sync/lazy_lock.rs
+++ b/library/std/src/sync/lazy_lock.rs
@@ -1,4 +1,4 @@
-use super::once::ExclusiveState;
+use super::poison::once::ExclusiveState;
 use crate::cell::UnsafeCell;
 use crate::mem::ManuallyDrop;
 use crate::ops::Deref;
@@ -63,6 +63,7 @@ union Data<T, F> {
 /// ```
 #[stable(feature = "lazy_cell", since = "1.80.0")]
 pub struct LazyLock<T, F = fn() -> T> {
+    // FIXME(nonpoison_once): if possible, switch to nonpoison version once it is available
     once: Once,
     data: UnsafeCell<Data<T, F>>,
 }
diff --git a/library/std/src/sync/mod.rs b/library/std/src/sync/mod.rs
index 0fb77331293..5b50a3c6ccf 100644
--- a/library/std/src/sync/mod.rs
+++ b/library/std/src/sync/mod.rs
@@ -167,6 +167,10 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+// No formatting: this file is just re-exports, and their order is worth preserving.
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+// These come from `core` & `alloc` and only in one flavor: no poisoning.
 #[unstable(feature = "exclusive_wrapper", issue = "98407")]
 pub use core::sync::Exclusive;
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -175,40 +179,54 @@ pub use core::sync::atomic;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use alloc_crate::sync::{Arc, Weak};
 
+// FIXME(sync_nonpoison,sync_poison_mod): remove all `#[doc(inline)]` once the modules are stabilized.
+
+// These exist only in one flavor: no poisoning.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::barrier::{Barrier, BarrierWaitResult};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::condvar::{Condvar, WaitTimeoutResult};
 #[stable(feature = "lazy_cell", since = "1.80.0")]
 pub use self::lazy_lock::LazyLock;
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-pub use self::mutex::MappedMutexGuard;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::mutex::{Mutex, MutexGuard};
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(deprecated)]
-pub use self::once::{ONCE_INIT, Once, OnceState};
 #[stable(feature = "once_cell", since = "1.70.0")]
 pub use self::once_lock::OnceLock;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::poison::{LockResult, PoisonError, TryLockError, TryLockResult};
 #[unstable(feature = "reentrant_lock", issue = "121440")]
 pub use self::reentrant_lock::{ReentrantLock, ReentrantLockGuard};
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-pub use self::rwlock::{MappedRwLockReadGuard, MappedRwLockWriteGuard};
+
+// These make sense and exist only with poisoning.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use self::rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+#[doc(inline)]
+pub use self::poison::{LockResult, PoisonError};
+
+// These (should) exist in both flavors: with and without poisoning.
+// FIXME(sync_nonpoison): implement nonpoison versions:
+//  * Mutex (nonpoison_mutex)
+//  * Condvar (nonpoison_condvar)
+//  * Once (nonpoison_once)
+//  * RwLock (nonpoison_rwlock)
+// The historical default is the version with poisoning.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[doc(inline)]
+pub use self::poison::{
+    Mutex, MutexGuard, TryLockError, TryLockResult,
+    Condvar, WaitTimeoutResult,
+    Once, OnceState,
+    RwLock, RwLockReadGuard, RwLockWriteGuard,
+};
+#[stable(feature = "rust1", since = "1.0.0")]
+#[doc(inline)]
+#[expect(deprecated)]
+pub use self::poison::ONCE_INIT;
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+#[doc(inline)]
+pub use self::poison::{MappedMutexGuard, MappedRwLockReadGuard, MappedRwLockWriteGuard};
 
 #[unstable(feature = "mpmc_channel", issue = "126840")]
 pub mod mpmc;
 pub mod mpsc;
 
+#[unstable(feature = "sync_poison_mod", issue = "134646")]
+pub mod poison;
+
 mod barrier;
-mod condvar;
 mod lazy_lock;
-mod mutex;
-pub(crate) mod once;
 mod once_lock;
-mod poison;
 mod reentrant_lock;
-mod rwlock;
diff --git a/library/std/src/sync/mutex.rs b/library/std/src/sync/mutex.rs
deleted file mode 100644
index e28c2090afe..00000000000
--- a/library/std/src/sync/mutex.rs
+++ /dev/null
@@ -1,849 +0,0 @@
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
-use crate::cell::UnsafeCell;
-use crate::fmt;
-use crate::marker::PhantomData;
-use crate::mem::{self, ManuallyDrop};
-use crate::ops::{Deref, DerefMut};
-use crate::ptr::NonNull;
-use crate::sync::{LockResult, PoisonError, TryLockError, TryLockResult, poison};
-use crate::sys::sync as sys;
-
-/// A mutual exclusion primitive useful for protecting shared data
-///
-/// This mutex will block threads waiting for the lock to become available. The
-/// mutex can be created via a [`new`] constructor. Each mutex has a type parameter
-/// which represents the data that it is protecting. The data can only be accessed
-/// through the RAII guards returned from [`lock`] and [`try_lock`], which
-/// guarantees that the data is only ever accessed when the mutex is locked.
-///
-/// # Poisoning
-///
-/// The mutexes in this module implement a strategy called "poisoning" where a
-/// mutex is considered poisoned whenever a thread panics while holding the
-/// mutex. Once a mutex is poisoned, all other threads are unable to access the
-/// data by default as it is likely tainted (some invariant is not being
-/// upheld).
-///
-/// For a mutex, this means that the [`lock`] and [`try_lock`] methods return a
-/// [`Result`] which indicates whether a mutex has been poisoned or not. Most
-/// usage of a mutex will simply [`unwrap()`] these results, propagating panics
-/// among threads to ensure that a possibly invalid invariant is not witnessed.
-///
-/// A poisoned mutex, however, does not prevent all access to the underlying
-/// data. The [`PoisonError`] type has an [`into_inner`] method which will return
-/// the guard that would have otherwise been returned on a successful lock. This
-/// allows access to the data, despite the lock being poisoned.
-///
-/// [`new`]: Self::new
-/// [`lock`]: Self::lock
-/// [`try_lock`]: Self::try_lock
-/// [`unwrap()`]: Result::unwrap
-/// [`PoisonError`]: super::PoisonError
-/// [`into_inner`]: super::PoisonError::into_inner
-///
-/// # Examples
-///
-/// ```
-/// use std::sync::{Arc, Mutex};
-/// use std::thread;
-/// use std::sync::mpsc::channel;
-///
-/// const N: usize = 10;
-///
-/// // Spawn a few threads to increment a shared variable (non-atomically), and
-/// // let the main thread know once all increments are done.
-/// //
-/// // Here we're using an Arc to share memory among threads, and the data inside
-/// // the Arc is protected with a mutex.
-/// let data = Arc::new(Mutex::new(0));
-///
-/// let (tx, rx) = channel();
-/// for _ in 0..N {
-///     let (data, tx) = (Arc::clone(&data), tx.clone());
-///     thread::spawn(move || {
-///         // The shared state can only be accessed once the lock is held.
-///         // Our non-atomic increment is safe because we're the only thread
-///         // which can access the shared state when the lock is held.
-///         //
-///         // We unwrap() the return value to assert that we are not expecting
-///         // threads to ever fail while holding the lock.
-///         let mut data = data.lock().unwrap();
-///         *data += 1;
-///         if *data == N {
-///             tx.send(()).unwrap();
-///         }
-///         // the lock is unlocked here when `data` goes out of scope.
-///     });
-/// }
-///
-/// rx.recv().unwrap();
-/// ```
-///
-/// To recover from a poisoned mutex:
-///
-/// ```
-/// use std::sync::{Arc, Mutex};
-/// use std::thread;
-///
-/// let lock = Arc::new(Mutex::new(0_u32));
-/// let lock2 = Arc::clone(&lock);
-///
-/// let _ = thread::spawn(move || -> () {
-///     // This thread will acquire the mutex first, unwrapping the result of
-///     // `lock` because the lock has not been poisoned.
-///     let _guard = lock2.lock().unwrap();
-///
-///     // This panic while holding the lock (`_guard` is in scope) will poison
-///     // the mutex.
-///     panic!();
-/// }).join();
-///
-/// // The lock is poisoned by this point, but the returned result can be
-/// // pattern matched on to return the underlying guard on both branches.
-/// let mut guard = match lock.lock() {
-///     Ok(guard) => guard,
-///     Err(poisoned) => poisoned.into_inner(),
-/// };
-///
-/// *guard += 1;
-/// ```
-///
-/// To unlock a mutex guard sooner than the end of the enclosing scope,
-/// either create an inner scope or drop the guard manually.
-///
-/// ```
-/// use std::sync::{Arc, Mutex};
-/// use std::thread;
-///
-/// const N: usize = 3;
-///
-/// let data_mutex = Arc::new(Mutex::new(vec![1, 2, 3, 4]));
-/// let res_mutex = Arc::new(Mutex::new(0));
-///
-/// let mut threads = Vec::with_capacity(N);
-/// (0..N).for_each(|_| {
-///     let data_mutex_clone = Arc::clone(&data_mutex);
-///     let res_mutex_clone = Arc::clone(&res_mutex);
-///
-///     threads.push(thread::spawn(move || {
-///         // Here we use a block to limit the lifetime of the lock guard.
-///         let result = {
-///             let mut data = data_mutex_clone.lock().unwrap();
-///             // This is the result of some important and long-ish work.
-///             let result = data.iter().fold(0, |acc, x| acc + x * 2);
-///             data.push(result);
-///             result
-///             // The mutex guard gets dropped here, together with any other values
-///             // created in the critical section.
-///         };
-///         // The guard created here is a temporary dropped at the end of the statement, i.e.
-///         // the lock would not remain being held even if the thread did some additional work.
-///         *res_mutex_clone.lock().unwrap() += result;
-///     }));
-/// });
-///
-/// let mut data = data_mutex.lock().unwrap();
-/// // This is the result of some important and long-ish work.
-/// let result = data.iter().fold(0, |acc, x| acc + x * 2);
-/// data.push(result);
-/// // We drop the `data` explicitly because it's not necessary anymore and the
-/// // thread still has work to do. This allows other threads to start working on
-/// // the data immediately, without waiting for the rest of the unrelated work
-/// // to be done here.
-/// //
-/// // It's even more important here than in the threads because we `.join` the
-/// // threads after that. If we had not dropped the mutex guard, a thread could
-/// // be waiting forever for it, causing a deadlock.
-/// // As in the threads, a block could have been used instead of calling the
-/// // `drop` function.
-/// drop(data);
-/// // Here the mutex guard is not assigned to a variable and so, even if the
-/// // scope does not end after this line, the mutex is still released: there is
-/// // no deadlock.
-/// *res_mutex.lock().unwrap() += result;
-///
-/// threads.into_iter().for_each(|thread| {
-///     thread
-///         .join()
-///         .expect("The thread creating or execution failed !")
-/// });
-///
-/// assert_eq!(*res_mutex.lock().unwrap(), 800);
-/// ```
-///
-#[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(test), rustc_diagnostic_item = "Mutex")]
-pub struct Mutex<T: ?Sized> {
-    inner: sys::Mutex,
-    poison: poison::Flag,
-    data: UnsafeCell<T>,
-}
-
-// these are the only places where `T: Send` matters; all other
-// functionality works fine on a single thread.
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: ?Sized + Send> Send for Mutex<T> {}
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}
-
-/// An RAII implementation of a "scoped lock" of a mutex. When this structure is
-/// dropped (falls out of scope), the lock will be unlocked.
-///
-/// The data protected by the mutex can be accessed through this guard via its
-/// [`Deref`] and [`DerefMut`] implementations.
-///
-/// This structure is created by the [`lock`] and [`try_lock`] methods on
-/// [`Mutex`].
-///
-/// [`lock`]: Mutex::lock
-/// [`try_lock`]: Mutex::try_lock
-#[must_use = "if unused the Mutex will immediately unlock"]
-#[must_not_suspend = "holding a MutexGuard across suspend \
-                      points can cause deadlocks, delays, \
-                      and cause Futures to not implement `Send`"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[clippy::has_significant_drop]
-#[cfg_attr(not(test), rustc_diagnostic_item = "MutexGuard")]
-pub struct MutexGuard<'a, T: ?Sized + 'a> {
-    lock: &'a Mutex<T>,
-    poison: poison::Guard,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> !Send for MutexGuard<'_, T> {}
-#[stable(feature = "mutexguard", since = "1.19.0")]
-unsafe impl<T: ?Sized + Sync> Sync for MutexGuard<'_, T> {}
-
-/// An RAII mutex guard returned by `MutexGuard::map`, which can point to a
-/// subfield of the protected data. When this structure is dropped (falls out
-/// of scope), the lock will be unlocked.
-///
-/// The main difference between `MappedMutexGuard` and [`MutexGuard`] is that the
-/// former cannot be used with [`Condvar`], since that
-/// could introduce soundness issues if the locked object is modified by another
-/// thread while the `Mutex` is unlocked.
-///
-/// The data protected by the mutex can be accessed through this guard via its
-/// [`Deref`] and [`DerefMut`] implementations.
-///
-/// This structure is created by the [`map`] and [`try_map`] methods on
-/// [`MutexGuard`].
-///
-/// [`map`]: MutexGuard::map
-/// [`try_map`]: MutexGuard::try_map
-/// [`Condvar`]: crate::sync::Condvar
-#[must_use = "if unused the Mutex will immediately unlock"]
-#[must_not_suspend = "holding a MappedMutexGuard across suspend \
-                      points can cause deadlocks, delays, \
-                      and cause Futures to not implement `Send`"]
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-#[clippy::has_significant_drop]
-pub struct MappedMutexGuard<'a, T: ?Sized + 'a> {
-    // NB: we use a pointer instead of `&'a mut T` to avoid `noalias` violations, because a
-    // `MappedMutexGuard` argument doesn't hold uniqueness for its whole scope, only until it drops.
-    // `NonNull` is covariant over `T`, so we add a `PhantomData<&'a mut T>` field
-    // below for the correct variance over `T` (invariance).
-    data: NonNull<T>,
-    inner: &'a sys::Mutex,
-    poison_flag: &'a poison::Flag,
-    poison: poison::Guard,
-    _variance: PhantomData<&'a mut T>,
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> !Send for MappedMutexGuard<'_, T> {}
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-unsafe impl<T: ?Sized + Sync> Sync for MappedMutexGuard<'_, T> {}
-
-impl<T> Mutex<T> {
-    /// Creates a new mutex in an unlocked state ready for use.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Mutex;
-    ///
-    /// let mutex = Mutex::new(0);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
-    #[inline]
-    pub const fn new(t: T) -> Mutex<T> {
-        Mutex { inner: sys::Mutex::new(), poison: poison::Flag::new(), data: UnsafeCell::new(t) }
-    }
-
-    /// Returns the contained value by cloning it.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(lock_value_accessors)]
-    ///
-    /// use std::sync::Mutex;
-    ///
-    /// let mut mutex = Mutex::new(7);
-    ///
-    /// assert_eq!(mutex.get_cloned().unwrap(), 7);
-    /// ```
-    #[unstable(feature = "lock_value_accessors", issue = "133407")]
-    pub fn get_cloned(&self) -> Result<T, PoisonError<()>>
-    where
-        T: Clone,
-    {
-        match self.lock() {
-            Ok(guard) => Ok((*guard).clone()),
-            Err(_) => Err(PoisonError::new(())),
-        }
-    }
-
-    /// Sets the contained value.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error containing the provided `value` instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(lock_value_accessors)]
-    ///
-    /// use std::sync::Mutex;
-    ///
-    /// let mut mutex = Mutex::new(7);
-    ///
-    /// assert_eq!(mutex.get_cloned().unwrap(), 7);
-    /// mutex.set(11).unwrap();
-    /// assert_eq!(mutex.get_cloned().unwrap(), 11);
-    /// ```
-    #[unstable(feature = "lock_value_accessors", issue = "133407")]
-    pub fn set(&self, value: T) -> Result<(), PoisonError<T>> {
-        if mem::needs_drop::<T>() {
-            // If the contained value has non-trivial destructor, we
-            // call that destructor after the lock being released.
-            self.replace(value).map(drop)
-        } else {
-            match self.lock() {
-                Ok(mut guard) => {
-                    *guard = value;
-
-                    Ok(())
-                }
-                Err(_) => Err(PoisonError::new(value)),
-            }
-        }
-    }
-
-    /// Replaces the contained value with `value`, and returns the old contained value.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error containing the provided `value` instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(lock_value_accessors)]
-    ///
-    /// use std::sync::Mutex;
-    ///
-    /// let mut mutex = Mutex::new(7);
-    ///
-    /// assert_eq!(mutex.replace(11).unwrap(), 7);
-    /// assert_eq!(mutex.get_cloned().unwrap(), 11);
-    /// ```
-    #[unstable(feature = "lock_value_accessors", issue = "133407")]
-    pub fn replace(&self, value: T) -> LockResult<T> {
-        match self.lock() {
-            Ok(mut guard) => Ok(mem::replace(&mut *guard, value)),
-            Err(_) => Err(PoisonError::new(value)),
-        }
-    }
-}
-
-impl<T: ?Sized> Mutex<T> {
-    /// Acquires a mutex, blocking the current thread until it is able to do so.
-    ///
-    /// This function will block the local thread until it is available to acquire
-    /// the mutex. Upon returning, the thread is the only thread with the lock
-    /// held. An RAII guard is returned to allow scoped unlock of the lock. When
-    /// the guard goes out of scope, the mutex will be unlocked.
-    ///
-    /// The exact behavior on locking a mutex in the thread which already holds
-    /// the lock is left unspecified. However, this function will not return on
-    /// the second call (it might panic or deadlock, for example).
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error once the mutex is acquired. The acquired
-    /// mutex guard will be contained in the returned error.
-    ///
-    /// # Panics
-    ///
-    /// This function might panic when called if the lock is already held by
-    /// the current thread.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex};
-    /// use std::thread;
-    ///
-    /// let mutex = Arc::new(Mutex::new(0));
-    /// let c_mutex = Arc::clone(&mutex);
-    ///
-    /// thread::spawn(move || {
-    ///     *c_mutex.lock().unwrap() = 10;
-    /// }).join().expect("thread::spawn failed");
-    /// assert_eq!(*mutex.lock().unwrap(), 10);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
-        unsafe {
-            self.inner.lock();
-            MutexGuard::new(self)
-        }
-    }
-
-    /// Attempts to acquire this lock.
-    ///
-    /// If the lock could not be acquired at this time, then [`Err`] is returned.
-    /// Otherwise, an RAII guard is returned. The lock will be unlocked when the
-    /// guard is dropped.
-    ///
-    /// This function does not block.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return the [`Poisoned`] error if the mutex would
-    /// otherwise be acquired. An acquired lock guard will be contained
-    /// in the returned error.
-    ///
-    /// If the mutex could not be acquired because it is already locked, then
-    /// this call will return the [`WouldBlock`] error.
-    ///
-    /// [`Poisoned`]: TryLockError::Poisoned
-    /// [`WouldBlock`]: TryLockError::WouldBlock
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex};
-    /// use std::thread;
-    ///
-    /// let mutex = Arc::new(Mutex::new(0));
-    /// let c_mutex = Arc::clone(&mutex);
-    ///
-    /// thread::spawn(move || {
-    ///     let mut lock = c_mutex.try_lock();
-    ///     if let Ok(ref mut mutex) = lock {
-    ///         **mutex = 10;
-    ///     } else {
-    ///         println!("try_lock failed");
-    ///     }
-    /// }).join().expect("thread::spawn failed");
-    /// assert_eq!(*mutex.lock().unwrap(), 10);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>> {
-        unsafe {
-            if self.inner.try_lock() {
-                Ok(MutexGuard::new(self)?)
-            } else {
-                Err(TryLockError::WouldBlock)
-            }
-        }
-    }
-
-    /// Determines whether the mutex is poisoned.
-    ///
-    /// If another thread is active, the mutex can still become poisoned at any
-    /// time. You should not trust a `false` value for program correctness
-    /// without additional synchronization.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex};
-    /// use std::thread;
-    ///
-    /// let mutex = Arc::new(Mutex::new(0));
-    /// let c_mutex = Arc::clone(&mutex);
-    ///
-    /// let _ = thread::spawn(move || {
-    ///     let _lock = c_mutex.lock().unwrap();
-    ///     panic!(); // the mutex gets poisoned
-    /// }).join();
-    /// assert_eq!(mutex.is_poisoned(), true);
-    /// ```
-    #[inline]
-    #[stable(feature = "sync_poison", since = "1.2.0")]
-    pub fn is_poisoned(&self) -> bool {
-        self.poison.get()
-    }
-
-    /// Clear the poisoned state from a mutex.
-    ///
-    /// If the mutex is poisoned, it will remain poisoned until this function is called. This
-    /// allows recovering from a poisoned state and marking that it has recovered. For example, if
-    /// the value is overwritten by a known-good value, then the mutex can be marked as
-    /// un-poisoned. Or possibly, the value could be inspected to determine if it is in a
-    /// consistent state, and if so the poison is removed.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, Mutex};
-    /// use std::thread;
-    ///
-    /// let mutex = Arc::new(Mutex::new(0));
-    /// let c_mutex = Arc::clone(&mutex);
-    ///
-    /// let _ = thread::spawn(move || {
-    ///     let _lock = c_mutex.lock().unwrap();
-    ///     panic!(); // the mutex gets poisoned
-    /// }).join();
-    ///
-    /// assert_eq!(mutex.is_poisoned(), true);
-    /// let x = mutex.lock().unwrap_or_else(|mut e| {
-    ///     **e.get_mut() = 1;
-    ///     mutex.clear_poison();
-    ///     e.into_inner()
-    /// });
-    /// assert_eq!(mutex.is_poisoned(), false);
-    /// assert_eq!(*x, 1);
-    /// ```
-    #[inline]
-    #[stable(feature = "mutex_unpoison", since = "1.77.0")]
-    pub fn clear_poison(&self) {
-        self.poison.clear();
-    }
-
-    /// Consumes this mutex, returning the underlying data.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error containing the the underlying data
-    /// instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Mutex;
-    ///
-    /// let mutex = Mutex::new(0);
-    /// assert_eq!(mutex.into_inner().unwrap(), 0);
-    /// ```
-    #[stable(feature = "mutex_into_inner", since = "1.6.0")]
-    pub fn into_inner(self) -> LockResult<T>
-    where
-        T: Sized,
-    {
-        let data = self.data.into_inner();
-        poison::map_result(self.poison.borrow(), |()| data)
-    }
-
-    /// Returns a mutable reference to the underlying data.
-    ///
-    /// Since this call borrows the `Mutex` mutably, no actual locking needs to
-    /// take place -- the mutable borrow statically guarantees no locks exist.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error containing a mutable reference to the
-    /// underlying data instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Mutex;
-    ///
-    /// let mut mutex = Mutex::new(0);
-    /// *mutex.get_mut().unwrap() = 10;
-    /// assert_eq!(*mutex.lock().unwrap(), 10);
-    /// ```
-    #[stable(feature = "mutex_get_mut", since = "1.6.0")]
-    pub fn get_mut(&mut self) -> LockResult<&mut T> {
-        let data = self.data.get_mut();
-        poison::map_result(self.poison.borrow(), |()| data)
-    }
-}
-
-#[stable(feature = "mutex_from", since = "1.24.0")]
-impl<T> From<T> for Mutex<T> {
-    /// Creates a new mutex in an unlocked state ready for use.
-    /// This is equivalent to [`Mutex::new`].
-    fn from(t: T) -> Self {
-        Mutex::new(t)
-    }
-}
-
-#[stable(feature = "mutex_default", since = "1.10.0")]
-impl<T: ?Sized + Default> Default for Mutex<T> {
-    /// Creates a `Mutex<T>`, with the `Default` value for T.
-    fn default() -> Mutex<T> {
-        Mutex::new(Default::default())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut d = f.debug_struct("Mutex");
-        match self.try_lock() {
-            Ok(guard) => {
-                d.field("data", &&*guard);
-            }
-            Err(TryLockError::Poisoned(err)) => {
-                d.field("data", &&**err.get_ref());
-            }
-            Err(TryLockError::WouldBlock) => {
-                d.field("data", &format_args!("<locked>"));
-            }
-        }
-        d.field("poisoned", &self.poison.get());
-        d.finish_non_exhaustive()
-    }
-}
-
-impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
-    unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> {
-        poison::map_result(lock.poison.guard(), |guard| MutexGuard { lock, poison: guard })
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Deref for MutexGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe { &*self.lock.data.get() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.lock.data.get() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Drop for MutexGuard<'_, T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            self.lock.poison.done(&self.poison);
-            self.lock.inner.unlock();
-        }
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
-    }
-}
-
-#[stable(feature = "std_guard_impls", since = "1.20.0")]
-impl<T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {
-    &guard.lock.inner
-}
-
-pub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {
-    &guard.lock.poison
-}
-
-impl<'a, T: ?Sized> MutexGuard<'a, T> {
-    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data, e.g.
-    /// an enum variant.
-    ///
-    /// The `Mutex` is already locked, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MutexGuard::map(...)`. A method would interfere with methods of the
-    /// same name on the contents of the `MutexGuard` used through `Deref`.
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn map<U, F>(orig: Self, f: F) -> MappedMutexGuard<'a, U>
-    where
-        F: FnOnce(&mut T) -> &mut U,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        let data = NonNull::from(f(unsafe { &mut *orig.lock.data.get() }));
-        let orig = ManuallyDrop::new(orig);
-        MappedMutexGuard {
-            data,
-            inner: &orig.lock.inner,
-            poison_flag: &orig.lock.poison,
-            poison: orig.poison.clone(),
-            _variance: PhantomData,
-        }
-    }
-
-    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data. The
-    /// original guard is returned as an `Err(...)` if the closure returns
-    /// `None`.
-    ///
-    /// The `Mutex` is already locked, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MutexGuard::try_map(...)`. A method would interfere with methods of the
-    /// same name on the contents of the `MutexGuard` used through `Deref`.
-    #[doc(alias = "filter_map")]
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedMutexGuard<'a, U>, Self>
-    where
-        F: FnOnce(&mut T) -> Option<&mut U>,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        match f(unsafe { &mut *orig.lock.data.get() }) {
-            Some(data) => {
-                let data = NonNull::from(data);
-                let orig = ManuallyDrop::new(orig);
-                Ok(MappedMutexGuard {
-                    data,
-                    inner: &orig.lock.inner,
-                    poison_flag: &orig.lock.poison,
-                    poison: orig.poison.clone(),
-                    _variance: PhantomData,
-                })
-            }
-            None => Err(orig),
-        }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> Deref for MappedMutexGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe { self.data.as_ref() }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> DerefMut for MappedMutexGuard<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe { self.data.as_mut() }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> Drop for MappedMutexGuard<'_, T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            self.poison_flag.done(&self.poison);
-            self.inner.unlock();
-        }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for MappedMutexGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized + fmt::Display> fmt::Display for MappedMutexGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<'a, T: ?Sized> MappedMutexGuard<'a, T> {
-    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data, e.g.
-    /// an enum variant.
-    ///
-    /// The `Mutex` is already locked, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MappedMutexGuard::map(...)`. A method would interfere with methods of the
-    /// same name on the contents of the `MutexGuard` used through `Deref`.
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn map<U, F>(mut orig: Self, f: F) -> MappedMutexGuard<'a, U>
-    where
-        F: FnOnce(&mut T) -> &mut U,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        let data = NonNull::from(f(unsafe { orig.data.as_mut() }));
-        let orig = ManuallyDrop::new(orig);
-        MappedMutexGuard {
-            data,
-            inner: orig.inner,
-            poison_flag: orig.poison_flag,
-            poison: orig.poison.clone(),
-            _variance: PhantomData,
-        }
-    }
-
-    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data. The
-    /// original guard is returned as an `Err(...)` if the closure returns
-    /// `None`.
-    ///
-    /// The `Mutex` is already locked, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MappedMutexGuard::try_map(...)`. A method would interfere with methods of the
-    /// same name on the contents of the `MutexGuard` used through `Deref`.
-    #[doc(alias = "filter_map")]
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn try_map<U, F>(mut orig: Self, f: F) -> Result<MappedMutexGuard<'a, U>, Self>
-    where
-        F: FnOnce(&mut T) -> Option<&mut U>,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        match f(unsafe { orig.data.as_mut() }) {
-            Some(data) => {
-                let data = NonNull::from(data);
-                let orig = ManuallyDrop::new(orig);
-                Ok(MappedMutexGuard {
-                    data,
-                    inner: orig.inner,
-                    poison_flag: orig.poison_flag,
-                    poison: orig.poison.clone(),
-                    _variance: PhantomData,
-                })
-            }
-            None => Err(orig),
-        }
-    }
-}
diff --git a/library/std/src/sync/mutex/tests.rs b/library/std/src/sync/mutex/tests.rs
deleted file mode 100644
index 395c8aada08..00000000000
--- a/library/std/src/sync/mutex/tests.rs
+++ /dev/null
@@ -1,442 +0,0 @@
-use crate::fmt::Debug;
-use crate::ops::FnMut;
-use crate::panic::{self, AssertUnwindSafe};
-use crate::sync::atomic::{AtomicUsize, Ordering};
-use crate::sync::mpsc::channel;
-use crate::sync::{Arc, Condvar, MappedMutexGuard, Mutex, MutexGuard, TryLockError};
-use crate::{hint, mem, thread};
-
-struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
-
-#[derive(Eq, PartialEq, Debug)]
-struct NonCopy(i32);
-
-#[derive(Eq, PartialEq, Debug)]
-struct NonCopyNeedsDrop(i32);
-
-impl Drop for NonCopyNeedsDrop {
-    fn drop(&mut self) {
-        hint::black_box(());
-    }
-}
-
-#[test]
-fn test_needs_drop() {
-    assert!(!mem::needs_drop::<NonCopy>());
-    assert!(mem::needs_drop::<NonCopyNeedsDrop>());
-}
-
-#[derive(Clone, Eq, PartialEq, Debug)]
-struct Cloneable(i32);
-
-#[test]
-fn smoke() {
-    let m = Mutex::new(());
-    drop(m.lock().unwrap());
-    drop(m.lock().unwrap());
-}
-
-#[test]
-fn lots_and_lots() {
-    const J: u32 = 1000;
-    const K: u32 = 3;
-
-    let m = Arc::new(Mutex::new(0));
-
-    fn inc(m: &Mutex<u32>) {
-        for _ in 0..J {
-            *m.lock().unwrap() += 1;
-        }
-    }
-
-    let (tx, rx) = channel();
-    for _ in 0..K {
-        let tx2 = tx.clone();
-        let m2 = m.clone();
-        thread::spawn(move || {
-            inc(&m2);
-            tx2.send(()).unwrap();
-        });
-        let tx2 = tx.clone();
-        let m2 = m.clone();
-        thread::spawn(move || {
-            inc(&m2);
-            tx2.send(()).unwrap();
-        });
-    }
-
-    drop(tx);
-    for _ in 0..2 * K {
-        rx.recv().unwrap();
-    }
-    assert_eq!(*m.lock().unwrap(), J * K * 2);
-}
-
-#[test]
-fn try_lock() {
-    let m = Mutex::new(());
-    *m.try_lock().unwrap() = ();
-}
-
-fn new_poisoned_mutex<T>(value: T) -> Mutex<T> {
-    let mutex = Mutex::new(value);
-
-    let catch_unwind_result = panic::catch_unwind(AssertUnwindSafe(|| {
-        let _guard = mutex.lock().unwrap();
-
-        panic!("test panic to poison mutex");
-    }));
-
-    assert!(catch_unwind_result.is_err());
-    assert!(mutex.is_poisoned());
-
-    mutex
-}
-
-#[test]
-fn test_into_inner() {
-    let m = Mutex::new(NonCopy(10));
-    assert_eq!(m.into_inner().unwrap(), NonCopy(10));
-}
-
-#[test]
-fn test_into_inner_drop() {
-    struct Foo(Arc<AtomicUsize>);
-    impl Drop for Foo {
-        fn drop(&mut self) {
-            self.0.fetch_add(1, Ordering::SeqCst);
-        }
-    }
-    let num_drops = Arc::new(AtomicUsize::new(0));
-    let m = Mutex::new(Foo(num_drops.clone()));
-    assert_eq!(num_drops.load(Ordering::SeqCst), 0);
-    {
-        let _inner = m.into_inner().unwrap();
-        assert_eq!(num_drops.load(Ordering::SeqCst), 0);
-    }
-    assert_eq!(num_drops.load(Ordering::SeqCst), 1);
-}
-
-#[test]
-fn test_into_inner_poison() {
-    let m = new_poisoned_mutex(NonCopy(10));
-
-    match m.into_inner() {
-        Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
-        Ok(x) => panic!("into_inner of poisoned Mutex is Ok: {x:?}"),
-    }
-}
-
-#[test]
-fn test_get_cloned() {
-    let m = Mutex::new(Cloneable(10));
-
-    assert_eq!(m.get_cloned().unwrap(), Cloneable(10));
-}
-
-#[test]
-fn test_get_cloned_poison() {
-    let m = new_poisoned_mutex(Cloneable(10));
-
-    match m.get_cloned() {
-        Err(e) => assert_eq!(e.into_inner(), ()),
-        Ok(x) => panic!("get of poisoned Mutex is Ok: {x:?}"),
-    }
-}
-
-#[test]
-fn test_get_mut() {
-    let mut m = Mutex::new(NonCopy(10));
-    *m.get_mut().unwrap() = NonCopy(20);
-    assert_eq!(m.into_inner().unwrap(), NonCopy(20));
-}
-
-#[test]
-fn test_get_mut_poison() {
-    let mut m = new_poisoned_mutex(NonCopy(10));
-
-    match m.get_mut() {
-        Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
-        Ok(x) => panic!("get_mut of poisoned Mutex is Ok: {x:?}"),
-    }
-}
-
-#[test]
-fn test_set() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = Mutex::new(init());
-
-        assert_eq!(*m.lock().unwrap(), init());
-        m.set(value()).unwrap();
-        assert_eq!(*m.lock().unwrap(), value());
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_set_poison() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = new_poisoned_mutex(init());
-
-        match m.set(value()) {
-            Err(e) => {
-                assert_eq!(e.into_inner(), value());
-                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
-            }
-            Ok(x) => panic!("set of poisoned Mutex is Ok: {x:?}"),
-        }
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_replace() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = Mutex::new(init());
-
-        assert_eq!(*m.lock().unwrap(), init());
-        assert_eq!(m.replace(value()).unwrap(), init());
-        assert_eq!(*m.lock().unwrap(), value());
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_replace_poison() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = new_poisoned_mutex(init());
-
-        match m.replace(value()) {
-            Err(e) => {
-                assert_eq!(e.into_inner(), value());
-                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
-            }
-            Ok(x) => panic!("replace of poisoned Mutex is Ok: {x:?}"),
-        }
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_mutex_arc_condvar() {
-    let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
-    let packet2 = Packet(packet.0.clone());
-    let (tx, rx) = channel();
-    let _t = thread::spawn(move || {
-        // wait until parent gets in
-        rx.recv().unwrap();
-        let &(ref lock, ref cvar) = &*packet2.0;
-        let mut lock = lock.lock().unwrap();
-        *lock = true;
-        cvar.notify_one();
-    });
-
-    let &(ref lock, ref cvar) = &*packet.0;
-    let mut lock = lock.lock().unwrap();
-    tx.send(()).unwrap();
-    assert!(!*lock);
-    while !*lock {
-        lock = cvar.wait(lock).unwrap();
-    }
-}
-
-#[test]
-fn test_arc_condvar_poison() {
-    let packet = Packet(Arc::new((Mutex::new(1), Condvar::new())));
-    let packet2 = Packet(packet.0.clone());
-    let (tx, rx) = channel();
-
-    let _t = thread::spawn(move || -> () {
-        rx.recv().unwrap();
-        let &(ref lock, ref cvar) = &*packet2.0;
-        let _g = lock.lock().unwrap();
-        cvar.notify_one();
-        // Parent should fail when it wakes up.
-        panic!();
-    });
-
-    let &(ref lock, ref cvar) = &*packet.0;
-    let mut lock = lock.lock().unwrap();
-    tx.send(()).unwrap();
-    while *lock == 1 {
-        match cvar.wait(lock) {
-            Ok(l) => {
-                lock = l;
-                assert_eq!(*lock, 1);
-            }
-            Err(..) => break,
-        }
-    }
-}
-
-#[test]
-fn test_mutex_arc_poison() {
-    let arc = Arc::new(Mutex::new(1));
-    assert!(!arc.is_poisoned());
-    let arc2 = arc.clone();
-    let _ = thread::spawn(move || {
-        let lock = arc2.lock().unwrap();
-        assert_eq!(*lock, 2); // deliberate assertion failure to poison the mutex
-    })
-    .join();
-    assert!(arc.lock().is_err());
-    assert!(arc.is_poisoned());
-}
-
-#[test]
-fn test_mutex_arc_poison_mapped() {
-    let arc = Arc::new(Mutex::new(1));
-    assert!(!arc.is_poisoned());
-    let arc2 = arc.clone();
-    let _ = thread::spawn(move || {
-        let lock = arc2.lock().unwrap();
-        let lock = MutexGuard::map(lock, |val| val);
-        assert_eq!(*lock, 2); // deliberate assertion failure to poison the mutex
-    })
-    .join();
-    assert!(arc.lock().is_err());
-    assert!(arc.is_poisoned());
-}
-
-#[test]
-fn test_mutex_arc_nested() {
-    // Tests nested mutexes and access
-    // to underlying data.
-    let arc = Arc::new(Mutex::new(1));
-    let arc2 = Arc::new(Mutex::new(arc));
-    let (tx, rx) = channel();
-    let _t = thread::spawn(move || {
-        let lock = arc2.lock().unwrap();
-        let lock2 = lock.lock().unwrap();
-        assert_eq!(*lock2, 1);
-        tx.send(()).unwrap();
-    });
-    rx.recv().unwrap();
-}
-
-#[test]
-fn test_mutex_arc_access_in_unwind() {
-    let arc = Arc::new(Mutex::new(1));
-    let arc2 = arc.clone();
-    let _ = thread::spawn(move || -> () {
-        struct Unwinder {
-            i: Arc<Mutex<i32>>,
-        }
-        impl Drop for Unwinder {
-            fn drop(&mut self) {
-                *self.i.lock().unwrap() += 1;
-            }
-        }
-        let _u = Unwinder { i: arc2 };
-        panic!();
-    })
-    .join();
-    let lock = arc.lock().unwrap();
-    assert_eq!(*lock, 2);
-}
-
-#[test]
-fn test_mutex_unsized() {
-    let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]);
-    {
-        let b = &mut *mutex.lock().unwrap();
-        b[0] = 4;
-        b[2] = 5;
-    }
-    let comp: &[i32] = &[4, 2, 5];
-    assert_eq!(&*mutex.lock().unwrap(), comp);
-}
-
-#[test]
-fn test_mapping_mapped_guard() {
-    let arr = [0; 4];
-    let mut lock = Mutex::new(arr);
-    let guard = lock.lock().unwrap();
-    let guard = MutexGuard::map(guard, |arr| &mut arr[..2]);
-    let mut guard = MappedMutexGuard::map(guard, |slice| &mut slice[1..]);
-    assert_eq!(guard.len(), 1);
-    guard[0] = 42;
-    drop(guard);
-    assert_eq!(*lock.get_mut().unwrap(), [0, 42, 0, 0]);
-}
-
-#[test]
-fn panic_while_mapping_unlocked_poison() {
-    let lock = Mutex::new(());
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.lock().unwrap();
-        let _guard = MutexGuard::map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_lock() {
-        Ok(_) => panic!("panicking in a MutexGuard::map closure should poison the Mutex"),
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a MutexGuard::map closure should unlock the mutex")
-        }
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.lock().unwrap();
-        let _guard = MutexGuard::try_map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_lock() {
-        Ok(_) => panic!("panicking in a MutexGuard::try_map closure should poison the Mutex"),
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a MutexGuard::try_map closure should unlock the mutex")
-        }
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.lock().unwrap();
-        let guard = MutexGuard::map::<(), _>(guard, |val| val);
-        let _guard = MappedMutexGuard::map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_lock() {
-        Ok(_) => panic!("panicking in a MappedMutexGuard::map closure should poison the Mutex"),
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a MappedMutexGuard::map closure should unlock the mutex")
-        }
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.lock().unwrap();
-        let guard = MutexGuard::map::<(), _>(guard, |val| val);
-        let _guard = MappedMutexGuard::try_map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_lock() {
-        Ok(_) => panic!("panicking in a MappedMutexGuard::try_map closure should poison the Mutex"),
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a MappedMutexGuard::try_map closure should unlock the mutex")
-        }
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    drop(lock);
-}
diff --git a/library/std/src/sync/once.rs b/library/std/src/sync/once.rs
deleted file mode 100644
index 27db4b634fb..00000000000
--- a/library/std/src/sync/once.rs
+++ /dev/null
@@ -1,390 +0,0 @@
-//! A "once initialization" primitive
-//!
-//! This primitive is meant to be used to run one-time initialization. An
-//! example use case would be for initializing an FFI library.
-
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
-use crate::fmt;
-use crate::panic::{RefUnwindSafe, UnwindSafe};
-use crate::sys::sync as sys;
-
-/// A low-level synchronization primitive for one-time global execution.
-///
-/// Previously this was the only "execute once" synchronization in `std`.
-/// Other libraries implemented novel synchronizing types with `Once`, like
-/// [`OnceLock<T>`] or [`LazyLock<T, F>`], before those were added to `std`.
-/// `OnceLock<T>` in particular supersedes `Once` in functionality and should
-/// be preferred for the common case where the `Once` is associated with data.
-///
-/// This type can only be constructed with [`Once::new()`].
-///
-/// # Examples
-///
-/// ```
-/// use std::sync::Once;
-///
-/// static START: Once = Once::new();
-///
-/// START.call_once(|| {
-///     // run initialization here
-/// });
-/// ```
-///
-/// [`OnceLock<T>`]: crate::sync::OnceLock
-/// [`LazyLock<T, F>`]: crate::sync::LazyLock
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Once {
-    inner: sys::Once,
-}
-
-#[stable(feature = "sync_once_unwind_safe", since = "1.59.0")]
-impl UnwindSafe for Once {}
-
-#[stable(feature = "sync_once_unwind_safe", since = "1.59.0")]
-impl RefUnwindSafe for Once {}
-
-/// State yielded to [`Once::call_once_force()`]’s closure parameter. The state
-/// can be used to query the poison status of the [`Once`].
-#[stable(feature = "once_poison", since = "1.51.0")]
-pub struct OnceState {
-    pub(crate) inner: sys::OnceState,
-}
-
-pub(crate) enum ExclusiveState {
-    Incomplete,
-    Poisoned,
-    Complete,
-}
-
-/// Initialization value for static [`Once`] values.
-///
-/// # Examples
-///
-/// ```
-/// use std::sync::{Once, ONCE_INIT};
-///
-/// static START: Once = ONCE_INIT;
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(
-    since = "1.38.0",
-    note = "the `Once::new()` function is now preferred",
-    suggestion = "Once::new()"
-)]
-pub const ONCE_INIT: Once = Once::new();
-
-impl Once {
-    /// Creates a new `Once` value.
-    #[inline]
-    #[stable(feature = "once_new", since = "1.2.0")]
-    #[rustc_const_stable(feature = "const_once_new", since = "1.32.0")]
-    #[must_use]
-    pub const fn new() -> Once {
-        Once { inner: sys::Once::new() }
-    }
-
-    /// Performs an initialization routine once and only once. The given closure
-    /// will be executed if this is the first time `call_once` has been called,
-    /// and otherwise the routine will *not* be invoked.
-    ///
-    /// This method will block the calling thread if another initialization
-    /// routine is currently running.
-    ///
-    /// When this function returns, it is guaranteed that some initialization
-    /// has run and completed (it might not be the closure specified). It is also
-    /// guaranteed that any memory writes performed by the executed closure can
-    /// be reliably observed by other threads at this point (there is a
-    /// happens-before relation between the closure and code executing after the
-    /// return).
-    ///
-    /// If the given closure recursively invokes `call_once` on the same [`Once`]
-    /// instance, the exact behavior is not specified: allowed outcomes are
-    /// a panic or a deadlock.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Once;
-    ///
-    /// static mut VAL: usize = 0;
-    /// static INIT: Once = Once::new();
-    ///
-    /// // Accessing a `static mut` is unsafe much of the time, but if we do so
-    /// // in a synchronized fashion (e.g., write once or read all) then we're
-    /// // good to go!
-    /// //
-    /// // This function will only call `expensive_computation` once, and will
-    /// // otherwise always return the value returned from the first invocation.
-    /// fn get_cached_val() -> usize {
-    ///     unsafe {
-    ///         INIT.call_once(|| {
-    ///             VAL = expensive_computation();
-    ///         });
-    ///         VAL
-    ///     }
-    /// }
-    ///
-    /// fn expensive_computation() -> usize {
-    ///     // ...
-    /// # 2
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// The closure `f` will only be executed once even if this is called
-    /// concurrently amongst many threads. If that closure panics, however, then
-    /// it will *poison* this [`Once`] instance, causing all future invocations of
-    /// `call_once` to also panic.
-    ///
-    /// This is similar to [poisoning with mutexes][poison].
-    ///
-    /// [poison]: struct.Mutex.html#poisoning
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
-    pub fn call_once<F>(&self, f: F)
-    where
-        F: FnOnce(),
-    {
-        // Fast path check
-        if self.inner.is_completed() {
-            return;
-        }
-
-        let mut f = Some(f);
-        self.inner.call(false, &mut |_| f.take().unwrap()());
-    }
-
-    /// Performs the same function as [`call_once()`] except ignores poisoning.
-    ///
-    /// Unlike [`call_once()`], if this [`Once`] has been poisoned (i.e., a previous
-    /// call to [`call_once()`] or [`call_once_force()`] caused a panic), calling
-    /// [`call_once_force()`] will still invoke the closure `f` and will _not_
-    /// result in an immediate panic. If `f` panics, the [`Once`] will remain
-    /// in a poison state. If `f` does _not_ panic, the [`Once`] will no
-    /// longer be in a poison state and all future calls to [`call_once()`] or
-    /// [`call_once_force()`] will be no-ops.
-    ///
-    /// The closure `f` is yielded a [`OnceState`] structure which can be used
-    /// to query the poison status of the [`Once`].
-    ///
-    /// [`call_once()`]: Once::call_once
-    /// [`call_once_force()`]: Once::call_once_force
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Once;
-    /// use std::thread;
-    ///
-    /// static INIT: Once = Once::new();
-    ///
-    /// // poison the once
-    /// let handle = thread::spawn(|| {
-    ///     INIT.call_once(|| panic!());
-    /// });
-    /// assert!(handle.join().is_err());
-    ///
-    /// // poisoning propagates
-    /// let handle = thread::spawn(|| {
-    ///     INIT.call_once(|| {});
-    /// });
-    /// assert!(handle.join().is_err());
-    ///
-    /// // call_once_force will still run and reset the poisoned state
-    /// INIT.call_once_force(|state| {
-    ///     assert!(state.is_poisoned());
-    /// });
-    ///
-    /// // once any success happens, we stop propagating the poison
-    /// INIT.call_once(|| {});
-    /// ```
-    #[inline]
-    #[stable(feature = "once_poison", since = "1.51.0")]
-    pub fn call_once_force<F>(&self, f: F)
-    where
-        F: FnOnce(&OnceState),
-    {
-        // Fast path check
-        if self.inner.is_completed() {
-            return;
-        }
-
-        let mut f = Some(f);
-        self.inner.call(true, &mut |p| f.take().unwrap()(p));
-    }
-
-    /// Returns `true` if some [`call_once()`] call has completed
-    /// successfully. Specifically, `is_completed` will return false in
-    /// the following situations:
-    ///   * [`call_once()`] was not called at all,
-    ///   * [`call_once()`] was called, but has not yet completed,
-    ///   * the [`Once`] instance is poisoned
-    ///
-    /// This function returning `false` does not mean that [`Once`] has not been
-    /// executed. For example, it may have been executed in the time between
-    /// when `is_completed` starts executing and when it returns, in which case
-    /// the `false` return value would be stale (but still permissible).
-    ///
-    /// [`call_once()`]: Once::call_once
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Once;
-    ///
-    /// static INIT: Once = Once::new();
-    ///
-    /// assert_eq!(INIT.is_completed(), false);
-    /// INIT.call_once(|| {
-    ///     assert_eq!(INIT.is_completed(), false);
-    /// });
-    /// assert_eq!(INIT.is_completed(), true);
-    /// ```
-    ///
-    /// ```
-    /// use std::sync::Once;
-    /// use std::thread;
-    ///
-    /// static INIT: Once = Once::new();
-    ///
-    /// assert_eq!(INIT.is_completed(), false);
-    /// let handle = thread::spawn(|| {
-    ///     INIT.call_once(|| panic!());
-    /// });
-    /// assert!(handle.join().is_err());
-    /// assert_eq!(INIT.is_completed(), false);
-    /// ```
-    #[stable(feature = "once_is_completed", since = "1.43.0")]
-    #[inline]
-    pub fn is_completed(&self) -> bool {
-        self.inner.is_completed()
-    }
-
-    /// Blocks the current thread until initialization has completed.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// #![feature(once_wait)]
-    ///
-    /// use std::sync::Once;
-    /// use std::thread;
-    ///
-    /// static READY: Once = Once::new();
-    ///
-    /// let thread = thread::spawn(|| {
-    ///     READY.wait();
-    ///     println!("everything is ready");
-    /// });
-    ///
-    /// READY.call_once(|| println!("performing setup"));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// If this [`Once`] has been poisoned because an initialization closure has
-    /// panicked, this method will also panic. Use [`wait_force`](Self::wait_force)
-    /// if this behavior is not desired.
-    #[unstable(feature = "once_wait", issue = "127527")]
-    pub fn wait(&self) {
-        if !self.inner.is_completed() {
-            self.inner.wait(false);
-        }
-    }
-
-    /// Blocks the current thread until initialization has completed, ignoring
-    /// poisoning.
-    #[unstable(feature = "once_wait", issue = "127527")]
-    pub fn wait_force(&self) {
-        if !self.inner.is_completed() {
-            self.inner.wait(true);
-        }
-    }
-
-    /// Returns the current state of the `Once` instance.
-    ///
-    /// Since this takes a mutable reference, no initialization can currently
-    /// be running, so the state must be either "incomplete", "poisoned" or
-    /// "complete".
-    #[inline]
-    pub(crate) fn state(&mut self) -> ExclusiveState {
-        self.inner.state()
-    }
-
-    /// Sets current state of the `Once` instance.
-    ///
-    /// Since this takes a mutable reference, no initialization can currently
-    /// be running, so the state must be either "incomplete", "poisoned" or
-    /// "complete".
-    #[inline]
-    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
-        self.inner.set_state(new_state);
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl fmt::Debug for Once {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Once").finish_non_exhaustive()
-    }
-}
-
-impl OnceState {
-    /// Returns `true` if the associated [`Once`] was poisoned prior to the
-    /// invocation of the closure passed to [`Once::call_once_force()`].
-    ///
-    /// # Examples
-    ///
-    /// A poisoned [`Once`]:
-    ///
-    /// ```
-    /// use std::sync::Once;
-    /// use std::thread;
-    ///
-    /// static INIT: Once = Once::new();
-    ///
-    /// // poison the once
-    /// let handle = thread::spawn(|| {
-    ///     INIT.call_once(|| panic!());
-    /// });
-    /// assert!(handle.join().is_err());
-    ///
-    /// INIT.call_once_force(|state| {
-    ///     assert!(state.is_poisoned());
-    /// });
-    /// ```
-    ///
-    /// An unpoisoned [`Once`]:
-    ///
-    /// ```
-    /// use std::sync::Once;
-    ///
-    /// static INIT: Once = Once::new();
-    ///
-    /// INIT.call_once_force(|state| {
-    ///     assert!(!state.is_poisoned());
-    /// });
-    #[stable(feature = "once_poison", since = "1.51.0")]
-    #[inline]
-    pub fn is_poisoned(&self) -> bool {
-        self.inner.is_poisoned()
-    }
-
-    /// Poison the associated [`Once`] without explicitly panicking.
-    // NOTE: This is currently only exposed for `OnceLock`.
-    #[inline]
-    pub(crate) fn poison(&self) {
-        self.inner.poison();
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl fmt::Debug for OnceState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OnceState").field("poisoned", &self.is_poisoned()).finish()
-    }
-}
diff --git a/library/std/src/sync/once/tests.rs b/library/std/src/sync/once/tests.rs
deleted file mode 100644
index ce96468aeb6..00000000000
--- a/library/std/src/sync/once/tests.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-use super::Once;
-use crate::sync::atomic::AtomicBool;
-use crate::sync::atomic::Ordering::Relaxed;
-use crate::sync::mpsc::channel;
-use crate::time::Duration;
-use crate::{panic, thread};
-
-#[test]
-fn smoke_once() {
-    static O: Once = Once::new();
-    let mut a = 0;
-    O.call_once(|| a += 1);
-    assert_eq!(a, 1);
-    O.call_once(|| a += 1);
-    assert_eq!(a, 1);
-}
-
-#[test]
-fn stampede_once() {
-    static O: Once = Once::new();
-    static mut RUN: bool = false;
-
-    let (tx, rx) = channel();
-    for _ in 0..10 {
-        let tx = tx.clone();
-        thread::spawn(move || {
-            for _ in 0..4 {
-                thread::yield_now()
-            }
-            unsafe {
-                O.call_once(|| {
-                    assert!(!RUN);
-                    RUN = true;
-                });
-                assert!(RUN);
-            }
-            tx.send(()).unwrap();
-        });
-    }
-
-    unsafe {
-        O.call_once(|| {
-            assert!(!RUN);
-            RUN = true;
-        });
-        assert!(RUN);
-    }
-
-    for _ in 0..10 {
-        rx.recv().unwrap();
-    }
-}
-
-#[test]
-fn poison_bad() {
-    static O: Once = Once::new();
-
-    // poison the once
-    let t = panic::catch_unwind(|| {
-        O.call_once(|| panic!());
-    });
-    assert!(t.is_err());
-
-    // poisoning propagates
-    let t = panic::catch_unwind(|| {
-        O.call_once(|| {});
-    });
-    assert!(t.is_err());
-
-    // we can subvert poisoning, however
-    let mut called = false;
-    O.call_once_force(|p| {
-        called = true;
-        assert!(p.is_poisoned())
-    });
-    assert!(called);
-
-    // once any success happens, we stop propagating the poison
-    O.call_once(|| {});
-}
-
-#[test]
-fn wait_for_force_to_finish() {
-    static O: Once = Once::new();
-
-    // poison the once
-    let t = panic::catch_unwind(|| {
-        O.call_once(|| panic!());
-    });
-    assert!(t.is_err());
-
-    // make sure someone's waiting inside the once via a force
-    let (tx1, rx1) = channel();
-    let (tx2, rx2) = channel();
-    let t1 = thread::spawn(move || {
-        O.call_once_force(|p| {
-            assert!(p.is_poisoned());
-            tx1.send(()).unwrap();
-            rx2.recv().unwrap();
-        });
-    });
-
-    rx1.recv().unwrap();
-
-    // put another waiter on the once
-    let t2 = thread::spawn(|| {
-        let mut called = false;
-        O.call_once(|| {
-            called = true;
-        });
-        assert!(!called);
-    });
-
-    tx2.send(()).unwrap();
-
-    assert!(t1.join().is_ok());
-    assert!(t2.join().is_ok());
-}
-
-#[test]
-fn wait() {
-    for _ in 0..50 {
-        let val = AtomicBool::new(false);
-        let once = Once::new();
-
-        thread::scope(|s| {
-            for _ in 0..4 {
-                s.spawn(|| {
-                    once.wait();
-                    assert!(val.load(Relaxed));
-                });
-            }
-
-            once.call_once(|| val.store(true, Relaxed));
-        });
-    }
-}
-
-#[test]
-fn wait_on_poisoned() {
-    let once = Once::new();
-
-    panic::catch_unwind(|| once.call_once(|| panic!())).unwrap_err();
-    panic::catch_unwind(|| once.wait()).unwrap_err();
-}
-
-#[test]
-fn wait_force_on_poisoned() {
-    let once = Once::new();
-
-    thread::scope(|s| {
-        panic::catch_unwind(|| once.call_once(|| panic!())).unwrap_err();
-
-        s.spawn(|| {
-            thread::sleep(Duration::from_millis(100));
-
-            once.call_once_force(|_| {});
-        });
-
-        once.wait_force();
-    })
-}
diff --git a/library/std/src/sync/once_lock.rs b/library/std/src/sync/once_lock.rs
index 0ae3cf4df36..49f2dafd8fd 100644
--- a/library/std/src/sync/once_lock.rs
+++ b/library/std/src/sync/once_lock.rs
@@ -101,6 +101,7 @@ use crate::sync::Once;
 /// ```
 #[stable(feature = "once_cell", since = "1.70.0")]
 pub struct OnceLock<T> {
+    // FIXME(nonpoison_once): switch to nonpoison version once it is available
     once: Once,
     // Whether or not the value is initialized is tracked by `once.is_completed()`.
     value: UnsafeCell<MaybeUninit<T>>,
diff --git a/library/std/src/sync/poison.rs b/library/std/src/sync/poison.rs
index 9eb900c2103..1b8809734b8 100644
--- a/library/std/src/sync/poison.rs
+++ b/library/std/src/sync/poison.rs
@@ -1,3 +1,78 @@
+//! Synchronization objects that employ poisoning.
+//!
+//! # Poisoning
+//!
+//! All synchronization objects in this module implement a strategy called "poisoning"
+//! where if a thread panics while holding the exclusive access granted by the primitive,
+//! the state of the primitive is set to "poisoned".
+//! This information is then propagated to all other threads
+//! to signify that the data protected by this primitive is likely tainted
+//! (some invariant is not being upheld).
+//!
+//! The specifics of how this "poisoned" state affects other threads
+//! depend on the primitive. See [#Overview] bellow.
+//!
+//! For the alternative implementations that do not employ poisoning,
+//! see `std::sys::nonpoisoning`.
+//!
+//! # Overview
+//!
+//! Below is a list of synchronization objects provided by this module
+//! with a high-level overview for each object and a description
+//! of how it employs "poisoning".
+//!
+//! - [`Condvar`]: Condition Variable, providing the ability to block
+//!   a thread while waiting for an event to occur.
+//!
+//!   Condition variables are typically associated with
+//!   a boolean predicate (a condition) and a mutex.
+//!   This implementation is associated with [`poison::Mutex`](Mutex),
+//!   which employs poisoning.
+//!   For this reason, [`Condvar::wait()`] will return a [`LockResult`],
+//!   just like [`poison::Mutex::lock()`](Mutex::lock) does.
+//!
+//! - [`Mutex`]: Mutual Exclusion mechanism, which ensures that at
+//!   most one thread at a time is able to access some data.
+//!
+//!   [`Mutex::lock()`] returns a [`LockResult`],
+//!   providing a way to deal with the poisoned state.
+//!   See [`Mutex`'s documentation](Mutex#poisoning) for more.
+//!
+//! - [`Once`]: A thread-safe way to run a piece of code only once.
+//!   Mostly useful for implementing one-time global initialization.
+//!
+//!   [`Once`] is poisoned if the piece of code passed to
+//!   [`Once::call_once()`] or [`Once::call_once_force()`] panics.
+//!   When in poisoned state, subsequent calls to [`Once::call_once()`] will panic too.
+//!   [`Once::call_once_force()`] can be used to clear the poisoned state.
+//!
+//! - [`RwLock`]: Provides a mutual exclusion mechanism which allows
+//!   multiple readers at the same time, while allowing only one
+//!   writer at a time. In some cases, this can be more efficient than
+//!   a mutex.
+//!
+//!   This implementation, like [`Mutex`], will become poisoned on a panic.
+//!   Note, however, that an `RwLock` may only be poisoned if a panic occurs
+//!   while it is locked exclusively (write mode). If a panic occurs in any reader,
+//!   then the lock will not be poisoned.
+
+// FIXME(sync_nonpoison) add links to sync::nonpoison to the doc comment above.
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::condvar::{Condvar, WaitTimeoutResult};
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+pub use self::mutex::MappedMutexGuard;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::mutex::{Mutex, MutexGuard};
+#[stable(feature = "rust1", since = "1.0.0")]
+#[expect(deprecated)]
+pub use self::once::ONCE_INIT;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::once::{Once, OnceState};
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+pub use self::rwlock::{MappedRwLockReadGuard, MappedRwLockWriteGuard};
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use crate::error::Error;
 use crate::fmt;
 #[cfg(panic = "unwind")]
@@ -5,7 +80,13 @@ use crate::sync::atomic::{AtomicBool, Ordering};
 #[cfg(panic = "unwind")]
 use crate::thread;
 
-pub struct Flag {
+mod condvar;
+#[stable(feature = "rust1", since = "1.0.0")]
+mod mutex;
+pub(crate) mod once;
+mod rwlock;
+
+pub(crate) struct Flag {
     #[cfg(panic = "unwind")]
     failed: AtomicBool,
 }
@@ -78,7 +159,7 @@ impl Flag {
 }
 
 #[derive(Clone)]
-pub struct Guard {
+pub(crate) struct Guard {
     #[cfg(panic = "unwind")]
     panicking: bool,
 }
@@ -316,7 +397,7 @@ impl<T> Error for TryLockError<T> {
     }
 }
 
-pub fn map_result<T, U, F>(result: LockResult<T>, f: F) -> LockResult<U>
+pub(crate) fn map_result<T, U, F>(result: LockResult<T>, f: F) -> LockResult<U>
 where
     F: FnOnce(T) -> U,
 {
diff --git a/library/std/src/sync/poison/condvar.rs b/library/std/src/sync/poison/condvar.rs
new file mode 100644
index 00000000000..a6e2389c93b
--- /dev/null
+++ b/library/std/src/sync/poison/condvar.rs
@@ -0,0 +1,571 @@
+#[cfg(test)]
+mod tests;
+
+use crate::fmt;
+use crate::sync::poison::{self, LockResult, MutexGuard, PoisonError, mutex};
+use crate::sys::sync as sys;
+use crate::time::{Duration, Instant};
+
+/// A type indicating whether a timed wait on a condition variable returned
+/// due to a time out or not.
+///
+/// It is returned by the [`wait_timeout`] method.
+///
+/// [`wait_timeout`]: Condvar::wait_timeout
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[stable(feature = "wait_timeout", since = "1.5.0")]
+pub struct WaitTimeoutResult(bool);
+
+// FIXME(sync_nonpoison): `WaitTimeoutResult` is actually poisoning-agnostic, it seems.
+// Should we take advantage of this fact?
+impl WaitTimeoutResult {
+    /// Returns `true` if the wait was known to have timed out.
+    ///
+    /// # Examples
+    ///
+    /// This example spawns a thread which will sleep 20 milliseconds before
+    /// updating a boolean value and then notifying the condvar.
+    ///
+    /// The main thread will wait with a 10 millisecond timeout on the condvar
+    /// and will leave the loop upon timeout.
+    ///
+    /// ```
+    /// use std::sync::{Arc, Condvar, Mutex};
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// # let handle =
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///
+    ///     // Let's wait 20 milliseconds before notifying the condvar.
+    ///     thread::sleep(Duration::from_millis(20));
+    ///
+    ///     let mut started = lock.lock().unwrap();
+    ///     // We update the boolean value.
+    ///     *started = true;
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // Wait for the thread to start up.
+    /// let (lock, cvar) = &*pair;
+    /// loop {
+    ///     // Let's put a timeout on the condvar's wait.
+    ///     let result = cvar.wait_timeout(lock.lock().unwrap(), Duration::from_millis(10)).unwrap();
+    ///     // 10 milliseconds have passed.
+    ///     if result.1.timed_out() {
+    ///         // timed out now and we can leave.
+    ///         break
+    ///     }
+    /// }
+    /// # // Prevent leaks for Miri.
+    /// # let _ = handle.join();
+    /// ```
+    #[must_use]
+    #[stable(feature = "wait_timeout", since = "1.5.0")]
+    pub fn timed_out(&self) -> bool {
+        self.0
+    }
+}
+
+/// A Condition Variable
+///
+/// Condition variables represent the ability to block a thread such that it
+/// consumes no CPU time while waiting for an event to occur. Condition
+/// variables are typically associated with a boolean predicate (a condition)
+/// and a mutex. The predicate is always verified inside of the mutex before
+/// determining that a thread must block.
+///
+/// Functions in this module will block the current **thread** of execution.
+/// Note that any attempt to use multiple mutexes on the same condition
+/// variable may result in a runtime panic.
+///
+/// # Examples
+///
+/// ```
+/// use std::sync::{Arc, Mutex, Condvar};
+/// use std::thread;
+///
+/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+/// let pair2 = Arc::clone(&pair);
+///
+/// // Inside of our lock, spawn a new thread, and then wait for it to start.
+/// thread::spawn(move || {
+///     let (lock, cvar) = &*pair2;
+///     let mut started = lock.lock().unwrap();
+///     *started = true;
+///     // We notify the condvar that the value has changed.
+///     cvar.notify_one();
+/// });
+///
+/// // Wait for the thread to start up.
+/// let (lock, cvar) = &*pair;
+/// let mut started = lock.lock().unwrap();
+/// while !*started {
+///     started = cvar.wait(started).unwrap();
+/// }
+/// ```
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct Condvar {
+    inner: sys::Condvar,
+}
+
+impl Condvar {
+    /// Creates a new condition variable which is ready to be waited on and
+    /// notified.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Condvar;
+    ///
+    /// let condvar = Condvar::new();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
+    #[must_use]
+    #[inline]
+    pub const fn new() -> Condvar {
+        Condvar { inner: sys::Condvar::new() }
+    }
+
+    /// Blocks the current thread until this condition variable receives a
+    /// notification.
+    ///
+    /// This function will atomically unlock the mutex specified (represented by
+    /// `guard`) and block the current thread. This means that any calls
+    /// to [`notify_one`] or [`notify_all`] which happen logically after the
+    /// mutex is unlocked are candidates to wake this thread up. When this
+    /// function call returns, the lock specified will have been re-acquired.
+    ///
+    /// Note that this function is susceptible to spurious wakeups. Condition
+    /// variables normally have a boolean predicate associated with them, and
+    /// the predicate must always be checked each time this function returns to
+    /// protect against spurious wakeups.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the mutex being waited on is
+    /// poisoned when this thread re-acquires the lock. For more information,
+    /// see information about [poisoning] on the [`Mutex`] type.
+    ///
+    /// # Panics
+    ///
+    /// This function may [`panic!`] if it is used with more than one mutex
+    /// over time.
+    ///
+    /// [`notify_one`]: Self::notify_one
+    /// [`notify_all`]: Self::notify_all
+    /// [poisoning]: super::Mutex#poisoning
+    /// [`Mutex`]: super::Mutex
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    ///
+    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut started = lock.lock().unwrap();
+    ///     *started = true;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // Wait for the thread to start up.
+    /// let (lock, cvar) = &*pair;
+    /// let mut started = lock.lock().unwrap();
+    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
+    /// while !*started {
+    ///     started = cvar.wait(started).unwrap();
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> {
+        let poisoned = unsafe {
+            let lock = mutex::guard_lock(&guard);
+            self.inner.wait(lock);
+            mutex::guard_poison(&guard).get()
+        };
+        if poisoned { Err(PoisonError::new(guard)) } else { Ok(guard) }
+    }
+
+    /// Blocks the current thread until the provided condition becomes false.
+    ///
+    /// `condition` is checked immediately; if not met (returns `true`), this
+    /// will [`wait`] for the next notification then check again. This repeats
+    /// until `condition` returns `false`, in which case this function returns.
+    ///
+    /// This function will atomically unlock the mutex specified (represented by
+    /// `guard`) and block the current thread. This means that any calls
+    /// to [`notify_one`] or [`notify_all`] which happen logically after the
+    /// mutex is unlocked are candidates to wake this thread up. When this
+    /// function call returns, the lock specified will have been re-acquired.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the mutex being waited on is
+    /// poisoned when this thread re-acquires the lock. For more information,
+    /// see information about [poisoning] on the [`Mutex`] type.
+    ///
+    /// [`wait`]: Self::wait
+    /// [`notify_one`]: Self::notify_one
+    /// [`notify_all`]: Self::notify_all
+    /// [poisoning]: super::Mutex#poisoning
+    /// [`Mutex`]: super::Mutex
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    ///
+    /// let pair = Arc::new((Mutex::new(true), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut pending = lock.lock().unwrap();
+    ///     *pending = false;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // Wait for the thread to start up.
+    /// let (lock, cvar) = &*pair;
+    /// // As long as the value inside the `Mutex<bool>` is `true`, we wait.
+    /// let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();
+    /// ```
+    #[stable(feature = "wait_until", since = "1.42.0")]
+    pub fn wait_while<'a, T, F>(
+        &self,
+        mut guard: MutexGuard<'a, T>,
+        mut condition: F,
+    ) -> LockResult<MutexGuard<'a, T>>
+    where
+        F: FnMut(&mut T) -> bool,
+    {
+        while condition(&mut *guard) {
+            guard = self.wait(guard)?;
+        }
+        Ok(guard)
+    }
+
+    /// Waits on this condition variable for a notification, timing out after a
+    /// specified duration.
+    ///
+    /// The semantics of this function are equivalent to [`wait`]
+    /// except that the thread will be blocked for roughly no longer
+    /// than `ms` milliseconds. This method should not be used for
+    /// precise timing due to anomalies such as preemption or platform
+    /// differences that might not cause the maximum amount of time
+    /// waited to be precisely `ms`.
+    ///
+    /// Note that the best effort is made to ensure that the time waited is
+    /// measured with a monotonic clock, and not affected by the changes made to
+    /// the system time.
+    ///
+    /// The returned boolean is `false` only if the timeout is known
+    /// to have elapsed.
+    ///
+    /// Like [`wait`], the lock specified will be re-acquired when this function
+    /// returns, regardless of whether the timeout elapsed or not.
+    ///
+    /// [`wait`]: Self::wait
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    ///
+    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut started = lock.lock().unwrap();
+    ///     *started = true;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // Wait for the thread to start up.
+    /// let (lock, cvar) = &*pair;
+    /// let mut started = lock.lock().unwrap();
+    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
+    /// loop {
+    ///     let result = cvar.wait_timeout_ms(started, 10).unwrap();
+    ///     // 10 milliseconds have passed, or maybe the value changed!
+    ///     started = result.0;
+    ///     if *started == true {
+    ///         // We received the notification and the value has been updated, we can leave.
+    ///         break
+    ///     }
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[deprecated(since = "1.6.0", note = "replaced by `std::sync::Condvar::wait_timeout`")]
+    pub fn wait_timeout_ms<'a, T>(
+        &self,
+        guard: MutexGuard<'a, T>,
+        ms: u32,
+    ) -> LockResult<(MutexGuard<'a, T>, bool)> {
+        let res = self.wait_timeout(guard, Duration::from_millis(ms as u64));
+        poison::map_result(res, |(a, b)| (a, !b.timed_out()))
+    }
+
+    /// Waits on this condition variable for a notification, timing out after a
+    /// specified duration.
+    ///
+    /// The semantics of this function are equivalent to [`wait`] except that
+    /// the thread will be blocked for roughly no longer than `dur`. This
+    /// method should not be used for precise timing due to anomalies such as
+    /// preemption or platform differences that might not cause the maximum
+    /// amount of time waited to be precisely `dur`.
+    ///
+    /// Note that the best effort is made to ensure that the time waited is
+    /// measured with a monotonic clock, and not affected by the changes made to
+    /// the system time. This function is susceptible to spurious wakeups.
+    /// Condition variables normally have a boolean predicate associated with
+    /// them, and the predicate must always be checked each time this function
+    /// returns to protect against spurious wakeups. Additionally, it is
+    /// typically desirable for the timeout to not exceed some duration in
+    /// spite of spurious wakes, thus the sleep-duration is decremented by the
+    /// amount slept. Alternatively, use the `wait_timeout_while` method
+    /// to wait with a timeout while a predicate is true.
+    ///
+    /// The returned [`WaitTimeoutResult`] value indicates if the timeout is
+    /// known to have elapsed.
+    ///
+    /// Like [`wait`], the lock specified will be re-acquired when this function
+    /// returns, regardless of whether the timeout elapsed or not.
+    ///
+    /// [`wait`]: Self::wait
+    /// [`wait_timeout_while`]: Self::wait_timeout_while
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut started = lock.lock().unwrap();
+    ///     *started = true;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // wait for the thread to start up
+    /// let (lock, cvar) = &*pair;
+    /// let mut started = lock.lock().unwrap();
+    /// // as long as the value inside the `Mutex<bool>` is `false`, we wait
+    /// loop {
+    ///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();
+    ///     // 10 milliseconds have passed, or maybe the value changed!
+    ///     started = result.0;
+    ///     if *started == true {
+    ///         // We received the notification and the value has been updated, we can leave.
+    ///         break
+    ///     }
+    /// }
+    /// ```
+    #[stable(feature = "wait_timeout", since = "1.5.0")]
+    pub fn wait_timeout<'a, T>(
+        &self,
+        guard: MutexGuard<'a, T>,
+        dur: Duration,
+    ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)> {
+        let (poisoned, result) = unsafe {
+            let lock = mutex::guard_lock(&guard);
+            let success = self.inner.wait_timeout(lock, dur);
+            (mutex::guard_poison(&guard).get(), WaitTimeoutResult(!success))
+        };
+        if poisoned { Err(PoisonError::new((guard, result))) } else { Ok((guard, result)) }
+    }
+
+    /// Waits on this condition variable for a notification, timing out after a
+    /// specified duration.
+    ///
+    /// The semantics of this function are equivalent to [`wait_while`] except
+    /// that the thread will be blocked for roughly no longer than `dur`. This
+    /// method should not be used for precise timing due to anomalies such as
+    /// preemption or platform differences that might not cause the maximum
+    /// amount of time waited to be precisely `dur`.
+    ///
+    /// Note that the best effort is made to ensure that the time waited is
+    /// measured with a monotonic clock, and not affected by the changes made to
+    /// the system time.
+    ///
+    /// The returned [`WaitTimeoutResult`] value indicates if the timeout is
+    /// known to have elapsed without the condition being met.
+    ///
+    /// Like [`wait_while`], the lock specified will be re-acquired when this
+    /// function returns, regardless of whether the timeout elapsed or not.
+    ///
+    /// [`wait_while`]: Self::wait_while
+    /// [`wait_timeout`]: Self::wait_timeout
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let pair = Arc::new((Mutex::new(true), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut pending = lock.lock().unwrap();
+    ///     *pending = false;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // wait for the thread to start up
+    /// let (lock, cvar) = &*pair;
+    /// let result = cvar.wait_timeout_while(
+    ///     lock.lock().unwrap(),
+    ///     Duration::from_millis(100),
+    ///     |&mut pending| pending,
+    /// ).unwrap();
+    /// if result.1.timed_out() {
+    ///     // timed-out without the condition ever evaluating to false.
+    /// }
+    /// // access the locked mutex via result.0
+    /// ```
+    #[stable(feature = "wait_timeout_until", since = "1.42.0")]
+    pub fn wait_timeout_while<'a, T, F>(
+        &self,
+        mut guard: MutexGuard<'a, T>,
+        dur: Duration,
+        mut condition: F,
+    ) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)>
+    where
+        F: FnMut(&mut T) -> bool,
+    {
+        let start = Instant::now();
+        loop {
+            if !condition(&mut *guard) {
+                return Ok((guard, WaitTimeoutResult(false)));
+            }
+            let timeout = match dur.checked_sub(start.elapsed()) {
+                Some(timeout) => timeout,
+                None => return Ok((guard, WaitTimeoutResult(true))),
+            };
+            guard = self.wait_timeout(guard, timeout)?.0;
+        }
+    }
+
+    /// Wakes up one blocked thread on this condvar.
+    ///
+    /// If there is a blocked thread on this condition variable, then it will
+    /// be woken up from its call to [`wait`] or [`wait_timeout`]. Calls to
+    /// `notify_one` are not buffered in any way.
+    ///
+    /// To wake up all threads, see [`notify_all`].
+    ///
+    /// [`wait`]: Self::wait
+    /// [`wait_timeout`]: Self::wait_timeout
+    /// [`notify_all`]: Self::notify_all
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    ///
+    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut started = lock.lock().unwrap();
+    ///     *started = true;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_one();
+    /// });
+    ///
+    /// // Wait for the thread to start up.
+    /// let (lock, cvar) = &*pair;
+    /// let mut started = lock.lock().unwrap();
+    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
+    /// while !*started {
+    ///     started = cvar.wait(started).unwrap();
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn notify_one(&self) {
+        self.inner.notify_one()
+    }
+
+    /// Wakes up all blocked threads on this condvar.
+    ///
+    /// This method will ensure that any current waiters on the condition
+    /// variable are awoken. Calls to `notify_all()` are not buffered in any
+    /// way.
+    ///
+    /// To wake up only one thread, see [`notify_one`].
+    ///
+    /// [`notify_one`]: Self::notify_one
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex, Condvar};
+    /// use std::thread;
+    ///
+    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    /// let pair2 = Arc::clone(&pair);
+    ///
+    /// thread::spawn(move || {
+    ///     let (lock, cvar) = &*pair2;
+    ///     let mut started = lock.lock().unwrap();
+    ///     *started = true;
+    ///     // We notify the condvar that the value has changed.
+    ///     cvar.notify_all();
+    /// });
+    ///
+    /// // Wait for the thread to start up.
+    /// let (lock, cvar) = &*pair;
+    /// let mut started = lock.lock().unwrap();
+    /// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
+    /// while !*started {
+    ///     started = cvar.wait(started).unwrap();
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn notify_all(&self) {
+        self.inner.notify_all()
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl fmt::Debug for Condvar {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Condvar").finish_non_exhaustive()
+    }
+}
+
+#[stable(feature = "condvar_default", since = "1.10.0")]
+impl Default for Condvar {
+    /// Creates a `Condvar` which is ready to be waited on and notified.
+    fn default() -> Condvar {
+        Condvar::new()
+    }
+}
diff --git a/library/std/src/sync/poison/condvar/tests.rs b/library/std/src/sync/poison/condvar/tests.rs
new file mode 100644
index 00000000000..f9e9066bc92
--- /dev/null
+++ b/library/std/src/sync/poison/condvar/tests.rs
@@ -0,0 +1,190 @@
+use crate::sync::atomic::{AtomicBool, Ordering};
+use crate::sync::mpsc::channel;
+use crate::sync::{Arc, Condvar, Mutex};
+use crate::thread;
+use crate::time::Duration;
+
+#[test]
+fn smoke() {
+    let c = Condvar::new();
+    c.notify_one();
+    c.notify_all();
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+fn notify_one() {
+    let m = Arc::new(Mutex::new(()));
+    let m2 = m.clone();
+    let c = Arc::new(Condvar::new());
+    let c2 = c.clone();
+
+    let g = m.lock().unwrap();
+    let _t = thread::spawn(move || {
+        let _g = m2.lock().unwrap();
+        c2.notify_one();
+    });
+    let g = c.wait(g).unwrap();
+    drop(g);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+fn notify_all() {
+    const N: usize = 10;
+
+    let data = Arc::new((Mutex::new(0), Condvar::new()));
+    let (tx, rx) = channel();
+    for _ in 0..N {
+        let data = data.clone();
+        let tx = tx.clone();
+        thread::spawn(move || {
+            let &(ref lock, ref cond) = &*data;
+            let mut cnt = lock.lock().unwrap();
+            *cnt += 1;
+            if *cnt == N {
+                tx.send(()).unwrap();
+            }
+            while *cnt != 0 {
+                cnt = cond.wait(cnt).unwrap();
+            }
+            tx.send(()).unwrap();
+        });
+    }
+    drop(tx);
+
+    let &(ref lock, ref cond) = &*data;
+    rx.recv().unwrap();
+    let mut cnt = lock.lock().unwrap();
+    *cnt = 0;
+    cond.notify_all();
+    drop(cnt);
+
+    for _ in 0..N {
+        rx.recv().unwrap();
+    }
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+fn wait_while() {
+    let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    let pair2 = pair.clone();
+
+    // Inside of our lock, spawn a new thread, and then wait for it to start.
+    thread::spawn(move || {
+        let &(ref lock, ref cvar) = &*pair2;
+        let mut started = lock.lock().unwrap();
+        *started = true;
+        // We notify the condvar that the value has changed.
+        cvar.notify_one();
+    });
+
+    // Wait for the thread to start up.
+    let &(ref lock, ref cvar) = &*pair;
+    let guard = cvar.wait_while(lock.lock().unwrap(), |started| !*started);
+    assert!(*guard.unwrap());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // condvar wait not supported
+fn wait_timeout_wait() {
+    let m = Arc::new(Mutex::new(()));
+    let c = Arc::new(Condvar::new());
+
+    loop {
+        let g = m.lock().unwrap();
+        let (_g, no_timeout) = c.wait_timeout(g, Duration::from_millis(1)).unwrap();
+        // spurious wakeups mean this isn't necessarily true
+        // so execute test again, if not timeout
+        if !no_timeout.timed_out() {
+            continue;
+        }
+
+        break;
+    }
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // condvar wait not supported
+fn wait_timeout_while_wait() {
+    let m = Arc::new(Mutex::new(()));
+    let c = Arc::new(Condvar::new());
+
+    let g = m.lock().unwrap();
+    let (_g, wait) = c.wait_timeout_while(g, Duration::from_millis(1), |_| true).unwrap();
+    // no spurious wakeups. ensure it timed-out
+    assert!(wait.timed_out());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // condvar wait not supported
+fn wait_timeout_while_instant_satisfy() {
+    let m = Arc::new(Mutex::new(()));
+    let c = Arc::new(Condvar::new());
+
+    let g = m.lock().unwrap();
+    let (_g, wait) = c.wait_timeout_while(g, Duration::from_millis(0), |_| false).unwrap();
+    // ensure it didn't time-out even if we were not given any time.
+    assert!(!wait.timed_out());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+fn wait_timeout_while_wake() {
+    let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    let pair_copy = pair.clone();
+
+    let &(ref m, ref c) = &*pair;
+    let g = m.lock().unwrap();
+    let _t = thread::spawn(move || {
+        let &(ref lock, ref cvar) = &*pair_copy;
+        let mut started = lock.lock().unwrap();
+        thread::sleep(Duration::from_millis(1));
+        *started = true;
+        cvar.notify_one();
+    });
+    let (g2, wait) = c
+        .wait_timeout_while(g, Duration::from_millis(u64::MAX), |&mut notified| !notified)
+        .unwrap();
+    // ensure it didn't time-out even if we were not given any time.
+    assert!(!wait.timed_out());
+    assert!(*g2);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+fn wait_timeout_wake() {
+    let m = Arc::new(Mutex::new(()));
+    let c = Arc::new(Condvar::new());
+
+    loop {
+        let g = m.lock().unwrap();
+
+        let c2 = c.clone();
+        let m2 = m.clone();
+
+        let notified = Arc::new(AtomicBool::new(false));
+        let notified_copy = notified.clone();
+
+        let t = thread::spawn(move || {
+            let _g = m2.lock().unwrap();
+            thread::sleep(Duration::from_millis(1));
+            notified_copy.store(true, Ordering::Relaxed);
+            c2.notify_one();
+        });
+        let (g, timeout_res) = c.wait_timeout(g, Duration::from_millis(u64::MAX)).unwrap();
+        assert!(!timeout_res.timed_out());
+        // spurious wakeups mean this isn't necessarily true
+        // so execute test again, if not notified
+        if !notified.load(Ordering::Relaxed) {
+            t.join().unwrap();
+            continue;
+        }
+        drop(g);
+
+        t.join().unwrap();
+
+        break;
+    }
+}
diff --git a/library/std/src/sync/poison/mutex.rs b/library/std/src/sync/poison/mutex.rs
new file mode 100644
index 00000000000..e28c2090afe
--- /dev/null
+++ b/library/std/src/sync/poison/mutex.rs
@@ -0,0 +1,849 @@
+#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
+mod tests;
+
+use crate::cell::UnsafeCell;
+use crate::fmt;
+use crate::marker::PhantomData;
+use crate::mem::{self, ManuallyDrop};
+use crate::ops::{Deref, DerefMut};
+use crate::ptr::NonNull;
+use crate::sync::{LockResult, PoisonError, TryLockError, TryLockResult, poison};
+use crate::sys::sync as sys;
+
+/// A mutual exclusion primitive useful for protecting shared data
+///
+/// This mutex will block threads waiting for the lock to become available. The
+/// mutex can be created via a [`new`] constructor. Each mutex has a type parameter
+/// which represents the data that it is protecting. The data can only be accessed
+/// through the RAII guards returned from [`lock`] and [`try_lock`], which
+/// guarantees that the data is only ever accessed when the mutex is locked.
+///
+/// # Poisoning
+///
+/// The mutexes in this module implement a strategy called "poisoning" where a
+/// mutex is considered poisoned whenever a thread panics while holding the
+/// mutex. Once a mutex is poisoned, all other threads are unable to access the
+/// data by default as it is likely tainted (some invariant is not being
+/// upheld).
+///
+/// For a mutex, this means that the [`lock`] and [`try_lock`] methods return a
+/// [`Result`] which indicates whether a mutex has been poisoned or not. Most
+/// usage of a mutex will simply [`unwrap()`] these results, propagating panics
+/// among threads to ensure that a possibly invalid invariant is not witnessed.
+///
+/// A poisoned mutex, however, does not prevent all access to the underlying
+/// data. The [`PoisonError`] type has an [`into_inner`] method which will return
+/// the guard that would have otherwise been returned on a successful lock. This
+/// allows access to the data, despite the lock being poisoned.
+///
+/// [`new`]: Self::new
+/// [`lock`]: Self::lock
+/// [`try_lock`]: Self::try_lock
+/// [`unwrap()`]: Result::unwrap
+/// [`PoisonError`]: super::PoisonError
+/// [`into_inner`]: super::PoisonError::into_inner
+///
+/// # Examples
+///
+/// ```
+/// use std::sync::{Arc, Mutex};
+/// use std::thread;
+/// use std::sync::mpsc::channel;
+///
+/// const N: usize = 10;
+///
+/// // Spawn a few threads to increment a shared variable (non-atomically), and
+/// // let the main thread know once all increments are done.
+/// //
+/// // Here we're using an Arc to share memory among threads, and the data inside
+/// // the Arc is protected with a mutex.
+/// let data = Arc::new(Mutex::new(0));
+///
+/// let (tx, rx) = channel();
+/// for _ in 0..N {
+///     let (data, tx) = (Arc::clone(&data), tx.clone());
+///     thread::spawn(move || {
+///         // The shared state can only be accessed once the lock is held.
+///         // Our non-atomic increment is safe because we're the only thread
+///         // which can access the shared state when the lock is held.
+///         //
+///         // We unwrap() the return value to assert that we are not expecting
+///         // threads to ever fail while holding the lock.
+///         let mut data = data.lock().unwrap();
+///         *data += 1;
+///         if *data == N {
+///             tx.send(()).unwrap();
+///         }
+///         // the lock is unlocked here when `data` goes out of scope.
+///     });
+/// }
+///
+/// rx.recv().unwrap();
+/// ```
+///
+/// To recover from a poisoned mutex:
+///
+/// ```
+/// use std::sync::{Arc, Mutex};
+/// use std::thread;
+///
+/// let lock = Arc::new(Mutex::new(0_u32));
+/// let lock2 = Arc::clone(&lock);
+///
+/// let _ = thread::spawn(move || -> () {
+///     // This thread will acquire the mutex first, unwrapping the result of
+///     // `lock` because the lock has not been poisoned.
+///     let _guard = lock2.lock().unwrap();
+///
+///     // This panic while holding the lock (`_guard` is in scope) will poison
+///     // the mutex.
+///     panic!();
+/// }).join();
+///
+/// // The lock is poisoned by this point, but the returned result can be
+/// // pattern matched on to return the underlying guard on both branches.
+/// let mut guard = match lock.lock() {
+///     Ok(guard) => guard,
+///     Err(poisoned) => poisoned.into_inner(),
+/// };
+///
+/// *guard += 1;
+/// ```
+///
+/// To unlock a mutex guard sooner than the end of the enclosing scope,
+/// either create an inner scope or drop the guard manually.
+///
+/// ```
+/// use std::sync::{Arc, Mutex};
+/// use std::thread;
+///
+/// const N: usize = 3;
+///
+/// let data_mutex = Arc::new(Mutex::new(vec![1, 2, 3, 4]));
+/// let res_mutex = Arc::new(Mutex::new(0));
+///
+/// let mut threads = Vec::with_capacity(N);
+/// (0..N).for_each(|_| {
+///     let data_mutex_clone = Arc::clone(&data_mutex);
+///     let res_mutex_clone = Arc::clone(&res_mutex);
+///
+///     threads.push(thread::spawn(move || {
+///         // Here we use a block to limit the lifetime of the lock guard.
+///         let result = {
+///             let mut data = data_mutex_clone.lock().unwrap();
+///             // This is the result of some important and long-ish work.
+///             let result = data.iter().fold(0, |acc, x| acc + x * 2);
+///             data.push(result);
+///             result
+///             // The mutex guard gets dropped here, together with any other values
+///             // created in the critical section.
+///         };
+///         // The guard created here is a temporary dropped at the end of the statement, i.e.
+///         // the lock would not remain being held even if the thread did some additional work.
+///         *res_mutex_clone.lock().unwrap() += result;
+///     }));
+/// });
+///
+/// let mut data = data_mutex.lock().unwrap();
+/// // This is the result of some important and long-ish work.
+/// let result = data.iter().fold(0, |acc, x| acc + x * 2);
+/// data.push(result);
+/// // We drop the `data` explicitly because it's not necessary anymore and the
+/// // thread still has work to do. This allows other threads to start working on
+/// // the data immediately, without waiting for the rest of the unrelated work
+/// // to be done here.
+/// //
+/// // It's even more important here than in the threads because we `.join` the
+/// // threads after that. If we had not dropped the mutex guard, a thread could
+/// // be waiting forever for it, causing a deadlock.
+/// // As in the threads, a block could have been used instead of calling the
+/// // `drop` function.
+/// drop(data);
+/// // Here the mutex guard is not assigned to a variable and so, even if the
+/// // scope does not end after this line, the mutex is still released: there is
+/// // no deadlock.
+/// *res_mutex.lock().unwrap() += result;
+///
+/// threads.into_iter().for_each(|thread| {
+///     thread
+///         .join()
+///         .expect("The thread creating or execution failed !")
+/// });
+///
+/// assert_eq!(*res_mutex.lock().unwrap(), 800);
+/// ```
+///
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "Mutex")]
+pub struct Mutex<T: ?Sized> {
+    inner: sys::Mutex,
+    poison: poison::Flag,
+    data: UnsafeCell<T>,
+}
+
+// these are the only places where `T: Send` matters; all other
+// functionality works fine on a single thread.
+#[stable(feature = "rust1", since = "1.0.0")]
+unsafe impl<T: ?Sized + Send> Send for Mutex<T> {}
+#[stable(feature = "rust1", since = "1.0.0")]
+unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}
+
+/// An RAII implementation of a "scoped lock" of a mutex. When this structure is
+/// dropped (falls out of scope), the lock will be unlocked.
+///
+/// The data protected by the mutex can be accessed through this guard via its
+/// [`Deref`] and [`DerefMut`] implementations.
+///
+/// This structure is created by the [`lock`] and [`try_lock`] methods on
+/// [`Mutex`].
+///
+/// [`lock`]: Mutex::lock
+/// [`try_lock`]: Mutex::try_lock
+#[must_use = "if unused the Mutex will immediately unlock"]
+#[must_not_suspend = "holding a MutexGuard across suspend \
+                      points can cause deadlocks, delays, \
+                      and cause Futures to not implement `Send`"]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[clippy::has_significant_drop]
+#[cfg_attr(not(test), rustc_diagnostic_item = "MutexGuard")]
+pub struct MutexGuard<'a, T: ?Sized + 'a> {
+    lock: &'a Mutex<T>,
+    poison: poison::Guard,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> !Send for MutexGuard<'_, T> {}
+#[stable(feature = "mutexguard", since = "1.19.0")]
+unsafe impl<T: ?Sized + Sync> Sync for MutexGuard<'_, T> {}
+
+/// An RAII mutex guard returned by `MutexGuard::map`, which can point to a
+/// subfield of the protected data. When this structure is dropped (falls out
+/// of scope), the lock will be unlocked.
+///
+/// The main difference between `MappedMutexGuard` and [`MutexGuard`] is that the
+/// former cannot be used with [`Condvar`], since that
+/// could introduce soundness issues if the locked object is modified by another
+/// thread while the `Mutex` is unlocked.
+///
+/// The data protected by the mutex can be accessed through this guard via its
+/// [`Deref`] and [`DerefMut`] implementations.
+///
+/// This structure is created by the [`map`] and [`try_map`] methods on
+/// [`MutexGuard`].
+///
+/// [`map`]: MutexGuard::map
+/// [`try_map`]: MutexGuard::try_map
+/// [`Condvar`]: crate::sync::Condvar
+#[must_use = "if unused the Mutex will immediately unlock"]
+#[must_not_suspend = "holding a MappedMutexGuard across suspend \
+                      points can cause deadlocks, delays, \
+                      and cause Futures to not implement `Send`"]
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+#[clippy::has_significant_drop]
+pub struct MappedMutexGuard<'a, T: ?Sized + 'a> {
+    // NB: we use a pointer instead of `&'a mut T` to avoid `noalias` violations, because a
+    // `MappedMutexGuard` argument doesn't hold uniqueness for its whole scope, only until it drops.
+    // `NonNull` is covariant over `T`, so we add a `PhantomData<&'a mut T>` field
+    // below for the correct variance over `T` (invariance).
+    data: NonNull<T>,
+    inner: &'a sys::Mutex,
+    poison_flag: &'a poison::Flag,
+    poison: poison::Guard,
+    _variance: PhantomData<&'a mut T>,
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> !Send for MappedMutexGuard<'_, T> {}
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+unsafe impl<T: ?Sized + Sync> Sync for MappedMutexGuard<'_, T> {}
+
+impl<T> Mutex<T> {
+    /// Creates a new mutex in an unlocked state ready for use.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Mutex;
+    ///
+    /// let mutex = Mutex::new(0);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
+    #[inline]
+    pub const fn new(t: T) -> Mutex<T> {
+        Mutex { inner: sys::Mutex::new(), poison: poison::Flag::new(), data: UnsafeCell::new(t) }
+    }
+
+    /// Returns the contained value by cloning it.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(7);
+    ///
+    /// assert_eq!(mutex.get_cloned().unwrap(), 7);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn get_cloned(&self) -> Result<T, PoisonError<()>>
+    where
+        T: Clone,
+    {
+        match self.lock() {
+            Ok(guard) => Ok((*guard).clone()),
+            Err(_) => Err(PoisonError::new(())),
+        }
+    }
+
+    /// Sets the contained value.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error containing the provided `value` instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(7);
+    ///
+    /// assert_eq!(mutex.get_cloned().unwrap(), 7);
+    /// mutex.set(11).unwrap();
+    /// assert_eq!(mutex.get_cloned().unwrap(), 11);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn set(&self, value: T) -> Result<(), PoisonError<T>> {
+        if mem::needs_drop::<T>() {
+            // If the contained value has non-trivial destructor, we
+            // call that destructor after the lock being released.
+            self.replace(value).map(drop)
+        } else {
+            match self.lock() {
+                Ok(mut guard) => {
+                    *guard = value;
+
+                    Ok(())
+                }
+                Err(_) => Err(PoisonError::new(value)),
+            }
+        }
+    }
+
+    /// Replaces the contained value with `value`, and returns the old contained value.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error containing the provided `value` instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(7);
+    ///
+    /// assert_eq!(mutex.replace(11).unwrap(), 7);
+    /// assert_eq!(mutex.get_cloned().unwrap(), 11);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn replace(&self, value: T) -> LockResult<T> {
+        match self.lock() {
+            Ok(mut guard) => Ok(mem::replace(&mut *guard, value)),
+            Err(_) => Err(PoisonError::new(value)),
+        }
+    }
+}
+
+impl<T: ?Sized> Mutex<T> {
+    /// Acquires a mutex, blocking the current thread until it is able to do so.
+    ///
+    /// This function will block the local thread until it is available to acquire
+    /// the mutex. Upon returning, the thread is the only thread with the lock
+    /// held. An RAII guard is returned to allow scoped unlock of the lock. When
+    /// the guard goes out of scope, the mutex will be unlocked.
+    ///
+    /// The exact behavior on locking a mutex in the thread which already holds
+    /// the lock is left unspecified. However, this function will not return on
+    /// the second call (it might panic or deadlock, for example).
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error once the mutex is acquired. The acquired
+    /// mutex guard will be contained in the returned error.
+    ///
+    /// # Panics
+    ///
+    /// This function might panic when called if the lock is already held by
+    /// the current thread.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex};
+    /// use std::thread;
+    ///
+    /// let mutex = Arc::new(Mutex::new(0));
+    /// let c_mutex = Arc::clone(&mutex);
+    ///
+    /// thread::spawn(move || {
+    ///     *c_mutex.lock().unwrap() = 10;
+    /// }).join().expect("thread::spawn failed");
+    /// assert_eq!(*mutex.lock().unwrap(), 10);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
+        unsafe {
+            self.inner.lock();
+            MutexGuard::new(self)
+        }
+    }
+
+    /// Attempts to acquire this lock.
+    ///
+    /// If the lock could not be acquired at this time, then [`Err`] is returned.
+    /// Otherwise, an RAII guard is returned. The lock will be unlocked when the
+    /// guard is dropped.
+    ///
+    /// This function does not block.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return the [`Poisoned`] error if the mutex would
+    /// otherwise be acquired. An acquired lock guard will be contained
+    /// in the returned error.
+    ///
+    /// If the mutex could not be acquired because it is already locked, then
+    /// this call will return the [`WouldBlock`] error.
+    ///
+    /// [`Poisoned`]: TryLockError::Poisoned
+    /// [`WouldBlock`]: TryLockError::WouldBlock
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex};
+    /// use std::thread;
+    ///
+    /// let mutex = Arc::new(Mutex::new(0));
+    /// let c_mutex = Arc::clone(&mutex);
+    ///
+    /// thread::spawn(move || {
+    ///     let mut lock = c_mutex.try_lock();
+    ///     if let Ok(ref mut mutex) = lock {
+    ///         **mutex = 10;
+    ///     } else {
+    ///         println!("try_lock failed");
+    ///     }
+    /// }).join().expect("thread::spawn failed");
+    /// assert_eq!(*mutex.lock().unwrap(), 10);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>> {
+        unsafe {
+            if self.inner.try_lock() {
+                Ok(MutexGuard::new(self)?)
+            } else {
+                Err(TryLockError::WouldBlock)
+            }
+        }
+    }
+
+    /// Determines whether the mutex is poisoned.
+    ///
+    /// If another thread is active, the mutex can still become poisoned at any
+    /// time. You should not trust a `false` value for program correctness
+    /// without additional synchronization.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex};
+    /// use std::thread;
+    ///
+    /// let mutex = Arc::new(Mutex::new(0));
+    /// let c_mutex = Arc::clone(&mutex);
+    ///
+    /// let _ = thread::spawn(move || {
+    ///     let _lock = c_mutex.lock().unwrap();
+    ///     panic!(); // the mutex gets poisoned
+    /// }).join();
+    /// assert_eq!(mutex.is_poisoned(), true);
+    /// ```
+    #[inline]
+    #[stable(feature = "sync_poison", since = "1.2.0")]
+    pub fn is_poisoned(&self) -> bool {
+        self.poison.get()
+    }
+
+    /// Clear the poisoned state from a mutex.
+    ///
+    /// If the mutex is poisoned, it will remain poisoned until this function is called. This
+    /// allows recovering from a poisoned state and marking that it has recovered. For example, if
+    /// the value is overwritten by a known-good value, then the mutex can be marked as
+    /// un-poisoned. Or possibly, the value could be inspected to determine if it is in a
+    /// consistent state, and if so the poison is removed.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, Mutex};
+    /// use std::thread;
+    ///
+    /// let mutex = Arc::new(Mutex::new(0));
+    /// let c_mutex = Arc::clone(&mutex);
+    ///
+    /// let _ = thread::spawn(move || {
+    ///     let _lock = c_mutex.lock().unwrap();
+    ///     panic!(); // the mutex gets poisoned
+    /// }).join();
+    ///
+    /// assert_eq!(mutex.is_poisoned(), true);
+    /// let x = mutex.lock().unwrap_or_else(|mut e| {
+    ///     **e.get_mut() = 1;
+    ///     mutex.clear_poison();
+    ///     e.into_inner()
+    /// });
+    /// assert_eq!(mutex.is_poisoned(), false);
+    /// assert_eq!(*x, 1);
+    /// ```
+    #[inline]
+    #[stable(feature = "mutex_unpoison", since = "1.77.0")]
+    pub fn clear_poison(&self) {
+        self.poison.clear();
+    }
+
+    /// Consumes this mutex, returning the underlying data.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error containing the the underlying data
+    /// instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Mutex;
+    ///
+    /// let mutex = Mutex::new(0);
+    /// assert_eq!(mutex.into_inner().unwrap(), 0);
+    /// ```
+    #[stable(feature = "mutex_into_inner", since = "1.6.0")]
+    pub fn into_inner(self) -> LockResult<T>
+    where
+        T: Sized,
+    {
+        let data = self.data.into_inner();
+        poison::map_result(self.poison.borrow(), |()| data)
+    }
+
+    /// Returns a mutable reference to the underlying data.
+    ///
+    /// Since this call borrows the `Mutex` mutably, no actual locking needs to
+    /// take place -- the mutable borrow statically guarantees no locks exist.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error containing a mutable reference to the
+    /// underlying data instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(0);
+    /// *mutex.get_mut().unwrap() = 10;
+    /// assert_eq!(*mutex.lock().unwrap(), 10);
+    /// ```
+    #[stable(feature = "mutex_get_mut", since = "1.6.0")]
+    pub fn get_mut(&mut self) -> LockResult<&mut T> {
+        let data = self.data.get_mut();
+        poison::map_result(self.poison.borrow(), |()| data)
+    }
+}
+
+#[stable(feature = "mutex_from", since = "1.24.0")]
+impl<T> From<T> for Mutex<T> {
+    /// Creates a new mutex in an unlocked state ready for use.
+    /// This is equivalent to [`Mutex::new`].
+    fn from(t: T) -> Self {
+        Mutex::new(t)
+    }
+}
+
+#[stable(feature = "mutex_default", since = "1.10.0")]
+impl<T: ?Sized + Default> Default for Mutex<T> {
+    /// Creates a `Mutex<T>`, with the `Default` value for T.
+    fn default() -> Mutex<T> {
+        Mutex::new(Default::default())
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut d = f.debug_struct("Mutex");
+        match self.try_lock() {
+            Ok(guard) => {
+                d.field("data", &&*guard);
+            }
+            Err(TryLockError::Poisoned(err)) => {
+                d.field("data", &&**err.get_ref());
+            }
+            Err(TryLockError::WouldBlock) => {
+                d.field("data", &format_args!("<locked>"));
+            }
+        }
+        d.field("poisoned", &self.poison.get());
+        d.finish_non_exhaustive()
+    }
+}
+
+impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
+    unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> {
+        poison::map_result(lock.poison.guard(), |guard| MutexGuard { lock, poison: guard })
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Deref for MutexGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.data.get() }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.lock.data.get() }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Drop for MutexGuard<'_, T> {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            self.lock.poison.done(&self.poison);
+            self.lock.inner.unlock();
+        }
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+#[stable(feature = "std_guard_impls", since = "1.20.0")]
+impl<T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {
+    &guard.lock.inner
+}
+
+pub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {
+    &guard.lock.poison
+}
+
+impl<'a, T: ?Sized> MutexGuard<'a, T> {
+    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data, e.g.
+    /// an enum variant.
+    ///
+    /// The `Mutex` is already locked, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MutexGuard::map(...)`. A method would interfere with methods of the
+    /// same name on the contents of the `MutexGuard` used through `Deref`.
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn map<U, F>(orig: Self, f: F) -> MappedMutexGuard<'a, U>
+    where
+        F: FnOnce(&mut T) -> &mut U,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        let data = NonNull::from(f(unsafe { &mut *orig.lock.data.get() }));
+        let orig = ManuallyDrop::new(orig);
+        MappedMutexGuard {
+            data,
+            inner: &orig.lock.inner,
+            poison_flag: &orig.lock.poison,
+            poison: orig.poison.clone(),
+            _variance: PhantomData,
+        }
+    }
+
+    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data. The
+    /// original guard is returned as an `Err(...)` if the closure returns
+    /// `None`.
+    ///
+    /// The `Mutex` is already locked, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MutexGuard::try_map(...)`. A method would interfere with methods of the
+    /// same name on the contents of the `MutexGuard` used through `Deref`.
+    #[doc(alias = "filter_map")]
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedMutexGuard<'a, U>, Self>
+    where
+        F: FnOnce(&mut T) -> Option<&mut U>,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        match f(unsafe { &mut *orig.lock.data.get() }) {
+            Some(data) => {
+                let data = NonNull::from(data);
+                let orig = ManuallyDrop::new(orig);
+                Ok(MappedMutexGuard {
+                    data,
+                    inner: &orig.lock.inner,
+                    poison_flag: &orig.lock.poison,
+                    poison: orig.poison.clone(),
+                    _variance: PhantomData,
+                })
+            }
+            None => Err(orig),
+        }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> Deref for MappedMutexGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { self.data.as_ref() }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> DerefMut for MappedMutexGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { self.data.as_mut() }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> Drop for MappedMutexGuard<'_, T> {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            self.poison_flag.done(&self.poison);
+            self.inner.unlock();
+        }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for MappedMutexGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized + fmt::Display> fmt::Display for MappedMutexGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<'a, T: ?Sized> MappedMutexGuard<'a, T> {
+    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data, e.g.
+    /// an enum variant.
+    ///
+    /// The `Mutex` is already locked, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MappedMutexGuard::map(...)`. A method would interfere with methods of the
+    /// same name on the contents of the `MutexGuard` used through `Deref`.
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn map<U, F>(mut orig: Self, f: F) -> MappedMutexGuard<'a, U>
+    where
+        F: FnOnce(&mut T) -> &mut U,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        let data = NonNull::from(f(unsafe { orig.data.as_mut() }));
+        let orig = ManuallyDrop::new(orig);
+        MappedMutexGuard {
+            data,
+            inner: orig.inner,
+            poison_flag: orig.poison_flag,
+            poison: orig.poison.clone(),
+            _variance: PhantomData,
+        }
+    }
+
+    /// Makes a [`MappedMutexGuard`] for a component of the borrowed data. The
+    /// original guard is returned as an `Err(...)` if the closure returns
+    /// `None`.
+    ///
+    /// The `Mutex` is already locked, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MappedMutexGuard::try_map(...)`. A method would interfere with methods of the
+    /// same name on the contents of the `MutexGuard` used through `Deref`.
+    #[doc(alias = "filter_map")]
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn try_map<U, F>(mut orig: Self, f: F) -> Result<MappedMutexGuard<'a, U>, Self>
+    where
+        F: FnOnce(&mut T) -> Option<&mut U>,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `MutexGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        match f(unsafe { orig.data.as_mut() }) {
+            Some(data) => {
+                let data = NonNull::from(data);
+                let orig = ManuallyDrop::new(orig);
+                Ok(MappedMutexGuard {
+                    data,
+                    inner: orig.inner,
+                    poison_flag: orig.poison_flag,
+                    poison: orig.poison.clone(),
+                    _variance: PhantomData,
+                })
+            }
+            None => Err(orig),
+        }
+    }
+}
diff --git a/library/std/src/sync/poison/mutex/tests.rs b/library/std/src/sync/poison/mutex/tests.rs
new file mode 100644
index 00000000000..395c8aada08
--- /dev/null
+++ b/library/std/src/sync/poison/mutex/tests.rs
@@ -0,0 +1,442 @@
+use crate::fmt::Debug;
+use crate::ops::FnMut;
+use crate::panic::{self, AssertUnwindSafe};
+use crate::sync::atomic::{AtomicUsize, Ordering};
+use crate::sync::mpsc::channel;
+use crate::sync::{Arc, Condvar, MappedMutexGuard, Mutex, MutexGuard, TryLockError};
+use crate::{hint, mem, thread};
+
+struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
+
+#[derive(Eq, PartialEq, Debug)]
+struct NonCopy(i32);
+
+#[derive(Eq, PartialEq, Debug)]
+struct NonCopyNeedsDrop(i32);
+
+impl Drop for NonCopyNeedsDrop {
+    fn drop(&mut self) {
+        hint::black_box(());
+    }
+}
+
+#[test]
+fn test_needs_drop() {
+    assert!(!mem::needs_drop::<NonCopy>());
+    assert!(mem::needs_drop::<NonCopyNeedsDrop>());
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+struct Cloneable(i32);
+
+#[test]
+fn smoke() {
+    let m = Mutex::new(());
+    drop(m.lock().unwrap());
+    drop(m.lock().unwrap());
+}
+
+#[test]
+fn lots_and_lots() {
+    const J: u32 = 1000;
+    const K: u32 = 3;
+
+    let m = Arc::new(Mutex::new(0));
+
+    fn inc(m: &Mutex<u32>) {
+        for _ in 0..J {
+            *m.lock().unwrap() += 1;
+        }
+    }
+
+    let (tx, rx) = channel();
+    for _ in 0..K {
+        let tx2 = tx.clone();
+        let m2 = m.clone();
+        thread::spawn(move || {
+            inc(&m2);
+            tx2.send(()).unwrap();
+        });
+        let tx2 = tx.clone();
+        let m2 = m.clone();
+        thread::spawn(move || {
+            inc(&m2);
+            tx2.send(()).unwrap();
+        });
+    }
+
+    drop(tx);
+    for _ in 0..2 * K {
+        rx.recv().unwrap();
+    }
+    assert_eq!(*m.lock().unwrap(), J * K * 2);
+}
+
+#[test]
+fn try_lock() {
+    let m = Mutex::new(());
+    *m.try_lock().unwrap() = ();
+}
+
+fn new_poisoned_mutex<T>(value: T) -> Mutex<T> {
+    let mutex = Mutex::new(value);
+
+    let catch_unwind_result = panic::catch_unwind(AssertUnwindSafe(|| {
+        let _guard = mutex.lock().unwrap();
+
+        panic!("test panic to poison mutex");
+    }));
+
+    assert!(catch_unwind_result.is_err());
+    assert!(mutex.is_poisoned());
+
+    mutex
+}
+
+#[test]
+fn test_into_inner() {
+    let m = Mutex::new(NonCopy(10));
+    assert_eq!(m.into_inner().unwrap(), NonCopy(10));
+}
+
+#[test]
+fn test_into_inner_drop() {
+    struct Foo(Arc<AtomicUsize>);
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+    let num_drops = Arc::new(AtomicUsize::new(0));
+    let m = Mutex::new(Foo(num_drops.clone()));
+    assert_eq!(num_drops.load(Ordering::SeqCst), 0);
+    {
+        let _inner = m.into_inner().unwrap();
+        assert_eq!(num_drops.load(Ordering::SeqCst), 0);
+    }
+    assert_eq!(num_drops.load(Ordering::SeqCst), 1);
+}
+
+#[test]
+fn test_into_inner_poison() {
+    let m = new_poisoned_mutex(NonCopy(10));
+
+    match m.into_inner() {
+        Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
+        Ok(x) => panic!("into_inner of poisoned Mutex is Ok: {x:?}"),
+    }
+}
+
+#[test]
+fn test_get_cloned() {
+    let m = Mutex::new(Cloneable(10));
+
+    assert_eq!(m.get_cloned().unwrap(), Cloneable(10));
+}
+
+#[test]
+fn test_get_cloned_poison() {
+    let m = new_poisoned_mutex(Cloneable(10));
+
+    match m.get_cloned() {
+        Err(e) => assert_eq!(e.into_inner(), ()),
+        Ok(x) => panic!("get of poisoned Mutex is Ok: {x:?}"),
+    }
+}
+
+#[test]
+fn test_get_mut() {
+    let mut m = Mutex::new(NonCopy(10));
+    *m.get_mut().unwrap() = NonCopy(20);
+    assert_eq!(m.into_inner().unwrap(), NonCopy(20));
+}
+
+#[test]
+fn test_get_mut_poison() {
+    let mut m = new_poisoned_mutex(NonCopy(10));
+
+    match m.get_mut() {
+        Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
+        Ok(x) => panic!("get_mut of poisoned Mutex is Ok: {x:?}"),
+    }
+}
+
+#[test]
+fn test_set() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = Mutex::new(init());
+
+        assert_eq!(*m.lock().unwrap(), init());
+        m.set(value()).unwrap();
+        assert_eq!(*m.lock().unwrap(), value());
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_set_poison() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = new_poisoned_mutex(init());
+
+        match m.set(value()) {
+            Err(e) => {
+                assert_eq!(e.into_inner(), value());
+                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
+            }
+            Ok(x) => panic!("set of poisoned Mutex is Ok: {x:?}"),
+        }
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_replace() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = Mutex::new(init());
+
+        assert_eq!(*m.lock().unwrap(), init());
+        assert_eq!(m.replace(value()).unwrap(), init());
+        assert_eq!(*m.lock().unwrap(), value());
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_replace_poison() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = new_poisoned_mutex(init());
+
+        match m.replace(value()) {
+            Err(e) => {
+                assert_eq!(e.into_inner(), value());
+                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
+            }
+            Ok(x) => panic!("replace of poisoned Mutex is Ok: {x:?}"),
+        }
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_mutex_arc_condvar() {
+    let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
+    let packet2 = Packet(packet.0.clone());
+    let (tx, rx) = channel();
+    let _t = thread::spawn(move || {
+        // wait until parent gets in
+        rx.recv().unwrap();
+        let &(ref lock, ref cvar) = &*packet2.0;
+        let mut lock = lock.lock().unwrap();
+        *lock = true;
+        cvar.notify_one();
+    });
+
+    let &(ref lock, ref cvar) = &*packet.0;
+    let mut lock = lock.lock().unwrap();
+    tx.send(()).unwrap();
+    assert!(!*lock);
+    while !*lock {
+        lock = cvar.wait(lock).unwrap();
+    }
+}
+
+#[test]
+fn test_arc_condvar_poison() {
+    let packet = Packet(Arc::new((Mutex::new(1), Condvar::new())));
+    let packet2 = Packet(packet.0.clone());
+    let (tx, rx) = channel();
+
+    let _t = thread::spawn(move || -> () {
+        rx.recv().unwrap();
+        let &(ref lock, ref cvar) = &*packet2.0;
+        let _g = lock.lock().unwrap();
+        cvar.notify_one();
+        // Parent should fail when it wakes up.
+        panic!();
+    });
+
+    let &(ref lock, ref cvar) = &*packet.0;
+    let mut lock = lock.lock().unwrap();
+    tx.send(()).unwrap();
+    while *lock == 1 {
+        match cvar.wait(lock) {
+            Ok(l) => {
+                lock = l;
+                assert_eq!(*lock, 1);
+            }
+            Err(..) => break,
+        }
+    }
+}
+
+#[test]
+fn test_mutex_arc_poison() {
+    let arc = Arc::new(Mutex::new(1));
+    assert!(!arc.is_poisoned());
+    let arc2 = arc.clone();
+    let _ = thread::spawn(move || {
+        let lock = arc2.lock().unwrap();
+        assert_eq!(*lock, 2); // deliberate assertion failure to poison the mutex
+    })
+    .join();
+    assert!(arc.lock().is_err());
+    assert!(arc.is_poisoned());
+}
+
+#[test]
+fn test_mutex_arc_poison_mapped() {
+    let arc = Arc::new(Mutex::new(1));
+    assert!(!arc.is_poisoned());
+    let arc2 = arc.clone();
+    let _ = thread::spawn(move || {
+        let lock = arc2.lock().unwrap();
+        let lock = MutexGuard::map(lock, |val| val);
+        assert_eq!(*lock, 2); // deliberate assertion failure to poison the mutex
+    })
+    .join();
+    assert!(arc.lock().is_err());
+    assert!(arc.is_poisoned());
+}
+
+#[test]
+fn test_mutex_arc_nested() {
+    // Tests nested mutexes and access
+    // to underlying data.
+    let arc = Arc::new(Mutex::new(1));
+    let arc2 = Arc::new(Mutex::new(arc));
+    let (tx, rx) = channel();
+    let _t = thread::spawn(move || {
+        let lock = arc2.lock().unwrap();
+        let lock2 = lock.lock().unwrap();
+        assert_eq!(*lock2, 1);
+        tx.send(()).unwrap();
+    });
+    rx.recv().unwrap();
+}
+
+#[test]
+fn test_mutex_arc_access_in_unwind() {
+    let arc = Arc::new(Mutex::new(1));
+    let arc2 = arc.clone();
+    let _ = thread::spawn(move || -> () {
+        struct Unwinder {
+            i: Arc<Mutex<i32>>,
+        }
+        impl Drop for Unwinder {
+            fn drop(&mut self) {
+                *self.i.lock().unwrap() += 1;
+            }
+        }
+        let _u = Unwinder { i: arc2 };
+        panic!();
+    })
+    .join();
+    let lock = arc.lock().unwrap();
+    assert_eq!(*lock, 2);
+}
+
+#[test]
+fn test_mutex_unsized() {
+    let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]);
+    {
+        let b = &mut *mutex.lock().unwrap();
+        b[0] = 4;
+        b[2] = 5;
+    }
+    let comp: &[i32] = &[4, 2, 5];
+    assert_eq!(&*mutex.lock().unwrap(), comp);
+}
+
+#[test]
+fn test_mapping_mapped_guard() {
+    let arr = [0; 4];
+    let mut lock = Mutex::new(arr);
+    let guard = lock.lock().unwrap();
+    let guard = MutexGuard::map(guard, |arr| &mut arr[..2]);
+    let mut guard = MappedMutexGuard::map(guard, |slice| &mut slice[1..]);
+    assert_eq!(guard.len(), 1);
+    guard[0] = 42;
+    drop(guard);
+    assert_eq!(*lock.get_mut().unwrap(), [0, 42, 0, 0]);
+}
+
+#[test]
+fn panic_while_mapping_unlocked_poison() {
+    let lock = Mutex::new(());
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.lock().unwrap();
+        let _guard = MutexGuard::map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_lock() {
+        Ok(_) => panic!("panicking in a MutexGuard::map closure should poison the Mutex"),
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a MutexGuard::map closure should unlock the mutex")
+        }
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.lock().unwrap();
+        let _guard = MutexGuard::try_map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_lock() {
+        Ok(_) => panic!("panicking in a MutexGuard::try_map closure should poison the Mutex"),
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a MutexGuard::try_map closure should unlock the mutex")
+        }
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.lock().unwrap();
+        let guard = MutexGuard::map::<(), _>(guard, |val| val);
+        let _guard = MappedMutexGuard::map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_lock() {
+        Ok(_) => panic!("panicking in a MappedMutexGuard::map closure should poison the Mutex"),
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a MappedMutexGuard::map closure should unlock the mutex")
+        }
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.lock().unwrap();
+        let guard = MutexGuard::map::<(), _>(guard, |val| val);
+        let _guard = MappedMutexGuard::try_map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_lock() {
+        Ok(_) => panic!("panicking in a MappedMutexGuard::try_map closure should poison the Mutex"),
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a MappedMutexGuard::try_map closure should unlock the mutex")
+        }
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    drop(lock);
+}
diff --git a/library/std/src/sync/poison/once.rs b/library/std/src/sync/poison/once.rs
new file mode 100644
index 00000000000..27db4b634fb
--- /dev/null
+++ b/library/std/src/sync/poison/once.rs
@@ -0,0 +1,390 @@
+//! A "once initialization" primitive
+//!
+//! This primitive is meant to be used to run one-time initialization. An
+//! example use case would be for initializing an FFI library.
+
+#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
+mod tests;
+
+use crate::fmt;
+use crate::panic::{RefUnwindSafe, UnwindSafe};
+use crate::sys::sync as sys;
+
+/// A low-level synchronization primitive for one-time global execution.
+///
+/// Previously this was the only "execute once" synchronization in `std`.
+/// Other libraries implemented novel synchronizing types with `Once`, like
+/// [`OnceLock<T>`] or [`LazyLock<T, F>`], before those were added to `std`.
+/// `OnceLock<T>` in particular supersedes `Once` in functionality and should
+/// be preferred for the common case where the `Once` is associated with data.
+///
+/// This type can only be constructed with [`Once::new()`].
+///
+/// # Examples
+///
+/// ```
+/// use std::sync::Once;
+///
+/// static START: Once = Once::new();
+///
+/// START.call_once(|| {
+///     // run initialization here
+/// });
+/// ```
+///
+/// [`OnceLock<T>`]: crate::sync::OnceLock
+/// [`LazyLock<T, F>`]: crate::sync::LazyLock
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct Once {
+    inner: sys::Once,
+}
+
+#[stable(feature = "sync_once_unwind_safe", since = "1.59.0")]
+impl UnwindSafe for Once {}
+
+#[stable(feature = "sync_once_unwind_safe", since = "1.59.0")]
+impl RefUnwindSafe for Once {}
+
+/// State yielded to [`Once::call_once_force()`]’s closure parameter. The state
+/// can be used to query the poison status of the [`Once`].
+#[stable(feature = "once_poison", since = "1.51.0")]
+pub struct OnceState {
+    pub(crate) inner: sys::OnceState,
+}
+
+pub(crate) enum ExclusiveState {
+    Incomplete,
+    Poisoned,
+    Complete,
+}
+
+/// Initialization value for static [`Once`] values.
+///
+/// # Examples
+///
+/// ```
+/// use std::sync::{Once, ONCE_INIT};
+///
+/// static START: Once = ONCE_INIT;
+/// ```
+#[stable(feature = "rust1", since = "1.0.0")]
+#[deprecated(
+    since = "1.38.0",
+    note = "the `Once::new()` function is now preferred",
+    suggestion = "Once::new()"
+)]
+pub const ONCE_INIT: Once = Once::new();
+
+impl Once {
+    /// Creates a new `Once` value.
+    #[inline]
+    #[stable(feature = "once_new", since = "1.2.0")]
+    #[rustc_const_stable(feature = "const_once_new", since = "1.32.0")]
+    #[must_use]
+    pub const fn new() -> Once {
+        Once { inner: sys::Once::new() }
+    }
+
+    /// Performs an initialization routine once and only once. The given closure
+    /// will be executed if this is the first time `call_once` has been called,
+    /// and otherwise the routine will *not* be invoked.
+    ///
+    /// This method will block the calling thread if another initialization
+    /// routine is currently running.
+    ///
+    /// When this function returns, it is guaranteed that some initialization
+    /// has run and completed (it might not be the closure specified). It is also
+    /// guaranteed that any memory writes performed by the executed closure can
+    /// be reliably observed by other threads at this point (there is a
+    /// happens-before relation between the closure and code executing after the
+    /// return).
+    ///
+    /// If the given closure recursively invokes `call_once` on the same [`Once`]
+    /// instance, the exact behavior is not specified: allowed outcomes are
+    /// a panic or a deadlock.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Once;
+    ///
+    /// static mut VAL: usize = 0;
+    /// static INIT: Once = Once::new();
+    ///
+    /// // Accessing a `static mut` is unsafe much of the time, but if we do so
+    /// // in a synchronized fashion (e.g., write once or read all) then we're
+    /// // good to go!
+    /// //
+    /// // This function will only call `expensive_computation` once, and will
+    /// // otherwise always return the value returned from the first invocation.
+    /// fn get_cached_val() -> usize {
+    ///     unsafe {
+    ///         INIT.call_once(|| {
+    ///             VAL = expensive_computation();
+    ///         });
+    ///         VAL
+    ///     }
+    /// }
+    ///
+    /// fn expensive_computation() -> usize {
+    ///     // ...
+    /// # 2
+    /// }
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// The closure `f` will only be executed once even if this is called
+    /// concurrently amongst many threads. If that closure panics, however, then
+    /// it will *poison* this [`Once`] instance, causing all future invocations of
+    /// `call_once` to also panic.
+    ///
+    /// This is similar to [poisoning with mutexes][poison].
+    ///
+    /// [poison]: struct.Mutex.html#poisoning
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[track_caller]
+    pub fn call_once<F>(&self, f: F)
+    where
+        F: FnOnce(),
+    {
+        // Fast path check
+        if self.inner.is_completed() {
+            return;
+        }
+
+        let mut f = Some(f);
+        self.inner.call(false, &mut |_| f.take().unwrap()());
+    }
+
+    /// Performs the same function as [`call_once()`] except ignores poisoning.
+    ///
+    /// Unlike [`call_once()`], if this [`Once`] has been poisoned (i.e., a previous
+    /// call to [`call_once()`] or [`call_once_force()`] caused a panic), calling
+    /// [`call_once_force()`] will still invoke the closure `f` and will _not_
+    /// result in an immediate panic. If `f` panics, the [`Once`] will remain
+    /// in a poison state. If `f` does _not_ panic, the [`Once`] will no
+    /// longer be in a poison state and all future calls to [`call_once()`] or
+    /// [`call_once_force()`] will be no-ops.
+    ///
+    /// The closure `f` is yielded a [`OnceState`] structure which can be used
+    /// to query the poison status of the [`Once`].
+    ///
+    /// [`call_once()`]: Once::call_once
+    /// [`call_once_force()`]: Once::call_once_force
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Once;
+    /// use std::thread;
+    ///
+    /// static INIT: Once = Once::new();
+    ///
+    /// // poison the once
+    /// let handle = thread::spawn(|| {
+    ///     INIT.call_once(|| panic!());
+    /// });
+    /// assert!(handle.join().is_err());
+    ///
+    /// // poisoning propagates
+    /// let handle = thread::spawn(|| {
+    ///     INIT.call_once(|| {});
+    /// });
+    /// assert!(handle.join().is_err());
+    ///
+    /// // call_once_force will still run and reset the poisoned state
+    /// INIT.call_once_force(|state| {
+    ///     assert!(state.is_poisoned());
+    /// });
+    ///
+    /// // once any success happens, we stop propagating the poison
+    /// INIT.call_once(|| {});
+    /// ```
+    #[inline]
+    #[stable(feature = "once_poison", since = "1.51.0")]
+    pub fn call_once_force<F>(&self, f: F)
+    where
+        F: FnOnce(&OnceState),
+    {
+        // Fast path check
+        if self.inner.is_completed() {
+            return;
+        }
+
+        let mut f = Some(f);
+        self.inner.call(true, &mut |p| f.take().unwrap()(p));
+    }
+
+    /// Returns `true` if some [`call_once()`] call has completed
+    /// successfully. Specifically, `is_completed` will return false in
+    /// the following situations:
+    ///   * [`call_once()`] was not called at all,
+    ///   * [`call_once()`] was called, but has not yet completed,
+    ///   * the [`Once`] instance is poisoned
+    ///
+    /// This function returning `false` does not mean that [`Once`] has not been
+    /// executed. For example, it may have been executed in the time between
+    /// when `is_completed` starts executing and when it returns, in which case
+    /// the `false` return value would be stale (but still permissible).
+    ///
+    /// [`call_once()`]: Once::call_once
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::Once;
+    ///
+    /// static INIT: Once = Once::new();
+    ///
+    /// assert_eq!(INIT.is_completed(), false);
+    /// INIT.call_once(|| {
+    ///     assert_eq!(INIT.is_completed(), false);
+    /// });
+    /// assert_eq!(INIT.is_completed(), true);
+    /// ```
+    ///
+    /// ```
+    /// use std::sync::Once;
+    /// use std::thread;
+    ///
+    /// static INIT: Once = Once::new();
+    ///
+    /// assert_eq!(INIT.is_completed(), false);
+    /// let handle = thread::spawn(|| {
+    ///     INIT.call_once(|| panic!());
+    /// });
+    /// assert!(handle.join().is_err());
+    /// assert_eq!(INIT.is_completed(), false);
+    /// ```
+    #[stable(feature = "once_is_completed", since = "1.43.0")]
+    #[inline]
+    pub fn is_completed(&self) -> bool {
+        self.inner.is_completed()
+    }
+
+    /// Blocks the current thread until initialization has completed.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// #![feature(once_wait)]
+    ///
+    /// use std::sync::Once;
+    /// use std::thread;
+    ///
+    /// static READY: Once = Once::new();
+    ///
+    /// let thread = thread::spawn(|| {
+    ///     READY.wait();
+    ///     println!("everything is ready");
+    /// });
+    ///
+    /// READY.call_once(|| println!("performing setup"));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// If this [`Once`] has been poisoned because an initialization closure has
+    /// panicked, this method will also panic. Use [`wait_force`](Self::wait_force)
+    /// if this behavior is not desired.
+    #[unstable(feature = "once_wait", issue = "127527")]
+    pub fn wait(&self) {
+        if !self.inner.is_completed() {
+            self.inner.wait(false);
+        }
+    }
+
+    /// Blocks the current thread until initialization has completed, ignoring
+    /// poisoning.
+    #[unstable(feature = "once_wait", issue = "127527")]
+    pub fn wait_force(&self) {
+        if !self.inner.is_completed() {
+            self.inner.wait(true);
+        }
+    }
+
+    /// Returns the current state of the `Once` instance.
+    ///
+    /// Since this takes a mutable reference, no initialization can currently
+    /// be running, so the state must be either "incomplete", "poisoned" or
+    /// "complete".
+    #[inline]
+    pub(crate) fn state(&mut self) -> ExclusiveState {
+        self.inner.state()
+    }
+
+    /// Sets current state of the `Once` instance.
+    ///
+    /// Since this takes a mutable reference, no initialization can currently
+    /// be running, so the state must be either "incomplete", "poisoned" or
+    /// "complete".
+    #[inline]
+    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
+        self.inner.set_state(new_state);
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl fmt::Debug for Once {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Once").finish_non_exhaustive()
+    }
+}
+
+impl OnceState {
+    /// Returns `true` if the associated [`Once`] was poisoned prior to the
+    /// invocation of the closure passed to [`Once::call_once_force()`].
+    ///
+    /// # Examples
+    ///
+    /// A poisoned [`Once`]:
+    ///
+    /// ```
+    /// use std::sync::Once;
+    /// use std::thread;
+    ///
+    /// static INIT: Once = Once::new();
+    ///
+    /// // poison the once
+    /// let handle = thread::spawn(|| {
+    ///     INIT.call_once(|| panic!());
+    /// });
+    /// assert!(handle.join().is_err());
+    ///
+    /// INIT.call_once_force(|state| {
+    ///     assert!(state.is_poisoned());
+    /// });
+    /// ```
+    ///
+    /// An unpoisoned [`Once`]:
+    ///
+    /// ```
+    /// use std::sync::Once;
+    ///
+    /// static INIT: Once = Once::new();
+    ///
+    /// INIT.call_once_force(|state| {
+    ///     assert!(!state.is_poisoned());
+    /// });
+    #[stable(feature = "once_poison", since = "1.51.0")]
+    #[inline]
+    pub fn is_poisoned(&self) -> bool {
+        self.inner.is_poisoned()
+    }
+
+    /// Poison the associated [`Once`] without explicitly panicking.
+    // NOTE: This is currently only exposed for `OnceLock`.
+    #[inline]
+    pub(crate) fn poison(&self) {
+        self.inner.poison();
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl fmt::Debug for OnceState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OnceState").field("poisoned", &self.is_poisoned()).finish()
+    }
+}
diff --git a/library/std/src/sync/poison/once/tests.rs b/library/std/src/sync/poison/once/tests.rs
new file mode 100644
index 00000000000..ce96468aeb6
--- /dev/null
+++ b/library/std/src/sync/poison/once/tests.rs
@@ -0,0 +1,162 @@
+use super::Once;
+use crate::sync::atomic::AtomicBool;
+use crate::sync::atomic::Ordering::Relaxed;
+use crate::sync::mpsc::channel;
+use crate::time::Duration;
+use crate::{panic, thread};
+
+#[test]
+fn smoke_once() {
+    static O: Once = Once::new();
+    let mut a = 0;
+    O.call_once(|| a += 1);
+    assert_eq!(a, 1);
+    O.call_once(|| a += 1);
+    assert_eq!(a, 1);
+}
+
+#[test]
+fn stampede_once() {
+    static O: Once = Once::new();
+    static mut RUN: bool = false;
+
+    let (tx, rx) = channel();
+    for _ in 0..10 {
+        let tx = tx.clone();
+        thread::spawn(move || {
+            for _ in 0..4 {
+                thread::yield_now()
+            }
+            unsafe {
+                O.call_once(|| {
+                    assert!(!RUN);
+                    RUN = true;
+                });
+                assert!(RUN);
+            }
+            tx.send(()).unwrap();
+        });
+    }
+
+    unsafe {
+        O.call_once(|| {
+            assert!(!RUN);
+            RUN = true;
+        });
+        assert!(RUN);
+    }
+
+    for _ in 0..10 {
+        rx.recv().unwrap();
+    }
+}
+
+#[test]
+fn poison_bad() {
+    static O: Once = Once::new();
+
+    // poison the once
+    let t = panic::catch_unwind(|| {
+        O.call_once(|| panic!());
+    });
+    assert!(t.is_err());
+
+    // poisoning propagates
+    let t = panic::catch_unwind(|| {
+        O.call_once(|| {});
+    });
+    assert!(t.is_err());
+
+    // we can subvert poisoning, however
+    let mut called = false;
+    O.call_once_force(|p| {
+        called = true;
+        assert!(p.is_poisoned())
+    });
+    assert!(called);
+
+    // once any success happens, we stop propagating the poison
+    O.call_once(|| {});
+}
+
+#[test]
+fn wait_for_force_to_finish() {
+    static O: Once = Once::new();
+
+    // poison the once
+    let t = panic::catch_unwind(|| {
+        O.call_once(|| panic!());
+    });
+    assert!(t.is_err());
+
+    // make sure someone's waiting inside the once via a force
+    let (tx1, rx1) = channel();
+    let (tx2, rx2) = channel();
+    let t1 = thread::spawn(move || {
+        O.call_once_force(|p| {
+            assert!(p.is_poisoned());
+            tx1.send(()).unwrap();
+            rx2.recv().unwrap();
+        });
+    });
+
+    rx1.recv().unwrap();
+
+    // put another waiter on the once
+    let t2 = thread::spawn(|| {
+        let mut called = false;
+        O.call_once(|| {
+            called = true;
+        });
+        assert!(!called);
+    });
+
+    tx2.send(()).unwrap();
+
+    assert!(t1.join().is_ok());
+    assert!(t2.join().is_ok());
+}
+
+#[test]
+fn wait() {
+    for _ in 0..50 {
+        let val = AtomicBool::new(false);
+        let once = Once::new();
+
+        thread::scope(|s| {
+            for _ in 0..4 {
+                s.spawn(|| {
+                    once.wait();
+                    assert!(val.load(Relaxed));
+                });
+            }
+
+            once.call_once(|| val.store(true, Relaxed));
+        });
+    }
+}
+
+#[test]
+fn wait_on_poisoned() {
+    let once = Once::new();
+
+    panic::catch_unwind(|| once.call_once(|| panic!())).unwrap_err();
+    panic::catch_unwind(|| once.wait()).unwrap_err();
+}
+
+#[test]
+fn wait_force_on_poisoned() {
+    let once = Once::new();
+
+    thread::scope(|s| {
+        panic::catch_unwind(|| once.call_once(|| panic!())).unwrap_err();
+
+        s.spawn(|| {
+            thread::sleep(Duration::from_millis(100));
+
+            once.call_once_force(|_| {});
+        });
+
+        once.wait_force();
+    })
+}
diff --git a/library/std/src/sync/poison/rwlock.rs b/library/std/src/sync/poison/rwlock.rs
new file mode 100644
index 00000000000..1519baf99a8
--- /dev/null
+++ b/library/std/src/sync/poison/rwlock.rs
@@ -0,0 +1,1205 @@
+#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
+mod tests;
+
+use crate::cell::UnsafeCell;
+use crate::fmt;
+use crate::marker::PhantomData;
+use crate::mem::{self, ManuallyDrop, forget};
+use crate::ops::{Deref, DerefMut};
+use crate::ptr::NonNull;
+use crate::sync::{LockResult, PoisonError, TryLockError, TryLockResult, poison};
+use crate::sys::sync as sys;
+
+/// A reader-writer lock
+///
+/// This type of lock allows a number of readers or at most one writer at any
+/// point in time. The write portion of this lock typically allows modification
+/// of the underlying data (exclusive access) and the read portion of this lock
+/// typically allows for read-only access (shared access).
+///
+/// In comparison, a [`Mutex`] does not distinguish between readers or writers
+/// that acquire the lock, therefore blocking any threads waiting for the lock to
+/// become available. An `RwLock` will allow any number of readers to acquire the
+/// lock as long as a writer is not holding the lock.
+///
+/// The priority policy of the lock is dependent on the underlying operating
+/// system's implementation, and this type does not guarantee that any
+/// particular policy will be used. In particular, a writer which is waiting to
+/// acquire the lock in `write` might or might not block concurrent calls to
+/// `read`, e.g.:
+///
+/// <details><summary>Potential deadlock example</summary>
+///
+/// ```text
+/// // Thread 1              |  // Thread 2
+/// let _rg1 = lock.read();  |
+///                          |  // will block
+///                          |  let _wg = lock.write();
+/// // may deadlock          |
+/// let _rg2 = lock.read();  |
+/// ```
+///
+/// </details>
+///
+/// The type parameter `T` represents the data that this lock protects. It is
+/// required that `T` satisfies [`Send`] to be shared across threads and
+/// [`Sync`] to allow concurrent access through readers. The RAII guards
+/// returned from the locking methods implement [`Deref`] (and [`DerefMut`]
+/// for the `write` methods) to allow access to the content of the lock.
+///
+/// # Poisoning
+///
+/// An `RwLock`, like [`Mutex`], will become poisoned on a panic. Note, however,
+/// that an `RwLock` may only be poisoned if a panic occurs while it is locked
+/// exclusively (write mode). If a panic occurs in any reader, then the lock
+/// will not be poisoned.
+///
+/// # Examples
+///
+/// ```
+/// use std::sync::RwLock;
+///
+/// let lock = RwLock::new(5);
+///
+/// // many reader locks can be held at once
+/// {
+///     let r1 = lock.read().unwrap();
+///     let r2 = lock.read().unwrap();
+///     assert_eq!(*r1, 5);
+///     assert_eq!(*r2, 5);
+/// } // read locks are dropped at this point
+///
+/// // only one write lock may be held, however
+/// {
+///     let mut w = lock.write().unwrap();
+///     *w += 1;
+///     assert_eq!(*w, 6);
+/// } // write lock is dropped here
+/// ```
+///
+/// [`Mutex`]: super::Mutex
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "RwLock")]
+pub struct RwLock<T: ?Sized> {
+    inner: sys::RwLock,
+    poison: poison::Flag,
+    data: UnsafeCell<T>,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+unsafe impl<T: ?Sized + Send> Send for RwLock<T> {}
+#[stable(feature = "rust1", since = "1.0.0")]
+unsafe impl<T: ?Sized + Send + Sync> Sync for RwLock<T> {}
+
+/// RAII structure used to release the shared read access of a lock when
+/// dropped.
+///
+/// This structure is created by the [`read`] and [`try_read`] methods on
+/// [`RwLock`].
+///
+/// [`read`]: RwLock::read
+/// [`try_read`]: RwLock::try_read
+#[must_use = "if unused the RwLock will immediately unlock"]
+#[must_not_suspend = "holding a RwLockReadGuard across suspend \
+                      points can cause deadlocks, delays, \
+                      and cause Futures to not implement `Send`"]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[clippy::has_significant_drop]
+#[cfg_attr(not(test), rustc_diagnostic_item = "RwLockReadGuard")]
+pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
+    // NB: we use a pointer instead of `&'a T` to avoid `noalias` violations, because a
+    // `RwLockReadGuard` argument doesn't hold immutability for its whole scope, only until it drops.
+    // `NonNull` is also covariant over `T`, just like we would have with `&T`. `NonNull`
+    // is preferable over `const* T` to allow for niche optimization.
+    data: NonNull<T>,
+    inner_lock: &'a sys::RwLock,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> !Send for RwLockReadGuard<'_, T> {}
+
+#[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
+unsafe impl<T: ?Sized + Sync> Sync for RwLockReadGuard<'_, T> {}
+
+/// RAII structure used to release the exclusive write access of a lock when
+/// dropped.
+///
+/// This structure is created by the [`write`] and [`try_write`] methods
+/// on [`RwLock`].
+///
+/// [`write`]: RwLock::write
+/// [`try_write`]: RwLock::try_write
+#[must_use = "if unused the RwLock will immediately unlock"]
+#[must_not_suspend = "holding a RwLockWriteGuard across suspend \
+                      points can cause deadlocks, delays, \
+                      and cause Future's to not implement `Send`"]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[clippy::has_significant_drop]
+#[cfg_attr(not(test), rustc_diagnostic_item = "RwLockWriteGuard")]
+pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
+    lock: &'a RwLock<T>,
+    poison: poison::Guard,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> !Send for RwLockWriteGuard<'_, T> {}
+
+#[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
+unsafe impl<T: ?Sized + Sync> Sync for RwLockWriteGuard<'_, T> {}
+
+/// RAII structure used to release the shared read access of a lock when
+/// dropped, which can point to a subfield of the protected data.
+///
+/// This structure is created by the [`map`] and [`try_map`] methods
+/// on [`RwLockReadGuard`].
+///
+/// [`map`]: RwLockReadGuard::map
+/// [`try_map`]: RwLockReadGuard::try_map
+#[must_use = "if unused the RwLock will immediately unlock"]
+#[must_not_suspend = "holding a MappedRwLockReadGuard across suspend \
+                      points can cause deadlocks, delays, \
+                      and cause Futures to not implement `Send`"]
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+#[clippy::has_significant_drop]
+pub struct MappedRwLockReadGuard<'a, T: ?Sized + 'a> {
+    // NB: we use a pointer instead of `&'a T` to avoid `noalias` violations, because a
+    // `MappedRwLockReadGuard` argument doesn't hold immutability for its whole scope, only until it drops.
+    // `NonNull` is also covariant over `T`, just like we would have with `&T`. `NonNull`
+    // is preferable over `const* T` to allow for niche optimization.
+    data: NonNull<T>,
+    inner_lock: &'a sys::RwLock,
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> !Send for MappedRwLockReadGuard<'_, T> {}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+unsafe impl<T: ?Sized + Sync> Sync for MappedRwLockReadGuard<'_, T> {}
+
+/// RAII structure used to release the exclusive write access of a lock when
+/// dropped, which can point to a subfield of the protected data.
+///
+/// This structure is created by the [`map`] and [`try_map`] methods
+/// on [`RwLockWriteGuard`].
+///
+/// [`map`]: RwLockWriteGuard::map
+/// [`try_map`]: RwLockWriteGuard::try_map
+#[must_use = "if unused the RwLock will immediately unlock"]
+#[must_not_suspend = "holding a MappedRwLockWriteGuard across suspend \
+                      points can cause deadlocks, delays, \
+                      and cause Future's to not implement `Send`"]
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+#[clippy::has_significant_drop]
+pub struct MappedRwLockWriteGuard<'a, T: ?Sized + 'a> {
+    // NB: we use a pointer instead of `&'a mut T` to avoid `noalias` violations, because a
+    // `MappedRwLockWriteGuard` argument doesn't hold uniqueness for its whole scope, only until it drops.
+    // `NonNull` is covariant over `T`, so we add a `PhantomData<&'a mut T>` field
+    // below for the correct variance over `T` (invariance).
+    data: NonNull<T>,
+    inner_lock: &'a sys::RwLock,
+    poison_flag: &'a poison::Flag,
+    poison: poison::Guard,
+    _variance: PhantomData<&'a mut T>,
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> !Send for MappedRwLockWriteGuard<'_, T> {}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+unsafe impl<T: ?Sized + Sync> Sync for MappedRwLockWriteGuard<'_, T> {}
+
+impl<T> RwLock<T> {
+    /// Creates a new instance of an `RwLock<T>` which is unlocked.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::RwLock;
+    ///
+    /// let lock = RwLock::new(5);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
+    #[inline]
+    pub const fn new(t: T) -> RwLock<T> {
+        RwLock { inner: sys::RwLock::new(), poison: poison::Flag::new(), data: UnsafeCell::new(t) }
+    }
+
+    /// Returns the contained value by cloning it.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the `RwLock` is poisoned. An
+    /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
+    /// lock.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::RwLock;
+    ///
+    /// let mut lock = RwLock::new(7);
+    ///
+    /// assert_eq!(lock.get_cloned().unwrap(), 7);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn get_cloned(&self) -> Result<T, PoisonError<()>>
+    where
+        T: Clone,
+    {
+        match self.read() {
+            Ok(guard) => Ok((*guard).clone()),
+            Err(_) => Err(PoisonError::new(())),
+        }
+    }
+
+    /// Sets the contained value.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error containing the provided `value` if
+    /// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer
+    /// panics while holding an exclusive lock.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::RwLock;
+    ///
+    /// let mut lock = RwLock::new(7);
+    ///
+    /// assert_eq!(lock.get_cloned().unwrap(), 7);
+    /// lock.set(11).unwrap();
+    /// assert_eq!(lock.get_cloned().unwrap(), 11);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn set(&self, value: T) -> Result<(), PoisonError<T>> {
+        if mem::needs_drop::<T>() {
+            // If the contained value has non-trivial destructor, we
+            // call that destructor after the lock being released.
+            self.replace(value).map(drop)
+        } else {
+            match self.write() {
+                Ok(mut guard) => {
+                    *guard = value;
+
+                    Ok(())
+                }
+                Err(_) => Err(PoisonError::new(value)),
+            }
+        }
+    }
+
+    /// Replaces the contained value with `value`, and returns the old contained value.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error containing the provided `value` if
+    /// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer
+    /// panics while holding an exclusive lock.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::RwLock;
+    ///
+    /// let mut lock = RwLock::new(7);
+    ///
+    /// assert_eq!(lock.replace(11).unwrap(), 7);
+    /// assert_eq!(lock.get_cloned().unwrap(), 11);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn replace(&self, value: T) -> LockResult<T> {
+        match self.write() {
+            Ok(mut guard) => Ok(mem::replace(&mut *guard, value)),
+            Err(_) => Err(PoisonError::new(value)),
+        }
+    }
+}
+
+impl<T: ?Sized> RwLock<T> {
+    /// Locks this `RwLock` with shared read access, blocking the current thread
+    /// until it can be acquired.
+    ///
+    /// The calling thread will be blocked until there are no more writers which
+    /// hold the lock. There may be other readers currently inside the lock when
+    /// this method returns. This method does not provide any guarantees with
+    /// respect to the ordering of whether contentious readers or writers will
+    /// acquire the lock first.
+    ///
+    /// Returns an RAII guard which will release this thread's shared access
+    /// once it is dropped.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the `RwLock` is poisoned. An
+    /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
+    /// lock. The failure will occur immediately after the lock has been
+    /// acquired. The acquired lock guard will be contained in the returned
+    /// error.
+    ///
+    /// # Panics
+    ///
+    /// This function might panic when called if the lock is already held by the current thread.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, RwLock};
+    /// use std::thread;
+    ///
+    /// let lock = Arc::new(RwLock::new(1));
+    /// let c_lock = Arc::clone(&lock);
+    ///
+    /// let n = lock.read().unwrap();
+    /// assert_eq!(*n, 1);
+    ///
+    /// thread::spawn(move || {
+    ///     let r = c_lock.read();
+    ///     assert!(r.is_ok());
+    /// }).join().unwrap();
+    /// ```
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, T>> {
+        unsafe {
+            self.inner.read();
+            RwLockReadGuard::new(self)
+        }
+    }
+
+    /// Attempts to acquire this `RwLock` with shared read access.
+    ///
+    /// If the access could not be granted at this time, then `Err` is returned.
+    /// Otherwise, an RAII guard is returned which will release the shared access
+    /// when it is dropped.
+    ///
+    /// This function does not block.
+    ///
+    /// This function does not provide any guarantees with respect to the ordering
+    /// of whether contentious readers or writers will acquire the lock first.
+    ///
+    /// # Errors
+    ///
+    /// This function will return the [`Poisoned`] error if the `RwLock` is
+    /// poisoned. An `RwLock` is poisoned whenever a writer panics while holding
+    /// an exclusive lock. `Poisoned` will only be returned if the lock would
+    /// have otherwise been acquired. An acquired lock guard will be contained
+    /// in the returned error.
+    ///
+    /// This function will return the [`WouldBlock`] error if the `RwLock` could
+    /// not be acquired because it was already locked exclusively.
+    ///
+    /// [`Poisoned`]: TryLockError::Poisoned
+    /// [`WouldBlock`]: TryLockError::WouldBlock
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::RwLock;
+    ///
+    /// let lock = RwLock::new(1);
+    ///
+    /// match lock.try_read() {
+    ///     Ok(n) => assert_eq!(*n, 1),
+    ///     Err(_) => unreachable!(),
+    /// };
+    /// ```
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn try_read(&self) -> TryLockResult<RwLockReadGuard<'_, T>> {
+        unsafe {
+            if self.inner.try_read() {
+                Ok(RwLockReadGuard::new(self)?)
+            } else {
+                Err(TryLockError::WouldBlock)
+            }
+        }
+    }
+
+    /// Locks this `RwLock` with exclusive write access, blocking the current
+    /// thread until it can be acquired.
+    ///
+    /// This function will not return while other writers or other readers
+    /// currently have access to the lock.
+    ///
+    /// Returns an RAII guard which will drop the write access of this `RwLock`
+    /// when dropped.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the `RwLock` is poisoned. An
+    /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
+    /// lock. An error will be returned when the lock is acquired. The acquired
+    /// lock guard will be contained in the returned error.
+    ///
+    /// # Panics
+    ///
+    /// This function might panic when called if the lock is already held by the current thread.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::RwLock;
+    ///
+    /// let lock = RwLock::new(1);
+    ///
+    /// let mut n = lock.write().unwrap();
+    /// *n = 2;
+    ///
+    /// assert!(lock.try_read().is_err());
+    /// ```
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, T>> {
+        unsafe {
+            self.inner.write();
+            RwLockWriteGuard::new(self)
+        }
+    }
+
+    /// Attempts to lock this `RwLock` with exclusive write access.
+    ///
+    /// If the lock could not be acquired at this time, then `Err` is returned.
+    /// Otherwise, an RAII guard is returned which will release the lock when
+    /// it is dropped.
+    ///
+    /// This function does not block.
+    ///
+    /// This function does not provide any guarantees with respect to the ordering
+    /// of whether contentious readers or writers will acquire the lock first.
+    ///
+    /// # Errors
+    ///
+    /// This function will return the [`Poisoned`] error if the `RwLock` is
+    /// poisoned. An `RwLock` is poisoned whenever a writer panics while holding
+    /// an exclusive lock. `Poisoned` will only be returned if the lock would
+    /// have otherwise been acquired. An acquired lock guard will be contained
+    /// in the returned error.
+    ///
+    /// This function will return the [`WouldBlock`] error if the `RwLock` could
+    /// not be acquired because it was already locked exclusively.
+    ///
+    /// [`Poisoned`]: TryLockError::Poisoned
+    /// [`WouldBlock`]: TryLockError::WouldBlock
+    ///
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::RwLock;
+    ///
+    /// let lock = RwLock::new(1);
+    ///
+    /// let n = lock.read().unwrap();
+    /// assert_eq!(*n, 1);
+    ///
+    /// assert!(lock.try_write().is_err());
+    /// ```
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn try_write(&self) -> TryLockResult<RwLockWriteGuard<'_, T>> {
+        unsafe {
+            if self.inner.try_write() {
+                Ok(RwLockWriteGuard::new(self)?)
+            } else {
+                Err(TryLockError::WouldBlock)
+            }
+        }
+    }
+
+    /// Determines whether the lock is poisoned.
+    ///
+    /// If another thread is active, the lock can still become poisoned at any
+    /// time. You should not trust a `false` value for program correctness
+    /// without additional synchronization.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, RwLock};
+    /// use std::thread;
+    ///
+    /// let lock = Arc::new(RwLock::new(0));
+    /// let c_lock = Arc::clone(&lock);
+    ///
+    /// let _ = thread::spawn(move || {
+    ///     let _lock = c_lock.write().unwrap();
+    ///     panic!(); // the lock gets poisoned
+    /// }).join();
+    /// assert_eq!(lock.is_poisoned(), true);
+    /// ```
+    #[inline]
+    #[stable(feature = "sync_poison", since = "1.2.0")]
+    pub fn is_poisoned(&self) -> bool {
+        self.poison.get()
+    }
+
+    /// Clear the poisoned state from a lock.
+    ///
+    /// If the lock is poisoned, it will remain poisoned until this function is called. This allows
+    /// recovering from a poisoned state and marking that it has recovered. For example, if the
+    /// value is overwritten by a known-good value, then the lock can be marked as un-poisoned. Or
+    /// possibly, the value could be inspected to determine if it is in a consistent state, and if
+    /// so the poison is removed.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::{Arc, RwLock};
+    /// use std::thread;
+    ///
+    /// let lock = Arc::new(RwLock::new(0));
+    /// let c_lock = Arc::clone(&lock);
+    ///
+    /// let _ = thread::spawn(move || {
+    ///     let _lock = c_lock.write().unwrap();
+    ///     panic!(); // the lock gets poisoned
+    /// }).join();
+    ///
+    /// assert_eq!(lock.is_poisoned(), true);
+    /// let guard = lock.write().unwrap_or_else(|mut e| {
+    ///     **e.get_mut() = 1;
+    ///     lock.clear_poison();
+    ///     e.into_inner()
+    /// });
+    /// assert_eq!(lock.is_poisoned(), false);
+    /// assert_eq!(*guard, 1);
+    /// ```
+    #[inline]
+    #[stable(feature = "mutex_unpoison", since = "1.77.0")]
+    pub fn clear_poison(&self) {
+        self.poison.clear();
+    }
+
+    /// Consumes this `RwLock`, returning the underlying data.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error containing the underlying data if
+    /// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer
+    /// panics while holding an exclusive lock. An error will only be returned
+    /// if the lock would have otherwise been acquired.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::RwLock;
+    ///
+    /// let lock = RwLock::new(String::new());
+    /// {
+    ///     let mut s = lock.write().unwrap();
+    ///     *s = "modified".to_owned();
+    /// }
+    /// assert_eq!(lock.into_inner().unwrap(), "modified");
+    /// ```
+    #[stable(feature = "rwlock_into_inner", since = "1.6.0")]
+    pub fn into_inner(self) -> LockResult<T>
+    where
+        T: Sized,
+    {
+        let data = self.data.into_inner();
+        poison::map_result(self.poison.borrow(), |()| data)
+    }
+
+    /// Returns a mutable reference to the underlying data.
+    ///
+    /// Since this call borrows the `RwLock` mutably, no actual locking needs to
+    /// take place -- the mutable borrow statically guarantees no locks exist.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error containing a mutable reference to
+    /// the underlying data if the `RwLock` is poisoned. An `RwLock` is
+    /// poisoned whenever a writer panics while holding an exclusive lock.
+    /// An error will only be returned if the lock would have otherwise been
+    /// acquired.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::RwLock;
+    ///
+    /// let mut lock = RwLock::new(0);
+    /// *lock.get_mut().unwrap() = 10;
+    /// assert_eq!(*lock.read().unwrap(), 10);
+    /// ```
+    #[stable(feature = "rwlock_get_mut", since = "1.6.0")]
+    pub fn get_mut(&mut self) -> LockResult<&mut T> {
+        let data = self.data.get_mut();
+        poison::map_result(self.poison.borrow(), |()| data)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLock<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut d = f.debug_struct("RwLock");
+        match self.try_read() {
+            Ok(guard) => {
+                d.field("data", &&*guard);
+            }
+            Err(TryLockError::Poisoned(err)) => {
+                d.field("data", &&**err.get_ref());
+            }
+            Err(TryLockError::WouldBlock) => {
+                d.field("data", &format_args!("<locked>"));
+            }
+        }
+        d.field("poisoned", &self.poison.get());
+        d.finish_non_exhaustive()
+    }
+}
+
+#[stable(feature = "rw_lock_default", since = "1.10.0")]
+impl<T: Default> Default for RwLock<T> {
+    /// Creates a new `RwLock<T>`, with the `Default` value for T.
+    fn default() -> RwLock<T> {
+        RwLock::new(Default::default())
+    }
+}
+
+#[stable(feature = "rw_lock_from", since = "1.24.0")]
+impl<T> From<T> for RwLock<T> {
+    /// Creates a new instance of an `RwLock<T>` which is unlocked.
+    /// This is equivalent to [`RwLock::new`].
+    fn from(t: T) -> Self {
+        RwLock::new(t)
+    }
+}
+
+impl<'rwlock, T: ?Sized> RwLockReadGuard<'rwlock, T> {
+    /// Creates a new instance of `RwLockReadGuard<T>` from a `RwLock<T>`.
+    ///
+    /// # Safety
+    ///
+    /// This function is safe if and only if the same thread has successfully and safely called
+    /// `lock.inner.read()`, `lock.inner.try_read()`, or `lock.inner.downgrade()` before
+    /// instantiating this object.
+    unsafe fn new(lock: &'rwlock RwLock<T>) -> LockResult<RwLockReadGuard<'rwlock, T>> {
+        poison::map_result(lock.poison.borrow(), |()| RwLockReadGuard {
+            data: unsafe { NonNull::new_unchecked(lock.data.get()) },
+            inner_lock: &lock.inner,
+        })
+    }
+}
+
+impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> {
+    /// Creates a new instance of `RwLockWriteGuard<T>` from a `RwLock<T>`.
+    // SAFETY: if and only if `lock.inner.write()` (or `lock.inner.try_write()`) has been
+    // successfully called from the same thread before instantiating this object.
+    unsafe fn new(lock: &'rwlock RwLock<T>) -> LockResult<RwLockWriteGuard<'rwlock, T>> {
+        poison::map_result(lock.poison.guard(), |guard| RwLockWriteGuard { lock, poison: guard })
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLockReadGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[stable(feature = "std_guard_impls", since = "1.20.0")]
+impl<T: ?Sized + fmt::Display> fmt::Display for RwLockReadGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLockWriteGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[stable(feature = "std_guard_impls", since = "1.20.0")]
+impl<T: ?Sized + fmt::Display> fmt::Display for RwLockWriteGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for MappedRwLockReadGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized + fmt::Display> fmt::Display for MappedRwLockReadGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized + fmt::Debug> fmt::Debug for MappedRwLockWriteGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized + fmt::Display> fmt::Display for MappedRwLockWriteGuard<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when created.
+        unsafe { self.data.as_ref() }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
+        unsafe { &*self.lock.data.get() }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
+        unsafe { &mut *self.lock.data.get() }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> Deref for MappedRwLockReadGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        unsafe { self.data.as_ref() }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> Deref for MappedRwLockWriteGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        unsafe { self.data.as_ref() }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> DerefMut for MappedRwLockWriteGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        unsafe { self.data.as_mut() }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Drop for RwLockReadGuard<'_, T> {
+    fn drop(&mut self) {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when created.
+        unsafe {
+            self.inner_lock.read_unlock();
+        }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Drop for RwLockWriteGuard<'_, T> {
+    fn drop(&mut self) {
+        self.lock.poison.done(&self.poison);
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
+        unsafe {
+            self.lock.inner.write_unlock();
+        }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> Drop for MappedRwLockReadGuard<'_, T> {
+    fn drop(&mut self) {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        unsafe {
+            self.inner_lock.read_unlock();
+        }
+    }
+}
+
+#[unstable(feature = "mapped_lock_guards", issue = "117108")]
+impl<T: ?Sized> Drop for MappedRwLockWriteGuard<'_, T> {
+    fn drop(&mut self) {
+        self.poison_flag.done(&self.poison);
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        unsafe {
+            self.inner_lock.write_unlock();
+        }
+    }
+}
+
+impl<'a, T: ?Sized> RwLockReadGuard<'a, T> {
+    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data, e.g.
+    /// an enum variant.
+    ///
+    /// The `RwLock` is already locked for reading, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `RwLockReadGuard::map(...)`. A method would interfere with methods of
+    /// the same name on the contents of the `RwLockReadGuard` used through
+    /// `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn map<U, F>(orig: Self, f: F) -> MappedRwLockReadGuard<'a, U>
+    where
+        F: FnOnce(&T) -> &U,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        let data = NonNull::from(f(unsafe { orig.data.as_ref() }));
+        let orig = ManuallyDrop::new(orig);
+        MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock }
+    }
+
+    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data. The
+    /// original guard is returned as an `Err(...)` if the closure returns
+    /// `None`.
+    ///
+    /// The `RwLock` is already locked for reading, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `RwLockReadGuard::try_map(...)`. A method would interfere with methods
+    /// of the same name on the contents of the `RwLockReadGuard` used through
+    /// `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
+    #[doc(alias = "filter_map")]
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedRwLockReadGuard<'a, U>, Self>
+    where
+        F: FnOnce(&T) -> Option<&U>,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        match f(unsafe { orig.data.as_ref() }) {
+            Some(data) => {
+                let data = NonNull::from(data);
+                let orig = ManuallyDrop::new(orig);
+                Ok(MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock })
+            }
+            None => Err(orig),
+        }
+    }
+}
+
+impl<'a, T: ?Sized> MappedRwLockReadGuard<'a, T> {
+    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data,
+    /// e.g. an enum variant.
+    ///
+    /// The `RwLock` is already locked for reading, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MappedRwLockReadGuard::map(...)`. A method would interfere with
+    /// methods of the same name on the contents of the `MappedRwLockReadGuard`
+    /// used through `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn map<U, F>(orig: Self, f: F) -> MappedRwLockReadGuard<'a, U>
+    where
+        F: FnOnce(&T) -> &U,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        let data = NonNull::from(f(unsafe { orig.data.as_ref() }));
+        let orig = ManuallyDrop::new(orig);
+        MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock }
+    }
+
+    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data.
+    /// The original guard is returned as an `Err(...)` if the closure returns
+    /// `None`.
+    ///
+    /// The `RwLock` is already locked for reading, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MappedRwLockReadGuard::try_map(...)`. A method would interfere with
+    /// methods of the same name on the contents of the `MappedRwLockReadGuard`
+    /// used through `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
+    #[doc(alias = "filter_map")]
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedRwLockReadGuard<'a, U>, Self>
+    where
+        F: FnOnce(&T) -> Option<&U>,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        match f(unsafe { orig.data.as_ref() }) {
+            Some(data) => {
+                let data = NonNull::from(data);
+                let orig = ManuallyDrop::new(orig);
+                Ok(MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock })
+            }
+            None => Err(orig),
+        }
+    }
+}
+
+impl<'a, T: ?Sized> RwLockWriteGuard<'a, T> {
+    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data, e.g.
+    /// an enum variant.
+    ///
+    /// The `RwLock` is already locked for writing, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `RwLockWriteGuard::map(...)`. A method would interfere with methods of
+    /// the same name on the contents of the `RwLockWriteGuard` used through
+    /// `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn map<U, F>(orig: Self, f: F) -> MappedRwLockWriteGuard<'a, U>
+    where
+        F: FnOnce(&mut T) -> &mut U,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        let data = NonNull::from(f(unsafe { &mut *orig.lock.data.get() }));
+        let orig = ManuallyDrop::new(orig);
+        MappedRwLockWriteGuard {
+            data,
+            inner_lock: &orig.lock.inner,
+            poison_flag: &orig.lock.poison,
+            poison: orig.poison.clone(),
+            _variance: PhantomData,
+        }
+    }
+
+    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data. The
+    /// original guard is returned as an `Err(...)` if the closure returns
+    /// `None`.
+    ///
+    /// The `RwLock` is already locked for writing, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `RwLockWriteGuard::try_map(...)`. A method would interfere with methods
+    /// of the same name on the contents of the `RwLockWriteGuard` used through
+    /// `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
+    #[doc(alias = "filter_map")]
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedRwLockWriteGuard<'a, U>, Self>
+    where
+        F: FnOnce(&mut T) -> Option<&mut U>,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        match f(unsafe { &mut *orig.lock.data.get() }) {
+            Some(data) => {
+                let data = NonNull::from(data);
+                let orig = ManuallyDrop::new(orig);
+                Ok(MappedRwLockWriteGuard {
+                    data,
+                    inner_lock: &orig.lock.inner,
+                    poison_flag: &orig.lock.poison,
+                    poison: orig.poison.clone(),
+                    _variance: PhantomData,
+                })
+            }
+            None => Err(orig),
+        }
+    }
+
+    /// Downgrades a write-locked `RwLockWriteGuard` into a read-locked [`RwLockReadGuard`].
+    ///
+    /// This method will atomically change the state of the [`RwLock`] from exclusive mode into
+    /// shared mode. This means that it is impossible for a writing thread to get in between a
+    /// thread calling `downgrade` and the same thread reading whatever it wrote while it had the
+    /// [`RwLock`] in write mode.
+    ///
+    /// Note that since we have the `RwLockWriteGuard`, we know that the [`RwLock`] is already
+    /// locked for writing, so this method cannot fail.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #![feature(rwlock_downgrade)]
+    /// use std::sync::{Arc, RwLock, RwLockWriteGuard};
+    ///
+    /// // The inner value starts as 0.
+    /// let rw = Arc::new(RwLock::new(0));
+    ///
+    /// // Put the lock in write mode.
+    /// let mut main_write_guard = rw.write().unwrap();
+    ///
+    /// let evil = rw.clone();
+    /// let handle = std::thread::spawn(move || {
+    ///     // This will not return until the main thread drops the `main_read_guard`.
+    ///     let mut evil_guard = evil.write().unwrap();
+    ///
+    ///     assert_eq!(*evil_guard, 1);
+    ///     *evil_guard = 2;
+    /// });
+    ///
+    /// // After spawning the writer thread, set the inner value to 1.
+    /// *main_write_guard = 1;
+    ///
+    /// // Atomically downgrade the write guard into a read guard.
+    /// let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);
+    ///
+    /// // Since `downgrade` is atomic, the writer thread cannot have set the inner value to 2.
+    /// assert_eq!(*main_read_guard, 1, "`downgrade` was not atomic");
+    ///
+    /// // Clean up everything now
+    /// drop(main_read_guard);
+    /// handle.join().unwrap();
+    ///
+    /// let final_check = rw.read().unwrap();
+    /// assert_eq!(*final_check, 2);
+    /// ```
+    #[unstable(feature = "rwlock_downgrade", issue = "128203")]
+    pub fn downgrade(s: Self) -> RwLockReadGuard<'a, T> {
+        let lock = s.lock;
+
+        // We don't want to call the destructor since that calls `write_unlock`.
+        forget(s);
+
+        // SAFETY: We take ownership of a write guard, so we must already have the `RwLock` in write
+        // mode, satisfying the `downgrade` contract.
+        unsafe { lock.inner.downgrade() };
+
+        // SAFETY: We have just successfully called `downgrade`, so we fulfill the safety contract.
+        unsafe { RwLockReadGuard::new(lock).unwrap_or_else(PoisonError::into_inner) }
+    }
+}
+
+impl<'a, T: ?Sized> MappedRwLockWriteGuard<'a, T> {
+    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data,
+    /// e.g. an enum variant.
+    ///
+    /// The `RwLock` is already locked for writing, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MappedRwLockWriteGuard::map(...)`. A method would interfere with
+    /// methods of the same name on the contents of the `MappedRwLockWriteGuard`
+    /// used through `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn map<U, F>(mut orig: Self, f: F) -> MappedRwLockWriteGuard<'a, U>
+    where
+        F: FnOnce(&mut T) -> &mut U,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        let data = NonNull::from(f(unsafe { orig.data.as_mut() }));
+        let orig = ManuallyDrop::new(orig);
+        MappedRwLockWriteGuard {
+            data,
+            inner_lock: orig.inner_lock,
+            poison_flag: orig.poison_flag,
+            poison: orig.poison.clone(),
+            _variance: PhantomData,
+        }
+    }
+
+    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data.
+    /// The original guard is returned as an `Err(...)` if the closure returns
+    /// `None`.
+    ///
+    /// The `RwLock` is already locked for writing, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as
+    /// `MappedRwLockWriteGuard::try_map(...)`. A method would interfere with
+    /// methods of the same name on the contents of the `MappedRwLockWriteGuard`
+    /// used through `Deref`.
+    ///
+    /// # Panics
+    ///
+    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
+    #[doc(alias = "filter_map")]
+    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
+    pub fn try_map<U, F>(mut orig: Self, f: F) -> Result<MappedRwLockWriteGuard<'a, U>, Self>
+    where
+        F: FnOnce(&mut T) -> Option<&mut U>,
+        U: ?Sized,
+    {
+        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
+        // was created, and have been upheld throughout `map` and/or `try_map`.
+        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
+        // passed to it. If the closure panics, the guard will be dropped.
+        match f(unsafe { orig.data.as_mut() }) {
+            Some(data) => {
+                let data = NonNull::from(data);
+                let orig = ManuallyDrop::new(orig);
+                Ok(MappedRwLockWriteGuard {
+                    data,
+                    inner_lock: orig.inner_lock,
+                    poison_flag: orig.poison_flag,
+                    poison: orig.poison.clone(),
+                    _variance: PhantomData,
+                })
+            }
+            None => Err(orig),
+        }
+    }
+}
diff --git a/library/std/src/sync/poison/rwlock/tests.rs b/library/std/src/sync/poison/rwlock/tests.rs
new file mode 100644
index 00000000000..057c2f1a5d7
--- /dev/null
+++ b/library/std/src/sync/poison/rwlock/tests.rs
@@ -0,0 +1,729 @@
+use rand::Rng;
+
+use crate::fmt::Debug;
+use crate::ops::FnMut;
+use crate::panic::{self, AssertUnwindSafe};
+use crate::sync::atomic::{AtomicUsize, Ordering};
+use crate::sync::mpsc::channel;
+use crate::sync::{
+    Arc, MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard, RwLockWriteGuard,
+    TryLockError,
+};
+use crate::{hint, mem, thread};
+
+#[derive(Eq, PartialEq, Debug)]
+struct NonCopy(i32);
+
+#[derive(Eq, PartialEq, Debug)]
+struct NonCopyNeedsDrop(i32);
+
+impl Drop for NonCopyNeedsDrop {
+    fn drop(&mut self) {
+        hint::black_box(());
+    }
+}
+
+#[test]
+fn test_needs_drop() {
+    assert!(!mem::needs_drop::<NonCopy>());
+    assert!(mem::needs_drop::<NonCopyNeedsDrop>());
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+struct Cloneable(i32);
+
+#[test]
+fn smoke() {
+    let l = RwLock::new(());
+    drop(l.read().unwrap());
+    drop(l.write().unwrap());
+    drop((l.read().unwrap(), l.read().unwrap()));
+    drop(l.write().unwrap());
+}
+
+#[test]
+// FIXME: On macOS we use a provenance-incorrect implementation and Miri
+// catches that issue with a chance of around 1/1000.
+// See <https://github.com/rust-lang/rust/issues/121950> for details.
+#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+fn frob() {
+    const N: u32 = 10;
+    const M: usize = if cfg!(miri) { 100 } else { 1000 };
+
+    let r = Arc::new(RwLock::new(()));
+
+    let (tx, rx) = channel::<()>();
+    for _ in 0..N {
+        let tx = tx.clone();
+        let r = r.clone();
+        thread::spawn(move || {
+            let mut rng = crate::test_helpers::test_rng();
+            for _ in 0..M {
+                if rng.gen_bool(1.0 / (N as f64)) {
+                    drop(r.write().unwrap());
+                } else {
+                    drop(r.read().unwrap());
+                }
+            }
+            drop(tx);
+        });
+    }
+    drop(tx);
+    let _ = rx.recv();
+}
+
+#[test]
+fn test_rw_arc_poison_wr() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.write().unwrap();
+        panic!();
+    })
+    .join();
+    assert!(arc.read().is_err());
+}
+
+#[test]
+fn test_rw_arc_poison_mapped_w_r() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let lock = arc2.write().unwrap();
+        let _lock = RwLockWriteGuard::map(lock, |val| val);
+        panic!();
+    })
+    .join();
+    assert!(arc.read().is_err());
+}
+
+#[test]
+fn test_rw_arc_poison_ww() {
+    let arc = Arc::new(RwLock::new(1));
+    assert!(!arc.is_poisoned());
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.write().unwrap();
+        panic!();
+    })
+    .join();
+    assert!(arc.write().is_err());
+    assert!(arc.is_poisoned());
+}
+
+#[test]
+fn test_rw_arc_poison_mapped_w_w() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let lock = arc2.write().unwrap();
+        let _lock = RwLockWriteGuard::map(lock, |val| val);
+        panic!();
+    })
+    .join();
+    assert!(arc.write().is_err());
+    assert!(arc.is_poisoned());
+}
+
+#[test]
+fn test_rw_arc_no_poison_rr() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.read().unwrap();
+        panic!();
+    })
+    .join();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 1);
+}
+
+#[test]
+fn test_rw_arc_no_poison_mapped_r_r() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let lock = arc2.read().unwrap();
+        let _lock = RwLockReadGuard::map(lock, |val| val);
+        panic!();
+    })
+    .join();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 1);
+}
+
+#[test]
+fn test_rw_arc_no_poison_rw() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.read().unwrap();
+        panic!()
+    })
+    .join();
+    let lock = arc.write().unwrap();
+    assert_eq!(*lock, 1);
+}
+
+#[test]
+fn test_rw_arc_no_poison_mapped_r_w() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let lock = arc2.read().unwrap();
+        let _lock = RwLockReadGuard::map(lock, |val| val);
+        panic!();
+    })
+    .join();
+    let lock = arc.write().unwrap();
+    assert_eq!(*lock, 1);
+}
+
+#[test]
+fn test_rw_arc() {
+    let arc = Arc::new(RwLock::new(0));
+    let arc2 = arc.clone();
+    let (tx, rx) = channel();
+
+    thread::spawn(move || {
+        let mut lock = arc2.write().unwrap();
+        for _ in 0..10 {
+            let tmp = *lock;
+            *lock = -1;
+            thread::yield_now();
+            *lock = tmp + 1;
+        }
+        tx.send(()).unwrap();
+    });
+
+    // Readers try to catch the writer in the act
+    let mut children = Vec::new();
+    for _ in 0..5 {
+        let arc3 = arc.clone();
+        children.push(thread::spawn(move || {
+            let lock = arc3.read().unwrap();
+            assert!(*lock >= 0);
+        }));
+    }
+
+    // Wait for children to pass their asserts
+    for r in children {
+        assert!(r.join().is_ok());
+    }
+
+    // Wait for writer to finish
+    rx.recv().unwrap();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 10);
+}
+
+#[test]
+fn test_rw_arc_access_in_unwind() {
+    let arc = Arc::new(RwLock::new(1));
+    let arc2 = arc.clone();
+    let _ = thread::spawn(move || -> () {
+        struct Unwinder {
+            i: Arc<RwLock<isize>>,
+        }
+        impl Drop for Unwinder {
+            fn drop(&mut self) {
+                let mut lock = self.i.write().unwrap();
+                *lock += 1;
+            }
+        }
+        let _u = Unwinder { i: arc2 };
+        panic!();
+    })
+    .join();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 2);
+}
+
+#[test]
+fn test_rwlock_unsized() {
+    let rw: &RwLock<[i32]> = &RwLock::new([1, 2, 3]);
+    {
+        let b = &mut *rw.write().unwrap();
+        b[0] = 4;
+        b[2] = 5;
+    }
+    let comp: &[i32] = &[4, 2, 5];
+    assert_eq!(&*rw.read().unwrap(), comp);
+}
+
+#[test]
+fn test_rwlock_try_write() {
+    let lock = RwLock::new(0isize);
+    let read_guard = lock.read().unwrap();
+
+    let write_result = lock.try_write();
+    match write_result {
+        Err(TryLockError::WouldBlock) => (),
+        Ok(_) => assert!(false, "try_write should not succeed while read_guard is in scope"),
+        Err(_) => assert!(false, "unexpected error"),
+    }
+
+    drop(read_guard);
+    let mapped_read_guard = RwLockReadGuard::map(lock.read().unwrap(), |_| &());
+
+    let write_result = lock.try_write();
+    match write_result {
+        Err(TryLockError::WouldBlock) => (),
+        Ok(_) => assert!(false, "try_write should not succeed while mapped_read_guard is in scope"),
+        Err(_) => assert!(false, "unexpected error"),
+    }
+
+    drop(mapped_read_guard);
+}
+
+fn new_poisoned_rwlock<T>(value: T) -> RwLock<T> {
+    let lock = RwLock::new(value);
+
+    let catch_unwind_result = panic::catch_unwind(AssertUnwindSafe(|| {
+        let _guard = lock.write().unwrap();
+
+        panic!("test panic to poison RwLock");
+    }));
+
+    assert!(catch_unwind_result.is_err());
+    assert!(lock.is_poisoned());
+
+    lock
+}
+
+#[test]
+fn test_into_inner() {
+    let m = RwLock::new(NonCopy(10));
+    assert_eq!(m.into_inner().unwrap(), NonCopy(10));
+}
+
+#[test]
+fn test_into_inner_drop() {
+    struct Foo(Arc<AtomicUsize>);
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+    let num_drops = Arc::new(AtomicUsize::new(0));
+    let m = RwLock::new(Foo(num_drops.clone()));
+    assert_eq!(num_drops.load(Ordering::SeqCst), 0);
+    {
+        let _inner = m.into_inner().unwrap();
+        assert_eq!(num_drops.load(Ordering::SeqCst), 0);
+    }
+    assert_eq!(num_drops.load(Ordering::SeqCst), 1);
+}
+
+#[test]
+fn test_into_inner_poison() {
+    let m = new_poisoned_rwlock(NonCopy(10));
+
+    match m.into_inner() {
+        Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
+        Ok(x) => panic!("into_inner of poisoned RwLock is Ok: {x:?}"),
+    }
+}
+
+#[test]
+fn test_get_cloned() {
+    let m = RwLock::new(Cloneable(10));
+
+    assert_eq!(m.get_cloned().unwrap(), Cloneable(10));
+}
+
+#[test]
+fn test_get_cloned_poison() {
+    let m = new_poisoned_rwlock(Cloneable(10));
+
+    match m.get_cloned() {
+        Err(e) => assert_eq!(e.into_inner(), ()),
+        Ok(x) => panic!("get of poisoned RwLock is Ok: {x:?}"),
+    }
+}
+
+#[test]
+fn test_get_mut() {
+    let mut m = RwLock::new(NonCopy(10));
+    *m.get_mut().unwrap() = NonCopy(20);
+    assert_eq!(m.into_inner().unwrap(), NonCopy(20));
+}
+
+#[test]
+fn test_get_mut_poison() {
+    let mut m = new_poisoned_rwlock(NonCopy(10));
+
+    match m.get_mut() {
+        Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
+        Ok(x) => panic!("get_mut of poisoned RwLock is Ok: {x:?}"),
+    }
+}
+
+#[test]
+fn test_set() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = RwLock::new(init());
+
+        assert_eq!(*m.read().unwrap(), init());
+        m.set(value()).unwrap();
+        assert_eq!(*m.read().unwrap(), value());
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_set_poison() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = new_poisoned_rwlock(init());
+
+        match m.set(value()) {
+            Err(e) => {
+                assert_eq!(e.into_inner(), value());
+                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
+            }
+            Ok(x) => panic!("set of poisoned RwLock is Ok: {x:?}"),
+        }
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_replace() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = RwLock::new(init());
+
+        assert_eq!(*m.read().unwrap(), init());
+        assert_eq!(m.replace(value()).unwrap(), init());
+        assert_eq!(*m.read().unwrap(), value());
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_replace_poison() {
+    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+    where
+        T: Debug + Eq,
+    {
+        let m = new_poisoned_rwlock(init());
+
+        match m.replace(value()) {
+            Err(e) => {
+                assert_eq!(e.into_inner(), value());
+                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
+            }
+            Ok(x) => panic!("replace of poisoned RwLock is Ok: {x:?}"),
+        }
+    }
+
+    inner(|| NonCopy(10), || NonCopy(20));
+    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+}
+
+#[test]
+fn test_read_guard_covariance() {
+    fn do_stuff<'a>(_: RwLockReadGuard<'_, &'a i32>, _: &'a i32) {}
+    let j: i32 = 5;
+    let lock = RwLock::new(&j);
+    {
+        let i = 6;
+        do_stuff(lock.read().unwrap(), &i);
+    }
+    drop(lock);
+}
+
+#[test]
+fn test_mapped_read_guard_covariance() {
+    fn do_stuff<'a>(_: MappedRwLockReadGuard<'_, &'a i32>, _: &'a i32) {}
+    let j: i32 = 5;
+    let lock = RwLock::new((&j, &j));
+    {
+        let i = 6;
+        let guard = lock.read().unwrap();
+        let guard = RwLockReadGuard::map(guard, |(val, _val)| val);
+        do_stuff(guard, &i);
+    }
+    drop(lock);
+}
+
+#[test]
+fn test_mapping_mapped_guard() {
+    let arr = [0; 4];
+    let mut lock = RwLock::new(arr);
+    let guard = lock.write().unwrap();
+    let guard = RwLockWriteGuard::map(guard, |arr| &mut arr[..2]);
+    let mut guard = MappedRwLockWriteGuard::map(guard, |slice| &mut slice[1..]);
+    assert_eq!(guard.len(), 1);
+    guard[0] = 42;
+    drop(guard);
+    assert_eq!(*lock.get_mut().unwrap(), [0, 42, 0, 0]);
+
+    let guard = lock.read().unwrap();
+    let guard = RwLockReadGuard::map(guard, |arr| &arr[..2]);
+    let guard = MappedRwLockReadGuard::map(guard, |slice| &slice[1..]);
+    assert_eq!(*guard, [42]);
+    drop(guard);
+    assert_eq!(*lock.get_mut().unwrap(), [0, 42, 0, 0]);
+}
+
+#[test]
+fn panic_while_mapping_read_unlocked_no_poison() {
+    let lock = RwLock::new(());
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.read().unwrap();
+        let _guard = RwLockReadGuard::map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => {}
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a RwLockReadGuard::map closure should release the read lock")
+        }
+        Err(TryLockError::Poisoned(_)) => {
+            panic!("panicking in a RwLockReadGuard::map closure should not poison the RwLock")
+        }
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.read().unwrap();
+        let _guard = RwLockReadGuard::try_map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => {}
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a RwLockReadGuard::try_map closure should release the read lock")
+        }
+        Err(TryLockError::Poisoned(_)) => {
+            panic!("panicking in a RwLockReadGuard::try_map closure should not poison the RwLock")
+        }
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.read().unwrap();
+        let guard = RwLockReadGuard::map::<(), _>(guard, |val| val);
+        let _guard = MappedRwLockReadGuard::map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => {}
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a MappedRwLockReadGuard::map closure should release the read lock")
+        }
+        Err(TryLockError::Poisoned(_)) => {
+            panic!("panicking in a MappedRwLockReadGuard::map closure should not poison the RwLock")
+        }
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.read().unwrap();
+        let guard = RwLockReadGuard::map::<(), _>(guard, |val| val);
+        let _guard = MappedRwLockReadGuard::try_map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => {}
+        Err(TryLockError::WouldBlock) => panic!(
+            "panicking in a MappedRwLockReadGuard::try_map closure should release the read lock"
+        ),
+        Err(TryLockError::Poisoned(_)) => panic!(
+            "panicking in a MappedRwLockReadGuard::try_map closure should not poison the RwLock"
+        ),
+    }
+
+    drop(lock);
+}
+
+#[test]
+fn panic_while_mapping_write_unlocked_poison() {
+    let lock = RwLock::new(());
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.write().unwrap();
+        let _guard = RwLockWriteGuard::map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => panic!("panicking in a RwLockWriteGuard::map closure should poison the RwLock"),
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a RwLockWriteGuard::map closure should release the write lock")
+        }
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.write().unwrap();
+        let _guard = RwLockWriteGuard::try_map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => {
+            panic!("panicking in a RwLockWriteGuard::try_map closure should poison the RwLock")
+        }
+        Err(TryLockError::WouldBlock) => {
+            panic!("panicking in a RwLockWriteGuard::try_map closure should release the write lock")
+        }
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.write().unwrap();
+        let guard = RwLockWriteGuard::map::<(), _>(guard, |val| val);
+        let _guard = MappedRwLockWriteGuard::map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => {
+            panic!("panicking in a MappedRwLockWriteGuard::map closure should poison the RwLock")
+        }
+        Err(TryLockError::WouldBlock) => panic!(
+            "panicking in a MappedRwLockWriteGuard::map closure should release the write lock"
+        ),
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    let _ = panic::catch_unwind(|| {
+        let guard = lock.write().unwrap();
+        let guard = RwLockWriteGuard::map::<(), _>(guard, |val| val);
+        let _guard = MappedRwLockWriteGuard::try_map::<(), _>(guard, |_| panic!());
+    });
+
+    match lock.try_write() {
+        Ok(_) => panic!(
+            "panicking in a MappedRwLockWriteGuard::try_map closure should poison the RwLock"
+        ),
+        Err(TryLockError::WouldBlock) => panic!(
+            "panicking in a MappedRwLockWriteGuard::try_map closure should release the write lock"
+        ),
+        Err(TryLockError::Poisoned(_)) => {}
+    }
+
+    drop(lock);
+}
+
+#[test]
+fn test_downgrade_basic() {
+    let r = RwLock::new(());
+
+    let write_guard = r.write().unwrap();
+    let _read_guard = RwLockWriteGuard::downgrade(write_guard);
+}
+
+#[test]
+// FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
+// See <https://github.com/rust-lang/rust/issues/121950> for details.
+#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+fn test_downgrade_observe() {
+    // Taken from the test `test_rwlock_downgrade` from:
+    // https://github.com/Amanieu/parking_lot/blob/master/src/rwlock.rs
+
+    const W: usize = 20;
+    const N: usize = if cfg!(miri) { 40 } else { 100 };
+
+    // This test spawns `W` writer threads, where each will increment a counter `N` times, ensuring
+    // that the value they wrote has not changed after downgrading.
+
+    let rw = Arc::new(RwLock::new(0));
+
+    // Spawn the writers that will do `W * N` operations and checks.
+    let handles: Vec<_> = (0..W)
+        .map(|_| {
+            let rw = rw.clone();
+            thread::spawn(move || {
+                for _ in 0..N {
+                    // Increment the counter.
+                    let mut write_guard = rw.write().unwrap();
+                    *write_guard += 1;
+                    let cur_val = *write_guard;
+
+                    // Downgrade the lock to read mode, where the value protected cannot be modified.
+                    let read_guard = RwLockWriteGuard::downgrade(write_guard);
+                    assert_eq!(cur_val, *read_guard);
+                }
+            })
+        })
+        .collect();
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    assert_eq!(*rw.read().unwrap(), W * N);
+}
+
+#[test]
+// FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
+// See <https://github.com/rust-lang/rust/issues/121950> for details.
+#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+fn test_downgrade_atomic() {
+    const NEW_VALUE: i32 = -1;
+
+    // This test checks that `downgrade` is atomic, meaning as soon as a write lock has been
+    // downgraded, the lock must be in read mode and no other threads can take the write lock to
+    // modify the protected value.
+
+    // `W` is the number of evil writer threads.
+    const W: usize = 20;
+    let rwlock = Arc::new(RwLock::new(0));
+
+    // Spawns many evil writer threads that will try and write to the locked value before the
+    // initial writer (who has the exclusive lock) can read after it downgrades.
+    // If the `RwLock` behaves correctly, then the initial writer should read the value it wrote
+    // itself as no other thread should be able to mutate the protected value.
+
+    // Put the lock in write mode, causing all future threads trying to access this go to sleep.
+    let mut main_write_guard = rwlock.write().unwrap();
+
+    // Spawn all of the evil writer threads. They will each increment the protected value by 1.
+    let handles: Vec<_> = (0..W)
+        .map(|_| {
+            let rwlock = rwlock.clone();
+            thread::spawn(move || {
+                // Will go to sleep since the main thread initially has the write lock.
+                let mut evil_guard = rwlock.write().unwrap();
+                *evil_guard += 1;
+            })
+        })
+        .collect();
+
+    // Wait for a good amount of time so that evil threads go to sleep.
+    // Note: this is not strictly necessary...
+    let eternity = crate::time::Duration::from_millis(42);
+    thread::sleep(eternity);
+
+    // Once everyone is asleep, set the value to `NEW_VALUE`.
+    *main_write_guard = NEW_VALUE;
+
+    // Atomically downgrade the write guard into a read guard.
+    let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);
+
+    // If the above is not atomic, then it would be possible for an evil thread to get in front of
+    // this read and change the value to be non-negative.
+    assert_eq!(*main_read_guard, NEW_VALUE, "`downgrade` was not atomic");
+
+    // Drop the main read guard and allow the evil writer threads to start incrementing.
+    drop(main_read_guard);
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    let final_check = rwlock.read().unwrap();
+    assert_eq!(*final_check, W as i32 + NEW_VALUE);
+}
diff --git a/library/std/src/sync/rwlock.rs b/library/std/src/sync/rwlock.rs
deleted file mode 100644
index 1519baf99a8..00000000000
--- a/library/std/src/sync/rwlock.rs
+++ /dev/null
@@ -1,1205 +0,0 @@
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
-use crate::cell::UnsafeCell;
-use crate::fmt;
-use crate::marker::PhantomData;
-use crate::mem::{self, ManuallyDrop, forget};
-use crate::ops::{Deref, DerefMut};
-use crate::ptr::NonNull;
-use crate::sync::{LockResult, PoisonError, TryLockError, TryLockResult, poison};
-use crate::sys::sync as sys;
-
-/// A reader-writer lock
-///
-/// This type of lock allows a number of readers or at most one writer at any
-/// point in time. The write portion of this lock typically allows modification
-/// of the underlying data (exclusive access) and the read portion of this lock
-/// typically allows for read-only access (shared access).
-///
-/// In comparison, a [`Mutex`] does not distinguish between readers or writers
-/// that acquire the lock, therefore blocking any threads waiting for the lock to
-/// become available. An `RwLock` will allow any number of readers to acquire the
-/// lock as long as a writer is not holding the lock.
-///
-/// The priority policy of the lock is dependent on the underlying operating
-/// system's implementation, and this type does not guarantee that any
-/// particular policy will be used. In particular, a writer which is waiting to
-/// acquire the lock in `write` might or might not block concurrent calls to
-/// `read`, e.g.:
-///
-/// <details><summary>Potential deadlock example</summary>
-///
-/// ```text
-/// // Thread 1              |  // Thread 2
-/// let _rg1 = lock.read();  |
-///                          |  // will block
-///                          |  let _wg = lock.write();
-/// // may deadlock          |
-/// let _rg2 = lock.read();  |
-/// ```
-///
-/// </details>
-///
-/// The type parameter `T` represents the data that this lock protects. It is
-/// required that `T` satisfies [`Send`] to be shared across threads and
-/// [`Sync`] to allow concurrent access through readers. The RAII guards
-/// returned from the locking methods implement [`Deref`] (and [`DerefMut`]
-/// for the `write` methods) to allow access to the content of the lock.
-///
-/// # Poisoning
-///
-/// An `RwLock`, like [`Mutex`], will become poisoned on a panic. Note, however,
-/// that an `RwLock` may only be poisoned if a panic occurs while it is locked
-/// exclusively (write mode). If a panic occurs in any reader, then the lock
-/// will not be poisoned.
-///
-/// # Examples
-///
-/// ```
-/// use std::sync::RwLock;
-///
-/// let lock = RwLock::new(5);
-///
-/// // many reader locks can be held at once
-/// {
-///     let r1 = lock.read().unwrap();
-///     let r2 = lock.read().unwrap();
-///     assert_eq!(*r1, 5);
-///     assert_eq!(*r2, 5);
-/// } // read locks are dropped at this point
-///
-/// // only one write lock may be held, however
-/// {
-///     let mut w = lock.write().unwrap();
-///     *w += 1;
-///     assert_eq!(*w, 6);
-/// } // write lock is dropped here
-/// ```
-///
-/// [`Mutex`]: super::Mutex
-#[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(test), rustc_diagnostic_item = "RwLock")]
-pub struct RwLock<T: ?Sized> {
-    inner: sys::RwLock,
-    poison: poison::Flag,
-    data: UnsafeCell<T>,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: ?Sized + Send> Send for RwLock<T> {}
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: ?Sized + Send + Sync> Sync for RwLock<T> {}
-
-/// RAII structure used to release the shared read access of a lock when
-/// dropped.
-///
-/// This structure is created by the [`read`] and [`try_read`] methods on
-/// [`RwLock`].
-///
-/// [`read`]: RwLock::read
-/// [`try_read`]: RwLock::try_read
-#[must_use = "if unused the RwLock will immediately unlock"]
-#[must_not_suspend = "holding a RwLockReadGuard across suspend \
-                      points can cause deadlocks, delays, \
-                      and cause Futures to not implement `Send`"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[clippy::has_significant_drop]
-#[cfg_attr(not(test), rustc_diagnostic_item = "RwLockReadGuard")]
-pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
-    // NB: we use a pointer instead of `&'a T` to avoid `noalias` violations, because a
-    // `RwLockReadGuard` argument doesn't hold immutability for its whole scope, only until it drops.
-    // `NonNull` is also covariant over `T`, just like we would have with `&T`. `NonNull`
-    // is preferable over `const* T` to allow for niche optimization.
-    data: NonNull<T>,
-    inner_lock: &'a sys::RwLock,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> !Send for RwLockReadGuard<'_, T> {}
-
-#[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
-unsafe impl<T: ?Sized + Sync> Sync for RwLockReadGuard<'_, T> {}
-
-/// RAII structure used to release the exclusive write access of a lock when
-/// dropped.
-///
-/// This structure is created by the [`write`] and [`try_write`] methods
-/// on [`RwLock`].
-///
-/// [`write`]: RwLock::write
-/// [`try_write`]: RwLock::try_write
-#[must_use = "if unused the RwLock will immediately unlock"]
-#[must_not_suspend = "holding a RwLockWriteGuard across suspend \
-                      points can cause deadlocks, delays, \
-                      and cause Future's to not implement `Send`"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[clippy::has_significant_drop]
-#[cfg_attr(not(test), rustc_diagnostic_item = "RwLockWriteGuard")]
-pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
-    lock: &'a RwLock<T>,
-    poison: poison::Guard,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> !Send for RwLockWriteGuard<'_, T> {}
-
-#[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
-unsafe impl<T: ?Sized + Sync> Sync for RwLockWriteGuard<'_, T> {}
-
-/// RAII structure used to release the shared read access of a lock when
-/// dropped, which can point to a subfield of the protected data.
-///
-/// This structure is created by the [`map`] and [`try_map`] methods
-/// on [`RwLockReadGuard`].
-///
-/// [`map`]: RwLockReadGuard::map
-/// [`try_map`]: RwLockReadGuard::try_map
-#[must_use = "if unused the RwLock will immediately unlock"]
-#[must_not_suspend = "holding a MappedRwLockReadGuard across suspend \
-                      points can cause deadlocks, delays, \
-                      and cause Futures to not implement `Send`"]
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-#[clippy::has_significant_drop]
-pub struct MappedRwLockReadGuard<'a, T: ?Sized + 'a> {
-    // NB: we use a pointer instead of `&'a T` to avoid `noalias` violations, because a
-    // `MappedRwLockReadGuard` argument doesn't hold immutability for its whole scope, only until it drops.
-    // `NonNull` is also covariant over `T`, just like we would have with `&T`. `NonNull`
-    // is preferable over `const* T` to allow for niche optimization.
-    data: NonNull<T>,
-    inner_lock: &'a sys::RwLock,
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> !Send for MappedRwLockReadGuard<'_, T> {}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-unsafe impl<T: ?Sized + Sync> Sync for MappedRwLockReadGuard<'_, T> {}
-
-/// RAII structure used to release the exclusive write access of a lock when
-/// dropped, which can point to a subfield of the protected data.
-///
-/// This structure is created by the [`map`] and [`try_map`] methods
-/// on [`RwLockWriteGuard`].
-///
-/// [`map`]: RwLockWriteGuard::map
-/// [`try_map`]: RwLockWriteGuard::try_map
-#[must_use = "if unused the RwLock will immediately unlock"]
-#[must_not_suspend = "holding a MappedRwLockWriteGuard across suspend \
-                      points can cause deadlocks, delays, \
-                      and cause Future's to not implement `Send`"]
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-#[clippy::has_significant_drop]
-pub struct MappedRwLockWriteGuard<'a, T: ?Sized + 'a> {
-    // NB: we use a pointer instead of `&'a mut T` to avoid `noalias` violations, because a
-    // `MappedRwLockWriteGuard` argument doesn't hold uniqueness for its whole scope, only until it drops.
-    // `NonNull` is covariant over `T`, so we add a `PhantomData<&'a mut T>` field
-    // below for the correct variance over `T` (invariance).
-    data: NonNull<T>,
-    inner_lock: &'a sys::RwLock,
-    poison_flag: &'a poison::Flag,
-    poison: poison::Guard,
-    _variance: PhantomData<&'a mut T>,
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> !Send for MappedRwLockWriteGuard<'_, T> {}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-unsafe impl<T: ?Sized + Sync> Sync for MappedRwLockWriteGuard<'_, T> {}
-
-impl<T> RwLock<T> {
-    /// Creates a new instance of an `RwLock<T>` which is unlocked.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::RwLock;
-    ///
-    /// let lock = RwLock::new(5);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
-    #[inline]
-    pub const fn new(t: T) -> RwLock<T> {
-        RwLock { inner: sys::RwLock::new(), poison: poison::Flag::new(), data: UnsafeCell::new(t) }
-    }
-
-    /// Returns the contained value by cloning it.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the `RwLock` is poisoned. An
-    /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
-    /// lock.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(lock_value_accessors)]
-    ///
-    /// use std::sync::RwLock;
-    ///
-    /// let mut lock = RwLock::new(7);
-    ///
-    /// assert_eq!(lock.get_cloned().unwrap(), 7);
-    /// ```
-    #[unstable(feature = "lock_value_accessors", issue = "133407")]
-    pub fn get_cloned(&self) -> Result<T, PoisonError<()>>
-    where
-        T: Clone,
-    {
-        match self.read() {
-            Ok(guard) => Ok((*guard).clone()),
-            Err(_) => Err(PoisonError::new(())),
-        }
-    }
-
-    /// Sets the contained value.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error containing the provided `value` if
-    /// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer
-    /// panics while holding an exclusive lock.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(lock_value_accessors)]
-    ///
-    /// use std::sync::RwLock;
-    ///
-    /// let mut lock = RwLock::new(7);
-    ///
-    /// assert_eq!(lock.get_cloned().unwrap(), 7);
-    /// lock.set(11).unwrap();
-    /// assert_eq!(lock.get_cloned().unwrap(), 11);
-    /// ```
-    #[unstable(feature = "lock_value_accessors", issue = "133407")]
-    pub fn set(&self, value: T) -> Result<(), PoisonError<T>> {
-        if mem::needs_drop::<T>() {
-            // If the contained value has non-trivial destructor, we
-            // call that destructor after the lock being released.
-            self.replace(value).map(drop)
-        } else {
-            match self.write() {
-                Ok(mut guard) => {
-                    *guard = value;
-
-                    Ok(())
-                }
-                Err(_) => Err(PoisonError::new(value)),
-            }
-        }
-    }
-
-    /// Replaces the contained value with `value`, and returns the old contained value.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error containing the provided `value` if
-    /// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer
-    /// panics while holding an exclusive lock.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(lock_value_accessors)]
-    ///
-    /// use std::sync::RwLock;
-    ///
-    /// let mut lock = RwLock::new(7);
-    ///
-    /// assert_eq!(lock.replace(11).unwrap(), 7);
-    /// assert_eq!(lock.get_cloned().unwrap(), 11);
-    /// ```
-    #[unstable(feature = "lock_value_accessors", issue = "133407")]
-    pub fn replace(&self, value: T) -> LockResult<T> {
-        match self.write() {
-            Ok(mut guard) => Ok(mem::replace(&mut *guard, value)),
-            Err(_) => Err(PoisonError::new(value)),
-        }
-    }
-}
-
-impl<T: ?Sized> RwLock<T> {
-    /// Locks this `RwLock` with shared read access, blocking the current thread
-    /// until it can be acquired.
-    ///
-    /// The calling thread will be blocked until there are no more writers which
-    /// hold the lock. There may be other readers currently inside the lock when
-    /// this method returns. This method does not provide any guarantees with
-    /// respect to the ordering of whether contentious readers or writers will
-    /// acquire the lock first.
-    ///
-    /// Returns an RAII guard which will release this thread's shared access
-    /// once it is dropped.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the `RwLock` is poisoned. An
-    /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
-    /// lock. The failure will occur immediately after the lock has been
-    /// acquired. The acquired lock guard will be contained in the returned
-    /// error.
-    ///
-    /// # Panics
-    ///
-    /// This function might panic when called if the lock is already held by the current thread.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, RwLock};
-    /// use std::thread;
-    ///
-    /// let lock = Arc::new(RwLock::new(1));
-    /// let c_lock = Arc::clone(&lock);
-    ///
-    /// let n = lock.read().unwrap();
-    /// assert_eq!(*n, 1);
-    ///
-    /// thread::spawn(move || {
-    ///     let r = c_lock.read();
-    ///     assert!(r.is_ok());
-    /// }).join().unwrap();
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn read(&self) -> LockResult<RwLockReadGuard<'_, T>> {
-        unsafe {
-            self.inner.read();
-            RwLockReadGuard::new(self)
-        }
-    }
-
-    /// Attempts to acquire this `RwLock` with shared read access.
-    ///
-    /// If the access could not be granted at this time, then `Err` is returned.
-    /// Otherwise, an RAII guard is returned which will release the shared access
-    /// when it is dropped.
-    ///
-    /// This function does not block.
-    ///
-    /// This function does not provide any guarantees with respect to the ordering
-    /// of whether contentious readers or writers will acquire the lock first.
-    ///
-    /// # Errors
-    ///
-    /// This function will return the [`Poisoned`] error if the `RwLock` is
-    /// poisoned. An `RwLock` is poisoned whenever a writer panics while holding
-    /// an exclusive lock. `Poisoned` will only be returned if the lock would
-    /// have otherwise been acquired. An acquired lock guard will be contained
-    /// in the returned error.
-    ///
-    /// This function will return the [`WouldBlock`] error if the `RwLock` could
-    /// not be acquired because it was already locked exclusively.
-    ///
-    /// [`Poisoned`]: TryLockError::Poisoned
-    /// [`WouldBlock`]: TryLockError::WouldBlock
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::RwLock;
-    ///
-    /// let lock = RwLock::new(1);
-    ///
-    /// match lock.try_read() {
-    ///     Ok(n) => assert_eq!(*n, 1),
-    ///     Err(_) => unreachable!(),
-    /// };
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn try_read(&self) -> TryLockResult<RwLockReadGuard<'_, T>> {
-        unsafe {
-            if self.inner.try_read() {
-                Ok(RwLockReadGuard::new(self)?)
-            } else {
-                Err(TryLockError::WouldBlock)
-            }
-        }
-    }
-
-    /// Locks this `RwLock` with exclusive write access, blocking the current
-    /// thread until it can be acquired.
-    ///
-    /// This function will not return while other writers or other readers
-    /// currently have access to the lock.
-    ///
-    /// Returns an RAII guard which will drop the write access of this `RwLock`
-    /// when dropped.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the `RwLock` is poisoned. An
-    /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
-    /// lock. An error will be returned when the lock is acquired. The acquired
-    /// lock guard will be contained in the returned error.
-    ///
-    /// # Panics
-    ///
-    /// This function might panic when called if the lock is already held by the current thread.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::RwLock;
-    ///
-    /// let lock = RwLock::new(1);
-    ///
-    /// let mut n = lock.write().unwrap();
-    /// *n = 2;
-    ///
-    /// assert!(lock.try_read().is_err());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, T>> {
-        unsafe {
-            self.inner.write();
-            RwLockWriteGuard::new(self)
-        }
-    }
-
-    /// Attempts to lock this `RwLock` with exclusive write access.
-    ///
-    /// If the lock could not be acquired at this time, then `Err` is returned.
-    /// Otherwise, an RAII guard is returned which will release the lock when
-    /// it is dropped.
-    ///
-    /// This function does not block.
-    ///
-    /// This function does not provide any guarantees with respect to the ordering
-    /// of whether contentious readers or writers will acquire the lock first.
-    ///
-    /// # Errors
-    ///
-    /// This function will return the [`Poisoned`] error if the `RwLock` is
-    /// poisoned. An `RwLock` is poisoned whenever a writer panics while holding
-    /// an exclusive lock. `Poisoned` will only be returned if the lock would
-    /// have otherwise been acquired. An acquired lock guard will be contained
-    /// in the returned error.
-    ///
-    /// This function will return the [`WouldBlock`] error if the `RwLock` could
-    /// not be acquired because it was already locked exclusively.
-    ///
-    /// [`Poisoned`]: TryLockError::Poisoned
-    /// [`WouldBlock`]: TryLockError::WouldBlock
-    ///
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::RwLock;
-    ///
-    /// let lock = RwLock::new(1);
-    ///
-    /// let n = lock.read().unwrap();
-    /// assert_eq!(*n, 1);
-    ///
-    /// assert!(lock.try_write().is_err());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn try_write(&self) -> TryLockResult<RwLockWriteGuard<'_, T>> {
-        unsafe {
-            if self.inner.try_write() {
-                Ok(RwLockWriteGuard::new(self)?)
-            } else {
-                Err(TryLockError::WouldBlock)
-            }
-        }
-    }
-
-    /// Determines whether the lock is poisoned.
-    ///
-    /// If another thread is active, the lock can still become poisoned at any
-    /// time. You should not trust a `false` value for program correctness
-    /// without additional synchronization.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, RwLock};
-    /// use std::thread;
-    ///
-    /// let lock = Arc::new(RwLock::new(0));
-    /// let c_lock = Arc::clone(&lock);
-    ///
-    /// let _ = thread::spawn(move || {
-    ///     let _lock = c_lock.write().unwrap();
-    ///     panic!(); // the lock gets poisoned
-    /// }).join();
-    /// assert_eq!(lock.is_poisoned(), true);
-    /// ```
-    #[inline]
-    #[stable(feature = "sync_poison", since = "1.2.0")]
-    pub fn is_poisoned(&self) -> bool {
-        self.poison.get()
-    }
-
-    /// Clear the poisoned state from a lock.
-    ///
-    /// If the lock is poisoned, it will remain poisoned until this function is called. This allows
-    /// recovering from a poisoned state and marking that it has recovered. For example, if the
-    /// value is overwritten by a known-good value, then the lock can be marked as un-poisoned. Or
-    /// possibly, the value could be inspected to determine if it is in a consistent state, and if
-    /// so the poison is removed.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::{Arc, RwLock};
-    /// use std::thread;
-    ///
-    /// let lock = Arc::new(RwLock::new(0));
-    /// let c_lock = Arc::clone(&lock);
-    ///
-    /// let _ = thread::spawn(move || {
-    ///     let _lock = c_lock.write().unwrap();
-    ///     panic!(); // the lock gets poisoned
-    /// }).join();
-    ///
-    /// assert_eq!(lock.is_poisoned(), true);
-    /// let guard = lock.write().unwrap_or_else(|mut e| {
-    ///     **e.get_mut() = 1;
-    ///     lock.clear_poison();
-    ///     e.into_inner()
-    /// });
-    /// assert_eq!(lock.is_poisoned(), false);
-    /// assert_eq!(*guard, 1);
-    /// ```
-    #[inline]
-    #[stable(feature = "mutex_unpoison", since = "1.77.0")]
-    pub fn clear_poison(&self) {
-        self.poison.clear();
-    }
-
-    /// Consumes this `RwLock`, returning the underlying data.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error containing the underlying data if
-    /// the `RwLock` is poisoned. An `RwLock` is poisoned whenever a writer
-    /// panics while holding an exclusive lock. An error will only be returned
-    /// if the lock would have otherwise been acquired.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::RwLock;
-    ///
-    /// let lock = RwLock::new(String::new());
-    /// {
-    ///     let mut s = lock.write().unwrap();
-    ///     *s = "modified".to_owned();
-    /// }
-    /// assert_eq!(lock.into_inner().unwrap(), "modified");
-    /// ```
-    #[stable(feature = "rwlock_into_inner", since = "1.6.0")]
-    pub fn into_inner(self) -> LockResult<T>
-    where
-        T: Sized,
-    {
-        let data = self.data.into_inner();
-        poison::map_result(self.poison.borrow(), |()| data)
-    }
-
-    /// Returns a mutable reference to the underlying data.
-    ///
-    /// Since this call borrows the `RwLock` mutably, no actual locking needs to
-    /// take place -- the mutable borrow statically guarantees no locks exist.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error containing a mutable reference to
-    /// the underlying data if the `RwLock` is poisoned. An `RwLock` is
-    /// poisoned whenever a writer panics while holding an exclusive lock.
-    /// An error will only be returned if the lock would have otherwise been
-    /// acquired.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::RwLock;
-    ///
-    /// let mut lock = RwLock::new(0);
-    /// *lock.get_mut().unwrap() = 10;
-    /// assert_eq!(*lock.read().unwrap(), 10);
-    /// ```
-    #[stable(feature = "rwlock_get_mut", since = "1.6.0")]
-    pub fn get_mut(&mut self) -> LockResult<&mut T> {
-        let data = self.data.get_mut();
-        poison::map_result(self.poison.borrow(), |()| data)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLock<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut d = f.debug_struct("RwLock");
-        match self.try_read() {
-            Ok(guard) => {
-                d.field("data", &&*guard);
-            }
-            Err(TryLockError::Poisoned(err)) => {
-                d.field("data", &&**err.get_ref());
-            }
-            Err(TryLockError::WouldBlock) => {
-                d.field("data", &format_args!("<locked>"));
-            }
-        }
-        d.field("poisoned", &self.poison.get());
-        d.finish_non_exhaustive()
-    }
-}
-
-#[stable(feature = "rw_lock_default", since = "1.10.0")]
-impl<T: Default> Default for RwLock<T> {
-    /// Creates a new `RwLock<T>`, with the `Default` value for T.
-    fn default() -> RwLock<T> {
-        RwLock::new(Default::default())
-    }
-}
-
-#[stable(feature = "rw_lock_from", since = "1.24.0")]
-impl<T> From<T> for RwLock<T> {
-    /// Creates a new instance of an `RwLock<T>` which is unlocked.
-    /// This is equivalent to [`RwLock::new`].
-    fn from(t: T) -> Self {
-        RwLock::new(t)
-    }
-}
-
-impl<'rwlock, T: ?Sized> RwLockReadGuard<'rwlock, T> {
-    /// Creates a new instance of `RwLockReadGuard<T>` from a `RwLock<T>`.
-    ///
-    /// # Safety
-    ///
-    /// This function is safe if and only if the same thread has successfully and safely called
-    /// `lock.inner.read()`, `lock.inner.try_read()`, or `lock.inner.downgrade()` before
-    /// instantiating this object.
-    unsafe fn new(lock: &'rwlock RwLock<T>) -> LockResult<RwLockReadGuard<'rwlock, T>> {
-        poison::map_result(lock.poison.borrow(), |()| RwLockReadGuard {
-            data: unsafe { NonNull::new_unchecked(lock.data.get()) },
-            inner_lock: &lock.inner,
-        })
-    }
-}
-
-impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> {
-    /// Creates a new instance of `RwLockWriteGuard<T>` from a `RwLock<T>`.
-    // SAFETY: if and only if `lock.inner.write()` (or `lock.inner.try_write()`) has been
-    // successfully called from the same thread before instantiating this object.
-    unsafe fn new(lock: &'rwlock RwLock<T>) -> LockResult<RwLockWriteGuard<'rwlock, T>> {
-        poison::map_result(lock.poison.guard(), |guard| RwLockWriteGuard { lock, poison: guard })
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLockReadGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[stable(feature = "std_guard_impls", since = "1.20.0")]
-impl<T: ?Sized + fmt::Display> fmt::Display for RwLockReadGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLockWriteGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[stable(feature = "std_guard_impls", since = "1.20.0")]
-impl<T: ?Sized + fmt::Display> fmt::Display for RwLockWriteGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for MappedRwLockReadGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized + fmt::Display> fmt::Display for MappedRwLockReadGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for MappedRwLockWriteGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized + fmt::Display> fmt::Display for MappedRwLockWriteGuard<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when created.
-        unsafe { self.data.as_ref() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
-        unsafe { &*self.lock.data.get() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
-        unsafe { &mut *self.lock.data.get() }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> Deref for MappedRwLockReadGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        unsafe { self.data.as_ref() }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> Deref for MappedRwLockWriteGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        unsafe { self.data.as_ref() }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> DerefMut for MappedRwLockWriteGuard<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        unsafe { self.data.as_mut() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Drop for RwLockReadGuard<'_, T> {
-    fn drop(&mut self) {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when created.
-        unsafe {
-            self.inner_lock.read_unlock();
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Drop for RwLockWriteGuard<'_, T> {
-    fn drop(&mut self) {
-        self.lock.poison.done(&self.poison);
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
-        unsafe {
-            self.lock.inner.write_unlock();
-        }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> Drop for MappedRwLockReadGuard<'_, T> {
-    fn drop(&mut self) {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        unsafe {
-            self.inner_lock.read_unlock();
-        }
-    }
-}
-
-#[unstable(feature = "mapped_lock_guards", issue = "117108")]
-impl<T: ?Sized> Drop for MappedRwLockWriteGuard<'_, T> {
-    fn drop(&mut self) {
-        self.poison_flag.done(&self.poison);
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        unsafe {
-            self.inner_lock.write_unlock();
-        }
-    }
-}
-
-impl<'a, T: ?Sized> RwLockReadGuard<'a, T> {
-    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data, e.g.
-    /// an enum variant.
-    ///
-    /// The `RwLock` is already locked for reading, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `RwLockReadGuard::map(...)`. A method would interfere with methods of
-    /// the same name on the contents of the `RwLockReadGuard` used through
-    /// `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn map<U, F>(orig: Self, f: F) -> MappedRwLockReadGuard<'a, U>
-    where
-        F: FnOnce(&T) -> &U,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        let data = NonNull::from(f(unsafe { orig.data.as_ref() }));
-        let orig = ManuallyDrop::new(orig);
-        MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock }
-    }
-
-    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data. The
-    /// original guard is returned as an `Err(...)` if the closure returns
-    /// `None`.
-    ///
-    /// The `RwLock` is already locked for reading, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `RwLockReadGuard::try_map(...)`. A method would interfere with methods
-    /// of the same name on the contents of the `RwLockReadGuard` used through
-    /// `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
-    #[doc(alias = "filter_map")]
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedRwLockReadGuard<'a, U>, Self>
-    where
-        F: FnOnce(&T) -> Option<&U>,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        match f(unsafe { orig.data.as_ref() }) {
-            Some(data) => {
-                let data = NonNull::from(data);
-                let orig = ManuallyDrop::new(orig);
-                Ok(MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock })
-            }
-            None => Err(orig),
-        }
-    }
-}
-
-impl<'a, T: ?Sized> MappedRwLockReadGuard<'a, T> {
-    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data,
-    /// e.g. an enum variant.
-    ///
-    /// The `RwLock` is already locked for reading, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MappedRwLockReadGuard::map(...)`. A method would interfere with
-    /// methods of the same name on the contents of the `MappedRwLockReadGuard`
-    /// used through `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn map<U, F>(orig: Self, f: F) -> MappedRwLockReadGuard<'a, U>
-    where
-        F: FnOnce(&T) -> &U,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        let data = NonNull::from(f(unsafe { orig.data.as_ref() }));
-        let orig = ManuallyDrop::new(orig);
-        MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock }
-    }
-
-    /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data.
-    /// The original guard is returned as an `Err(...)` if the closure returns
-    /// `None`.
-    ///
-    /// The `RwLock` is already locked for reading, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MappedRwLockReadGuard::try_map(...)`. A method would interfere with
-    /// methods of the same name on the contents of the `MappedRwLockReadGuard`
-    /// used through `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will not be poisoned.
-    #[doc(alias = "filter_map")]
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedRwLockReadGuard<'a, U>, Self>
-    where
-        F: FnOnce(&T) -> Option<&U>,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        match f(unsafe { orig.data.as_ref() }) {
-            Some(data) => {
-                let data = NonNull::from(data);
-                let orig = ManuallyDrop::new(orig);
-                Ok(MappedRwLockReadGuard { data, inner_lock: &orig.inner_lock })
-            }
-            None => Err(orig),
-        }
-    }
-}
-
-impl<'a, T: ?Sized> RwLockWriteGuard<'a, T> {
-    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data, e.g.
-    /// an enum variant.
-    ///
-    /// The `RwLock` is already locked for writing, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `RwLockWriteGuard::map(...)`. A method would interfere with methods of
-    /// the same name on the contents of the `RwLockWriteGuard` used through
-    /// `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn map<U, F>(orig: Self, f: F) -> MappedRwLockWriteGuard<'a, U>
-    where
-        F: FnOnce(&mut T) -> &mut U,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        let data = NonNull::from(f(unsafe { &mut *orig.lock.data.get() }));
-        let orig = ManuallyDrop::new(orig);
-        MappedRwLockWriteGuard {
-            data,
-            inner_lock: &orig.lock.inner,
-            poison_flag: &orig.lock.poison,
-            poison: orig.poison.clone(),
-            _variance: PhantomData,
-        }
-    }
-
-    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data. The
-    /// original guard is returned as an `Err(...)` if the closure returns
-    /// `None`.
-    ///
-    /// The `RwLock` is already locked for writing, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `RwLockWriteGuard::try_map(...)`. A method would interfere with methods
-    /// of the same name on the contents of the `RwLockWriteGuard` used through
-    /// `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
-    #[doc(alias = "filter_map")]
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn try_map<U, F>(orig: Self, f: F) -> Result<MappedRwLockWriteGuard<'a, U>, Self>
-    where
-        F: FnOnce(&mut T) -> Option<&mut U>,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        match f(unsafe { &mut *orig.lock.data.get() }) {
-            Some(data) => {
-                let data = NonNull::from(data);
-                let orig = ManuallyDrop::new(orig);
-                Ok(MappedRwLockWriteGuard {
-                    data,
-                    inner_lock: &orig.lock.inner,
-                    poison_flag: &orig.lock.poison,
-                    poison: orig.poison.clone(),
-                    _variance: PhantomData,
-                })
-            }
-            None => Err(orig),
-        }
-    }
-
-    /// Downgrades a write-locked `RwLockWriteGuard` into a read-locked [`RwLockReadGuard`].
-    ///
-    /// This method will atomically change the state of the [`RwLock`] from exclusive mode into
-    /// shared mode. This means that it is impossible for a writing thread to get in between a
-    /// thread calling `downgrade` and the same thread reading whatever it wrote while it had the
-    /// [`RwLock`] in write mode.
-    ///
-    /// Note that since we have the `RwLockWriteGuard`, we know that the [`RwLock`] is already
-    /// locked for writing, so this method cannot fail.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// #![feature(rwlock_downgrade)]
-    /// use std::sync::{Arc, RwLock, RwLockWriteGuard};
-    ///
-    /// // The inner value starts as 0.
-    /// let rw = Arc::new(RwLock::new(0));
-    ///
-    /// // Put the lock in write mode.
-    /// let mut main_write_guard = rw.write().unwrap();
-    ///
-    /// let evil = rw.clone();
-    /// let handle = std::thread::spawn(move || {
-    ///     // This will not return until the main thread drops the `main_read_guard`.
-    ///     let mut evil_guard = evil.write().unwrap();
-    ///
-    ///     assert_eq!(*evil_guard, 1);
-    ///     *evil_guard = 2;
-    /// });
-    ///
-    /// // After spawning the writer thread, set the inner value to 1.
-    /// *main_write_guard = 1;
-    ///
-    /// // Atomically downgrade the write guard into a read guard.
-    /// let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);
-    ///
-    /// // Since `downgrade` is atomic, the writer thread cannot have set the inner value to 2.
-    /// assert_eq!(*main_read_guard, 1, "`downgrade` was not atomic");
-    ///
-    /// // Clean up everything now
-    /// drop(main_read_guard);
-    /// handle.join().unwrap();
-    ///
-    /// let final_check = rw.read().unwrap();
-    /// assert_eq!(*final_check, 2);
-    /// ```
-    #[unstable(feature = "rwlock_downgrade", issue = "128203")]
-    pub fn downgrade(s: Self) -> RwLockReadGuard<'a, T> {
-        let lock = s.lock;
-
-        // We don't want to call the destructor since that calls `write_unlock`.
-        forget(s);
-
-        // SAFETY: We take ownership of a write guard, so we must already have the `RwLock` in write
-        // mode, satisfying the `downgrade` contract.
-        unsafe { lock.inner.downgrade() };
-
-        // SAFETY: We have just successfully called `downgrade`, so we fulfill the safety contract.
-        unsafe { RwLockReadGuard::new(lock).unwrap_or_else(PoisonError::into_inner) }
-    }
-}
-
-impl<'a, T: ?Sized> MappedRwLockWriteGuard<'a, T> {
-    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data,
-    /// e.g. an enum variant.
-    ///
-    /// The `RwLock` is already locked for writing, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MappedRwLockWriteGuard::map(...)`. A method would interfere with
-    /// methods of the same name on the contents of the `MappedRwLockWriteGuard`
-    /// used through `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn map<U, F>(mut orig: Self, f: F) -> MappedRwLockWriteGuard<'a, U>
-    where
-        F: FnOnce(&mut T) -> &mut U,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        let data = NonNull::from(f(unsafe { orig.data.as_mut() }));
-        let orig = ManuallyDrop::new(orig);
-        MappedRwLockWriteGuard {
-            data,
-            inner_lock: orig.inner_lock,
-            poison_flag: orig.poison_flag,
-            poison: orig.poison.clone(),
-            _variance: PhantomData,
-        }
-    }
-
-    /// Makes a [`MappedRwLockWriteGuard`] for a component of the borrowed data.
-    /// The original guard is returned as an `Err(...)` if the closure returns
-    /// `None`.
-    ///
-    /// The `RwLock` is already locked for writing, so this cannot fail.
-    ///
-    /// This is an associated function that needs to be used as
-    /// `MappedRwLockWriteGuard::try_map(...)`. A method would interfere with
-    /// methods of the same name on the contents of the `MappedRwLockWriteGuard`
-    /// used through `Deref`.
-    ///
-    /// # Panics
-    ///
-    /// If the closure panics, the guard will be dropped (unlocked) and the RwLock will be poisoned.
-    #[doc(alias = "filter_map")]
-    #[unstable(feature = "mapped_lock_guards", issue = "117108")]
-    pub fn try_map<U, F>(mut orig: Self, f: F) -> Result<MappedRwLockWriteGuard<'a, U>, Self>
-    where
-        F: FnOnce(&mut T) -> Option<&mut U>,
-        U: ?Sized,
-    {
-        // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when the original guard
-        // was created, and have been upheld throughout `map` and/or `try_map`.
-        // The signature of the closure guarantees that it will not "leak" the lifetime of the reference
-        // passed to it. If the closure panics, the guard will be dropped.
-        match f(unsafe { orig.data.as_mut() }) {
-            Some(data) => {
-                let data = NonNull::from(data);
-                let orig = ManuallyDrop::new(orig);
-                Ok(MappedRwLockWriteGuard {
-                    data,
-                    inner_lock: orig.inner_lock,
-                    poison_flag: orig.poison_flag,
-                    poison: orig.poison.clone(),
-                    _variance: PhantomData,
-                })
-            }
-            None => Err(orig),
-        }
-    }
-}
diff --git a/library/std/src/sync/rwlock/tests.rs b/library/std/src/sync/rwlock/tests.rs
deleted file mode 100644
index 057c2f1a5d7..00000000000
--- a/library/std/src/sync/rwlock/tests.rs
+++ /dev/null
@@ -1,729 +0,0 @@
-use rand::Rng;
-
-use crate::fmt::Debug;
-use crate::ops::FnMut;
-use crate::panic::{self, AssertUnwindSafe};
-use crate::sync::atomic::{AtomicUsize, Ordering};
-use crate::sync::mpsc::channel;
-use crate::sync::{
-    Arc, MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard, RwLockWriteGuard,
-    TryLockError,
-};
-use crate::{hint, mem, thread};
-
-#[derive(Eq, PartialEq, Debug)]
-struct NonCopy(i32);
-
-#[derive(Eq, PartialEq, Debug)]
-struct NonCopyNeedsDrop(i32);
-
-impl Drop for NonCopyNeedsDrop {
-    fn drop(&mut self) {
-        hint::black_box(());
-    }
-}
-
-#[test]
-fn test_needs_drop() {
-    assert!(!mem::needs_drop::<NonCopy>());
-    assert!(mem::needs_drop::<NonCopyNeedsDrop>());
-}
-
-#[derive(Clone, Eq, PartialEq, Debug)]
-struct Cloneable(i32);
-
-#[test]
-fn smoke() {
-    let l = RwLock::new(());
-    drop(l.read().unwrap());
-    drop(l.write().unwrap());
-    drop((l.read().unwrap(), l.read().unwrap()));
-    drop(l.write().unwrap());
-}
-
-#[test]
-// FIXME: On macOS we use a provenance-incorrect implementation and Miri
-// catches that issue with a chance of around 1/1000.
-// See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
-fn frob() {
-    const N: u32 = 10;
-    const M: usize = if cfg!(miri) { 100 } else { 1000 };
-
-    let r = Arc::new(RwLock::new(()));
-
-    let (tx, rx) = channel::<()>();
-    for _ in 0..N {
-        let tx = tx.clone();
-        let r = r.clone();
-        thread::spawn(move || {
-            let mut rng = crate::test_helpers::test_rng();
-            for _ in 0..M {
-                if rng.gen_bool(1.0 / (N as f64)) {
-                    drop(r.write().unwrap());
-                } else {
-                    drop(r.read().unwrap());
-                }
-            }
-            drop(tx);
-        });
-    }
-    drop(tx);
-    let _ = rx.recv();
-}
-
-#[test]
-fn test_rw_arc_poison_wr() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let _lock = arc2.write().unwrap();
-        panic!();
-    })
-    .join();
-    assert!(arc.read().is_err());
-}
-
-#[test]
-fn test_rw_arc_poison_mapped_w_r() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let lock = arc2.write().unwrap();
-        let _lock = RwLockWriteGuard::map(lock, |val| val);
-        panic!();
-    })
-    .join();
-    assert!(arc.read().is_err());
-}
-
-#[test]
-fn test_rw_arc_poison_ww() {
-    let arc = Arc::new(RwLock::new(1));
-    assert!(!arc.is_poisoned());
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let _lock = arc2.write().unwrap();
-        panic!();
-    })
-    .join();
-    assert!(arc.write().is_err());
-    assert!(arc.is_poisoned());
-}
-
-#[test]
-fn test_rw_arc_poison_mapped_w_w() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let lock = arc2.write().unwrap();
-        let _lock = RwLockWriteGuard::map(lock, |val| val);
-        panic!();
-    })
-    .join();
-    assert!(arc.write().is_err());
-    assert!(arc.is_poisoned());
-}
-
-#[test]
-fn test_rw_arc_no_poison_rr() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let _lock = arc2.read().unwrap();
-        panic!();
-    })
-    .join();
-    let lock = arc.read().unwrap();
-    assert_eq!(*lock, 1);
-}
-
-#[test]
-fn test_rw_arc_no_poison_mapped_r_r() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let lock = arc2.read().unwrap();
-        let _lock = RwLockReadGuard::map(lock, |val| val);
-        panic!();
-    })
-    .join();
-    let lock = arc.read().unwrap();
-    assert_eq!(*lock, 1);
-}
-
-#[test]
-fn test_rw_arc_no_poison_rw() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let _lock = arc2.read().unwrap();
-        panic!()
-    })
-    .join();
-    let lock = arc.write().unwrap();
-    assert_eq!(*lock, 1);
-}
-
-#[test]
-fn test_rw_arc_no_poison_mapped_r_w() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _: Result<(), _> = thread::spawn(move || {
-        let lock = arc2.read().unwrap();
-        let _lock = RwLockReadGuard::map(lock, |val| val);
-        panic!();
-    })
-    .join();
-    let lock = arc.write().unwrap();
-    assert_eq!(*lock, 1);
-}
-
-#[test]
-fn test_rw_arc() {
-    let arc = Arc::new(RwLock::new(0));
-    let arc2 = arc.clone();
-    let (tx, rx) = channel();
-
-    thread::spawn(move || {
-        let mut lock = arc2.write().unwrap();
-        for _ in 0..10 {
-            let tmp = *lock;
-            *lock = -1;
-            thread::yield_now();
-            *lock = tmp + 1;
-        }
-        tx.send(()).unwrap();
-    });
-
-    // Readers try to catch the writer in the act
-    let mut children = Vec::new();
-    for _ in 0..5 {
-        let arc3 = arc.clone();
-        children.push(thread::spawn(move || {
-            let lock = arc3.read().unwrap();
-            assert!(*lock >= 0);
-        }));
-    }
-
-    // Wait for children to pass their asserts
-    for r in children {
-        assert!(r.join().is_ok());
-    }
-
-    // Wait for writer to finish
-    rx.recv().unwrap();
-    let lock = arc.read().unwrap();
-    assert_eq!(*lock, 10);
-}
-
-#[test]
-fn test_rw_arc_access_in_unwind() {
-    let arc = Arc::new(RwLock::new(1));
-    let arc2 = arc.clone();
-    let _ = thread::spawn(move || -> () {
-        struct Unwinder {
-            i: Arc<RwLock<isize>>,
-        }
-        impl Drop for Unwinder {
-            fn drop(&mut self) {
-                let mut lock = self.i.write().unwrap();
-                *lock += 1;
-            }
-        }
-        let _u = Unwinder { i: arc2 };
-        panic!();
-    })
-    .join();
-    let lock = arc.read().unwrap();
-    assert_eq!(*lock, 2);
-}
-
-#[test]
-fn test_rwlock_unsized() {
-    let rw: &RwLock<[i32]> = &RwLock::new([1, 2, 3]);
-    {
-        let b = &mut *rw.write().unwrap();
-        b[0] = 4;
-        b[2] = 5;
-    }
-    let comp: &[i32] = &[4, 2, 5];
-    assert_eq!(&*rw.read().unwrap(), comp);
-}
-
-#[test]
-fn test_rwlock_try_write() {
-    let lock = RwLock::new(0isize);
-    let read_guard = lock.read().unwrap();
-
-    let write_result = lock.try_write();
-    match write_result {
-        Err(TryLockError::WouldBlock) => (),
-        Ok(_) => assert!(false, "try_write should not succeed while read_guard is in scope"),
-        Err(_) => assert!(false, "unexpected error"),
-    }
-
-    drop(read_guard);
-    let mapped_read_guard = RwLockReadGuard::map(lock.read().unwrap(), |_| &());
-
-    let write_result = lock.try_write();
-    match write_result {
-        Err(TryLockError::WouldBlock) => (),
-        Ok(_) => assert!(false, "try_write should not succeed while mapped_read_guard is in scope"),
-        Err(_) => assert!(false, "unexpected error"),
-    }
-
-    drop(mapped_read_guard);
-}
-
-fn new_poisoned_rwlock<T>(value: T) -> RwLock<T> {
-    let lock = RwLock::new(value);
-
-    let catch_unwind_result = panic::catch_unwind(AssertUnwindSafe(|| {
-        let _guard = lock.write().unwrap();
-
-        panic!("test panic to poison RwLock");
-    }));
-
-    assert!(catch_unwind_result.is_err());
-    assert!(lock.is_poisoned());
-
-    lock
-}
-
-#[test]
-fn test_into_inner() {
-    let m = RwLock::new(NonCopy(10));
-    assert_eq!(m.into_inner().unwrap(), NonCopy(10));
-}
-
-#[test]
-fn test_into_inner_drop() {
-    struct Foo(Arc<AtomicUsize>);
-    impl Drop for Foo {
-        fn drop(&mut self) {
-            self.0.fetch_add(1, Ordering::SeqCst);
-        }
-    }
-    let num_drops = Arc::new(AtomicUsize::new(0));
-    let m = RwLock::new(Foo(num_drops.clone()));
-    assert_eq!(num_drops.load(Ordering::SeqCst), 0);
-    {
-        let _inner = m.into_inner().unwrap();
-        assert_eq!(num_drops.load(Ordering::SeqCst), 0);
-    }
-    assert_eq!(num_drops.load(Ordering::SeqCst), 1);
-}
-
-#[test]
-fn test_into_inner_poison() {
-    let m = new_poisoned_rwlock(NonCopy(10));
-
-    match m.into_inner() {
-        Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
-        Ok(x) => panic!("into_inner of poisoned RwLock is Ok: {x:?}"),
-    }
-}
-
-#[test]
-fn test_get_cloned() {
-    let m = RwLock::new(Cloneable(10));
-
-    assert_eq!(m.get_cloned().unwrap(), Cloneable(10));
-}
-
-#[test]
-fn test_get_cloned_poison() {
-    let m = new_poisoned_rwlock(Cloneable(10));
-
-    match m.get_cloned() {
-        Err(e) => assert_eq!(e.into_inner(), ()),
-        Ok(x) => panic!("get of poisoned RwLock is Ok: {x:?}"),
-    }
-}
-
-#[test]
-fn test_get_mut() {
-    let mut m = RwLock::new(NonCopy(10));
-    *m.get_mut().unwrap() = NonCopy(20);
-    assert_eq!(m.into_inner().unwrap(), NonCopy(20));
-}
-
-#[test]
-fn test_get_mut_poison() {
-    let mut m = new_poisoned_rwlock(NonCopy(10));
-
-    match m.get_mut() {
-        Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
-        Ok(x) => panic!("get_mut of poisoned RwLock is Ok: {x:?}"),
-    }
-}
-
-#[test]
-fn test_set() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = RwLock::new(init());
-
-        assert_eq!(*m.read().unwrap(), init());
-        m.set(value()).unwrap();
-        assert_eq!(*m.read().unwrap(), value());
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_set_poison() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = new_poisoned_rwlock(init());
-
-        match m.set(value()) {
-            Err(e) => {
-                assert_eq!(e.into_inner(), value());
-                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
-            }
-            Ok(x) => panic!("set of poisoned RwLock is Ok: {x:?}"),
-        }
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_replace() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = RwLock::new(init());
-
-        assert_eq!(*m.read().unwrap(), init());
-        assert_eq!(m.replace(value()).unwrap(), init());
-        assert_eq!(*m.read().unwrap(), value());
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_replace_poison() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = new_poisoned_rwlock(init());
-
-        match m.replace(value()) {
-            Err(e) => {
-                assert_eq!(e.into_inner(), value());
-                assert_eq!(m.into_inner().unwrap_err().into_inner(), init());
-            }
-            Ok(x) => panic!("replace of poisoned RwLock is Ok: {x:?}"),
-        }
-    }
-
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
-
-#[test]
-fn test_read_guard_covariance() {
-    fn do_stuff<'a>(_: RwLockReadGuard<'_, &'a i32>, _: &'a i32) {}
-    let j: i32 = 5;
-    let lock = RwLock::new(&j);
-    {
-        let i = 6;
-        do_stuff(lock.read().unwrap(), &i);
-    }
-    drop(lock);
-}
-
-#[test]
-fn test_mapped_read_guard_covariance() {
-    fn do_stuff<'a>(_: MappedRwLockReadGuard<'_, &'a i32>, _: &'a i32) {}
-    let j: i32 = 5;
-    let lock = RwLock::new((&j, &j));
-    {
-        let i = 6;
-        let guard = lock.read().unwrap();
-        let guard = RwLockReadGuard::map(guard, |(val, _val)| val);
-        do_stuff(guard, &i);
-    }
-    drop(lock);
-}
-
-#[test]
-fn test_mapping_mapped_guard() {
-    let arr = [0; 4];
-    let mut lock = RwLock::new(arr);
-    let guard = lock.write().unwrap();
-    let guard = RwLockWriteGuard::map(guard, |arr| &mut arr[..2]);
-    let mut guard = MappedRwLockWriteGuard::map(guard, |slice| &mut slice[1..]);
-    assert_eq!(guard.len(), 1);
-    guard[0] = 42;
-    drop(guard);
-    assert_eq!(*lock.get_mut().unwrap(), [0, 42, 0, 0]);
-
-    let guard = lock.read().unwrap();
-    let guard = RwLockReadGuard::map(guard, |arr| &arr[..2]);
-    let guard = MappedRwLockReadGuard::map(guard, |slice| &slice[1..]);
-    assert_eq!(*guard, [42]);
-    drop(guard);
-    assert_eq!(*lock.get_mut().unwrap(), [0, 42, 0, 0]);
-}
-
-#[test]
-fn panic_while_mapping_read_unlocked_no_poison() {
-    let lock = RwLock::new(());
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.read().unwrap();
-        let _guard = RwLockReadGuard::map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => {}
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a RwLockReadGuard::map closure should release the read lock")
-        }
-        Err(TryLockError::Poisoned(_)) => {
-            panic!("panicking in a RwLockReadGuard::map closure should not poison the RwLock")
-        }
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.read().unwrap();
-        let _guard = RwLockReadGuard::try_map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => {}
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a RwLockReadGuard::try_map closure should release the read lock")
-        }
-        Err(TryLockError::Poisoned(_)) => {
-            panic!("panicking in a RwLockReadGuard::try_map closure should not poison the RwLock")
-        }
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.read().unwrap();
-        let guard = RwLockReadGuard::map::<(), _>(guard, |val| val);
-        let _guard = MappedRwLockReadGuard::map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => {}
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a MappedRwLockReadGuard::map closure should release the read lock")
-        }
-        Err(TryLockError::Poisoned(_)) => {
-            panic!("panicking in a MappedRwLockReadGuard::map closure should not poison the RwLock")
-        }
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.read().unwrap();
-        let guard = RwLockReadGuard::map::<(), _>(guard, |val| val);
-        let _guard = MappedRwLockReadGuard::try_map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => {}
-        Err(TryLockError::WouldBlock) => panic!(
-            "panicking in a MappedRwLockReadGuard::try_map closure should release the read lock"
-        ),
-        Err(TryLockError::Poisoned(_)) => panic!(
-            "panicking in a MappedRwLockReadGuard::try_map closure should not poison the RwLock"
-        ),
-    }
-
-    drop(lock);
-}
-
-#[test]
-fn panic_while_mapping_write_unlocked_poison() {
-    let lock = RwLock::new(());
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.write().unwrap();
-        let _guard = RwLockWriteGuard::map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => panic!("panicking in a RwLockWriteGuard::map closure should poison the RwLock"),
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a RwLockWriteGuard::map closure should release the write lock")
-        }
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.write().unwrap();
-        let _guard = RwLockWriteGuard::try_map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => {
-            panic!("panicking in a RwLockWriteGuard::try_map closure should poison the RwLock")
-        }
-        Err(TryLockError::WouldBlock) => {
-            panic!("panicking in a RwLockWriteGuard::try_map closure should release the write lock")
-        }
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.write().unwrap();
-        let guard = RwLockWriteGuard::map::<(), _>(guard, |val| val);
-        let _guard = MappedRwLockWriteGuard::map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => {
-            panic!("panicking in a MappedRwLockWriteGuard::map closure should poison the RwLock")
-        }
-        Err(TryLockError::WouldBlock) => panic!(
-            "panicking in a MappedRwLockWriteGuard::map closure should release the write lock"
-        ),
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    let _ = panic::catch_unwind(|| {
-        let guard = lock.write().unwrap();
-        let guard = RwLockWriteGuard::map::<(), _>(guard, |val| val);
-        let _guard = MappedRwLockWriteGuard::try_map::<(), _>(guard, |_| panic!());
-    });
-
-    match lock.try_write() {
-        Ok(_) => panic!(
-            "panicking in a MappedRwLockWriteGuard::try_map closure should poison the RwLock"
-        ),
-        Err(TryLockError::WouldBlock) => panic!(
-            "panicking in a MappedRwLockWriteGuard::try_map closure should release the write lock"
-        ),
-        Err(TryLockError::Poisoned(_)) => {}
-    }
-
-    drop(lock);
-}
-
-#[test]
-fn test_downgrade_basic() {
-    let r = RwLock::new(());
-
-    let write_guard = r.write().unwrap();
-    let _read_guard = RwLockWriteGuard::downgrade(write_guard);
-}
-
-#[test]
-// FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
-// See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
-fn test_downgrade_observe() {
-    // Taken from the test `test_rwlock_downgrade` from:
-    // https://github.com/Amanieu/parking_lot/blob/master/src/rwlock.rs
-
-    const W: usize = 20;
-    const N: usize = if cfg!(miri) { 40 } else { 100 };
-
-    // This test spawns `W` writer threads, where each will increment a counter `N` times, ensuring
-    // that the value they wrote has not changed after downgrading.
-
-    let rw = Arc::new(RwLock::new(0));
-
-    // Spawn the writers that will do `W * N` operations and checks.
-    let handles: Vec<_> = (0..W)
-        .map(|_| {
-            let rw = rw.clone();
-            thread::spawn(move || {
-                for _ in 0..N {
-                    // Increment the counter.
-                    let mut write_guard = rw.write().unwrap();
-                    *write_guard += 1;
-                    let cur_val = *write_guard;
-
-                    // Downgrade the lock to read mode, where the value protected cannot be modified.
-                    let read_guard = RwLockWriteGuard::downgrade(write_guard);
-                    assert_eq!(cur_val, *read_guard);
-                }
-            })
-        })
-        .collect();
-
-    for handle in handles {
-        handle.join().unwrap();
-    }
-
-    assert_eq!(*rw.read().unwrap(), W * N);
-}
-
-#[test]
-// FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
-// See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
-fn test_downgrade_atomic() {
-    const NEW_VALUE: i32 = -1;
-
-    // This test checks that `downgrade` is atomic, meaning as soon as a write lock has been
-    // downgraded, the lock must be in read mode and no other threads can take the write lock to
-    // modify the protected value.
-
-    // `W` is the number of evil writer threads.
-    const W: usize = 20;
-    let rwlock = Arc::new(RwLock::new(0));
-
-    // Spawns many evil writer threads that will try and write to the locked value before the
-    // initial writer (who has the exclusive lock) can read after it downgrades.
-    // If the `RwLock` behaves correctly, then the initial writer should read the value it wrote
-    // itself as no other thread should be able to mutate the protected value.
-
-    // Put the lock in write mode, causing all future threads trying to access this go to sleep.
-    let mut main_write_guard = rwlock.write().unwrap();
-
-    // Spawn all of the evil writer threads. They will each increment the protected value by 1.
-    let handles: Vec<_> = (0..W)
-        .map(|_| {
-            let rwlock = rwlock.clone();
-            thread::spawn(move || {
-                // Will go to sleep since the main thread initially has the write lock.
-                let mut evil_guard = rwlock.write().unwrap();
-                *evil_guard += 1;
-            })
-        })
-        .collect();
-
-    // Wait for a good amount of time so that evil threads go to sleep.
-    // Note: this is not strictly necessary...
-    let eternity = crate::time::Duration::from_millis(42);
-    thread::sleep(eternity);
-
-    // Once everyone is asleep, set the value to `NEW_VALUE`.
-    *main_write_guard = NEW_VALUE;
-
-    // Atomically downgrade the write guard into a read guard.
-    let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);
-
-    // If the above is not atomic, then it would be possible for an evil thread to get in front of
-    // this read and change the value to be non-negative.
-    assert_eq!(*main_read_guard, NEW_VALUE, "`downgrade` was not atomic");
-
-    // Drop the main read guard and allow the evil writer threads to start incrementing.
-    drop(main_read_guard);
-
-    for handle in handles {
-        handle.join().unwrap();
-    }
-
-    let final_check = rwlock.read().unwrap();
-    assert_eq!(*final_check, W as i32 + NEW_VALUE);
-}
diff --git a/library/std/src/sys/sync/once/futex.rs b/library/std/src/sys/sync/once/futex.rs
index 10bfa81a6d7..539f0fe89ea 100644
--- a/library/std/src/sys/sync/once/futex.rs
+++ b/library/std/src/sys/sync/once/futex.rs
@@ -1,7 +1,7 @@
 use crate::cell::Cell;
 use crate::sync as public;
 use crate::sync::atomic::Ordering::{Acquire, Relaxed, Release};
-use crate::sync::once::ExclusiveState;
+use crate::sync::poison::once::ExclusiveState;
 use crate::sys::futex::{Futex, Primitive, futex_wait, futex_wake_all};
 
 // On some platforms, the OS is very nice and handles the waiter queue for us.
diff --git a/library/std/src/sys/sync/once/no_threads.rs b/library/std/src/sys/sync/once/no_threads.rs
index 88a1d50361e..2568059cfe3 100644
--- a/library/std/src/sys/sync/once/no_threads.rs
+++ b/library/std/src/sys/sync/once/no_threads.rs
@@ -1,6 +1,6 @@
 use crate::cell::Cell;
 use crate::sync as public;
-use crate::sync::once::ExclusiveState;
+use crate::sync::poison::once::ExclusiveState;
 
 pub struct Once {
     state: Cell<State>,
diff --git a/library/std/src/sys/sync/once/queue.rs b/library/std/src/sys/sync/once/queue.rs
index 5beff4ce683..fde1e0ca510 100644
--- a/library/std/src/sys/sync/once/queue.rs
+++ b/library/std/src/sys/sync/once/queue.rs
@@ -58,7 +58,7 @@
 use crate::cell::Cell;
 use crate::sync::atomic::Ordering::{AcqRel, Acquire, Release};
 use crate::sync::atomic::{AtomicBool, AtomicPtr};
-use crate::sync::once::ExclusiveState;
+use crate::sync::poison::once::ExclusiveState;
 use crate::thread::{self, Thread};
 use crate::{fmt, ptr, sync as public};
 
diff --git a/tests/debuginfo/mutex.rs b/tests/debuginfo/mutex.rs
index 4f458c0d7e0..c47e3ac6dce 100644
--- a/tests/debuginfo/mutex.rs
+++ b/tests/debuginfo/mutex.rs
@@ -9,7 +9,7 @@
 // cdb-command:g
 //
 // cdb-command:dx m,d
-// cdb-check:m,d              [Type: std::sync::mutex::Mutex<i32>]
+// cdb-check:m,d              [Type: std::sync::poison::mutex::Mutex<i32>]
 // cdb-check:    [...] inner            [Type: std::sys::sync::mutex::futex::Mutex]
 // cdb-check:    [...] poison           [Type: std::sync::poison::Flag]
 // cdb-check:    [...] data             : 0 [Type: core::cell::UnsafeCell<i32>]
@@ -21,8 +21,8 @@
 
 //
 // cdb-command:dx _lock,d
-// cdb-check:_lock,d          : Ok [Type: enum2$<core::result::Result<std::sync::mutex::MutexGuard<i32>,enum2$<std::sync::poison::TryLockError<std::sync::mutex::MutexGuard<i32> > > > >]
-// cdb-check:    [...] __0              [Type: std::sync::mutex::MutexGuard<i32>]
+// cdb-check:_lock,d          : Ok [Type: enum2$<core::result::Result<std::sync::poison::mutex::MutexGuard<i32>,enum2$<std::sync::poison::TryLockError<std::sync::poison::mutex::MutexGuard<i32> > > > >]
+// cdb-check:    [...] __0              [Type: std::sync::poison::mutex::MutexGuard<i32>]
 
 use std::sync::Mutex;
 
diff --git a/tests/debuginfo/rwlock-read.rs b/tests/debuginfo/rwlock-read.rs
index 3fd6ac33726..825cdbe5510 100644
--- a/tests/debuginfo/rwlock-read.rs
+++ b/tests/debuginfo/rwlock-read.rs
@@ -9,12 +9,12 @@
 // cdb-command:g
 //
 // cdb-command:dx l
-// cdb-check:l                [Type: std::sync::rwlock::RwLock<i32>]
+// cdb-check:l                [Type: std::sync::poison::rwlock::RwLock<i32>]
 // cdb-check:    [...] poison           [Type: std::sync::poison::Flag]
 // cdb-check:    [...] data             : 0 [Type: core::cell::UnsafeCell<i32>]
 //
 // cdb-command:dx r
-// cdb-check:r                [Type: std::sync::rwlock::RwLockReadGuard<i32>]
+// cdb-check:r                [Type: std::sync::poison::rwlock::RwLockReadGuard<i32>]
 // cdb-check:    [...] data             : NonNull([...]: 0) [Type: core::ptr::non_null::NonNull<i32>]
 // cdb-check:    [...] inner_lock       : [...] [Type: std::sys::sync::rwlock::futex::RwLock *]
 
diff --git a/tests/debuginfo/rwlock-write.rs b/tests/debuginfo/rwlock-write.rs
index d7864303666..aaca048b8a7 100644
--- a/tests/debuginfo/rwlock-write.rs
+++ b/tests/debuginfo/rwlock-write.rs
@@ -9,8 +9,8 @@
 // cdb-command:g
 //
 // cdb-command:dx w
-// cdb-check:w                [Type: std::sync::rwlock::RwLockWriteGuard<i32>]
-// cdb-check:    [...] lock             : [...] [Type: std::sync::rwlock::RwLock<i32> *]
+// cdb-check:w                [Type: std::sync::poison::rwlock::RwLockWriteGuard<i32>]
+// cdb-check:    [...] lock             : [...] [Type: std::sync::poison::rwlock::RwLock<i32> *]
 // cdb-check:    [...] poison           [Type: std::sync::poison::Guard]
 
 #[allow(unused_variables)]
diff --git a/tests/ui/traits/const-traits/span-bug-issue-121418.stderr b/tests/ui/traits/const-traits/span-bug-issue-121418.stderr
index fe1e5e558b2..f41c19b4573 100644
--- a/tests/ui/traits/const-traits/span-bug-issue-121418.stderr
+++ b/tests/ui/traits/const-traits/span-bug-issue-121418.stderr
@@ -27,7 +27,7 @@ LL |     pub const fn new() -> std::sync::Mutex<dyn T> {}
    |
    = help: within `Mutex<(dyn T + 'static)>`, the trait `Sized` is not implemented for `(dyn T + 'static)`
 note: required because it appears within the type `Mutex<(dyn T + 'static)>`
-  --> $SRC_DIR/std/src/sync/mutex.rs:LL:COL
+  --> $SRC_DIR/std/src/sync/poison/mutex.rs:LL:COL
    = note: the return type of a function must have a statically known size
 
 error: aborting due to 3 previous errors
diff --git a/tests/ui/typeck/assign-non-lval-derefmut.stderr b/tests/ui/typeck/assign-non-lval-derefmut.stderr
index ce0ff1d957b..16fb1e9c5c3 100644
--- a/tests/ui/typeck/assign-non-lval-derefmut.stderr
+++ b/tests/ui/typeck/assign-non-lval-derefmut.stderr
@@ -20,7 +20,7 @@ LL |     x.lock().unwrap() += 1;
    |     cannot use `+=` on type `MutexGuard<'_, usize>`
    |
 note: the foreign item type `MutexGuard<'_, usize>` doesn't implement `AddAssign<{integer}>`
-  --> $SRC_DIR/std/src/sync/mutex.rs:LL:COL
+  --> $SRC_DIR/std/src/sync/poison/mutex.rs:LL:COL
    |
    = note: not implement `AddAssign<{integer}>`
 help: `+=` can be used on `usize` if you dereference the left-hand side
@@ -52,7 +52,7 @@ LL |     y += 1;
    |     cannot use `+=` on type `MutexGuard<'_, usize>`
    |
 note: the foreign item type `MutexGuard<'_, usize>` doesn't implement `AddAssign<{integer}>`
-  --> $SRC_DIR/std/src/sync/mutex.rs:LL:COL
+  --> $SRC_DIR/std/src/sync/poison/mutex.rs:LL:COL
    |
    = note: not implement `AddAssign<{integer}>`
 help: `+=` can be used on `usize` if you dereference the left-hand side
-- 
cgit 1.4.1-3-g733a5


From e8a4792b3e5ffa85453451ba27026de3a48c1581 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Tue, 17 Sep 2024 23:55:53 +0200
Subject: Make the `test` cfg a "userspace" check-cfg

---
 compiler/rustc_session/src/config/cfg.rs              |  7 +++++--
 src/doc/rustc/src/check-cfg.md                        |  6 ++++--
 src/tools/compiletest/src/runtest.rs                  |  5 +++--
 tests/ui/check-cfg/allow-same-level.stderr            |  2 +-
 tests/ui/check-cfg/cargo-build-script.stderr          |  2 +-
 tests/ui/check-cfg/cargo-feature.none.stderr          |  2 +-
 tests/ui/check-cfg/cargo-feature.some.stderr          |  2 +-
 .../check-cfg/cfg-value-for-cfg-name-duplicate.stderr |  2 +-
 .../check-cfg/cfg-value-for-cfg-name-multiple.stderr  |  2 +-
 tests/ui/check-cfg/cfg-value-for-cfg-name.stderr      |  2 +-
 tests/ui/check-cfg/compact-names.stderr               |  2 +-
 .../exhaustive-names-values.empty_cfg.stderr          | 10 ++++------
 .../check-cfg/exhaustive-names-values.feature.stderr  | 10 ++++------
 .../ui/check-cfg/exhaustive-names-values.full.stderr  | 10 ++++------
 tests/ui/check-cfg/exhaustive-names-values.rs         |  2 +-
 tests/ui/check-cfg/exhaustive-names.stderr            |  2 +-
 tests/ui/check-cfg/exhaustive-values.empty_cfg.stderr |  4 ++--
 tests/ui/check-cfg/exhaustive-values.rs               |  2 +-
 .../check-cfg/exhaustive-values.without_names.stderr  |  4 ++--
 tests/ui/check-cfg/mix.rs                             |  2 +-
 tests/ui/check-cfg/mix.stderr                         |  4 ++--
 tests/ui/check-cfg/no-expected-values.empty.stderr    |  1 +
 tests/ui/check-cfg/no-expected-values.mixed.stderr    |  1 +
 tests/ui/check-cfg/no-expected-values.simple.stderr   |  1 +
 tests/ui/check-cfg/raw-keywords.edition2015.stderr    |  2 +-
 tests/ui/check-cfg/raw-keywords.edition2021.stderr    |  2 +-
 .../check-cfg/report-in-external-macros.cargo.stderr  |  2 +-
 .../check-cfg/report-in-external-macros.rustc.stderr  |  2 +-
 tests/ui/check-cfg/stmt-no-ice.stderr                 |  2 +-
 tests/ui/check-cfg/unexpected-cfg-name.rs             |  3 +++
 tests/ui/check-cfg/unexpected-cfg-name.stderr         | 12 +++++++++++-
 tests/ui/check-cfg/well-known-names.stderr            |  2 +-
 tests/ui/check-cfg/well-known-values.rs               |  2 --
 tests/ui/check-cfg/well-known-values.stderr           | 19 ++++---------------
 34 files changed, 69 insertions(+), 66 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index 3426858495b..b68dfeffa34 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -332,6 +332,11 @@ impl CheckCfg {
         // Note that symbols inserted conditionally in `default_configuration`
         // are inserted unconditionally here.
         //
+        // One exception is the `test` cfg which is consider to be a "user-space"
+        // cfg, despite being also set by in `default_configuration` above.
+        // It allows the build system to "deny" using the config by not marking it
+        // as expected (e.g. `lib.test = false` for Cargo).
+        //
         // When adding a new config here you should also update
         // `tests/ui/check-cfg/well-known-values.rs` (in order to test the
         // expected values of the new config) and bless the all directory.
@@ -453,8 +458,6 @@ impl CheckCfg {
 
         ins!(sym::target_thread_local, no_values);
 
-        ins!(sym::test, no_values);
-
         ins!(sym::ub_checks, no_values);
 
         ins!(sym::unix, no_values);
diff --git a/src/doc/rustc/src/check-cfg.md b/src/doc/rustc/src/check-cfg.md
index 992f14a79bf..f7e831dc8bd 100644
--- a/src/doc/rustc/src/check-cfg.md
+++ b/src/doc/rustc/src/check-cfg.md
@@ -99,7 +99,7 @@ the need to specify them manually.
 Well known names and values are implicitly added as long as at least one `--check-cfg` argument
 is present.
 
-As of `2024-08-20T`, the list of known names is as follows:
+As of `2025-01-02T`, the list of known names is as follows:
 
 <!--- See CheckCfg::fill_well_known in compiler/rustc_session/src/config.rs -->
 
@@ -130,11 +130,13 @@ As of `2024-08-20T`, the list of known names is as follows:
  - `target_pointer_width`
  - `target_thread_local`
  - `target_vendor`
- - `test`
  - `ub_checks`
  - `unix`
  - `windows`
 
+> Starting with CURRENT_RUSTC_VERSION, the `test` cfg is consider to be a "userspace" config
+> despite being also set by `rustc` and should be managed by the build-system it-self.
+
 Like with `values(any())`, well known names checking can be disabled by passing `cfg(any())`
 as argument to `--check-cfg`.
 
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 7084c407a64..9e8443cd13c 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -506,8 +506,9 @@ impl<'test> TestCx<'test> {
             // Generate `cfg(FALSE, REV1, ..., REVN)` (for all possible revisions)
             //
             // For compatibility reason we consider the `FALSE` cfg to be expected
-            // since it is extensively used in the testsuite.
-            check_cfg.push_str("cfg(FALSE");
+            // since it is extensively used in the testsuite, as well as the `test`
+            // cfg since we have tests that uses it.
+            check_cfg.push_str("cfg(test,FALSE");
             for revision in &self.props.revisions {
                 check_cfg.push(',');
                 check_cfg.push_str(&normalize_revision(revision));
diff --git a/tests/ui/check-cfg/allow-same-level.stderr b/tests/ui/check-cfg/allow-same-level.stderr
index b1a9c5810d8..5d74b211654 100644
--- a/tests/ui/check-cfg/allow-same-level.stderr
+++ b/tests/ui/check-cfg/allow-same-level.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `FALSE`
 LL | #[cfg(FALSE)]
    |       ^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(FALSE)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/cargo-build-script.stderr b/tests/ui/check-cfg/cargo-build-script.stderr
index 0b01b1da5a7..fb48751bc1d 100644
--- a/tests/ui/check-cfg/cargo-build-script.stderr
+++ b/tests/ui/check-cfg/cargo-build-script.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `has_foo`
 LL | #[cfg(has_foo)]
    |       ^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `has_bar`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `has_bar`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
diff --git a/tests/ui/check-cfg/cargo-feature.none.stderr b/tests/ui/check-cfg/cargo-feature.none.stderr
index 6de6e9a6851..aa2a1ab8fb2 100644
--- a/tests/ui/check-cfg/cargo-feature.none.stderr
+++ b/tests/ui/check-cfg/cargo-feature.none.stderr
@@ -25,7 +25,7 @@ warning: unexpected `cfg` condition name: `tokio_unstable`
 LL | #[cfg(tokio_unstable)]
    |       ^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
diff --git a/tests/ui/check-cfg/cargo-feature.some.stderr b/tests/ui/check-cfg/cargo-feature.some.stderr
index d4a7f6defb2..c3ba123985b 100644
--- a/tests/ui/check-cfg/cargo-feature.some.stderr
+++ b/tests/ui/check-cfg/cargo-feature.some.stderr
@@ -25,7 +25,7 @@ warning: unexpected `cfg` condition name: `tokio_unstable`
 LL | #[cfg(tokio_unstable)]
    |       ^^^^^^^^^^^^^^
    |
-   = help: expected names are: `CONFIG_NVME`, `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `CONFIG_NVME`, `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
diff --git a/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr b/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr
index 831722a12e2..b7dc27f9ba9 100644
--- a/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr
+++ b/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `value`
 LL | #[cfg(value)]
    |       ^^^^^
    |
-   = help: expected names are: `bar`, `bee`, `clippy`, `cow`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `bar`, `bee`, `clippy`, `cow`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(value)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr b/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr
index a35a8d68def..d2af81d7787 100644
--- a/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr
+++ b/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `my_value`
 LL | #[cfg(my_value)]
    |       ^^^^^^^^
    |
-   = help: expected names are: `bar`, `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `bar`, `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(my_value)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr b/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr
index 65a73ffcd1d..85bf66eb10c 100644
--- a/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr
+++ b/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `linux`
 LL | #[cfg(linux)]
    |       ^^^^^ help: found config with similar value: `target_os = "linux"`
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(linux)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/compact-names.stderr b/tests/ui/check-cfg/compact-names.stderr
index 536c992ee92..ef0a413bd0d 100644
--- a/tests/ui/check-cfg/compact-names.stderr
+++ b/tests/ui/check-cfg/compact-names.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `target_architecture`
 LL | #[cfg(target(os = "linux", architecture = "arm"))]
    |                            ^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(target_architecture, values("arm"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
index 6c26a8b11d9..d49ed3e7551 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `unknown_key`
 LL | #[cfg(unknown_key = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
@@ -12,12 +12,10 @@ LL | #[cfg(unknown_key = "value")]
 warning: unexpected `cfg` condition value: `value`
   --> $DIR/exhaustive-names-values.rs:14:7
    |
-LL | #[cfg(test = "value")]
-   |       ^^^^----------
-   |           |
-   |           help: remove the value
+LL | #[cfg(target_vendor = "value")]
+   |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: no expected value for `test`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition name: `feature`
diff --git a/tests/ui/check-cfg/exhaustive-names-values.feature.stderr b/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
index b7ccf5e5f83..81dbbca4f86 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `unknown_key`
 LL | #[cfg(unknown_key = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
@@ -12,12 +12,10 @@ LL | #[cfg(unknown_key = "value")]
 warning: unexpected `cfg` condition value: `value`
   --> $DIR/exhaustive-names-values.rs:14:7
    |
-LL | #[cfg(test = "value")]
-   |       ^^^^----------
-   |           |
-   |           help: remove the value
+LL | #[cfg(target_vendor = "value")]
+   |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: no expected value for `test`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `unk`
diff --git a/tests/ui/check-cfg/exhaustive-names-values.full.stderr b/tests/ui/check-cfg/exhaustive-names-values.full.stderr
index b7ccf5e5f83..81dbbca4f86 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.full.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.full.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `unknown_key`
 LL | #[cfg(unknown_key = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
@@ -12,12 +12,10 @@ LL | #[cfg(unknown_key = "value")]
 warning: unexpected `cfg` condition value: `value`
   --> $DIR/exhaustive-names-values.rs:14:7
    |
-LL | #[cfg(test = "value")]
-   |       ^^^^----------
-   |           |
-   |           help: remove the value
+LL | #[cfg(target_vendor = "value")]
+   |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: no expected value for `test`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `unk`
diff --git a/tests/ui/check-cfg/exhaustive-names-values.rs b/tests/ui/check-cfg/exhaustive-names-values.rs
index 7b2d89b5781..772c78288f8 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.rs
+++ b/tests/ui/check-cfg/exhaustive-names-values.rs
@@ -11,7 +11,7 @@
 //~^ WARNING unexpected `cfg` condition name
 pub fn f() {}
 
-#[cfg(test = "value")]
+#[cfg(target_vendor = "value")]
 //~^ WARNING unexpected `cfg` condition value
 pub fn f() {}
 
diff --git a/tests/ui/check-cfg/exhaustive-names.stderr b/tests/ui/check-cfg/exhaustive-names.stderr
index 5350534f3e8..d134cfcfd29 100644
--- a/tests/ui/check-cfg/exhaustive-names.stderr
+++ b/tests/ui/check-cfg/exhaustive-names.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `unknown_key`
 LL | #[cfg(unknown_key = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/exhaustive-values.empty_cfg.stderr b/tests/ui/check-cfg/exhaustive-values.empty_cfg.stderr
index a3c0f36aee8..713451dac2e 100644
--- a/tests/ui/check-cfg/exhaustive-values.empty_cfg.stderr
+++ b/tests/ui/check-cfg/exhaustive-values.empty_cfg.stderr
@@ -1,12 +1,12 @@
 warning: unexpected `cfg` condition value: `value`
   --> $DIR/exhaustive-values.rs:9:7
    |
-LL | #[cfg(test = "value")]
+LL | #[cfg(unix = "value")]
    |       ^^^^----------
    |           |
    |           help: remove the value
    |
-   = note: no expected value for `test`
+   = note: no expected value for `unix`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
 
diff --git a/tests/ui/check-cfg/exhaustive-values.rs b/tests/ui/check-cfg/exhaustive-values.rs
index b4ce2ac98dc..be7fa10f8f6 100644
--- a/tests/ui/check-cfg/exhaustive-values.rs
+++ b/tests/ui/check-cfg/exhaustive-values.rs
@@ -6,7 +6,7 @@
 //@ [empty_cfg]compile-flags: --check-cfg=cfg()
 //@ [without_names]compile-flags: --check-cfg=cfg(any())
 
-#[cfg(test = "value")]
+#[cfg(unix = "value")]
 //~^ WARNING unexpected `cfg` condition value
 pub fn f() {}
 
diff --git a/tests/ui/check-cfg/exhaustive-values.without_names.stderr b/tests/ui/check-cfg/exhaustive-values.without_names.stderr
index a3c0f36aee8..713451dac2e 100644
--- a/tests/ui/check-cfg/exhaustive-values.without_names.stderr
+++ b/tests/ui/check-cfg/exhaustive-values.without_names.stderr
@@ -1,12 +1,12 @@
 warning: unexpected `cfg` condition value: `value`
   --> $DIR/exhaustive-values.rs:9:7
    |
-LL | #[cfg(test = "value")]
+LL | #[cfg(unix = "value")]
    |       ^^^^----------
    |           |
    |           help: remove the value
    |
-   = note: no expected value for `test`
+   = note: no expected value for `unix`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
 
diff --git a/tests/ui/check-cfg/mix.rs b/tests/ui/check-cfg/mix.rs
index e9a2de2f672..198bf828a2d 100644
--- a/tests/ui/check-cfg/mix.rs
+++ b/tests/ui/check-cfg/mix.rs
@@ -29,7 +29,7 @@ fn use_bar() {}
 //~^ WARNING unexpected `cfg` condition value
 fn use_zebra() {}
 
-#[cfg_attr(uu, test)]
+#[cfg_attr(uu, unix)]
 //~^ WARNING unexpected `cfg` condition name
 fn do_test() {}
 
diff --git a/tests/ui/check-cfg/mix.stderr b/tests/ui/check-cfg/mix.stderr
index 231236799c6..76c7befd6d3 100644
--- a/tests/ui/check-cfg/mix.stderr
+++ b/tests/ui/check-cfg/mix.stderr
@@ -41,10 +41,10 @@ LL | #[cfg(feature = "zebra")]
 warning: unexpected `cfg` condition name: `uu`
   --> $DIR/mix.rs:32:12
    |
-LL | #[cfg_attr(uu, test)]
+LL | #[cfg_attr(uu, unix)]
    |            ^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(uu)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
diff --git a/tests/ui/check-cfg/no-expected-values.empty.stderr b/tests/ui/check-cfg/no-expected-values.empty.stderr
index 9c7d970f35e..f0c033b7207 100644
--- a/tests/ui/check-cfg/no-expected-values.empty.stderr
+++ b/tests/ui/check-cfg/no-expected-values.empty.stderr
@@ -20,6 +20,7 @@ LL | #[cfg(test = "foo")]
    |           help: remove the value
    |
    = note: no expected value for `test`
+   = help: to expect this configuration use `--check-cfg=cfg(test, values("foo"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: 2 warnings emitted
diff --git a/tests/ui/check-cfg/no-expected-values.mixed.stderr b/tests/ui/check-cfg/no-expected-values.mixed.stderr
index 9c7d970f35e..f0c033b7207 100644
--- a/tests/ui/check-cfg/no-expected-values.mixed.stderr
+++ b/tests/ui/check-cfg/no-expected-values.mixed.stderr
@@ -20,6 +20,7 @@ LL | #[cfg(test = "foo")]
    |           help: remove the value
    |
    = note: no expected value for `test`
+   = help: to expect this configuration use `--check-cfg=cfg(test, values("foo"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: 2 warnings emitted
diff --git a/tests/ui/check-cfg/no-expected-values.simple.stderr b/tests/ui/check-cfg/no-expected-values.simple.stderr
index 9c7d970f35e..f0c033b7207 100644
--- a/tests/ui/check-cfg/no-expected-values.simple.stderr
+++ b/tests/ui/check-cfg/no-expected-values.simple.stderr
@@ -20,6 +20,7 @@ LL | #[cfg(test = "foo")]
    |           help: remove the value
    |
    = note: no expected value for `test`
+   = help: to expect this configuration use `--check-cfg=cfg(test, values("foo"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: 2 warnings emitted
diff --git a/tests/ui/check-cfg/raw-keywords.edition2015.stderr b/tests/ui/check-cfg/raw-keywords.edition2015.stderr
index ab7e77686ee..3ad8ebac959 100644
--- a/tests/ui/check-cfg/raw-keywords.edition2015.stderr
+++ b/tests/ui/check-cfg/raw-keywords.edition2015.stderr
@@ -14,7 +14,7 @@ warning: unexpected `cfg` condition name: `r#false`
 LL | #[cfg(r#false)]
    |       ^^^^^^^
    |
-   = help: expected names are: `async`, `clippy`, `debug_assertions`, `doc`, `doctest`, `edition2015`, `edition2021`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `r#true`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `async`, `clippy`, `debug_assertions`, `doc`, `doctest`, `edition2015`, `edition2021`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `r#true`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(r#false)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
diff --git a/tests/ui/check-cfg/raw-keywords.edition2021.stderr b/tests/ui/check-cfg/raw-keywords.edition2021.stderr
index 1ae1cad4e6b..ff43a332697 100644
--- a/tests/ui/check-cfg/raw-keywords.edition2021.stderr
+++ b/tests/ui/check-cfg/raw-keywords.edition2021.stderr
@@ -14,7 +14,7 @@ warning: unexpected `cfg` condition name: `r#false`
 LL | #[cfg(r#false)]
    |       ^^^^^^^
    |
-   = help: expected names are: `r#async`, `clippy`, `debug_assertions`, `doc`, `doctest`, `edition2015`, `edition2021`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `r#true`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `r#async`, `clippy`, `debug_assertions`, `doc`, `doctest`, `edition2015`, `edition2021`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `r#true`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(r#false)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
diff --git a/tests/ui/check-cfg/report-in-external-macros.cargo.stderr b/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
index 290de4afb26..b82a09917f4 100644
--- a/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
+++ b/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `my_lib_cfg`
 LL |     cfg_macro::my_lib_macro!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
    = help: try referring to `cfg_macro::my_lib_macro` crate for guidance on how handle this unexpected cfg
    = help: the macro `cfg_macro::my_lib_macro` may come from an old version of the `cfg_macro` crate, try updating your dependency with `cargo update -p cfg_macro`
diff --git a/tests/ui/check-cfg/report-in-external-macros.rustc.stderr b/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
index e1a2a8e86c6..85d84a1e1ee 100644
--- a/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
+++ b/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `my_lib_cfg`
 LL |     cfg_macro::my_lib_macro!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
    = help: try referring to `cfg_macro::my_lib_macro` crate for guidance on how handle this unexpected cfg
    = help: to expect this configuration use `--check-cfg=cfg(my_lib_cfg)`
diff --git a/tests/ui/check-cfg/stmt-no-ice.stderr b/tests/ui/check-cfg/stmt-no-ice.stderr
index 98f09a648bc..d8c6b0f3cec 100644
--- a/tests/ui/check-cfg/stmt-no-ice.stderr
+++ b/tests/ui/check-cfg/stmt-no-ice.stderr
@@ -4,7 +4,7 @@ warning: unexpected `cfg` condition name: `crossbeam_loom`
 LL |     #[cfg(crossbeam_loom)]
    |           ^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(crossbeam_loom)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/unexpected-cfg-name.rs b/tests/ui/check-cfg/unexpected-cfg-name.rs
index 8178df8b87c..af91db745e8 100644
--- a/tests/ui/check-cfg/unexpected-cfg-name.rs
+++ b/tests/ui/check-cfg/unexpected-cfg-name.rs
@@ -8,6 +8,9 @@
 //~^ WARNING unexpected `cfg` condition name
 pub fn f() {}
 
+#[cfg(test)]
+//~^ WARNING unexpected `cfg` condition name
+
 #[cfg(windows)]
 pub fn g() {}
 
diff --git a/tests/ui/check-cfg/unexpected-cfg-name.stderr b/tests/ui/check-cfg/unexpected-cfg-name.stderr
index c652c8e27bc..4ca7209cc07 100644
--- a/tests/ui/check-cfg/unexpected-cfg-name.stderr
+++ b/tests/ui/check-cfg/unexpected-cfg-name.stderr
@@ -8,5 +8,15 @@ LL | #[cfg(widnows)]
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
 
-warning: 1 warning emitted
+warning: unexpected `cfg` condition name: `test`
+  --> $DIR/unexpected-cfg-name.rs:11:7
+   |
+LL | #[cfg(test)]
+   |       ^^^^
+   |
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
+   = help: to expect this configuration use `--check-cfg=cfg(test)`
+   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+
+warning: 2 warnings emitted
 
diff --git a/tests/ui/check-cfg/well-known-names.stderr b/tests/ui/check-cfg/well-known-names.stderr
index abcf53cfe30..61d518627ba 100644
--- a/tests/ui/check-cfg/well-known-names.stderr
+++ b/tests/ui/check-cfg/well-known-names.stderr
@@ -18,7 +18,7 @@ warning: unexpected `cfg` condition name: `features`
 LL | #[cfg(features = "foo")]
    |       ^^^^^^^^^^^^^^^^
    |
-   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
+   = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `ub_checks`, `unix`, and `windows`
    = help: to expect this configuration use `--check-cfg=cfg(features, values("foo"))`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
diff --git a/tests/ui/check-cfg/well-known-values.rs b/tests/ui/check-cfg/well-known-values.rs
index 40b7b2db836..0eb749b55a7 100644
--- a/tests/ui/check-cfg/well-known-values.rs
+++ b/tests/ui/check-cfg/well-known-values.rs
@@ -76,8 +76,6 @@
     //~^ WARN unexpected `cfg` condition value
     target_vendor = "_UNEXPECTED_VALUE",
     //~^ WARN unexpected `cfg` condition value
-    test = "_UNEXPECTED_VALUE",
-    //~^ WARN unexpected `cfg` condition value
     ub_checks = "_UNEXPECTED_VALUE",
     //~^ WARN unexpected `cfg` condition value
     unix = "_UNEXPECTED_VALUE",
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index 7c03d0570db..ab69938f51a 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -236,17 +236,6 @@ LL |     target_vendor = "_UNEXPECTED_VALUE",
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
   --> $DIR/well-known-values.rs:79:5
    |
-LL |     test = "_UNEXPECTED_VALUE",
-   |     ^^^^----------------------
-   |         |
-   |         help: remove the value
-   |
-   = note: no expected value for `test`
-   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
-
-warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
-  --> $DIR/well-known-values.rs:81:5
-   |
 LL |     ub_checks = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^----------------------
    |              |
@@ -256,7 +245,7 @@ LL |     ub_checks = "_UNEXPECTED_VALUE",
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
-  --> $DIR/well-known-values.rs:83:5
+  --> $DIR/well-known-values.rs:81:5
    |
 LL |     unix = "_UNEXPECTED_VALUE",
    |     ^^^^----------------------
@@ -267,7 +256,7 @@ LL |     unix = "_UNEXPECTED_VALUE",
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
-  --> $DIR/well-known-values.rs:85:5
+  --> $DIR/well-known-values.rs:83:5
    |
 LL |     windows = "_UNEXPECTED_VALUE",
    |     ^^^^^^^----------------------
@@ -278,7 +267,7 @@ LL |     windows = "_UNEXPECTED_VALUE",
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `linuz`
-  --> $DIR/well-known-values.rs:91:7
+  --> $DIR/well-known-values.rs:89:7
    |
 LL | #[cfg(target_os = "linuz")] // testing that we suggest `linux`
    |       ^^^^^^^^^^^^-------
@@ -288,5 +277,5 @@ LL | #[cfg(target_os = "linuz")] // testing that we suggest `linux`
    = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
-warning: 29 warnings emitted
+warning: 28 warnings emitted
 
-- 
cgit 1.4.1-3-g733a5


From 93bb639ad6b02a68e1681b96351badf8b6a33fa3 Mon Sep 17 00:00:00 2001
From: Lukas Markeffsky <@>
Date: Thu, 2 Jan 2025 18:31:40 +0100
Subject: taint fcx on selection errors during unsizing

---
 compiler/rustc_hir_typeck/src/coercion.rs          |  7 ++-
 tests/crashes/130521.rs                            | 13 ----
 .../dyn-compatibility/taint-const-eval.curr.stderr | 71 ++++++++++++++++++++++
 ...t-const-eval.dyn_compatible_for_dispatch.stderr | 26 ++++++++
 tests/ui/dyn-compatibility/taint-const-eval.rs     | 16 +++++
 5 files changed, 119 insertions(+), 14 deletions(-)
 delete mode 100644 tests/crashes/130521.rs
 create mode 100644 tests/ui/dyn-compatibility/taint-const-eval.curr.stderr
 create mode 100644 tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr
 create mode 100644 tests/ui/dyn-compatibility/taint-const-eval.rs

(limited to 'tests')

diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 60e3c0166b9..bd26be11279 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -666,7 +666,12 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
                 // Dyn-compatibility violations or miscellaneous.
                 Err(err) => {
-                    self.err_ctxt().report_selection_error(obligation.clone(), &obligation, &err);
+                    let guar = self.err_ctxt().report_selection_error(
+                        obligation.clone(),
+                        &obligation,
+                        &err,
+                    );
+                    self.fcx.set_tainted_by_errors(guar);
                     // Treat this like an obligation and follow through
                     // with the unsizing - the lack of a coercion should
                     // be silent, as it causes a type mismatch later.
diff --git a/tests/crashes/130521.rs b/tests/crashes/130521.rs
deleted file mode 100644
index ebcfacf9623..00000000000
--- a/tests/crashes/130521.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #130521
-
-#![feature(dyn_compatible_for_dispatch)]
-struct Vtable(dyn Cap<'static>);
-
-trait Cap<'a> {}
-
-union Transmute {
-    t: u128,
-    u: &'static Vtable,
-}
-
-const G: &Copy = unsafe { Transmute { t: 1 }.u };
diff --git a/tests/ui/dyn-compatibility/taint-const-eval.curr.stderr b/tests/ui/dyn-compatibility/taint-const-eval.curr.stderr
new file mode 100644
index 00000000000..ef0abc16342
--- /dev/null
+++ b/tests/ui/dyn-compatibility/taint-const-eval.curr.stderr
@@ -0,0 +1,71 @@
+error[E0038]: the trait `Qux` cannot be made into an object
+  --> $DIR/taint-const-eval.rs:11:15
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |               ^^^^^^^^^^^^^^ `Qux` cannot be made into an object
+   |
+note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+  --> $DIR/taint-const-eval.rs:8:8
+   |
+LL | trait Qux {
+   |       --- this trait cannot be made into an object...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error[E0038]: the trait `Qux` cannot be made into an object
+  --> $DIR/taint-const-eval.rs:11:33
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |                                 ^^^^^^ `Qux` cannot be made into an object
+   |
+note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+  --> $DIR/taint-const-eval.rs:8:8
+   |
+LL | trait Qux {
+   |       --- this trait cannot be made into an object...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+   = note: required for the cast from `&'static str` to `&'static (dyn Qux + Sync + 'static)`
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error[E0038]: the trait `Qux` cannot be made into an object
+  --> $DIR/taint-const-eval.rs:11:15
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |               ^^^^^^^^^^^^^^ `Qux` cannot be made into an object
+   |
+note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+  --> $DIR/taint-const-eval.rs:8:8
+   |
+LL | trait Qux {
+   |       --- this trait cannot be made into an object...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr
new file mode 100644
index 00000000000..14940365d23
--- /dev/null
+++ b/tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr
@@ -0,0 +1,26 @@
+error[E0038]: the trait `Qux` cannot be made into an object
+  --> $DIR/taint-const-eval.rs:11:33
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |                                 ^^^^^^ `Qux` cannot be made into an object
+   |
+note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+  --> $DIR/taint-const-eval.rs:8:8
+   |
+LL | trait Qux {
+   |       --- this trait cannot be made into an object...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+   = note: required for the cast from `&'static str` to `&'static (dyn Qux + Sync + 'static)`
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/taint-const-eval.rs b/tests/ui/dyn-compatibility/taint-const-eval.rs
new file mode 100644
index 00000000000..9825ec0ca1c
--- /dev/null
+++ b/tests/ui/dyn-compatibility/taint-const-eval.rs
@@ -0,0 +1,16 @@
+// Test that we do not attempt to create dyn-incompatible trait objects in const eval.
+
+//@ revisions: curr dyn_compatible_for_dispatch
+
+#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
+
+trait Qux {
+    fn bar();
+}
+
+static FOO: &(dyn Qux + Sync) = "desc";
+//~^ the trait `Qux` cannot be made into an object
+//[curr]~| the trait `Qux` cannot be made into an object
+//[curr]~| the trait `Qux` cannot be made into an object
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c7cb8224e2020d30df6bceb8ea2e16e7a2594585 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 2 Jan 2025 11:58:15 -0700
Subject: rustdoc: treat `allowed_through_unstable_modules` as deprecation

This ensures `std::intrinsics::transmute` is deemphasized
in the search engine and other UI, by cleaning it into a deprecation
without propagating it through reexports when the parent module
is stable.
---
 src/librustdoc/clean/types.rs                | 22 +++++++++++++++++++++-
 src/librustdoc/passes/propagate_stability.rs |  9 +++++++++
 tests/rustdoc-js-std/core-transmute.js       | 11 +++++++++++
 tests/rustdoc-js-std/transmute-fail.js       |  3 ++-
 tests/rustdoc-js-std/transmute.js            |  3 ++-
 5 files changed, 45 insertions(+), 3 deletions(-)
 create mode 100644 tests/rustdoc-js-std/core-transmute.js

(limited to 'tests')

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 3c4fad4bca9..dcee96978d2 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -400,7 +400,27 @@ impl Item {
     }
 
     pub(crate) fn deprecation(&self, tcx: TyCtxt<'_>) -> Option<Deprecation> {
-        self.def_id().and_then(|did| tcx.lookup_deprecation(did))
+        self.def_id().and_then(|did| tcx.lookup_deprecation(did)).or_else(|| {
+            // `allowed_through_unstable_modules` is a bug-compatibility hack for old rustc
+            // versions; the paths that are exposed through it are "deprecated" because they
+            // were never supposed to work at all.
+            let stab = self.stability(tcx)?;
+            if let rustc_attr_parsing::StabilityLevel::Stable {
+                allowed_through_unstable_modules: true,
+                ..
+            } = stab.level
+            {
+                Some(Deprecation {
+                    // FIXME(#131676, #135003): when a note is added to this stability tag,
+                    // translate it here
+                    since: rustc_attr_parsing::DeprecatedSince::Unspecified,
+                    note: None,
+                    suggestion: None,
+                })
+            } else {
+                None
+            }
+        })
     }
 
     pub(crate) fn inner_docs(&self, tcx: TyCtxt<'_>) -> bool {
diff --git a/src/librustdoc/passes/propagate_stability.rs b/src/librustdoc/passes/propagate_stability.rs
index 4c682c3d4ca..9e06102bef6 100644
--- a/src/librustdoc/passes/propagate_stability.rs
+++ b/src/librustdoc/passes/propagate_stability.rs
@@ -107,6 +107,15 @@ fn merge_stability(
             || parent_stab.stable_since().is_some_and(|parent_since| parent_since > own_since))
     {
         parent_stability
+    } else if let Some(mut own_stab) = own_stability
+        && let StabilityLevel::Stable { since, allowed_through_unstable_modules: true } =
+            own_stab.level
+        && let Some(parent_stab) = parent_stability
+        && parent_stab.is_stable()
+    {
+        // this property does not apply transitively through re-exports
+        own_stab.level = StabilityLevel::Stable { since, allowed_through_unstable_modules: false };
+        Some(own_stab)
     } else {
         own_stability
     }
diff --git a/tests/rustdoc-js-std/core-transmute.js b/tests/rustdoc-js-std/core-transmute.js
new file mode 100644
index 00000000000..8c9910a32d7
--- /dev/null
+++ b/tests/rustdoc-js-std/core-transmute.js
@@ -0,0 +1,11 @@
+const FILTER_CRATE = "core";
+const EXPECTED = [
+    {
+        'query': 'generic:T -> generic:U',
+        'others': [
+            { 'path': 'core::intrinsics::simd', 'name': 'simd_as' },
+            { 'path': 'core::intrinsics::simd', 'name': 'simd_cast' },
+            { 'path': 'core::mem', 'name': 'transmute' },
+        ],
+    },
+];
diff --git a/tests/rustdoc-js-std/transmute-fail.js b/tests/rustdoc-js-std/transmute-fail.js
index c4dddf3cf3c..ddfb2761948 100644
--- a/tests/rustdoc-js-std/transmute-fail.js
+++ b/tests/rustdoc-js-std/transmute-fail.js
@@ -1,4 +1,5 @@
 // should-fail
+const FILTER_CRATE = "std";
 const EXPECTED = [
     {
         // Keep this test case identical to `transmute`, except the
@@ -7,7 +8,7 @@ const EXPECTED = [
         'others': [
             { 'path': 'std::intrinsics::simd', 'name': 'simd_as' },
             { 'path': 'std::intrinsics::simd', 'name': 'simd_cast' },
-            { 'path': 'std::intrinsics', 'name': 'transmute' },
+            { 'path': 'std::mem', 'name': 'transmute' },
         ],
     },
 ];
diff --git a/tests/rustdoc-js-std/transmute.js b/tests/rustdoc-js-std/transmute.js
index 0e52e21e0de..f52e0ab1436 100644
--- a/tests/rustdoc-js-std/transmute.js
+++ b/tests/rustdoc-js-std/transmute.js
@@ -1,3 +1,4 @@
+const FILTER_CRATE = "std";
 const EXPECTED = [
     {
         // Keep this test case identical to `transmute-fail`, except the
@@ -6,7 +7,7 @@ const EXPECTED = [
         'others': [
             { 'path': 'std::intrinsics::simd', 'name': 'simd_as' },
             { 'path': 'std::intrinsics::simd', 'name': 'simd_cast' },
-            { 'path': 'std::intrinsics', 'name': 'transmute' },
+            { 'path': 'std::mem', 'name': 'transmute' },
         ],
     },
 ];
-- 
cgit 1.4.1-3-g733a5


From 4da3aedb5e98cf9f9ce3fd33720b9d2751753dfe Mon Sep 17 00:00:00 2001
From: Noratrieb <48135649+Noratrieb@users.noreply.github.com>
Date: Thu, 2 Jan 2025 16:50:21 +0100
Subject: Pass objcopy args for stripping on OSX

When `-Cstrip` was changed to use the bundled rust-objcopy instead of
/usr/bin/strip on OSX, strip-like arguments were preserved.

But strip and objcopy are, while being the same binary, different, they
have different defaults depending on which binary they are.
Notably, strip strips everything by default, and objcopy doesn't strip
anything by default.

Additionally, `-S` actually means `--strip-all`, so debuginfo stripped
everything and symbols didn't strip anything.

We now correctly pass `--strip-debug` and `--strip-all`.
---
 compiler/rustc_codegen_ssa/src/back/link.rs | 25 +++++------------
 tests/run-make/strip/hello.rs               |  8 ++++++
 tests/run-make/strip/rmake.rs               | 42 +++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+), 18 deletions(-)
 create mode 100644 tests/run-make/strip/hello.rs
 create mode 100644 tests/run-make/strip/rmake.rs

(limited to 'tests')

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 4bc064528f3..e2081ad7563 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1104,14 +1104,14 @@ fn link_natively(
         let stripcmd = "rust-objcopy";
         match (strip, crate_type) {
             (Strip::Debuginfo, _) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-S"])
+                strip_with_external_utility(sess, stripcmd, out_filename, &["--strip-debug"])
             }
             // Per the manpage, `-x` is the maximum safe strip level for dynamic libraries. (#93988)
             (Strip::Symbols, CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-x"])
+                strip_with_external_utility(sess, stripcmd, out_filename, &["-x"])
             }
             (Strip::Symbols, _) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[])
+                strip_with_external_utility(sess, stripcmd, out_filename, &["--strip-all"])
             }
             (Strip::None, _) => {}
         }
@@ -1127,9 +1127,7 @@ fn link_natively(
         let stripcmd = if !sess.host.is_like_solaris { "rust-objcopy" } else { "/usr/bin/strip" };
         match strip {
             // Always preserve the symbol table (-x).
-            Strip::Debuginfo => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-x"])
-            }
+            Strip::Debuginfo => strip_with_external_utility(sess, stripcmd, out_filename, &["-x"]),
             // Strip::Symbols is handled via the --strip-all linker option.
             Strip::Symbols => {}
             Strip::None => {}
@@ -1145,15 +1143,11 @@ fn link_natively(
         match strip {
             Strip::Debuginfo => {
                 // FIXME: AIX's strip utility only offers option to strip line number information.
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[
-                    "-X32_64", "-l",
-                ])
+                strip_with_external_utility(sess, stripcmd, out_filename, &["-X32_64", "-l"])
             }
             Strip::Symbols => {
                 // Must be noted this option might remove symbol __aix_rust_metadata and thus removes .info section which contains metadata.
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[
-                    "-X32_64", "-r",
-                ])
+                strip_with_external_utility(sess, stripcmd, out_filename, &["-X32_64", "-r"])
             }
             Strip::None => {}
         }
@@ -1166,12 +1160,7 @@ fn link_natively(
     }
 }
 
-fn strip_symbols_with_external_utility(
-    sess: &Session,
-    util: &str,
-    out_filename: &Path,
-    options: &[&str],
-) {
+fn strip_with_external_utility(sess: &Session, util: &str, out_filename: &Path, options: &[&str]) {
     let mut cmd = Command::new(util);
     cmd.args(options);
 
diff --git a/tests/run-make/strip/hello.rs b/tests/run-make/strip/hello.rs
new file mode 100644
index 00000000000..2dc0376650b
--- /dev/null
+++ b/tests/run-make/strip/hello.rs
@@ -0,0 +1,8 @@
+fn main() {
+    hey_i_get_compiled();
+}
+
+#[inline(never)]
+fn hey_i_get_compiled() {
+    println!("Hi! Do or do not strip me, your choice.");
+}
diff --git a/tests/run-make/strip/rmake.rs b/tests/run-make/strip/rmake.rs
new file mode 100644
index 00000000000..ef1acc26b45
--- /dev/null
+++ b/tests/run-make/strip/rmake.rs
@@ -0,0 +1,42 @@
+//@ ignore-windows Windows does not actually strip
+
+// Test that -Cstrip correctly strips/preserves debuginfo and symbols.
+
+use run_make_support::{bin_name, is_darwin, llvm_dwarfdump, llvm_nm, rustc};
+
+fn main() {
+    // We use DW_ (the start of any DWARF name) to check that some debuginfo is present.
+    let dwarf_indicator = "DW_";
+
+    let test_symbol = "hey_i_get_compiled";
+    let binary = &bin_name("hello");
+
+    // Avoid checking debuginfo on darwin, because it is not actually affected by strip.
+    // Darwin *never* puts debuginfo in the main binary (-Csplit-debuginfo=off just removes it),
+    // so we never actually have any debuginfo in there, so we can't check that it's present.
+    let do_debuginfo_check = !is_darwin();
+
+    // Additionally, use -Cdebuginfo=2 to make the test independent of the amount of debuginfo
+    // for std.
+
+    // -Cstrip=none should preserve symbols and debuginfo.
+    rustc().arg("hello.rs").arg("-Cdebuginfo=2").arg("-Cstrip=none").run();
+    llvm_nm().input(binary).run().assert_stdout_contains(test_symbol);
+    if do_debuginfo_check {
+        llvm_dwarfdump().input(binary).run().assert_stdout_contains(dwarf_indicator);
+    }
+
+    // -Cstrip=debuginfo should preserve symbols and strip debuginfo.
+    rustc().arg("hello.rs").arg("-Cdebuginfo=2").arg("-Cstrip=debuginfo").run();
+    llvm_nm().input(binary).run().assert_stdout_contains(test_symbol);
+    if do_debuginfo_check {
+        llvm_dwarfdump().input(binary).run().assert_stdout_not_contains(dwarf_indicator);
+    }
+
+    // -Cstrip=symbols should strip symbols and strip debuginfo.
+    rustc().arg("hello.rs").arg("-Cdebuginfo=2").arg("-Cstrip=symbols").run();
+    llvm_nm().input(binary).run().assert_stderr_not_contains(test_symbol);
+    if do_debuginfo_check {
+        llvm_dwarfdump().input(binary).run().assert_stdout_not_contains(dwarf_indicator);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c529fe0475e7c8161e950c9dc2d1409073593750 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 2 Jan 2025 18:18:19 +0000
Subject: Remove diagnostic_only_typeck and fix placeholder suggestion for
 const/static

---
 compiler/rustc_hir_analysis/src/collect/type_of.rs |  2 +-
 compiler/rustc_hir_typeck/src/lib.rs               | 43 +++++++++++-----------
 compiler/rustc_middle/src/query/mod.rs             |  3 --
 .../generic_arg_infer/in-signature.stderr          | 10 ++++-
 tests/ui/consts/issue-104768.rs                    |  1 +
 tests/ui/consts/issue-104768.stderr                | 18 ++++++++-
 .../assoc-const-missing-type.rs                    |  1 -
 .../assoc-const-missing-type.stderr                | 18 ++-------
 tests/ui/parser/issues/issue-89574.rs              |  1 -
 tests/ui/parser/issues/issue-89574.stderr          | 10 +----
 tests/ui/typeck/issue-79040.rs                     |  6 +--
 tests/ui/typeck/issue-79040.stderr                 | 12 +-----
 tests/ui/typeck/typeck_type_placeholder_item.rs    |  1 +
 .../ui/typeck/typeck_type_placeholder_item.stderr  | 41 +++++++++++++++------
 14 files changed, 85 insertions(+), 82 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index c0526903e88..f51018f5c3f 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -412,7 +412,7 @@ fn infer_placeholder_type<'tcx>(
     kind: &'static str,
 ) -> Ty<'tcx> {
     let tcx = cx.tcx();
-    let ty = tcx.diagnostic_only_typeck(def_id).node_type(body_id.hir_id);
+    let ty = tcx.typeck(def_id).node_type(body_id.hir_id);
 
     // If this came from a free `const` or `static mut?` item,
     // then the user may have written e.g. `const A = 42;`.
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index b24aa0e4693..5a0a855147d 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -87,21 +87,7 @@ fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDef
 }
 
 fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
-    let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
-    typeck_with_fallback(tcx, def_id, fallback, None)
-}
-
-/// Used only to get `TypeckResults` for type inference during error recovery.
-/// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
-fn diagnostic_only_typeck<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    def_id: LocalDefId,
-) -> &'tcx ty::TypeckResults<'tcx> {
-    let fallback = move || {
-        let span = tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
-        Ty::new_error_with_message(tcx, span, "diagnostic only typeck table used")
-    };
-    typeck_with_fallback(tcx, def_id, fallback, None)
+    typeck_with_fallback(tcx, def_id, None)
 }
 
 /// Same as `typeck` but `inspect` is invoked on evaluation of each root obligation.
@@ -113,15 +99,13 @@ pub fn inspect_typeck<'tcx>(
     def_id: LocalDefId,
     inspect: ObligationInspector<'tcx>,
 ) -> &'tcx ty::TypeckResults<'tcx> {
-    let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
-    typeck_with_fallback(tcx, def_id, fallback, Some(inspect))
+    typeck_with_fallback(tcx, def_id, Some(inspect))
 }
 
-#[instrument(level = "debug", skip(tcx, fallback, inspector), ret)]
+#[instrument(level = "debug", skip(tcx, inspector), ret)]
 fn typeck_with_fallback<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
-    fallback: impl Fn() -> Ty<'tcx> + 'tcx,
     inspector: Option<ObligationInspector<'tcx>>,
 ) -> &'tcx ty::TypeckResults<'tcx> {
     // Closures' typeck results come from their outermost function,
@@ -151,6 +135,10 @@ fn typeck_with_fallback<'tcx>(
 
     if let Some(hir::FnSig { header, decl, .. }) = node.fn_sig() {
         let fn_sig = if decl.output.is_suggestable_infer_ty().is_some() {
+            // In the case that we're recovering `fn() -> W<_>` or some other return
+            // type that has an infer in it, lower the type directly so that it'll
+            // be correctly filled with infer. We'll use this inference to provide
+            // a suggestion later on.
             fcx.lowerer().lower_fn_ty(id, header.safety, header.abi, decl, None, None)
         } else {
             tcx.fn_sig(def_id).instantiate_identity()
@@ -164,8 +152,19 @@ fn typeck_with_fallback<'tcx>(
 
         check_fn(&mut fcx, fn_sig, None, decl, def_id, body, tcx.features().unsized_fn_params());
     } else {
-        let expected_type = infer_type_if_missing(&fcx, node);
-        let expected_type = expected_type.unwrap_or_else(fallback);
+        let expected_type = if let Some(infer_ty) = infer_type_if_missing(&fcx, node) {
+            infer_ty
+        } else if let Some(ty) = node.ty()
+            && ty.is_suggestable_infer_ty()
+        {
+            // In the case that we're recovering `const X: [T; _]` or some other
+            // type that has an infer in it, lower the type directly so that it'll
+            // be correctly filled with infer. We'll use this inference to provide
+            // a suggestion later on.
+            fcx.lowerer().lower_ty(ty)
+        } else {
+            tcx.type_of(def_id).instantiate_identity()
+        };
 
         let expected_type = fcx.normalize(body.value.span, expected_type);
 
@@ -506,5 +505,5 @@ fn fatally_break_rust(tcx: TyCtxt<'_>, span: Span) -> ! {
 
 pub fn provide(providers: &mut Providers) {
     method::provide(providers);
-    *providers = Providers { typeck, diagnostic_only_typeck, used_trait_imports, ..*providers };
+    *providers = Providers { typeck, used_trait_imports, ..*providers };
 }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 7e7b602c560..b6934495e44 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1100,9 +1100,6 @@ rustc_queries! {
         desc { |tcx| "type-checking `{}`", tcx.def_path_str(key) }
         cache_on_disk_if(tcx) { !tcx.is_typeck_child(key.to_def_id()) }
     }
-    query diagnostic_only_typeck(key: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
-        desc { |tcx| "type-checking `{}`", tcx.def_path_str(key) }
-    }
 
     query used_trait_imports(key: LocalDefId) -> &'tcx UnordSet<LocalDefId> {
         desc { |tcx| "finding used_trait_imports `{}`", tcx.def_path_str(key) }
diff --git a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
index fcac95732d1..afe6f5eb67e 100644
--- a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
+++ b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
@@ -30,13 +30,19 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/in-signature.rs:22:15
    |
 LL | const ARR_CT: [u8; _] = [0; 3];
-   |               ^^^^^^^ not allowed in type signatures
+   |               ^^^^^^^
+   |               |
+   |               not allowed in type signatures
+   |               help: replace with the correct type: `[u8; 3]`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/in-signature.rs:24:20
    |
 LL | static ARR_STATIC: [u8; _] = [0; 3];
-   |                    ^^^^^^^ not allowed in type signatures
+   |                    ^^^^^^^
+   |                    |
+   |                    not allowed in type signatures
+   |                    help: replace with the correct type: `[u8; 3]`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/in-signature.rs:26:14
diff --git a/tests/ui/consts/issue-104768.rs b/tests/ui/consts/issue-104768.rs
index 3192daafa0b..52a8070be4e 100644
--- a/tests/ui/consts/issue-104768.rs
+++ b/tests/ui/consts/issue-104768.rs
@@ -1,4 +1,5 @@
 const A: &_ = 0_u32;
 //~^ ERROR: the placeholder `_` is not allowed within types on item signatures for constants
+//~| ERROR: mismatched types
 
 fn main() {}
diff --git a/tests/ui/consts/issue-104768.stderr b/tests/ui/consts/issue-104768.stderr
index 8a4a41e4d68..b5f22763e28 100644
--- a/tests/ui/consts/issue-104768.stderr
+++ b/tests/ui/consts/issue-104768.stderr
@@ -1,3 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/issue-104768.rs:1:15
+   |
+LL | const A: &_ = 0_u32;
+   |               ^^^^^ expected `&_`, found `u32`
+   |
+   = note: expected reference `&'static _`
+                   found type `u32`
+help: consider borrowing here
+   |
+LL | const A: &_ = &0_u32;
+   |               +
+
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/issue-104768.rs:1:10
    |
@@ -7,6 +20,7 @@ LL | const A: &_ = 0_u32;
    |          not allowed in type signatures
    |          help: replace with the correct type: `u32`
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0121`.
+Some errors have detailed explanations: E0121, E0308.
+For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/generic-const-items/assoc-const-missing-type.rs b/tests/ui/generic-const-items/assoc-const-missing-type.rs
index 93160f0b575..0c94a4262ef 100644
--- a/tests/ui/generic-const-items/assoc-const-missing-type.rs
+++ b/tests/ui/generic-const-items/assoc-const-missing-type.rs
@@ -12,7 +12,6 @@ impl Trait for () {
     const K<T> = ();
     //~^ ERROR missing type for `const` item
     //~| ERROR mismatched types
-    //~| ERROR mismatched types
     const Q = "";
     //~^ ERROR missing type for `const` item
     //~| ERROR lifetime parameters or bounds on const `Q` do not match the trait declaration
diff --git a/tests/ui/generic-const-items/assoc-const-missing-type.stderr b/tests/ui/generic-const-items/assoc-const-missing-type.stderr
index 6f35c0958d4..5af119dffa7 100644
--- a/tests/ui/generic-const-items/assoc-const-missing-type.stderr
+++ b/tests/ui/generic-const-items/assoc-const-missing-type.stderr
@@ -16,7 +16,7 @@ LL |     const K<T> = ();
    |               ^ help: provide a type for the associated constant: `()`
 
 error[E0195]: lifetime parameters or bounds on const `Q` do not match the trait declaration
-  --> $DIR/assoc-const-missing-type.rs:16:12
+  --> $DIR/assoc-const-missing-type.rs:15:12
    |
 LL |     const Q<'a>: &'a str;
    |            ---- lifetimes in impl do not match this const in trait
@@ -25,24 +25,12 @@ LL |     const Q = "";
    |            ^ lifetimes do not match const in trait
 
 error: missing type for `const` item
-  --> $DIR/assoc-const-missing-type.rs:16:12
+  --> $DIR/assoc-const-missing-type.rs:15:12
    |
 LL |     const Q = "";
    |            ^ help: provide a type for the associated constant: `: &str`
 
-error[E0308]: mismatched types
-  --> $DIR/assoc-const-missing-type.rs:12:18
-   |
-LL |     const K<T> = ();
-   |             -    ^^ expected type parameter `T`, found `()`
-   |             |
-   |             expected this type parameter
-   |
-   = note: expected type parameter `T`
-                   found unit type `()`
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0195, E0308.
 For more information about an error, try `rustc --explain E0195`.
diff --git a/tests/ui/parser/issues/issue-89574.rs b/tests/ui/parser/issues/issue-89574.rs
index bafb0ce5e66..276abfe7110 100644
--- a/tests/ui/parser/issues/issue-89574.rs
+++ b/tests/ui/parser/issues/issue-89574.rs
@@ -2,5 +2,4 @@ fn main() {
     const EMPTY_ARRAY = [];
     //~^ missing type for `const` item
     //~| ERROR type annotations needed
-    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/parser/issues/issue-89574.stderr b/tests/ui/parser/issues/issue-89574.stderr
index aa5e66b18a9..f40f5aded8e 100644
--- a/tests/ui/parser/issues/issue-89574.stderr
+++ b/tests/ui/parser/issues/issue-89574.stderr
@@ -15,14 +15,6 @@ help: provide a type for the item
 LL |     const EMPTY_ARRAY: <type> = [];
    |                      ++++++++
 
-error[E0282]: type annotations needed
-  --> $DIR/issue-89574.rs:2:25
-   |
-LL |     const EMPTY_ARRAY = [];
-   |                         ^^ cannot infer type
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/typeck/issue-79040.rs b/tests/ui/typeck/issue-79040.rs
index 03e00820756..f8e38e7867d 100644
--- a/tests/ui/typeck/issue-79040.rs
+++ b/tests/ui/typeck/issue-79040.rs
@@ -1,6 +1,6 @@
 fn main() {
-    const FOO = "hello" + 1; //~ ERROR cannot add `{integer}` to `&str`
-    //~^ missing type for `const` item
-    //~| ERROR cannot add `{integer}` to `&str`
+    const FOO = "hello" + 1;
+    //~^ ERROR cannot add `{integer}` to `&str`
+    //~| missing type for `const` item
     println!("{}", FOO);
 }
diff --git a/tests/ui/typeck/issue-79040.stderr b/tests/ui/typeck/issue-79040.stderr
index 39636db85a7..4ab8df8f6c9 100644
--- a/tests/ui/typeck/issue-79040.stderr
+++ b/tests/ui/typeck/issue-79040.stderr
@@ -17,16 +17,6 @@ help: provide a type for the item
 LL |     const FOO: <type> = "hello" + 1;
    |              ++++++++
 
-error[E0369]: cannot add `{integer}` to `&str`
-  --> $DIR/issue-79040.rs:2:25
-   |
-LL |     const FOO = "hello" + 1;
-   |                 ------- ^ - {integer}
-   |                 |
-   |                 &str
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.rs b/tests/ui/typeck/typeck_type_placeholder_item.rs
index 437a1aed403..9f1bfd7909e 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.rs
+++ b/tests/ui/typeck/typeck_type_placeholder_item.rs
@@ -221,6 +221,7 @@ fn value() -> Option<&'static _> {
 
 const _: Option<_> = map(value);
 //~^ ERROR the placeholder `_` is not allowed within types on item signatures for constants
+//~| ERROR cannot call non-const function `map::<u8>` in constants
 
 fn evens_squared(n: usize) -> _ {
 //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.stderr b/tests/ui/typeck/typeck_type_placeholder_item.stderr
index e62ebae5fd2..30cdd0e72a7 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item.stderr
@@ -85,7 +85,10 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:19:15
    |
 LL | static TEST5: (_, _) = (1, 2);
-   |               ^^^^^^ not allowed in type signatures
+   |               ^^^^^^
+   |               |
+   |               not allowed in type signatures
+   |               help: replace with the correct type: `(i32, i32)`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/typeck_type_placeholder_item.rs:22:13
@@ -229,7 +232,10 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:77:15
    |
 LL |     static C: Option<_> = Some(42);
-   |               ^^^^^^^^^ not allowed in type signatures
+   |               ^^^^^^^^^
+   |               |
+   |               not allowed in type signatures
+   |               help: replace with the correct type: `Option<i32>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:79:21
@@ -272,7 +278,10 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:91:22
    |
 LL |     static FN_TEST5: (_, _) = (1, 2);
-   |                      ^^^^^^ not allowed in type signatures
+   |                      ^^^^^^
+   |                      |
+   |                      not allowed in type signatures
+   |                      help: replace with the correct type: `(i32, i32)`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/typeck_type_placeholder_item.rs:94:20
@@ -578,7 +587,7 @@ LL | const _: Option<_> = map(value);
    |          help: replace with the correct type: `Option<u8>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
-  --> $DIR/typeck_type_placeholder_item.rs:225:31
+  --> $DIR/typeck_type_placeholder_item.rs:226:31
    |
 LL | fn evens_squared(n: usize) -> _ {
    |                               ^
@@ -587,13 +596,13 @@ LL | fn evens_squared(n: usize) -> _ {
    |                               help: replace with an appropriate return type: `impl Iterator<Item = usize>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
-  --> $DIR/typeck_type_placeholder_item.rs:230:10
+  --> $DIR/typeck_type_placeholder_item.rs:231:10
    |
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |          ^ not allowed in type signatures
    |
-note: however, the inferred type `Map<Filter<Range<i32>, {closure@typeck_type_placeholder_item.rs:230:29}>, {closure@typeck_type_placeholder_item.rs:230:49}>` cannot be named
-  --> $DIR/typeck_type_placeholder_item.rs:230:14
+note: however, the inferred type `Map<Filter<Range<i32>, {closure@typeck_type_placeholder_item.rs:231:29}>, {closure@typeck_type_placeholder_item.rs:231:49}>` cannot be named
+  --> $DIR/typeck_type_placeholder_item.rs:231:14
    |
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -668,23 +677,31 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL |     type F: std::ops::Fn(_);
    |                          ^ not allowed in type signatures
 
-error[E0015]: cannot call non-const method `<std::ops::Range<i32> as Iterator>::filter::<{closure@$DIR/typeck_type_placeholder_item.rs:230:29: 230:32}>` in constants
-  --> $DIR/typeck_type_placeholder_item.rs:230:22
+error[E0015]: cannot call non-const function `map::<u8>` in constants
+  --> $DIR/typeck_type_placeholder_item.rs:222:22
+   |
+LL | const _: Option<_> = map(value);
+   |                      ^^^^^^^^^^
+   |
+   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
+
+error[E0015]: cannot call non-const method `<std::ops::Range<i32> as Iterator>::filter::<{closure@$DIR/typeck_type_placeholder_item.rs:231:29: 231:32}>` in constants
+  --> $DIR/typeck_type_placeholder_item.rs:231:22
    |
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error[E0015]: cannot call non-const method `<Filter<std::ops::Range<i32>, {closure@$DIR/typeck_type_placeholder_item.rs:230:29: 230:32}> as Iterator>::map::<i32, {closure@$DIR/typeck_type_placeholder_item.rs:230:49: 230:52}>` in constants
-  --> $DIR/typeck_type_placeholder_item.rs:230:45
+error[E0015]: cannot call non-const method `<Filter<std::ops::Range<i32>, {closure@$DIR/typeck_type_placeholder_item.rs:231:29: 231:32}> as Iterator>::map::<i32, {closure@$DIR/typeck_type_placeholder_item.rs:231:49: 231:52}>` in constants
+  --> $DIR/typeck_type_placeholder_item.rs:231:45
    |
 LL | const _: _ = (1..10).filter(|x| x % 2 == 0).map(|x| x * x);
    |                                             ^^^^^^^^^^^^^^
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 74 previous errors
+error: aborting due to 75 previous errors
 
 Some errors have detailed explanations: E0015, E0046, E0121, E0282, E0403.
 For more information about an error, try `rustc --explain E0015`.
-- 
cgit 1.4.1-3-g733a5


From b85a91fc598117ab23eb5dd294ed3371bc7081d9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 2 Jan 2025 18:25:52 +0000
Subject: More refined spans for placeholder error in const/static

---
 compiler/rustc_hir_analysis/src/collect/type_of.rs | 13 +++++-
 .../generic_arg_infer/in-signature.stderr          | 50 +++++++++++-----------
 tests/ui/consts/issue-104768.stderr                |  8 ++--
 .../ui/typeck/typeck_type_placeholder_item.stderr  | 34 ++++++++-------
 4 files changed, 59 insertions(+), 46 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index f51018f5c3f..35a319dc5bd 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -4,6 +4,7 @@ use rustc_errors::{Applicability, StashKey, Suggestions};
 use rustc_hir as hir;
 use rustc_hir::HirId;
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::intravisit::Visitor;
 use rustc_middle::query::plumbing::CyclePlaceholder;
 use rustc_middle::ty::fold::fold_regions;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
@@ -12,7 +13,7 @@ use rustc_middle::ty::{self, Article, IsSuggestable, Ty, TyCtxt, TypeVisitableEx
 use rustc_middle::{bug, span_bug};
 use rustc_span::{DUMMY_SP, Ident, Span};
 
-use super::{ItemCtxt, bad_placeholder};
+use super::{HirPlaceholderCollector, ItemCtxt, bad_placeholder};
 use crate::errors::TypeofReservedKeywordUsed;
 use crate::hir_ty_lowering::HirTyLowerer;
 
@@ -447,7 +448,15 @@ fn infer_placeholder_type<'tcx>(
             }
         })
         .unwrap_or_else(|| {
-            let mut diag = bad_placeholder(cx, vec![span], kind);
+            let mut visitor = HirPlaceholderCollector::default();
+            if let Some(ty) = tcx.hir_node_by_def_id(def_id).ty() {
+                visitor.visit_ty(ty);
+            }
+            // If we didn't find any infer tys, then just fallback to `span``.
+            if visitor.0.is_empty() {
+                visitor.0.push(span);
+            }
+            let mut diag = bad_placeholder(cx, visitor.0, kind);
 
             if !ty.references_error() {
                 if let Some(ty) = ty.make_suggestable(tcx, false, None) {
diff --git a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
index afe6f5eb67e..71fd5b140b1 100644
--- a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
+++ b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
@@ -27,57 +27,59 @@ LL | fn ty_fn_mixed() -> Bar<_, _> {
    |                     help: replace with the correct return type: `Bar<i32, 3>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
-  --> $DIR/in-signature.rs:22:15
+  --> $DIR/in-signature.rs:22:20
    |
 LL | const ARR_CT: [u8; _] = [0; 3];
-   |               ^^^^^^^
-   |               |
-   |               not allowed in type signatures
+   |               -----^-
+   |               |    |
+   |               |    not allowed in type signatures
    |               help: replace with the correct type: `[u8; 3]`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
-  --> $DIR/in-signature.rs:24:20
+  --> $DIR/in-signature.rs:24:25
    |
 LL | static ARR_STATIC: [u8; _] = [0; 3];
-   |                    ^^^^^^^
-   |                    |
-   |                    not allowed in type signatures
+   |                    -----^-
+   |                    |    |
+   |                    |    not allowed in type signatures
    |                    help: replace with the correct type: `[u8; 3]`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
-  --> $DIR/in-signature.rs:26:14
+  --> $DIR/in-signature.rs:26:23
    |
 LL | const TY_CT: Bar<i32, _> = Bar::<i32, 3>(0);
-   |              ^^^^^^^^^^^
-   |              |
-   |              not allowed in type signatures
+   |              ---------^-
+   |              |        |
+   |              |        not allowed in type signatures
    |              help: replace with the correct type: `Bar<i32, 3>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
-  --> $DIR/in-signature.rs:28:19
+  --> $DIR/in-signature.rs:28:28
    |
 LL | static TY_STATIC: Bar<i32, _> = Bar::<i32, 3>(0);
-   |                   ^^^^^^^^^^^
-   |                   |
-   |                   not allowed in type signatures
+   |                   ---------^-
+   |                   |        |
+   |                   |        not allowed in type signatures
    |                   help: replace with the correct type: `Bar<i32, 3>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
-  --> $DIR/in-signature.rs:30:20
+  --> $DIR/in-signature.rs:30:24
    |
 LL | const TY_CT_MIXED: Bar<_, _> = Bar::<i32, 3>(0);
-   |                    ^^^^^^^^^
-   |                    |
-   |                    not allowed in type signatures
+   |                    ----^--^-
+   |                    |   |  |
+   |                    |   |  not allowed in type signatures
+   |                    |   not allowed in type signatures
    |                    help: replace with the correct type: `Bar<i32, 3>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
-  --> $DIR/in-signature.rs:32:25
+  --> $DIR/in-signature.rs:32:29
    |
 LL | static TY_STATIC_MIXED: Bar<_, _> = Bar::<i32, 3>(0);
-   |                         ^^^^^^^^^
-   |                         |
-   |                         not allowed in type signatures
+   |                         ----^--^-
+   |                         |   |  |
+   |                         |   |  not allowed in type signatures
+   |                         |   not allowed in type signatures
    |                         help: replace with the correct type: `Bar<i32, 3>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for associated types
diff --git a/tests/ui/consts/issue-104768.stderr b/tests/ui/consts/issue-104768.stderr
index b5f22763e28..762fda74a83 100644
--- a/tests/ui/consts/issue-104768.stderr
+++ b/tests/ui/consts/issue-104768.stderr
@@ -12,12 +12,12 @@ LL | const A: &_ = &0_u32;
    |               +
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
-  --> $DIR/issue-104768.rs:1:10
+  --> $DIR/issue-104768.rs:1:11
    |
 LL | const A: &_ = 0_u32;
-   |          ^^
-   |          |
-   |          not allowed in type signatures
+   |          -^
+   |          ||
+   |          |not allowed in type signatures
    |          help: replace with the correct type: `u32`
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.stderr b/tests/ui/typeck/typeck_type_placeholder_item.stderr
index 30cdd0e72a7..09d03e7c75c 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item.stderr
@@ -82,12 +82,13 @@ LL | static TEST4: _ = 145;
    |               help: replace with the correct type: `i32`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
-  --> $DIR/typeck_type_placeholder_item.rs:19:15
+  --> $DIR/typeck_type_placeholder_item.rs:19:16
    |
 LL | static TEST5: (_, _) = (1, 2);
-   |               ^^^^^^
-   |               |
-   |               not allowed in type signatures
+   |               -^--^-
+   |               ||  |
+   |               ||  not allowed in type signatures
+   |               |not allowed in type signatures
    |               help: replace with the correct type: `(i32, i32)`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
@@ -229,12 +230,12 @@ LL |     static B: _ = 42;
    |               help: replace with the correct type: `i32`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
-  --> $DIR/typeck_type_placeholder_item.rs:77:15
+  --> $DIR/typeck_type_placeholder_item.rs:77:22
    |
 LL |     static C: Option<_> = Some(42);
-   |               ^^^^^^^^^
-   |               |
-   |               not allowed in type signatures
+   |               -------^-
+   |               |      |
+   |               |      not allowed in type signatures
    |               help: replace with the correct type: `Option<i32>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
@@ -275,12 +276,13 @@ LL |     static FN_TEST4: _ = 145;
    |                      help: replace with the correct type: `i32`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
-  --> $DIR/typeck_type_placeholder_item.rs:91:22
+  --> $DIR/typeck_type_placeholder_item.rs:91:23
    |
 LL |     static FN_TEST5: (_, _) = (1, 2);
-   |                      ^^^^^^
-   |                      |
-   |                      not allowed in type signatures
+   |                      -^--^-
+   |                      ||  |
+   |                      ||  not allowed in type signatures
+   |                      |not allowed in type signatures
    |                      help: replace with the correct type: `(i32, i32)`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
@@ -578,12 +580,12 @@ LL | fn value() -> Option<&'static _> {
    |               help: replace with the correct return type: `Option<&'static u8>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
-  --> $DIR/typeck_type_placeholder_item.rs:222:10
+  --> $DIR/typeck_type_placeholder_item.rs:222:17
    |
 LL | const _: Option<_> = map(value);
-   |          ^^^^^^^^^
-   |          |
-   |          not allowed in type signatures
+   |          -------^-
+   |          |      |
+   |          |      not allowed in type signatures
    |          help: replace with the correct type: `Option<u8>`
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
-- 
cgit 1.4.1-3-g733a5


From 6885ff4a7b40f7550fd27c405c7f4ea3768bddb6 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 2 Jan 2025 18:49:43 +0000
Subject: Unconditionally lower generic_arg_infer

---
 compiler/rustc_ast_lowering/src/lib.rs             |  9 +--
 compiler/rustc_hir_analysis/src/collect/type_of.rs | 17 +++-
 compiler/rustc_hir_typeck/src/expr.rs              |  1 -
 .../ui/array-slice-vec/suggest-array-length.fixed  | 25 +++---
 tests/ui/array-slice-vec/suggest-array-length.rs   | 25 +++---
 .../ui/array-slice-vec/suggest-array-length.stderr | 93 ++++++++--------------
 tests/ui/async-await/issues/issue-95307.rs         |  4 +-
 tests/ui/async-await/issues/issue-95307.stderr     | 12 ++-
 .../feature-gate-generic_arg_infer.normal.stderr   | 18 +----
 .../feature-gate-generic_arg_infer.rs              |  2 -
 10 files changed, 89 insertions(+), 117 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 46e91636cfb..fe2d5a594f3 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2031,11 +2031,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_array_length_to_const_arg(&mut self, c: &AnonConst) -> &'hir hir::ConstArg<'hir> {
         match c.value.kind {
             ExprKind::Underscore => {
-                if self.tcx.features().generic_arg_infer() {
-                    let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span));
-                    self.arena
-                        .alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })
-                } else {
+                if !self.tcx.features().generic_arg_infer() {
                     feature_err(
                         &self.tcx.sess,
                         sym::generic_arg_infer,
@@ -2043,8 +2039,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         fluent_generated::ast_lowering_underscore_array_length_unstable,
                     )
                     .stash(c.value.span, StashKey::UnderscoreForArrayLengths);
-                    self.lower_anon_const_to_const_arg(c)
                 }
+                let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span));
+                self.arena.alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })
             }
             _ => self.lower_anon_const_to_const_arg(c),
         }
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 35a319dc5bd..76e125aebf9 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -452,6 +452,12 @@ fn infer_placeholder_type<'tcx>(
             if let Some(ty) = tcx.hir_node_by_def_id(def_id).ty() {
                 visitor.visit_ty(ty);
             }
+            // If we have just one span, let's try to steal a const `_` feature error.
+            let try_steal_span = if !tcx.features().generic_arg_infer() && visitor.0.len() == 1 {
+                visitor.0.first().copied()
+            } else {
+                None
+            };
             // If we didn't find any infer tys, then just fallback to `span``.
             if visitor.0.is_empty() {
                 visitor.0.push(span);
@@ -473,7 +479,16 @@ fn infer_placeholder_type<'tcx>(
                     ));
                 }
             }
-            diag.emit()
+
+            if let Some(try_steal_span) = try_steal_span {
+                cx.dcx().try_steal_replace_and_emit_err(
+                    try_steal_span,
+                    StashKey::UnderscoreForArrayLengths,
+                    diag,
+                )
+            } else {
+                diag.emit()
+            }
         });
     Ty::new_error(tcx, guar)
 }
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 8ba9a4bab57..1f32887ce9b 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1774,7 +1774,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let Some((
             _,
             hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), .. })
-            | hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(ty, _, _), .. }),
         )) = parent_node
         else {
             return;
diff --git a/tests/ui/array-slice-vec/suggest-array-length.fixed b/tests/ui/array-slice-vec/suggest-array-length.fixed
index 29f85da56e5..2eacc2517d3 100644
--- a/tests/ui/array-slice-vec/suggest-array-length.fixed
+++ b/tests/ui/array-slice-vec/suggest-array-length.fixed
@@ -3,24 +3,21 @@
 
 fn main() {
     const Foo: [i32; 3] = [1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for constants
     const REF_FOO: &[u8; 1] = &[1];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for constants
+    static Statik: [i32; 3] = [1, 2, 3];
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for static variables
+    static REF_STATIK: &[u8; 1] = &[1];
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for static variables
     let foo: [i32; 3] = [1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let bar: [i32; 3] = [0; 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let ref_foo: &[i32; 3] = &[1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let ref_bar: &[i32; 3] = &[0; 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let multiple_ref_foo: &&[i32; 3] = &&[1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
 }
diff --git a/tests/ui/array-slice-vec/suggest-array-length.rs b/tests/ui/array-slice-vec/suggest-array-length.rs
index 82d871cf875..fb4424cfed9 100644
--- a/tests/ui/array-slice-vec/suggest-array-length.rs
+++ b/tests/ui/array-slice-vec/suggest-array-length.rs
@@ -3,24 +3,21 @@
 
 fn main() {
     const Foo: [i32; _] = [1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for constants
     const REF_FOO: &[u8; _] = &[1];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for constants
+    static Statik: [i32; _] = [1, 2, 3];
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for static variables
+    static REF_STATIK: &[u8; _] = &[1];
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for static variables
     let foo: [i32; _] = [1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let bar: [i32; _] = [0; 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let ref_foo: &[i32; _] = &[1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let ref_bar: &[i32; _] = &[0; 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
     let multiple_ref_foo: &&[i32; _] = &&[1, 2, 3];
-    //~^ ERROR in expressions, `_` can only be used on the left-hand side of an assignment
-    //~| ERROR using `_` for array lengths is unstable
+    //~^ ERROR using `_` for array lengths is unstable
 }
diff --git a/tests/ui/array-slice-vec/suggest-array-length.stderr b/tests/ui/array-slice-vec/suggest-array-length.stderr
index fdab7ba7064..c0fc2989d5b 100644
--- a/tests/ui/array-slice-vec/suggest-array-length.stderr
+++ b/tests/ui/array-slice-vec/suggest-array-length.stderr
@@ -1,67 +1,41 @@
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/suggest-array-length.rs:11:20
-   |
-LL |     let foo: [i32; _] = [1, 2, 3];
-   |                    ^ `_` not allowed here
-
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/suggest-array-length.rs:14:20
-   |
-LL |     let bar: [i32; _] = [0; 3];
-   |                    ^ `_` not allowed here
-
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/suggest-array-length.rs:17:25
-   |
-LL |     let ref_foo: &[i32; _] = &[1, 2, 3];
-   |                         ^ `_` not allowed here
-
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/suggest-array-length.rs:20:25
-   |
-LL |     let ref_bar: &[i32; _] = &[0; 3];
-   |                         ^ `_` not allowed here
-
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/suggest-array-length.rs:23:35
-   |
-LL |     let multiple_ref_foo: &&[i32; _] = &&[1, 2, 3];
-   |                                   ^ `_` not allowed here
-
-error: in expressions, `_` can only be used on the left-hand side of an assignment
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/suggest-array-length.rs:5:22
    |
 LL |     const Foo: [i32; _] = [1, 2, 3];
-   |                      ^ `_` not allowed here
+   |                ------^-
+   |                |     |
+   |                |     not allowed in type signatures
+   |                help: replace with the correct type: `[i32; 3]`
 
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/suggest-array-length.rs:8:26
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
+  --> $DIR/suggest-array-length.rs:7:26
    |
 LL |     const REF_FOO: &[u8; _] = &[1];
-   |                          ^ `_` not allowed here
+   |                    ------^-
+   |                    |     |
+   |                    |     not allowed in type signatures
+   |                    help: replace with the correct type: `&[u8; 1]`
 
-error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/suggest-array-length.rs:5:22
-   |
-LL |     const Foo: [i32; _] = [1, 2, 3];
-   |                      ^ help: consider specifying the array length: `3`
-   |
-   = note: see issue #85077 <https://github.com/rust-lang/rust/issues/85077> for more information
-   = help: add `#![feature(generic_arg_infer)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
+  --> $DIR/suggest-array-length.rs:9:26
+   |
+LL |     static Statik: [i32; _] = [1, 2, 3];
+   |                    ------^-
+   |                    |     |
+   |                    |     not allowed in type signatures
+   |                    help: replace with the correct type: `[i32; 3]`
 
-error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/suggest-array-length.rs:8:26
-   |
-LL |     const REF_FOO: &[u8; _] = &[1];
-   |                          ^ help: consider specifying the array length: `1`
-   |
-   = note: see issue #85077 <https://github.com/rust-lang/rust/issues/85077> for more information
-   = help: add `#![feature(generic_arg_infer)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
+  --> $DIR/suggest-array-length.rs:11:30
+   |
+LL |     static REF_STATIK: &[u8; _] = &[1];
+   |                        ------^-
+   |                        |     |
+   |                        |     not allowed in type signatures
+   |                        help: replace with the correct type: `&[u8; 1]`
 
 error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/suggest-array-length.rs:11:20
+  --> $DIR/suggest-array-length.rs:13:20
    |
 LL |     let foo: [i32; _] = [1, 2, 3];
    |                    ^ help: consider specifying the array length: `3`
@@ -71,7 +45,7 @@ LL |     let foo: [i32; _] = [1, 2, 3];
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/suggest-array-length.rs:14:20
+  --> $DIR/suggest-array-length.rs:15:20
    |
 LL |     let bar: [i32; _] = [0; 3];
    |                    ^ help: consider specifying the array length: `3`
@@ -91,7 +65,7 @@ LL |     let ref_foo: &[i32; _] = &[1, 2, 3];
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/suggest-array-length.rs:20:25
+  --> $DIR/suggest-array-length.rs:19:25
    |
 LL |     let ref_bar: &[i32; _] = &[0; 3];
    |                         ^ help: consider specifying the array length: `3`
@@ -101,7 +75,7 @@ LL |     let ref_bar: &[i32; _] = &[0; 3];
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/suggest-array-length.rs:23:35
+  --> $DIR/suggest-array-length.rs:21:35
    |
 LL |     let multiple_ref_foo: &&[i32; _] = &&[1, 2, 3];
    |                                   ^ help: consider specifying the array length: `3`
@@ -110,6 +84,7 @@ LL |     let multiple_ref_foo: &&[i32; _] = &&[1, 2, 3];
    = help: add `#![feature(generic_arg_infer)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 14 previous errors
+error: aborting due to 9 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0121, E0658.
+For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/async-await/issues/issue-95307.rs b/tests/ui/async-await/issues/issue-95307.rs
index 40700c610f3..27903a667fb 100644
--- a/tests/ui/async-await/issues/issue-95307.rs
+++ b/tests/ui/async-await/issues/issue-95307.rs
@@ -5,8 +5,8 @@
 
 pub trait C {
     async fn new() -> [u8; _];
-    //~^ ERROR: using `_` for array lengths is unstable
-    //~| ERROR: in expressions, `_` can only be used on the left-hand side of an assignment
+    //~^ ERROR: the placeholder `_` is not allowed within types on item signatures for functions
+    //~| ERROR using `_` for array lengths is unstable
 }
 
 fn main() {}
diff --git a/tests/ui/async-await/issues/issue-95307.stderr b/tests/ui/async-await/issues/issue-95307.stderr
index dd8fcd3690a..8445c3f9811 100644
--- a/tests/ui/async-await/issues/issue-95307.stderr
+++ b/tests/ui/async-await/issues/issue-95307.stderr
@@ -1,8 +1,13 @@
-error: in expressions, `_` can only be used on the left-hand side of an assignment
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/issue-95307.rs:7:28
    |
 LL |     async fn new() -> [u8; _];
-   |                            ^ `_` not allowed here
+   |                            ^ not allowed in type signatures
+   |
+help: use type parameters instead
+   |
+LL |     async fn new<T>() -> [u8; T];
+   |                 +++           ~
 
 error[E0658]: using `_` for array lengths is unstable
   --> $DIR/issue-95307.rs:7:28
@@ -16,4 +21,5 @@ LL |     async fn new() -> [u8; _];
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0121, E0658.
+For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/feature-gates/feature-gate-generic_arg_infer.normal.stderr b/tests/ui/feature-gates/feature-gate-generic_arg_infer.normal.stderr
index 97370f0489b..96fb4a53609 100644
--- a/tests/ui/feature-gates/feature-gate-generic_arg_infer.normal.stderr
+++ b/tests/ui/feature-gates/feature-gate-generic_arg_infer.normal.stderr
@@ -1,17 +1,5 @@
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/feature-gate-generic_arg_infer.rs:11:27
-   |
-LL |     let _x: [u8; 3] = [0; _];
-   |                           ^ `_` not allowed here
-
-error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/feature-gate-generic_arg_infer.rs:14:18
-   |
-LL |     let _y: [u8; _] = [0; 3];
-   |                  ^ `_` not allowed here
-
 error[E0658]: using `_` for array lengths is unstable
-  --> $DIR/feature-gate-generic_arg_infer.rs:14:18
+  --> $DIR/feature-gate-generic_arg_infer.rs:13:18
    |
 LL |     let _y: [u8; _] = [0; 3];
    |                  ^ help: consider specifying the array length: `3`
@@ -21,7 +9,7 @@ LL |     let _y: [u8; _] = [0; 3];
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0747]: type provided when a constant was expected
-  --> $DIR/feature-gate-generic_arg_infer.rs:20:20
+  --> $DIR/feature-gate-generic_arg_infer.rs:18:20
    |
 LL |     let _x = foo::<_>([1,2]);
    |                    ^
@@ -42,7 +30,7 @@ LL |     let _x: [u8; 3] = [0; _];
    = help: add `#![feature(generic_arg_infer)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0658, E0747.
 For more information about an error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-generic_arg_infer.rs b/tests/ui/feature-gates/feature-gate-generic_arg_infer.rs
index 0473253004a..de4b7078ea6 100644
--- a/tests/ui/feature-gates/feature-gate-generic_arg_infer.rs
+++ b/tests/ui/feature-gates/feature-gate-generic_arg_infer.rs
@@ -10,10 +10,8 @@ fn foo<const N: usize>(_: [u8; N]) -> [u8; N] {
 fn bar() {
     let _x: [u8; 3] = [0; _];
     //[normal]~^ ERROR: using `_` for array lengths is unstable
-    //[normal]~| ERROR: in expressions, `_` can only be used on the left-hand side of an assignment
     let _y: [u8; _] = [0; 3];
     //[normal]~^ ERROR: using `_` for array lengths is unstable
-    //[normal]~| ERROR: in expressions, `_` can only be used on the left-hand side of an assignment
 }
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 8e344ae127782afeda06062266945b8f6368c985 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 2 Jan 2025 19:08:12 +0000
Subject: Suppress type param suggestion if encountering invalid const infer

---
 compiler/rustc_hir_analysis/src/collect.rs         | 62 ++++++++++++++++------
 compiler/rustc_hir_analysis/src/collect/type_of.rs | 13 ++---
 compiler/rustc_hir_typeck/src/expr.rs              |  6 +--
 tests/ui/async-await/issues/issue-95307.stderr     |  5 --
 4 files changed, 53 insertions(+), 33 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 2ba7e2d1669..888605b2345 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -131,19 +131,25 @@ pub struct ItemCtxt<'tcx> {
 ///////////////////////////////////////////////////////////////////////////
 
 #[derive(Default)]
-pub(crate) struct HirPlaceholderCollector(pub(crate) Vec<Span>);
+pub(crate) struct HirPlaceholderCollector {
+    pub spans: Vec<Span>,
+    // If any of the spans points to a const infer var, then suppress any messages
+    // that may try to turn that const infer into a type parameter.
+    pub may_contain_const_infer: bool,
+}
 
 impl<'v> Visitor<'v> for HirPlaceholderCollector {
     fn visit_ty(&mut self, t: &'v hir::Ty<'v>) {
         if let hir::TyKind::Infer = t.kind {
-            self.0.push(t.span);
+            self.spans.push(t.span);
         }
         intravisit::walk_ty(self, t)
     }
     fn visit_generic_arg(&mut self, generic_arg: &'v hir::GenericArg<'v>) {
         match generic_arg {
             hir::GenericArg::Infer(inf) => {
-                self.0.push(inf.span);
+                self.spans.push(inf.span);
+                self.may_contain_const_infer = true;
                 intravisit::walk_inf(self, inf);
             }
             hir::GenericArg::Type(t) => self.visit_ty(t),
@@ -152,7 +158,8 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {
     }
     fn visit_const_arg(&mut self, const_arg: &'v hir::ConstArg<'v>) {
         if let hir::ConstArgKind::Infer(span) = const_arg.kind {
-            self.0.push(span);
+            self.may_contain_const_infer = true;
+            self.spans.push(span);
         }
         intravisit::walk_const_arg(self, const_arg)
     }
@@ -277,8 +284,8 @@ fn reject_placeholder_type_signatures_in_item<'tcx>(
     placeholder_type_error(
         icx.lowerer(),
         Some(generics),
-        visitor.0,
-        suggest,
+        visitor.spans,
+        suggest && !visitor.may_contain_const_infer,
         None,
         item.kind.descr(),
     );
@@ -607,16 +614,16 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
             hir::FnRetTy::DefaultReturn(..) => tcx.types.unit,
         };
 
-        if !(visitor.0.is_empty() && infer_replacements.is_empty()) {
+        if !(visitor.spans.is_empty() && infer_replacements.is_empty()) {
             // We check for the presence of
             // `ident_span` to not emit an error twice when we have `fn foo(_: fn() -> _)`.
 
             let mut diag = crate::collect::placeholder_type_error_diag(
                 self,
                 generics,
-                visitor.0,
+                visitor.spans,
                 infer_replacements.iter().map(|(s, _)| *s).collect(),
-                true,
+                !visitor.may_contain_const_infer,
                 hir_ty,
                 "function",
             );
@@ -712,7 +719,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
                         placeholder_type_error(
                             icx.lowerer(),
                             None,
-                            visitor.0,
+                            visitor.spans,
                             false,
                             None,
                             "static variable",
@@ -780,7 +787,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
                 placeholder_type_error(
                     icx.lowerer(),
                     None,
-                    visitor.0,
+                    visitor.spans,
                     false,
                     None,
                     it.kind.descr(),
@@ -822,7 +829,7 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
                 placeholder_type_error(
                     icx.lowerer(),
                     None,
-                    visitor.0,
+                    visitor.spans,
                     false,
                     None,
                     "associated constant",
@@ -837,7 +844,14 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
             // Account for `type T = _;`.
             let mut visitor = HirPlaceholderCollector::default();
             visitor.visit_trait_item(trait_item);
-            placeholder_type_error(icx.lowerer(), None, visitor.0, false, None, "associated type");
+            placeholder_type_error(
+                icx.lowerer(),
+                None,
+                visitor.spans,
+                false,
+                None,
+                "associated type",
+            );
         }
 
         hir::TraitItemKind::Type(_, None) => {
@@ -848,7 +862,14 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
             let mut visitor = HirPlaceholderCollector::default();
             visitor.visit_trait_item(trait_item);
 
-            placeholder_type_error(icx.lowerer(), None, visitor.0, false, None, "associated type");
+            placeholder_type_error(
+                icx.lowerer(),
+                None,
+                visitor.spans,
+                false,
+                None,
+                "associated type",
+            );
         }
     };
 
@@ -872,7 +893,14 @@ fn lower_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::ImplItemId) {
             let mut visitor = HirPlaceholderCollector::default();
             visitor.visit_impl_item(impl_item);
 
-            placeholder_type_error(icx.lowerer(), None, visitor.0, false, None, "associated type");
+            placeholder_type_error(
+                icx.lowerer(),
+                None,
+                visitor.spans,
+                false,
+                None,
+                "associated type",
+            );
         }
         hir::ImplItemKind::Const(ty, _) => {
             // Account for `const T: _ = ..;`
@@ -882,7 +910,7 @@ fn lower_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::ImplItemId) {
                 placeholder_type_error(
                     icx.lowerer(),
                     None,
-                    visitor.0,
+                    visitor.spans,
                     false,
                     None,
                     "associated constant",
@@ -1422,7 +1450,7 @@ fn recover_infer_ret_ty<'tcx>(
     let mut visitor = HirPlaceholderCollector::default();
     visitor.visit_ty(infer_ret_ty);
 
-    let mut diag = bad_placeholder(icx.lowerer(), visitor.0, "return type");
+    let mut diag = bad_placeholder(icx.lowerer(), visitor.spans, "return type");
     let ret_ty = fn_sig.output();
 
     // Don't leak types into signatures unless they're nameable!
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 76e125aebf9..a3cbf811815 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -453,16 +453,17 @@ fn infer_placeholder_type<'tcx>(
                 visitor.visit_ty(ty);
             }
             // If we have just one span, let's try to steal a const `_` feature error.
-            let try_steal_span = if !tcx.features().generic_arg_infer() && visitor.0.len() == 1 {
-                visitor.0.first().copied()
+            let try_steal_span = if !tcx.features().generic_arg_infer() && visitor.spans.len() == 1
+            {
+                visitor.spans.first().copied()
             } else {
                 None
             };
-            // If we didn't find any infer tys, then just fallback to `span``.
-            if visitor.0.is_empty() {
-                visitor.0.push(span);
+            // If we didn't find any infer tys, then just fallback to `span`.
+            if visitor.spans.is_empty() {
+                visitor.spans.push(span);
             }
-            let mut diag = bad_placeholder(cx, visitor.0, kind);
+            let mut diag = bad_placeholder(cx, visitor.spans, kind);
 
             if !ty.references_error() {
                 if let Some(ty) = ty.make_suggestable(tcx, false, None) {
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 1f32887ce9b..ae36628d549 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1771,11 +1771,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let parent_node = self.tcx.hir().parent_iter(expr.hir_id).find(|(_, node)| {
             !matches!(node, hir::Node::Expr(hir::Expr { kind: hir::ExprKind::AddrOf(..), .. }))
         });
-        let Some((
-            _,
-            hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), .. })
-        )) = parent_node
-        else {
+        let Some((_, hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), .. }))) = parent_node else {
             return;
         };
         if let hir::TyKind::Array(_, ct) = ty.peel_refs().kind {
diff --git a/tests/ui/async-await/issues/issue-95307.stderr b/tests/ui/async-await/issues/issue-95307.stderr
index 8445c3f9811..90100f39163 100644
--- a/tests/ui/async-await/issues/issue-95307.stderr
+++ b/tests/ui/async-await/issues/issue-95307.stderr
@@ -3,11 +3,6 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
    |
 LL |     async fn new() -> [u8; _];
    |                            ^ not allowed in type signatures
-   |
-help: use type parameters instead
-   |
-LL |     async fn new<T>() -> [u8; T];
-   |                 +++           ~
 
 error[E0658]: using `_` for array lengths is unstable
   --> $DIR/issue-95307.rs:7:28
-- 
cgit 1.4.1-3-g733a5


From 7601adb4a06be26c5d240b7678ea1d0f661be5ed Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 2 Jan 2025 22:19:45 +0000
Subject: Make suggestion verbose and tweak error message

---
 compiler/rustc_hir_analysis/src/collect/type_of.rs |   4 +-
 .../ui/array-slice-vec/suggest-array-length.stderr |  40 ++++----
 .../generic_arg_infer/in-signature.stderr          |  66 ++++++++-----
 tests/ui/consts/issue-104768.stderr                |  10 +-
 tests/ui/error-codes/E0121.stderr                  |  10 +-
 .../issue-69396-const-no-type-in-macro.stderr      |   9 +-
 tests/ui/suggestions/unnamable-types.rs            |   2 +-
 tests/ui/suggestions/unnamable-types.stderr        |  10 +-
 .../ui/typeck/typeck_type_placeholder_item.stderr  | 106 +++++++++++++--------
 .../typeck_type_placeholder_item_help.stderr       |  40 ++++----
 10 files changed, 178 insertions(+), 119 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index a3cbf811815..208fa238f80 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -467,9 +467,9 @@ fn infer_placeholder_type<'tcx>(
 
             if !ty.references_error() {
                 if let Some(ty) = ty.make_suggestable(tcx, false, None) {
-                    diag.span_suggestion(
+                    diag.span_suggestion_verbose(
                         span,
-                        "replace with the correct type",
+                        "replace this with a fully-specified type",
                         ty,
                         Applicability::MachineApplicable,
                     );
diff --git a/tests/ui/array-slice-vec/suggest-array-length.stderr b/tests/ui/array-slice-vec/suggest-array-length.stderr
index c0fc2989d5b..b71be306780 100644
--- a/tests/ui/array-slice-vec/suggest-array-length.stderr
+++ b/tests/ui/array-slice-vec/suggest-array-length.stderr
@@ -2,37 +2,45 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/suggest-array-length.rs:5:22
    |
 LL |     const Foo: [i32; _] = [1, 2, 3];
-   |                ------^-
-   |                |     |
-   |                |     not allowed in type signatures
-   |                help: replace with the correct type: `[i32; 3]`
+   |                      ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     const Foo: [i32; 3] = [1, 2, 3];
+   |                ~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/suggest-array-length.rs:7:26
    |
 LL |     const REF_FOO: &[u8; _] = &[1];
-   |                    ------^-
-   |                    |     |
-   |                    |     not allowed in type signatures
-   |                    help: replace with the correct type: `&[u8; 1]`
+   |                          ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     const REF_FOO: &[u8; 1] = &[1];
+   |                    ~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/suggest-array-length.rs:9:26
    |
 LL |     static Statik: [i32; _] = [1, 2, 3];
-   |                    ------^-
-   |                    |     |
-   |                    |     not allowed in type signatures
-   |                    help: replace with the correct type: `[i32; 3]`
+   |                          ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static Statik: [i32; 3] = [1, 2, 3];
+   |                    ~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/suggest-array-length.rs:11:30
    |
 LL |     static REF_STATIK: &[u8; _] = &[1];
-   |                        ------^-
-   |                        |     |
-   |                        |     not allowed in type signatures
-   |                        help: replace with the correct type: `&[u8; 1]`
+   |                              ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static REF_STATIK: &[u8; 1] = &[1];
+   |                        ~~~~~~~~
 
 error[E0658]: using `_` for array lengths is unstable
   --> $DIR/suggest-array-length.rs:13:20
diff --git a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
index 71fd5b140b1..5999bc18204 100644
--- a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
+++ b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
@@ -30,57 +30,71 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/in-signature.rs:22:20
    |
 LL | const ARR_CT: [u8; _] = [0; 3];
-   |               -----^-
-   |               |    |
-   |               |    not allowed in type signatures
-   |               help: replace with the correct type: `[u8; 3]`
+   |                    ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const ARR_CT: [u8; 3] = [0; 3];
+   |               ~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/in-signature.rs:24:25
    |
 LL | static ARR_STATIC: [u8; _] = [0; 3];
-   |                    -----^-
-   |                    |    |
-   |                    |    not allowed in type signatures
-   |                    help: replace with the correct type: `[u8; 3]`
+   |                         ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static ARR_STATIC: [u8; 3] = [0; 3];
+   |                    ~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/in-signature.rs:26:23
    |
 LL | const TY_CT: Bar<i32, _> = Bar::<i32, 3>(0);
-   |              ---------^-
-   |              |        |
-   |              |        not allowed in type signatures
-   |              help: replace with the correct type: `Bar<i32, 3>`
+   |                       ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const TY_CT: Bar<i32, 3> = Bar::<i32, 3>(0);
+   |              ~~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/in-signature.rs:28:28
    |
 LL | static TY_STATIC: Bar<i32, _> = Bar::<i32, 3>(0);
-   |                   ---------^-
-   |                   |        |
-   |                   |        not allowed in type signatures
-   |                   help: replace with the correct type: `Bar<i32, 3>`
+   |                            ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static TY_STATIC: Bar<i32, 3> = Bar::<i32, 3>(0);
+   |                   ~~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/in-signature.rs:30:24
    |
 LL | const TY_CT_MIXED: Bar<_, _> = Bar::<i32, 3>(0);
-   |                    ----^--^-
-   |                    |   |  |
-   |                    |   |  not allowed in type signatures
-   |                    |   not allowed in type signatures
-   |                    help: replace with the correct type: `Bar<i32, 3>`
+   |                        ^  ^ not allowed in type signatures
+   |                        |
+   |                        not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const TY_CT_MIXED: Bar<i32, 3> = Bar::<i32, 3>(0);
+   |                    ~~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/in-signature.rs:32:29
    |
 LL | static TY_STATIC_MIXED: Bar<_, _> = Bar::<i32, 3>(0);
-   |                         ----^--^-
-   |                         |   |  |
-   |                         |   |  not allowed in type signatures
-   |                         |   not allowed in type signatures
-   |                         help: replace with the correct type: `Bar<i32, 3>`
+   |                             ^  ^ not allowed in type signatures
+   |                             |
+   |                             not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static TY_STATIC_MIXED: Bar<i32, 3> = Bar::<i32, 3>(0);
+   |                         ~~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for associated types
   --> $DIR/in-signature.rs:51:23
diff --git a/tests/ui/consts/issue-104768.stderr b/tests/ui/consts/issue-104768.stderr
index 762fda74a83..41a9bab0961 100644
--- a/tests/ui/consts/issue-104768.stderr
+++ b/tests/ui/consts/issue-104768.stderr
@@ -15,10 +15,12 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/issue-104768.rs:1:11
    |
 LL | const A: &_ = 0_u32;
-   |          -^
-   |          ||
-   |          |not allowed in type signatures
-   |          help: replace with the correct type: `u32`
+   |           ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const A: u32 = 0_u32;
+   |          ~~~
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/error-codes/E0121.stderr b/tests/ui/error-codes/E0121.stderr
index 023d7e011bf..5f5df0fd0ae 100644
--- a/tests/ui/error-codes/E0121.stderr
+++ b/tests/ui/error-codes/E0121.stderr
@@ -11,10 +11,12 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/E0121.rs:3:13
    |
 LL | static BAR: _ = "test";
-   |             ^
-   |             |
-   |             not allowed in type signatures
-   |             help: replace with the correct type: `&str`
+   |             ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static BAR: &str = "test";
+   |             ~~~~
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr b/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr
index 89aeafebac4..ef49a0bc2b5 100644
--- a/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr
+++ b/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr
@@ -31,10 +31,7 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/issue-69396-const-no-type-in-macro.rs:4:20
    |
 LL |               const A = "A".$fn();
-   |                      ^
-   |                      |
-   |                      not allowed in type signatures
-   |                      help: replace with the correct type: `bool`
+   |                      ^ not allowed in type signatures
 ...
 LL | / suite! {
 LL | |     len;
@@ -43,6 +40,10 @@ LL | | }
    | |_- in this macro invocation
    |
    = note: this error originates in the macro `suite` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: replace this with a fully-specified type
+   |
+LL |             const Abool = "A".$fn();
+   |                    ++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/suggestions/unnamable-types.rs b/tests/ui/suggestions/unnamable-types.rs
index dd2c3536eb9..094584ff850 100644
--- a/tests/ui/suggestions/unnamable-types.rs
+++ b/tests/ui/suggestions/unnamable-types.rs
@@ -10,7 +10,7 @@ const A = 5;
 static B: _ = "abc";
 //~^ ERROR: the placeholder `_` is not allowed within types on item signatures for static variables
 //~| NOTE: not allowed in type signatures
-//~| HELP: replace with the correct type
+//~| HELP: replace this with a fully-specified type
 
 
 // FIXME: this should also suggest a function pointer, as the closure is non-capturing
diff --git a/tests/ui/suggestions/unnamable-types.stderr b/tests/ui/suggestions/unnamable-types.stderr
index 6623678fd0c..dc236af91f8 100644
--- a/tests/ui/suggestions/unnamable-types.stderr
+++ b/tests/ui/suggestions/unnamable-types.stderr
@@ -8,10 +8,12 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/unnamable-types.rs:10:11
    |
 LL | static B: _ = "abc";
-   |           ^
-   |           |
-   |           not allowed in type signatures
-   |           help: replace with the correct type: `&str`
+   |           ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static B: &str = "abc";
+   |           ~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/unnamable-types.rs:17:10
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.stderr b/tests/ui/typeck/typeck_type_placeholder_item.stderr
index 09d03e7c75c..c97b9312076 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item.stderr
@@ -67,29 +67,36 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:13:15
    |
 LL | static TEST3: _ = "test";
-   |               ^
-   |               |
-   |               not allowed in type signatures
-   |               help: replace with the correct type: `&str`
+   |               ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static TEST3: &str = "test";
+   |               ~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:16:15
    |
 LL | static TEST4: _ = 145;
-   |               ^
-   |               |
-   |               not allowed in type signatures
-   |               help: replace with the correct type: `i32`
+   |               ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static TEST4: i32 = 145;
+   |               ~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:19:16
    |
 LL | static TEST5: (_, _) = (1, 2);
-   |               -^--^-
-   |               ||  |
-   |               ||  not allowed in type signatures
-   |               |not allowed in type signatures
-   |               help: replace with the correct type: `(i32, i32)`
+   |                ^  ^ not allowed in type signatures
+   |                |
+   |                not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | static TEST5: (i32, i32) = (1, 2);
+   |               ~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/typeck_type_placeholder_item.rs:22:13
@@ -224,19 +231,23 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:75:15
    |
 LL |     static B: _ = 42;
-   |               ^
-   |               |
-   |               not allowed in type signatures
-   |               help: replace with the correct type: `i32`
+   |               ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static B: i32 = 42;
+   |               ~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:77:22
    |
 LL |     static C: Option<_> = Some(42);
-   |               -------^-
-   |               |      |
-   |               |      not allowed in type signatures
-   |               help: replace with the correct type: `Option<i32>`
+   |                      ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static C: Option<i32> = Some(42);
+   |               ~~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:79:21
@@ -261,29 +272,36 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:85:22
    |
 LL |     static FN_TEST3: _ = "test";
-   |                      ^
-   |                      |
-   |                      not allowed in type signatures
-   |                      help: replace with the correct type: `&str`
+   |                      ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static FN_TEST3: &str = "test";
+   |                      ~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:88:22
    |
 LL |     static FN_TEST4: _ = 145;
-   |                      ^
-   |                      |
-   |                      not allowed in type signatures
-   |                      help: replace with the correct type: `i32`
+   |                      ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static FN_TEST4: i32 = 145;
+   |                      ~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:91:23
    |
 LL |     static FN_TEST5: (_, _) = (1, 2);
-   |                      -^--^-
-   |                      ||  |
-   |                      ||  not allowed in type signatures
-   |                      |not allowed in type signatures
-   |                      help: replace with the correct type: `(i32, i32)`
+   |                       ^  ^ not allowed in type signatures
+   |                       |
+   |                       not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     static FN_TEST5: (i32, i32) = (1, 2);
+   |                      ~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/typeck_type_placeholder_item.rs:94:20
@@ -550,10 +568,12 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:194:14
    |
 LL |     const D: _ = 42;
-   |              ^
-   |              |
-   |              not allowed in type signatures
-   |              help: replace with the correct type: `i32`
+   |              ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     const D: i32 = 42;
+   |              ~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for associated constants
   --> $DIR/typeck_type_placeholder_item.rs:209:14
@@ -583,10 +603,12 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:222:17
    |
 LL | const _: Option<_> = map(value);
-   |          -------^-
-   |          |      |
-   |          |      not allowed in type signatures
-   |          help: replace with the correct type: `Option<u8>`
+   |                 ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const _: Option<u8> = map(value);
+   |          ~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:226:31
diff --git a/tests/ui/typeck/typeck_type_placeholder_item_help.stderr b/tests/ui/typeck/typeck_type_placeholder_item_help.stderr
index 32585e2937b..a05e27cebfc 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item_help.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item_help.stderr
@@ -11,19 +11,23 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item_help.rs:7:14
    |
 LL | const TEST2: _ = 42u32;
-   |              ^
-   |              |
-   |              not allowed in type signatures
-   |              help: replace with the correct type: `u32`
+   |              ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const TEST2: u32 = 42u32;
+   |              ~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/typeck_type_placeholder_item_help.rs:10:14
    |
 LL | const TEST3: _ = Some(42);
-   |              ^
-   |              |
-   |              not allowed in type signatures
-   |              help: replace with the correct type: `Option<i32>`
+   |              ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL | const TEST3: Option<i32> = Some(42);
+   |              ~~~~~~~~~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/typeck_type_placeholder_item_help.rs:13:22
@@ -41,19 +45,23 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item_help.rs:25:18
    |
 LL |     const TEST6: _ = 13;
-   |                  ^
-   |                  |
-   |                  not allowed in type signatures
-   |                  help: replace with the correct type: `i32`
+   |                  ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     const TEST6: i32 = 13;
+   |                  ~~~
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for associated constants
   --> $DIR/typeck_type_placeholder_item_help.rs:18:18
    |
 LL |     const TEST5: _ = 42;
-   |                  ^
-   |                  |
-   |                  not allowed in type signatures
-   |                  help: replace with the correct type: `i32`
+   |                  ^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL |     const TEST5: i32 = 42;
+   |                  ~~~
 
 error[E0308]: mismatched types
   --> $DIR/typeck_type_placeholder_item_help.rs:30:28
-- 
cgit 1.4.1-3-g733a5


From 0fd64efa2f3677ca0f1f0f970b31474a5218f0b8 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 2 Jan 2025 22:33:41 +0000
Subject: Fix macro shenanigans

---
 compiler/rustc_hir_analysis/src/collect/type_of.rs        | 13 +++++++++++--
 tests/ui/macros/issue-69396-const-no-type-in-macro.rs     |  2 +-
 tests/ui/macros/issue-69396-const-no-type-in-macro.stderr |  6 +-----
 3 files changed, 13 insertions(+), 8 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 208fa238f80..87a04820f7e 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -449,7 +449,8 @@ fn infer_placeholder_type<'tcx>(
         })
         .unwrap_or_else(|| {
             let mut visitor = HirPlaceholderCollector::default();
-            if let Some(ty) = tcx.hir_node_by_def_id(def_id).ty() {
+            let node = tcx.hir_node_by_def_id(def_id);
+            if let Some(ty) = node.ty() {
                 visitor.visit_ty(ty);
             }
             // If we have just one span, let's try to steal a const `_` feature error.
@@ -465,7 +466,15 @@ fn infer_placeholder_type<'tcx>(
             }
             let mut diag = bad_placeholder(cx, visitor.spans, kind);
 
-            if !ty.references_error() {
+            // HACK(#69396): Stashing and stealing diagnostics does not interact
+            // well with macros which may delay more than one diagnostic on the
+            // same span. If this happens, we will fall through to this arm, so
+            // we need to suppress the suggestion since it's invalid. Ideally we
+            // would suppress the duplicated error too, but that's really hard.
+            if span.is_empty() && span.from_expansion() {
+                // An approximately better primary message + no suggestion...
+                diag.primary_message("missing type for item");
+            } else if !ty.references_error() {
                 if let Some(ty) = ty.make_suggestable(tcx, false, None) {
                     diag.span_suggestion_verbose(
                         span,
diff --git a/tests/ui/macros/issue-69396-const-no-type-in-macro.rs b/tests/ui/macros/issue-69396-const-no-type-in-macro.rs
index 45a30857413..c200a1fd0b4 100644
--- a/tests/ui/macros/issue-69396-const-no-type-in-macro.rs
+++ b/tests/ui/macros/issue-69396-const-no-type-in-macro.rs
@@ -4,7 +4,7 @@ macro_rules! suite {
             const A = "A".$fn();
             //~^ ERROR the name `A` is defined multiple times
             //~| ERROR missing type for `const` item
-            //~| ERROR the placeholder `_` is not allowed within types on item signatures for constants
+            //~| ERROR missing type for item
         )*
     }
 }
diff --git a/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr b/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr
index ef49a0bc2b5..4342d7d88f5 100644
--- a/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr
+++ b/tests/ui/macros/issue-69396-const-no-type-in-macro.stderr
@@ -27,7 +27,7 @@ LL | | }
    |
    = note: this error originates in the macro `suite` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
+error[E0121]: missing type for item
   --> $DIR/issue-69396-const-no-type-in-macro.rs:4:20
    |
 LL |               const A = "A".$fn();
@@ -40,10 +40,6 @@ LL | | }
    | |_- in this macro invocation
    |
    = note: this error originates in the macro `suite` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: replace this with a fully-specified type
-   |
-LL |             const Abool = "A".$fn();
-   |                    ++++
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c29838843b0573a583f6457c176d9d49873e9eb5 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 3 Jan 2025 02:45:09 +0000
Subject: Report impl has stricter requirements even when RPITIT inference gets
 in the way

---
 .../src/check/compare_impl_item.rs                 | 20 ++++++++++++++++++
 ...move-invalid-type-bound-suggest-issue-127555.rs |  2 +-
 ...-invalid-type-bound-suggest-issue-127555.stderr | 23 ++++++++-------------
 ...itive-predicate-entailment-error.current.stderr | 22 ++++++++++----------
 .../false-positive-predicate-entailment-error.rs   |  4 ++--
 .../in-trait/mismatched-where-clauses.rs           | 12 +++++++++++
 .../in-trait/mismatched-where-clauses.stderr       | 12 +++++++++++
 .../in-trait/return-dont-satisfy-bounds.rs         |  2 +-
 .../in-trait/return-dont-satisfy-bounds.stderr     | 24 ++++++++++------------
 ...pitit-hidden-types-self-implied-wf-via-param.rs |  2 +-
 ...t-hidden-types-self-implied-wf-via-param.stderr | 21 ++++++++++---------
 11 files changed, 90 insertions(+), 54 deletions(-)
 create mode 100644 tests/ui/impl-trait/in-trait/mismatched-where-clauses.rs
 create mode 100644 tests/ui/impl-trait/in-trait/mismatched-where-clauses.stderr

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index a6b504de3da..4a957d5da24 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -529,6 +529,26 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     let infcx = &tcx.infer_ctxt().build(TypingMode::non_body_analysis());
     let ocx = ObligationCtxt::new_with_diagnostics(infcx);
 
+    // Check that the where clauses of the impl are satisfied by the hybrid param env.
+    // You might ask -- what does this have to do with RPITIT inference? Nothing.
+    // We check these because if the where clauses of the signatures do not match
+    // up, then we don't want to give spurious other errors that point at the RPITITs.
+    // They're not necessary to check, though, because we already check them in
+    // `compare_method_predicate_entailment`.
+    let impl_m_own_bounds = tcx.predicates_of(impl_m_def_id).instantiate_own_identity();
+    for (predicate, span) in impl_m_own_bounds {
+        let normalize_cause = traits::ObligationCause::misc(span, impl_m_def_id);
+        let predicate = ocx.normalize(&normalize_cause, param_env, predicate);
+
+        let cause =
+            ObligationCause::new(span, impl_m_def_id, ObligationCauseCode::CompareImplItem {
+                impl_item_def_id: impl_m_def_id,
+                trait_item_def_id: trait_m.def_id,
+                kind: impl_m.kind,
+            });
+        ocx.register_obligation(traits::Obligation::new(tcx, cause, param_env, predicate));
+    }
+
     // Normalize the impl signature with fresh variables for lifetime inference.
     let misc_cause = ObligationCause::misc(return_span, impl_m_def_id);
     let impl_sig = ocx.normalize(
diff --git a/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.rs b/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.rs
index b4df58b3c25..4dfeab9e8c3 100644
--- a/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.rs
+++ b/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.rs
@@ -11,9 +11,9 @@ struct Baz {}
 
 impl Foo for Baz {
     async fn bar<F>(&mut self, _func: F) -> ()
-    //~^ ERROR `F` cannot be sent between threads safely
     where
         F: FnMut() + Send,
+        //~^ impl has stricter requirements than trait
     {
         ()
     }
diff --git a/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.stderr b/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.stderr
index e6379954776..8d5cad4493e 100644
--- a/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.stderr
+++ b/tests/ui/associated-types/remove-invalid-type-bound-suggest-issue-127555.stderr
@@ -1,21 +1,14 @@
-error[E0277]: `F` cannot be sent between threads safely
-  --> $DIR/remove-invalid-type-bound-suggest-issue-127555.rs:13:5
+error[E0276]: impl has stricter requirements than trait
+  --> $DIR/remove-invalid-type-bound-suggest-issue-127555.rs:15:22
    |
-LL | /     async fn bar<F>(&mut self, _func: F) -> ()
-LL | |
+LL | /     fn bar<F>(&mut self, func: F) -> impl std::future::Future<Output = ()> + Send
 LL | |     where
-LL | |         F: FnMut() + Send,
-   | |__________________________^ `F` cannot be sent between threads safely
-   |
-note: required by a bound in `<Baz as Foo>::bar`
-  --> $DIR/remove-invalid-type-bound-suggest-issue-127555.rs:16:22
-   |
-LL |     async fn bar<F>(&mut self, _func: F) -> ()
-   |              --- required by a bound in this associated function
+LL | |         F: FnMut();
+   | |___________________- definition of `bar` from trait
 ...
-LL |         F: FnMut() + Send,
-   |                      ^^^^ required by this bound in `<Baz as Foo>::bar`
+LL |           F: FnMut() + Send,
+   |                        ^^^^ impl has extra requirement `F: Send`
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
index e38e18857ef..b6e7e02f331 100644
--- a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
+++ b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
@@ -19,11 +19,11 @@ help: consider further restricting type parameter `F` with trait `MyFn`
 LL |         F: Callback<Self::CallbackArg> + MyFn<i32>,
    |                                        +++++++++++
 
-error[E0277]: the trait bound `F: MyFn<i32>` is not satisfied
-  --> $DIR/false-positive-predicate-entailment-error.rs:36:30
+error[E0277]: the trait bound `F: Callback<i32>` is not satisfied
+  --> $DIR/false-positive-predicate-entailment-error.rs:42:12
    |
-LL |     fn autobatch<F>(self) -> impl Trait
-   |                              ^^^^^^^^^^ the trait `MyFn<i32>` is not implemented for `F`
+LL |         F: Callback<Self::CallbackArg>,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MyFn<i32>` is not implemented for `F`
    |
 note: required for `F` to implement `Callback<i32>`
   --> $DIR/false-positive-predicate-entailment-error.rs:14:21
@@ -32,14 +32,14 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
    |            -------  ^^^^^^^^^^^     ^
    |            |
    |            unsatisfied trait bound introduced here
-note: required by a bound in `<Sender as ChannelSender>::autobatch`
-  --> $DIR/false-positive-predicate-entailment-error.rs:43:12
+note: the requirement `F: Callback<i32>` appears on the `impl`'s method `autobatch` but not on the corresponding trait's method
+  --> $DIR/false-positive-predicate-entailment-error.rs:25:8
    |
-LL |     fn autobatch<F>(self) -> impl Trait
-   |        --------- required by a bound in this associated function
+LL | trait ChannelSender {
+   |       ------------- in this trait
 ...
-LL |         F: Callback<Self::CallbackArg>,
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<Sender as ChannelSender>::autobatch`
+LL |     fn autobatch<F>(self) -> impl Trait
+   |        ^^^^^^^^^ this trait's method doesn't have the requirement `F: Callback<i32>`
 help: consider further restricting type parameter `F` with trait `MyFn`
    |
 LL |         F: Callback<Self::CallbackArg> + MyFn<i32>,
@@ -118,7 +118,7 @@ LL |         F: Callback<Self::CallbackArg> + MyFn<i32>,
    |                                        +++++++++++
 
 error[E0277]: the trait bound `F: MyFn<i32>` is not satisfied
-  --> $DIR/false-positive-predicate-entailment-error.rs:43:12
+  --> $DIR/false-positive-predicate-entailment-error.rs:42:12
    |
 LL |         F: Callback<Self::CallbackArg>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MyFn<i32>` is not implemented for `F`
diff --git a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.rs b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.rs
index 2987d183e04..cbe6c32b890 100644
--- a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.rs
+++ b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.rs
@@ -38,11 +38,11 @@ impl ChannelSender for Sender {
     //[current]~| ERROR the trait bound `F: MyFn<i32>` is not satisfied
     //[current]~| ERROR the trait bound `F: MyFn<i32>` is not satisfied
     //[current]~| ERROR the trait bound `F: MyFn<i32>` is not satisfied
-    //[current]~| ERROR the trait bound `F: MyFn<i32>` is not satisfied
     where
         F: Callback<Self::CallbackArg>,
         //[current]~^ ERROR the trait bound `F: MyFn<i32>` is not satisfied
-    {
+        //[current]~| ERROR the trait bound `F: Callback<i32>` is not satisfied
+        {
         Thing
     }
 }
diff --git a/tests/ui/impl-trait/in-trait/mismatched-where-clauses.rs b/tests/ui/impl-trait/in-trait/mismatched-where-clauses.rs
new file mode 100644
index 00000000000..a2c735cc126
--- /dev/null
+++ b/tests/ui/impl-trait/in-trait/mismatched-where-clauses.rs
@@ -0,0 +1,12 @@
+trait Foo {
+    fn foo<S>(s: S) -> impl Sized;
+}
+
+trait Bar {}
+
+impl Foo for () {
+    fn foo<S>(s: S) -> impl Sized where S: Bar {}
+    //~^ ERROR impl has stricter requirements than trait
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/in-trait/mismatched-where-clauses.stderr b/tests/ui/impl-trait/in-trait/mismatched-where-clauses.stderr
new file mode 100644
index 00000000000..cc6e027cad7
--- /dev/null
+++ b/tests/ui/impl-trait/in-trait/mismatched-where-clauses.stderr
@@ -0,0 +1,12 @@
+error[E0276]: impl has stricter requirements than trait
+  --> $DIR/mismatched-where-clauses.rs:8:44
+   |
+LL |     fn foo<S>(s: S) -> impl Sized;
+   |     ------------------------------ definition of `foo` from trait
+...
+LL |     fn foo<S>(s: S) -> impl Sized where S: Bar {}
+   |                                            ^^^ impl has extra requirement `S: Bar`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.rs b/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.rs
index ee47de2c732..ff265e576b9 100644
--- a/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.rs
+++ b/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.rs
@@ -8,7 +8,7 @@ impl Foo<char> for Bar {
     fn foo<F2: Foo<u8>>(self) -> impl Foo<u8> {
         //~^ ERROR: the trait bound `impl Foo<u8>: Foo<char>` is not satisfied [E0277]
         //~| ERROR: the trait bound `Bar: Foo<u8>` is not satisfied [E0277]
-        //~| ERROR: the trait bound `F2: Foo<u8>` is not satisfied
+        //~| ERROR: impl has stricter requirements than trait
         self
     }
 }
diff --git a/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr b/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
index 663c9a7f2ae..5cb80386b35 100644
--- a/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
+++ b/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
@@ -1,3 +1,12 @@
+error[E0276]: impl has stricter requirements than trait
+  --> $DIR/return-dont-satisfy-bounds.rs:8:16
+   |
+LL |     fn foo<F2>(self) -> impl Foo<T>;
+   |     -------------------------------- definition of `foo` from trait
+...
+LL |     fn foo<F2: Foo<u8>>(self) -> impl Foo<u8> {
+   |                ^^^^^^^ impl has extra requirement `F2: Foo<u8>`
+
 error[E0277]: the trait bound `impl Foo<u8>: Foo<char>` is not satisfied
   --> $DIR/return-dont-satisfy-bounds.rs:8:34
    |
@@ -11,18 +20,6 @@ note: required by a bound in `Foo::{synthetic#0}`
 LL |     fn foo<F2>(self) -> impl Foo<T>;
    |                              ^^^^^^ required by this bound in `Foo::{synthetic#0}`
 
-error[E0277]: the trait bound `F2: Foo<u8>` is not satisfied
-  --> $DIR/return-dont-satisfy-bounds.rs:8:34
-   |
-LL |     fn foo<F2: Foo<u8>>(self) -> impl Foo<u8> {
-   |                                  ^^^^^^^^^^^^ the trait `Foo<u8>` is not implemented for `F2`
-   |
-note: required by a bound in `<Bar as Foo<char>>::foo`
-  --> $DIR/return-dont-satisfy-bounds.rs:8:16
-   |
-LL |     fn foo<F2: Foo<u8>>(self) -> impl Foo<u8> {
-   |                ^^^^^^^ required by this bound in `<Bar as Foo<char>>::foo`
-
 error[E0277]: the trait bound `Bar: Foo<u8>` is not satisfied
   --> $DIR/return-dont-satisfy-bounds.rs:8:34
    |
@@ -38,4 +35,5 @@ LL |         self
 
 error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0276, E0277.
+For more information about an error, try `rustc --explain E0276`.
diff --git a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.rs b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.rs
index 37b0b229776..7a3a59d37c6 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.rs
+++ b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.rs
@@ -4,9 +4,9 @@ trait Extend {
 
 impl Extend for () {
     fn extend<'a: 'a>(s: &'a str) -> (Option<&'static &'a ()>, &'static str)
-    //~^ ERROR in type `&'static &'a ()`, reference has a longer lifetime than the data it references
     where
         'a: 'static,
+        //~^ impl has stricter requirements than trait
     {
         (None, s)
     }
diff --git a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr
index 5ace64b6903..15bef5c78b0 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr
+++ b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr
@@ -1,16 +1,17 @@
-error[E0491]: in type `&'static &'a ()`, reference has a longer lifetime than the data it references
-  --> $DIR/rpitit-hidden-types-self-implied-wf-via-param.rs:6:38
+error[E0276]: impl has stricter requirements than trait
+  --> $DIR/rpitit-hidden-types-self-implied-wf-via-param.rs:8:13
    |
-LL |     fn extend<'a: 'a>(s: &'a str) -> (Option<&'static &'a ()>, &'static str)
-   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     fn extend<'a: 'a>(_: &'a str) -> (impl Sized + 'a, &'static str);
+   |     ----------------------------------------------------------------- definition of `extend` from trait
+...
+LL |         'a: 'static,
+   |             ^^^^^^^ impl has extra requirement `'a: 'static`
    |
-   = note: the pointer is valid for the static lifetime
-note: but the referenced data is only valid for the lifetime `'a` as defined here
-  --> $DIR/rpitit-hidden-types-self-implied-wf-via-param.rs:6:15
+help: copy the `where` clause predicates from the trait
+   |
+LL |     where 'a: 'a
    |
-LL |     fn extend<'a: 'a>(s: &'a str) -> (Option<&'static &'a ()>, &'static str)
-   |               ^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0491`.
+For more information about this error, try `rustc --explain E0276`.
-- 
cgit 1.4.1-3-g733a5


From 2d602ea7931ca6988a34567d9255a10c09d0e17e Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 3 Jan 2025 05:01:14 +0000
Subject: Do not project when there are unconstrained impl params

---
 compiler/rustc_hir_analysis/src/impl_wf_check.rs   | 123 +++++++++++++++------
 compiler/rustc_hir_analysis/src/lib.rs             |   2 +
 compiler/rustc_middle/src/query/mod.rs             |   5 +
 .../rustc_trait_selection/src/traits/project.rs    |  63 ++++++-----
 .../src/traits/specialize/specialization_graph.rs  |  14 +++
 tests/crashes/123141.rs                            |  23 ----
 tests/crashes/125874.rs                            |  22 ----
 tests/crashes/126942.rs                            |  11 --
 tests/crashes/127804.rs                            |  12 --
 tests/crashes/130967.rs                            |  13 ---
 .../bugs/issue-87735.stderr                        |  68 +-----------
 .../in-trait/refine-resolution-errors.rs           |   1 -
 .../in-trait/refine-resolution-errors.stderr       |  11 +-
 tests/ui/impl-trait/issues/issue-87340.rs          |   2 -
 tests/ui/impl-trait/issues/issue-87340.stderr      |  17 +--
 tests/ui/impl-unused-tps.stderr                    |  12 +-
 .../unconstrained-projection-normalization-2.rs    |  17 +++
 ...unconstrained-projection-normalization-2.stderr |   9 ++
 .../unconstrained-projection-normalization.rs      |  16 +++
 .../unconstrained-projection-normalization.stderr  |   9 ++
 .../ice-failed-to-resolve-instance-for-110696.rs   |   1 -
 ...ce-failed-to-resolve-instance-for-110696.stderr |  15 +--
 .../impl-with-unconstrained-param.rs               |   2 -
 .../impl-with-unconstrained-param.stderr           |  17 +--
 tests/ui/type-alias-impl-trait/issue-74244.rs      |   1 -
 tests/ui/type-alias-impl-trait/issue-74244.stderr  |  11 +-
 26 files changed, 214 insertions(+), 283 deletions(-)
 delete mode 100644 tests/crashes/123141.rs
 delete mode 100644 tests/crashes/125874.rs
 delete mode 100644 tests/crashes/126942.rs
 delete mode 100644 tests/crashes/127804.rs
 delete mode 100644 tests/crashes/130967.rs
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization-2.rs
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization-2.stderr
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization.rs
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization.stderr

(limited to 'tests')

diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check.rs b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
index d9c70c3cee6..bb122009593 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
@@ -57,22 +57,24 @@ pub(crate) fn check_impl_wf(
     tcx: TyCtxt<'_>,
     impl_def_id: LocalDefId,
 ) -> Result<(), ErrorGuaranteed> {
-    let min_specialization = tcx.features().min_specialization();
-    let mut res = Ok(());
     debug_assert_matches!(tcx.def_kind(impl_def_id), DefKind::Impl { .. });
-    res = res.and(enforce_impl_params_are_constrained(tcx, impl_def_id));
-    if min_specialization {
+
+    // Check that the args are constrained. We queryfied the check for ty/const params
+    // since unconstrained type/const params cause ICEs in projection, so we want to
+    // detect those specifically and project those to `TyKind::Error`.
+    let mut res = tcx.ensure().enforce_impl_non_lifetime_params_are_constrained(impl_def_id);
+    res = res.and(enforce_impl_lifetime_params_are_constrained(tcx, impl_def_id));
+
+    if tcx.features().min_specialization() {
         res = res.and(check_min_specialization(tcx, impl_def_id));
     }
-
     res
 }
 
-fn enforce_impl_params_are_constrained(
+pub(crate) fn enforce_impl_lifetime_params_are_constrained(
     tcx: TyCtxt<'_>,
     impl_def_id: LocalDefId,
 ) -> Result<(), ErrorGuaranteed> {
-    // Every lifetime used in an associated type must be constrained.
     let impl_self_ty = tcx.type_of(impl_def_id).instantiate_identity();
     if impl_self_ty.references_error() {
         // Don't complain about unconstrained type params when self ty isn't known due to errors.
@@ -88,6 +90,7 @@ fn enforce_impl_params_are_constrained(
         // Compilation must continue in order for other important diagnostics to keep showing up.
         return Ok(());
     }
+
     let impl_generics = tcx.generics_of(impl_def_id);
     let impl_predicates = tcx.predicates_of(impl_def_id);
     let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).map(ty::EarlyBinder::instantiate_identity);
@@ -121,6 +124,84 @@ fn enforce_impl_params_are_constrained(
         })
         .collect();
 
+    let mut res = Ok(());
+    for param in &impl_generics.own_params {
+        match param.kind {
+            ty::GenericParamDefKind::Lifetime => {
+                let param_lt = cgp::Parameter::from(param.to_early_bound_region_data());
+                if lifetimes_in_associated_types.contains(&param_lt) // (*)
+                    && !input_parameters.contains(&param_lt)
+                {
+                    let mut diag = tcx.dcx().create_err(UnconstrainedGenericParameter {
+                        span: tcx.def_span(param.def_id),
+                        param_name: param.name,
+                        param_def_kind: tcx.def_descr(param.def_id),
+                        const_param_note: false,
+                        const_param_note2: false,
+                    });
+                    diag.code(E0207);
+                    res = Err(diag.emit());
+                }
+                // (*) This is a horrible concession to reality. I think it'd be
+                // better to just ban unconstrained lifetimes outright, but in
+                // practice people do non-hygienic macros like:
+                //
+                // ```
+                // macro_rules! __impl_slice_eq1 {
+                //   ($Lhs: ty, $Rhs: ty, $Bound: ident) => {
+                //     impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
+                //        ....
+                //     }
+                //   }
+                // }
+                // ```
+                //
+                // In a concession to backwards compatibility, we continue to
+                // permit those, so long as the lifetimes aren't used in
+                // associated types. I believe this is sound, because lifetimes
+                // used elsewhere are not projected back out.
+            }
+            ty::GenericParamDefKind::Type { .. } | ty::GenericParamDefKind::Const { .. } => {
+                // Enforced in `enforce_impl_non_lifetime_params_are_constrained`.
+            }
+        }
+    }
+    res
+}
+
+pub(crate) fn enforce_impl_non_lifetime_params_are_constrained(
+    tcx: TyCtxt<'_>,
+    impl_def_id: LocalDefId,
+) -> Result<(), ErrorGuaranteed> {
+    let impl_self_ty = tcx.type_of(impl_def_id).instantiate_identity();
+    if impl_self_ty.references_error() {
+        // Don't complain about unconstrained type params when self ty isn't known due to errors.
+        // (#36836)
+        tcx.dcx().span_delayed_bug(
+            tcx.def_span(impl_def_id),
+            format!(
+                "potentially unconstrained type parameters weren't evaluated: {impl_self_ty:?}",
+            ),
+        );
+        // This is super fishy, but our current `rustc_hir_analysis::check_crate` pipeline depends on
+        // `type_of` having been called much earlier, and thus this value being read from cache.
+        // Compilation must continue in order for other important diagnostics to keep showing up.
+        return Ok(());
+    }
+    let impl_generics = tcx.generics_of(impl_def_id);
+    let impl_predicates = tcx.predicates_of(impl_def_id);
+    let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).map(ty::EarlyBinder::instantiate_identity);
+
+    impl_trait_ref.error_reported()?;
+
+    let mut input_parameters = cgp::parameters_for_impl(tcx, impl_self_ty, impl_trait_ref);
+    cgp::identify_constrained_generic_params(
+        tcx,
+        impl_predicates,
+        impl_trait_ref,
+        &mut input_parameters,
+    );
+
     let mut res = Ok(());
     for param in &impl_generics.own_params {
         let err = match param.kind {
@@ -129,15 +210,14 @@ fn enforce_impl_params_are_constrained(
                 let param_ty = ty::ParamTy::for_def(param);
                 !input_parameters.contains(&cgp::Parameter::from(param_ty))
             }
-            ty::GenericParamDefKind::Lifetime => {
-                let param_lt = cgp::Parameter::from(param.to_early_bound_region_data());
-                lifetimes_in_associated_types.contains(&param_lt) && // (*)
-                    !input_parameters.contains(&param_lt)
-            }
             ty::GenericParamDefKind::Const { .. } => {
                 let param_ct = ty::ParamConst::for_def(param);
                 !input_parameters.contains(&cgp::Parameter::from(param_ct))
             }
+            ty::GenericParamDefKind::Lifetime => {
+                // Enforced in `enforce_impl_type_params_are_constrained`.
+                false
+            }
         };
         if err {
             let const_param_note = matches!(param.kind, ty::GenericParamDefKind::Const { .. });
@@ -153,23 +233,4 @@ fn enforce_impl_params_are_constrained(
         }
     }
     res
-
-    // (*) This is a horrible concession to reality. I think it'd be
-    // better to just ban unconstrained lifetimes outright, but in
-    // practice people do non-hygienic macros like:
-    //
-    // ```
-    // macro_rules! __impl_slice_eq1 {
-    //     ($Lhs: ty, $Rhs: ty, $Bound: ident) => {
-    //         impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
-    //            ....
-    //         }
-    //     }
-    // }
-    // ```
-    //
-    // In a concession to backwards compatibility, we continue to
-    // permit those, so long as the lifetimes aren't used in
-    // associated types. I believe this is sound, because lifetimes
-    // used elsewhere are not projected back out.
 }
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 87fd4de26a5..a42a168234f 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -128,6 +128,8 @@ pub fn provide(providers: &mut Providers) {
     hir_wf_check::provide(providers);
     *providers = Providers {
         inherit_sig_for_delegation_item: delegation::inherit_sig_for_delegation_item,
+        enforce_impl_non_lifetime_params_are_constrained:
+            impl_wf_check::enforce_impl_non_lifetime_params_are_constrained,
         ..*providers
     };
 }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 7e7b602c560..8b8467472f5 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1719,6 +1719,11 @@ rustc_queries! {
         ensure_forwards_result_if_red
     }
 
+    query enforce_impl_non_lifetime_params_are_constrained(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
+        desc { |tcx| "checking that `{}`'s generics are constrained by the impl header", tcx.def_path_str(key) }
+        ensure_forwards_result_if_red
+    }
+
     // The `DefId`s of all non-generic functions and statics in the given crate
     // that can be reached from outside the crate.
     //
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 54407d17dcf..69b7d5cff1e 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -950,39 +950,45 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                 //
                 // NOTE: This should be kept in sync with the similar code in
                 // `rustc_ty_utils::instance::resolve_associated_item()`.
-                let node_item = specialization_graph::assoc_def(
+                match specialization_graph::assoc_def(
                     selcx.tcx(),
                     impl_data.impl_def_id,
                     obligation.predicate.def_id,
-                )
-                .map_err(|ErrorGuaranteed { .. }| ())?;
-
-                if node_item.is_final() {
-                    // Non-specializable items are always projectable.
-                    true
-                } else {
-                    // Only reveal a specializable default if we're past type-checking
-                    // and the obligation is monomorphic, otherwise passes such as
-                    // transmute checking and polymorphic MIR optimizations could
-                    // get a result which isn't correct for all monomorphizations.
-                    match selcx.infcx.typing_mode() {
-                        TypingMode::Coherence
-                        | TypingMode::Analysis { .. }
-                        | TypingMode::PostBorrowckAnalysis { .. } => {
-                            debug!(
-                                assoc_ty = ?selcx.tcx().def_path_str(node_item.item.def_id),
-                                ?obligation.predicate,
-                                "assemble_candidates_from_impls: not eligible due to default",
-                            );
-                            false
-                        }
-                        TypingMode::PostAnalysis => {
-                            // NOTE(eddyb) inference variables can resolve to parameters, so
-                            // assume `poly_trait_ref` isn't monomorphic, if it contains any.
-                            let poly_trait_ref = selcx.infcx.resolve_vars_if_possible(trait_ref);
-                            !poly_trait_ref.still_further_specializable()
+                ) {
+                    Ok(node_item) => {
+                        if node_item.is_final() {
+                            // Non-specializable items are always projectable.
+                            true
+                        } else {
+                            // Only reveal a specializable default if we're past type-checking
+                            // and the obligation is monomorphic, otherwise passes such as
+                            // transmute checking and polymorphic MIR optimizations could
+                            // get a result which isn't correct for all monomorphizations.
+                            match selcx.infcx.typing_mode() {
+                                TypingMode::Coherence
+                                | TypingMode::Analysis { .. }
+                                | TypingMode::PostBorrowckAnalysis { .. } => {
+                                    debug!(
+                                        assoc_ty = ?selcx.tcx().def_path_str(node_item.item.def_id),
+                                        ?obligation.predicate,
+                                        "not eligible due to default",
+                                    );
+                                    false
+                                }
+                                TypingMode::PostAnalysis => {
+                                    // NOTE(eddyb) inference variables can resolve to parameters, so
+                                    // assume `poly_trait_ref` isn't monomorphic, if it contains any.
+                                    let poly_trait_ref =
+                                        selcx.infcx.resolve_vars_if_possible(trait_ref);
+                                    !poly_trait_ref.still_further_specializable()
+                                }
+                            }
                         }
                     }
+                    // Always project `ErrorGuaranteed`, since this will just help
+                    // us propagate `TyKind::Error` around which suppresses ICEs
+                    // and spurious, unrelated inference errors.
+                    Err(ErrorGuaranteed { .. }) => true,
                 }
             }
             ImplSource::Builtin(BuiltinImplSource::Misc, _) => {
@@ -2014,7 +2020,6 @@ fn confirm_impl_candidate<'cx, 'tcx>(
         Ok(assoc_ty) => assoc_ty,
         Err(guar) => return Progress::error(tcx, guar),
     };
-
     if !assoc_ty.item.defaultness(tcx).has_value() {
         // This means that the impl is missing a definition for the
         // associated type. This error will be reported by the type
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
index 13620f4b8d9..c351cf5aaac 100644
--- a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
@@ -376,6 +376,12 @@ pub(crate) fn assoc_def(
     // If there is no such item in that impl, this function will fail with a
     // cycle error if the specialization graph is currently being built.
     if let Some(&impl_item_id) = tcx.impl_item_implementor_ids(impl_def_id).get(&assoc_def_id) {
+        // Ensure that the impl is constrained, otherwise projection may give us
+        // bad unconstrained infer vars.
+        if let Some(impl_def_id) = impl_def_id.as_local() {
+            tcx.ensure().enforce_impl_non_lifetime_params_are_constrained(impl_def_id)?;
+        }
+
         let item = tcx.associated_item(impl_item_id);
         let impl_node = Node::Impl(impl_def_id);
         return Ok(LeafDef {
@@ -391,6 +397,14 @@ pub(crate) fn assoc_def(
 
     let ancestors = trait_def.ancestors(tcx, impl_def_id)?;
     if let Some(assoc_item) = ancestors.leaf_def(tcx, assoc_def_id) {
+        // Ensure that the impl is constrained, otherwise projection may give us
+        // bad unconstrained infer vars.
+        if assoc_item.item.container == ty::AssocItemContainer::Impl
+            && let Some(impl_def_id) = assoc_item.item.container_id(tcx).as_local()
+        {
+            tcx.ensure().enforce_impl_non_lifetime_params_are_constrained(impl_def_id)?;
+        }
+
         Ok(assoc_item)
     } else {
         // This is saying that neither the trait nor
diff --git a/tests/crashes/123141.rs b/tests/crashes/123141.rs
deleted file mode 100644
index 07181387e04..00000000000
--- a/tests/crashes/123141.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ known-bug: #123141
-
-trait Trait {
-    fn next(self) -> Self::Item;
-    type Item;
-}
-
-struct Foo<T: ?Sized>(T);
-
-impl<T: ?Sized, U> Trait for Foo<U> {
-    type Item = Foo<T>;
-    fn next(self) -> Self::Item {
-        loop {}
-    }
-}
-
-fn opaque() -> impl Trait {
-    Foo::<_>(10_u32)
-}
-
-fn main() {
-    opaque().next();
-}
diff --git a/tests/crashes/125874.rs b/tests/crashes/125874.rs
deleted file mode 100644
index 6a2713cd7c8..00000000000
--- a/tests/crashes/125874.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ known-bug: rust-lang/rust#125874
-pub trait A {}
-
-pub trait Mirror {
-    type Assoc: ?Sized;
-}
-impl<T: ?Sized> Mirror for dyn A {
-    type Assoc = T;
-}
-
-struct Bar {
-    foo: <dyn A + 'static as Mirror>::Assoc,
-}
-
-pub fn main() {
-    let strct = Bar { foo: 3 };
-
-    match strct {
-        Bar { foo: 1, .. } => {}
-        _ => (),
-    };
-}
diff --git a/tests/crashes/126942.rs b/tests/crashes/126942.rs
deleted file mode 100644
index e4adc8fab28..00000000000
--- a/tests/crashes/126942.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ known-bug: rust-lang/rust#126942
-struct Thing;
-
-pub trait Every {
-    type Assoc;
-}
-impl<T: ?Sized> Every for Thing {
-    type Assoc = T;
-}
-
-static I: <Thing as Every>::Assoc = 3;
diff --git a/tests/crashes/127804.rs b/tests/crashes/127804.rs
deleted file mode 100644
index e583a7c1fc6..00000000000
--- a/tests/crashes/127804.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ known-bug: #127804
-
-struct Thing;
-
-pub trait Every {
-    type Assoc;
-}
-impl<T: ?Sized> Every for Thing {
-    type Assoc = T;
-}
-
-fn foo(_: <Thing as Every>::Assoc) {}
diff --git a/tests/crashes/130967.rs b/tests/crashes/130967.rs
deleted file mode 100644
index 8a3aae72c20..00000000000
--- a/tests/crashes/130967.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #130967
-
-trait Producer {
-    type Produced;
-    fn make_one() -> Self::Produced;
-}
-
-impl<E: ?Sized> Producer for () {
-    type Produced = Option<E>;
-    fn make_one() -> Self::Produced {
-        loop {}
-    }
-}
diff --git a/tests/ui/generic-associated-types/bugs/issue-87735.stderr b/tests/ui/generic-associated-types/bugs/issue-87735.stderr
index d8005065238..1b955431363 100644
--- a/tests/ui/generic-associated-types/bugs/issue-87735.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-87735.stderr
@@ -22,73 +22,7 @@ help: consider adding an explicit lifetime bound
 LL |   type Output<'a> = FooRef<'a, U> where Self: 'a, U: 'a;
    |                                                 +++++++
 
-error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/issue-87735.rs:31:15
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
-...
-LL |     T: AsRef2<Output<'b> = &'b [U]>,
-   |               ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
-   |
-note: ...that is required by this bound
-  --> $DIR/issue-87735.rs:7:31
-   |
-LL |   type Output<'a> where Self: 'a;
-   |                               ^^
-help: consider adding an explicit lifetime bound
-   |
-LL |     T: AsRef2<Output<'b> = &'b [U]> + 'b,
-   |                                     ++++
-
-error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/issue-87735.rs:36:31
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
-...
-LL |   fn as_ref2<'a>(&'a self) -> Self::Output<'a> {
-   |                               ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
-   |
-note: ...that is required by this bound
-  --> $DIR/issue-87735.rs:7:31
-   |
-LL |   type Output<'a> where Self: 'a;
-   |                               ^^
-help: consider adding an explicit lifetime bound
-   |
-LL |     T: AsRef2<Output<'b> = &'b [U]> + 'b,
-   |                                     ++++
-
-error: lifetime may not live long enough
-  --> $DIR/issue-87735.rs:37:5
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- lifetime `'b` defined here
-...
-LL |   fn as_ref2<'a>(&'a self) -> Self::Output<'a> {
-   |              -- lifetime `'a` defined here
-LL |     FooRef(self.0.as_ref2())
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ method was supposed to return data with lifetime `'a` but it is returning data with lifetime `'b`
-   |
-   = help: consider adding the following bound: `'b: 'a`
-
-error: lifetime may not live long enough
-  --> $DIR/issue-87735.rs:37:12
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- lifetime `'b` defined here
-...
-LL |   fn as_ref2<'a>(&'a self) -> Self::Output<'a> {
-   |              -- lifetime `'a` defined here
-LL |     FooRef(self.0.as_ref2())
-   |            ^^^^^^^^^^^^^^^^ argument requires that `'a` must outlive `'b`
-   |
-   = help: consider adding the following bound: `'a: 'b`
-
-help: `'b` and `'a` must be the same: replace one with the other
-
-error: aborting due to 6 previous errors
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0207, E0309.
 For more information about an error, try `rustc --explain E0207`.
diff --git a/tests/ui/impl-trait/in-trait/refine-resolution-errors.rs b/tests/ui/impl-trait/in-trait/refine-resolution-errors.rs
index a9936c7bc3f..894f592d9e2 100644
--- a/tests/ui/impl-trait/in-trait/refine-resolution-errors.rs
+++ b/tests/ui/impl-trait/in-trait/refine-resolution-errors.rs
@@ -13,7 +13,6 @@ impl<T: ?Sized> Mirror for () {
 
 pub trait First {
     async fn first() -> <() as Mirror>::Assoc;
-    //~^ ERROR type annotations needed
 }
 
 impl First for () {
diff --git a/tests/ui/impl-trait/in-trait/refine-resolution-errors.stderr b/tests/ui/impl-trait/in-trait/refine-resolution-errors.stderr
index 0f5573dda04..10ebad2a7d5 100644
--- a/tests/ui/impl-trait/in-trait/refine-resolution-errors.stderr
+++ b/tests/ui/impl-trait/in-trait/refine-resolution-errors.stderr
@@ -4,13 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T: ?Sized> Mirror for () {
    |      ^ unconstrained type parameter
 
-error[E0282]: type annotations needed
-  --> $DIR/refine-resolution-errors.rs:15:5
-   |
-LL |     async fn first() -> <() as Mirror>::Assoc;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0207, E0282.
-For more information about an error, try `rustc --explain E0207`.
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/impl-trait/issues/issue-87340.rs b/tests/ui/impl-trait/issues/issue-87340.rs
index b1baaaa6ba5..705a4addcb7 100644
--- a/tests/ui/impl-trait/issues/issue-87340.rs
+++ b/tests/ui/impl-trait/issues/issue-87340.rs
@@ -9,8 +9,6 @@ impl<T> X for () {
     //~^ ERROR `T` is not constrained by the impl trait, self type, or predicates
     type I = impl Sized;
     fn f() -> Self::I {}
-    //~^ ERROR type annotations needed
-    //~| ERROR type annotations needed
 }
 
 fn main() {}
diff --git a/tests/ui/impl-trait/issues/issue-87340.stderr b/tests/ui/impl-trait/issues/issue-87340.stderr
index 1be4087be42..8513cb2881e 100644
--- a/tests/ui/impl-trait/issues/issue-87340.stderr
+++ b/tests/ui/impl-trait/issues/issue-87340.stderr
@@ -4,19 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T> X for () {
    |      ^ unconstrained type parameter
 
-error[E0282]: type annotations needed
-  --> $DIR/issue-87340.rs:11:23
-   |
-LL |     fn f() -> Self::I {}
-   |                       ^^ cannot infer type for type parameter `T`
-
-error[E0282]: type annotations needed
-  --> $DIR/issue-87340.rs:11:15
-   |
-LL |     fn f() -> Self::I {}
-   |               ^^^^^^^ cannot infer type for type parameter `T`
-
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0207, E0282.
-For more information about an error, try `rustc --explain E0207`.
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/impl-unused-tps.stderr b/tests/ui/impl-unused-tps.stderr
index da4589dee82..09c3fce641c 100644
--- a/tests/ui/impl-unused-tps.stderr
+++ b/tests/ui/impl-unused-tps.stderr
@@ -7,6 +7,12 @@ LL | impl<T> Foo<T> for [isize; 0] {
 LL | impl<T, U> Foo<T> for U {
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[isize; 0]`
 
+error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/impl-unused-tps.rs:32:9
+   |
+LL | impl<T, U> Bar for T {
+   |         ^ unconstrained type parameter
+
 error[E0119]: conflicting implementations of trait `Bar`
   --> $DIR/impl-unused-tps.rs:40:1
    |
@@ -46,12 +52,6 @@ error[E0207]: the type parameter `U` is not constrained by the impl trait, self
 LL | impl<T, U> Foo<T> for [isize; 1] {
    |         ^ unconstrained type parameter
 
-error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:32:9
-   |
-LL | impl<T, U> Bar for T {
-   |         ^ unconstrained type parameter
-
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
   --> $DIR/impl-unused-tps.rs:40:9
    |
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.rs b/tests/ui/traits/unconstrained-projection-normalization-2.rs
new file mode 100644
index 00000000000..085e9e4a61a
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization-2.rs
@@ -0,0 +1,17 @@
+// Make sure we don't ICE in `normalize_erasing_regions` when normalizing
+// an associated type in an impl with unconstrained non-lifetime params.
+// (This time in a function signature)
+
+struct Thing;
+
+pub trait Every {
+    type Assoc;
+}
+impl<T: ?Sized> Every for Thing {
+//~^ ERROR the type parameter `T` is not constrained
+    type Assoc = T;
+}
+
+fn foo(_: <Thing as Every>::Assoc) {}
+
+fn main() {}
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.stderr b/tests/ui/traits/unconstrained-projection-normalization-2.stderr
new file mode 100644
index 00000000000..6d3d4492b07
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization-2.stderr
@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained-projection-normalization-2.rs:10:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/traits/unconstrained-projection-normalization.rs b/tests/ui/traits/unconstrained-projection-normalization.rs
new file mode 100644
index 00000000000..e4d25a5ba6c
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization.rs
@@ -0,0 +1,16 @@
+// Make sure we don't ICE in `normalize_erasing_regions` when normalizing
+// an associated type in an impl with unconstrained non-lifetime params.
+
+struct Thing;
+
+pub trait Every {
+    type Assoc;
+}
+impl<T: ?Sized> Every for Thing {
+//~^ ERROR the type parameter `T` is not constrained
+    type Assoc = T;
+}
+
+static I: <Thing as Every>::Assoc = 3;
+
+fn main() {}
diff --git a/tests/ui/traits/unconstrained-projection-normalization.stderr b/tests/ui/traits/unconstrained-projection-normalization.stderr
new file mode 100644
index 00000000000..4e4421a73e5
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization.stderr
@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained-projection-normalization.rs:9:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.rs b/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.rs
index 0ee188d825f..2bcb8f06f4f 100644
--- a/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.rs
+++ b/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.rs
@@ -42,7 +42,6 @@ impl<T: MyFrom<Phantom2<DummyT<U>>>, U> MyIndex<DummyT<T>> for Scope<U> {
     //~^ ERROR the type parameter `T` is not constrained by the impl
     type O = T;
     fn my_index(self) -> Self::O {
-        //~^ ERROR item does not constrain
         MyFrom::my_from(self.0).ok().unwrap()
     }
 }
diff --git a/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.stderr b/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.stderr
index eace96317dc..0ab4c34381a 100644
--- a/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.stderr
+++ b/tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.stderr
@@ -17,19 +17,6 @@ note: this opaque type is in the signature
 LL | type DummyT<T> = impl F;
    |                  ^^^^^^
 
-error: item does not constrain `DummyT::{opaque#0}`, but has it in its signature
-  --> $DIR/ice-failed-to-resolve-instance-for-110696.rs:44:8
-   |
-LL |     fn my_index(self) -> Self::O {
-   |        ^^^^^^^^
-   |
-   = note: consider moving the opaque type's declaration and defining uses into a separate module
-note: this opaque type is in the signature
-  --> $DIR/ice-failed-to-resolve-instance-for-110696.rs:20:18
-   |
-LL | type DummyT<T> = impl F;
-   |                  ^^^^^^
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.rs b/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.rs
index fcac83500ec..1824ff5e2fb 100644
--- a/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.rs
+++ b/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.rs
@@ -12,8 +12,6 @@ impl<T> X for () {
     //~^ ERROR the type parameter `T` is not constrained
     type I = impl Sized;
     fn f() -> Self::I {}
-    //~^ ERROR type annotations needed
-    //~| ERROR type annotations needed
 }
 
 fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr b/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr
index bb0e11d314c..137a4db81b5 100644
--- a/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr
+++ b/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr
@@ -4,19 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T> X for () {
    |      ^ unconstrained type parameter
 
-error[E0282]: type annotations needed
-  --> $DIR/impl-with-unconstrained-param.rs:14:23
-   |
-LL |     fn f() -> Self::I {}
-   |                       ^^ cannot infer type for type parameter `T`
-
-error[E0282]: type annotations needed
-  --> $DIR/impl-with-unconstrained-param.rs:14:15
-   |
-LL |     fn f() -> Self::I {}
-   |               ^^^^^^^ cannot infer type for type parameter `T`
-
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0207, E0282.
-For more information about an error, try `rustc --explain E0207`.
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/issue-74244.rs b/tests/ui/type-alias-impl-trait/issue-74244.rs
index ce8a38a3361..bb4104b3d25 100644
--- a/tests/ui/type-alias-impl-trait/issue-74244.rs
+++ b/tests/ui/type-alias-impl-trait/issue-74244.rs
@@ -14,7 +14,6 @@ impl<T> Allocator for DefaultAllocator {
 type A = impl Fn(<DefaultAllocator as Allocator>::Buffer);
 
 fn foo() -> A {
-    //~^ ERROR: type annotations needed
     |_| ()
 }
 
diff --git a/tests/ui/type-alias-impl-trait/issue-74244.stderr b/tests/ui/type-alias-impl-trait/issue-74244.stderr
index d2b50ffd86b..f5ca56baccc 100644
--- a/tests/ui/type-alias-impl-trait/issue-74244.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-74244.stderr
@@ -4,13 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T> Allocator for DefaultAllocator {
    |      ^ unconstrained type parameter
 
-error[E0282]: type annotations needed
-  --> $DIR/issue-74244.rs:16:13
-   |
-LL | fn foo() -> A {
-   |             ^ cannot infer type for type parameter `T`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0207, E0282.
-For more information about an error, try `rustc --explain E0207`.
+For more information about this error, try `rustc --explain E0207`.
-- 
cgit 1.4.1-3-g733a5


From 7143ef6550f501083bcf6e8b516bb1ae3e191d29 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 3 Jan 2025 05:22:14 +0000
Subject: Also in the new solver

---
 compiler/rustc_next_trait_solver/src/delegate.rs   |  5 ++-
 .../src/solve/eval_ctxt/mod.rs                     |  2 +-
 .../src/solve/normalizes_to/mod.rs                 | 38 +++++++++++++---------
 .../rustc_trait_selection/src/solve/delegate.rs    |  5 ++-
 ...ained-projection-normalization-2.current.stderr |  9 +++++
 ...strained-projection-normalization-2.next.stderr |  9 +++++
 .../unconstrained-projection-normalization-2.rs    |  4 +++
 ...unconstrained-projection-normalization-2.stderr |  9 -----
 ...trained-projection-normalization.current.stderr |  9 +++++
 ...onstrained-projection-normalization.next.stderr |  9 +++++
 .../unconstrained-projection-normalization.rs      |  4 +++
 .../unconstrained-projection-normalization.stderr  |  9 -----
 12 files changed, 73 insertions(+), 39 deletions(-)
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization-2.current.stderr
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization-2.next.stderr
 delete mode 100644 tests/ui/traits/unconstrained-projection-normalization-2.stderr
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization.current.stderr
 create mode 100644 tests/ui/traits/unconstrained-projection-normalization.next.stderr
 delete mode 100644 tests/ui/traits/unconstrained-projection-normalization.stderr

(limited to 'tests')

diff --git a/compiler/rustc_next_trait_solver/src/delegate.rs b/compiler/rustc_next_trait_solver/src/delegate.rs
index 4ba54a2e0bf..2d2d50e62f9 100644
--- a/compiler/rustc_next_trait_solver/src/delegate.rs
+++ b/compiler/rustc_next_trait_solver/src/delegate.rs
@@ -95,7 +95,10 @@ pub trait SolverDelegate: Deref<Target = <Self as SolverDelegate>::Infcx> + Size
         goal_trait_ref: ty::TraitRef<Self::Interner>,
         trait_assoc_def_id: <Self::Interner as Interner>::DefId,
         impl_def_id: <Self::Interner as Interner>::DefId,
-    ) -> Result<Option<<Self::Interner as Interner>::DefId>, NoSolution>;
+    ) -> Result<
+        Option<<Self::Interner as Interner>::DefId>,
+        <Self::Interner as Interner>::ErrorGuaranteed,
+    >;
 
     fn is_transmutable(
         &self,
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 8c74490e0e0..91ad24bff67 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -950,7 +950,7 @@ where
         goal_trait_ref: ty::TraitRef<I>,
         trait_assoc_def_id: I::DefId,
         impl_def_id: I::DefId,
-    ) -> Result<Option<I::DefId>, NoSolution> {
+    ) -> Result<Option<I::DefId>, I::ErrorGuaranteed> {
         self.delegate.fetch_eligible_assoc_item(goal_trait_ref, trait_assoc_def_id, impl_def_id)
     }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index f5ecfea5408..76cbe5758b2 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -244,20 +244,7 @@ where
                     .map(|pred| goal.with(cx, pred)),
             );
 
-            // In case the associated item is hidden due to specialization, we have to
-            // return ambiguity this would otherwise be incomplete, resulting in
-            // unsoundness during coherence (#105782).
-            let Some(target_item_def_id) = ecx.fetch_eligible_assoc_item(
-                goal_trait_ref,
-                goal.predicate.def_id(),
-                impl_def_id,
-            )?
-            else {
-                return ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
-            };
-
-            let error_response = |ecx: &mut EvalCtxt<'_, D>, msg: &str| {
-                let guar = cx.delay_bug(msg);
+            let error_response = |ecx: &mut EvalCtxt<'_, D>, guar| {
                 let error_term = match goal.predicate.alias.kind(cx) {
                     ty::AliasTermKind::ProjectionTy => Ty::new_error(cx, guar).into(),
                     ty::AliasTermKind::ProjectionConst => Const::new_error(cx, guar).into(),
@@ -267,8 +254,24 @@ where
                 ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             };
 
+            // In case the associated item is hidden due to specialization, we have to
+            // return ambiguity this would otherwise be incomplete, resulting in
+            // unsoundness during coherence (#105782).
+            let target_item_def_id = match ecx.fetch_eligible_assoc_item(
+                goal_trait_ref,
+                goal.predicate.def_id(),
+                impl_def_id,
+            ) {
+                Ok(Some(target_item_def_id)) => target_item_def_id,
+                Ok(None) => {
+                    return ecx
+                        .evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
+                }
+                Err(guar) => return error_response(ecx, guar),
+            };
+
             if !cx.has_item_definition(target_item_def_id) {
-                return error_response(ecx, "missing item");
+                return error_response(ecx, cx.delay_bug("missing item"));
             }
 
             let target_container_def_id = cx.parent(target_item_def_id);
@@ -292,7 +295,10 @@ where
             )?;
 
             if !cx.check_args_compatible(target_item_def_id, target_args) {
-                return error_response(ecx, "associated item has mismatched arguments");
+                return error_response(
+                    ecx,
+                    cx.delay_bug("associated item has mismatched arguments"),
+                );
             }
 
             // Finally we construct the actual value of the associated type.
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 9b8c9ff6bb8..acd00d9f74f 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -190,9 +190,8 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         goal_trait_ref: ty::TraitRef<'tcx>,
         trait_assoc_def_id: DefId,
         impl_def_id: DefId,
-    ) -> Result<Option<DefId>, NoSolution> {
-        let node_item = specialization_graph::assoc_def(self.tcx, impl_def_id, trait_assoc_def_id)
-            .map_err(|ErrorGuaranteed { .. }| NoSolution)?;
+    ) -> Result<Option<DefId>, ErrorGuaranteed> {
+        let node_item = specialization_graph::assoc_def(self.tcx, impl_def_id, trait_assoc_def_id)?;
 
         let eligible = if node_item.is_final() {
             // Non-specializable items are always projectable.
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.current.stderr b/tests/ui/traits/unconstrained-projection-normalization-2.current.stderr
new file mode 100644
index 00000000000..2bb389c6ec1
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization-2.current.stderr
@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained-projection-normalization-2.rs:14:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.next.stderr b/tests/ui/traits/unconstrained-projection-normalization-2.next.stderr
new file mode 100644
index 00000000000..2bb389c6ec1
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization-2.next.stderr
@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained-projection-normalization-2.rs:14:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.rs b/tests/ui/traits/unconstrained-projection-normalization-2.rs
index 085e9e4a61a..6b584c436c6 100644
--- a/tests/ui/traits/unconstrained-projection-normalization-2.rs
+++ b/tests/ui/traits/unconstrained-projection-normalization-2.rs
@@ -2,6 +2,10 @@
 // an associated type in an impl with unconstrained non-lifetime params.
 // (This time in a function signature)
 
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
 struct Thing;
 
 pub trait Every {
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.stderr b/tests/ui/traits/unconstrained-projection-normalization-2.stderr
deleted file mode 100644
index 6d3d4492b07..00000000000
--- a/tests/ui/traits/unconstrained-projection-normalization-2.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/unconstrained-projection-normalization-2.rs:10:6
-   |
-LL | impl<T: ?Sized> Every for Thing {
-   |      ^ unconstrained type parameter
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/traits/unconstrained-projection-normalization.current.stderr b/tests/ui/traits/unconstrained-projection-normalization.current.stderr
new file mode 100644
index 00000000000..991f0e8ba66
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization.current.stderr
@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained-projection-normalization.rs:13:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/traits/unconstrained-projection-normalization.next.stderr b/tests/ui/traits/unconstrained-projection-normalization.next.stderr
new file mode 100644
index 00000000000..991f0e8ba66
--- /dev/null
+++ b/tests/ui/traits/unconstrained-projection-normalization.next.stderr
@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained-projection-normalization.rs:13:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/traits/unconstrained-projection-normalization.rs b/tests/ui/traits/unconstrained-projection-normalization.rs
index e4d25a5ba6c..fa4ab7fec4c 100644
--- a/tests/ui/traits/unconstrained-projection-normalization.rs
+++ b/tests/ui/traits/unconstrained-projection-normalization.rs
@@ -1,6 +1,10 @@
 // Make sure we don't ICE in `normalize_erasing_regions` when normalizing
 // an associated type in an impl with unconstrained non-lifetime params.
 
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
 struct Thing;
 
 pub trait Every {
diff --git a/tests/ui/traits/unconstrained-projection-normalization.stderr b/tests/ui/traits/unconstrained-projection-normalization.stderr
deleted file mode 100644
index 4e4421a73e5..00000000000
--- a/tests/ui/traits/unconstrained-projection-normalization.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/unconstrained-projection-normalization.rs:9:6
-   |
-LL | impl<T: ?Sized> Every for Thing {
-   |      ^ unconstrained type parameter
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0207`.
-- 
cgit 1.4.1-3-g733a5


From ac9cb908ac4301dfc25e7a2edee574320022ae2c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 2 Jan 2025 21:22:42 +0100
Subject: turn rustc_box into an intrinsic

---
 compiler/rustc_feature/src/builtin_attrs.rs        |   5 --
 compiler/rustc_hir_analysis/src/check/intrinsic.rs |   3 +
 compiler/rustc_mir_build/messages.ftl              |   5 --
 compiler/rustc_mir_build/src/errors.rs             |  19 ----
 compiler/rustc_mir_build/src/thir/cx/expr.rs       |  57 ++++--------
 compiler/rustc_span/src/symbol.rs                  |   1 -
 library/alloc/src/alloc.rs                         |   2 +-
 library/alloc/src/boxed.rs                         |  24 ++++-
 library/alloc/src/lib.rs                           |   1 +
 library/alloc/src/macros.rs                        |   5 +-
 .../disallowed_macros/disallowed_macros.stderr     |  17 ++--
 tests/mir-opt/box_expr.rs                          |   5 +-
 tests/mir-opt/building/uniform_array_move_out.rs   |  16 +---
 tests/mir-opt/const_prop/boxes.rs                  |   6 +-
 tests/mir-opt/issue_62289.rs                       |   7 +-
 tests/ui/attributes/rustc-box.rs                   |  18 ----
 tests/ui/attributes/rustc-box.stderr               |  34 -------
 tests/ui/coroutine/issue-105084.rs                 |   5 +-
 tests/ui/coroutine/issue-105084.stderr             |  16 ++--
 tests/ui/lint/unused/unused-allocation.rs          |   2 -
 tests/ui/lint/unused/unused-allocation.stderr      |  16 ++--
 tests/ui/macros/vec-macro-in-pattern.rs            |   4 +-
 tests/ui/macros/vec-macro-in-pattern.stderr        |  31 +++++--
 tests/ui/unpretty/box.rs                           |   7 +-
 tests/ui/unpretty/box.stdout                       | 100 ++++++++++++++++++---
 25 files changed, 198 insertions(+), 208 deletions(-)
 delete mode 100644 tests/ui/attributes/rustc-box.rs
 delete mode 100644 tests/ui/attributes/rustc-box.stderr

(limited to 'tests')

diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 4112ae80980..71941c8a206 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -933,11 +933,6 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         "#[rustc_has_incoherent_inherent_impls] allows the addition of incoherent inherent impls for \
          the given type by annotating all impl items with #[rustc_allow_incoherent_impl]."
     ),
-    rustc_attr!(
-        rustc_box, AttributeType::Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::No,
-        "#[rustc_box] allows creating boxes \
-        and it is only intended to be used in `alloc`."
-    ),
 
     BuiltinAttribute {
         name: sym::rustc_diagnostic_item,
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index fd78bf3e8fc..5595cc3280f 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -86,6 +86,7 @@ pub fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -
         | sym::assert_inhabited
         | sym::assert_zero_valid
         | sym::assert_mem_uninitialized_valid
+        | sym::box_new
         | sym::breakpoint
         | sym::size_of
         | sym::min_align_of
@@ -606,6 +607,8 @@ pub fn check_intrinsic_type(
 
             sym::ub_checks => (0, 0, Vec::new(), tcx.types.bool),
 
+            sym::box_new => (1, 0, vec![param(0)], Ty::new_box(tcx, param(0))),
+
             sym::simd_eq
             | sym::simd_ne
             | sym::simd_lt
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index edba247c7b0..5d61a9d1e75 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -287,11 +287,6 @@ mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabite
 
 mir_build_rust_2024_incompatible_pat = this pattern relies on behavior which may change in edition 2024
 
-mir_build_rustc_box_attribute_error = `#[rustc_box]` attribute used incorrectly
-    .attributes = no other attributes may be applied
-    .not_box = `#[rustc_box]` may only be applied to a `Box::new()` call
-    .missing_box = `#[rustc_box]` requires the `owned_box` lang item
-
 mir_build_static_in_pattern = statics cannot be referenced in patterns
     .label = can't be used in patterns
 mir_build_static_in_pattern_def = `static` defined here
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index be5f8bdffb5..790d56860d2 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -1067,25 +1067,6 @@ pub(crate) enum MiscPatternSuggestion {
     },
 }
 
-#[derive(Diagnostic)]
-#[diag(mir_build_rustc_box_attribute_error)]
-pub(crate) struct RustcBoxAttributeError {
-    #[primary_span]
-    pub(crate) span: Span,
-    #[subdiagnostic]
-    pub(crate) reason: RustcBoxAttrReason,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum RustcBoxAttrReason {
-    #[note(mir_build_attributes)]
-    Attributes,
-    #[note(mir_build_not_box)]
-    NotBoxNew,
-    #[note(mir_build_missing_box)]
-    MissingBox,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(mir_build_rust_2024_incompatible_pat)]
 pub(crate) struct Rust2024IncompatiblePat<'a> {
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 0338ac674e5..9cdf08d749b 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -20,7 +20,6 @@ use rustc_middle::{bug, span_bug};
 use rustc_span::{Span, sym};
 use tracing::{debug, info, instrument, trace};
 
-use crate::errors;
 use crate::thir::cx::Cx;
 use crate::thir::util::UserAnnotatedTyHelpers;
 
@@ -380,45 +379,25 @@ impl<'tcx> Cx<'tcx> {
                         from_hir_call: true,
                         fn_span: expr.span,
                     }
-                } else {
-                    let attrs = tcx.hir().attrs(expr.hir_id);
-                    if attrs.iter().any(|a| a.name_or_empty() == sym::rustc_box) {
-                        if attrs.len() != 1 {
-                            tcx.dcx().emit_err(errors::RustcBoxAttributeError {
-                                span: attrs[0].span,
-                                reason: errors::RustcBoxAttrReason::Attributes,
-                            });
-                        } else if let Some(box_item) = tcx.lang_items().owned_box() {
-                            if let hir::ExprKind::Path(hir::QPath::TypeRelative(ty, fn_path)) =
-                                fun.kind
-                                && let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
-                                && path.res.opt_def_id().is_some_and(|did| did == box_item)
-                                && fn_path.ident.name == sym::new
-                                && let [value] = args
-                            {
-                                return Expr {
-                                    temp_lifetime: TempLifetime {
-                                        temp_lifetime,
-                                        backwards_incompatible,
-                                    },
-                                    ty: expr_ty,
-                                    span: expr.span,
-                                    kind: ExprKind::Box { value: self.mirror_expr(value) },
-                                };
-                            } else {
-                                tcx.dcx().emit_err(errors::RustcBoxAttributeError {
-                                    span: expr.span,
-                                    reason: errors::RustcBoxAttrReason::NotBoxNew,
-                                });
-                            }
-                        } else {
-                            tcx.dcx().emit_err(errors::RustcBoxAttributeError {
-                                span: attrs[0].span,
-                                reason: errors::RustcBoxAttrReason::MissingBox,
-                            });
-                        }
+                } else if let ty::FnDef(def_id, _) = self.typeck_results().expr_ty(fun).kind()
+                    && let Some(intrinsic) = self.tcx.intrinsic(def_id)
+                    && intrinsic.name == sym::box_new
+                {
+                    // We don't actually evaluate `fun` here, so make sure that doesn't miss any side-effects.
+                    if !matches!(fun.kind, hir::ExprKind::Path(_)) {
+                        span_bug!(
+                            expr.span,
+                            "`box_new` intrinsic can only be called via path expression"
+                        );
                     }
-
+                    let value = &args[0];
+                    return Expr {
+                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        ty: expr_ty,
+                        span: expr.span,
+                        kind: ExprKind::Box { value: self.mirror_expr(value) },
+                    };
+                } else {
                     // Tuple-like ADTs are represented as ExprKind::Call. We convert them here.
                     let adt_data = if let hir::ExprKind::Path(ref qpath) = fun.kind
                         && let Some(adt_def) = expr_ty.ty_adt_def()
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 4ecc4201f89..bdfbfb1e38d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1696,7 +1696,6 @@ symbols! {
         rustc_as_ptr,
         rustc_attrs,
         rustc_autodiff,
-        rustc_box,
         rustc_builtin_macro,
         rustc_capture_analysis,
         rustc_clean,
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
index ae34fc65326..e9b7f985667 100644
--- a/library/alloc/src/alloc.rs
+++ b/library/alloc/src/alloc.rs
@@ -339,7 +339,7 @@ unsafe impl Allocator for Global {
     }
 }
 
-/// The allocator for unique pointers.
+/// The allocator for `Box`.
 #[cfg(all(not(no_global_oom_handling), not(test)))]
 #[lang = "exchange_malloc"]
 #[inline]
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 05e5d712a27..0f66217b5cb 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -233,6 +233,27 @@ pub struct Box<
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
 >(Unique<T>, A);
 
+/// Constructs a `Box<T>` by calling the `exchange_malloc` lang item and moving the argument into
+/// the newly allocated memory. This is an intrinsic to avoid unnecessary copies.
+///
+/// This is the surface syntax for `box <expr>` expressions.
+#[cfg(not(bootstrap))]
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[unstable(feature = "liballoc_internals", issue = "none")]
+pub fn box_new<T>(_x: T) -> Box<T> {
+    unreachable!()
+}
+
+/// Transition function for the next bootstrap bump.
+#[cfg(bootstrap)]
+#[unstable(feature = "liballoc_internals", issue = "none")]
+#[inline(always)]
+pub fn box_new<T>(x: T) -> Box<T> {
+    #[rustc_box]
+    Box::new(x)
+}
+
 impl<T> Box<T> {
     /// Allocates memory on the heap and then places `x` into it.
     ///
@@ -250,8 +271,7 @@ impl<T> Box<T> {
     #[rustc_diagnostic_item = "box_new"]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn new(x: T) -> Self {
-        #[rustc_box]
-        Box::new(x)
+        return box_new(x);
     }
 
     /// Constructs a new box with uninitialized contents.
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 40759cb0ba8..aff90f5abb3 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -168,6 +168,7 @@
 #![feature(dropck_eyepatch)]
 #![feature(fundamental)]
 #![feature(hashmap_internals)]
+#![feature(intrinsics)]
 #![feature(lang_items)]
 #![feature(min_specialization)]
 #![feature(multiple_supertrait_upcastable)]
diff --git a/library/alloc/src/macros.rs b/library/alloc/src/macros.rs
index 8c6a367869c..6ee3907cc8e 100644
--- a/library/alloc/src/macros.rs
+++ b/library/alloc/src/macros.rs
@@ -48,10 +48,9 @@ macro_rules! vec {
     );
     ($($x:expr),+ $(,)?) => (
         <[_]>::into_vec(
-            // This rustc_box is not required, but it produces a dramatic improvement in compile
+            // Using the intrinsic produces a dramatic improvement in compile
             // time when constructing arrays with many elements.
-            #[rustc_box]
-            $crate::boxed::Box::new([$($x),+])
+            $crate::boxed::box_new([$($x),+])
         )
     );
 }
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr b/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
index 2e3386628b4..6a6c6168a1f 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
+++ b/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
@@ -1,12 +1,3 @@
-error: use of a disallowed macro `std::vec`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:16:5
-   |
-LL |     vec![1, 2, 3];
-   |     ^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::disallowed-macros` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::disallowed_macros)]`
-
 error: use of a disallowed macro `serde::Serialize`
   --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:18:14
    |
@@ -14,6 +5,8 @@ LL |     #[derive(Serialize)]
    |              ^^^^^^^^^
    |
    = note: no serializing
+   = note: `-D clippy::disallowed-macros` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::disallowed_macros)]`
 
 error: use of a disallowed macro `macros::attr`
   --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:31:1
@@ -47,6 +40,12 @@ error: use of a disallowed macro `std::cfg`
 LL |     cfg!(unix);
    |     ^^^^^^^^^^
 
+error: use of a disallowed macro `std::vec`
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:16:5
+   |
+LL |     vec![1, 2, 3];
+   |     ^^^^^^^^^^^^^
+
 error: use of a disallowed macro `macros::expr`
   --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:21:13
    |
diff --git a/tests/mir-opt/box_expr.rs b/tests/mir-opt/box_expr.rs
index 41cd4ca57bf..233946e713c 100644
--- a/tests/mir-opt/box_expr.rs
+++ b/tests/mir-opt/box_expr.rs
@@ -1,7 +1,7 @@
 //@ test-mir-pass: ElaborateDrops
 //@ needs-unwind
 
-#![feature(rustc_attrs, stmt_expr_attributes)]
+#![feature(rustc_attrs, liballoc_internals)]
 
 // EMIT_MIR box_expr.main.ElaborateDrops.diff
 fn main() {
@@ -17,8 +17,7 @@ fn main() {
     // CHECK:   [[boxref:_.*]] = &mut [[box]];
     // CHECK:   <Box<S> as Drop>::drop(move [[boxref]])
 
-    let x = #[rustc_box]
-    Box::new(S::new());
+    let x = std::boxed::box_new(S::new());
     drop(x);
 }
 
diff --git a/tests/mir-opt/building/uniform_array_move_out.rs b/tests/mir-opt/building/uniform_array_move_out.rs
index 0682891611d..aff5996d0b6 100644
--- a/tests/mir-opt/building/uniform_array_move_out.rs
+++ b/tests/mir-opt/building/uniform_array_move_out.rs
@@ -1,25 +1,15 @@
 // skip-filecheck
-#![feature(stmt_expr_attributes, rustc_attrs)]
+#![feature(liballoc_internals, rustc_attrs)]
 
 // EMIT_MIR uniform_array_move_out.move_out_from_end.built.after.mir
 fn move_out_from_end() {
-    let a = [
-        #[rustc_box]
-        Box::new(1),
-        #[rustc_box]
-        Box::new(2),
-    ];
+    let a = [std::boxed::box_new(1), std::boxed::box_new(2)];
     let [.., _y] = a;
 }
 
 // EMIT_MIR uniform_array_move_out.move_out_by_subslice.built.after.mir
 fn move_out_by_subslice() {
-    let a = [
-        #[rustc_box]
-        Box::new(1),
-        #[rustc_box]
-        Box::new(2),
-    ];
+    let a = [std::boxed::box_new(1), std::boxed::box_new(2)];
     let [_y @ ..] = a;
 }
 
diff --git a/tests/mir-opt/const_prop/boxes.rs b/tests/mir-opt/const_prop/boxes.rs
index f04db260e27..a192d6b4133 100644
--- a/tests/mir-opt/const_prop/boxes.rs
+++ b/tests/mir-opt/const_prop/boxes.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: -O
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 
-#![feature(rustc_attrs, stmt_expr_attributes)]
+#![feature(rustc_attrs, liballoc_internals)]
 
 // Note: this test verifies that we, in fact, do not const prop `#[rustc_box]`
 
@@ -13,7 +13,5 @@ fn main() {
     // CHECK: (*{{_.*}}) = const 42_i32;
     // CHECK: [[tmp:_.*]] = copy (*{{_.*}});
     // CHECK: [[x]] = copy [[tmp]];
-    let x = *(#[rustc_box]
-    Box::new(42))
-        + 0;
+    let x = *(std::boxed::box_new(42)) + 0;
 }
diff --git a/tests/mir-opt/issue_62289.rs b/tests/mir-opt/issue_62289.rs
index 40e8352cff4..d020c2cedca 100644
--- a/tests/mir-opt/issue_62289.rs
+++ b/tests/mir-opt/issue_62289.rs
@@ -3,14 +3,11 @@
 // initializing it
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 
-#![feature(rustc_attrs)]
+#![feature(rustc_attrs, liballoc_internals)]
 
 // EMIT_MIR issue_62289.test.ElaborateDrops.before.mir
 fn test() -> Option<Box<u32>> {
-    Some(
-        #[rustc_box]
-        Box::new(None?),
-    )
+    Some(std::boxed::box_new(None?))
 }
 
 fn main() {
diff --git a/tests/ui/attributes/rustc-box.rs b/tests/ui/attributes/rustc-box.rs
deleted file mode 100644
index b3726fb3867..00000000000
--- a/tests/ui/attributes/rustc-box.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-#![feature(rustc_attrs, stmt_expr_attributes)]
-
-fn foo(_: u32, _: u32) {}
-fn bar(_: u32) {}
-
-fn main() {
-    #[rustc_box]
-    Box::new(1); // OK
-    #[rustc_box]
-    Box::pin(1); //~ ERROR `#[rustc_box]` attribute used incorrectly
-    #[rustc_box]
-    foo(1, 1); //~ ERROR `#[rustc_box]` attribute used incorrectly
-    #[rustc_box]
-    bar(1); //~ ERROR `#[rustc_box]` attribute used incorrectly
-    #[rustc_box] //~ ERROR `#[rustc_box]` attribute used incorrectly
-    #[rustfmt::skip]
-    Box::new(1);
-}
diff --git a/tests/ui/attributes/rustc-box.stderr b/tests/ui/attributes/rustc-box.stderr
deleted file mode 100644
index 073a18c7d58..00000000000
--- a/tests/ui/attributes/rustc-box.stderr
+++ /dev/null
@@ -1,34 +0,0 @@
-error: `#[rustc_box]` attribute used incorrectly
-  --> $DIR/rustc-box.rs:10:5
-   |
-LL |     Box::pin(1);
-   |     ^^^^^^^^^^^
-   |
-   = note: `#[rustc_box]` may only be applied to a `Box::new()` call
-
-error: `#[rustc_box]` attribute used incorrectly
-  --> $DIR/rustc-box.rs:12:5
-   |
-LL |     foo(1, 1);
-   |     ^^^^^^^^^
-   |
-   = note: `#[rustc_box]` may only be applied to a `Box::new()` call
-
-error: `#[rustc_box]` attribute used incorrectly
-  --> $DIR/rustc-box.rs:14:5
-   |
-LL |     bar(1);
-   |     ^^^^^^
-   |
-   = note: `#[rustc_box]` may only be applied to a `Box::new()` call
-
-error: `#[rustc_box]` attribute used incorrectly
-  --> $DIR/rustc-box.rs:15:5
-   |
-LL |     #[rustc_box]
-   |     ^^^^^^^^^^^^
-   |
-   = note: no other attributes may be applied
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/coroutine/issue-105084.rs b/tests/ui/coroutine/issue-105084.rs
index 0f6168ec58b..cddee499017 100644
--- a/tests/ui/coroutine/issue-105084.rs
+++ b/tests/ui/coroutine/issue-105084.rs
@@ -2,7 +2,7 @@
 #![feature(coroutines)]
 #![feature(coroutine_clone)]
 #![feature(coroutine_trait)]
-#![feature(rustc_attrs, stmt_expr_attributes)]
+#![feature(rustc_attrs, stmt_expr_attributes, liballoc_internals)]
 
 use std::ops::Coroutine;
 use std::pin::Pin;
@@ -19,8 +19,7 @@ fn main() {
         // - create a Box that is ignored for trait computations;
         // - compute fields (and yields);
         // - assign to `t`.
-        let t = #[rustc_box]
-        Box::new((5, yield));
+        let t = std::boxed::box_new((5, yield));
         drop(t);
     };
 
diff --git a/tests/ui/coroutine/issue-105084.stderr b/tests/ui/coroutine/issue-105084.stderr
index 073f1fbea4c..23c1fdc5459 100644
--- a/tests/ui/coroutine/issue-105084.stderr
+++ b/tests/ui/coroutine/issue-105084.stderr
@@ -1,5 +1,5 @@
 error[E0382]: borrow of moved value: `g`
-  --> $DIR/issue-105084.rs:39:14
+  --> $DIR/issue-105084.rs:38:14
    |
 LL |     let mut g = #[coroutine]
    |         ----- move occurs because `g` has type `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`, which does not implement the `Copy` trait
@@ -23,7 +23,7 @@ LL |     let mut h = copy(g.clone());
    |                       ++++++++
 
 error[E0277]: the trait bound `Box<(i32, ())>: Copy` is not satisfied in `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`
-  --> $DIR/issue-105084.rs:33:17
+  --> $DIR/issue-105084.rs:32:17
    |
 LL |     || {
    |     -- within this `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`
@@ -32,13 +32,13 @@ LL |     let mut h = copy(g);
    |                 ^^^^^^^ within `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`, the trait `Copy` is not implemented for `Box<(i32, ())>`
    |
 note: coroutine does not implement `Copy` as this value is used across a yield
-  --> $DIR/issue-105084.rs:23:22
+  --> $DIR/issue-105084.rs:22:41
    |
-LL |         Box::new((5, yield));
-   |         -------------^^^^^--
-   |         |            |
-   |         |            yield occurs here, with `Box::new((5, yield))` maybe used later
-   |         has type `Box<(i32, ())>` which does not implement `Copy`
+LL |         let t = std::boxed::box_new((5, yield));
+   |                 ------------------------^^^^^--
+   |                 |                       |
+   |                 |                       yield occurs here, with `std::boxed::box_new((5, yield))` maybe used later
+   |                 has type `Box<(i32, ())>` which does not implement `Copy`
 note: required by a bound in `copy`
   --> $DIR/issue-105084.rs:10:12
    |
diff --git a/tests/ui/lint/unused/unused-allocation.rs b/tests/ui/lint/unused/unused-allocation.rs
index c1a6f5ceaf1..1d5727362ea 100644
--- a/tests/ui/lint/unused/unused-allocation.rs
+++ b/tests/ui/lint/unused/unused-allocation.rs
@@ -1,7 +1,5 @@
-#![feature(rustc_attrs, stmt_expr_attributes)]
 #![deny(unused_allocation)]
 
 fn main() {
-    _ = (#[rustc_box] Box::new([1])).len(); //~ error: unnecessary allocation, use `&` instead
     _ = Box::new([1]).len(); //~ error: unnecessary allocation, use `&` instead
 }
diff --git a/tests/ui/lint/unused/unused-allocation.stderr b/tests/ui/lint/unused/unused-allocation.stderr
index c9ccfbd30e5..4487395e908 100644
--- a/tests/ui/lint/unused/unused-allocation.stderr
+++ b/tests/ui/lint/unused/unused-allocation.stderr
@@ -1,20 +1,14 @@
 error: unnecessary allocation, use `&` instead
-  --> $DIR/unused-allocation.rs:5:9
+  --> $DIR/unused-allocation.rs:4:9
    |
-LL |     _ = (#[rustc_box] Box::new([1])).len();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     _ = Box::new([1]).len();
+   |         ^^^^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/unused-allocation.rs:2:9
+  --> $DIR/unused-allocation.rs:1:9
    |
 LL | #![deny(unused_allocation)]
    |         ^^^^^^^^^^^^^^^^^
 
-error: unnecessary allocation, use `&` instead
-  --> $DIR/unused-allocation.rs:6:9
-   |
-LL |     _ = Box::new([1]).len();
-   |         ^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/vec-macro-in-pattern.rs b/tests/ui/macros/vec-macro-in-pattern.rs
index 26d7d4280fa..9b9a1edf54c 100644
--- a/tests/ui/macros/vec-macro-in-pattern.rs
+++ b/tests/ui/macros/vec-macro-in-pattern.rs
@@ -4,7 +4,9 @@
 
 fn main() {
     match Some(vec![42]) {
-        Some(vec![43]) => {} //~ ERROR expected pattern, found `#`
+        Some(vec![43]) => {} //~ ERROR expected a pattern, found a function call
+        //~| ERROR found associated function
+        //~| ERROR usage of qualified paths in this context is experimental
         _ => {}
     }
 }
diff --git a/tests/ui/macros/vec-macro-in-pattern.stderr b/tests/ui/macros/vec-macro-in-pattern.stderr
index f32a2cf8e43..71ba0ea5ad4 100644
--- a/tests/ui/macros/vec-macro-in-pattern.stderr
+++ b/tests/ui/macros/vec-macro-in-pattern.stderr
@@ -1,14 +1,33 @@
-error: expected pattern, found `#`
+error[E0532]: expected a pattern, found a function call
+  --> $DIR/vec-macro-in-pattern.rs:7:14
+   |
+LL |         Some(vec![43]) => {}
+   |              ^^^^^^^^ not a tuple struct or tuple variant
+   |
+   = note: function calls are not allowed in patterns: <https://doc.rust-lang.org/book/ch19-00-patterns.html>
+   = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0658]: usage of qualified paths in this context is experimental
   --> $DIR/vec-macro-in-pattern.rs:7:14
    |
 LL |         Some(vec![43]) => {}
    |              ^^^^^^^^
-   |              |
-   |              expected pattern
-   |              in this macro invocation
-   |              this macro call doesn't expand to a pattern
    |
+   = note: see issue #86935 <https://github.com/rust-lang/rust/issues/86935> for more information
+   = help: add `#![feature(more_qualified_paths)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0164]: expected tuple struct or tuple variant, found associated function `<[_]>::into_vec`
+  --> $DIR/vec-macro-in-pattern.rs:7:14
+   |
+LL |         Some(vec![43]) => {}
+   |              ^^^^^^^^ `fn` calls are not allowed in patterns
+   |
+   = help: for more information, visit https://doc.rust-lang.org/book/ch19-00-patterns.html
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 1 previous error
+error: aborting due to 3 previous errors
 
+Some errors have detailed explanations: E0164, E0532, E0658.
+For more information about an error, try `rustc --explain E0164`.
diff --git a/tests/ui/unpretty/box.rs b/tests/ui/unpretty/box.rs
index 8972eccf3b8..83fdeff7a17 100644
--- a/tests/ui/unpretty/box.rs
+++ b/tests/ui/unpretty/box.rs
@@ -1,9 +1,8 @@
-//@ compile-flags: -Zunpretty=hir
+//@ compile-flags: -Zunpretty=thir-tree
 //@ check-pass
 
-#![feature(stmt_expr_attributes, rustc_attrs)]
+#![feature(liballoc_internals)]
 
 fn main() {
-    let _ = #[rustc_box]
-    Box::new(1);
+    let _ = std::boxed::box_new(1);
 }
diff --git a/tests/ui/unpretty/box.stdout b/tests/ui/unpretty/box.stdout
index e3b9b9ac207..92155d0c73b 100644
--- a/tests/ui/unpretty/box.stdout
+++ b/tests/ui/unpretty/box.stdout
@@ -1,14 +1,90 @@
-//@ compile-flags: -Zunpretty=hir
-//@ check-pass
+DefId(0:3 ~ box[efb9]::main):
+params: [
+]
+body:
+    Expr {
+        ty: ()
+        temp_lifetime: TempLifetime { temp_lifetime: Some(Node(11)), backwards_incompatible: None }
+        span: $DIR/box.rs:6:11: 8:2 (#0)
+        kind: 
+            Scope {
+                region_scope: Node(11)
+                lint_level: Explicit(HirId(DefId(0:3 ~ box[efb9]::main).11))
+                value:
+                    Expr {
+                        ty: ()
+                        temp_lifetime: TempLifetime { temp_lifetime: Some(Node(11)), backwards_incompatible: None }
+                        span: $DIR/box.rs:6:11: 8:2 (#0)
+                        kind: 
+                            Block {
+                                targeted_by_break: false
+                                span: $DIR/box.rs:6:11: 8:2 (#0)
+                                region_scope: Node(1)
+                                safety_mode: Safe
+                                stmts: [
+                                    Stmt {
+                                        kind: Let {
+                                            remainder_scope: Remainder { block: 1, first_statement_index: 0}
+                                            init_scope: Node(2)
+                                            pattern: 
+                                                Pat: {
+                                                    ty: std::boxed::Box<i32, std::alloc::Global>
+                                                    span: $DIR/box.rs:7:9: 7:10 (#0)
+                                                    kind: PatKind {
+                                                        Wild
+                                                    }
+                                                }
+                                            ,
+                                            initializer: Some(
+                                                Expr {
+                                                    ty: std::boxed::Box<i32, std::alloc::Global>
+                                                    temp_lifetime: TempLifetime { temp_lifetime: Some(Node(2)), backwards_incompatible: None }
+                                                    span: $DIR/box.rs:7:13: 7:35 (#0)
+                                                    kind: 
+                                                        Scope {
+                                                            region_scope: Node(3)
+                                                            lint_level: Explicit(HirId(DefId(0:3 ~ box[efb9]::main).3))
+                                                            value:
+                                                                Expr {
+                                                                    ty: std::boxed::Box<i32, std::alloc::Global>
+                                                                    temp_lifetime: TempLifetime { temp_lifetime: Some(Node(2)), backwards_incompatible: None }
+                                                                    span: $DIR/box.rs:7:13: 7:35 (#0)
+                                                                    kind: 
+                                                                        Box {
+                                                                            Expr {
+                                                                                ty: i32
+                                                                                temp_lifetime: TempLifetime { temp_lifetime: Some(Node(2)), backwards_incompatible: None }
+                                                                                span: $DIR/box.rs:7:33: 7:34 (#0)
+                                                                                kind: 
+                                                                                    Scope {
+                                                                                        region_scope: Node(8)
+                                                                                        lint_level: Explicit(HirId(DefId(0:3 ~ box[efb9]::main).8))
+                                                                                        value:
+                                                                                            Expr {
+                                                                                                ty: i32
+                                                                                                temp_lifetime: TempLifetime { temp_lifetime: Some(Node(2)), backwards_incompatible: None }
+                                                                                                span: $DIR/box.rs:7:33: 7:34 (#0)
+                                                                                                kind: 
+                                                                                                    Literal( lit: Spanned { node: Int(Pu128(1), Unsuffixed), span: $DIR/box.rs:7:33: 7:34 (#0) }, neg: false)
+
+                                                                                            }
+                                                                                    }
+                                                                            }
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                            )
+                                            else_block: None
+                                            lint_level: Explicit(HirId(DefId(0:3 ~ box[efb9]::main).9))
+                                            span: $DIR/box.rs:7:5: 7:35 (#0)
+                                        }
+                                    }
+                                ]
+                                expr: []
+                            }
+                    }
+            }
+    }
 
-#![feature(stmt_expr_attributes, rustc_attrs)]
-#[prelude_import]
-use ::std::prelude::rust_2015::*;
-#[macro_use]
-extern crate std;
 
-fn main() {
-    let _ =
-        #[rustc_box]
-        Box::new(1);
-}
-- 
cgit 1.4.1-3-g733a5


From 5a0ce36232101334da178f154ec79066cb5f2a61 Mon Sep 17 00:00:00 2001
From: YunQiang Su <yunqiang@isrc.iscas.ac.cn>
Date: Fri, 3 Jan 2025 09:16:05 +0800
Subject: Target: Add mips mti baremetal support

Do the same thing as gcc, which use the vendor `mti` to mark
the toolchain as MIPS32r2 default.

We support both big endian and little endian flavor:
  mips-mti-none-elf
  mipsel-mti-none-elf
---
 compiler/rustc_target/src/spec/mod.rs              |  2 ++
 .../src/spec/targets/mips_mti_none_elf.rs          | 36 ++++++++++++++++++++++
 .../src/spec/targets/mipsel_mti_none_elf.rs        | 36 ++++++++++++++++++++++
 src/doc/rustc/src/SUMMARY.md                       |  1 +
 src/doc/rustc/src/platform-support.md              |  2 ++
 .../src/platform-support/mips-mti-none-elf.md      | 31 +++++++++++++++++++
 src/tools/build-manifest/src/main.rs               |  2 ++
 tests/assembly/targets/targets-elf.rs              |  6 ++++
 tests/ui/check-cfg/well-known-values.stderr        |  2 +-
 9 files changed, 117 insertions(+), 1 deletion(-)
 create mode 100644 compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
 create mode 100644 src/doc/rustc/src/platform-support/mips-mti-none-elf.md

(limited to 'tests')

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 02962d55a60..bfe6f444147 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1926,6 +1926,8 @@ supported_targets! {
     ("mipsel-sony-psp", mipsel_sony_psp),
     ("mipsel-sony-psx", mipsel_sony_psx),
     ("mipsel-unknown-none", mipsel_unknown_none),
+    ("mips-mti-none-elf", mips_mti_none_elf),
+    ("mipsel-mti-none-elf", mipsel_mti_none_elf),
     ("thumbv4t-none-eabi", thumbv4t_none_eabi),
     ("armv4t-none-eabi", armv4t_none_eabi),
     ("thumbv5te-none-eabi", thumbv5te_none_eabi),
diff --git a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
new file mode 100644
index 00000000000..4637e31fb17
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
@@ -0,0 +1,36 @@
+use crate::abi::Endian;
+use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetOptions};
+
+pub(crate) fn target() -> Target {
+    Target {
+        data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),
+        llvm_target: "mips".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("MIPS32r2 BE Baremetal Softfloat".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: None, // ?
+        },
+        pointer_width: 32,
+        arch: "mips".into(),
+
+        options: TargetOptions {
+            vendor: "mti".into(),
+            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
+            linker: Some("rust-lld".into()),
+            endian: Endian::Big,
+            cpu: "mips32r2".into(),
+
+            max_atomic_width: Some(32),
+
+            features: "+mips32r2,+soft-float,+noabicalls".into(),
+            executables: true,
+            panic_strategy: PanicStrategy::Abort,
+            relocation_model: RelocModel::Static,
+            emit_debug_gdb_scripts: false,
+            eh_frame_header: false,
+            singlethread: true,
+            ..Default::default()
+        },
+    }
+}
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
new file mode 100644
index 00000000000..a89c0fce88c
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
@@ -0,0 +1,36 @@
+use crate::abi::Endian;
+use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetOptions};
+
+pub(crate) fn target() -> Target {
+    Target {
+        data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),
+        llvm_target: "mipsel".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("MIPS32r2 LE Baremetal Softfloat".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: None, // ?
+        },
+        pointer_width: 32,
+        arch: "mips".into(),
+
+        options: TargetOptions {
+            vendor: "mti".into(),
+            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
+            linker: Some("rust-lld".into()),
+            endian: Endian::Little,
+            cpu: "mips32r2".into(),
+
+            max_atomic_width: Some(32),
+
+            features: "+mips32r2,+soft-float,+noabicalls".into(),
+            executables: true,
+            panic_strategy: PanicStrategy::Abort,
+            relocation_model: RelocModel::Static,
+            emit_debug_gdb_scripts: false,
+            eh_frame_header: false,
+            singlethread: true,
+            ..Default::default()
+        },
+    }
+}
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index f0c3720eae1..16ae83126af 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -62,6 +62,7 @@
     - [m68k-unknown-linux-gnu](platform-support/m68k-unknown-linux-gnu.md)
     - [mips64-openwrt-linux-musl](platform-support/mips64-openwrt-linux-musl.md)
     - [mipsel-sony-psx](platform-support/mipsel-sony-psx.md)
+    - [mips\*-mti-none-elf](platform-support/mips-mti-none-elf.md)
     - [mipsisa\*r6\*-unknown-linux-gnu\*](platform-support/mips-release-6.md)
     - [nvptx64-nvidia-cuda](platform-support/nvptx64-nvidia-cuda.md)
     - [powerpc-unknown-openbsd](platform-support/powerpc-unknown-openbsd.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 24e9a3c8121..5c787f56ed2 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -332,6 +332,8 @@ target | std | host | notes
 `mipsel-unknown-linux-uclibc` | ✓ |  | MIPS (LE) Linux with uClibc
 [`mipsel-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | 32-bit MIPS (LE), requires mips32 cpu support
 `mipsel-unknown-none` | * |  | Bare MIPS (LE) softfloat
+[`mips-mti-none-elf`](platform-support/mips-mti-none-elf.md) | * |  | Bare MIPS32r2 (BE) softfloat
+[`mipsel-mti-none-elf`](platform-support/mips-mti-none-elf.md) | * |  | Bare MIPS32r2 (LE) softfloat
 [`mipsisa32r6-unknown-linux-gnu`](platform-support/mips-release-6.md) | ? |  | 32-bit MIPS Release 6 Big Endian
 [`mipsisa32r6el-unknown-linux-gnu`](platform-support/mips-release-6.md) | ? |  | 32-bit MIPS Release 6 Little Endian
 [`mipsisa64r6-unknown-linux-gnuabi64`](platform-support/mips-release-6.md) | ? |  | 64-bit MIPS Release 6 Big Endian
diff --git a/src/doc/rustc/src/platform-support/mips-mti-none-elf.md b/src/doc/rustc/src/platform-support/mips-mti-none-elf.md
new file mode 100644
index 00000000000..b472f2f0d67
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/mips-mti-none-elf.md
@@ -0,0 +1,31 @@
+# `mips*-mti-none-elf`
+
+**Tier: 3**
+
+MIPS32r2 baremetal softfloat, Big Endian or Little Enedian.
+
+- mips-mti-none-elf
+- mipsel-mti-none-elf
+
+## Target maintainers
+
+- YunQiang Su, `syq@debian.org`, https://github.com/wzssyqa
+
+## Background
+
+These 2 targets, aka mips-mti-none-elf and mipsel-mti-none-elf, are for
+baremetal development of MIPS32r2. The lld is used instead of Gnu-ld.
+
+## Requirements
+
+The target only supports cross compilation and no host tools. The target
+supports `alloc` with a default allocator while only support `no-std` development.
+
+The vendor name `mti` follows the naming of gcc to indicate MIPS32r2.
+
+## Cross-compilation toolchains and C code
+
+Compatible C code can be built for this target on any compiler that has a MIPS32r2
+target.  On clang and ld.lld linker, it can be generated using the
+`-march=mips`/`-march=mipsel`, `-mabi=32` with llvm features flag
+`features=+mips32r2,+soft-float,+noabicalls`.
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index 561b611148a..d6ca03f7643 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -128,6 +128,8 @@ static TARGETS: &[&str] = &[
     "mipsisa64r6el-unknown-linux-gnuabi64",
     "mipsel-unknown-linux-gnu",
     "mipsel-unknown-linux-musl",
+    "mips-mti-none-elf",
+    "mipsel-mti-none-elf",
     "nvptx64-nvidia-cuda",
     "powerpc-unknown-linux-gnu",
     "powerpc64-unknown-linux-gnu",
diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
index 7d50647bed1..93394277f24 100644
--- a/tests/assembly/targets/targets-elf.rs
+++ b/tests/assembly/targets/targets-elf.rs
@@ -285,6 +285,12 @@
 //@ revisions: mips_unknown_linux_uclibc
 //@ [mips_unknown_linux_uclibc] compile-flags: --target mips-unknown-linux-uclibc
 //@ [mips_unknown_linux_uclibc] needs-llvm-components: mips
+//@ revisions: mips_mti_none_elf
+//@ [mips_mti_none_elf] compile-flags: --target mips-mti-none-elf
+//@ [mips_mti_none_elf] needs-llvm-components: mips
+//@ revisions: mipsel_mti_none_elf
+//@ [mipsel_mti_none_elf] compile-flags: --target mipsel-mti-none-elf
+//@ [mipsel_mti_none_elf] needs-llvm-components: mips
 //@ revisions: mipsel_sony_psp
 //@ [mipsel_sony_psp] compile-flags: --target mipsel-sony-psp
 //@ [mipsel_sony_psp] needs-llvm-components: mips
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index ab69938f51a..5c1898a0ae3 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -230,7 +230,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     target_vendor = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `mti`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
-- 
cgit 1.4.1-3-g733a5


From b806dccdc41274152f91d1efb421f2e50b4ab463 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 3 Jan 2025 10:55:15 +0100
Subject: const-in-pattern: test that the PartialEq impl does not need to be
 const

---
 .../src/thir/pattern/const_to_pat.rs               |  4 ++
 .../const-traits/pattern-custom-partial-eq.rs      | 54 ++++++++++++++++++++++
 2 files changed, 58 insertions(+)
 create mode 100644 tests/ui/traits/const-traits/pattern-custom-partial-eq.rs

(limited to 'tests')

diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index aed00aecefc..2b3c98db966 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -491,6 +491,10 @@ fn type_has_partial_eq_impl<'tcx>(
     // `PartialEq` for some lifetime but *not* for `'static`? If this ever becomes a problem
     // we'll need to leave some sort of trace of this requirement in the MIR so that borrowck
     // can ensure that the type really implements `PartialEq`.
+    // We also do *not* require `const PartialEq`, not even in `const fn`. This violates the model
+    // that patterns can only do things that the code could also do without patterns, but it is
+    // needed for backwards compatibility. The actual pattern matching compares primitive values,
+    // `PartialEq::eq` never gets invoked, so there's no risk of us running non-const code.
     (
         infcx.predicate_must_hold_modulo_regions(&partial_eq_obligation),
         automatically_derived,
diff --git a/tests/ui/traits/const-traits/pattern-custom-partial-eq.rs b/tests/ui/traits/const-traits/pattern-custom-partial-eq.rs
new file mode 100644
index 00000000000..1003775be2f
--- /dev/null
+++ b/tests/ui/traits/const-traits/pattern-custom-partial-eq.rs
@@ -0,0 +1,54 @@
+//! Ensure that a `const fn` can match on constants of a type that is `PartialEq`
+//! but not `const PartialEq`. This is accepted for backwards compatibility reasons.
+//@ check-pass
+#![feature(const_trait_impl)]
+
+#[derive(Eq, PartialEq)]
+pub struct Y(u8);
+pub const GREEN: Y = Y(4);
+pub const fn is_green(x: Y) -> bool {
+    match x { GREEN => true, _ => false }
+}
+
+struct CustomEq;
+
+impl Eq for CustomEq {}
+impl PartialEq for CustomEq {
+    fn eq(&self, _: &Self) -> bool {
+        false
+    }
+}
+
+#[derive(PartialEq, Eq)]
+#[allow(unused)]
+enum Foo {
+    Bar,
+    Baz,
+    Qux(CustomEq),
+}
+
+const BAR_BAZ: Foo = if 42 == 42 {
+    Foo::Bar
+} else {
+    Foo::Qux(CustomEq) // dead arm
+};
+
+const EMPTY: &[CustomEq] = &[];
+
+const fn test() {
+    // BAR_BAZ itself is fine but the enum has other variants
+    // that are non-structural. Still, this should be accepted.
+    match Foo::Qux(CustomEq) {
+        BAR_BAZ => panic!(),
+        _ => {}
+    }
+
+    // Similarly, an empty slice of a type that is non-structural
+    // is accepted.
+    match &[CustomEq] as &[CustomEq] {
+        EMPTY => panic!(),
+        _ => {},
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 8f3aa358bf4c5507eccaca2f315d94eaef3b48d9 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Fri, 3 Jan 2025 19:44:08 +0100
Subject: add codegen test for `bool::select_unpredictable`

---
 tests/codegen/bool-select-unpredictable.rs | 35 ++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 tests/codegen/bool-select-unpredictable.rs

(limited to 'tests')

diff --git a/tests/codegen/bool-select-unpredictable.rs b/tests/codegen/bool-select-unpredictable.rs
new file mode 100644
index 00000000000..1562b177542
--- /dev/null
+++ b/tests/codegen/bool-select-unpredictable.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -O
+
+#![feature(select_unpredictable)]
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test_int(p: bool, a: u64, b: u64) -> u64 {
+    // CHECK-LABEL: define{{.*}} @test_int
+    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
+    p.select_unpredictable(a, b)
+}
+
+#[no_mangle]
+pub fn test_pair(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
+    // CHECK-LABEL: define{{.*}} @test_pair
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    p.select_unpredictable(a, b)
+}
+
+struct Large {
+    e: [u64; 100],
+}
+
+#[no_mangle]
+pub fn test_struct(p: bool, a: Large, b: Large) -> Large {
+    // CHECK-LABEL: define{{.*}} @test_struct
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    p.select_unpredictable(a, b)
+}
+
+#[no_mangle]
+pub fn test_zst(p: bool, a: (), b: ()) -> () {
+    // CHECK-LABEL: define{{.*}} @test_zst
+    p.select_unpredictable(a, b)
+}
-- 
cgit 1.4.1-3-g733a5


From ed005245c64447db5bcf28c29045a3bb99dd15e0 Mon Sep 17 00:00:00 2001
From: Matthew Maurer <mmaurer@google.com>
Date: Fri, 3 Jan 2025 19:39:52 +0000
Subject: Update carrying_mul_add test to tolerate `nuw`

LLVM 20 adds nuw to GEP operations in this code, tolerate them.
---
 tests/codegen/intrinsics/carrying_mul_add.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/codegen/intrinsics/carrying_mul_add.rs b/tests/codegen/intrinsics/carrying_mul_add.rs
index 174c4077f09..b53585a8a6e 100644
--- a/tests/codegen/intrinsics/carrying_mul_add.rs
+++ b/tests/codegen/intrinsics/carrying_mul_add.rs
@@ -84,7 +84,7 @@ pub unsafe fn cma_u128(a: u128, b: u128, c: u128, d: u128) -> (u128, u128) {
     // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
     // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
     // OPT: store i128 [[LOW]], ptr %_0
-    // OPT: [[P1:%.+]] = getelementptr inbounds i8, ptr %_0, {{i32|i64}} 16
+    // OPT: [[P1:%.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %_0, {{i32|i64}} 16
     // OPT: store i128 [[HIGH]], ptr [[P1]]
     // CHECK: ret void
     carrying_mul_add(a, b, c, d)
@@ -111,7 +111,7 @@ pub unsafe fn cma_i128(a: i128, b: i128, c: i128, d: i128) -> (u128, i128) {
     // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
     // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
     // OPT: store i128 [[LOW]], ptr %_0
-    // OPT: [[P1:%.+]] = getelementptr inbounds i8, ptr %_0, {{i32|i64}} 16
+    // OPT: [[P1:%.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %_0, {{i32|i64}} 16
     // OPT: store i128 [[HIGH]], ptr [[P1]]
     // CHECK: ret void
     carrying_mul_add(a, b, c, d)
-- 
cgit 1.4.1-3-g733a5


From 228749148058da556e7d945acc9aefc48ac695e6 Mon Sep 17 00:00:00 2001
From: kirk <knickish@gmail.com>
Date: Fri, 3 Jan 2025 20:22:39 +0000
Subject: add m68k-unknown-none-elf target

---
 compiler/rustc_target/src/spec/mod.rs              |   1 +
 .../src/spec/targets/m68k_unknown_none_elf.rs      |  30 ++++++
 src/doc/rustc/src/SUMMARY.md                       |   1 +
 src/doc/rustc/src/platform-support.md              |   1 +
 .../src/platform-support/m68k-unknown-none-elf.md  | 110 +++++++++++++++++++++
 src/tools/build-manifest/src/main.rs               |   1 +
 src/tools/compiletest/src/header/tests.rs          |   1 +
 tests/assembly/targets/targets-elf.rs              |   3 +
 8 files changed, 148 insertions(+)
 create mode 100644 compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs
 create mode 100644 src/doc/rustc/src/platform-support/m68k-unknown-none-elf.md

(limited to 'tests')

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 02962d55a60..d406c03c9a4 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1656,6 +1656,7 @@ supported_targets! {
     ("loongarch64-unknown-linux-gnu", loongarch64_unknown_linux_gnu),
     ("loongarch64-unknown-linux-musl", loongarch64_unknown_linux_musl),
     ("m68k-unknown-linux-gnu", m68k_unknown_linux_gnu),
+    ("m68k-unknown-none-elf", m68k_unknown_none_elf),
     ("csky-unknown-linux-gnuabiv2", csky_unknown_linux_gnuabiv2),
     ("csky-unknown-linux-gnuabiv2hf", csky_unknown_linux_gnuabiv2hf),
     ("mips-unknown-linux-gnu", mips_unknown_linux_gnu),
diff --git a/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs
new file mode 100644
index 00000000000..c57470a94c5
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs
@@ -0,0 +1,30 @@
+use crate::abi::Endian;
+use crate::spec::{CodeModel, PanicStrategy, Target, TargetOptions};
+
+pub(crate) fn target() -> Target {
+    let options = TargetOptions {
+        cpu: "M68010".into(),
+        max_atomic_width: None,
+        endian: Endian::Big,
+        // LLD currently does not have support for M68k
+        linker: Some("m68k-linux-gnu-ld".into()),
+        panic_strategy: PanicStrategy::Abort,
+        code_model: Some(CodeModel::Medium),
+        has_rpath: false,
+        ..Default::default()
+    };
+
+    Target {
+        llvm_target: "m68k".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("Motorola 680x0".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "E-m:e-p:32:16:32-i8:8:8-i16:16:16-i32:16:32-n8:16:32-a:0:16-S16".into(),
+        arch: "m68k".into(),
+        options,
+    }
+}
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index f0c3720eae1..bfde0e1f3e7 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -60,6 +60,7 @@
     - [loongarch\*-unknown-linux-\*](platform-support/loongarch-linux.md)
     - [loongarch\*-unknown-none\*](platform-support/loongarch-none.md)
     - [m68k-unknown-linux-gnu](platform-support/m68k-unknown-linux-gnu.md)
+    - [m68k-unknown-none-elf](platform-support/m68k-unknown-none-elf.md)
     - [mips64-openwrt-linux-musl](platform-support/mips64-openwrt-linux-musl.md)
     - [mipsel-sony-psx](platform-support/mipsel-sony-psx.md)
     - [mipsisa\*r6\*-unknown-linux-gnu\*](platform-support/mips-release-6.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 24e9a3c8121..dd801f2455c 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -317,6 +317,7 @@ target | std | host | notes
 [`i686-wrs-vxworks`](platform-support/vxworks.md) | ✓ |  | [^x86_32-floats-return-ABI]
 [`loongarch64-unknown-linux-ohos`](platform-support/openharmony.md) | ✓ |   | LoongArch64 OpenHarmony
 [`m68k-unknown-linux-gnu`](platform-support/m68k-unknown-linux-gnu.md) | ? |  | Motorola 680x0 Linux
+[`m68k-unknown-none-elf`](platform-support/m68k-unknown-none-elf.md) |  |  | Motorola 680x0
 `mips-unknown-linux-gnu` | ✓ | ✓ | MIPS Linux (kernel 4.4, glibc 2.23)
 `mips-unknown-linux-musl` | ✓ |  | MIPS Linux with musl 1.2.3
 `mips-unknown-linux-uclibc` | ✓ |  | MIPS Linux with uClibc
diff --git a/src/doc/rustc/src/platform-support/m68k-unknown-none-elf.md b/src/doc/rustc/src/platform-support/m68k-unknown-none-elf.md
new file mode 100644
index 00000000000..acad2853240
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/m68k-unknown-none-elf.md
@@ -0,0 +1,110 @@
+# m68k-unknown-none-elf
+
+**Tier: 3**
+
+Motorola 680x0 Linux
+
+## Designated Developers
+
+* [@knickish](https://github.com/knickish)
+* [@glaubitz](https://github.com/glaubitz)
+* [@ricky26](https://github.com/ricky26)
+
+## Requirements
+
+This target requires am m68k build environment for cross-compilation which
+is available on Debian and Debian-based systems, openSUSE and other distributions.
+
+On Debian, it should be sufficient to install a g++ cross-compiler for the m68k
+architecture which will automatically pull in additional dependencies such as
+the glibc cross development package:
+
+```text
+# apt install g++-m68k-linux-gnu
+```
+
+Binaries can be run using QEMU user emulation. On Debian-based systems, it should be
+sufficient to install the package `qemu-user-static` to be able to run simple static
+binaries:
+
+```text
+# apt install qemu-user-static
+```
+
+To run more complex programs, it will be necessary to set up a Debian/m68k chroot with
+the help of the command `debootstrap`:
+
+```text
+# apt install debootstrap debian-ports-archive-keyring
+# debootstrap --keyring=/usr/share/keyrings/debian-ports-archive-keyring.gpg --arch=m68k unstable debian-68k http://ftp.ports.debian.org/debian-ports
+```
+
+This chroot can then seamlessly entered using the normal `chroot` command thanks to
+QEMU user emulation:
+
+```text
+# chroot /path/to/debian-68k
+```
+
+To get started with native builds, which are currently untested, a native Debian/m68k
+system can be installed either on real hardware such as 68k-based Commodore Amiga or
+Atari systems or emulated environments such as QEMU version 4.2 or newer or ARAnyM.
+
+ISO images for installation are provided by the Debian Ports team and can be obtained
+from the Debian CD image server available at:
+
+[https://cdimage.debian.org/cdimage/ports/current](https://cdimage.debian.org/cdimage/ports/current/)
+
+Documentation for Debian/m68k is available on the Debian Wiki at:
+
+[https://wiki.debian.org/M68k](https://wiki.debian.org/M68k)
+
+Support is available either through the `debian-68k` mailing list:
+
+[https://lists.debian.org/debian-68k/](https://lists.debian.org/debian-68k/)
+
+or the `#debian-68k` IRC channel on OFTC network.
+
+## Building
+
+At least llvm version `19.1.5` is required to build `core` and `alloc` for this target, and currently the gnu linker is required, as `lld` has no support for the `m68k` architecture
+
+## Cross-compilation
+
+This target can be cross-compiled from a standard Debian or Debian-based, openSUSE or any
+other distribution which has a basic m68k cross-toolchain available.
+
+## Testing
+
+Currently there is no support to run the rustc test suite for this target.
+
+## Building Rust programs
+
+Recommended `.cargo/config.toml`:
+```toml
+[unstable]
+build-std = ["panic_abort","core", "alloc"]
+
+[target.m68k-unknown-none-elf]
+# there is no easily available non-linux m68k linker, so just use the linux one
+linker = "m68k-linux-gnu-ld"
+
+# the mold linker also supports m68k, remove the above line and uncomment the
+# following ones to use that instead
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=/path/to/mold/binary"]
+```
+
+Rust programs can be built for this target using:
+
+```text
+cargo build --target m68k-unknown-none-elf
+```
+
+Very simple programs can be run using the `qemu-m68k-static` program:
+
+```text
+$ qemu-m68k-static your-code
+```
+
+For more complex applications, a chroot or native m68k system is required for testing.
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index 561b611148a..642977b124a 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -114,6 +114,7 @@ static TARGETS: &[&str] = &[
     "loongarch64-unknown-none",
     "loongarch64-unknown-none-softfloat",
     "m68k-unknown-linux-gnu",
+    "m68k-unknown-none-elf",
     "csky-unknown-linux-gnuabiv2",
     "csky-unknown-linux-gnuabiv2hf",
     "mips-unknown-linux-gnu",
diff --git a/src/tools/compiletest/src/header/tests.rs b/src/tools/compiletest/src/header/tests.rs
index 618b66dfd4c..dc6f262bbbc 100644
--- a/src/tools/compiletest/src/header/tests.rs
+++ b/src/tools/compiletest/src/header/tests.rs
@@ -617,6 +617,7 @@ fn is_big_endian() {
         ("x86_64-unknown-linux-gnu", false),
         ("bpfeb-unknown-none", true),
         ("m68k-unknown-linux-gnu", true),
+        ("m68k-unknown-none-elf", true),
         ("aarch64_be-unknown-linux-gnu", true),
         ("powerpc64-unknown-linux-gnu", true),
     ];
diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
index 7d50647bed1..c6d5b841be0 100644
--- a/tests/assembly/targets/targets-elf.rs
+++ b/tests/assembly/targets/targets-elf.rs
@@ -261,6 +261,9 @@
 //@ revisions: m68k_unknown_linux_gnu
 //@ [m68k_unknown_linux_gnu] compile-flags: --target m68k-unknown-linux-gnu
 //@ [m68k_unknown_linux_gnu] needs-llvm-components: m68k
+//@ revisions: m68k_unknown_none_elf
+//@ [m68k_unknown_none_elf] compile-flags: --target m68k-unknown-none-elf
+//@ [m68k_unknown_none_elf] needs-llvm-components: m68k
 //@ revisions: mips64_openwrt_linux_musl
 //@ [mips64_openwrt_linux_musl] compile-flags: --target mips64-openwrt-linux-musl
 //@ [mips64_openwrt_linux_musl] needs-llvm-components: mips
-- 
cgit 1.4.1-3-g733a5


From cf679e428136f7992e8c110b32365a0e0057154e Mon Sep 17 00:00:00 2001
From: Matthew Maurer <mmaurer@google.com>
Date: Fri, 3 Jan 2025 22:21:39 +0000
Subject: Force code generation in assembly generation smoke-tests

In llvm/llvm-project@7b23f413d1f76532825e470b523e971818d453ca , `.text`
started being suppressed from LLVM assembly in cases where it wasn't
strictly necessary. Currently, the sample functions in these two tests
are frequently decided to be IR-only functions, resulting in no code
generation, so LLVM drops the `.text` directive.

Adding `#[no_mangle]` forces these tests back to their original intent -
assembly code is generated, and so a `.text` directive is generated as
well.
---
 tests/assembly/targets/targets-elf.rs   | 2 ++
 tests/assembly/targets/targets-macho.rs | 2 ++
 2 files changed, 4 insertions(+)

(limited to 'tests')

diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
index 7d50647bed1..59d27ed649c 100644
--- a/tests/assembly/targets/targets-elf.rs
+++ b/tests/assembly/targets/targets-elf.rs
@@ -676,6 +676,8 @@
 #[lang = "sized"]
 trait Sized {}
 
+// Force linkage to ensure code is actually generated
+#[no_mangle]
 pub fn test() -> u8 {
     42
 }
diff --git a/tests/assembly/targets/targets-macho.rs b/tests/assembly/targets/targets-macho.rs
index 8095ae9029b..25e9059afeb 100644
--- a/tests/assembly/targets/targets-macho.rs
+++ b/tests/assembly/targets/targets-macho.rs
@@ -83,6 +83,8 @@
 #[lang = "sized"]
 trait Sized {}
 
+// Force linkage to ensure code is actually generated
+#[no_mangle]
 pub fn test() -> u8 {
     42
 }
-- 
cgit 1.4.1-3-g733a5


From 3cd3649c6cd370ac20e47f40bd5f210c9fe63f92 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 4 Jan 2025 11:41:51 +0100
Subject: rustc_intrinsic: support functions without body; they are implicitly
 marked as must-be-overridden

---
 compiler/rustc_ast_lowering/src/item.rs            | 58 +++++++++++++++-------
 compiler/rustc_ast_passes/src/ast_validation.rs    |  4 +-
 compiler/rustc_const_eval/src/interpret/call.rs    |  3 +-
 compiler/rustc_feature/src/builtin_attrs.rs        |  2 +-
 compiler/rustc_hir/src/hir.rs                      | 12 ++++-
 compiler/rustc_middle/src/ty/util.rs               |  9 +++-
 compiler/rustc_mir_build/src/builder/mod.rs        | 14 ++++++
 compiler/rustc_mir_transform/src/inline.rs         |  3 +-
 compiler/rustc_monomorphize/src/collector.rs       | 18 +++----
 src/tools/miri/src/bin/miri.rs                     |  2 +-
 tests/ui/consts/auxiliary/unstable_intrinsic.rs    |  6 +--
 tests/ui/consts/const-unstable-intrinsic.rs        | 13 ++---
 tests/ui/consts/const-unstable-intrinsic.stderr    |  4 +-
 tests/ui/intrinsics/not-overridden.rs              |  3 +-
 tests/ui/intrinsics/not-overridden.stderr          |  2 +-
 tests/ui/parser/fn-body-optional-semantic-fail.rs  |  4 ++
 .../parser/fn-body-optional-semantic-fail.stderr   | 18 +++++--
 tests/ui/target-feature/no-llvm-leaks.rs           |  5 +-
 tests/ui/traits/const-traits/auxiliary/minicore.rs |  6 +--
 19 files changed, 118 insertions(+), 68 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 74a02eebd02..6fce9116938 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -222,6 +222,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         decl,
                         coroutine_kind,
                         body.as_deref(),
+                        attrs,
                     );
 
                     let itctx = ImplTraitContext::Universal;
@@ -233,7 +234,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         header: this.lower_fn_header(*header, hir::Safety::Safe),
                         span: this.lower_span(*fn_sig_span),
                     };
-                    hir::ItemKind::Fn { sig, generics, body: body_id }
+                    hir::ItemKind::Fn { sig, generics, body: body_id, has_body: body.is_some() }
                 })
             }
             ItemKind::Mod(_, mod_kind) => match mod_kind {
@@ -439,6 +440,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     sig: delegation_results.sig,
                     generics: delegation_results.generics,
                     body: delegation_results.body_id,
+                    has_body: true,
                 }
             }
             ItemKind::MacCall(..) | ItemKind::DelegationMac(..) => {
@@ -747,7 +749,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
-        self.lower_attrs(hir_id, &i.attrs);
+        let attrs = self.lower_attrs(hir_id, &i.attrs);
         let trait_item_def_id = hir_id.expect_owner();
 
         let (generics, kind, has_default) = match &i.kind {
@@ -785,6 +787,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     &sig.decl,
                     sig.header.coroutine_kind,
                     Some(body),
+                    attrs,
                 );
                 let (generics, sig) = self.lower_method_sig(
                     generics,
@@ -877,7 +880,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let has_value = true;
         let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
-        self.lower_attrs(hir_id, &i.attrs);
+        let attrs = self.lower_attrs(hir_id, &i.attrs);
 
         let (generics, kind) = match &i.kind {
             AssocItemKind::Const(box ConstItem { generics, ty, expr, .. }) => self.lower_generics(
@@ -900,6 +903,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     &sig.decl,
                     sig.header.coroutine_kind,
                     body.as_deref(),
+                    attrs,
                 );
                 let (generics, sig) = self.lower_method_sig(
                     generics,
@@ -1054,20 +1058,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         })
     }
 
-    fn lower_fn_body_block(
-        &mut self,
-        span: Span,
-        decl: &FnDecl,
-        body: Option<&Block>,
-    ) -> hir::BodyId {
-        self.lower_fn_body(decl, |this| this.lower_block_expr_opt(span, body))
-    }
-
-    fn lower_block_expr_opt(&mut self, span: Span, block: Option<&Block>) -> hir::Expr<'hir> {
-        match block {
-            Some(block) => self.lower_block_expr(block),
-            None => self.expr_err(span, self.dcx().has_errors().unwrap()),
-        }
+    fn lower_fn_body_block(&mut self, decl: &FnDecl, body: &Block) -> hir::BodyId {
+        self.lower_fn_body(decl, |this| this.lower_block_expr(body))
     }
 
     pub(super) fn lower_const_body(&mut self, span: Span, expr: Option<&Expr>) -> hir::BodyId {
@@ -1089,9 +1081,37 @@ impl<'hir> LoweringContext<'_, 'hir> {
         decl: &FnDecl,
         coroutine_kind: Option<CoroutineKind>,
         body: Option<&Block>,
+        attrs: &'hir [hir::Attribute],
     ) -> hir::BodyId {
-        let (Some(coroutine_kind), Some(body)) = (coroutine_kind, body) else {
-            return self.lower_fn_body_block(span, decl, body);
+        let Some(body) = body else {
+            // Functions without a body are an error, except if this is an intrinsic. For those we
+            // create a fake body so that the entire rest of the compiler doesn't have to deal with
+            // this as a special case.
+            return self.lower_fn_body(decl, |this| {
+                if attrs.iter().any(|a| a.name_or_empty() == sym::rustc_intrinsic) {
+                    let empty_block = hir::Block {
+                        hir_id: this.next_id(),
+                        stmts: &[],
+                        expr: None,
+                        rules: hir::BlockCheckMode::DefaultBlock,
+                        span,
+                        targeted_by_break: false,
+                    };
+                    let loop_ = hir::ExprKind::Loop(
+                        this.arena.alloc(empty_block),
+                        None,
+                        hir::LoopSource::Loop,
+                        span,
+                    );
+                    hir::Expr { hir_id: this.next_id(), kind: loop_, span }
+                } else {
+                    this.expr_err(span, this.dcx().has_errors().unwrap())
+                }
+            });
+        };
+        let Some(coroutine_kind) = coroutine_kind else {
+            // Typical case: not a coroutine.
+            return self.lower_fn_body_block(decl, body);
         };
         self.lower_body(|this| {
             let (parameters, expr) = this.lower_coroutine_body_with_moved_arguments(
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index d1cf9c53d66..236ca7ba703 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -920,7 +920,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             ItemKind::Fn(box Fn { defaultness, sig, generics, body }) => {
                 self.check_defaultness(item.span, *defaultness);
 
-                if body.is_none() {
+                let is_intrinsic =
+                    item.attrs.iter().any(|a| a.name_or_empty() == sym::rustc_intrinsic);
+                if body.is_none() && !is_intrinsic {
                     self.dcx().emit_err(errors::FnWithoutBody {
                         span: item.span,
                         replace_span: self.ending_semi_or_hi(item.span),
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 99f0ac702c5..e6a34193c9d 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -566,7 +566,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             | ty::InstanceKind::ThreadLocalShim(..)
             | ty::InstanceKind::AsyncDropGlueCtorShim(..)
             | ty::InstanceKind::Item(_) => {
-                // We need MIR for this fn
+                // We need MIR for this fn.
+                // Note that this can be an intrinsic, if we are executing its fallback body.
                 let Some((body, instance)) = M::find_mir_or_eval_fn(
                     self,
                     instance,
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 4112ae80980..489ef5e8fe7 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -1013,7 +1013,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
     gated!(
         rustc_intrinsic, Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::Yes, intrinsics,
-        "the `#[rustc_intrinsic]` attribute is used to declare intrinsics with function bodies",
+        "the `#[rustc_intrinsic]` attribute is used to declare intrinsics as function items",
     ),
     gated!(
         rustc_intrinsic_must_be_overridden, Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::Yes, intrinsics,
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index c09f4e9fadc..114fc072c9e 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -3640,7 +3640,7 @@ impl<'hir> Item<'hir> {
             ItemKind::Const(ty, generics, body), (ty, generics, *body);
 
         expect_fn, (&FnSig<'hir>, &'hir Generics<'hir>, BodyId),
-            ItemKind::Fn { sig, generics, body }, (sig, generics, *body);
+            ItemKind::Fn { sig, generics, body, .. }, (sig, generics, *body);
 
         expect_macro, (&ast::MacroDef, MacroKind), ItemKind::Macro(def, mk), (def, *mk);
 
@@ -3768,7 +3768,15 @@ pub enum ItemKind<'hir> {
     /// A `const` item.
     Const(&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
     /// A function declaration.
-    Fn { sig: FnSig<'hir>, generics: &'hir Generics<'hir>, body: BodyId },
+    Fn {
+        sig: FnSig<'hir>,
+        generics: &'hir Generics<'hir>,
+        body: BodyId,
+        /// Whether this function actually has a body.
+        /// For functions without a body, `body` is synthesized (to avoid ICEs all over the
+        /// compiler), but that code should never be translated.
+        has_body: bool,
+    },
     /// A MBE macro definition (`macro_rules!` or `macro`).
     Macro(&'hir ast::MacroDef, MacroKind),
     /// A module.
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index ab8285f87d6..4272893df30 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1778,9 +1778,16 @@ pub fn intrinsic_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::Intrinsi
         && (matches!(tcx.fn_sig(def_id).skip_binder().abi(), ExternAbi::RustIntrinsic)
             || tcx.has_attr(def_id, sym::rustc_intrinsic))
     {
+        let must_be_overridden = tcx.has_attr(def_id, sym::rustc_intrinsic_must_be_overridden)
+            || match tcx.hir_node_by_def_id(def_id) {
+                hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn { has_body, .. }, .. }) => {
+                    !has_body
+                }
+                _ => true,
+            };
         Some(ty::IntrinsicDef {
             name: tcx.item_name(def_id.into()),
-            must_be_overridden: tcx.has_attr(def_id, sym::rustc_intrinsic_must_be_overridden),
+            must_be_overridden,
             const_stable: tcx.has_attr(def_id, sym::rustc_intrinsic_const_stable_indirect),
         })
     } else {
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index 0a60899248a..932b6fbe026 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -1005,11 +1005,25 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if let Some(source_scope) = scope {
             self.source_scope = source_scope;
         }
+
         if self.tcx.intrinsic(self.def_id).is_some_and(|i| i.must_be_overridden) {
             let source_info = self.source_info(rustc_span::DUMMY_SP);
             self.cfg.terminate(block, source_info, TerminatorKind::Unreachable);
             self.cfg.start_new_block().unit()
         } else {
+            // Ensure we don't silently codegen functions with fake bodies.
+            match self.tcx.hir_node(self.hir_id) {
+                hir::Node::Item(hir::Item {
+                    kind: hir::ItemKind::Fn { has_body: false, .. },
+                    ..
+                }) => {
+                    self.tcx.dcx().span_delayed_bug(
+                        expr_span,
+                        format!("fn item without body has reached MIR building: {:?}", self.def_id),
+                    );
+                }
+                _ => {}
+            }
             self.expr_into_dest(Place::return_place(), block, expr_id)
         }
     }
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 35699acb318..339acbad6b9 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -190,7 +190,8 @@ impl<'tcx> Inliner<'tcx> {
 
         // Intrinsic fallback bodies are automatically made cross-crate inlineable,
         // but at this stage we don't know whether codegen knows the intrinsic,
-        // so just conservatively don't inline it.
+        // so just conservatively don't inline it. This also ensures that we do not
+        // accidentally inline the body of an intrinsic that *must* be overridden.
         if self.tcx.has_attr(callsite.callee.def_id(), sym::rustc_intrinsic) {
             return Err("Callee is an intrinsic, do not inline fallback bodies");
         }
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 05d34715314..00aae03704f 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -232,7 +232,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::Limit;
 use rustc_session::config::EntryFnType;
 use rustc_span::source_map::{Spanned, dummy_spanned, respan};
-use rustc_span::{DUMMY_SP, Span, sym};
+use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument, trace};
 
 use crate::errors::{self, EncounteredErrorWhileInstantiating, NoOptimizedMir, RecursionLimit};
@@ -894,9 +894,8 @@ fn visit_instance_use<'tcx>(
     if !tcx.should_codegen_locally(instance) {
         return;
     }
-    if let ty::InstanceKind::Intrinsic(def_id) = instance.def {
-        let name = tcx.item_name(def_id);
-        if let Some(_requirement) = ValidityRequirement::from_intrinsic(name) {
+    if let Some(intrinsic) = tcx.intrinsic(instance.def_id()) {
+        if let Some(_requirement) = ValidityRequirement::from_intrinsic(intrinsic.name) {
             // The intrinsics assert_inhabited, assert_zero_valid, and assert_mem_uninitialized_valid will
             // be lowered in codegen to nothing or a call to panic_nounwind. So if we encounter any
             // of those intrinsics, we need to include a mono item for panic_nounwind, else we may try to
@@ -906,11 +905,12 @@ fn visit_instance_use<'tcx>(
             if tcx.should_codegen_locally(panic_instance) {
                 output.push(create_fn_mono_item(tcx, panic_instance, source));
             }
-        } else if tcx.has_attr(def_id, sym::rustc_intrinsic)
-            && !tcx.has_attr(def_id, sym::rustc_intrinsic_must_be_overridden)
-        {
-            // Codegen the fallback body of intrinsics with fallback bodies
-            let instance = ty::Instance::new(def_id, instance.args);
+        } else if !intrinsic.must_be_overridden {
+            // Codegen the fallback body of intrinsics with fallback bodies.
+            // We explicitly skip this otherwise to ensure we get a linker error
+            // if anyone tries to call this intrinsic and the codegen backend did not
+            // override the implementation.
+            let instance = ty::Instance::new(instance.def_id(), instance.args);
             if tcx.should_codegen_locally(instance) {
                 output.push(create_fn_mono_item(tcx, instance, source));
             }
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 962e313ce33..9055aa30271 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -242,7 +242,7 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
                             let is_reachable_non_generic = matches!(
                                 tcx.hir_node_by_def_id(local_def_id),
                                 Node::Item(&hir::Item {
-                                    kind: hir::ItemKind::Static(..) | hir::ItemKind::Fn { .. },
+                                    kind: hir::ItemKind::Static(..) | hir::ItemKind::Fn{ .. },
                                     ..
                                 }) | Node::ImplItem(&hir::ImplItem {
                                     kind: hir::ImplItemKind::Fn(..),
diff --git a/tests/ui/consts/auxiliary/unstable_intrinsic.rs b/tests/ui/consts/auxiliary/unstable_intrinsic.rs
index 9e53a8feb5d..45631df7859 100644
--- a/tests/ui/consts/auxiliary/unstable_intrinsic.rs
+++ b/tests/ui/consts/auxiliary/unstable_intrinsic.rs
@@ -3,11 +3,9 @@
 
 #[unstable(feature = "unstable", issue = "42")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn size_of_val<T>(x: *const T) -> usize { 42 }
+pub const unsafe fn size_of_val<T>(x: *const T) -> usize;
 
 #[unstable(feature = "unstable", issue = "42")]
 #[rustc_const_unstable(feature = "unstable", issue = "42")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn min_align_of_val<T>(x: *const T) -> usize { 42 }
+pub const unsafe fn min_align_of_val<T>(x: *const T) -> usize;
diff --git a/tests/ui/consts/const-unstable-intrinsic.rs b/tests/ui/consts/const-unstable-intrinsic.rs
index 8b38067e46e..890a30c73c8 100644
--- a/tests/ui/consts/const-unstable-intrinsic.rs
+++ b/tests/ui/consts/const-unstable-intrinsic.rs
@@ -2,7 +2,7 @@
 //! neither within a crate nor cross-crate.
 //@ aux-build:unstable_intrinsic.rs
 #![feature(staged_api, rustc_attrs, intrinsics)]
-#![stable(since="1.0.0", feature = "stable")]
+#![stable(since = "1.0.0", feature = "stable")]
 #![feature(local)]
 
 extern crate unstable_intrinsic;
@@ -30,14 +30,12 @@ const fn const_main() {
 
 #[unstable(feature = "local", issue = "42")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn size_of_val<T>(x: *const T) -> usize { 42 }
+pub const unsafe fn size_of_val<T>(x: *const T) -> usize;
 
 #[unstable(feature = "local", issue = "42")]
 #[rustc_const_unstable(feature = "local", issue = "42")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn min_align_of_val<T>(x: *const T) -> usize { 42 }
+pub const unsafe fn min_align_of_val<T>(x: *const T) -> usize;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")]
@@ -45,10 +43,7 @@ pub const unsafe fn min_align_of_val<T>(x: *const T) -> usize { 42 }
 pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
     // Const stability attributes are not inherited from parent items.
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
-        unimplemented!()
-    }
+    const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
 
     unsafe { copy(src, dst, count) }
     //~^ ERROR cannot be (indirectly) exposed to stable
diff --git a/tests/ui/consts/const-unstable-intrinsic.stderr b/tests/ui/consts/const-unstable-intrinsic.stderr
index dfca04bef07..601c8647eee 100644
--- a/tests/ui/consts/const-unstable-intrinsic.stderr
+++ b/tests/ui/consts/const-unstable-intrinsic.stderr
@@ -69,7 +69,7 @@ LL | const fn const_main() {
    |
 
 error: intrinsic `copy::copy` cannot be (indirectly) exposed to stable
-  --> $DIR/const-unstable-intrinsic.rs:53:14
+  --> $DIR/const-unstable-intrinsic.rs:48:14
    |
 LL |     unsafe { copy(src, dst, count) }
    |              ^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     unsafe { copy(src, dst, count) }
    = help: mark the caller as `#[rustc_const_unstable]`, or mark the intrinsic `#[rustc_intrinsic_const_stable_indirect]` (but this requires team approval)
 
 error: const function that might be (indirectly) exposed to stable cannot use `#[feature(local)]`
-  --> $DIR/const-unstable-intrinsic.rs:61:9
+  --> $DIR/const-unstable-intrinsic.rs:56:9
    |
 LL |         super::size_of_val(src);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/intrinsics/not-overridden.rs b/tests/ui/intrinsics/not-overridden.rs
index b57b4e5bc06..2359eee8b26 100644
--- a/tests/ui/intrinsics/not-overridden.rs
+++ b/tests/ui/intrinsics/not-overridden.rs
@@ -9,8 +9,7 @@
 //@ rustc-env:RUST_BACKTRACE=0
 
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {}
+pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize);
 
 fn main() {
     unsafe { const_deallocate(std::ptr::null_mut(), 0, 0) }
diff --git a/tests/ui/intrinsics/not-overridden.stderr b/tests/ui/intrinsics/not-overridden.stderr
index 9b8849cea1c..025a18fa4de 100644
--- a/tests/ui/intrinsics/not-overridden.stderr
+++ b/tests/ui/intrinsics/not-overridden.stderr
@@ -1,5 +1,5 @@
 error: must be overridden by codegen backend, but isn't
-  --> $DIR/not-overridden.rs:16:14
+  --> $DIR/not-overridden.rs:15:14
    |
 LL |     unsafe { const_deallocate(std::ptr::null_mut(), 0, 0) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/parser/fn-body-optional-semantic-fail.rs b/tests/ui/parser/fn-body-optional-semantic-fail.rs
index 12df488802e..46f5d7e96d1 100644
--- a/tests/ui/parser/fn-body-optional-semantic-fail.rs
+++ b/tests/ui/parser/fn-body-optional-semantic-fail.rs
@@ -1,7 +1,11 @@
 // Tests the different rules for `fn` forms requiring the presence or lack of a body.
+// Also ensures that functions without a body don't show other odd errors.
+
+trait Trait {}
 
 fn main() {
     fn f1(); //~ ERROR free function without a body
+    fn f1_rpit() -> impl Trait; //~ ERROR free function without a body
     fn f2() {} // OK.
 
     trait X {
diff --git a/tests/ui/parser/fn-body-optional-semantic-fail.stderr b/tests/ui/parser/fn-body-optional-semantic-fail.stderr
index 14bcd7c16fa..525a0a0f681 100644
--- a/tests/ui/parser/fn-body-optional-semantic-fail.stderr
+++ b/tests/ui/parser/fn-body-optional-semantic-fail.stderr
@@ -1,13 +1,21 @@
 error: free function without a body
-  --> $DIR/fn-body-optional-semantic-fail.rs:4:5
+  --> $DIR/fn-body-optional-semantic-fail.rs:7:5
    |
 LL |     fn f1();
    |     ^^^^^^^-
    |            |
    |            help: provide a definition for the function: `{ <body> }`
 
+error: free function without a body
+  --> $DIR/fn-body-optional-semantic-fail.rs:8:5
+   |
+LL |     fn f1_rpit() -> impl Trait;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |                               |
+   |                               help: provide a definition for the function: `{ <body> }`
+
 error: associated function in `impl` without body
-  --> $DIR/fn-body-optional-semantic-fail.rs:14:9
+  --> $DIR/fn-body-optional-semantic-fail.rs:18:9
    |
 LL |         fn f1();
    |         ^^^^^^^-
@@ -15,7 +23,7 @@ LL |         fn f1();
    |                help: provide a definition for the function: `{ <body> }`
 
 error: associated function in `impl` without body
-  --> $DIR/fn-body-optional-semantic-fail.rs:19:9
+  --> $DIR/fn-body-optional-semantic-fail.rs:23:9
    |
 LL |         fn f3();
    |         ^^^^^^^-
@@ -23,7 +31,7 @@ LL |         fn f3();
    |                help: provide a definition for the function: `{ <body> }`
 
 error: incorrect function inside `extern` block
-  --> $DIR/fn-body-optional-semantic-fail.rs:25:12
+  --> $DIR/fn-body-optional-semantic-fail.rs:29:12
    |
 LL |     extern "C" {
    |     ---------- `extern` blocks define existing foreign functions and functions inside of them cannot have a body
@@ -36,5 +44,5 @@ LL |         fn f6() {}
    = help: you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/target-feature/no-llvm-leaks.rs b/tests/ui/target-feature/no-llvm-leaks.rs
index 10268686405..d4f70fe7069 100644
--- a/tests/ui/target-feature/no-llvm-leaks.rs
+++ b/tests/ui/target-feature/no-llvm-leaks.rs
@@ -19,10 +19,7 @@ impl Copy for bool {}
 #[stable(feature = "test", since = "1.0.0")]
 #[rustc_const_stable(feature = "test", since = "1.0.0")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-const unsafe fn unreachable() -> ! {
-    loop {}
-}
+const unsafe fn unreachable() -> !;
 
 #[rustc_builtin_macro]
 macro_rules! cfg {
diff --git a/tests/ui/traits/const-traits/auxiliary/minicore.rs b/tests/ui/traits/const-traits/auxiliary/minicore.rs
index e606d896e93..08d7817548d 100644
--- a/tests/ui/traits/const-traits/auxiliary/minicore.rs
+++ b/tests/ui/traits/const-traits/auxiliary/minicore.rs
@@ -471,7 +471,6 @@ pub trait StructuralPartialEq {}
 
 pub const fn drop<T: ~const Destruct>(_: T) {}
 
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_intrinsic]
 const fn const_eval_select<ARG: Tuple, F, G, RET>(
     arg: ARG,
@@ -480,7 +479,4 @@ const fn const_eval_select<ARG: Tuple, F, G, RET>(
 ) -> RET
 where
     F: const FnOnce<ARG, Output = RET>,
-    G: FnOnce<ARG, Output = RET>,
-{
-    loop {}
-}
+    G: FnOnce<ARG, Output = RET>;
-- 
cgit 1.4.1-3-g733a5


From 9444195e92129373f2dca68960177eddfde44733 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 3 Jan 2025 09:52:14 +0100
Subject: crashes: add latest batch of tests

---
 tests/crashes/134336.rs | 11 +++++++++++
 tests/crashes/134355.rs |  6 ++++++
 tests/crashes/134479.rs | 24 ++++++++++++++++++++++++
 tests/crashes/134587.rs | 27 +++++++++++++++++++++++++++
 tests/crashes/134615.rs | 16 ++++++++++++++++
 tests/crashes/134641.rs | 13 +++++++++++++
 tests/crashes/134654.rs | 12 ++++++++++++
 tests/crashes/134838.rs | 14 ++++++++++++++
 tests/crashes/134905.rs | 16 ++++++++++++++++
 tests/crashes/135020.rs | 11 +++++++++++
 tests/crashes/135039.rs | 34 ++++++++++++++++++++++++++++++++++
 11 files changed, 184 insertions(+)
 create mode 100644 tests/crashes/134336.rs
 create mode 100644 tests/crashes/134355.rs
 create mode 100644 tests/crashes/134479.rs
 create mode 100644 tests/crashes/134587.rs
 create mode 100644 tests/crashes/134615.rs
 create mode 100644 tests/crashes/134641.rs
 create mode 100644 tests/crashes/134654.rs
 create mode 100644 tests/crashes/134838.rs
 create mode 100644 tests/crashes/134905.rs
 create mode 100644 tests/crashes/135020.rs
 create mode 100644 tests/crashes/135039.rs

(limited to 'tests')

diff --git a/tests/crashes/134336.rs b/tests/crashes/134336.rs
new file mode 100644
index 00000000000..14b88e14f04
--- /dev/null
+++ b/tests/crashes/134336.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #134336
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+trait Tr {
+    fn f();
+}
+
+fn g<T: Tr>() {
+    become T::f();
+}
diff --git a/tests/crashes/134355.rs b/tests/crashes/134355.rs
new file mode 100644
index 00000000000..b662341e6b1
--- /dev/null
+++ b/tests/crashes/134355.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #134355
+
+//@compile-flags: --crate-type=lib
+fn digit() -> str {
+    return { i32::MIN };
+}
diff --git a/tests/crashes/134479.rs b/tests/crashes/134479.rs
new file mode 100644
index 00000000000..0e4ddb2bfd5
--- /dev/null
+++ b/tests/crashes/134479.rs
@@ -0,0 +1,24 @@
+//@ known-bug: #134479
+//@ compile-flags: -Csymbol-mangling-version=v0 -Cdebuginfo=1
+
+#![feature(generic_const_exprs)]
+
+fn main() {
+    test::<2>();
+}
+
+struct Test<const N: usize>;
+
+fn new<const N: usize>() -> Test<N>
+where
+    [(); N * 1]: Sized,
+{
+    Test
+}
+
+fn test<const N: usize>() -> Test<{ N - 1 }>
+where
+    [(); (N - 1) * 1]: Sized,
+{
+    new()
+}
diff --git a/tests/crashes/134587.rs b/tests/crashes/134587.rs
new file mode 100644
index 00000000000..6d4441012e0
--- /dev/null
+++ b/tests/crashes/134587.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #134587
+
+use std::ops::Add;
+
+pub fn foo<T>(slf: *const T)
+where
+    *const T: Add,
+{
+    slf + slf;
+}
+
+pub fn foo2<T>(slf: *const T)
+where
+    *const T: Add<u8>,
+{
+    slf + 1_u8;
+}
+
+
+pub trait TimesTwo
+   where *const Self: Add<*const Self>,
+{
+   extern "C" fn t2_ptr(slf: *const Self)
+   -> <*const Self as Add<*const Self>>::Output {
+       slf + slf
+   }
+}
diff --git a/tests/crashes/134615.rs b/tests/crashes/134615.rs
new file mode 100644
index 00000000000..d7aa51389a0
--- /dev/null
+++ b/tests/crashes/134615.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #134615
+
+#![feature(generic_const_exprs)]
+
+trait Trait {
+    const CONST: usize;
+}
+
+fn f()
+where
+    for<'a> (): Trait,
+    [(); <() as Trait>::CONST]:,
+{
+}
+
+pub fn main() {}
diff --git a/tests/crashes/134641.rs b/tests/crashes/134641.rs
new file mode 100644
index 00000000000..e3e5ab69287
--- /dev/null
+++ b/tests/crashes/134641.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #134641
+#![feature(associated_const_equality)]
+
+pub trait IsVoid {
+    const IS_VOID: bool;
+}
+impl IsVoid for () {
+    const IS_VOID: bool = true;
+}
+
+pub trait Maybe {}
+impl Maybe for () {}
+impl Maybe for () where (): IsVoid<IS_VOID = true> {}
diff --git a/tests/crashes/134654.rs b/tests/crashes/134654.rs
new file mode 100644
index 00000000000..8a8d18359e9
--- /dev/null
+++ b/tests/crashes/134654.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #134654
+//@ compile-flags: -Zmir-enable-passes=+GVN -Zmir-enable-passes=+Inline -Zvalidate-mir
+//@ only-x86_64
+
+fn function_with_bytes<const BYTES:
+    &'static [u8; 0xa9008fb6c9d81e42_0e25730562a601c8_u128]>() -> &'static [u8] {
+    BYTES
+}
+
+fn main() {
+    function_with_bytes::<b"aa">() == &[];
+}
diff --git a/tests/crashes/134838.rs b/tests/crashes/134838.rs
new file mode 100644
index 00000000000..ac8af09b31b
--- /dev/null
+++ b/tests/crashes/134838.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #134838
+#![feature(type_ascription)]
+#![allow(dead_code)]
+
+struct Ty(());
+
+fn mk() -> impl Sized {
+    if false {
+         let _ = type_ascribe!(mk(), Ty).0;
+    }
+    Ty(())
+}
+
+fn main() {}
diff --git a/tests/crashes/134905.rs b/tests/crashes/134905.rs
new file mode 100644
index 00000000000..9f0f0f4b3f2
--- /dev/null
+++ b/tests/crashes/134905.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #134905
+
+trait Iterate<'a> {
+    type Ty: Valid;
+}
+impl<'a, T> Iterate<'a> for T
+where
+    T: Check,
+{
+    default type Ty = ();
+}
+
+trait Check {}
+impl<'a, T> Eq for T where <T as Iterate<'a>>::Ty: Valid {}
+
+trait Valid {}
diff --git a/tests/crashes/135020.rs b/tests/crashes/135020.rs
new file mode 100644
index 00000000000..b44056eb3af
--- /dev/null
+++ b/tests/crashes/135020.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #135020
+
+pub fn problem_thingy(items: &mut impl Iterator<Item = str>) {
+    let mut peeker = items.peekable();
+    match peeker.peek() {
+        Some(_) => (),
+        None => return (),
+    }
+}
+
+pub fn main() {}
diff --git a/tests/crashes/135039.rs b/tests/crashes/135039.rs
new file mode 100644
index 00000000000..c4c5336fd4f
--- /dev/null
+++ b/tests/crashes/135039.rs
@@ -0,0 +1,34 @@
+//@ known-bug: #135039
+//@ edition:2021
+
+pub type UserId<Backend> = <<Backend as AuthnBackend>::User as AuthUser>::Id;
+
+pub trait AuthUser {
+    type Id;
+}
+
+pub trait AuthnBackend {
+    type User: AuthUser;
+}
+
+pub struct AuthSession<Backend: AuthnBackend> {
+    user: Option<Backend::User>,
+    data: Option<UserId<Backend>>,
+}
+
+pub trait Authz: Sized {
+    type AuthnBackend: AuthnBackend<User = Self>;
+}
+
+pub trait Query<User: Authz> {
+    type Output;
+    async fn run(&self) -> Result<Self::Output, ()>;
+}
+
+pub async fn run_query<User: Authz, Q: Query<User> + 'static>(
+    auth: AuthSession<User::AuthnBackend>,
+    query: Q,
+) -> Result<Q::Output, ()> {
+    let user = auth.user;
+    query.run().await
+}
-- 
cgit 1.4.1-3-g733a5


From d42c3ae02f4c54fe3bdac7e0cc49c3c51e8fb517 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 5 Jan 2025 01:17:07 +0000
Subject: Merge the intrinsic and user tests for `select_unpredictable`

[1] mentions that having a single test with `-Zmerge-functions=disabled`
is preferable to having two separate tests.  Apply that to the new
`select_unpredicatble` test here.

[1]: https://github.com/rust-lang/rust/pull/133964#issuecomment-2569693325
---
 tests/codegen/bool-select-unpredictable.rs       | 35 ------------------------
 tests/codegen/intrinsics/select_unpredictable.rs | 34 ++++++++++++++++++++++-
 2 files changed, 33 insertions(+), 36 deletions(-)
 delete mode 100644 tests/codegen/bool-select-unpredictable.rs

(limited to 'tests')

diff --git a/tests/codegen/bool-select-unpredictable.rs b/tests/codegen/bool-select-unpredictable.rs
deleted file mode 100644
index 1562b177542..00000000000
--- a/tests/codegen/bool-select-unpredictable.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -O
-
-#![feature(select_unpredictable)]
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test_int(p: bool, a: u64, b: u64) -> u64 {
-    // CHECK-LABEL: define{{.*}} @test_int
-    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
-    p.select_unpredictable(a, b)
-}
-
-#[no_mangle]
-pub fn test_pair(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
-    // CHECK-LABEL: define{{.*}} @test_pair
-    // CHECK: select i1 %p, {{.*}}, !unpredictable
-    p.select_unpredictable(a, b)
-}
-
-struct Large {
-    e: [u64; 100],
-}
-
-#[no_mangle]
-pub fn test_struct(p: bool, a: Large, b: Large) -> Large {
-    // CHECK-LABEL: define{{.*}} @test_struct
-    // CHECK: select i1 %p, {{.*}}, !unpredictable
-    p.select_unpredictable(a, b)
-}
-
-#[no_mangle]
-pub fn test_zst(p: bool, a: (), b: ()) -> () {
-    // CHECK-LABEL: define{{.*}} @test_zst
-    p.select_unpredictable(a, b)
-}
diff --git a/tests/codegen/intrinsics/select_unpredictable.rs b/tests/codegen/intrinsics/select_unpredictable.rs
index 2054838dd79..b03c9708b8e 100644
--- a/tests/codegen/intrinsics/select_unpredictable.rs
+++ b/tests/codegen/intrinsics/select_unpredictable.rs
@@ -1,8 +1,11 @@
-//@ compile-flags: -O
+//@ compile-flags: -O -Zmerge-functions=disabled
 
 #![feature(core_intrinsics)]
+#![feature(select_unpredictable)]
 #![crate_type = "lib"]
 
+/* Test the intrinsic */
+
 #[no_mangle]
 pub fn test_int(p: bool, a: u64, b: u64) -> u64 {
     // CHECK-LABEL: define{{.*}} @test_int
@@ -33,3 +36,32 @@ pub fn test_zst(p: bool, a: (), b: ()) -> () {
     // CHECK-LABEL: define{{.*}} @test_zst
     core::intrinsics::select_unpredictable(p, a, b)
 }
+
+/* Test the user-facing version */
+
+#[no_mangle]
+pub fn test_int2(p: bool, a: u64, b: u64) -> u64 {
+    // CHECK-LABEL: define{{.*}} @test_int2
+    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
+    p.select_unpredictable(a, b)
+}
+
+#[no_mangle]
+pub fn test_pair2(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
+    // CHECK-LABEL: define{{.*}} @test_pair2
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    p.select_unpredictable(a, b)
+}
+
+#[no_mangle]
+pub fn test_struct2(p: bool, a: Large, b: Large) -> Large {
+    // CHECK-LABEL: define{{.*}} @test_struct2
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    p.select_unpredictable(a, b)
+}
+
+#[no_mangle]
+pub fn test_zst2(p: bool, a: (), b: ()) -> () {
+    // CHECK-LABEL: define{{.*}} @test_zst2
+    p.select_unpredictable(a, b)
+}
-- 
cgit 1.4.1-3-g733a5


From 51dc35017859f640663799b7989277fefae75d95 Mon Sep 17 00:00:00 2001
From: YunQiang Su <syq@debian.org>
Date: Sun, 5 Jan 2025 13:00:26 +0800
Subject: fix tests

---
 tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr | 2 +-
 tests/ui/check-cfg/exhaustive-names-values.feature.stderr   | 2 +-
 tests/ui/check-cfg/exhaustive-names-values.full.stderr      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
index d49ed3e7551..23b6edacce7 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
@@ -15,7 +15,7 @@ warning: unexpected `cfg` condition value: `value`
 LL | #[cfg(target_vendor = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `mti`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition name: `feature`
diff --git a/tests/ui/check-cfg/exhaustive-names-values.feature.stderr b/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
index 81dbbca4f86..804d7fb9163 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
@@ -15,7 +15,7 @@ warning: unexpected `cfg` condition value: `value`
 LL | #[cfg(target_vendor = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `mti`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `unk`
diff --git a/tests/ui/check-cfg/exhaustive-names-values.full.stderr b/tests/ui/check-cfg/exhaustive-names-values.full.stderr
index 81dbbca4f86..804d7fb9163 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.full.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.full.stderr
@@ -15,7 +15,7 @@ warning: unexpected `cfg` condition value: `value`
 LL | #[cfg(target_vendor = "value")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `mti`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `unk`
-- 
cgit 1.4.1-3-g733a5


From 74d2d4bfa475a131df0c9ee0754b022a458cd152 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 5 Jan 2025 08:44:01 +0000
Subject: Expand the `select_unpredictable` test for ZSTs

For ZSTs there is no selection that needs to take place, so assert that
no `select` statement is emitted.
---
 tests/codegen/intrinsics/select_unpredictable.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests')

diff --git a/tests/codegen/intrinsics/select_unpredictable.rs b/tests/codegen/intrinsics/select_unpredictable.rs
index b03c9708b8e..ea6127a48bf 100644
--- a/tests/codegen/intrinsics/select_unpredictable.rs
+++ b/tests/codegen/intrinsics/select_unpredictable.rs
@@ -31,9 +31,12 @@ pub fn test_struct(p: bool, a: Large, b: Large) -> Large {
     core::intrinsics::select_unpredictable(p, a, b)
 }
 
+// ZSTs should not need a `select` expression.
 #[no_mangle]
 pub fn test_zst(p: bool, a: (), b: ()) -> () {
     // CHECK-LABEL: define{{.*}} @test_zst
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
     core::intrinsics::select_unpredictable(p, a, b)
 }
 
@@ -63,5 +66,7 @@ pub fn test_struct2(p: bool, a: Large, b: Large) -> Large {
 #[no_mangle]
 pub fn test_zst2(p: bool, a: (), b: ()) -> () {
     // CHECK-LABEL: define{{.*}} @test_zst2
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
     p.select_unpredictable(a, b)
 }
-- 
cgit 1.4.1-3-g733a5


From db17be84fe7902e663ad78d3bc419b3f32717c52 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 5 Jan 2025 20:49:04 -0300
Subject: [generic_assert] Constify methods used by the formatting system

---
 library/core/src/fmt/mod.rs              |  4 ++--
 library/core/src/fmt/rt.rs               | 12 ++++++------
 tests/ui/consts/const-eval/format.rs     |  2 --
 tests/ui/consts/const-eval/format.stderr | 24 +++---------------------
 4 files changed, 11 insertions(+), 31 deletions(-)

(limited to 'tests')

diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index c2c78dd9c67..a033b8bd305 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -596,7 +596,7 @@ impl<'a> Arguments<'a> {
     /// When using the format_args!() macro, this function is used to generate the
     /// Arguments structure.
     #[inline]
-    pub fn new_v1<const P: usize, const A: usize>(
+    pub const fn new_v1<const P: usize, const A: usize>(
         pieces: &'a [&'static str; P],
         args: &'a [rt::Argument<'a>; A],
     ) -> Arguments<'a> {
@@ -612,7 +612,7 @@ impl<'a> Arguments<'a> {
     /// 2. Every `rt::Placeholder::position` value within `fmt` must be a valid index of `args`.
     /// 3. Every `rt::Count::Param` within `fmt` must contain a valid index of `args`.
     #[inline]
-    pub fn new_v1_formatted(
+    pub const fn new_v1_formatted(
         pieces: &'a [&'static str],
         args: &'a [rt::Argument<'a>],
         fmt: &'a [rt::Placeholder],
diff --git a/library/core/src/fmt/rt.rs b/library/core/src/fmt/rt.rs
index 94341a4da66..85d089a0790 100644
--- a/library/core/src/fmt/rt.rs
+++ b/library/core/src/fmt/rt.rs
@@ -96,12 +96,12 @@ pub struct Argument<'a> {
 #[rustc_diagnostic_item = "ArgumentMethods"]
 impl Argument<'_> {
     #[inline]
-    fn new<'a, T>(x: &'a T, f: fn(&T, &mut Formatter<'_>) -> Result) -> Argument<'a> {
+    const fn new<'a, T>(x: &'a T, f: fn(&T, &mut Formatter<'_>) -> Result) -> Argument<'a> {
         Argument {
             // INVARIANT: this creates an `ArgumentType<'a>` from a `&'a T` and
             // a `fn(&T, ...)`, so the invariant is maintained.
             ty: ArgumentType::Placeholder {
-                value: NonNull::from(x).cast(),
+                value: NonNull::from_ref(x).cast(),
                 // SAFETY: function pointers always have the same layout.
                 formatter: unsafe { mem::transmute(f) },
                 _lifetime: PhantomData,
@@ -150,7 +150,7 @@ impl Argument<'_> {
         Self::new(x, UpperExp::fmt)
     }
     #[inline]
-    pub fn from_usize(x: &usize) -> Argument<'_> {
+    pub const fn from_usize(x: &usize) -> Argument<'_> {
         Argument { ty: ArgumentType::Count(*x) }
     }
 
@@ -181,7 +181,7 @@ impl Argument<'_> {
     }
 
     #[inline]
-    pub(super) fn as_usize(&self) -> Option<usize> {
+    pub(super) const fn as_usize(&self) -> Option<usize> {
         match self.ty {
             ArgumentType::Count(count) => Some(count),
             ArgumentType::Placeholder { .. } => None,
@@ -199,7 +199,7 @@ impl Argument<'_> {
     /// println!("{f}");
     /// ```
     #[inline]
-    pub fn none() -> [Self; 0] {
+    pub const fn none() -> [Self; 0] {
         []
     }
 }
@@ -216,7 +216,7 @@ impl UnsafeArg {
     /// See documentation where `UnsafeArg` is required to know when it is safe to
     /// create and use `UnsafeArg`.
     #[inline]
-    pub unsafe fn new() -> Self {
+    pub const unsafe fn new() -> Self {
         Self { _private: () }
     }
 }
diff --git a/tests/ui/consts/const-eval/format.rs b/tests/ui/consts/const-eval/format.rs
index e56d15e935b..1878fc03827 100644
--- a/tests/ui/consts/const-eval/format.rs
+++ b/tests/ui/consts/const-eval/format.rs
@@ -1,13 +1,11 @@
 const fn failure() {
     panic!("{:?}", 0);
     //~^ ERROR cannot call non-const formatting macro in constant functions
-    //~| ERROR cannot call non-const associated function `Arguments::<'_>::new_v1::<1, 1>` in constant functions
 }
 
 const fn print() {
     println!("{:?}", 0);
     //~^ ERROR cannot call non-const formatting macro in constant functions
-    //~| ERROR cannot call non-const associated function `Arguments::<'_>::new_v1::<2, 1>` in constant functions
     //~| ERROR cannot call non-const function `_print` in constant functions
 }
 
diff --git a/tests/ui/consts/const-eval/format.stderr b/tests/ui/consts/const-eval/format.stderr
index 25ed44e0f33..af90acc2a26 100644
--- a/tests/ui/consts/const-eval/format.stderr
+++ b/tests/ui/consts/const-eval/format.stderr
@@ -7,17 +7,8 @@ LL |     panic!("{:?}", 0);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `$crate::const_format_args` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const associated function `Arguments::<'_>::new_v1::<1, 1>` in constant functions
-  --> $DIR/format.rs:2:5
-   |
-LL |     panic!("{:?}", 0);
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: this error originates in the macro `$crate::const_format_args` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0015]: cannot call non-const formatting macro in constant functions
-  --> $DIR/format.rs:8:15
+  --> $DIR/format.rs:7:15
    |
 LL |     println!("{:?}", 0);
    |               ^^^^
@@ -25,17 +16,8 @@ LL |     println!("{:?}", 0);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const associated function `Arguments::<'_>::new_v1::<2, 1>` in constant functions
-  --> $DIR/format.rs:8:5
-   |
-LL |     println!("{:?}", 0);
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0015]: cannot call non-const function `_print` in constant functions
-  --> $DIR/format.rs:8:5
+  --> $DIR/format.rs:7:5
    |
 LL |     println!("{:?}", 0);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -43,6 +25,6 @@ LL |     println!("{:?}", 0);
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0015`.
-- 
cgit 1.4.1-3-g733a5


From 3560a2b399ea30b8cd62d9c91a326f03a728e92a Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 6 Jan 2025 03:14:04 +0000
Subject: Improve span when temporary receiver is dropped in edition 2024

---
 .../src/diagnostics/explain_borrow.rs              | 34 ++++++++++++++++++++++
 tests/ui/lifetimes/tail-expr-in-nested-expr.stderr |  3 +-
 2 files changed, 35 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index 22f7f708419..87017460e8e 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -17,6 +17,7 @@ use rustc_middle::mir::{
 };
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt};
+use rustc_middle::util::CallKind;
 use rustc_span::{DesugaringKind, Span, Symbol, kw, sym};
 use rustc_trait_selection::error_reporting::traits::FindExprBySpan;
 use tracing::{debug, instrument};
@@ -635,6 +636,39 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                 // Used in a closure.
                 (LaterUseKind::ClosureCapture, capture_kind_span, Some(path_span))
             }
+            // In the case that the borrowed value (probably a temporary)
+            // overlaps with the method's receiver, then point at the method.
+            UseSpans::FnSelfUse {
+                var_span: span,
+                kind: CallKind::Normal { desugaring: None, .. },
+                ..
+            } if span
+                .overlaps(self.body.local_decls[borrow.assigned_place.local].source_info.span) =>
+            {
+                if let TerminatorKind::Call { func, call_source: CallSource::Normal, .. } =
+                    &self.body.basic_blocks[location.block].terminator().kind
+                {
+                    // Just point to the function, to reduce the chance of overlapping spans.
+                    let function_span = match func {
+                        Operand::Constant(c) => c.span,
+                        Operand::Copy(place) | Operand::Move(place) => {
+                            if let Some(l) = place.as_local() {
+                                let local_decl = &self.body.local_decls[l];
+                                if self.local_names[l].is_none() {
+                                    local_decl.source_info.span
+                                } else {
+                                    span
+                                }
+                            } else {
+                                span
+                            }
+                        }
+                    };
+                    (LaterUseKind::Call, function_span, None)
+                } else {
+                    (LaterUseKind::Other, span, None)
+                }
+            }
             UseSpans::PatUse(span)
             | UseSpans::OtherUse(span)
             | UseSpans::FnSelfUse { var_span: span, .. } => {
diff --git a/tests/ui/lifetimes/tail-expr-in-nested-expr.stderr b/tests/ui/lifetimes/tail-expr-in-nested-expr.stderr
index 6770da091ce..09801a1aad2 100644
--- a/tests/ui/lifetimes/tail-expr-in-nested-expr.stderr
+++ b/tests/ui/lifetimes/tail-expr-in-nested-expr.stderr
@@ -2,11 +2,10 @@ error[E0716]: temporary value dropped while borrowed
   --> $DIR/tail-expr-in-nested-expr.rs:4:15
    |
 LL |     let _ = { String::new().as_str() }.len();
-   |               ^^^^^^^^^^^^^---------
+   |               ^^^^^^^^^^^^^        -   --- borrow later used by call
    |               |                    |
    |               |                    temporary value is freed at the end of this statement
    |               creates a temporary value which is freed while still in use
-   |               borrow later used here
    |
    = note: consider using a `let` binding to create a longer lived value
 
-- 
cgit 1.4.1-3-g733a5


From cd65cd27db8a8fc11f3191d3e461d331ed0db968 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 6 Jan 2025 03:17:04 +0000
Subject: Improve find_self_call with reborrowed receiver

---
 compiler/rustc_middle/src/util/find_self_call.rs | 41 +++++++++++++-----------
 tests/ui/lint/lint-const-item-mutation.stderr    |  7 +++-
 2 files changed, 28 insertions(+), 20 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_middle/src/util/find_self_call.rs b/compiler/rustc_middle/src/util/find_self_call.rs
index ec6051d0a77..0fdd3520738 100644
--- a/compiler/rustc_middle/src/util/find_self_call.rs
+++ b/compiler/rustc_middle/src/util/find_self_call.rs
@@ -17,26 +17,29 @@ pub fn find_self_call<'tcx>(
     debug!("find_self_call(local={:?}): terminator={:?}", local, body[block].terminator);
     if let Some(Terminator { kind: TerminatorKind::Call { func, args, .. }, .. }) =
         &body[block].terminator
+        && let Operand::Constant(box ConstOperand { const_, .. }) = func
+        && let ty::FnDef(def_id, fn_args) = *const_.ty().kind()
+        && let Some(ty::AssocItem { fn_has_self_parameter: true, .. }) =
+            tcx.opt_associated_item(def_id)
+        && let [Spanned { node: Operand::Move(self_place) | Operand::Copy(self_place), .. }, ..] =
+            **args
     {
-        debug!("find_self_call: func={:?}", func);
-        if let Operand::Constant(box ConstOperand { const_, .. }) = func {
-            if let ty::FnDef(def_id, fn_args) = *const_.ty().kind() {
-                if let Some(ty::AssocItem { fn_has_self_parameter: true, .. }) =
-                    tcx.opt_associated_item(def_id)
-                {
-                    debug!("find_self_call: args={:?}", fn_args);
-                    if let [
-                        Spanned {
-                            node: Operand::Move(self_place) | Operand::Copy(self_place), ..
-                        },
-                        ..,
-                    ] = **args
-                    {
-                        if self_place.as_local() == Some(local) {
-                            return Some((def_id, fn_args));
-                        }
-                    }
-                }
+        if self_place.as_local() == Some(local) {
+            return Some((def_id, fn_args));
+        }
+
+        // Handle the case where `self_place` gets reborrowed.
+        // This happens when the receiver is `&T`.
+        for stmt in &body[block].statements {
+            if let StatementKind::Assign(box (place, rvalue)) = &stmt.kind
+                && let Some(reborrow_local) = place.as_local()
+                && self_place.as_local() == Some(reborrow_local)
+                && let Rvalue::Ref(_, _, deref_place) = rvalue
+                && let PlaceRef { local: deref_local, projection: [ProjectionElem::Deref] } =
+                    deref_place.as_ref()
+                && deref_local == local
+            {
+                return Some((def_id, fn_args));
             }
         }
     }
diff --git a/tests/ui/lint/lint-const-item-mutation.stderr b/tests/ui/lint/lint-const-item-mutation.stderr
index 747c38b8007..0e405c306fe 100644
--- a/tests/ui/lint/lint-const-item-mutation.stderr
+++ b/tests/ui/lint/lint-const-item-mutation.stderr
@@ -75,10 +75,15 @@ warning: taking a mutable reference to a `const` item
   --> $DIR/lint-const-item-mutation.rs:42:5
    |
 LL |     (&mut MY_STRUCT).use_mut();
-   |     ^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: each usage of a `const` item creates a new temporary
    = note: the mutable reference will refer to this temporary, not the original `const` item
+note: mutable reference created due to call to this method
+  --> $DIR/lint-const-item-mutation.rs:9:5
+   |
+LL |     fn use_mut(&mut self) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^
 note: `const` item defined here
   --> $DIR/lint-const-item-mutation.rs:27:1
    |
-- 
cgit 1.4.1-3-g733a5


From 339902908eba714abb3fbb7ec9014393392ea7f6 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 6 Jan 2025 03:45:02 +0000
Subject: Remove CallKind::Deref hack from UseSpans

It's not really necessary
---
 compiler/rustc_borrowck/src/diagnostics/mod.rs | 9 ---------
 tests/ui/moves/move-deref-coercion.stderr      | 4 ++--
 tests/ui/no-capture-arc.stderr                 | 4 ++--
 tests/ui/no-reuse-move-arc.stderr              | 4 ++--
 4 files changed, 6 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 180046ca256..ebbdfea302c 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -661,9 +661,6 @@ impl UseSpans<'_> {
             UseSpans::ClosureUse { args_span: span, .. }
             | UseSpans::PatUse(span)
             | UseSpans::OtherUse(span) => span,
-            UseSpans::FnSelfUse { fn_call_span, kind: CallKind::DerefCoercion { .. }, .. } => {
-                fn_call_span
-            }
             UseSpans::FnSelfUse { var_span, .. } => var_span,
         }
     }
@@ -674,9 +671,6 @@ impl UseSpans<'_> {
             UseSpans::ClosureUse { path_span: span, .. }
             | UseSpans::PatUse(span)
             | UseSpans::OtherUse(span) => span,
-            UseSpans::FnSelfUse { fn_call_span, kind: CallKind::DerefCoercion { .. }, .. } => {
-                fn_call_span
-            }
             UseSpans::FnSelfUse { var_span, .. } => var_span,
         }
     }
@@ -687,9 +681,6 @@ impl UseSpans<'_> {
             UseSpans::ClosureUse { capture_kind_span: span, .. }
             | UseSpans::PatUse(span)
             | UseSpans::OtherUse(span) => span,
-            UseSpans::FnSelfUse { fn_call_span, kind: CallKind::DerefCoercion { .. }, .. } => {
-                fn_call_span
-            }
             UseSpans::FnSelfUse { var_span, .. } => var_span,
         }
     }
diff --git a/tests/ui/moves/move-deref-coercion.stderr b/tests/ui/moves/move-deref-coercion.stderr
index 5760f4a7fdc..25639075a3f 100644
--- a/tests/ui/moves/move-deref-coercion.stderr
+++ b/tests/ui/moves/move-deref-coercion.stderr
@@ -4,7 +4,7 @@ error[E0382]: borrow of partially moved value: `val`
 LL |     let _val = val.first;
    |                --------- value partially moved here
 LL |     val.inner;
-   |     ^^^^^^^^^ value borrowed here after partial move
+   |     ^^^ value borrowed here after partial move
    |
    = note: partial move occurs because `val.first` has type `NotCopy`, which does not implement the `Copy` trait
    = note: borrow occurs due to deref coercion to `NotCopy`
@@ -20,7 +20,7 @@ error[E0382]: borrow of partially moved value: `val`
 LL |     let _val = val.first;
    |                --------- value partially moved here
 LL |     val.inner_method();
-   |     ^^^^^^^^^^^^^^^^^^ value borrowed here after partial move
+   |     ^^^ value borrowed here after partial move
    |
    = note: partial move occurs because `val.first` has type `NotCopy`, which does not implement the `Copy` trait
    = note: borrow occurs due to deref coercion to `NotCopy`
diff --git a/tests/ui/no-capture-arc.stderr b/tests/ui/no-capture-arc.stderr
index 38432c851c5..4a51ddb67a3 100644
--- a/tests/ui/no-capture-arc.stderr
+++ b/tests/ui/no-capture-arc.stderr
@@ -1,5 +1,5 @@
 error[E0382]: borrow of moved value: `arc_v`
-  --> $DIR/no-capture-arc.rs:14:16
+  --> $DIR/no-capture-arc.rs:14:18
    |
 LL |     let arc_v = Arc::new(v);
    |         ----- move occurs because `arc_v` has type `Arc<Vec<i32>>`, which does not implement the `Copy` trait
@@ -10,7 +10,7 @@ LL |         assert_eq!((*arc_v)[3], 4);
    |                      ----- variable moved due to use in closure
 ...
 LL |     assert_eq!((*arc_v)[2], 3);
-   |                ^^^^^^^^ value borrowed here after move
+   |                  ^^^^^ value borrowed here after move
    |
    = note: borrow occurs due to deref coercion to `Vec<i32>`
 
diff --git a/tests/ui/no-reuse-move-arc.stderr b/tests/ui/no-reuse-move-arc.stderr
index cdeb6eadc17..61f4837dc0e 100644
--- a/tests/ui/no-reuse-move-arc.stderr
+++ b/tests/ui/no-reuse-move-arc.stderr
@@ -1,5 +1,5 @@
 error[E0382]: borrow of moved value: `arc_v`
-  --> $DIR/no-reuse-move-arc.rs:12:16
+  --> $DIR/no-reuse-move-arc.rs:12:18
    |
 LL |     let arc_v = Arc::new(v);
    |         ----- move occurs because `arc_v` has type `Arc<Vec<i32>>`, which does not implement the `Copy` trait
@@ -10,7 +10,7 @@ LL |         assert_eq!((*arc_v)[3], 4);
    |                      ----- variable moved due to use in closure
 ...
 LL |     assert_eq!((*arc_v)[2], 3);
-   |                ^^^^^^^^ value borrowed here after move
+   |                  ^^^^^ value borrowed here after move
    |
    = note: borrow occurs due to deref coercion to `Vec<i32>`
 
-- 
cgit 1.4.1-3-g733a5


From 591bf634394867c44cfc5cdaf391f948e6c3d11a Mon Sep 17 00:00:00 2001
From: crystalstall <crystalruby@qq.com>
Date: Mon, 6 Jan 2025 15:47:49 +0800
Subject: chore: remove redundant words in comment

Signed-off-by: crystalstall <crystalruby@qq.com>
---
 library/std/src/ffi/os_str.rs                                           | 2 +-
 library/std/src/pipe.rs                                                 | 2 +-
 library/std/src/sync/poison/mutex.rs                                    | 2 +-
 .../dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch  | 2 +-
 tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs          | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index fff140f1564..7fb57d41043 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -550,7 +550,7 @@ impl OsString {
         OsStr::from_inner_mut(self.inner.leak())
     }
 
-    /// Truncate the the `OsString` to the specified length.
+    /// Truncate the `OsString` to the specified length.
     ///
     /// # Panics
     /// Panics if `len` does not lie on a valid `OsStr` boundary
diff --git a/library/std/src/pipe.rs b/library/std/src/pipe.rs
index 06f3fd9fdff..913c22588a7 100644
--- a/library/std/src/pipe.rs
+++ b/library/std/src/pipe.rs
@@ -97,7 +97,7 @@ impl PipeReader {
     /// let mut jobs = vec![];
     /// let (reader, mut writer) = std::pipe::pipe()?;
     ///
-    /// // Write NUM_SLOT characters the the pipe.
+    /// // Write NUM_SLOT characters the pipe.
     /// writer.write_all(&[b'|'; NUM_SLOT as usize])?;
     ///
     /// // Spawn several processes that read a character from the pipe, do some work, then
diff --git a/library/std/src/sync/poison/mutex.rs b/library/std/src/sync/poison/mutex.rs
index e28c2090afe..01ef71a187f 100644
--- a/library/std/src/sync/poison/mutex.rs
+++ b/library/std/src/sync/poison/mutex.rs
@@ -534,7 +534,7 @@ impl<T: ?Sized> Mutex<T> {
     /// # Errors
     ///
     /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return an error containing the the underlying data
+    /// this call will return an error containing the underlying data
     /// instead.
     ///
     /// # Examples
diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch b/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch
index 7ae4469428b..1ae0ecf6cb5 100644
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch
+++ b/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch
@@ -10,7 +10,7 @@ https://sourceware.org/bugzilla/show_bug.cgi?id=28509
 And this is the first version of the proposed binutils patch,
 https://sourceware.org/pipermail/binutils/2021-November/118398.html
 
-After applying the binutils patch, I get the the unexpected error when
+After applying the binutils patch, I get the unexpected error when
 building libgcc,
 
 /scratch/nelsonc/riscv-gnu-toolchain/riscv-gcc/libgcc/config/riscv/div.S:42:
diff --git a/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs b/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs
index 72375eb0b3e..f3bf299aa65 100644
--- a/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs
+++ b/tests/ui/duplicate/multiple-types-with-same-name-and-derive.rs
@@ -1,5 +1,5 @@
 // Here, there are two types with the same name. One of these has a `derive` annotation, but in the
-// expansion these `impl`s are associated to the the *other* type. There is a suggestion to remove
+// expansion these `impl`s are associated to the *other* type. There is a suggestion to remove
 // unneeded type parameters, but because we're now point at a type with no type parameters, the
 // suggestion would suggest removing code from an empty span, which would ICE in nightly.
 //
-- 
cgit 1.4.1-3-g733a5


From 49c74234a79107afa7f86ca947708c3abef07674 Mon Sep 17 00:00:00 2001
From: Hood Chatham <roberthoodchatham@gmail.com>
Date: Thu, 17 Oct 2024 13:00:35 +0200
Subject: Add support for wasm exception handling to Emscripten target

Gated behind an unstable `-Z emscripten-wasm-eh` flag
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs       |  5 +-
 compiler/rustc_codegen_ssa/src/back/link.rs        |  8 ++-
 compiler/rustc_codegen_ssa/src/base.rs             |  3 +-
 compiler/rustc_feature/src/builtin_attrs.rs        |  1 +
 compiler/rustc_feature/src/unstable.rs             |  2 +
 compiler/rustc_interface/src/tests.rs              |  1 +
 compiler/rustc_passes/src/weak_lang_items.rs       |  5 +-
 compiler/rustc_session/src/config/cfg.rs           |  5 ++
 compiler/rustc_session/src/options.rs              |  2 +
 compiler/rustc_span/src/symbol.rs                  |  2 +
 library/panic_unwind/Cargo.toml                    |  2 +-
 library/panic_unwind/src/lib.rs                    |  3 +-
 library/unwind/Cargo.toml                          |  2 +-
 library/unwind/src/lib.rs                          |  3 +-
 .../src/compiler-flags/emscripten-wasm-eh.md       |  6 ++
 tests/codegen/emcripten-catch-unwind.rs            | 66 ----------------------
 tests/codegen/emscripten-catch-unwind-js-eh.rs     | 66 ++++++++++++++++++++++
 tests/codegen/emscripten-catch-unwind-wasm-eh.rs   | 65 +++++++++++++++++++++
 .../disallowed-cli-cfgs.emscripten_wasm_eh_.stderr |  8 +++
 tests/ui/cfg/disallowed-cli-cfgs.rs                |  2 +
 .../feature-gate-cfg-emscripten-wasm-eh.rs         |  4 ++
 .../feature-gate-cfg-emscripten-wasm-eh.stderr     | 12 ++++
 22 files changed, 197 insertions(+), 76 deletions(-)
 create mode 100644 src/doc/unstable-book/src/compiler-flags/emscripten-wasm-eh.md
 delete mode 100644 tests/codegen/emcripten-catch-unwind.rs
 create mode 100644 tests/codegen/emscripten-catch-unwind-js-eh.rs
 create mode 100644 tests/codegen/emscripten-catch-unwind-wasm-eh.rs
 create mode 100644 tests/ui/cfg/disallowed-cli-cfgs.emscripten_wasm_eh_.stderr
 create mode 100644 tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.stderr

(limited to 'tests')

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 628c0b1c29c..b3e1210632f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -109,7 +109,10 @@ unsafe fn configure_llvm(sess: &Session) {
             add("-wasm-enable-eh", false);
         }
 
-        if sess.target.os == "emscripten" && sess.panic_strategy() == PanicStrategy::Unwind {
+        if sess.target.os == "emscripten"
+            && !sess.opts.unstable_opts.emscripten_wasm_eh
+            && sess.panic_strategy() == PanicStrategy::Unwind
+        {
             add("-enable-emscripten-cxx-exceptions", false);
         }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 4bc064528f3..0a941a89609 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -2466,10 +2466,12 @@ fn add_order_independent_options(
     }
 
     if sess.target.os == "emscripten" {
-        cmd.cc_arg("-s").cc_arg(if sess.panic_strategy() == PanicStrategy::Abort {
-            "DISABLE_EXCEPTION_CATCHING=1"
+        cmd.cc_arg(if sess.panic_strategy() == PanicStrategy::Abort {
+            "-sDISABLE_EXCEPTION_CATCHING=1"
+        } else if sess.opts.unstable_opts.emscripten_wasm_eh {
+            "-fwasm-exceptions"
         } else {
-            "DISABLE_EXCEPTION_CATCHING=0"
+            "-sDISABLE_EXCEPTION_CATCHING=0"
         });
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 77e1fed720d..544578b29f1 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -388,7 +388,8 @@ pub(crate) fn build_shift_expr_rhs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 // exceptions. This means that the VM does the unwinding for
 // us
 pub fn wants_wasm_eh(sess: &Session) -> bool {
-    sess.target.is_like_wasm && sess.target.os != "emscripten"
+    sess.target.is_like_wasm
+        && (sess.target.os != "emscripten" || sess.opts.unstable_opts.emscripten_wasm_eh)
 }
 
 /// Returns `true` if this session's target will use SEH-based unwinding.
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 4112ae80980..09c8a8a06ec 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -37,6 +37,7 @@ const GATED_CFGS: &[GatedCfg] = &[
     (sym::sanitizer_cfi_normalize_integers, sym::cfg_sanitizer_cfi, Features::cfg_sanitizer_cfi),
     // this is consistent with naming of the compiler flag it's for
     (sym::fmt_debug, sym::fmt_debug, Features::fmt_debug),
+    (sym::emscripten_wasm_eh, sym::cfg_emscripten_wasm_eh, Features::cfg_emscripten_wasm_eh),
 ];
 
 /// Find a gated cfg determined by the `pred`icate which is given the cfg's name.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index d40823d2ed6..8cc4c18c02a 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -202,6 +202,8 @@ declare_features! (
     (internal, allow_internal_unstable, "1.0.0", None),
     /// Allows using anonymous lifetimes in argument-position impl-trait.
     (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
+    /// Allows access to the emscripten_wasm_eh config, used by panic_unwind and unwind
+    (internal, cfg_emscripten_wasm_eh, "CURRENT_RUSTC_VERSION", None),
     /// Allows identifying the `compiler_builtins` crate.
     (internal, compiler_builtins, "1.13.0", None),
     /// Allows writing custom MIR
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 9ad69039914..b50f3b38f2e 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -782,6 +782,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(dwarf_version, Some(5));
     tracked!(embed_source, true);
     tracked!(emit_thin_lto, false);
+    tracked!(emscripten_wasm_eh, true);
     tracked!(export_executable_symbols, true);
     tracked!(fewer_names, Some(true));
     tracked!(fixed_x18, true);
diff --git a/compiler/rustc_passes/src/weak_lang_items.rs b/compiler/rustc_passes/src/weak_lang_items.rs
index 020128f29c5..701f500e4f6 100644
--- a/compiler/rustc_passes/src/weak_lang_items.rs
+++ b/compiler/rustc_passes/src/weak_lang_items.rs
@@ -26,7 +26,10 @@ pub(crate) fn check_crate(
     if items.eh_personality().is_none() {
         items.missing.push(LangItem::EhPersonality);
     }
-    if tcx.sess.target.os == "emscripten" && items.eh_catch_typeinfo().is_none() {
+    if tcx.sess.target.os == "emscripten"
+        && items.eh_catch_typeinfo().is_none()
+        && !tcx.sess.opts.unstable_opts.emscripten_wasm_eh
+    {
         items.missing.push(LangItem::EhCatchTypeinfo);
     }
 
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index 3426858495b..40016cb76d6 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -143,6 +143,7 @@ pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
             | (sym::target_has_atomic_load_store, Some(_))
             | (sym::target_thread_local, None) => disallow(cfg, "--target"),
             (sym::fmt_debug, None | Some(_)) => disallow(cfg, "-Z fmt-debug"),
+            (sym::emscripten_wasm_eh, None | Some(_)) => disallow(cfg, "-Z emscripten_wasm_eh"),
             _ => {}
         }
     }
@@ -295,6 +296,10 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg {
         ins_none!(sym::ub_checks);
     }
 
+    // Nightly-only implementation detail for the `panic_unwind` and `unwind` crates.
+    if sess.is_nightly_build() && sess.opts.unstable_opts.emscripten_wasm_eh {
+        ins_none!(sym::emscripten_wasm_eh);
+    }
     ret
 }
 
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 3772a4a08af..a344ec94a26 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -1771,6 +1771,8 @@ options! {
         "emit a section containing stack size metadata (default: no)"),
     emit_thin_lto: bool = (true, parse_bool, [TRACKED],
         "emit the bc module with thin LTO info (default: yes)"),
+    emscripten_wasm_eh: bool = (false, parse_bool, [TRACKED],
+        "Use WebAssembly error handling for wasm32-unknown-emscripten"),
     enforce_type_length_limit: bool = (false, parse_bool, [TRACKED],
         "enforce the type length limit when monomorphizing instances in codegen"),
     export_executable_symbols: bool = (false, parse_bool, [TRACKED],
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 4ecc4201f89..e62107c450e 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -570,6 +570,7 @@ symbols! {
         cfg_autodiff_fallback,
         cfg_boolean_literals,
         cfg_doctest,
+        cfg_emscripten_wasm_eh,
         cfg_eval,
         cfg_fmt_debug,
         cfg_hide,
@@ -823,6 +824,7 @@ symbols! {
         emit_enum_variant_arg,
         emit_struct,
         emit_struct_field,
+        emscripten_wasm_eh,
         enable,
         encode,
         end,
diff --git a/library/panic_unwind/Cargo.toml b/library/panic_unwind/Cargo.toml
index 252f118fecf..c2abb79192e 100644
--- a/library/panic_unwind/Cargo.toml
+++ b/library/panic_unwind/Cargo.toml
@@ -23,4 +23,4 @@ libc = { version = "0.2", default-features = false }
 
 [lints.rust.unexpected_cfgs]
 level = "warn"
-check-cfg = []
+check-cfg = ['cfg(emscripten_wasm_eh)']
diff --git a/library/panic_unwind/src/lib.rs b/library/panic_unwind/src/lib.rs
index 1981675f409..085c07591d2 100644
--- a/library/panic_unwind/src/lib.rs
+++ b/library/panic_unwind/src/lib.rs
@@ -25,13 +25,14 @@
 // `real_imp` is unused with Miri, so silence warnings.
 #![cfg_attr(miri, allow(dead_code))]
 #![allow(internal_features)]
+#![cfg_attr(not(bootstrap), feature(cfg_emscripten_wasm_eh))]
 
 use alloc::boxed::Box;
 use core::any::Any;
 use core::panic::PanicPayload;
 
 cfg_if::cfg_if! {
-    if #[cfg(target_os = "emscripten")] {
+    if #[cfg(all(target_os = "emscripten", not(emscripten_wasm_eh)))] {
         #[path = "emcc.rs"]
         mod imp;
     } else if #[cfg(target_os = "hermit")] {
diff --git a/library/unwind/Cargo.toml b/library/unwind/Cargo.toml
index e13c9a06c05..66e8d1a3ffe 100644
--- a/library/unwind/Cargo.toml
+++ b/library/unwind/Cargo.toml
@@ -37,4 +37,4 @@ system-llvm-libunwind = []
 
 [lints.rust.unexpected_cfgs]
 level = "warn"
-check-cfg = []
+check-cfg = ['cfg(emscripten_wasm_eh)']
diff --git a/library/unwind/src/lib.rs b/library/unwind/src/lib.rs
index 40d409310ff..9b93f0b3da0 100644
--- a/library/unwind/src/lib.rs
+++ b/library/unwind/src/lib.rs
@@ -4,10 +4,11 @@
 #![feature(staged_api)]
 #![cfg_attr(not(target_env = "msvc"), feature(libc))]
 #![cfg_attr(
-    all(target_family = "wasm", not(target_os = "emscripten")),
+    all(target_family = "wasm", any(not(target_os = "emscripten"), emscripten_wasm_eh)),
     feature(simd_wasm64, wasm_exception_handling_intrinsics)
 )]
 #![allow(internal_features)]
+#![cfg_attr(not(bootstrap), feature(cfg_emscripten_wasm_eh))]
 
 // Force libc to be included even if unused. This is required by many platforms.
 #[cfg(not(all(windows, target_env = "msvc")))]
diff --git a/src/doc/unstable-book/src/compiler-flags/emscripten-wasm-eh.md b/src/doc/unstable-book/src/compiler-flags/emscripten-wasm-eh.md
new file mode 100644
index 00000000000..eab29a1744b
--- /dev/null
+++ b/src/doc/unstable-book/src/compiler-flags/emscripten-wasm-eh.md
@@ -0,0 +1,6 @@
+# `emscripten-wasm-eh`
+
+Use the WebAssembly exception handling ABI to unwind for the
+`wasm32-unknown-emscripten`. If compiling with this setting, the `emcc` linker
+should be invoked with `-fwasm-exceptions`. If linking with C/C++ files, the
+C/C++ files should also be compiled with `-fwasm-exceptions`.
diff --git a/tests/codegen/emcripten-catch-unwind.rs b/tests/codegen/emcripten-catch-unwind.rs
deleted file mode 100644
index b15fb40b68f..00000000000
--- a/tests/codegen/emcripten-catch-unwind.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//@ compile-flags: -O --target wasm32-unknown-emscripten
-//@ needs-llvm-components: webassembly
-
-// Emscripten has its own unique implementation of catch_unwind (in `codegen_emcc_try`),
-// make sure it generates something reasonable.
-
-#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
-
-impl<T> Copy for *mut T {}
-
-#[rustc_intrinsic]
-fn size_of<T>() -> usize {
-    loop {}
-}
-
-extern "rust-intrinsic" {
-    fn catch_unwind(
-        try_fn: fn(_: *mut u8),
-        data: *mut u8,
-        catch_fn: fn(_: *mut u8, _: *mut u8),
-    ) -> i32;
-}
-
-// CHECK-LABEL: @ptr_size
-#[no_mangle]
-pub fn ptr_size() -> usize {
-    // CHECK: ret [[PTR_SIZE:.*]]
-    size_of::<*mut u8>()
-}
-
-// CHECK-LABEL: @test_catch_unwind
-#[no_mangle]
-pub unsafe fn test_catch_unwind(
-    try_fn: fn(_: *mut u8),
-    data: *mut u8,
-    catch_fn: fn(_: *mut u8, _: *mut u8),
-) -> i32 {
-    // CHECK: start:
-    // CHECK: [[ALLOCA:%.*]] = alloca
-
-    // CHECK: catch.i:
-    // CHECK: [[LANDINGPAD:%.*]] = landingpad
-    // CHECK: [[EXCEPTION:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 0
-    // CHECK: [[SELECTOR:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 1
-
-    // CHECK: [[IS_RUST_EXN:%.*]] = icmp eq {{.*}}[[SELECTOR]]
-    // CHECK: [[IS_RUST_EXN_I8:%.*]] = zext i1 [[IS_RUST_EXN]] to i8
-
-    // CHECK: store ptr [[EXCEPTION]], ptr [[ALLOCA]]
-    // CHECK: [[IS_RUST_SLOT:%.*]] = getelementptr inbounds{{( nuw)?}} i8, ptr [[ALLOCA]], [[PTR_SIZE]]
-    // CHECK: store i8 [[IS_RUST_EXN_I8]], ptr [[IS_RUST_SLOT]]
-
-    // CHECK: call void %catch_fn(ptr %data, ptr nonnull [[ALLOCA]])
-
-    catch_unwind(try_fn, data, catch_fn)
-}
diff --git a/tests/codegen/emscripten-catch-unwind-js-eh.rs b/tests/codegen/emscripten-catch-unwind-js-eh.rs
new file mode 100644
index 00000000000..b15fb40b68f
--- /dev/null
+++ b/tests/codegen/emscripten-catch-unwind-js-eh.rs
@@ -0,0 +1,66 @@
+//@ compile-flags: -O --target wasm32-unknown-emscripten
+//@ needs-llvm-components: webassembly
+
+// Emscripten has its own unique implementation of catch_unwind (in `codegen_emcc_try`),
+// make sure it generates something reasonable.
+
+#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
+
+impl<T> Copy for *mut T {}
+
+#[rustc_intrinsic]
+fn size_of<T>() -> usize {
+    loop {}
+}
+
+extern "rust-intrinsic" {
+    fn catch_unwind(
+        try_fn: fn(_: *mut u8),
+        data: *mut u8,
+        catch_fn: fn(_: *mut u8, _: *mut u8),
+    ) -> i32;
+}
+
+// CHECK-LABEL: @ptr_size
+#[no_mangle]
+pub fn ptr_size() -> usize {
+    // CHECK: ret [[PTR_SIZE:.*]]
+    size_of::<*mut u8>()
+}
+
+// CHECK-LABEL: @test_catch_unwind
+#[no_mangle]
+pub unsafe fn test_catch_unwind(
+    try_fn: fn(_: *mut u8),
+    data: *mut u8,
+    catch_fn: fn(_: *mut u8, _: *mut u8),
+) -> i32 {
+    // CHECK: start:
+    // CHECK: [[ALLOCA:%.*]] = alloca
+
+    // CHECK: catch.i:
+    // CHECK: [[LANDINGPAD:%.*]] = landingpad
+    // CHECK: [[EXCEPTION:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 0
+    // CHECK: [[SELECTOR:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 1
+
+    // CHECK: [[IS_RUST_EXN:%.*]] = icmp eq {{.*}}[[SELECTOR]]
+    // CHECK: [[IS_RUST_EXN_I8:%.*]] = zext i1 [[IS_RUST_EXN]] to i8
+
+    // CHECK: store ptr [[EXCEPTION]], ptr [[ALLOCA]]
+    // CHECK: [[IS_RUST_SLOT:%.*]] = getelementptr inbounds{{( nuw)?}} i8, ptr [[ALLOCA]], [[PTR_SIZE]]
+    // CHECK: store i8 [[IS_RUST_EXN_I8]], ptr [[IS_RUST_SLOT]]
+
+    // CHECK: call void %catch_fn(ptr %data, ptr nonnull [[ALLOCA]])
+
+    catch_unwind(try_fn, data, catch_fn)
+}
diff --git a/tests/codegen/emscripten-catch-unwind-wasm-eh.rs b/tests/codegen/emscripten-catch-unwind-wasm-eh.rs
new file mode 100644
index 00000000000..72395f432d5
--- /dev/null
+++ b/tests/codegen/emscripten-catch-unwind-wasm-eh.rs
@@ -0,0 +1,65 @@
+//@ compile-flags: -O --target wasm32-unknown-emscripten -Z emscripten-wasm-eh
+//@ needs-llvm-components: webassembly
+
+// Emscripten catch_unwind using wasm exceptions
+
+#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
+
+impl<T> Copy for *mut T {}
+
+#[rustc_intrinsic]
+fn size_of<T>() -> usize {
+    loop {}
+}
+
+extern "rust-intrinsic" {
+    fn catch_unwind(
+        try_fn: fn(_: *mut u8),
+        data: *mut u8,
+        catch_fn: fn(_: *mut u8, _: *mut u8),
+    ) -> i32;
+}
+
+// CHECK-LABEL: @ptr_size
+#[no_mangle]
+pub fn ptr_size() -> usize {
+    // CHECK: ret [[PTR_SIZE:.*]]
+    size_of::<*mut u8>()
+}
+
+// CHECK-LABEL: @test_catch_unwind
+#[no_mangle]
+pub unsafe fn test_catch_unwind(
+    try_fn: fn(_: *mut u8),
+    data: *mut u8,
+    catch_fn: fn(_: *mut u8, _: *mut u8),
+) -> i32 {
+    // CHECK: start:
+    // CHECK: invoke void %try_fn(ptr %data)
+    // CHECK:         to label %__rust_try.exit unwind label %catchswitch.i
+    // CHECK:   catchswitch.i:                                    ; preds = %start
+    // CHECK:   %catchswitch1.i = catchswitch within none [label %catchpad.i] unwind to caller
+
+    // CHECK: catchpad.i:                                       ; preds = %catchswitch.i
+    // CHECK:   %catchpad2.i = catchpad within %catchswitch1.i [ptr null]
+    // CHECK:   %0 = tail call ptr @llvm.wasm.get.exception(token %catchpad2.i)
+    // CHECK:   %1 = tail call i32 @llvm.wasm.get.ehselector(token %catchpad2.i)
+    // CHECK:   call void %catch_fn(ptr %data, ptr %0) [ "funclet"(token %catchpad2.i) ]
+    // CHECK:   catchret from %catchpad2.i to label %__rust_try.exit
+
+    // CHECK: __rust_try.exit:                                  ; preds = %start, %catchpad.i
+    // CHECK:   %common.ret.op.i = phi i32 [ 0, %start ], [ 1, %catchpad.i ]
+    // CHECK:   ret i32 %common.ret.op.i
+
+    catch_unwind(try_fn, data, catch_fn)
+}
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.emscripten_wasm_eh_.stderr b/tests/ui/cfg/disallowed-cli-cfgs.emscripten_wasm_eh_.stderr
new file mode 100644
index 00000000000..8b2ee0e5c0c
--- /dev/null
+++ b/tests/ui/cfg/disallowed-cli-cfgs.emscripten_wasm_eh_.stderr
@@ -0,0 +1,8 @@
+error: unexpected `--cfg emscripten_wasm_eh` flag
+   |
+   = note: config `emscripten_wasm_eh` is only supposed to be controlled by `-Z emscripten_wasm_eh`
+   = note: manually setting a built-in cfg can and does create incoherent behaviors
+   = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.rs b/tests/ui/cfg/disallowed-cli-cfgs.rs
index 3c9ee87f28a..cae9c65cb45 100644
--- a/tests/ui/cfg/disallowed-cli-cfgs.rs
+++ b/tests/ui/cfg/disallowed-cli-cfgs.rs
@@ -7,6 +7,7 @@
 //@ revisions: target_has_atomic_equal_alignment_ target_has_atomic_load_store_
 //@ revisions: target_thread_local_ relocation_model_
 //@ revisions: fmt_debug_
+//@ revisions: emscripten_wasm_eh_
 
 //@ [overflow_checks_]compile-flags: --cfg overflow_checks
 //@ [debug_assertions_]compile-flags: --cfg debug_assertions
@@ -33,5 +34,6 @@
 //@ [target_thread_local_]compile-flags: --cfg target_thread_local
 //@ [relocation_model_]compile-flags: --cfg relocation_model="a"
 //@ [fmt_debug_]compile-flags: --cfg fmt_debug="shallow"
+//@ [emscripten_wasm_eh_]compile-flags: --cfg emscripten_wasm_eh
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.rs b/tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.rs
new file mode 100644
index 00000000000..cff98b43fe7
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.rs
@@ -0,0 +1,4 @@
+//@ compile-flags: --check-cfg=cfg(emscripten_wasm_eh)
+#[cfg(not(emscripten_wasm_eh))]
+//~^ `cfg(emscripten_wasm_eh)` is experimental
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.stderr b/tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.stderr
new file mode 100644
index 00000000000..67769e3c758
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-cfg-emscripten-wasm-eh.stderr
@@ -0,0 +1,12 @@
+error[E0658]: `cfg(emscripten_wasm_eh)` is experimental and subject to change
+  --> $DIR/feature-gate-cfg-emscripten-wasm-eh.rs:2:11
+   |
+LL | #[cfg(not(emscripten_wasm_eh))]
+   |           ^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(cfg_emscripten_wasm_eh)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From 37f26311ebd2895e8052a4caa4c89dedf6fbef9d Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Sun, 5 Jan 2025 15:32:20 +0300
Subject: add deprecated and do nothing flag to options table

inline_threshold mark deprecated

no-stack-check

print deprecation message for -Car too

inline_threshold deprecated and do nothing: make in untracked

make OptionDesc struct from tuple
---
 compiler/rustc_driver_impl/src/lib.rs              | 30 +++++---------
 compiler/rustc_interface/src/tests.rs              |  2 +-
 compiler/rustc_session/src/options.rs              | 48 ++++++++++++++++++----
 tests/ui/deprecation/deprecated_ar.rs              |  4 ++
 tests/ui/deprecation/deprecated_ar.stderr          |  2 +
 .../deprecated_inline_threshold.bad_val.stderr     |  4 ++
 .../deprecated_inline_threshold.good_val.stderr    |  2 +
 .../deprecated_inline_threshold.no_val.stderr      |  4 ++
 .../ui/deprecation/deprecated_inline_threshold.rs  |  8 +++-
 .../deprecation/deprecated_inline_threshold.stderr |  2 -
 .../deprecation/deprecated_no_stack_check_opt.rs   |  4 ++
 .../deprecated_no_stack_check_opt.stderr           |  2 +
 12 files changed, 78 insertions(+), 34 deletions(-)
 create mode 100644 tests/ui/deprecation/deprecated_ar.rs
 create mode 100644 tests/ui/deprecation/deprecated_ar.stderr
 create mode 100644 tests/ui/deprecation/deprecated_inline_threshold.bad_val.stderr
 create mode 100644 tests/ui/deprecation/deprecated_inline_threshold.good_val.stderr
 create mode 100644 tests/ui/deprecation/deprecated_inline_threshold.no_val.stderr
 delete mode 100644 tests/ui/deprecation/deprecated_inline_threshold.stderr
 create mode 100644 tests/ui/deprecation/deprecated_no_stack_check_opt.rs
 create mode 100644 tests/ui/deprecation/deprecated_no_stack_check_opt.stderr

(limited to 'tests')

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 90f382e7226..0413e5e8634 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -52,8 +52,8 @@ use rustc_metadata::locator;
 use rustc_middle::ty::TyCtxt;
 use rustc_parse::{new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_session::config::{
-    CG_OPTIONS, ErrorOutputType, Input, OutFileName, OutputType, UnstableOptions, Z_OPTIONS,
-    nightly_options,
+    CG_OPTIONS, ErrorOutputType, Input, OptionDesc, OutFileName, OutputType, UnstableOptions,
+    Z_OPTIONS, nightly_options,
 };
 use rustc_session::getopts::{self, Matches};
 use rustc_session::lint::{Lint, LintId};
@@ -1124,14 +1124,6 @@ pub fn describe_flag_categories(early_dcx: &EarlyDiagCtxt, matches: &Matches) ->
         return true;
     }
 
-    if cg_flags.iter().any(|x| *x == "no-stack-check") {
-        early_dcx.early_warn("the `-Cno-stack-check` flag is deprecated and does nothing");
-    }
-
-    if cg_flags.iter().any(|x| x.starts_with("inline-threshold")) {
-        early_dcx.early_warn("the `-Cinline-threshold` flag is deprecated and does nothing (consider using `-Cllvm-args=--inline-threshold=...`)");
-    }
-
     if cg_flags.iter().any(|x| *x == "passes=list") {
         let backend_name = debug_flags.iter().find_map(|x| x.strip_prefix("codegen-backend="));
 
@@ -1156,18 +1148,16 @@ fn describe_codegen_flags() {
     print_flag_list("-C", config::CG_OPTIONS);
 }
 
-fn print_flag_list<T>(
-    cmdline_opt: &str,
-    flag_list: &[(&'static str, T, &'static str, &'static str)],
-) {
-    let max_len = flag_list.iter().map(|&(name, _, _, _)| name.chars().count()).max().unwrap_or(0);
+fn print_flag_list<T>(cmdline_opt: &str, flag_list: &[OptionDesc<T>]) {
+    let max_len =
+        flag_list.iter().map(|opt_desc| opt_desc.name().chars().count()).max().unwrap_or(0);
 
-    for &(name, _, _, desc) in flag_list {
+    for opt_desc in flag_list {
         safe_println!(
             "    {} {:>width$}=val -- {}",
             cmdline_opt,
-            name.replace('_', "-"),
-            desc,
+            opt_desc.name().replace('_', "-"),
+            opt_desc.desc(),
             width = max_len
         );
     }
@@ -1221,8 +1211,8 @@ pub fn handle_options(early_dcx: &EarlyDiagCtxt, args: &[String]) -> Option<geto
         let msg: Option<String> = match e {
             getopts::Fail::UnrecognizedOption(ref opt) => CG_OPTIONS
                 .iter()
-                .map(|&(name, ..)| ('C', name))
-                .chain(Z_OPTIONS.iter().map(|&(name, ..)| ('Z', name)))
+                .map(|opt_desc| ('C', opt_desc.name()))
+                .chain(Z_OPTIONS.iter().map(|opt_desc| ('Z', opt_desc.name())))
                 .find(|&(_, name)| *opt == name.replace('_', "-"))
                 .map(|(flag, _)| format!("{e}. Did you mean `-{flag} {opt}`?")),
             getopts::Fail::ArgumentMissing(ref opt) => {
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 9ad69039914..bb5f1c295c7 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -582,6 +582,7 @@ fn test_codegen_options_tracking_hash() {
     untracked!(dlltool, Some(PathBuf::from("custom_dlltool.exe")));
     untracked!(extra_filename, String::from("extra-filename"));
     untracked!(incremental, Some(String::from("abc")));
+    untracked!(inline_threshold, Some(0xf007ba11));
     // `link_arg` is omitted because it just forwards to `link_args`.
     untracked!(link_args, vec![String::from("abc"), String::from("def")]);
     untracked!(link_self_contained, LinkSelfContained::on());
@@ -613,7 +614,6 @@ fn test_codegen_options_tracking_hash() {
     tracked!(embed_bitcode, false);
     tracked!(force_frame_pointers, FramePointer::Always);
     tracked!(force_unwind_tables, Some(true));
-    tracked!(inline_threshold, Some(0xf007ba11));
     tracked!(instrument_coverage, InstrumentCoverage::Yes);
     tracked!(link_dead_code, Some(true));
     tracked!(linker_plugin_lto, LinkerPluginLto::LinkerPluginAuto);
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 3772a4a08af..30047339810 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -239,7 +239,8 @@ macro_rules! options {
         $init:expr,
         $parse:ident,
         [$dep_tracking_marker:ident],
-        $desc:expr)
+        $desc:expr
+        $(, deprecated_do_nothing: $dnn:literal )?)
      ),* ,) =>
 (
     #[derive(Clone)]
@@ -280,7 +281,8 @@ macro_rules! options {
     }
 
     pub const $stat: OptionDescrs<$struct_name> =
-        &[ $( (stringify!($opt), $optmod::$opt, desc::$parse, $desc) ),* ];
+        &[ $( OptionDesc{ name: stringify!($opt), setter: $optmod::$opt,
+            type_desc: desc::$parse, desc: $desc, is_deprecated_and_do_nothing: false $( || $dnn )? } ),* ];
 
     mod $optmod {
     $(
@@ -315,7 +317,27 @@ macro_rules! redirect_field {
 }
 
 type OptionSetter<O> = fn(&mut O, v: Option<&str>) -> bool;
-type OptionDescrs<O> = &'static [(&'static str, OptionSetter<O>, &'static str, &'static str)];
+type OptionDescrs<O> = &'static [OptionDesc<O>];
+
+pub struct OptionDesc<O> {
+    name: &'static str,
+    setter: OptionSetter<O>,
+    // description for return value/type from mod desc
+    type_desc: &'static str,
+    // description for option from options table
+    desc: &'static str,
+    is_deprecated_and_do_nothing: bool,
+}
+
+impl<O> OptionDesc<O> {
+    pub fn name(&self) -> &'static str {
+        self.name
+    }
+
+    pub fn desc(&self) -> &'static str {
+        self.desc
+    }
+}
 
 #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
 fn build_options<O: Default>(
@@ -333,8 +355,13 @@ fn build_options<O: Default>(
         };
 
         let option_to_lookup = key.replace('-', "_");
-        match descrs.iter().find(|(name, ..)| *name == option_to_lookup) {
-            Some((_, setter, type_desc, _)) => {
+        match descrs.iter().find(|opt_desc| opt_desc.name == option_to_lookup) {
+            Some(OptionDesc { name: _, setter, type_desc, desc, is_deprecated_and_do_nothing }) => {
+                if *is_deprecated_and_do_nothing {
+                    // deprecation works for prefixed options only
+                    assert!(!prefix.is_empty());
+                    early_dcx.early_warn(format!("`-{prefix} {key}`: {desc}"));
+                }
                 if !setter(&mut op, value) {
                     match value {
                         None => early_dcx.early_fatal(
@@ -1546,7 +1573,8 @@ options! {
     // tidy-alphabetical-start
     #[rustc_lint_opt_deny_field_access("documented to do nothing")]
     ar: String = (String::new(), parse_string, [UNTRACKED],
-        "this option is deprecated and does nothing"),
+        "this option is deprecated and does nothing",
+        deprecated_do_nothing: true),
     #[rustc_lint_opt_deny_field_access("use `Session::code_model` instead of this field")]
     code_model: Option<CodeModel> = (None, parse_code_model, [TRACKED],
         "choose the code model to use (`rustc --print code-models` for details)"),
@@ -1578,9 +1606,10 @@ options! {
     incremental: Option<String> = (None, parse_opt_string, [UNTRACKED],
         "enable incremental compilation"),
     #[rustc_lint_opt_deny_field_access("documented to do nothing")]
-    inline_threshold: Option<u32> = (None, parse_opt_number, [TRACKED],
+    inline_threshold: Option<u32> = (None, parse_opt_number, [UNTRACKED],
         "this option is deprecated and does nothing \
-        (consider using `-Cllvm-args=--inline-threshold=...`)"),
+        (consider using `-Cllvm-args=--inline-threshold=...`)",
+        deprecated_do_nothing: true),
     #[rustc_lint_opt_deny_field_access("use `Session::instrument_coverage` instead of this field")]
     instrument_coverage: InstrumentCoverage = (InstrumentCoverage::No, parse_instrument_coverage, [TRACKED],
         "instrument the generated code to support LLVM source-based code coverage reports \
@@ -1616,7 +1645,8 @@ options! {
         "disable the use of the redzone"),
     #[rustc_lint_opt_deny_field_access("documented to do nothing")]
     no_stack_check: bool = (false, parse_no_value, [UNTRACKED],
-        "this option is deprecated and does nothing"),
+        "this option is deprecated and does nothing",
+        deprecated_do_nothing: true),
     no_vectorize_loops: bool = (false, parse_no_value, [TRACKED],
         "disable loop vectorization optimization passes"),
     no_vectorize_slp: bool = (false, parse_no_value, [TRACKED],
diff --git a/tests/ui/deprecation/deprecated_ar.rs b/tests/ui/deprecation/deprecated_ar.rs
new file mode 100644
index 00000000000..404d062e6a4
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_ar.rs
@@ -0,0 +1,4 @@
+//@ check-pass
+//@ compile-flags: -Car=foo
+
+fn main() {}
diff --git a/tests/ui/deprecation/deprecated_ar.stderr b/tests/ui/deprecation/deprecated_ar.stderr
new file mode 100644
index 00000000000..de776c67499
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_ar.stderr
@@ -0,0 +1,2 @@
+warning: `-C ar`: this option is deprecated and does nothing
+
diff --git a/tests/ui/deprecation/deprecated_inline_threshold.bad_val.stderr b/tests/ui/deprecation/deprecated_inline_threshold.bad_val.stderr
new file mode 100644
index 00000000000..2e7a99010ae
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_inline_threshold.bad_val.stderr
@@ -0,0 +1,4 @@
+warning: `-C inline-threshold`: this option is deprecated and does nothing (consider using `-Cllvm-args=--inline-threshold=...`)
+
+error: incorrect value `asd` for codegen option `inline-threshold` - a number was expected
+
diff --git a/tests/ui/deprecation/deprecated_inline_threshold.good_val.stderr b/tests/ui/deprecation/deprecated_inline_threshold.good_val.stderr
new file mode 100644
index 00000000000..2d6f3652d25
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_inline_threshold.good_val.stderr
@@ -0,0 +1,2 @@
+warning: `-C inline-threshold`: this option is deprecated and does nothing (consider using `-Cllvm-args=--inline-threshold=...`)
+
diff --git a/tests/ui/deprecation/deprecated_inline_threshold.no_val.stderr b/tests/ui/deprecation/deprecated_inline_threshold.no_val.stderr
new file mode 100644
index 00000000000..25104e637e0
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_inline_threshold.no_val.stderr
@@ -0,0 +1,4 @@
+warning: `-C inline-threshold`: this option is deprecated and does nothing (consider using `-Cllvm-args=--inline-threshold=...`)
+
+error: codegen option `inline-threshold` requires a number (C inline-threshold=<value>)
+
diff --git a/tests/ui/deprecation/deprecated_inline_threshold.rs b/tests/ui/deprecation/deprecated_inline_threshold.rs
index 56e033b8cf5..b54fa36397a 100644
--- a/tests/ui/deprecation/deprecated_inline_threshold.rs
+++ b/tests/ui/deprecation/deprecated_inline_threshold.rs
@@ -1,4 +1,8 @@
-//@ check-pass
-//@ compile-flags: -Cinline-threshold=666
+//@ revisions: good_val bad_val no_val
+//
+//@[good_val] compile-flags: -Cinline-threshold=666
+//@[good_val] check-pass
+//@[bad_val] compile-flags: -Cinline-threshold=asd
+//@[no_val] compile-flags: -Cinline-threshold
 
 fn main() {}
diff --git a/tests/ui/deprecation/deprecated_inline_threshold.stderr b/tests/ui/deprecation/deprecated_inline_threshold.stderr
deleted file mode 100644
index c4f8ff092b2..00000000000
--- a/tests/ui/deprecation/deprecated_inline_threshold.stderr
+++ /dev/null
@@ -1,2 +0,0 @@
-warning: the `-Cinline-threshold` flag is deprecated and does nothing (consider using `-Cllvm-args=--inline-threshold=...`)
-
diff --git a/tests/ui/deprecation/deprecated_no_stack_check_opt.rs b/tests/ui/deprecation/deprecated_no_stack_check_opt.rs
new file mode 100644
index 00000000000..62584ec23e3
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_no_stack_check_opt.rs
@@ -0,0 +1,4 @@
+//@ check-pass
+//@ compile-flags: -Cno-stack-check
+
+fn main() {}
diff --git a/tests/ui/deprecation/deprecated_no_stack_check_opt.stderr b/tests/ui/deprecation/deprecated_no_stack_check_opt.stderr
new file mode 100644
index 00000000000..17efba787f0
--- /dev/null
+++ b/tests/ui/deprecation/deprecated_no_stack_check_opt.stderr
@@ -0,0 +1,2 @@
+warning: `-C no-stack-check`: this option is deprecated and does nothing
+
-- 
cgit 1.4.1-3-g733a5


From 2be9ffc1afd0623ab0697cbaca5693b80c6d362c Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 10 Dec 2024 22:08:44 +0000
Subject: Add derived causes for host effect predicates

---
 compiler/rustc_middle/src/traits/mod.rs            | 89 +++++++++++++++++-----
 compiler/rustc_middle/src/ty/predicate.rs          | 22 ++++++
 .../src/solve/effect_goals.rs                      |  2 +-
 .../error_reporting/traits/fulfillment_errors.rs   | 11 +--
 .../src/error_reporting/traits/suggestions.rs      | 57 +++++++++++++-
 .../rustc_trait_selection/src/solve/fulfill.rs     | 73 +++++++++++++++++-
 .../rustc_trait_selection/src/traits/effects.rs    | 21 ++++-
 compiler/rustc_type_ir/src/binder.rs               |  1 +
 tests/ui/const-generics/issues/issue-88119.stderr  | 18 +++++
 ...ssoc-type-const-bound-usage-fail.current.stderr |  2 +-
 .../assoc-type-const-bound-usage-fail.next.stderr  |  6 +-
 .../assoc-type-const-bound-usage-fail.rs           |  6 +-
 .../ui/traits/const-traits/const-opaque.no.stderr  |  2 +-
 tests/ui/traits/const-traits/const-opaque.rs       |  2 +-
 .../item-bound-entailment-fails.stderr             |  5 ++
 15 files changed, 278 insertions(+), 39 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index 99211c1f924..db2bb8a7248 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -125,6 +125,15 @@ impl<'tcx> ObligationCause<'tcx> {
         self
     }
 
+    pub fn derived_host_cause(
+        mut self,
+        parent_host_pred: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+        variant: impl FnOnce(DerivedHostCause<'tcx>) -> ObligationCauseCode<'tcx>,
+    ) -> ObligationCause<'tcx> {
+        self.code = variant(DerivedHostCause { parent_host_pred, parent_code: self.code }).into();
+        self
+    }
+
     pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx> {
         match self.code() {
             ObligationCauseCode::MatchImpl(cause, _) => cause.to_constraint_category(),
@@ -278,6 +287,14 @@ pub enum ObligationCauseCode<'tcx> {
     /// Derived obligation for WF goals.
     WellFormedDerived(DerivedCause<'tcx>),
 
+    /// Derived obligation (i.e. `where` clause) on an user-provided impl
+    /// or a trait alias.
+    ImplDerivedHost(Box<ImplDerivedHostCause<'tcx>>),
+
+    /// Derived obligation (i.e. `where` clause) on an user-provided impl
+    /// or a trait alias.
+    BuiltinDerivedHost(DerivedHostCause<'tcx>),
+
     /// Derived obligation refined to point at a specific argument in
     /// a call or method expression.
     FunctionArg {
@@ -437,36 +454,38 @@ pub enum WellFormedLoc {
     },
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
-#[derive(TypeVisitable, TypeFoldable)]
-pub struct ImplDerivedCause<'tcx> {
-    pub derived: DerivedCause<'tcx>,
-    /// The `DefId` of the `impl` that gave rise to the `derived` obligation.
-    /// If the `derived` obligation arose from a trait alias, which conceptually has a synthetic impl,
-    /// then this will be the `DefId` of that trait alias. Care should therefore be taken to handle
-    /// that exceptional case where appropriate.
-    pub impl_or_alias_def_id: DefId,
-    /// The index of the derived predicate in the parent impl's predicates.
-    pub impl_def_predicate_index: Option<usize>,
-    pub span: Span,
-}
-
 impl<'tcx> ObligationCauseCode<'tcx> {
     /// Returns the base obligation, ignoring derived obligations.
     pub fn peel_derives(&self) -> &Self {
         let mut base_cause = self;
-        while let Some((parent_code, _)) = base_cause.parent() {
+        while let Some(parent_code) = base_cause.parent() {
             base_cause = parent_code;
         }
         base_cause
     }
 
+    pub fn parent(&self) -> Option<&Self> {
+        match self {
+            ObligationCauseCode::FunctionArg { parent_code, .. } => Some(parent_code),
+            ObligationCauseCode::BuiltinDerived(derived)
+            | ObligationCauseCode::WellFormedDerived(derived)
+            | ObligationCauseCode::ImplDerived(box ImplDerivedCause { derived, .. }) => {
+                Some(&derived.parent_code)
+            }
+            ObligationCauseCode::BuiltinDerivedHost(derived)
+            | ObligationCauseCode::ImplDerivedHost(box ImplDerivedHostCause { derived, .. }) => {
+                Some(&derived.parent_code)
+            }
+            _ => None,
+        }
+    }
+
     /// Returns the base obligation and the base trait predicate, if any, ignoring
     /// derived obligations.
     pub fn peel_derives_with_predicate(&self) -> (&Self, Option<ty::PolyTraitPredicate<'tcx>>) {
         let mut base_cause = self;
         let mut base_trait_pred = None;
-        while let Some((parent_code, parent_pred)) = base_cause.parent() {
+        while let Some((parent_code, parent_pred)) = base_cause.parent_with_predicate() {
             base_cause = parent_code;
             if let Some(parent_pred) = parent_pred {
                 base_trait_pred = Some(parent_pred);
@@ -476,7 +495,7 @@ impl<'tcx> ObligationCauseCode<'tcx> {
         (base_cause, base_trait_pred)
     }
 
-    pub fn parent(&self) -> Option<(&Self, Option<ty::PolyTraitPredicate<'tcx>>)> {
+    pub fn parent_with_predicate(&self) -> Option<(&Self, Option<ty::PolyTraitPredicate<'tcx>>)> {
         match self {
             ObligationCauseCode::FunctionArg { parent_code, .. } => Some((parent_code, None)),
             ObligationCauseCode::BuiltinDerived(derived)
@@ -573,6 +592,42 @@ pub struct DerivedCause<'tcx> {
     pub parent_code: InternedObligationCauseCode<'tcx>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
+#[derive(TypeVisitable, TypeFoldable)]
+pub struct ImplDerivedCause<'tcx> {
+    pub derived: DerivedCause<'tcx>,
+    /// The `DefId` of the `impl` that gave rise to the `derived` obligation.
+    /// If the `derived` obligation arose from a trait alias, which conceptually has a synthetic impl,
+    /// then this will be the `DefId` of that trait alias. Care should therefore be taken to handle
+    /// that exceptional case where appropriate.
+    pub impl_or_alias_def_id: DefId,
+    /// The index of the derived predicate in the parent impl's predicates.
+    pub impl_def_predicate_index: Option<usize>,
+    pub span: Span,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
+#[derive(TypeVisitable, TypeFoldable)]
+pub struct DerivedHostCause<'tcx> {
+    /// The trait predicate of the parent obligation that led to the
+    /// current obligation. Note that only trait obligations lead to
+    /// derived obligations, so we just store the trait predicate here
+    /// directly.
+    pub parent_host_pred: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+
+    /// The parent trait had this cause.
+    pub parent_code: InternedObligationCauseCode<'tcx>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
+#[derive(TypeVisitable, TypeFoldable)]
+pub struct ImplDerivedHostCause<'tcx> {
+    pub derived: DerivedHostCause<'tcx>,
+    /// The `DefId` of the `impl` that gave rise to the `derived` obligation.
+    pub impl_def_id: DefId,
+    pub span: Span,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, TypeVisitable)]
 pub enum SelectionError<'tcx> {
     /// The trait is not implemented.
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index 3ecaa3e22d3..32d6455e825 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -634,6 +634,28 @@ impl<'tcx> UpcastFrom<TyCtxt<'tcx>, PolyProjectionPredicate<'tcx>> for Clause<'t
     }
 }
 
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>>
+    for Predicate<'tcx>
+{
+    fn upcast_from(
+        from: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+        tcx: TyCtxt<'tcx>,
+    ) -> Self {
+        from.map_bound(ty::ClauseKind::HostEffect).upcast(tcx)
+    }
+}
+
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>>
+    for Clause<'tcx>
+{
+    fn upcast_from(
+        from: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+        tcx: TyCtxt<'tcx>,
+    ) -> Self {
+        from.map_bound(ty::ClauseKind::HostEffect).upcast(tcx)
+    }
+}
+
 impl<'tcx> UpcastFrom<TyCtxt<'tcx>, NormalizesTo<'tcx>> for Predicate<'tcx> {
     fn upcast_from(from: NormalizesTo<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
         PredicateKind::NormalizesTo(from).upcast(tcx)
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index ce7552e30f0..281796e84b1 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -353,7 +353,7 @@ where
 
         ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| {
             ecx.add_goals(
-                GoalSource::Misc,
+                GoalSource::ImplWhereBound,
                 const_conditions.into_iter().map(|trait_ref| {
                     goal.with(
                         cx,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index f9a30408326..1678aa8c657 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -753,7 +753,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     applied_do_not_recommend = true;
                 }
             }
-            if let Some((parent_cause, _parent_pred)) = base_cause.parent() {
+            if let Some(parent_cause) = base_cause.parent() {
                 base_cause = parent_cause.clone();
             } else {
                 break;
@@ -778,7 +778,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 trait_ref.skip_binder().args.type_at(1).to_opt_closure_kind()
             && !found_kind.extends(expected_kind)
         {
-            if let Some((_, Some(parent))) = obligation.cause.code().parent() {
+            if let Some((_, Some(parent))) = obligation.cause.code().parent_with_predicate() {
                 // If we have a derived obligation, then the parent will be a `AsyncFn*` goal.
                 trait_ref = parent.to_poly_trait_ref();
             } else if let &ObligationCauseCode::FunctionArg { arg_hir_id, .. } =
@@ -926,7 +926,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let Some(typeck) = &self.typeck_results else {
             return false;
         };
-        let Some((ObligationCauseCode::QuestionMark, Some(y))) = obligation.cause.code().parent()
+        let Some((ObligationCauseCode::QuestionMark, Some(y))) =
+            obligation.cause.code().parent_with_predicate()
         else {
             return false;
         };
@@ -1179,7 +1180,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         let mut code = obligation.cause.code();
         let mut pred = obligation.predicate.as_trait_clause();
-        while let Some((next_code, next_pred)) = code.parent() {
+        while let Some((next_code, next_pred)) = code.parent_with_predicate() {
             if let Some(pred) = pred {
                 self.enter_forall(pred, |pred| {
                     diag.note(format!(
@@ -2095,7 +2096,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let mut code = obligation.cause.code();
         let mut trait_pred = trait_predicate;
         let mut peeled = false;
-        while let Some((parent_code, parent_trait_pred)) = code.parent() {
+        while let Some((parent_code, parent_trait_pred)) = code.parent_with_predicate() {
             code = parent_code;
             if let Some(parent_trait_pred) = parent_trait_pred {
                 trait_pred = parent_trait_pred;
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 007a220ae69..9d85ca1dd4d 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -464,7 +464,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
             // Get the root obligation, since the leaf obligation we have may be unhelpful (#87437)
             let mut real_trait_pred = trait_pred;
-            while let Some((parent_code, parent_trait_pred)) = code.parent() {
+            while let Some((parent_code, parent_trait_pred)) = code.parent_with_predicate() {
                 code = parent_code;
                 if let Some(parent_trait_pred) = parent_trait_pred {
                     real_trait_pred = parent_trait_pred;
@@ -1447,7 +1447,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let mut span = obligation.cause.span;
         let mut trait_pred = trait_pred;
         let mut code = obligation.cause.code();
-        while let Some((c, Some(parent_trait_pred))) = code.parent() {
+        while let Some((c, Some(parent_trait_pred))) = code.parent_with_predicate() {
             // We want the root obligation, in order to detect properly handle
             // `for _ in &mut &mut vec![] {}`.
             code = c;
@@ -3470,6 +3470,59 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     )
                 });
             }
+            ObligationCauseCode::ImplDerivedHost(ref data) => {
+                let self_ty =
+                    self.resolve_vars_if_possible(data.derived.parent_host_pred.self_ty());
+                let msg = format!(
+                    "required for `{self_ty}` to implement `{} {}`",
+                    data.derived.parent_host_pred.skip_binder().constness,
+                    data.derived
+                        .parent_host_pred
+                        .map_bound(|pred| pred.trait_ref)
+                        .print_only_trait_path(),
+                );
+                match tcx.hir().get_if_local(data.impl_def_id) {
+                    Some(Node::Item(hir::Item {
+                        kind: hir::ItemKind::Impl(hir::Impl { of_trait, self_ty, .. }),
+                        ..
+                    })) => {
+                        let mut spans = vec![self_ty.span];
+                        spans.extend(of_trait.as_ref().map(|t| t.path.span));
+                        let mut spans: MultiSpan = spans.into();
+                        spans.push_span_label(data.span, "unsatisfied trait bound introduced here");
+                        err.span_note(spans, msg);
+                    }
+                    _ => {
+                        err.note(msg);
+                    }
+                }
+                ensure_sufficient_stack(|| {
+                    self.note_obligation_cause_code(
+                        body_id,
+                        err,
+                        data.derived.parent_host_pred,
+                        param_env,
+                        &data.derived.parent_code,
+                        obligated_types,
+                        seen_requirements,
+                        long_ty_file,
+                    )
+                });
+            }
+            ObligationCauseCode::BuiltinDerivedHost(ref data) => {
+                ensure_sufficient_stack(|| {
+                    self.note_obligation_cause_code(
+                        body_id,
+                        err,
+                        data.parent_host_pred,
+                        param_env,
+                        &data.parent_code,
+                        obligated_types,
+                        seen_requirements,
+                        long_ty_file,
+                    )
+                });
+            }
             ObligationCauseCode::WellFormedDerived(ref data) => {
                 let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
                 let parent_predicate = parent_trait_ref;
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 2b2623a050e..7aa82c52c9f 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -474,8 +474,11 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
         // for normalizes-to.
         let pred_kind = goal.goal().predicate.kind();
         let child_mode = match pred_kind.skip_binder() {
-            ty::PredicateKind::Clause(ty::ClauseKind::Trait(parent_trait_pred)) => {
-                ChildMode::Trait(pred_kind.rebind(parent_trait_pred))
+            ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => {
+                ChildMode::Trait(pred_kind.rebind(pred))
+            }
+            ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(pred)) => {
+                ChildMode::Host(pred_kind.rebind(pred))
             }
             ty::PredicateKind::NormalizesTo(normalizes_to)
                 if matches!(
@@ -492,6 +495,7 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
         };
 
         let mut impl_where_bound_count = 0;
+        let mut impl_const_condition_bound_count = 0;
         for nested_goal in candidate.instantiate_nested_goals(self.span()) {
             trace!(nested_goal = ?(nested_goal.goal(), nested_goal.source(), nested_goal.result()));
 
@@ -504,7 +508,7 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
 
             let obligation;
             match (child_mode, nested_goal.source()) {
-                (ChildMode::Trait(_), GoalSource::Misc) => {
+                (ChildMode::Trait(_) | ChildMode::Host(_), GoalSource::Misc) => {
                     continue;
                 }
                 (ChildMode::Trait(parent_trait_pred), GoalSource::ImplWhereBound) => {
@@ -517,6 +521,16 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
                     ));
                     impl_where_bound_count += 1;
                 }
+                (ChildMode::Host(parent_host_pred), GoalSource::ImplWhereBound) => {
+                    obligation = make_obligation(derive_host_cause(
+                        tcx,
+                        candidate.kind(),
+                        self.obligation.cause.clone(),
+                        impl_const_condition_bound_count,
+                        parent_host_pred,
+                    ));
+                    impl_const_condition_bound_count += 1;
+                }
                 // Skip over a higher-ranked predicate.
                 (_, GoalSource::InstantiateHigherRanked) => {
                     obligation = self.obligation.clone();
@@ -575,6 +589,10 @@ enum ChildMode<'tcx> {
     // and skip all `GoalSource::Misc`, which represent useless obligations
     // such as alias-eq which may not hold.
     Trait(ty::PolyTraitPredicate<'tcx>),
+    // Try to derive an `ObligationCause::{ImplDerived,BuiltinDerived}`,
+    // and skip all `GoalSource::Misc`, which represent useless obligations
+    // such as alias-eq which may not hold.
+    Host(ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>),
     // Skip trying to derive an `ObligationCause` from this obligation, and
     // report *all* sub-obligations as if they came directly from the parent
     // obligation.
@@ -616,3 +634,52 @@ fn derive_cause<'tcx>(
     };
     cause
 }
+
+fn derive_host_cause<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    candidate_kind: inspect::ProbeKind<TyCtxt<'tcx>>,
+    mut cause: ObligationCause<'tcx>,
+    idx: usize,
+    parent_host_pred: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
+) -> ObligationCause<'tcx> {
+    match candidate_kind {
+        inspect::ProbeKind::TraitCandidate {
+            source: CandidateSource::Impl(impl_def_id),
+            result: _,
+        } => {
+            if let Some((_, span)) = tcx
+                .predicates_of(impl_def_id)
+                .instantiate_identity(tcx)
+                .into_iter()
+                .chain(tcx.const_conditions(impl_def_id).instantiate_identity(tcx).into_iter().map(
+                    |(trait_ref, span)| {
+                        (
+                            trait_ref.to_host_effect_clause(
+                                tcx,
+                                parent_host_pred.skip_binder().constness,
+                            ),
+                            span,
+                        )
+                    },
+                ))
+                .nth(idx)
+            {
+                cause =
+                    cause.derived_host_cause(parent_host_pred, |derived| {
+                        ObligationCauseCode::ImplDerivedHost(Box::new(
+                            traits::ImplDerivedHostCause { derived, impl_def_id, span },
+                        ))
+                    })
+            }
+        }
+        inspect::ProbeKind::TraitCandidate {
+            source: CandidateSource::BuiltinImpl(..),
+            result: _,
+        } => {
+            cause =
+                cause.derived_host_cause(parent_host_pred, ObligationCauseCode::BuiltinDerivedHost);
+        }
+        _ => {}
+    };
+    cause
+}
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index 91484ef99db..0ac24eb54e7 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -1,6 +1,8 @@
 use rustc_hir as hir;
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes};
-use rustc_infer::traits::{ImplSource, Obligation, PredicateObligation};
+use rustc_infer::traits::{
+    ImplDerivedHostCause, ImplSource, Obligation, ObligationCauseCode, PredicateObligation,
+};
 use rustc_middle::span_bug;
 use rustc_middle::ty::fast_reject::DeepRejectCtxt;
 use rustc_middle::ty::{self, TypingMode};
@@ -248,9 +250,22 @@ fn evaluate_host_effect_from_selection_candiate<'tcx>(
                         tcx.const_conditions(impl_.impl_def_id)
                             .instantiate(tcx, impl_.args)
                             .into_iter()
-                            .map(|(trait_ref, _)| {
-                                obligation.with(
+                            .map(|(trait_ref, span)| {
+                                Obligation::new(
                                     tcx,
+                                    obligation.cause.clone().derived_host_cause(
+                                        ty::Binder::dummy(obligation.predicate),
+                                        |derived| {
+                                            ObligationCauseCode::ImplDerivedHost(Box::new(
+                                                ImplDerivedHostCause {
+                                                    derived,
+                                                    impl_def_id: impl_.impl_def_id,
+                                                    span,
+                                                },
+                                            ))
+                                        },
+                                    ),
+                                    obligation.param_env,
                                     trait_ref
                                         .to_host_effect_clause(tcx, obligation.predicate.constness),
                                 )
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index 47447af2215..cb59bc608c2 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -89,6 +89,7 @@ impl_binder_encode_decode! {
     ty::ExistentialPredicate<I>,
     ty::TraitRef<I>,
     ty::ExistentialTraitRef<I>,
+    ty::HostEffectPredicate<I>,
 }
 
 impl<I: Interner, T> Binder<I, T>
diff --git a/tests/ui/const-generics/issues/issue-88119.stderr b/tests/ui/const-generics/issues/issue-88119.stderr
index 370244fe8c9..f219c90849a 100644
--- a/tests/ui/const-generics/issues/issue-88119.stderr
+++ b/tests/ui/const-generics/issues/issue-88119.stderr
@@ -11,12 +11,30 @@ error[E0284]: type annotations needed: cannot normalize `<&T as ConstName>::{con
    |
 LL | impl<T: ?Sized + ConstName> const ConstName for &T
    |                                                 ^^ cannot normalize `<&T as ConstName>::{constant#0}`
+   |
+note: required for `&T` to implement `~const ConstName`
+  --> $DIR/issue-88119.rs:19:35
+   |
+LL | impl<T: ?Sized + ConstName> const ConstName for &T
+   |                                   ^^^^^^^^^     ^^
+LL | where
+LL |     [(); name_len::<T>()]:,
+   |     --------------------- unsatisfied trait bound introduced here
 
 error[E0284]: type annotations needed: cannot normalize `<&mut T as ConstName>::{constant#0}`
   --> $DIR/issue-88119.rs:26:49
    |
 LL | impl<T: ?Sized + ConstName> const ConstName for &mut T
    |                                                 ^^^^^^ cannot normalize `<&mut T as ConstName>::{constant#0}`
+   |
+note: required for `&mut T` to implement `~const ConstName`
+  --> $DIR/issue-88119.rs:26:35
+   |
+LL | impl<T: ?Sized + ConstName> const ConstName for &mut T
+   |                                   ^^^^^^^^^     ^^^^^^
+LL | where
+LL |     [(); name_len::<T>()]:,
+   |     --------------------- unsatisfied trait bound introduced here
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
index 9c29a894749..ccd4af99cf4 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
@@ -5,7 +5,7 @@ LL |     T::Assoc::func();
    |     ^^^^^^^^
 
 error[E0277]: the trait bound `T: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail.rs:19:5
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:20:5
    |
 LL |     <T as Trait>::Assoc::func();
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
index 9c29a894749..ee1b663b999 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `T: ~const Trait` is not satisfied
+error[E0277]: the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
   --> $DIR/assoc-type-const-bound-usage-fail.rs:17:5
    |
 LL |     T::Assoc::func();
    |     ^^^^^^^^
 
-error[E0277]: the trait bound `T: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail.rs:19:5
+error[E0277]: the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:20:5
    |
 LL |     <T as Trait>::Assoc::func();
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
index 3761fea1968..224ebb2daf1 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
@@ -15,9 +15,11 @@ trait Trait {
 
 const fn unqualified<T: Trait>() {
     T::Assoc::func();
-    //~^ ERROR the trait bound `T: ~const Trait` is not satisfied
+    //[current]~^ ERROR the trait bound `T: ~const Trait` is not satisfied
+    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
     <T as Trait>::Assoc::func();
-    //~^ ERROR the trait bound `T: ~const Trait` is not satisfied
+    //[current]~^ ERROR the trait bound `T: ~const Trait` is not satisfied
+    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
 }
 
 const fn works<T: ~const Trait>() {
diff --git a/tests/ui/traits/const-traits/const-opaque.no.stderr b/tests/ui/traits/const-traits/const-opaque.no.stderr
index 1278e125746..33aa1065df3 100644
--- a/tests/ui/traits/const-traits/const-opaque.no.stderr
+++ b/tests/ui/traits/const-traits/const-opaque.no.stderr
@@ -12,7 +12,7 @@ note: required by a bound in `bar`
 LL | const fn bar<T: ~const Foo>(t: T) -> impl ~const Foo {
    |                 ^^^^^^ required by this bound in `bar`
 
-error[E0277]: the trait bound `(): const Foo` is not satisfied
+error[E0277]: the trait bound `impl Foo: const Foo` is not satisfied
   --> $DIR/const-opaque.rs:33:12
    |
 LL |     opaque.method();
diff --git a/tests/ui/traits/const-traits/const-opaque.rs b/tests/ui/traits/const-traits/const-opaque.rs
index 96cdd7d9f26..bfcadd521a5 100644
--- a/tests/ui/traits/const-traits/const-opaque.rs
+++ b/tests/ui/traits/const-traits/const-opaque.rs
@@ -31,7 +31,7 @@ const _: () = {
     let opaque = bar(());
     //[no]~^ ERROR the trait bound `(): const Foo` is not satisfied
     opaque.method();
-    //[no]~^ ERROR the trait bound `(): const Foo` is not satisfied
+    //[no]~^ ERROR the trait bound `impl Foo: const Foo` is not satisfied
     std::mem::forget(opaque);
 };
 
diff --git a/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr b/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr
index 3fc6f584709..0d53bc5897e 100644
--- a/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr
+++ b/tests/ui/traits/const-traits/item-bound-entailment-fails.stderr
@@ -16,6 +16,11 @@ error[E0277]: the trait bound `T: ~const Bar` is not satisfied
 LL |     type Assoc<T> = C<T>
    |                     ^^^^
    |
+note: required for `C<T>` to implement `~const Bar`
+  --> $DIR/item-bound-entailment-fails.rs:14:15
+   |
+LL | impl<T> const Bar for C<T> where T: ~const Bar {}
+   |               ^^^     ^^^^          ------ unsatisfied trait bound introduced here
 note: required by a bound in `Foo::Assoc`
   --> $DIR/item-bound-entailment-fails.rs:5:20
    |
-- 
cgit 1.4.1-3-g733a5


From 96285bde3858b608258bdc48bb933c626bfd6a21 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 25 Dec 2024 02:22:08 +0000
Subject: Don't ice on bad transmute in typeck in new solver

---
 compiler/rustc_hir_typeck/src/intrinsicck.rs       | 14 +++-
 .../dont-ice-on-bad-transmute-in-typeck.rs         | 17 +++++
 .../dont-ice-on-bad-transmute-in-typeck.stderr     | 75 ++++++++++++++++++++++
 3 files changed, 105 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.rs
 create mode 100644 tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.stderr

(limited to 'tests')

diff --git a/compiler/rustc_hir_typeck/src/intrinsicck.rs b/compiler/rustc_hir_typeck/src/intrinsicck.rs
index 789530d35dd..f4929aae599 100644
--- a/compiler/rustc_hir_typeck/src/intrinsicck.rs
+++ b/compiler/rustc_hir_typeck/src/intrinsicck.rs
@@ -40,13 +40,25 @@ fn unpack_option_like<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
 }
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
+    /// FIXME: Move this check out of typeck, since it'll easily cycle when revealing opaques,
+    /// and we shouldn't need to check anything here if the typeck results are tainted.
     pub(crate) fn check_transmute(&self, from: Ty<'tcx>, to: Ty<'tcx>, hir_id: HirId) {
         let tcx = self.tcx;
         let dl = &tcx.data_layout;
         let span = tcx.hir().span(hir_id);
         let normalize = |ty| {
             let ty = self.resolve_vars_if_possible(ty);
-            self.tcx.normalize_erasing_regions(self.typing_env(self.param_env), ty)
+            if let Ok(ty) =
+                self.tcx.try_normalize_erasing_regions(self.typing_env(self.param_env), ty)
+            {
+                ty
+            } else {
+                Ty::new_error_with_message(
+                    tcx,
+                    span,
+                    "tried to normalize non-wf type in check_transmute",
+                )
+            }
         };
         let from = normalize(from);
         let to = normalize(to);
diff --git a/tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.rs b/tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.rs
new file mode 100644
index 00000000000..129e90a07f4
--- /dev/null
+++ b/tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Znext-solver
+
+trait Trait<'a> {
+    type Assoc;
+}
+
+fn foo(x: for<'a> fn(<() as Trait<'a>>::Assoc)) {
+    //~^ ERROR the trait bound `for<'a> (): Trait<'a>` is not satisfied
+    //~| ERROR the trait bound `for<'a> (): Trait<'a>` is not satisfied
+    //~| ERROR the trait bound `for<'a> (): Trait<'a>` is not satisfied
+    unsafe { std::mem::transmute::<_, ()>(x); }
+    //~^ ERROR the trait bound `for<'a> (): Trait<'a>` is not satisfied
+    //~| ERROR the trait bound `for<'a> (): Trait<'a>` is not satisfied
+    //~| ERROR the trait bound `for<'a> (): Trait<'a>` is not satisfied
+}
+
+fn main() {}
diff --git a/tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.stderr b/tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.stderr
new file mode 100644
index 00000000000..2d42fedae43
--- /dev/null
+++ b/tests/ui/traits/next-solver/dont-ice-on-bad-transmute-in-typeck.stderr
@@ -0,0 +1,75 @@
+error[E0277]: the trait bound `for<'a> (): Trait<'a>` is not satisfied
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:7:11
+   |
+LL | fn foo(x: for<'a> fn(<() as Trait<'a>>::Assoc)) {
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> Trait<'a>` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:3:1
+   |
+LL | trait Trait<'a> {
+   | ^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `for<'a> (): Trait<'a>` is not satisfied
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:7:8
+   |
+LL | fn foo(x: for<'a> fn(<() as Trait<'a>>::Assoc)) {
+   |        ^ the trait `for<'a> Trait<'a>` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:3:1
+   |
+LL | trait Trait<'a> {
+   | ^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `for<'a> (): Trait<'a>` is not satisfied
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:11:14
+   |
+LL |     unsafe { std::mem::transmute::<_, ()>(x); }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> Trait<'a>` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:3:1
+   |
+LL | trait Trait<'a> {
+   | ^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `for<'a> (): Trait<'a>` is not satisfied
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:11:36
+   |
+LL |     unsafe { std::mem::transmute::<_, ()>(x); }
+   |                                    ^ the trait `for<'a> Trait<'a>` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:3:1
+   |
+LL | trait Trait<'a> {
+   | ^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `for<'a> (): Trait<'a>` is not satisfied
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:11:43
+   |
+LL |     unsafe { std::mem::transmute::<_, ()>(x); }
+   |                                           ^ the trait `for<'a> Trait<'a>` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:3:1
+   |
+LL | trait Trait<'a> {
+   | ^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `for<'a> (): Trait<'a>` is not satisfied
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:7:1
+   |
+LL | fn foo(x: for<'a> fn(<() as Trait<'a>>::Assoc)) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> Trait<'a>` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dont-ice-on-bad-transmute-in-typeck.rs:3:1
+   |
+LL | trait Trait<'a> {
+   | ^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From ebdf19a8bbd1efb533bab35b0a2b327e4a33282f Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 23 Dec 2024 20:17:53 +0000
Subject: Recurse on GAT where clauses in fulfillment error proof tree visitor

---
 compiler/rustc_next_trait_solver/src/solve/effect_goals.rs |  4 ++--
 compiler/rustc_trait_selection/src/solve/fulfill.rs        | 14 +++++++++-----
 compiler/rustc_type_ir/src/solve/mod.rs                    |  4 ++++
 .../assoc-type-const-bound-usage-fail-2.current.stderr     |  2 +-
 .../assoc-type-const-bound-usage-fail-2.next.stderr        |  6 +++---
 .../const-traits/assoc-type-const-bound-usage-fail-2.rs    |  6 ++----
 .../assoc-type-const-bound-usage-fail.current.stderr       |  2 +-
 .../assoc-type-const-bound-usage-fail.next.stderr          |  6 +++---
 .../const-traits/assoc-type-const-bound-usage-fail.rs      |  6 ++----
 tests/ui/traits/const-traits/const-opaque.no.stderr        |  2 +-
 tests/ui/traits/const-traits/const-opaque.rs               |  2 +-
 11 files changed, 29 insertions(+), 25 deletions(-)

(limited to 'tests')

diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index 281796e84b1..7669a305d58 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -103,7 +103,7 @@ where
                 |ecx| {
                     // Const conditions must hold for the implied const bound to hold.
                     ecx.add_goals(
-                        GoalSource::Misc,
+                        GoalSource::AliasBoundConstCondition,
                         cx.const_conditions(alias_ty.def_id)
                             .iter_instantiated(cx, alias_ty.args)
                             .map(|trait_ref| {
@@ -353,7 +353,7 @@ where
 
         ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| {
             ecx.add_goals(
-                GoalSource::ImplWhereBound,
+                GoalSource::AliasBoundConstCondition,
                 const_conditions.into_iter().map(|trait_ref| {
                     goal.with(
                         cx,
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 7aa82c52c9f..986176aca77 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -413,6 +413,7 @@ impl<'tcx> BestObligation<'tcx> {
                                     matches!(
                                         nested_goal.source(),
                                         GoalSource::ImplWhereBound
+                                            | GoalSource::AliasBoundConstCondition
                                             | GoalSource::InstantiateHigherRanked
                                             | GoalSource::AliasWellFormed
                                     ) && match self.consider_ambiguities {
@@ -495,7 +496,6 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
         };
 
         let mut impl_where_bound_count = 0;
-        let mut impl_const_condition_bound_count = 0;
         for nested_goal in candidate.instantiate_nested_goals(self.span()) {
             trace!(nested_goal = ?(nested_goal.goal(), nested_goal.source(), nested_goal.result()));
 
@@ -521,21 +521,25 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
                     ));
                     impl_where_bound_count += 1;
                 }
-                (ChildMode::Host(parent_host_pred), GoalSource::ImplWhereBound) => {
+                (
+                    ChildMode::Host(parent_host_pred),
+                    GoalSource::ImplWhereBound | GoalSource::AliasBoundConstCondition,
+                ) => {
                     obligation = make_obligation(derive_host_cause(
                         tcx,
                         candidate.kind(),
                         self.obligation.cause.clone(),
-                        impl_const_condition_bound_count,
+                        impl_where_bound_count,
                         parent_host_pred,
                     ));
-                    impl_const_condition_bound_count += 1;
+                    impl_where_bound_count += 1;
                 }
                 // Skip over a higher-ranked predicate.
                 (_, GoalSource::InstantiateHigherRanked) => {
                     obligation = self.obligation.clone();
                 }
-                (ChildMode::PassThrough, _) | (_, GoalSource::AliasWellFormed) => {
+                (ChildMode::PassThrough, _)
+                | (_, GoalSource::AliasWellFormed | GoalSource::AliasBoundConstCondition) => {
                     obligation = make_obligation(self.obligation.cause.clone());
                 }
             }
diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs
index 8fe512026e5..1ae904d50e0 100644
--- a/compiler/rustc_type_ir/src/solve/mod.rs
+++ b/compiler/rustc_type_ir/src/solve/mod.rs
@@ -68,6 +68,10 @@ pub enum GoalSource {
     /// FIXME(-Znext-solver=coinductive): Explain how and why this
     /// changes whether cycles are coinductive.
     ImplWhereBound,
+    /// Const conditions that need to hold for `~const` alias bounds to hold.
+    ///
+    /// FIXME(-Znext-solver=coinductive): Are these even coinductive?
+    AliasBoundConstCondition,
     /// Instantiating a higher-ranked goal and re-proving it.
     InstantiateHigherRanked,
     /// Predicate required for an alias projection to be well-formed.
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr
index 03da9159bea..4cd87002e49 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.current.stderr
@@ -5,7 +5,7 @@ LL |     T::Assoc::<U>::func();
    |     ^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `U: ~const Other` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:27:5
+  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:26:5
    |
 LL |     <T as Trait>::Assoc::<U>::func();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr
index ce58b486a16..4cd87002e49 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.next.stderr
@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+error[E0277]: the trait bound `U: ~const Other` is not satisfied
   --> $DIR/assoc-type-const-bound-usage-fail-2.rs:24:5
    |
 LL |     T::Assoc::<U>::func();
    |     ^^^^^^^^^^^^^
 
-error[E0277]: the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:27:5
+error[E0277]: the trait bound `U: ~const Other` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail-2.rs:26:5
    |
 LL |     <T as Trait>::Assoc::<U>::func();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs
index bdd98eaf541..e1c30b53611 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail-2.rs
@@ -22,11 +22,9 @@ trait Other {}
 
 const fn fails<T: ~const Trait, U: Other>() {
     T::Assoc::<U>::func();
-    //[current]~^ ERROR the trait bound `U: ~const Other` is not satisfied
-    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+    //~^ ERROR the trait bound `U: ~const Other` is not satisfied
     <T as Trait>::Assoc::<U>::func();
-    //[current]~^ ERROR the trait bound `U: ~const Other` is not satisfied
-    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc<U>: ~const Trait` is not satisfied
+    //~^ ERROR the trait bound `U: ~const Other` is not satisfied
 }
 
 const fn works<T: ~const Trait, U: ~const Other>() {
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
index ccd4af99cf4..9c29a894749 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.current.stderr
@@ -5,7 +5,7 @@ LL |     T::Assoc::func();
    |     ^^^^^^^^
 
 error[E0277]: the trait bound `T: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail.rs:20:5
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:19:5
    |
 LL |     <T as Trait>::Assoc::func();
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
index ee1b663b999..9c29a894749 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.next.stderr
@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
+error[E0277]: the trait bound `T: ~const Trait` is not satisfied
   --> $DIR/assoc-type-const-bound-usage-fail.rs:17:5
    |
 LL |     T::Assoc::func();
    |     ^^^^^^^^
 
-error[E0277]: the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
-  --> $DIR/assoc-type-const-bound-usage-fail.rs:20:5
+error[E0277]: the trait bound `T: ~const Trait` is not satisfied
+  --> $DIR/assoc-type-const-bound-usage-fail.rs:19:5
    |
 LL |     <T as Trait>::Assoc::func();
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
index 224ebb2daf1..3761fea1968 100644
--- a/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
+++ b/tests/ui/traits/const-traits/assoc-type-const-bound-usage-fail.rs
@@ -15,11 +15,9 @@ trait Trait {
 
 const fn unqualified<T: Trait>() {
     T::Assoc::func();
-    //[current]~^ ERROR the trait bound `T: ~const Trait` is not satisfied
-    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
+    //~^ ERROR the trait bound `T: ~const Trait` is not satisfied
     <T as Trait>::Assoc::func();
-    //[current]~^ ERROR the trait bound `T: ~const Trait` is not satisfied
-    //[next]~^^ ERROR the trait bound `<T as Trait>::Assoc: ~const Trait` is not satisfied
+    //~^ ERROR the trait bound `T: ~const Trait` is not satisfied
 }
 
 const fn works<T: ~const Trait>() {
diff --git a/tests/ui/traits/const-traits/const-opaque.no.stderr b/tests/ui/traits/const-traits/const-opaque.no.stderr
index 33aa1065df3..1278e125746 100644
--- a/tests/ui/traits/const-traits/const-opaque.no.stderr
+++ b/tests/ui/traits/const-traits/const-opaque.no.stderr
@@ -12,7 +12,7 @@ note: required by a bound in `bar`
 LL | const fn bar<T: ~const Foo>(t: T) -> impl ~const Foo {
    |                 ^^^^^^ required by this bound in `bar`
 
-error[E0277]: the trait bound `impl Foo: const Foo` is not satisfied
+error[E0277]: the trait bound `(): const Foo` is not satisfied
   --> $DIR/const-opaque.rs:33:12
    |
 LL |     opaque.method();
diff --git a/tests/ui/traits/const-traits/const-opaque.rs b/tests/ui/traits/const-traits/const-opaque.rs
index bfcadd521a5..96cdd7d9f26 100644
--- a/tests/ui/traits/const-traits/const-opaque.rs
+++ b/tests/ui/traits/const-traits/const-opaque.rs
@@ -31,7 +31,7 @@ const _: () = {
     let opaque = bar(());
     //[no]~^ ERROR the trait bound `(): const Foo` is not satisfied
     opaque.method();
-    //[no]~^ ERROR the trait bound `impl Foo: const Foo` is not satisfied
+    //[no]~^ ERROR the trait bound `(): const Foo` is not satisfied
     std::mem::forget(opaque);
 };
 
-- 
cgit 1.4.1-3-g733a5


From 304ccf45d15153b29c413a84334a9b4aaee23d53 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 4 Jan 2025 00:13:49 +0000
Subject: Suggest to replace tuple constructor through projection

---
 compiler/rustc_hir_typeck/src/method/suggest.rs | 26 ++++++++++++++++++++++++-
 tests/ui/associated-types/invalid-ctor.fixed    | 22 +++++++++++++++++++++
 tests/ui/associated-types/invalid-ctor.rs       | 22 +++++++++++++++++++++
 tests/ui/associated-types/invalid-ctor.stderr   | 14 +++++++++++++
 4 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/associated-types/invalid-ctor.fixed
 create mode 100644 tests/ui/associated-types/invalid-ctor.rs
 create mode 100644 tests/ui/associated-types/invalid-ctor.stderr

(limited to 'tests')

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 0b008fd10b5..b4f1dcfb9cc 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -14,7 +14,7 @@ use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::unord::UnordSet;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, MultiSpan, StashKey, pluralize, struct_span_code_err};
-use rustc_hir::def::DefKind;
+use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::lang_items::LangItem;
@@ -690,6 +690,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 );
             }
 
+            // Check if we wrote `Self::Assoc(1)` as if it were a tuple ctor.
+            if let SelfSource::QPath(ty) = source
+                && let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
+                && let Res::SelfTyAlias { alias_to: impl_def_id, .. } = path.res
+                && let DefKind::Impl { .. } = self.tcx.def_kind(impl_def_id)
+                && let Some(candidate) = tcx.associated_items(impl_def_id).find_by_name_and_kind(
+                    self.tcx,
+                    item_name,
+                    ty::AssocKind::Type,
+                    impl_def_id,
+                )
+                && let Some(adt_def) = tcx.type_of(candidate.def_id).skip_binder().ty_adt_def()
+                && adt_def.is_struct()
+                && adt_def.non_enum_variant().ctor_kind() == Some(CtorKind::Fn)
+            {
+                let def_path = tcx.def_path_str(adt_def.did());
+                err.span_suggestion(
+                    ty.span.to(item_name.span),
+                    format!("to construct a value of type `{}`, use the explicit path", def_path),
+                    def_path,
+                    Applicability::MachineApplicable,
+                );
+            }
+
             err
         };
         if tcx.sess.source_map().is_multiline(sugg_span) {
diff --git a/tests/ui/associated-types/invalid-ctor.fixed b/tests/ui/associated-types/invalid-ctor.fixed
new file mode 100644
index 00000000000..eba3820de0c
--- /dev/null
+++ b/tests/ui/associated-types/invalid-ctor.fixed
@@ -0,0 +1,22 @@
+//@ run-rustfix
+
+#![allow(unused)]
+
+struct Constructor(i32);
+
+trait Trait {
+    type Out;
+
+    fn mk() -> Self::Out;
+}
+
+impl Trait for () {
+    type Out = Constructor;
+
+    fn mk() -> Self::Out {
+        Constructor(1)
+        //~^ ERROR no associated item named `Out` found for unit type `()`
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/associated-types/invalid-ctor.rs b/tests/ui/associated-types/invalid-ctor.rs
new file mode 100644
index 00000000000..73335c065c2
--- /dev/null
+++ b/tests/ui/associated-types/invalid-ctor.rs
@@ -0,0 +1,22 @@
+//@ run-rustfix
+
+#![allow(unused)]
+
+struct Constructor(i32);
+
+trait Trait {
+    type Out;
+
+    fn mk() -> Self::Out;
+}
+
+impl Trait for () {
+    type Out = Constructor;
+
+    fn mk() -> Self::Out {
+        Self::Out(1)
+        //~^ ERROR no associated item named `Out` found for unit type `()`
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/associated-types/invalid-ctor.stderr b/tests/ui/associated-types/invalid-ctor.stderr
new file mode 100644
index 00000000000..b545c95a768
--- /dev/null
+++ b/tests/ui/associated-types/invalid-ctor.stderr
@@ -0,0 +1,14 @@
+error[E0599]: no associated item named `Out` found for unit type `()` in the current scope
+  --> $DIR/invalid-ctor.rs:17:15
+   |
+LL |         Self::Out(1)
+   |               ^^^ associated item not found in `()`
+   |
+help: to construct a value of type `Constructor`, use the explicit path
+   |
+LL |         Constructor(1)
+   |         ~~~~~~~~~~~
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.
-- 
cgit 1.4.1-3-g733a5


From b0aaa386d8f0af9dd4d08f3009498addbe0157fa Mon Sep 17 00:00:00 2001
From: Noah Lev <camelidcamel@gmail.com>
Date: Sat, 4 Jan 2025 19:51:56 -0800
Subject: rustdoc: Fix mismatched capitalization in sidebar

Previously, the main content used "Aliased Type", while the sidebar said
"Aliased type". Now, they both say "Aliased Type", which is the more common
capitalization in Rustdoc.

See the following link for an example.
https://doc.rust-lang.org/1.83.0/std/io/type.Result.html
---
 src/librustdoc/html/render/sidebar.rs   | 2 +-
 tests/rustdoc/type-alias/deref-32077.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/src/librustdoc/html/render/sidebar.rs b/src/librustdoc/html/render/sidebar.rs
index af39d15f671..881df8b0050 100644
--- a/src/librustdoc/html/render/sidebar.rs
+++ b/src/librustdoc/html/render/sidebar.rs
@@ -357,7 +357,7 @@ fn sidebar_type_alias<'a>(
     deref_id_map: &'a DefIdMap<String>,
 ) {
     if let Some(inner_type) = &t.inner_type {
-        items.push(LinkBlock::forced(Link::new("aliased-type", "Aliased type"), "type"));
+        items.push(LinkBlock::forced(Link::new("aliased-type", "Aliased Type"), "type"));
         match inner_type {
             clean::TypeAliasInnerType::Enum { variants, is_non_exhaustive: _ } => {
                 let mut variants = variants
diff --git a/tests/rustdoc/type-alias/deref-32077.rs b/tests/rustdoc/type-alias/deref-32077.rs
index 79a83381340..faab4b6f522 100644
--- a/tests/rustdoc/type-alias/deref-32077.rs
+++ b/tests/rustdoc/type-alias/deref-32077.rs
@@ -19,8 +19,8 @@ impl<T> Foo for GenericStruct<T> {}
 impl Bar for GenericStruct<u32> {}
 
 //@ has 'foo/type.TypedefStruct.html'
-// We check that "Aliased type" is also present as a title in the sidebar.
-//@ has - '//*[@class="sidebar-elems"]//h3/a[@href="#aliased-type"]' 'Aliased type'
+// We check that "Aliased Type" is also present as a title in the sidebar.
+//@ has - '//*[@class="sidebar-elems"]//h3/a[@href="#aliased-type"]' 'Aliased Type'
 // We check that we have the implementation of the type alias itself.
 //@ has - '//*[@id="impl-GenericStruct%3Cu8%3E"]/h3' 'impl TypedefStruct'
 //@ has - '//*[@id="method.on_alias"]/h4' 'pub fn on_alias()'
-- 
cgit 1.4.1-3-g733a5