From 736ab66c62ad23b880299e1f997ff1e4d7a9ceef Mon Sep 17 00:00:00 2001
From: Wafarm <qinyy07@gmail.com>
Date: Mon, 19 Aug 2024 11:37:11 +0800
Subject: [PATCH 01/20] Don't suggest adding return type for closures with
 default return type

---
 compiler/rustc_hir_typeck/src/_match.rs       |  2 +-
 compiler/rustc_hir_typeck/src/coercion.rs     |  4 +-
 compiler/rustc_hir_typeck/src/expr.rs         |  2 +-
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     | 39 +++++----------
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  2 +-
 .../src/fn_ctxt/suggestions.rs                | 49 ++++++++++++++-----
 .../add_semicolon_non_block_closure.rs        |  1 -
 .../add_semicolon_non_block_closure.stderr    |  4 --
 .../try-operator-dont-suggest-semicolon.rs    |  1 -
 ...try-operator-dont-suggest-semicolon.stderr | 17 ++-----
 tests/ui/typeck/issue-81943.stderr            | 26 +++++-----
 11 files changed, 74 insertions(+), 73 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
index 7427fb147166f..573c8d4d7119a 100644
--- a/compiler/rustc_hir_typeck/src/_match.rs
+++ b/compiler/rustc_hir_typeck/src/_match.rs
@@ -388,7 +388,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 // check that the `if` expr without `else` is the fn body's expr
                 if expr.span == sp {
-                    return self.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
+                    return self.get_fn_decl(hir_id).map(|(_, fn_decl)| {
                         let (ty, span) = match fn_decl.output {
                             hir::FnRetTy::DefaultReturn(span) => ("()".to_string(), span),
                             hir::FnRetTy::Return(ty) => (ty_to_string(&self.tcx, ty), ty.span),
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index dabc5a8939783..8e5d8cba5bef0 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -1859,10 +1859,10 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
         };
 
         // If this is due to an explicit `return`, suggest adding a return type.
-        if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(block_or_return_id)
+        if let Some((fn_id, fn_decl)) = fcx.get_fn_decl(block_or_return_id)
             && !due_to_block
         {
-            fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id);
+            fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, fn_id);
         }
 
         // If this is due to a block, then maybe we forgot a `return`/`break`.
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index dd33b947b0d06..d70c3f6a0d843 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -773,7 +773,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.ret_coercion_span.set(Some(expr.span));
             }
             let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
-            if let Some((_, fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
+            if let Some((_, fn_decl)) = self.get_fn_decl(expr.hir_id) {
                 coercion.coerce_forced_unit(
                     self,
                     &cause,
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 2d205d1ede9cd..1c4a6fc22f797 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -31,7 +31,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::DesugaringKind;
-use rustc_span::symbol::{kw, sym};
+use rustc_span::symbol::kw;
 use rustc_span::Span;
 use rustc_target::abi::FieldIdx;
 use rustc_trait_selection::error_reporting::infer::need_type_info::TypeAnnotationNeeded;
@@ -895,38 +895,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         )
     }
 
-    /// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
-    /// suggestion can be made, `None` otherwise.
+    /// Given a `HirId`, return the `HirId` of the enclosing function and its `FnDecl`.
     pub(crate) fn get_fn_decl(
         &self,
         blk_id: HirId,
-    ) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
+    ) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>)> {
         // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
         // `while` before reaching it, as block tail returns are not available in them.
         self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|item_id| {
             match self.tcx.hir_node(item_id) {
                 Node::Item(&hir::Item {
-                    ident,
-                    kind: hir::ItemKind::Fn(ref sig, ..),
-                    owner_id,
-                    ..
-                }) => {
-                    // This is less than ideal, it will not suggest a return type span on any
-                    // method called `main`, regardless of whether it is actually the entry point,
-                    // but it will still present it as the reason for the expected type.
-                    Some((owner_id.def_id, sig.decl, ident.name != sym::main))
-                }
+                    kind: hir::ItemKind::Fn(ref sig, ..), owner_id, ..
+                }) => Some((owner_id.def_id, sig.decl)),
                 Node::TraitItem(&hir::TraitItem {
                     kind: hir::TraitItemKind::Fn(ref sig, ..),
                     owner_id,
                     ..
-                }) => Some((owner_id.def_id, sig.decl, true)),
-                // FIXME: Suggestable if this is not a trait implementation
+                }) => Some((owner_id.def_id, sig.decl)),
                 Node::ImplItem(&hir::ImplItem {
                     kind: hir::ImplItemKind::Fn(ref sig, ..),
                     owner_id,
                     ..
-                }) => Some((owner_id.def_id, sig.decl, false)),
+                }) => Some((owner_id.def_id, sig.decl)),
                 Node::Expr(&hir::Expr {
                     hir_id,
                     kind: hir::ExprKind::Closure(&hir::Closure { def_id, kind, fn_decl, .. }),
@@ -937,33 +927,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             // FIXME(async_closures): Implement this.
                             return None;
                         }
-                        hir::ClosureKind::Closure => Some((def_id, fn_decl, true)),
+                        hir::ClosureKind::Closure => Some((def_id, fn_decl)),
                         hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
                             _,
                             hir::CoroutineSource::Fn,
                         )) => {
-                            let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
+                            let (sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
                                 Node::Item(&hir::Item {
-                                    ident,
                                     kind: hir::ItemKind::Fn(ref sig, ..),
                                     owner_id,
                                     ..
-                                }) => (ident, sig, owner_id),
+                                }) => (sig, owner_id),
                                 Node::TraitItem(&hir::TraitItem {
-                                    ident,
                                     kind: hir::TraitItemKind::Fn(ref sig, ..),
                                     owner_id,
                                     ..
-                                }) => (ident, sig, owner_id),
+                                }) => (sig, owner_id),
                                 Node::ImplItem(&hir::ImplItem {
-                                    ident,
                                     kind: hir::ImplItemKind::Fn(ref sig, ..),
                                     owner_id,
                                     ..
-                                }) => (ident, sig, owner_id),
+                                }) => (sig, owner_id),
                                 _ => return None,
                             };
-                            Some((owner_id.def_id, sig.decl, ident.name != sym::main))
+                            Some((owner_id.def_id, sig.decl))
                         }
                         _ => None,
                     }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 5333982c42029..2a1c3b0300482 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1841,7 +1841,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // that highlight errors inline.
                     let mut sp = blk.span;
                     let mut fn_span = None;
-                    if let Some((fn_def_id, decl, _)) = self.get_fn_decl(blk.hir_id) {
+                    if let Some((fn_def_id, decl)) = self.get_fn_decl(blk.hir_id) {
                         let ret_sp = decl.output.span();
                         if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
                             // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 031aa6159d2bc..8b63a6df8af00 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -78,9 +78,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // `break` type mismatches provide better context for tail `loop` expressions.
             return false;
         }
-        if let Some((fn_id, fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
+        if let Some((fn_id, fn_decl)) = self.get_fn_decl(blk_id) {
             pointing_at_return_type =
-                self.suggest_missing_return_type(err, fn_decl, expected, found, can_suggest, fn_id);
+                self.suggest_missing_return_type(err, fn_decl, expected, found, fn_id);
             self.suggest_missing_break_or_return_expr(
                 err, expr, fn_decl, expected, found, blk_id, fn_id,
             );
@@ -812,7 +812,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         fn_decl: &hir::FnDecl<'tcx>,
         expected: Ty<'tcx>,
         found: Ty<'tcx>,
-        can_suggest: bool,
         fn_id: LocalDefId,
     ) -> bool {
         // Can't suggest `->` on a block-like coroutine
@@ -825,28 +824,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let found =
             self.resolve_numeric_literals_with_default(self.resolve_vars_if_possible(found));
         // Only suggest changing the return type for methods that
-        // haven't set a return type at all (and aren't `fn main()` or an impl).
+        // haven't set a return type at all (and aren't `fn main()`, impl or closure).
         match &fn_decl.output {
-            &hir::FnRetTy::DefaultReturn(span) if expected.is_unit() && !can_suggest => {
-                // `fn main()` must return `()`, do not suggest changing return type
-                err.subdiagnostic(errors::ExpectedReturnTypeLabel::Unit { span });
-                return true;
-            }
+            // For closure with default returns, don't suggest adding return type
+            &hir::FnRetTy::DefaultReturn(_) if self.tcx.is_closure_like(fn_id.to_def_id()) => {}
             &hir::FnRetTy::DefaultReturn(span) if expected.is_unit() => {
-                if let Some(found) = found.make_suggestable(self.tcx, false, None) {
+                if !self.can_add_return_type(fn_id) {
+                    err.subdiagnostic(errors::ExpectedReturnTypeLabel::Unit { span });
+                } else if let Some(found) = found.make_suggestable(self.tcx, false, None) {
                     err.subdiagnostic(errors::AddReturnTypeSuggestion::Add {
                         span,
                         found: found.to_string(),
                     });
-                    return true;
                 } else if let Some(sugg) = suggest_impl_trait(self, self.param_env, found) {
                     err.subdiagnostic(errors::AddReturnTypeSuggestion::Add { span, found: sugg });
-                    return true;
                 } else {
                     // FIXME: if `found` could be `impl Iterator` we should suggest that.
                     err.subdiagnostic(errors::AddReturnTypeSuggestion::MissingHere { span });
-                    return true;
                 }
+
+                return true;
             }
             hir::FnRetTy::Return(hir_ty) => {
                 if let hir::TyKind::OpaqueDef(item_id, ..) = hir_ty.kind
@@ -904,6 +901,32 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         false
     }
 
+    /// Checks whether we can add a return type to a function.
+    /// Assumes given function doesn't have a explicit return type.
+    fn can_add_return_type(&self, fn_id: LocalDefId) -> bool {
+        match self.tcx.hir_node_by_def_id(fn_id) {
+            Node::Item(&hir::Item { ident, .. }) => {
+                // This is less than ideal, it will not suggest a return type span on any
+                // method called `main`, regardless of whether it is actually the entry point,
+                // but it will still present it as the reason for the expected type.
+                ident.name != sym::main
+            }
+            Node::ImplItem(item) => {
+                // If it doesn't impl a trait, we can add a return type
+                let Node::Item(&hir::Item {
+                    kind: hir::ItemKind::Impl(&hir::Impl { of_trait, .. }),
+                    ..
+                }) = self.tcx.parent_hir_node(item.hir_id())
+                else {
+                    unreachable!();
+                };
+
+                of_trait.is_none()
+            }
+            _ => true,
+        }
+    }
+
     fn try_note_caller_chooses_ty_for_ty_param(
         &self,
         diag: &mut Diag<'_>,
diff --git a/tests/ui/closures/add_semicolon_non_block_closure.rs b/tests/ui/closures/add_semicolon_non_block_closure.rs
index 62c5e343cd345..3ae91be60c5a0 100644
--- a/tests/ui/closures/add_semicolon_non_block_closure.rs
+++ b/tests/ui/closures/add_semicolon_non_block_closure.rs
@@ -8,5 +8,4 @@ fn main() {
     foo(|| bar())
     //~^ ERROR mismatched types [E0308]
     //~| HELP consider using a semicolon here
-    //~| HELP try adding a return type
 }
diff --git a/tests/ui/closures/add_semicolon_non_block_closure.stderr b/tests/ui/closures/add_semicolon_non_block_closure.stderr
index 7883db8f98ec5..3dd8f12d55f32 100644
--- a/tests/ui/closures/add_semicolon_non_block_closure.stderr
+++ b/tests/ui/closures/add_semicolon_non_block_closure.stderr
@@ -8,10 +8,6 @@ help: consider using a semicolon here
    |
 LL |     foo(|| { bar(); })
    |            +      +++
-help: try adding a return type
-   |
-LL |     foo(|| -> i32 bar())
-   |            ++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/try-operator-dont-suggest-semicolon.rs b/tests/ui/suggestions/try-operator-dont-suggest-semicolon.rs
index 35a06d396f2bb..f882a159f9834 100644
--- a/tests/ui/suggestions/try-operator-dont-suggest-semicolon.rs
+++ b/tests/ui/suggestions/try-operator-dont-suggest-semicolon.rs
@@ -3,7 +3,6 @@
 
 fn main() -> Result<(), ()> {
     a(|| {
-        //~^ HELP: try adding a return type
         b()
         //~^ ERROR: mismatched types [E0308]
         //~| NOTE: expected `()`, found `i32`
diff --git a/tests/ui/suggestions/try-operator-dont-suggest-semicolon.stderr b/tests/ui/suggestions/try-operator-dont-suggest-semicolon.stderr
index 5506456afe9ca..939285498fb69 100644
--- a/tests/ui/suggestions/try-operator-dont-suggest-semicolon.stderr
+++ b/tests/ui/suggestions/try-operator-dont-suggest-semicolon.stderr
@@ -1,20 +1,13 @@
 error[E0308]: mismatched types
-  --> $DIR/try-operator-dont-suggest-semicolon.rs:7:9
+  --> $DIR/try-operator-dont-suggest-semicolon.rs:6:9
    |
 LL |         b()
-   |         ^^^ expected `()`, found `i32`
-   |
-help: consider using a semicolon here
-   |
-LL |         b();
-   |            +
-help: try adding a return type
-   |
-LL |     a(|| -> i32 {
-   |          ++++++
+   |         ^^^- help: consider using a semicolon here: `;`
+   |         |
+   |         expected `()`, found `i32`
 
 error[E0308]: mismatched types
-  --> $DIR/try-operator-dont-suggest-semicolon.rs:17:9
+  --> $DIR/try-operator-dont-suggest-semicolon.rs:16:9
    |
 LL | /     if true {
 LL | |
diff --git a/tests/ui/typeck/issue-81943.stderr b/tests/ui/typeck/issue-81943.stderr
index f8da9ef0d180f..041ff10752cf0 100644
--- a/tests/ui/typeck/issue-81943.stderr
+++ b/tests/ui/typeck/issue-81943.stderr
@@ -2,9 +2,7 @@ error[E0308]: mismatched types
   --> $DIR/issue-81943.rs:7:9
    |
 LL |   f(|x| lib::d!(x));
-   |        -^^^^^^^^^^ expected `()`, found `i32`
-   |        |
-   |        help: try adding a return type: `-> i32`
+   |         ^^^^^^^^^^ expected `()`, found `i32`
    |
    = note: this error originates in the macro `lib::d` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -12,22 +10,28 @@ error[E0308]: mismatched types
   --> $DIR/issue-81943.rs:8:28
    |
 LL |   f(|x| match x { tmp => { g(tmp) } });
-   |                            ^^^^^^ expected `()`, found `i32`
+   |         -------------------^^^^^^----
+   |         |                  |
+   |         |                  expected `()`, found `i32`
+   |         expected this to be `()`
    |
 help: consider using a semicolon here
    |
 LL |   f(|x| match x { tmp => { g(tmp); } });
    |                                  +
-help: try adding a return type
+help: consider using a semicolon here
    |
-LL |   f(|x| -> i32 match x { tmp => { g(tmp) } });
-   |         ++++++
+LL |   f(|x| match x { tmp => { g(tmp) } };);
+   |                                      +
 
 error[E0308]: mismatched types
   --> $DIR/issue-81943.rs:10:38
    |
 LL |     ($e:expr) => { match $e { x => { g(x) } } }
-   |                                      ^^^^ expected `()`, found `i32`
+   |                    ------------------^^^^----
+   |                    |                 |
+   |                    |                 expected `()`, found `i32`
+   |                    expected this to be `()`
 LL |   }
 LL |   f(|x| d!(x));
    |         ----- in this macro invocation
@@ -37,10 +41,10 @@ help: consider using a semicolon here
    |
 LL |     ($e:expr) => { match $e { x => { g(x); } } }
    |                                          +
-help: try adding a return type
+help: consider using a semicolon here
    |
-LL |   f(|x| -> i32 d!(x));
-   |         ++++++
+LL |     ($e:expr) => { match $e { x => { g(x) } }; }
+   |                                              +
 
 error: aborting due to 3 previous errors
 

From 2ddcbca0e626cc3856349deeed17814ba6c272d6 Mon Sep 17 00:00:00 2001
From: tunawasabi <77270077+tunawasabi@users.noreply.github.com>
Date: Sun, 25 Aug 2024 04:24:27 +0900
Subject: [PATCH 02/20] Suggest the struct variant pattern syntax on usage of
 unit variant pattern for a struct variant

---
 compiler/rustc_hir_typeck/src/lib.rs          | 32 ++++++++++++++++++-
 .../ui/empty/empty-struct-braces-pat-1.stderr | 10 ++++++
 .../ui/empty/empty-struct-braces-pat-3.stderr | 20 ++++++++++++
 tests/ui/issues/issue-63983.stderr            |  5 +++
 .../recover/recover-from-bad-variant.stderr   |  5 +++
 tests/ui/suggestions/issue-84700.stderr       |  5 +++
 ...t-variant-form-through-alias-caught.stderr | 10 ++++++
 7 files changed, 86 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 9ec101196a43f..0a4df619c20f3 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -45,7 +45,7 @@ pub use coercion::can_coerce;
 use fn_ctxt::FnCtxt;
 use rustc_data_structures::unord::UnordSet;
 use rustc_errors::codes::*;
-use rustc_errors::{struct_span_code_err, Applicability, ErrorGuaranteed};
+use rustc_errors::{pluralize, struct_span_code_err, Applicability, ErrorGuaranteed};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::Visitor;
@@ -421,6 +421,36 @@ fn report_unexpected_variant_res(
             err.multipart_suggestion_verbose(descr, suggestion, Applicability::MaybeIncorrect);
             err
         }
+        Res::Def(DefKind::Variant, _) if expr.is_none() => {
+            err.span_label(span, format!("not a {expected}"));
+
+            let fields = &tcx.expect_variant_res(res).fields.raw;
+            let span = qpath.span().shrink_to_hi().to(span.shrink_to_hi());
+            let (msg, sugg) = if fields.is_empty() {
+                ("use the struct variant pattern syntax".to_string(), " {}".to_string())
+            } else {
+                let msg = format!(
+                    "the struct variant's field{s} {are} being ignored",
+                    s = pluralize!(fields.len()),
+                    are = pluralize!("is", fields.len())
+                );
+                let fields = fields
+                    .iter()
+                    .map(|field| format!("{}: _", field.name.to_ident_string()))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let sugg = format!(" {{ {} }}", fields);
+                (msg, sugg)
+            };
+
+            err.span_suggestion_verbose(
+                qpath.span().shrink_to_hi().to(span.shrink_to_hi()),
+                msg,
+                sugg,
+                Applicability::HasPlaceholders,
+            );
+            err
+        }
         _ => err.with_span_label(span, format!("not a {expected}")),
     }
     .emit()
diff --git a/tests/ui/empty/empty-struct-braces-pat-1.stderr b/tests/ui/empty/empty-struct-braces-pat-1.stderr
index 14e09fc27a06d..c16fbc7de2b29 100644
--- a/tests/ui/empty/empty-struct-braces-pat-1.stderr
+++ b/tests/ui/empty/empty-struct-braces-pat-1.stderr
@@ -3,12 +3,22 @@ error[E0533]: expected unit struct, unit variant or constant, found struct varia
    |
 LL |         E::Empty3 => ()
    |         ^^^^^^^^^ not a unit struct, unit variant or constant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |         E::Empty3 {} => ()
+   |                   ++
 
 error[E0533]: expected unit struct, unit variant or constant, found struct variant `XE::XEmpty3`
   --> $DIR/empty-struct-braces-pat-1.rs:31:9
    |
 LL |         XE::XEmpty3 => ()
    |         ^^^^^^^^^^^ not a unit struct, unit variant or constant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |         XE::XEmpty3 {} => ()
+   |                     ++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/empty/empty-struct-braces-pat-3.stderr b/tests/ui/empty/empty-struct-braces-pat-3.stderr
index 00c8b12e6f984..b2ab7113347ff 100644
--- a/tests/ui/empty/empty-struct-braces-pat-3.stderr
+++ b/tests/ui/empty/empty-struct-braces-pat-3.stderr
@@ -3,24 +3,44 @@ error[E0164]: expected tuple struct or tuple variant, found struct variant `E::E
    |
 LL |         E::Empty3() => ()
    |         ^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |         E::Empty3 {} => ()
+   |                   ~~
 
 error[E0164]: expected tuple struct or tuple variant, found struct variant `XE::XEmpty3`
   --> $DIR/empty-struct-braces-pat-3.rs:21:9
    |
 LL |         XE::XEmpty3() => ()
    |         ^^^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |         XE::XEmpty3 {} => ()
+   |                     ~~
 
 error[E0164]: expected tuple struct or tuple variant, found struct variant `E::Empty3`
   --> $DIR/empty-struct-braces-pat-3.rs:25:9
    |
 LL |         E::Empty3(..) => ()
    |         ^^^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |         E::Empty3 {} => ()
+   |                   ~~
 
 error[E0164]: expected tuple struct or tuple variant, found struct variant `XE::XEmpty3`
   --> $DIR/empty-struct-braces-pat-3.rs:29:9
    |
 LL |         XE::XEmpty3(..) => ()
    |         ^^^^^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |         XE::XEmpty3 {} => ()
+   |                     ~~
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/issues/issue-63983.stderr b/tests/ui/issues/issue-63983.stderr
index f90c81116264a..3539732451ce2 100644
--- a/tests/ui/issues/issue-63983.stderr
+++ b/tests/ui/issues/issue-63983.stderr
@@ -12,6 +12,11 @@ error[E0533]: expected unit struct, unit variant or constant, found struct varia
    |
 LL |         MyEnum::Struct => "",
    |         ^^^^^^^^^^^^^^ not a unit struct, unit variant or constant
+   |
+help: the struct variant's field is being ignored
+   |
+LL |         MyEnum::Struct { s: _ } => "",
+   |                        ++++++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/parser/recover/recover-from-bad-variant.stderr b/tests/ui/parser/recover/recover-from-bad-variant.stderr
index 04968bbdf999d..0339f86951543 100644
--- a/tests/ui/parser/recover/recover-from-bad-variant.stderr
+++ b/tests/ui/parser/recover/recover-from-bad-variant.stderr
@@ -19,6 +19,11 @@ error[E0164]: expected tuple struct or tuple variant, found struct variant `Enum
    |
 LL |         Enum::Foo(a, b) => {}
    |         ^^^^^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: the struct variant's fields are being ignored
+   |
+LL |         Enum::Foo { a: _, b: _ } => {}
+   |                   ~~~~~~~~~~~~~~
 
 error[E0769]: tuple variant `Enum::Bar` written as struct variant
   --> $DIR/recover-from-bad-variant.rs:12:9
diff --git a/tests/ui/suggestions/issue-84700.stderr b/tests/ui/suggestions/issue-84700.stderr
index ac9f5ab0b0cbb..d07055826606d 100644
--- a/tests/ui/suggestions/issue-84700.stderr
+++ b/tests/ui/suggestions/issue-84700.stderr
@@ -12,6 +12,11 @@ error[E0164]: expected tuple struct or tuple variant, found struct variant `Farm
    |
 LL |         FarmAnimal::Chicken(_) => "cluck, cluck!".to_string(),
    |         ^^^^^^^^^^^^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: the struct variant's field is being ignored
+   |
+LL |         FarmAnimal::Chicken { num_eggs: _ } => "cluck, cluck!".to_string(),
+   |                             ~~~~~~~~~~~~~~~
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr b/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr
index c21c59397c79e..714b4fd7d25f6 100644
--- a/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr
+++ b/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr
@@ -14,12 +14,22 @@ error[E0533]: expected unit struct, unit variant or constant, found struct varia
    |
 LL |     let Alias::Braced = panic!();
    |         ^^^^^^^^^^^^^ not a unit struct, unit variant or constant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |     let Alias::Braced {} = panic!();
+   |                       ++
 
 error[E0164]: expected tuple struct or tuple variant, found struct variant `Alias::Braced`
   --> $DIR/incorrect-variant-form-through-alias-caught.rs:12:9
    |
 LL |     let Alias::Braced(..) = panic!();
    |         ^^^^^^^^^^^^^^^^^ not a tuple struct or tuple variant
+   |
+help: use the struct variant pattern syntax
+   |
+LL |     let Alias::Braced {} = panic!();
+   |                       ~~
 
 error[E0618]: expected function, found enum variant `Alias::Unit`
   --> $DIR/incorrect-variant-form-through-alias-caught.rs:15:5

From 7ed9f945a22a6e9cfb75405698e0eaa163c12beb Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Fri, 6 Sep 2024 12:39:11 -0700
Subject: [PATCH 03/20] Don't leave debug locations for constants sitting on
 the builder indefinitely.

Because constants are currently emitted *before* the prologue, leaving the
debug location on the IRBuilder spills onto other instructions in the prologue
and messes up both line numbers as well as the point LLVM chooses to be the
prologue end.

Example LLVM IR (irrelevant IR elided):
Before:

define internal { i64, i64 } @_ZN3tmp3Foo18var_return_opt_try17he02116165b0fc08cE(ptr align 8 %self) !dbg !347 {
start:
  %self.dbg.spill = alloca [8 x i8], align 8
  %_0 = alloca [16 x i8], align 8
  %residual.dbg.spill = alloca [0 x i8], align 1
    #dbg_declare(ptr %residual.dbg.spill, !353, !DIExpression(), !357)
  store ptr %self, ptr %self.dbg.spill, align 8, !dbg !357
    #dbg_declare(ptr %self.dbg.spill, !350, !DIExpression(), !358)

After:

define internal { i64, i64 } @_ZN3tmp3Foo18var_return_opt_try17h00b17d08874ddd90E(ptr align 8 %self) !dbg !347 {
start:
  %self.dbg.spill = alloca [8 x i8], align 8
  %_0 = alloca [16 x i8], align 8
  %residual.dbg.spill = alloca [0 x i8], align 1
    #dbg_declare(ptr %residual.dbg.spill, !353, !DIExpression(), !357)
  store ptr %self, ptr %self.dbg.spill, align 8
    #dbg_declare(ptr %self.dbg.spill, !350, !DIExpression(), !358)

Note in particular how !357 from %residual.dbg.spill's dbg_declare no longer
falls through onto the store to %self.dbg.spill. This fixes argument values
at entry when the constant is a ZST (e.g. <Option as Try>::Residual). This
fixes #130003 (but note that it does *not* fix issues with argument values and
non-ZST constants, which emit their own stores that have debug info on them,
like #128945).
---
 compiler/rustc_codegen_gcc/src/debuginfo.rs   |  4 ++
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   |  8 ++-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  2 +-
 .../rustc_codegen_ssa/src/mir/debuginfo.rs    |  1 +
 .../rustc_codegen_ssa/src/traits/debuginfo.rs |  1 +
 .../debuginfo/zst-interferes-with-prologue.rs | 72 +++++++++++++++++++
 6 files changed, 86 insertions(+), 2 deletions(-)
 create mode 100644 tests/debuginfo/zst-interferes-with-prologue.rs

diff --git a/compiler/rustc_codegen_gcc/src/debuginfo.rs b/compiler/rustc_codegen_gcc/src/debuginfo.rs
index d770da5a8c44f..f2ae9f9c8a62e 100644
--- a/compiler/rustc_codegen_gcc/src/debuginfo.rs
+++ b/compiler/rustc_codegen_gcc/src/debuginfo.rs
@@ -48,6 +48,10 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
     fn set_dbg_loc(&mut self, dbg_loc: Self::DILocation) {
         self.location = Some(dbg_loc);
     }
+
+    fn clear_dbg_loc(&mut self) {
+        self.location = None;
+    }
 }
 
 /// Generate the `debug_context` in an MIR Body.
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index f5d6fc6f08073..842212ac05d4d 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -1,8 +1,8 @@
 #![doc = include_str!("doc.md")]
 
 use std::cell::{OnceCell, RefCell};
-use std::iter;
 use std::ops::Range;
+use std::{iter, ptr};
 
 use libc::c_uint;
 use rustc_codegen_ssa::debuginfo::type_names;
@@ -209,6 +209,12 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         }
     }
 
+    fn clear_dbg_loc(&mut self) {
+        unsafe {
+            llvm::LLVMSetCurrentDebugLocation2(self.llbuilder, ptr::null());
+        }
+    }
+
     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
         gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
     }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 3bf4d4964082f..e84ab0aa53889 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1041,7 +1041,7 @@ unsafe extern "C" {
     pub fn LLVMDisposeBuilder<'a>(Builder: &'a mut Builder<'a>);
 
     // Metadata
-    pub fn LLVMSetCurrentDebugLocation2<'a>(Builder: &Builder<'a>, Loc: &'a Metadata);
+    pub fn LLVMSetCurrentDebugLocation2<'a>(Builder: &Builder<'a>, Loc: *const Metadata);
 
     // Terminators
     pub fn LLVMBuildRetVoid<'a>(B: &Builder<'a>) -> &'a Value;
diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index 75692540c0345..ab08ef72a697b 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -547,6 +547,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         self.set_debug_loc(bx, var.source_info);
                         let base =
                             Self::spill_operand_to_stack(operand, Some(var.name.to_string()), bx);
+                        bx.clear_dbg_loc();
 
                         bx.dbg_var_addr(
                             dbg_var,
diff --git a/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs b/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
index 31104e5749b30..5fbe97214fb00 100644
--- a/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
@@ -80,6 +80,7 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
         fragment: Option<Range<Size>>,
     );
     fn set_dbg_loc(&mut self, dbg_loc: Self::DILocation);
+    fn clear_dbg_loc(&mut self);
     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self);
     fn set_var_name(&mut self, value: Self::Value, name: &str);
 }
diff --git a/tests/debuginfo/zst-interferes-with-prologue.rs b/tests/debuginfo/zst-interferes-with-prologue.rs
new file mode 100644
index 0000000000000..09041a3bb72c7
--- /dev/null
+++ b/tests/debuginfo/zst-interferes-with-prologue.rs
@@ -0,0 +1,72 @@
+//@ min-lldb-version: 310
+
+//@ compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:break zst_interferes_with_prologue::Foo::var_return_opt_try
+// gdb-command:run
+
+// gdb-command:print self
+// gdb-command:next
+// gdb-command:print self
+// gdb-command:print $1 == $2
+// gdb-check:true
+
+// === LLDB TESTS ==================================================================================
+
+// lldb-command:b "zst_interferes_with_prologue::Foo::var_return_opt_try"
+// lldb-command:run
+
+// lldb-command:expr self
+// lldb-command:next
+// lldb-command:expr self
+// lldb-command:print $0 == $1
+// lldb-check:true
+
+struct Foo {
+    a: usize,
+}
+
+impl Foo {
+    #[inline(never)]
+    fn get_a(&self) -> Option<usize> {
+        Some(self.a)
+    }
+
+    #[inline(never)]
+    fn var_return(&self) -> usize {
+        let r = self.get_a().unwrap();
+        r
+    }
+
+    #[inline(never)]
+    fn var_return_opt_unwrap(&self) -> Option<usize> {
+        let r = self.get_a().unwrap();
+        Some(r)
+    }
+
+    #[inline(never)]
+    fn var_return_opt_match(&self) -> Option<usize> {
+        let r = match self.get_a() {
+            None => return None,
+            Some(a) => a,
+        };
+        Some(r)
+    }
+
+    #[inline(never)]
+    fn var_return_opt_try(&self) -> Option<usize> {
+        let r = self.get_a()?;
+        Some(r)
+    }
+}
+
+fn main() {
+    let f1 = Foo{ a: 1 };
+    let f2 = Foo{ a: 1 };
+    f1.var_return();
+    f1.var_return_opt_unwrap();
+    f1.var_return_opt_match();
+    f2.var_return_opt_try();
+}

From f98ca32b0a594b1ee59e22e1927198ed03eb0ce7 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Sat, 7 Sep 2024 17:57:47 +0200
Subject: [PATCH 04/20] Fix linking error when compiling for 32-bit watchOS

In https://github.com/rust-lang/rust/pull/124748, I mistakenly conflated
"not SjLj" to mean "ARM EHABI", which isn't true, watchOS armv7k
(specifically only that architecture) uses a third unwinding method
called "DWARF CFI".
---
 library/std/src/sys/personality/dwarf/eh.rs |  6 +++---
 library/std/src/sys/personality/gcc.rs      | 13 +++++++------
 library/unwind/src/libunwind.rs             | 13 ++++++++-----
 3 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/library/std/src/sys/personality/dwarf/eh.rs b/library/std/src/sys/personality/dwarf/eh.rs
index c37c3e442aea6..778d8686f023e 100644
--- a/library/std/src/sys/personality/dwarf/eh.rs
+++ b/library/std/src/sys/personality/dwarf/eh.rs
@@ -54,10 +54,10 @@ pub enum EHAction {
     Terminate,
 }
 
-/// 32-bit Apple ARM uses SjLj exceptions, except for watchOS.
+/// 32-bit ARM Darwin platforms uses SjLj exceptions.
 ///
-/// I.e. iOS and tvOS, as those are the only Apple OSes that used 32-bit ARM
-/// devices.
+/// The exception is watchOS armv7k (specifically that subarchitecture), which
+/// instead uses DWARF Call Frame Information (CFI) unwinding.
 ///
 /// <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.4/clang/lib/Driver/ToolChains/Darwin.cpp#L3107-L3119>
 pub const USING_SJLJ_EXCEPTIONS: bool =
diff --git a/library/std/src/sys/personality/gcc.rs b/library/std/src/sys/personality/gcc.rs
index f6b1844e153fd..ad596ecff65d5 100644
--- a/library/std/src/sys/personality/gcc.rs
+++ b/library/std/src/sys/personality/gcc.rs
@@ -95,14 +95,15 @@ const UNWIND_DATA_REG: (i32, i32) = (4, 5); // a0, a1
 
 cfg_if::cfg_if! {
     if #[cfg(all(
-            target_arch = "arm",
-            not(all(target_vendor = "apple", not(target_os = "watchos"))),
-            not(target_os = "netbsd"),
-        ))] {
+        target_arch = "arm",
+        not(target_vendor = "apple"),
+        not(target_os = "netbsd"),
+    ))] {
         /// personality fn called by [ARM EHABI][armeabi-eh]
         ///
-        /// Apple 32-bit ARM (but not watchOS) uses the default routine instead
-        /// since it uses "setjmp-longjmp" unwinding.
+        /// 32-bit ARM on iOS/tvOS/watchOS does not use ARM EHABI, it uses
+        /// either "setjmp-longjmp" unwinding or DWARF CFI unwinding, which is
+        /// handled by the default routine.
         ///
         /// [armeabi-eh]: https://web.archive.org/web/20190728160938/https://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
         #[lang = "eh_personality"]
diff --git a/library/unwind/src/libunwind.rs b/library/unwind/src/libunwind.rs
index e5e28f32e4dbf..1d856ce1879a5 100644
--- a/library/unwind/src/libunwind.rs
+++ b/library/unwind/src/libunwind.rs
@@ -33,10 +33,10 @@ pub const unwinder_private_data_size: usize = 2;
 #[cfg(all(target_arch = "x86_64", target_os = "windows"))]
 pub const unwinder_private_data_size: usize = 6;
 
-#[cfg(all(target_arch = "arm", not(all(target_vendor = "apple", not(target_os = "watchos")))))]
+#[cfg(all(target_arch = "arm", not(target_vendor = "apple")))]
 pub const unwinder_private_data_size: usize = 20;
 
-#[cfg(all(target_arch = "arm", all(target_vendor = "apple", not(target_os = "watchos"))))]
+#[cfg(all(target_arch = "arm", target_vendor = "apple"))]
 pub const unwinder_private_data_size: usize = 5;
 
 #[cfg(all(target_arch = "aarch64", target_pointer_width = "64", not(target_os = "windows")))]
@@ -123,8 +123,11 @@ extern "C" {
 }
 
 cfg_if::cfg_if! {
-if #[cfg(any(all(target_vendor = "apple", not(target_os = "watchos")), target_os = "netbsd", not(target_arch = "arm")))] {
+if #[cfg(any(target_vendor = "apple", target_os = "netbsd", not(target_arch = "arm")))] {
     // Not ARM EHABI
+    //
+    // 32-bit ARM on iOS/tvOS/watchOS use either DWARF/Compact unwinding or
+    // "setjmp-longjmp" / SjLj unwinding.
     #[repr(C)]
     #[derive(Copy, Clone, PartialEq)]
     pub enum _Unwind_Action {
@@ -259,8 +262,8 @@ if #[cfg(any(all(target_vendor = "apple", not(target_os = "watchos")), target_os
 
 cfg_if::cfg_if! {
 if #[cfg(all(target_vendor = "apple", not(target_os = "watchos"), target_arch = "arm"))] {
-    // 32-bit ARM Apple (except for watchOS) uses SjLj and does not provide
-    // _Unwind_Backtrace()
+    // 32-bit ARM Apple (except for watchOS armv7k specifically) uses SjLj and
+    // does not provide _Unwind_Backtrace()
     extern "C-unwind" {
         pub fn _Unwind_SjLj_RaiseException(e: *mut _Unwind_Exception) -> _Unwind_Reason_Code;
     }

From 713828d4f430e1393535f588e73dd5d8bb5d793a Mon Sep 17 00:00:00 2001
From: Florian Schmiderer <florian.schmiderer@posteo.net>
Date: Fri, 6 Sep 2024 23:41:16 +0200
Subject: [PATCH 05/20] Add test for S_OBJNAME and update test for LF_BUILDINFO
 cl and cmd for pdb files.

---
 .../src/external_deps/llvm.rs                 |  6 +++++
 .../pdb-buildinfo-cl-cmd/filecheck.txt        |  4 ++++
 tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs  | 24 ++++---------------
 tests/run-make/pdb-sobjname/main.rs           |  1 +
 tests/run-make/pdb-sobjname/rmake.rs          | 20 ++++++++++++++++
 5 files changed, 36 insertions(+), 19 deletions(-)
 create mode 100644 tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt
 create mode 100644 tests/run-make/pdb-sobjname/main.rs
 create mode 100644 tests/run-make/pdb-sobjname/rmake.rs

diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
index 16c4251998fb2..38a9ac923b4dc 100644
--- a/src/tools/run-make-support/src/external_deps/llvm.rs
+++ b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -54,6 +54,12 @@ pub fn llvm_dwarfdump() -> LlvmDwarfdump {
     LlvmDwarfdump::new()
 }
 
+/// Construct a new `llvm-pdbutil` invocation. This assumes that `llvm-pdbutil` is available
+/// at `$LLVM_BIN_DIR/llvm-pdbutil`.
+pub fn llvm_pdbutil() -> LlvmPdbutil {
+    LlvmPdbutil::new()
+}
+
 /// A `llvm-readobj` invocation builder.
 #[derive(Debug)]
 #[must_use]
diff --git a/tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt b/tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt
new file mode 100644
index 0000000000000..a01999d5bdf76
--- /dev/null
+++ b/tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt
@@ -0,0 +1,4 @@
+CHECK: LF_BUILDINFO
+CHECK: rustc.exe
+CHECK: main.rs
+CHECK: "-g" "--crate-name" "my_crate_name" "--crate-type" "bin" "-Cmetadata=dc9ef878b0a48666"
diff --git a/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs b/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs
index 2ab9057b24c1b..9418f4f8d84d3 100644
--- a/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs
+++ b/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs
@@ -7,7 +7,7 @@
 //@ only-windows-msvc
 // Reason: pdb files are unique to this architecture
 
-use run_make_support::{assert_contains, bstr, env_var, rfs, rustc};
+use run_make_support::{llvm, rustc};
 
 fn main() {
     rustc()
@@ -17,23 +17,9 @@ fn main() {
         .crate_type("bin")
         .metadata("dc9ef878b0a48666")
         .run();
-    let tests = [
-        &env_var("RUSTC"),
-        r#""main.rs""#,
-        r#""-g""#,
-        r#""--crate-name""#,
-        r#""my_crate_name""#,
-        r#""--crate-type""#,
-        r#""bin""#,
-        r#""-Cmetadata=dc9ef878b0a48666""#,
-    ];
-    for test in tests {
-        assert_pdb_contains(test);
-    }
-}
 
-fn assert_pdb_contains(needle: &str) {
-    let needle = needle.as_bytes();
-    use bstr::ByteSlice;
-    assert!(&rfs::read("my_crate_name.pdb").find(needle).is_some());
+    let pdbutil_result =
+        llvm::llvm_pdbutil().arg("dump").arg("-ids").input("my_crate_name.pdb").run();
+
+    llvm::llvm_filecheck().patterns("filecheck.txt").stdin_buf(pdbutil_result.stdout_utf8()).run();
 }
diff --git a/tests/run-make/pdb-sobjname/main.rs b/tests/run-make/pdb-sobjname/main.rs
new file mode 100644
index 0000000000000..f328e4d9d04c3
--- /dev/null
+++ b/tests/run-make/pdb-sobjname/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/run-make/pdb-sobjname/rmake.rs b/tests/run-make/pdb-sobjname/rmake.rs
new file mode 100644
index 0000000000000..83c39fdccd3c7
--- /dev/null
+++ b/tests/run-make/pdb-sobjname/rmake.rs
@@ -0,0 +1,20 @@
+// Check if the pdb file contains an S_OBJNAME entry with the name of the .o file
+
+// This is because it used to be missing in #96475.
+// See https://github.com/rust-lang/rust/pull/115704
+
+//@ only-windows-msvc
+// Reason: pdb files are unique to this architecture
+
+use run_make_support::{llvm, rustc};
+
+fn main() {
+    rustc().input("main.rs").arg("-g").crate_name("my_great_crate_name").crate_type("bin").run();
+
+    let pdbutil_result = llvm::llvm_pdbutil()
+        .arg("dump")
+        .arg("-symbols")
+        .input("my_great_crate_name.pdb")
+        .run()
+        .assert_stdout_contains_regex("S_OBJNAME.+my_great_crate_name.*\\.o");
+}

From 4cecf429717ceab06007570fd699086a0855a027 Mon Sep 17 00:00:00 2001
From: FedericoBruzzone <federico.bruzzone.i@gmail.com>
Date: Mon, 9 Sep 2024 01:17:49 +0200
Subject: [PATCH 06/20] Report the `note` when specified in
 `diagnostic::on_unimplemented`

Signed-off-by: FedericoBruzzone <federico.bruzzone.i@gmail.com>
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 14 +++++---
 .../methods/suggest-convert-ptr-to-ref.stderr |  2 ++
 .../custom-on-unimplemented-diagnostic.rs     | 19 +++++++++++
 .../custom-on-unimplemented-diagnostic.stderr | 32 +++++++++++++++++++
 4 files changed, 62 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/traits/custom-on-unimplemented-diagnostic.rs
 create mode 100644 tests/ui/traits/custom-on-unimplemented-diagnostic.stderr

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 14ad5830111b4..178d5dce08643 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1317,7 +1317,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let actual_prefix = rcvr_ty.prefix_string(self.tcx);
                 info!("unimplemented_traits.len() == {}", unimplemented_traits.len());
                 let mut long_ty_file = None;
-                let (primary_message, label) = if unimplemented_traits.len() == 1
+                let (primary_message, label, notes) = if unimplemented_traits.len() == 1
                     && unimplemented_traits_only
                 {
                     unimplemented_traits
@@ -1327,16 +1327,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             if trait_ref.self_ty().references_error() || rcvr_ty.references_error()
                             {
                                 // Avoid crashing.
-                                return (None, None);
+                                return (None, None, Vec::new());
                             }
-                            let OnUnimplementedNote { message, label, .. } = self
+                            let OnUnimplementedNote { message, label, notes, .. } = self
                                 .err_ctxt()
                                 .on_unimplemented_note(trait_ref, &obligation, &mut long_ty_file);
-                            (message, label)
+                            (message, label, notes)
                         })
                         .unwrap()
                 } else {
-                    (None, None)
+                    (None, None, Vec::new())
                 };
                 let primary_message = primary_message.unwrap_or_else(|| {
                     format!(
@@ -1363,6 +1363,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         "the following trait bounds were not satisfied:\n{bound_list}"
                     ));
                 }
+                for note in notes {
+                    err.note(note);
+                }
+
                 suggested_derive = self.suggest_derive(&mut err, unsatisfied_predicates);
 
                 unsatisfied_bounds = true;
diff --git a/tests/ui/methods/suggest-convert-ptr-to-ref.stderr b/tests/ui/methods/suggest-convert-ptr-to-ref.stderr
index 69b20d57be829..0e1565e251adc 100644
--- a/tests/ui/methods/suggest-convert-ptr-to-ref.stderr
+++ b/tests/ui/methods/suggest-convert-ptr-to-ref.stderr
@@ -11,6 +11,7 @@ note: the method `to_string` exists on the type `&u8`
    = note: the following trait bounds were not satisfied:
            `*const u8: std::fmt::Display`
            which is required by `*const u8: ToString`
+   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
 
 error[E0599]: `*mut u8` doesn't implement `std::fmt::Display`
   --> $DIR/suggest-convert-ptr-to-ref.rs:8:22
@@ -25,6 +26,7 @@ note: the method `to_string` exists on the type `&&mut u8`
    = note: the following trait bounds were not satisfied:
            `*mut u8: std::fmt::Display`
            which is required by `*mut u8: ToString`
+   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
 
 error[E0599]: no method named `make_ascii_lowercase` found for raw pointer `*mut u8` in the current scope
   --> $DIR/suggest-convert-ptr-to-ref.rs:9:7
diff --git a/tests/ui/traits/custom-on-unimplemented-diagnostic.rs b/tests/ui/traits/custom-on-unimplemented-diagnostic.rs
new file mode 100644
index 0000000000000..d7e257ef3bbe3
--- /dev/null
+++ b/tests/ui/traits/custom-on-unimplemented-diagnostic.rs
@@ -0,0 +1,19 @@
+#[diagnostic::on_unimplemented(message = "my message", label = "my label", note = "my note")]
+pub trait ProviderLt {}
+
+pub trait ProviderExt {
+    fn request<R>(&self) {
+        todo!()
+    }
+}
+
+impl<T: ?Sized + ProviderLt> ProviderExt for T {}
+
+struct B;
+
+fn main() {
+    B.request();
+    //~^ my message [E0599]
+    //~| my label
+    //~| my note
+}
diff --git a/tests/ui/traits/custom-on-unimplemented-diagnostic.stderr b/tests/ui/traits/custom-on-unimplemented-diagnostic.stderr
new file mode 100644
index 0000000000000..f9788360d06ad
--- /dev/null
+++ b/tests/ui/traits/custom-on-unimplemented-diagnostic.stderr
@@ -0,0 +1,32 @@
+error[E0599]: my message
+  --> $DIR/custom-on-unimplemented-diagnostic.rs:15:7
+   |
+LL | struct B;
+   | -------- method `request` not found for this struct because it doesn't satisfy `B: ProviderExt` or `B: ProviderLt`
+...
+LL |     B.request();
+   |       ^^^^^^^ my label
+   |
+note: trait bound `B: ProviderLt` was not satisfied
+  --> $DIR/custom-on-unimplemented-diagnostic.rs:10:18
+   |
+LL | impl<T: ?Sized + ProviderLt> ProviderExt for T {}
+   |                  ^^^^^^^^^^  -----------     -
+   |                  |
+   |                  unsatisfied trait bound introduced here
+   = note: my note
+note: the trait `ProviderLt` must be implemented
+  --> $DIR/custom-on-unimplemented-diagnostic.rs:2:1
+   |
+LL | pub trait ProviderLt {}
+   | ^^^^^^^^^^^^^^^^^^^^
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `ProviderExt` defines an item `request`, perhaps you need to implement it
+  --> $DIR/custom-on-unimplemented-diagnostic.rs:4:1
+   |
+LL | pub trait ProviderExt {
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.

From 8f815978b56c908dcfe7c30b4108fa0486921272 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Wed, 11 Sep 2024 00:15:43 +0300
Subject: [PATCH 07/20] Map `WSAEDQUOT` to `ErrorKind::FilesystemQuotaExceeded`

---
 library/std/src/sys/pal/windows/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 1cc9a2b7ffa98..af98de3276a37 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -139,6 +139,7 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind {
         c::WSAEHOSTUNREACH => HostUnreachable,
         c::WSAENETDOWN => NetworkDown,
         c::WSAENETUNREACH => NetworkUnreachable,
+        c::WSAEDQUOT => FilesystemQuotaExceeded,
 
         _ => Uncategorized,
     }

From 49b3df92452ca5ce15017e69bb3f9c65d1af4139 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Wed, 11 Sep 2024 00:18:23 +0300
Subject: [PATCH 08/20] Map `ERROR_CANT_RESOLVE_FILENAME` to
 `ErrorKind::FilesystemLoop`

---
 library/std/src/sys/pal/windows/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 1cc9a2b7ffa98..b19a225fc27d8 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -122,6 +122,7 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind {
         c::ERROR_NOT_SAME_DEVICE => return CrossesDevices,
         c::ERROR_TOO_MANY_LINKS => return TooManyLinks,
         c::ERROR_FILENAME_EXCED_RANGE => return InvalidFilename,
+        c::ERROR_CANT_RESOLVE_FILENAME => return FilesystemLoop,
         _ => {}
     }
 

From 4198594ef2d95de255bc0535900dac182ecfbe08 Mon Sep 17 00:00:00 2001
From: James Liu <777445+root-goblin@users.noreply.github.com>
Date: Sun, 1 Sep 2024 15:27:48 -0400
Subject: [PATCH 09/20] Clarify docs for std::collections

Page affected: https://doc.rust-lang.org/std/collections/index.html#performance

Changes:

- bulleted conventions
- expanded definitions on terms used
- more accessible language
- merged Sequence and Map performance cost tables
---
 library/std/src/collections/mod.rs | 62 +++++++++++++++++-------------
 1 file changed, 35 insertions(+), 27 deletions(-)

diff --git a/library/std/src/collections/mod.rs b/library/std/src/collections/mod.rs
index 3b04412e76630..21bebff96b956 100644
--- a/library/std/src/collections/mod.rs
+++ b/library/std/src/collections/mod.rs
@@ -79,41 +79,49 @@
 //! see each type's documentation, and note that the names of actual methods may
 //! differ from the tables below on certain collections.
 //!
-//! Throughout the documentation, we will follow a few conventions. For all
-//! operations, the collection's size is denoted by n. If another collection is
-//! involved in the operation, it contains m elements. Operations which have an
-//! *amortized* cost are suffixed with a `*`. Operations with an *expected*
-//! cost are suffixed with a `~`.
+//! Throughout the documentation, we will adhere to the following conventions
+//! for operation notation:
 //!
-//! All amortized costs are for the potential need to resize when capacity is
-//! exhausted. If a resize occurs it will take *O*(*n*) time. Our collections never
-//! automatically shrink, so removal operations aren't amortized. Over a
-//! sufficiently large series of operations, the average cost per operation will
-//! deterministically equal the given cost.
+//! * The collection's size is denoted by `n`.
+//! * If a second collection is involved, its size is denoted by `m`.
+//! * Item indices are denoted by `i`.
+//! * Operations which have an *amortized* cost are suffixed with a `*`.
+//! * Operations with an *expected* cost are suffixed with a `~`.
 //!
-//! Only [`HashMap`] has expected costs, due to the probabilistic nature of hashing.
-//! It is theoretically possible, though very unlikely, for [`HashMap`] to
-//! experience worse performance.
+//! Calling operations that add to a collection will occasionally require a
+//! collection to be resized - an extra operation that takes *O*(*n*) time.
 //!
-//! ## Sequences
+//! *Amortized* costs are calculated to account for the time cost of such resize
+//! operations *over a sufficiently large series of operations*. An individual
+//! operation may be slower or faster due to the sporadic nature of collection
+//! resizing, however the average cost per operation will approach the amortized
+//! cost.
 //!
-//! |                | get(i)                 | insert(i)               | remove(i)              | append    | split_off(i)           |
-//! |----------------|------------------------|-------------------------|------------------------|-----------|------------------------|
-//! | [`Vec`]        | *O*(1)                 | *O*(*n*-*i*)*           | *O*(*n*-*i*)           | *O*(*m*)* | *O*(*n*-*i*)           |
-//! | [`VecDeque`]   | *O*(1)                 | *O*(min(*i*, *n*-*i*))* | *O*(min(*i*, *n*-*i*)) | *O*(*m*)* | *O*(min(*i*, *n*-*i*)) |
-//! | [`LinkedList`] | *O*(min(*i*, *n*-*i*)) | *O*(min(*i*, *n*-*i*))  | *O*(min(*i*, *n*-*i*)) | *O*(1)    | *O*(min(*i*, *n*-*i*)) |
+//! Rust's collections never automatically shrink, so removal operations aren't
+//! amortized.
 //!
-//! Note that where ties occur, [`Vec`] is generally going to be faster than [`VecDeque`], and
-//! [`VecDeque`] is generally going to be faster than [`LinkedList`].
+//! [`HashMap`] uses *expected* costs. It is theoretically possible, though very
+//! unlikely, for [`HashMap`] to experience significantly worse performance than
+//! the expected cost. This is due to the probabilistic nature of hashing - i.e.
+//! it is possible to generate a duplicate hash given some input key that will
+//! requires extra computation to correct.
 //!
-//! ## Maps
+//! ## Cost of Collection Operations
 //!
-//! For Sets, all operations have the cost of the equivalent Map operation.
 //!
-//! |              | get           | insert        | remove        | range         | append       |
-//! |--------------|---------------|---------------|---------------|---------------|--------------|
-//! | [`HashMap`]  | *O*(1)~       | *O*(1)~*      | *O*(1)~       | N/A           | N/A          |
-//! | [`BTreeMap`] | *O*(log(*n*)) | *O*(log(*n*)) | *O*(log(*n*)) | *O*(log(*n*)) | *O*(*n*+*m*) |
+//! |                | get(i)                 | insert(i)               | remove(i)              | append(Vec(m))    | split_off(i)           | range           | append       |
+//! |----------------|------------------------|-------------------------|------------------------|-------------------|------------------------|-----------------|--------------|
+//! | [`Vec`]        | *O*(1)                 | *O*(*n*-*i*)*           | *O*(*n*-*i*)           | *O*(*m*)*         | *O*(*n*-*i*)           | N/A             | N/A          |
+//! | [`VecDeque`]   | *O*(1)                 | *O*(min(*i*, *n*-*i*))* | *O*(min(*i*, *n*-*i*)) | *O*(*m*)*         | *O*(min(*i*, *n*-*i*)) | N/A             | N/A          |
+//! | [`LinkedList`] | *O*(min(*i*, *n*-*i*)) | *O*(min(*i*, *n*-*i*))  | *O*(min(*i*, *n*-*i*)) | *O*(1)            | *O*(min(*i*, *n*-*i*)) | N/A             | N/A          |
+//! | [`HashMap`]    | *O*(1)~                | *O*(1)~*                | *O*(1)~                | N/A               | N/A                    | N/A             | N/A          |
+//! | [`BTreeMap`]   | *O*(log(*n*))          | *O*(log(*n*))           | *O*(log(*n*))          | N/A               | N/A                    | *O*(log(*n*))   | *O*(*n*+*m*) |
+//!
+//! Note that where ties occur, [`Vec`] is generally going to be faster than
+//! [`VecDeque`], and [`VecDeque`] is generally going to be faster than
+//! [`LinkedList`].
+//!
+//! For Sets, all operations have the cost of the equivalent Map operation.
 //!
 //! # Correct and Efficient Usage of Collections
 //!

From 180eacea1c51610f6ddd550dc0dac5e33d313030 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 31 Aug 2024 22:18:30 +0200
Subject: [PATCH 10/20] these tests seem to work fine on i586 these days

---
 library/std/src/f32/tests.rs | 13 -------------
 library/std/src/f64/tests.rs | 13 -------------
 2 files changed, 26 deletions(-)

diff --git a/library/std/src/f32/tests.rs b/library/std/src/f32/tests.rs
index 3a4c1c120a495..99cfcfb231dad 100644
--- a/library/std/src/f32/tests.rs
+++ b/library/std/src/f32/tests.rs
@@ -2,31 +2,24 @@ use crate::f32::consts;
 use crate::num::{FpCategory as Fp, *};
 
 /// Smallest number
-#[allow(dead_code)] // unused on x86
 const TINY_BITS: u32 = 0x1;
 
 /// Next smallest number
-#[allow(dead_code)] // unused on x86
 const TINY_UP_BITS: u32 = 0x2;
 
 /// Exponent = 0b11...10, Sifnificand 0b1111..10. Min val > 0
-#[allow(dead_code)] // unused on x86
 const MAX_DOWN_BITS: u32 = 0x7f7f_fffe;
 
 /// Zeroed exponent, full significant
-#[allow(dead_code)] // unused on x86
 const LARGEST_SUBNORMAL_BITS: u32 = 0x007f_ffff;
 
 /// Exponent = 0b1, zeroed significand
-#[allow(dead_code)] // unused on x86
 const SMALLEST_NORMAL_BITS: u32 = 0x0080_0000;
 
 /// First pattern over the mantissa
-#[allow(dead_code)] // unused on x86
 const NAN_MASK1: u32 = 0x002a_aaaa;
 
 /// Second pattern over the mantissa
-#[allow(dead_code)] // unused on x86
 const NAN_MASK2: u32 = 0x0055_5555;
 
 #[allow(unused_macros)]
@@ -353,9 +346,6 @@ fn test_is_sign_negative() {
     assert!((-f32::NAN).is_sign_negative());
 }
 
-// Ignore test on x87 floating point, these platforms do not guarantee NaN
-// payloads are preserved and flush denormals to zero, failing the tests.
-#[cfg(not(target_arch = "x86"))]
 #[test]
 fn test_next_up() {
     let tiny = f32::from_bits(TINY_BITS);
@@ -386,9 +376,6 @@ fn test_next_up() {
     assert_f32_biteq!(nan2.next_up(), nan2);
 }
 
-// Ignore test on x87 floating point, these platforms do not guarantee NaN
-// payloads are preserved and flush denormals to zero, failing the tests.
-#[cfg(not(target_arch = "x86"))]
 #[test]
 fn test_next_down() {
     let tiny = f32::from_bits(TINY_BITS);
diff --git a/library/std/src/f64/tests.rs b/library/std/src/f64/tests.rs
index bac8405f97361..3fac2efe0d76c 100644
--- a/library/std/src/f64/tests.rs
+++ b/library/std/src/f64/tests.rs
@@ -2,31 +2,24 @@ use crate::f64::consts;
 use crate::num::{FpCategory as Fp, *};
 
 /// Smallest number
-#[allow(dead_code)] // unused on x86
 const TINY_BITS: u64 = 0x1;
 
 /// Next smallest number
-#[allow(dead_code)] // unused on x86
 const TINY_UP_BITS: u64 = 0x2;
 
 /// Exponent = 0b11...10, Sifnificand 0b1111..10. Min val > 0
-#[allow(dead_code)] // unused on x86
 const MAX_DOWN_BITS: u64 = 0x7fef_ffff_ffff_fffe;
 
 /// Zeroed exponent, full significant
-#[allow(dead_code)] // unused on x86
 const LARGEST_SUBNORMAL_BITS: u64 = 0x000f_ffff_ffff_ffff;
 
 /// Exponent = 0b1, zeroed significand
-#[allow(dead_code)] // unused on x86
 const SMALLEST_NORMAL_BITS: u64 = 0x0010_0000_0000_0000;
 
 /// First pattern over the mantissa
-#[allow(dead_code)] // unused on x86
 const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 
 /// Second pattern over the mantissa
-#[allow(dead_code)] // unused on x86
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
 #[allow(unused_macros)]
@@ -343,9 +336,6 @@ fn test_is_sign_negative() {
     assert!((-f64::NAN).is_sign_negative());
 }
 
-// Ignore test on x87 floating point, these platforms do not guarantee NaN
-// payloads are preserved and flush denormals to zero, failing the tests.
-#[cfg(not(target_arch = "x86"))]
 #[test]
 fn test_next_up() {
     let tiny = f64::from_bits(TINY_BITS);
@@ -375,9 +365,6 @@ fn test_next_up() {
     assert_f64_biteq!(nan2.next_up(), nan2);
 }
 
-// Ignore test on x87 floating point, these platforms do not guarantee NaN
-// payloads are preserved and flush denormals to zero, failing the tests.
-#[cfg(not(target_arch = "x86"))]
 #[test]
 fn test_next_down() {
     let tiny = f64::from_bits(TINY_BITS);

From c40ee79b849daee16f3ab07a5e2bae409d40aca1 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Tue, 10 Sep 2024 16:05:37 -0700
Subject: [PATCH 11/20] move float tests into their own dir

---
 .../const-float-classify.rs => float/classify-runtime-const.rs}   | 0
 .../classify-runtime-const.stderr}                                | 0
 .../const-float-bits-conv.rs => float/conv-bits-runtime-const.rs} | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{consts/const-float-classify.rs => float/classify-runtime-const.rs} (100%)
 rename tests/ui/{consts/const-float-classify.stderr => float/classify-runtime-const.stderr} (100%)
 rename tests/ui/{consts/const-float-bits-conv.rs => float/conv-bits-runtime-const.rs} (100%)

diff --git a/tests/ui/consts/const-float-classify.rs b/tests/ui/float/classify-runtime-const.rs
similarity index 100%
rename from tests/ui/consts/const-float-classify.rs
rename to tests/ui/float/classify-runtime-const.rs
diff --git a/tests/ui/consts/const-float-classify.stderr b/tests/ui/float/classify-runtime-const.stderr
similarity index 100%
rename from tests/ui/consts/const-float-classify.stderr
rename to tests/ui/float/classify-runtime-const.stderr
diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/float/conv-bits-runtime-const.rs
similarity index 100%
rename from tests/ui/consts/const-float-bits-conv.rs
rename to tests/ui/float/conv-bits-runtime-const.rs

From 3daa9518d5234d0768ba8ea81fd19c372ab98445 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 31 Aug 2024 22:23:13 +0200
Subject: [PATCH 12/20] enable and extend float-classify test

---
 tests/ui/float/classify-runtime-const.rs     |  74 ++++----
 tests/ui/float/classify-runtime-const.stderr |  11 --
 tests/ui/float/conv-bits-runtime-const.rs    | 169 ++++++++++---------
 3 files changed, 128 insertions(+), 126 deletions(-)
 delete mode 100644 tests/ui/float/classify-runtime-const.stderr

diff --git a/tests/ui/float/classify-runtime-const.rs b/tests/ui/float/classify-runtime-const.rs
index 6e5097f7f2b9c..59a232c255e8d 100644
--- a/tests/ui/float/classify-runtime-const.rs
+++ b/tests/ui/float/classify-runtime-const.rs
@@ -1,40 +1,46 @@
 //@ compile-flags: -Zmir-opt-level=0 -Znext-solver
-//@ known-bug: #110395
-// FIXME(effects) run-pass
+//@ run-pass
+// ignore-tidy-linelength
 
+// This tests the float classification functions, for regular runtime code and for const evaluation.
+
+#![feature(f16_const)]
+#![feature(f128_const)]
 #![feature(const_float_classify)]
-#![feature(const_trait_impl, effects)]
-#![allow(incomplete_features)]
 
-// Don't promote
-const fn nop<T>(x: T) -> T { x }
+use std::hint::black_box;
+use std::num::FpCategory::*;
 
-impl const PartialEq<NonDet> for bool {
-    fn eq(&self, _: &NonDet) -> bool {
-        true
-    }
-}
-
-macro_rules! const_assert {
-    ($a:expr, $b:expr) => {
+macro_rules! both_assert {
+    ($a:expr, NonDet) => {
         {
-            const _: () = assert!($a == $b);
-            assert!(nop($a) == nop($b));
+            // Compute `a`, but do not compare with anything as the result is non-deterministic.
+            const _: () = { let _val = $a; };
+            // `black_box` prevents promotion, and MIR opts are disabled above, so this is truly
+            // going through LLVM.
+            let _val = black_box($a);
+        }
+    };
+    ($a:expr, $b:ident) => {
+        {
+            const _: () = assert!(matches!($a, $b));
+            assert!(black_box($a) == black_box($b));
         }
     };
 }
 
 macro_rules! suite {
-    ( $( $tt:tt )* ) => {
+    ( $tyname:ident: $( $tt:tt )* ) => {
         fn f32() {
+            type $tyname = f32;
             suite_inner!(f32 $($tt)*);
         }
 
         fn f64() {
+            type $tyname = f64;
             suite_inner!(f64 $($tt)*);
         }
     }
-
 }
 
 macro_rules! suite_inner {
@@ -44,33 +50,33 @@ macro_rules! suite_inner {
 
         $( $tail:tt )*
     ) => {
-        $( const_assert!($ty::$fn($val), $out); )*
+        $( both_assert!($ty::$fn($val), $out); )*
         suite_inner!($ty [$($fn),*] $($tail)*)
     };
 
     ( $ty:ident [$( $fn:ident ),*]) => {};
 }
 
-#[derive(Debug)]
-struct NonDet;
-
-// The result of the `is_sign` methods are not checked for correctness, since LLVM does not
+// The result of the `is_sign` methods are not checked for correctness, since we do not
 // guarantee anything about the signedness of NaNs. See
-// https://github.com/rust-lang/rust/issues/55131.
+// https://rust-lang.github.io/rfcs/3514-float-semantics.html.
 
-suite! {
-                   [is_nan, is_infinite, is_finite, is_normal, is_sign_positive, is_sign_negative]
-     -0.0 / 0.0 => [  true,       false,     false,     false,           NonDet,           NonDet]
-      0.0 / 0.0 => [  true,       false,     false,     false,           NonDet,           NonDet]
-            1.0 => [ false,       false,      true,      true,             true,            false]
-           -1.0 => [ false,       false,      true,      true,            false,             true]
-            0.0 => [ false,       false,      true,     false,             true,            false]
-           -0.0 => [ false,       false,      true,     false,            false,             true]
-      1.0 / 0.0 => [ false,        true,     false,     false,             true,            false]
-     -1.0 / 0.0 => [ false,        true,     false,     false,            false,             true]
+suite! { T: // type alias for the type we are testing
+                   [ classify, is_nan, is_infinite, is_finite, is_normal, is_sign_positive, is_sign_negative]
+     -0.0 / 0.0 => [      Nan,   true,       false,     false,     false,           NonDet,           NonDet]
+      0.0 / 0.0 => [      Nan,   true,       false,     false,     false,           NonDet,           NonDet]
+            1.0 => [   Normal,  false,       false,      true,      true,             true,            false]
+           -1.0 => [   Normal,  false,       false,      true,      true,            false,             true]
+            0.0 => [     Zero,  false,       false,      true,     false,             true,            false]
+           -0.0 => [     Zero,  false,       false,      true,     false,            false,             true]
+      1.0 / 0.0 => [ Infinite,  false,        true,     false,     false,             true,            false]
+     -1.0 / 0.0 => [ Infinite,  false,        true,     false,     false,            false,             true]
+   1.0 / T::MAX => [Subnormal,  false,       false,      true,     false,             true,            false]
+  -1.0 / T::MAX => [Subnormal,  false,       false,      true,     false,            false,             true]
 }
 
 fn main() {
     f32();
     f64();
+    // FIXME(f16_f128): also test f16 and f128
 }
diff --git a/tests/ui/float/classify-runtime-const.stderr b/tests/ui/float/classify-runtime-const.stderr
deleted file mode 100644
index a35de8ad0eabd..0000000000000
--- a/tests/ui/float/classify-runtime-const.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
-  --> $DIR/const-float-classify.rs:12:12
-   |
-LL | impl const PartialEq<NonDet> for bool {
-   |            ^^^^^^^^^^^^^^^^^
-   |
-   = 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: aborting due to 1 previous error
-
diff --git a/tests/ui/float/conv-bits-runtime-const.rs b/tests/ui/float/conv-bits-runtime-const.rs
index 869498d107612..e85a889d2c240 100644
--- a/tests/ui/float/conv-bits-runtime-const.rs
+++ b/tests/ui/float/conv-bits-runtime-const.rs
@@ -1,49 +1,55 @@
 //@ compile-flags: -Zmir-opt-level=0
 //@ run-pass
 
+// This tests the float classification functions, for regular runtime code and for const evaluation.
+
 #![feature(const_float_classify)]
-#![feature(f16, f16_const)]
-#![feature(f128, f128_const)]
+#![feature(f16)]
+#![feature(f128)]
+#![feature(f16_const)]
+#![feature(f128_const)]
 #![allow(unused_macro_rules)]
-// Don't promote
-const fn nop<T>(x: T) -> T { x }
 
-macro_rules! const_assert {
+use std::hint::black_box;
+
+macro_rules! both_assert {
     ($a:expr) => {
         {
             const _: () = assert!($a);
-            assert!(nop($a));
+            // `black_box` prevents promotion, and MIR opts are disabled above, so this is truly
+            // going through LLVM.
+            assert!(black_box($a));
         }
     };
     ($a:expr, $b:expr) => {
         {
             const _: () = assert!($a == $b);
-            assert_eq!(nop($a), nop($b));
+            assert_eq!(black_box($a), black_box($b));
         }
     };
 }
 
 fn has_broken_floats() -> bool {
     // i586 targets are broken due to <https://github.com/rust-lang/rust/issues/114479>.
-    std::env::var("TARGET").is_ok_and(|v| v.contains("i586"))
+    cfg!(all(target_arch = "x86", not(target_feature = "sse2")))
 }
 
 #[cfg(target_arch = "x86_64")]
 fn f16(){
-    const_assert!((1f16).to_bits(), 0x3c00);
-    const_assert!(u16::from_be_bytes(1f16.to_be_bytes()), 0x3c00);
-    const_assert!((12.5f16).to_bits(), 0x4a40);
-    const_assert!(u16::from_le_bytes(12.5f16.to_le_bytes()), 0x4a40);
-    const_assert!((1337f16).to_bits(), 0x6539);
-    const_assert!(u16::from_ne_bytes(1337f16.to_ne_bytes()), 0x6539);
-    const_assert!((-14.25f16).to_bits(), 0xcb20);
-    const_assert!(f16::from_bits(0x3c00), 1.0);
-    const_assert!(f16::from_be_bytes(0x3c00u16.to_be_bytes()), 1.0);
-    const_assert!(f16::from_bits(0x4a40), 12.5);
-    const_assert!(f16::from_le_bytes(0x4a40u16.to_le_bytes()), 12.5);
-    const_assert!(f16::from_bits(0x5be0), 252.0);
-    const_assert!(f16::from_ne_bytes(0x5be0u16.to_ne_bytes()), 252.0);
-    const_assert!(f16::from_bits(0xcb20), -14.25);
+    both_assert!((1f16).to_bits(), 0x3c00);
+    both_assert!(u16::from_be_bytes(1f16.to_be_bytes()), 0x3c00);
+    both_assert!((12.5f16).to_bits(), 0x4a40);
+    both_assert!(u16::from_le_bytes(12.5f16.to_le_bytes()), 0x4a40);
+    both_assert!((1337f16).to_bits(), 0x6539);
+    both_assert!(u16::from_ne_bytes(1337f16.to_ne_bytes()), 0x6539);
+    both_assert!((-14.25f16).to_bits(), 0xcb20);
+    both_assert!(f16::from_bits(0x3c00), 1.0);
+    both_assert!(f16::from_be_bytes(0x3c00u16.to_be_bytes()), 1.0);
+    both_assert!(f16::from_bits(0x4a40), 12.5);
+    both_assert!(f16::from_le_bytes(0x4a40u16.to_le_bytes()), 12.5);
+    both_assert!(f16::from_bits(0x5be0), 252.0);
+    both_assert!(f16::from_ne_bytes(0x5be0u16.to_ne_bytes()), 252.0);
+    both_assert!(f16::from_bits(0xcb20), -14.25);
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
@@ -51,29 +57,29 @@ fn f16(){
     const QUIET_NAN: u16 = f16::NAN.to_bits() ^ 0x0155;
     const SIGNALING_NAN: u16 = f16::NAN.to_bits() ^ 0x02AA;
 
-    const_assert!(f16::from_bits(QUIET_NAN).is_nan());
-    const_assert!(f16::from_bits(SIGNALING_NAN).is_nan());
-    const_assert!(f16::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
+    both_assert!(f16::from_bits(QUIET_NAN).is_nan());
+    both_assert!(f16::from_bits(SIGNALING_NAN).is_nan());
+    both_assert!(f16::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
     if !has_broken_floats() {
-        const_assert!(f16::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
+        both_assert!(f16::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
     }
 }
 
 fn f32() {
-    const_assert!((1f32).to_bits(), 0x3f800000);
-    const_assert!(u32::from_be_bytes(1f32.to_be_bytes()), 0x3f800000);
-    const_assert!((12.5f32).to_bits(), 0x41480000);
-    const_assert!(u32::from_le_bytes(12.5f32.to_le_bytes()), 0x41480000);
-    const_assert!((1337f32).to_bits(), 0x44a72000);
-    const_assert!(u32::from_ne_bytes(1337f32.to_ne_bytes()), 0x44a72000);
-    const_assert!((-14.25f32).to_bits(), 0xc1640000);
-    const_assert!(f32::from_bits(0x3f800000), 1.0);
-    const_assert!(f32::from_be_bytes(0x3f800000u32.to_be_bytes()), 1.0);
-    const_assert!(f32::from_bits(0x41480000), 12.5);
-    const_assert!(f32::from_le_bytes(0x41480000u32.to_le_bytes()), 12.5);
-    const_assert!(f32::from_bits(0x44a72000), 1337.0);
-    const_assert!(f32::from_ne_bytes(0x44a72000u32.to_ne_bytes()), 1337.0);
-    const_assert!(f32::from_bits(0xc1640000), -14.25);
+    both_assert!((1f32).to_bits(), 0x3f800000);
+    both_assert!(u32::from_be_bytes(1f32.to_be_bytes()), 0x3f800000);
+    both_assert!((12.5f32).to_bits(), 0x41480000);
+    both_assert!(u32::from_le_bytes(12.5f32.to_le_bytes()), 0x41480000);
+    both_assert!((1337f32).to_bits(), 0x44a72000);
+    both_assert!(u32::from_ne_bytes(1337f32.to_ne_bytes()), 0x44a72000);
+    both_assert!((-14.25f32).to_bits(), 0xc1640000);
+    both_assert!(f32::from_bits(0x3f800000), 1.0);
+    both_assert!(f32::from_be_bytes(0x3f800000u32.to_be_bytes()), 1.0);
+    both_assert!(f32::from_bits(0x41480000), 12.5);
+    both_assert!(f32::from_le_bytes(0x41480000u32.to_le_bytes()), 12.5);
+    both_assert!(f32::from_bits(0x44a72000), 1337.0);
+    both_assert!(f32::from_ne_bytes(0x44a72000u32.to_ne_bytes()), 1337.0);
+    both_assert!(f32::from_bits(0xc1640000), -14.25);
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
@@ -81,29 +87,29 @@ fn f32() {
     const QUIET_NAN: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
     const SIGNALING_NAN: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
 
-    const_assert!(f32::from_bits(QUIET_NAN).is_nan());
-    const_assert!(f32::from_bits(SIGNALING_NAN).is_nan());
-    const_assert!(f32::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
+    both_assert!(f32::from_bits(QUIET_NAN).is_nan());
+    both_assert!(f32::from_bits(SIGNALING_NAN).is_nan());
+    both_assert!(f32::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
     if !has_broken_floats() {
-        const_assert!(f32::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
+        both_assert!(f32::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
     }
 }
 
 fn f64() {
-    const_assert!((1f64).to_bits(), 0x3ff0000000000000);
-    const_assert!(u64::from_be_bytes(1f64.to_be_bytes()), 0x3ff0000000000000);
-    const_assert!((12.5f64).to_bits(), 0x4029000000000000);
-    const_assert!(u64::from_le_bytes(12.5f64.to_le_bytes()), 0x4029000000000000);
-    const_assert!((1337f64).to_bits(), 0x4094e40000000000);
-    const_assert!(u64::from_ne_bytes(1337f64.to_ne_bytes()), 0x4094e40000000000);
-    const_assert!((-14.25f64).to_bits(), 0xc02c800000000000);
-    const_assert!(f64::from_bits(0x3ff0000000000000), 1.0);
-    const_assert!(f64::from_be_bytes(0x3ff0000000000000u64.to_be_bytes()), 1.0);
-    const_assert!(f64::from_bits(0x4029000000000000), 12.5);
-    const_assert!(f64::from_le_bytes(0x4029000000000000u64.to_le_bytes()), 12.5);
-    const_assert!(f64::from_bits(0x4094e40000000000), 1337.0);
-    const_assert!(f64::from_ne_bytes(0x4094e40000000000u64.to_ne_bytes()), 1337.0);
-    const_assert!(f64::from_bits(0xc02c800000000000), -14.25);
+    both_assert!((1f64).to_bits(), 0x3ff0000000000000);
+    both_assert!(u64::from_be_bytes(1f64.to_be_bytes()), 0x3ff0000000000000);
+    both_assert!((12.5f64).to_bits(), 0x4029000000000000);
+    both_assert!(u64::from_le_bytes(12.5f64.to_le_bytes()), 0x4029000000000000);
+    both_assert!((1337f64).to_bits(), 0x4094e40000000000);
+    both_assert!(u64::from_ne_bytes(1337f64.to_ne_bytes()), 0x4094e40000000000);
+    both_assert!((-14.25f64).to_bits(), 0xc02c800000000000);
+    both_assert!(f64::from_bits(0x3ff0000000000000), 1.0);
+    both_assert!(f64::from_be_bytes(0x3ff0000000000000u64.to_be_bytes()), 1.0);
+    both_assert!(f64::from_bits(0x4029000000000000), 12.5);
+    both_assert!(f64::from_le_bytes(0x4029000000000000u64.to_le_bytes()), 12.5);
+    both_assert!(f64::from_bits(0x4094e40000000000), 1337.0);
+    both_assert!(f64::from_ne_bytes(0x4094e40000000000u64.to_ne_bytes()), 1337.0);
+    both_assert!(f64::from_bits(0xc02c800000000000), -14.25);
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
@@ -111,30 +117,30 @@ fn f64() {
     const QUIET_NAN: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
     const SIGNALING_NAN: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
 
-    const_assert!(f64::from_bits(QUIET_NAN).is_nan());
-    const_assert!(f64::from_bits(SIGNALING_NAN).is_nan());
-    const_assert!(f64::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
+    both_assert!(f64::from_bits(QUIET_NAN).is_nan());
+    both_assert!(f64::from_bits(SIGNALING_NAN).is_nan());
+    both_assert!(f64::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
     if !has_broken_floats() {
-        const_assert!(f64::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
+        both_assert!(f64::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
     }
 }
 
 #[cfg(target_arch = "x86_64")]
 fn f128() {
-    const_assert!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
-    const_assert!(u128::from_be_bytes(1f128.to_be_bytes()), 0x3fff0000000000000000000000000000);
-    const_assert!((12.5f128).to_bits(), 0x40029000000000000000000000000000);
-    const_assert!(u128::from_le_bytes(12.5f128.to_le_bytes()), 0x40029000000000000000000000000000);
-    const_assert!((1337f128).to_bits(), 0x40094e40000000000000000000000000);
-    const_assert!(u128::from_ne_bytes(1337f128.to_ne_bytes()), 0x40094e40000000000000000000000000);
-    const_assert!((-14.25f128).to_bits(), 0xc002c800000000000000000000000000);
-    const_assert!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0);
-    const_assert!(f128::from_be_bytes(0x3fff0000000000000000000000000000u128.to_be_bytes()), 1.0);
-    const_assert!(f128::from_bits(0x40029000000000000000000000000000), 12.5);
-    const_assert!(f128::from_le_bytes(0x40029000000000000000000000000000u128.to_le_bytes()), 12.5);
-    const_assert!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0);
+    both_assert!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
+    both_assert!(u128::from_be_bytes(1f128.to_be_bytes()), 0x3fff0000000000000000000000000000);
+    both_assert!((12.5f128).to_bits(), 0x40029000000000000000000000000000);
+    both_assert!(u128::from_le_bytes(12.5f128.to_le_bytes()), 0x40029000000000000000000000000000);
+    both_assert!((1337f128).to_bits(), 0x40094e40000000000000000000000000);
+    both_assert!(u128::from_ne_bytes(1337f128.to_ne_bytes()), 0x40094e40000000000000000000000000);
+    both_assert!((-14.25f128).to_bits(), 0xc002c800000000000000000000000000);
+    both_assert!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0);
+    both_assert!(f128::from_be_bytes(0x3fff0000000000000000000000000000u128.to_be_bytes()), 1.0);
+    both_assert!(f128::from_bits(0x40029000000000000000000000000000), 12.5);
+    both_assert!(f128::from_le_bytes(0x40029000000000000000000000000000u128.to_le_bytes()), 12.5);
+    both_assert!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0);
     assert_eq!(f128::from_ne_bytes(0x40094e40000000000000000000000000u128.to_ne_bytes()), 1337.0);
-    const_assert!(f128::from_bits(0xc002c800000000000000000000000000), -14.25);
+    both_assert!(f128::from_bits(0xc002c800000000000000000000000000), -14.25);
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
@@ -142,20 +148,21 @@ fn f128() {
     const QUIET_NAN: u128 = f128::NAN.to_bits() | 0x0000_AAAA_AAAA_AAAA_AAAA_AAAA_AAAA_AAAA;
     const SIGNALING_NAN: u128 = f128::NAN.to_bits() ^ 0x0000_5555_5555_5555_5555_5555_5555_5555;
 
-    const_assert!(f128::from_bits(QUIET_NAN).is_nan());
-    const_assert!(f128::from_bits(SIGNALING_NAN).is_nan());
-    const_assert!(f128::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
+    both_assert!(f128::from_bits(QUIET_NAN).is_nan());
+    both_assert!(f128::from_bits(SIGNALING_NAN).is_nan());
+    both_assert!(f128::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
     if !has_broken_floats() {
-        const_assert!(f128::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
+        both_assert!(f128::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
     }
 }
 
 fn main() {
+    f32();
+    f64();
+
     #[cfg(target_arch = "x86_64")]
     {
         f16();
         f128();
     }
-    f32();
-    f64();
 }

From e556c136f3a4e5ff36afa248a6dd0e2cc9ddaced Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 31 Aug 2024 22:28:17 +0200
Subject: [PATCH 13/20] clean up internal comments about float semantics

- remove an outdated FIXME
- add reference to floating-point semantics issue

Co-authored-by: Jubilee <workingjubilee@gmail.com>
---
 library/core/src/num/f16.rs                 | 1 +
 library/core/src/num/f32.rs                 | 5 +----
 library/core/src/num/f64.rs                 | 5 +----
 tests/ui/numbers-arithmetic/issue-105626.rs | 1 +
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 9252e8c601558..da92da1086dab 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -435,6 +435,7 @@ impl f16 {
         // WASM, see llvm/llvm-project#96437). These are platforms bugs, and Rust will misbehave on
         // such platforms, but we can at least try to make things seem as sane as possible by being
         // careful here.
+        // see also https://github.com/rust-lang/rust/issues/114479
         if self.is_infinite() {
             // Thus, a value may compare unequal to infinity, despite having a "full" exponent mask.
             FpCategory::Infinite
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index 2bc897224970d..885f7608a337e 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -662,10 +662,7 @@ impl f32 {
         // hardware flushes subnormals to zero. These are platforms bugs, and Rust will misbehave on
         // such hardware, but we can at least try to make things seem as sane as possible by being
         // careful here.
-        //
-        // FIXME(jubilee): Using x87 operations is never necessary in order to function
-        // on x86 processors for Rust-to-Rust calls, so this issue should not happen.
-        // Code generation should be adjusted to use non-C calling conventions, avoiding this.
+        // see also https://github.com/rust-lang/rust/issues/114479
         if self.is_infinite() {
             // A value may compare unequal to infinity, despite having a "full" exponent mask.
             FpCategory::Infinite
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index b3f5be9fc8a46..28cc231ccc76d 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -660,10 +660,7 @@ impl f64 {
         // float semantics Rust relies on: x87 uses a too-large exponent, and some hardware flushes
         // subnormals to zero. These are platforms bugs, and Rust will misbehave on such hardware,
         // but we can at least try to make things seem as sane as possible by being careful here.
-        //
-        // FIXME(jubilee): Using x87 operations is never necessary in order to function
-        // on x86 processors for Rust-to-Rust calls, so this issue should not happen.
-        // Code generation should be adjusted to use non-C calling conventions, avoiding this.
+        // see also https://github.com/rust-lang/rust/issues/114479
         //
         // Thus, a value may compare unequal to infinity, despite having a "full" exponent mask.
         // And it may not be NaN, as it can simply be an "overextended" finite value.
diff --git a/tests/ui/numbers-arithmetic/issue-105626.rs b/tests/ui/numbers-arithmetic/issue-105626.rs
index f942cf1283d0d..8d4a7c308e7fe 100644
--- a/tests/ui/numbers-arithmetic/issue-105626.rs
+++ b/tests/ui/numbers-arithmetic/issue-105626.rs
@@ -11,6 +11,7 @@ fn main() {
     assert_ne!((n as f64) as f32, n as f32);
 
     // FIXME: these assertions fail if only x87 is enabled
+    // see also https://github.com/rust-lang/rust/issues/114479
     assert_eq!(n as i64 as f32, r);
     assert_eq!(n as u64 as f32, r);
 }

From b44f1dd758b01d6be035e24b7dac3b6ba0bda66d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 28 Aug 2024 16:02:59 +0200
Subject: [PATCH 14/20] update stdarch

---
 library/stdarch | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/stdarch b/library/stdarch
index d9466edb4c53c..ace72223a0e32 160000
--- a/library/stdarch
+++ b/library/stdarch
@@ -1 +1 @@
-Subproject commit d9466edb4c53cece8686ee6e17b028436ddf4151
+Subproject commit ace72223a0e321c1b0a37b5862aa756fe8ab5111

From 542a6c67aef7cf5fa234e5d8134b88cffb9a3c36 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 11 Sep 2024 11:18:35 +0200
Subject: [PATCH 15/20] miri: support vector index arguments in simd_shuffle

---
 src/tools/miri/src/intrinsics/simd.rs             | 15 ++++++---------
 .../miri/tests/pass/intrinsics/portable-simd.rs   |  8 ++++++++
 .../simd-intrinsic-generic-elements.rs            |  0
 3 files changed, 14 insertions(+), 9 deletions(-)
 rename src/tools/miri/tests/pass/{ => intrinsics}/simd-intrinsic-generic-elements.rs (100%)

diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index a5afd029b6519..85d7459bb4595 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -666,22 +666,19 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let (right, right_len) = this.operand_to_simd(right)?;
                 let (dest, dest_len) = this.mplace_to_simd(dest)?;
 
-                // `index` is an array, not a SIMD type
-                let ty::Array(_, index_len) = index.layout.ty.kind() else {
-                    span_bug!(
-                        this.cur_span(),
-                        "simd_shuffle index argument has non-array type {}",
-                        index.layout.ty
-                    )
+                // `index` is an array or a SIMD type
+                let (index, index_len) = match index.layout.ty.kind() {
+                    // FIXME: remove this once `index` must always be a SIMD vector.
+                    ty::Array(..) => (index.assert_mem_place(), index.len(this)?),
+                    _ => this.operand_to_simd(index)?,
                 };
-                let index_len = index_len.eval_target_usize(*this.tcx, this.param_env());
 
                 assert_eq!(left_len, right_len);
                 assert_eq!(index_len, dest_len);
 
                 for i in 0..dest_len {
                     let src_index: u64 = this
-                        .read_immediate(&this.project_index(index, i)?)?
+                        .read_immediate(&this.project_index(&index, i)?)?
                         .to_scalar()
                         .to_u32()?
                         .into();
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index c4ba11d0a436f..daf75fee8fe13 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -620,6 +620,10 @@ fn simd_intrinsics() {
         );
         assert_eq!(simd_shuffle_generic::<_, i32x4, { &[3, 1, 0, 2] }>(a, b), a,);
         assert_eq!(simd_shuffle::<_, _, i32x4>(a, b, const { [3u32, 1, 0, 2] }), a,);
+        assert_eq!(
+            simd_shuffle::<_, _, i32x4>(a, b, const { u32x4::from_array([3u32, 1, 0, 2]) }),
+            a,
+        );
         assert_eq!(
             simd_shuffle_generic::<_, i32x4, { &[7, 5, 4, 6] }>(a, b),
             i32x4::from_array([4, 2, 1, 10]),
@@ -628,6 +632,10 @@ fn simd_intrinsics() {
             simd_shuffle::<_, _, i32x4>(a, b, const { [7u32, 5, 4, 6] }),
             i32x4::from_array([4, 2, 1, 10]),
         );
+        assert_eq!(
+            simd_shuffle::<_, _, i32x4>(a, b, const { u32x4::from_array([7u32, 5, 4, 6]) }),
+            i32x4::from_array([4, 2, 1, 10]),
+        );
     }
 }
 
diff --git a/src/tools/miri/tests/pass/simd-intrinsic-generic-elements.rs b/src/tools/miri/tests/pass/intrinsics/simd-intrinsic-generic-elements.rs
similarity index 100%
rename from src/tools/miri/tests/pass/simd-intrinsic-generic-elements.rs
rename to src/tools/miri/tests/pass/intrinsics/simd-intrinsic-generic-elements.rs

From 6eddbb704ee4d80f18e6359c027e9f249ad2a7ae Mon Sep 17 00:00:00 2001
From: Olivier Goffart <olivier.goffart@slint.dev>
Date: Wed, 11 Sep 2024 10:35:02 +0200
Subject: [PATCH 16/20] Fix false positive with `missing_docs` and `#[test]`

Since #130025, the compiler don't ignore missing_docs when compiling the tests.
But there is now a false positive warning for every `#[test]`

For example, this code
```rust
//! Crate docs

fn just_a_test() {}
```

Would emit this warning when running `cargo test`

```
warning: missing documentation for a constant
 --> src/lib.rs:5:1
  |
4 | #[test]
  | ------- in this procedural macro expansion
5 | fn just_a_test() {}
  | ^^^^^^^^^^^^^^^^^^^
```
---
 compiler/rustc_builtin_macros/src/test.rs | 2 ++
 tests/pretty/tests-are-sorted.pp          | 3 +++
 tests/ui/lint/lint-missing-doc-test.rs    | 3 +++
 3 files changed, 8 insertions(+)

diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index 1b76a5f3234a2..ab3517d362721 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -277,6 +277,8 @@ pub(crate) fn expand_test_or_bench(
                 cx.attr_nested_word(sym::cfg, sym::test, attr_sp),
                 // #[rustc_test_marker = "test_case_sort_key"]
                 cx.attr_name_value_str(sym::rustc_test_marker, test_path_symbol, attr_sp),
+                // #[allow(missing_docs)]
+                cx.attr_nested_word(sym::allow, sym::missing_docs, attr_sp),
             ],
             // const $ident: test::TestDescAndFn =
             ast::ItemKind::Const(
diff --git a/tests/pretty/tests-are-sorted.pp b/tests/pretty/tests-are-sorted.pp
index a4b15dde4530e..0a31c3fc1b58f 100644
--- a/tests/pretty/tests-are-sorted.pp
+++ b/tests/pretty/tests-are-sorted.pp
@@ -12,6 +12,7 @@
 extern crate test;
 #[cfg(test)]
 #[rustc_test_marker = "m_test"]
+#[allow(missing_docs)]
 pub const m_test: test::TestDescAndFn =
     test::TestDescAndFn {
         desc: test::TestDesc {
@@ -36,6 +37,7 @@
 extern crate test;
 #[cfg(test)]
 #[rustc_test_marker = "z_test"]
+#[allow(missing_docs)]
 pub const z_test: test::TestDescAndFn =
     test::TestDescAndFn {
         desc: test::TestDesc {
@@ -61,6 +63,7 @@
 extern crate test;
 #[cfg(test)]
 #[rustc_test_marker = "a_test"]
+#[allow(missing_docs)]
 pub const a_test: test::TestDescAndFn =
     test::TestDescAndFn {
         desc: test::TestDesc {
diff --git a/tests/ui/lint/lint-missing-doc-test.rs b/tests/ui/lint/lint-missing-doc-test.rs
index 93d4e4a44e928..466b79c0fb949 100644
--- a/tests/ui/lint/lint-missing-doc-test.rs
+++ b/tests/ui/lint/lint-missing-doc-test.rs
@@ -3,3 +3,6 @@
 
 //@ check-pass
 //@ compile-flags: --test -Dmissing_docs
+
+#[test]
+fn test() {}

From 9566163364a91678006a2b22d62d2a73a6012ff5 Mon Sep 17 00:00:00 2001
From: Vetle Rasmussen <vetle.rasmussen@muybridge.com>
Date: Wed, 11 Sep 2024 11:40:01 +0200
Subject: [PATCH 17/20] Make SearchPath::new public

---
 compiler/rustc_session/src/search_paths.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_session/src/search_paths.rs b/compiler/rustc_session/src/search_paths.rs
index d65b1b8b3f15a..b212f6afa1717 100644
--- a/compiler/rustc_session/src/search_paths.rs
+++ b/compiler/rustc_session/src/search_paths.rs
@@ -96,7 +96,7 @@ impl SearchPath {
         Self::new(PathKind::All, make_target_lib_path(sysroot, triple))
     }
 
-    fn new(kind: PathKind, dir: PathBuf) -> Self {
+    pub fn new(kind: PathKind, dir: PathBuf) -> Self {
         // Get the files within the directory.
         let files = match std::fs::read_dir(&dir) {
             Ok(files) => files

From 5d456dfaa1a712f1b1619c3b5a6f725776d5f101 Mon Sep 17 00:00:00 2001
From: Olivier Goffart <olivier.goffart@slint.dev>
Date: Wed, 11 Sep 2024 11:49:27 +0200
Subject: [PATCH 18/20] Use `#[doc(hidden)]` instead of
 `#[allow(missing_docs)]` on the const generated for `#[test]`

---
 compiler/rustc_builtin_macros/src/test.rs | 4 ++--
 tests/pretty/tests-are-sorted.pp          | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index ab3517d362721..40dc75339efd7 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -277,8 +277,8 @@ pub(crate) fn expand_test_or_bench(
                 cx.attr_nested_word(sym::cfg, sym::test, attr_sp),
                 // #[rustc_test_marker = "test_case_sort_key"]
                 cx.attr_name_value_str(sym::rustc_test_marker, test_path_symbol, attr_sp),
-                // #[allow(missing_docs)]
-                cx.attr_nested_word(sym::allow, sym::missing_docs, attr_sp),
+                // #[doc(hidden)]
+                cx.attr_nested_word(sym::doc, sym::hidden, attr_sp),
             ],
             // const $ident: test::TestDescAndFn =
             ast::ItemKind::Const(
diff --git a/tests/pretty/tests-are-sorted.pp b/tests/pretty/tests-are-sorted.pp
index 0a31c3fc1b58f..d10368a89cbc7 100644
--- a/tests/pretty/tests-are-sorted.pp
+++ b/tests/pretty/tests-are-sorted.pp
@@ -12,7 +12,7 @@
 extern crate test;
 #[cfg(test)]
 #[rustc_test_marker = "m_test"]
-#[allow(missing_docs)]
+#[doc(hidden)]
 pub const m_test: test::TestDescAndFn =
     test::TestDescAndFn {
         desc: test::TestDesc {
@@ -37,7 +37,7 @@
 extern crate test;
 #[cfg(test)]
 #[rustc_test_marker = "z_test"]
-#[allow(missing_docs)]
+#[doc(hidden)]
 pub const z_test: test::TestDescAndFn =
     test::TestDescAndFn {
         desc: test::TestDesc {
@@ -63,7 +63,7 @@
 extern crate test;
 #[cfg(test)]
 #[rustc_test_marker = "a_test"]
-#[allow(missing_docs)]
+#[doc(hidden)]
 pub const a_test: test::TestDescAndFn =
     test::TestDescAndFn {
         desc: test::TestDesc {

From cc34d64c511feaf576854797fc291e03f5f275a7 Mon Sep 17 00:00:00 2001
From: Olivier Goffart <olivier.goffart@slint.dev>
Date: Wed, 11 Sep 2024 12:08:14 +0200
Subject: [PATCH 19/20] Use `doc(hidden)` instead of `allow(missing_docs)` in
 the test harness

So that it doesn't fail with `forbid(missing_docs)`

Fixes #130218
---
 compiler/rustc_builtin_macros/src/test_harness.rs | 6 +++---
 compiler/rustc_span/src/symbol.rs                 | 1 -
 tests/pretty/tests-are-sorted.pp                  | 2 +-
 tests/ui/lint/lint-missing-doc-test.rs            | 4 +++-
 4 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index a694d3b8c2857..400557ca260b2 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -326,8 +326,8 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
     let main_attr = ecx.attr_word(sym::rustc_main, sp);
     // #[coverage(off)]
     let coverage_attr = ecx.attr_nested_word(sym::coverage, sym::off, sp);
-    // #[allow(missing_docs)]
-    let missing_docs_attr = ecx.attr_nested_word(sym::allow, sym::missing_docs, sp);
+    // #[doc(hidden)]
+    let doc_hidden_attr = ecx.attr_nested_word(sym::doc, sym::hidden, sp);
 
     // pub fn main() { ... }
     let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(ThinVec::new()));
@@ -357,7 +357,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
 
     let main = P(ast::Item {
         ident: main_id,
-        attrs: thin_vec![main_attr, coverage_attr, missing_docs_attr],
+        attrs: thin_vec![main_attr, coverage_attr, doc_hidden_attr],
         id: ast::DUMMY_NODE_ID,
         kind: main,
         vis: ast::Visibility { span: sp, kind: ast::VisibilityKind::Public, tokens: None },
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index d5240a05310b6..28d18f2dfcc15 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1236,7 +1236,6 @@ symbols! {
         mir_unwind_unreachable,
         mir_variant,
         miri,
-        missing_docs,
         mmx_reg,
         modifiers,
         module,
diff --git a/tests/pretty/tests-are-sorted.pp b/tests/pretty/tests-are-sorted.pp
index d10368a89cbc7..31449b51dc3e1 100644
--- a/tests/pretty/tests-are-sorted.pp
+++ b/tests/pretty/tests-are-sorted.pp
@@ -86,7 +86,7 @@
 fn a_test() {}
 #[rustc_main]
 #[coverage(off)]
-#[allow(missing_docs)]
+#[doc(hidden)]
 pub fn main() -> () {
     extern crate test;
     test::test_main_static(&[&a_test, &m_test, &z_test])
diff --git a/tests/ui/lint/lint-missing-doc-test.rs b/tests/ui/lint/lint-missing-doc-test.rs
index 466b79c0fb949..d86ec3525df36 100644
--- a/tests/ui/lint/lint-missing-doc-test.rs
+++ b/tests/ui/lint/lint-missing-doc-test.rs
@@ -2,7 +2,9 @@
 //! on the generated test harness.
 
 //@ check-pass
-//@ compile-flags: --test -Dmissing_docs
+//@ compile-flags: --test
+
+#![forbid(missing_docs)]
 
 #[test]
 fn test() {}

From 41dc5d37501b8b2a2e0c720afd403a793215b448 Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Fri, 30 Aug 2024 04:48:05 +0800
Subject: [PATCH 20/20] Stabilize `const_refs_to_static`

---
 .../src/check_consts/check.rs                 |  1 -
 .../rustc_const_eval/src/check_consts/ops.rs  | 27 ------
 .../src/error_codes/E0013.md                  |  2 +-
 compiler/rustc_feature/src/accepted.rs        |  2 +
 compiler/rustc_feature/src/unstable.rs        |  2 -
 tests/ui/asm/const-refs-to-static.rs          |  2 -
 tests/ui/asm/const-refs-to-static.stderr      |  4 +-
 tests/ui/asm/x86_64/type-check-4.rs           |  9 +-
 tests/ui/asm/x86_64/type-check-4.stderr       | 39 +--------
 .../ui/consts/const-fn-not-safe-for-const.rs  |  2 -
 .../consts/const-fn-not-safe-for-const.stderr | 29 +------
 .../mut_ref_in_final_dynamic_check.rs         |  2 +-
 .../const-ref-to-static-linux-vtable.rs       |  4 +-
 .../consts/const_refs_to_static-ice-121413.rs |  1 -
 .../const_refs_to_static-ice-121413.stderr    |  8 +-
 tests/ui/consts/const_refs_to_static.rs       |  1 -
 tests/ui/consts/const_refs_to_static_fail.rs  |  2 +-
 .../const_refs_to_static_fail_invalid.rs      |  1 -
 .../const_refs_to_static_fail_invalid.stderr  | 12 +--
 .../ui/consts/issue-17718-const-bad-values.rs |  3 +-
 .../issue-17718-const-bad-values.stderr       | 14 +---
 tests/ui/consts/issue-17718-references.rs     | 11 ++-
 tests/ui/consts/issue-17718-references.stderr | 39 ---------
 tests/ui/consts/issue-52060.rs                |  3 +-
 tests/ui/consts/issue-52060.stderr            | 15 ----
 tests/ui/consts/min_const_fn/min_const_fn.rs  |  4 +-
 .../consts/min_const_fn/min_const_fn.stderr   | 26 +-----
 .../const_refers_to_static.stderr             | 25 ------
 .../const_refers_to_static_cross_crate.stderr | 25 +-----
 .../miri_unleashed/mutable_references.rs      |  9 +-
 .../miri_unleashed/mutable_references.stderr  | 83 ++++++++-----------
 .../feature-gate-const-refs-to-static.rs      | 11 ---
 .../feature-gate-const-refs-to-static.stderr  | 27 ------
 tests/ui/static/issue-18118-2.rs              |  8 +-
 tests/ui/static/issue-18118-2.stderr          | 15 ----
 tests/ui/statics/const_generics.rs            |  1 -
 tests/ui/statics/mutable_memory_validation.rs |  1 -
 .../statics/mutable_memory_validation.stderr  |  2 +-
 38 files changed, 86 insertions(+), 386 deletions(-)
 delete mode 100644 tests/ui/consts/issue-17718-references.stderr
 delete mode 100644 tests/ui/consts/issue-52060.stderr
 delete mode 100644 tests/ui/feature-gates/feature-gate-const-refs-to-static.rs
 delete mode 100644 tests/ui/feature-gates/feature-gate-const-refs-to-static.stderr
 delete mode 100644 tests/ui/static/issue-18118-2.stderr

diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 8be327a8b5647..529979de79414 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -355,7 +355,6 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
         {
             self.error_emitted = Some(guar);
         }
-        self.check_op_spanned(ops::StaticAccess, span)
     }
 
     fn check_local_or_return_ty(&mut self, ty: Ty<'tcx>, local: Local) {
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
index e8f10c88408ba..4146a699d663c 100644
--- a/compiler/rustc_const_eval/src/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -553,33 +553,6 @@ impl<'tcx> NonConstOp<'tcx> for RawPtrToIntCast {
     }
 }
 
-/// An access to a (non-thread-local) `static`.
-#[derive(Debug)]
-pub(crate) struct StaticAccess;
-impl<'tcx> NonConstOp<'tcx> for StaticAccess {
-    fn status_in_item(&self, ccx: &ConstCx<'_, 'tcx>) -> Status {
-        if let hir::ConstContext::Static(_) = ccx.const_kind() {
-            Status::Allowed
-        } else {
-            Status::Unstable(sym::const_refs_to_static)
-        }
-    }
-
-    #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
-    fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        let mut err = feature_err(
-            &ccx.tcx.sess,
-            sym::const_refs_to_static,
-            span,
-            format!("referencing statics in {}s is unstable", ccx.const_kind(),),
-        );
-        err
-            .note("`static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.")
-            .help("to fix this, the value can be extracted to a `const` and then used.");
-        err
-    }
-}
-
 /// An access to a thread-local `static`.
 #[derive(Debug)]
 pub(crate) struct ThreadLocalAccess;
diff --git a/compiler/rustc_error_codes/src/error_codes/E0013.md b/compiler/rustc_error_codes/src/error_codes/E0013.md
index 9f4848343ff1c..c4d65225ece90 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0013.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0013.md
@@ -5,7 +5,7 @@ variable cannot refer to a static variable.
 
 Erroneous code example:
 
-```compile_fail,E0658
+```
 static X: i32 = 42;
 const Y: i32 = X;
 ```
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 8949fdffdaec1..8c077c1de45ab 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -145,6 +145,8 @@ declare_features! (
     (accepted, const_panic, "1.57.0", Some(51999)),
     /// Allows dereferencing raw pointers during const eval.
     (accepted, const_raw_ptr_deref, "1.58.0", Some(51911)),
+    /// Allows creating pointers and references to `static` items in constants.
+    (accepted, const_refs_to_static, "CURRENT_RUSTC_VERSION", Some(119618)),
     /// Allows implementing `Copy` for closures where possible (RFC 2132).
     (accepted, copy_closures, "1.26.0", Some(44490)),
     /// Allows `crate` in paths.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 3254dab9a0344..0e787d4b1b249 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -413,8 +413,6 @@ declare_features! (
     (unstable, const_precise_live_drops, "1.46.0", Some(73255)),
     /// Allows references to types with interior mutability within constants
     (unstable, const_refs_to_cell, "1.51.0", Some(80384)),
-    /// Allows creating pointers and references to `static` items in constants.
-    (unstable, const_refs_to_static, "1.78.0", Some(119618)),
     /// Allows `impl const Trait for T` syntax.
     (unstable, const_trait_impl, "1.42.0", Some(67792)),
     /// Allows the `?` operator in const contexts.
diff --git a/tests/ui/asm/const-refs-to-static.rs b/tests/ui/asm/const-refs-to-static.rs
index 9fc010b576309..ce2c5b3246ec8 100644
--- a/tests/ui/asm/const-refs-to-static.rs
+++ b/tests/ui/asm/const-refs-to-static.rs
@@ -2,8 +2,6 @@
 //@ ignore-nvptx64
 //@ ignore-spirv
 
-#![feature(const_refs_to_static)]
-
 use std::arch::{asm, global_asm};
 use std::ptr::addr_of;
 
diff --git a/tests/ui/asm/const-refs-to-static.stderr b/tests/ui/asm/const-refs-to-static.stderr
index 8fd69da0d1e92..10e1ca5bd6068 100644
--- a/tests/ui/asm/const-refs-to-static.stderr
+++ b/tests/ui/asm/const-refs-to-static.stderr
@@ -1,5 +1,5 @@
 error: invalid type for `const` operand
-  --> $DIR/const-refs-to-static.rs:12:19
+  --> $DIR/const-refs-to-static.rs:10:19
    |
 LL | global_asm!("{}", const addr_of!(FOO));
    |                   ^^^^^^-------------
@@ -9,7 +9,7 @@ LL | global_asm!("{}", const addr_of!(FOO));
    = help: `const` operands must be of an integer type
 
 error: invalid type for `const` operand
-  --> $DIR/const-refs-to-static.rs:17:25
+  --> $DIR/const-refs-to-static.rs:15:25
    |
 LL |     unsafe { asm!("{}", const addr_of!(FOO)) };
    |                         ^^^^^^-------------
diff --git a/tests/ui/asm/x86_64/type-check-4.rs b/tests/ui/asm/x86_64/type-check-4.rs
index 9503cd6d8ab2b..79d55bd913c50 100644
--- a/tests/ui/asm/x86_64/type-check-4.rs
+++ b/tests/ui/asm/x86_64/type-check-4.rs
@@ -1,14 +1,12 @@
 //@ only-x86_64
 //@ compile-flags: -C target-feature=+avx512f
-
-use std::arch::{asm, global_asm};
+//@ check-pass
 
 use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps};
+use std::arch::{asm, global_asm};
 
 fn main() {}
 
-// Constants must be... constant
-
 static S: i32 = 1;
 const fn const_foo(x: i32) -> i32 {
     x
@@ -17,10 +15,7 @@ const fn const_bar<T>(x: T) -> T {
     x
 }
 global_asm!("{}", const S);
-//~^ ERROR referencing statics
 global_asm!("{}", const const_foo(0));
 global_asm!("{}", const const_foo(S));
-//~^ ERROR referencing statics
 global_asm!("{}", const const_bar(0));
 global_asm!("{}", const const_bar(S));
-//~^ ERROR referencing statics
diff --git a/tests/ui/asm/x86_64/type-check-4.stderr b/tests/ui/asm/x86_64/type-check-4.stderr
index f1bbc9e7d33de..8a50fe99adee4 100644
--- a/tests/ui/asm/x86_64/type-check-4.stderr
+++ b/tests/ui/asm/x86_64/type-check-4.stderr
@@ -1,39 +1,6 @@
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:19:25
+warning: unstable feature specified for `-Ctarget-feature`: `avx512f`
    |
-LL | global_asm!("{}", const S);
-   |                         ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:22:35
-   |
-LL | global_asm!("{}", const const_foo(S));
-   |                                   ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:25:35
-   |
-LL | global_asm!("{}", const const_bar(S));
-   |                                   ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
+   = note: this feature is not stably supported; its behavior can change in the future
 
-error: aborting due to 3 previous errors
+warning: 1 warning emitted
 
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-fn-not-safe-for-const.rs b/tests/ui/consts/const-fn-not-safe-for-const.rs
index 6d8404880ca30..8a0cd86819edf 100644
--- a/tests/ui/consts/const-fn-not-safe-for-const.rs
+++ b/tests/ui/consts/const-fn-not-safe-for-const.rs
@@ -18,12 +18,10 @@ static Y: u32 = 0;
 
 const fn get_Y() -> u32 {
     Y
-    //~^ ERROR referencing statics in constant functions
 }
 
 const fn get_Y_addr() -> &'static u32 {
     &Y
-    //~^ ERROR referencing statics in constant functions
 }
 
 const fn get() -> u32 {
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 7d7e94da86f7a..674e05a0ba99a 100644
--- a/tests/ui/consts/const-fn-not-safe-for-const.stderr
+++ b/tests/ui/consts/const-fn-not-safe-for-const.stderr
@@ -6,31 +6,6 @@ LL |     random()
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error[E0658]: referencing statics in constant functions is unstable
-  --> $DIR/const-fn-not-safe-for-const.rs:20:5
-   |
-LL |     Y
-   |     ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constant functions is unstable
-  --> $DIR/const-fn-not-safe-for-const.rs:25:6
-   |
-LL |     &Y
-   |      ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0015, E0658.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0015`.
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 e208845e74702..3d457856758e6 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,7 +1,7 @@
 //@ 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"
-#![feature(const_mut_refs, const_refs_to_static)]
+#![feature(const_mut_refs)]
 
 use std::sync::Mutex;
 
diff --git a/tests/ui/consts/const-ref-to-static-linux-vtable.rs b/tests/ui/consts/const-ref-to-static-linux-vtable.rs
index 9325746c1e725..17896d5afceb0 100644
--- a/tests/ui/consts/const-ref-to-static-linux-vtable.rs
+++ b/tests/ui/consts/const-ref-to-static-linux-vtable.rs
@@ -1,6 +1,6 @@
-//@check-pass
+//@ check-pass
 //! This is the reduced version of the "Linux kernel vtable" use-case.
-#![feature(const_mut_refs, const_refs_to_static)]
+#![feature(const_mut_refs)]
 use std::ptr::addr_of_mut;
 
 #[repr(C)]
diff --git a/tests/ui/consts/const_refs_to_static-ice-121413.rs b/tests/ui/consts/const_refs_to_static-ice-121413.rs
index 8fc3912efd08e..5b2d27ae85342 100644
--- a/tests/ui/consts/const_refs_to_static-ice-121413.rs
+++ b/tests/ui/consts/const_refs_to_static-ice-121413.rs
@@ -3,7 +3,6 @@
 // issue: rust-lang/rust#121413
 //@ compile-flags: -Zextra-const-ub-checks
 // ignore-tidy-linelength
-#![feature(const_refs_to_static)]
 const REF_INTERIOR_MUT: &usize = {
     //~^ HELP consider importing this struct
     static FOO: Sync = AtomicUsize::new(0);
diff --git a/tests/ui/consts/const_refs_to_static-ice-121413.stderr b/tests/ui/consts/const_refs_to_static-ice-121413.stderr
index fbe32a70293aa..c977c698a92e9 100644
--- a/tests/ui/consts/const_refs_to_static-ice-121413.stderr
+++ b/tests/ui/consts/const_refs_to_static-ice-121413.stderr
@@ -1,5 +1,5 @@
 error[E0433]: failed to resolve: use of undeclared type `AtomicUsize`
-  --> $DIR/const_refs_to_static-ice-121413.rs:9:24
+  --> $DIR/const_refs_to_static-ice-121413.rs:8:24
    |
 LL |     static FOO: Sync = AtomicUsize::new(0);
    |                        ^^^^^^^^^^^ use of undeclared type `AtomicUsize`
@@ -10,7 +10,7 @@ LL + use std::sync::atomic::AtomicUsize;
    |
 
 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/const_refs_to_static-ice-121413.rs:9:17
+  --> $DIR/const_refs_to_static-ice-121413.rs:8:17
    |
 LL |     static FOO: Sync = AtomicUsize::new(0);
    |                 ^^^^
@@ -24,7 +24,7 @@ LL |     static FOO: dyn Sync = AtomicUsize::new(0);
    |                 +++
 
 error[E0277]: the size for values of type `(dyn Sync + 'static)` cannot be known at compilation time
-  --> $DIR/const_refs_to_static-ice-121413.rs:9:17
+  --> $DIR/const_refs_to_static-ice-121413.rs:8:17
    |
 LL |     static FOO: Sync = AtomicUsize::new(0);
    |                 ^^^^ doesn't have a size known at compile-time
@@ -32,7 +32,7 @@ LL |     static FOO: Sync = AtomicUsize::new(0);
    = help: the trait `Sized` is not implemented for `(dyn Sync + 'static)`
 
 error[E0277]: the size for values of type `(dyn Sync + 'static)` cannot be known at compilation time
-  --> $DIR/const_refs_to_static-ice-121413.rs:9:24
+  --> $DIR/const_refs_to_static-ice-121413.rs:8:24
    |
 LL |     static FOO: Sync = AtomicUsize::new(0);
    |                        ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
diff --git a/tests/ui/consts/const_refs_to_static.rs b/tests/ui/consts/const_refs_to_static.rs
index f41725b786eb3..3c59697e8eda4 100644
--- a/tests/ui/consts/const_refs_to_static.rs
+++ b/tests/ui/consts/const_refs_to_static.rs
@@ -1,5 +1,4 @@
 //@ run-pass
-#![feature(const_refs_to_static)]
 
 static S: i32 = 0;
 static mut S_MUT: i32 = 0;
diff --git a/tests/ui/consts/const_refs_to_static_fail.rs b/tests/ui/consts/const_refs_to_static_fail.rs
index 806aa5f8f6fba..18b1d63b1e9c4 100644
--- a/tests/ui/consts/const_refs_to_static_fail.rs
+++ b/tests/ui/consts/const_refs_to_static_fail.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: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-#![feature(const_refs_to_static, const_mut_refs, sync_unsafe_cell)]
+#![feature(const_mut_refs, sync_unsafe_cell)]
 use std::cell::SyncUnsafeCell;
 
 static S: SyncUnsafeCell<i32> = SyncUnsafeCell::new(0);
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 c58606d2ebb5f..a160862a0fa69 100644
--- a/tests/ui/consts/const_refs_to_static_fail_invalid.rs
+++ b/tests/ui/consts/const_refs_to_static_fail_invalid.rs
@@ -1,6 +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"
-#![feature(const_refs_to_static)]
 #![allow(static_mut_refs)]
 
 fn invalid() {
diff --git a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
index d5bb4847746eb..0153f501174b2 100644
--- a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
+++ b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
@@ -1,5 +1,5 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/const_refs_to_static_fail_invalid.rs:9:5
+  --> $DIR/const_refs_to_static_fail_invalid.rs:8:5
    |
 LL |     const C: &bool = unsafe { std::mem::transmute(&S) };
    |     ^^^^^^^^^^^^^^ constructing invalid value at .<deref>: encountered 0x0a, but expected a boolean
@@ -10,7 +10,7 @@ LL |     const C: &bool = unsafe { std::mem::transmute(&S) };
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/const_refs_to_static_fail_invalid.rs:25:5
+  --> $DIR/const_refs_to_static_fail_invalid.rs:24:5
    |
 LL |     const C: &i8 = unsafe { &S };
    |     ^^^^^^^^^^^^ constructing invalid value: encountered reference to `extern` static in `const`
@@ -21,7 +21,7 @@ LL |     const C: &i8 = unsafe { &S };
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/const_refs_to_static_fail_invalid.rs:39:5
+  --> $DIR/const_refs_to_static_fail_invalid.rs:38:5
    |
 LL |     const C: &i32 = unsafe { &S_MUT };
    |     ^^^^^^^^^^^^^ constructing invalid value: encountered reference to mutable memory in `const`
@@ -32,19 +32,19 @@ LL |     const C: &i32 = unsafe { &S_MUT };
            }
 
 error: could not evaluate constant pattern
-  --> $DIR/const_refs_to_static_fail_invalid.rs:15:9
+  --> $DIR/const_refs_to_static_fail_invalid.rs:14:9
    |
 LL |         C => {}
    |         ^
 
 error: could not evaluate constant pattern
-  --> $DIR/const_refs_to_static_fail_invalid.rs:31:9
+  --> $DIR/const_refs_to_static_fail_invalid.rs:30:9
    |
 LL |         C => {}
    |         ^
 
 error: could not evaluate constant pattern
-  --> $DIR/const_refs_to_static_fail_invalid.rs:46:9
+  --> $DIR/const_refs_to_static_fail_invalid.rs:45:9
    |
 LL |         C => {}
    |         ^
diff --git a/tests/ui/consts/issue-17718-const-bad-values.rs b/tests/ui/consts/issue-17718-const-bad-values.rs
index 33347d8df622a..8e083e97cb874 100644
--- a/tests/ui/consts/issue-17718-const-bad-values.rs
+++ b/tests/ui/consts/issue-17718-const-bad-values.rs
@@ -5,7 +5,6 @@ const C1: &'static mut [usize] = &mut [];
 
 static mut S: usize = 3;
 const C2: &'static mut usize = unsafe { &mut S };
-//~^ ERROR: referencing statics in constants
-//~| ERROR: mutable references are not allowed
+//~^ ERROR: mutable references are not allowed in constants
 
 fn main() {}
diff --git a/tests/ui/consts/issue-17718-const-bad-values.stderr b/tests/ui/consts/issue-17718-const-bad-values.stderr
index e755e5601a87d..139049e75f050 100644
--- a/tests/ui/consts/issue-17718-const-bad-values.stderr
+++ b/tests/ui/consts/issue-17718-const-bad-values.stderr
@@ -4,18 +4,6 @@ error[E0764]: mutable references are not allowed in the final value of constants
 LL | const C1: &'static mut [usize] = &mut [];
    |                                  ^^^^^^^
 
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/issue-17718-const-bad-values.rs:7:46
-   |
-LL | const C2: &'static mut usize = unsafe { &mut S };
-   |                                              ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
 error[E0658]: mutable references are not allowed in constants
   --> $DIR/issue-17718-const-bad-values.rs:7:41
    |
@@ -26,7 +14,7 @@ LL | const C2: &'static mut usize = unsafe { &mut S };
    = help: add `#![feature(const_mut_refs)]` 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 3 previous errors
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0658, E0764.
 For more information about an error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/issue-17718-references.rs b/tests/ui/consts/issue-17718-references.rs
index 6a8955f463433..120ec28c40490 100644
--- a/tests/ui/consts/issue-17718-references.rs
+++ b/tests/ui/consts/issue-17718-references.rs
@@ -1,23 +1,26 @@
+//@ check-pass
 #![allow(warnings)]
 
-struct Struct { a: usize }
+struct Struct {
+    a: usize,
+}
 
 const C: usize = 1;
 static S: usize = 1;
 
 const T1: &'static usize = &C;
-const T2: &'static usize = &S; //~ ERROR: referencing statics in constants
+const T2: &'static usize = &S;
 static T3: &'static usize = &C;
 static T4: &'static usize = &S;
 
 const T5: usize = C;
-const T6: usize = S; //~ ERROR: referencing statics in constants
+const T6: usize = S;
 static T7: usize = C;
 static T8: usize = S;
 
 const T9: Struct = Struct { a: C };
 const T10: Struct = Struct { a: S };
-//~^ ERROR: referencing statics in constants
+
 static T11: Struct = Struct { a: C };
 static T12: Struct = Struct { a: S };
 
diff --git a/tests/ui/consts/issue-17718-references.stderr b/tests/ui/consts/issue-17718-references.stderr
deleted file mode 100644
index 8b57220378123..0000000000000
--- a/tests/ui/consts/issue-17718-references.stderr
+++ /dev/null
@@ -1,39 +0,0 @@
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/issue-17718-references.rs:9:29
-   |
-LL | const T2: &'static usize = &S;
-   |                             ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/issue-17718-references.rs:14:19
-   |
-LL | const T6: usize = S;
-   |                   ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/issue-17718-references.rs:19:33
-   |
-LL | const T10: Struct = Struct { a: S };
-   |                                 ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/issue-52060.rs b/tests/ui/consts/issue-52060.rs
index 0f16ede040010..79d248db674ff 100644
--- a/tests/ui/consts/issue-52060.rs
+++ b/tests/ui/consts/issue-52060.rs
@@ -1,7 +1,8 @@
 // Regression test for https://github.com/rust-lang/rust/issues/52060
 // The compiler shouldn't ICE in this case
+//@ check-pass
+
 static A: &'static [u32] = &[1];
 static B: [u32; 1] = [0; A.len()];
-//~^ ERROR referencing statics in constants
 
 fn main() {}
diff --git a/tests/ui/consts/issue-52060.stderr b/tests/ui/consts/issue-52060.stderr
deleted file mode 100644
index 644a5314622d9..0000000000000
--- a/tests/ui/consts/issue-52060.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/issue-52060.rs:4:26
-   |
-LL | static B: [u32; 1] = [0; A.len()];
-   |                          ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/min_const_fn/min_const_fn.rs b/tests/ui/consts/min_const_fn/min_const_fn.rs
index f7663f6044eef..4239c4db25d9c 100644
--- a/tests/ui/consts/min_const_fn/min_const_fn.rs
+++ b/tests/ui/consts/min_const_fn/min_const_fn.rs
@@ -86,8 +86,8 @@ const fn foo11_2<T: Send>(t: T) -> T { t }
 // not ok
 
 static BAR: u32 = 42;
-const fn foo25() -> u32 { BAR } //~ ERROR referencing statics in constant functions
-const fn foo26() -> &'static u32 { &BAR } //~ ERROR referencing statics in constant functions
+const fn foo25() -> u32 { BAR }
+const fn foo26() -> &'static u32 { &BAR }
 const fn foo30(x: *const u32) -> usize { x as usize }
 //~^ ERROR pointers cannot be cast to integers
 const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize } }
diff --git a/tests/ui/consts/min_const_fn/min_const_fn.stderr b/tests/ui/consts/min_const_fn/min_const_fn.stderr
index 4b348a182b87f..4bcd15159986e 100644
--- a/tests/ui/consts/min_const_fn/min_const_fn.stderr
+++ b/tests/ui/consts/min_const_fn/min_const_fn.stderr
@@ -162,30 +162,6 @@ LL |     const fn get_mut_sq(&mut self) -> &mut T { &mut self.0 }
    = help: add `#![feature(const_mut_refs)]` 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]: referencing statics in constant functions is unstable
-  --> $DIR/min_const_fn.rs:89:27
-   |
-LL | const fn foo25() -> u32 { BAR }
-   |                           ^^^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constant functions is unstable
-  --> $DIR/min_const_fn.rs:90:37
-   |
-LL | const fn foo26() -> &'static u32 { &BAR }
-   |                                     ^^^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
 error: pointers cannot be cast to integers during const eval
   --> $DIR/min_const_fn.rs:91:42
    |
@@ -248,7 +224,7 @@ LL | const fn no_apit(_x: impl std::fmt::Debug) {}
    |                  |
    |                  the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to 24 previous errors; 2 warnings emitted
+error: aborting due to 22 previous errors; 2 warnings emitted
 
 Some errors have detailed explanations: E0493, E0658.
 For more information about an error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr b/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr
index df910546d11ad..f8e0606fbd778 100644
--- a/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr
+++ b/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr
@@ -29,36 +29,11 @@ LL | const REF_INTERIOR_MUT: &usize = {
 
 warning: skipping const checks
    |
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static.rs:10:5
-   |
-LL |     FOO.fetch_add(1, Ordering::Relaxed)
-   |     ^^^
 help: skipping check that does not even have a feature gate
   --> $DIR/const_refers_to_static.rs:10:5
    |
 LL |     FOO.fetch_add(1, Ordering::Relaxed)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static.rs:15:17
-   |
-LL |     unsafe { *(&FOO as *const _ as *const usize) }
-   |                 ^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static.rs:19:32
-   |
-LL | const READ_MUT: u32 = unsafe { MUTABLE };
-   |                                ^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static.rs:25:18
-   |
-LL |     unsafe { &*(&FOO as *const _ as *const usize) }
-   |                  ^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static.rs:30:25
-   |
-LL | const REF_IMMUT: &u8 = &MY_STATIC;
-   |                         ^^^^^^^^^
 
 error: aborting due to 4 previous errors; 1 warning emitted
 
diff --git a/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr b/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr
index 7a7b7bc57da72..147d3f238f777 100644
--- a/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr
+++ b/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr
@@ -61,29 +61,6 @@ error: could not evaluate constant pattern
 LL |         U8_MUT3 => true,
    |         ^^^^^^^
 
-warning: skipping const checks
-   |
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static_cross_crate.rs:14:15
-   |
-LL |     unsafe { &static_cross_crate::ZERO }
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static_cross_crate.rs:19:15
-   |
-LL |     unsafe { &static_cross_crate::ZERO[0] }
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static_cross_crate.rs:25:17
-   |
-LL |     unsafe { &(*static_cross_crate::ZERO_REF)[0] }
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/const_refers_to_static_cross_crate.rs:29:15
-   |
-LL |         match static_cross_crate::OPT_ZERO {
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 8 previous errors; 1 warning emitted
+error: aborting due to 8 previous errors
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/mutable_references.rs b/tests/ui/consts/miri_unleashed/mutable_references.rs
index 7e759a1a1e42e..8f10749a2ca27 100644
--- a/tests/ui/consts/miri_unleashed/mutable_references.rs
+++ b/tests/ui/consts/miri_unleashed/mutable_references.rs
@@ -30,9 +30,11 @@ const BLUNT: &mut i32 = &mut 42;
 //~^ ERROR: it is undefined behavior to use this value
 //~| pointing to read-only memory
 
-const SUBTLE: &mut i32 = unsafe { static mut STATIC: i32 = 0; &mut STATIC };
-//~^ ERROR: it is undefined behavior to use this value
-//~| static
+const SUBTLE: &mut i32 = unsafe {
+    //~^ ERROR: it is undefined behavior to use this value
+    static mut STATIC: i32 = 0;
+    &mut STATIC
+};
 
 // # Interior mutability
 
@@ -112,7 +114,6 @@ const RAW_MUT_COERCE: SyncPtr<i32> = SyncPtr { x: &mut 0 };
 //~^ ERROR mutable pointer in final value
 //~| WARNING this was previously accepted by the compiler
 
-
 fn main() {
     unsafe {
         *MEH.x.get() = 99;
diff --git a/tests/ui/consts/miri_unleashed/mutable_references.stderr b/tests/ui/consts/miri_unleashed/mutable_references.stderr
index 620953ffa3e2e..10b5d7fb4153f 100644
--- a/tests/ui/consts/miri_unleashed/mutable_references.stderr
+++ b/tests/ui/consts/miri_unleashed/mutable_references.stderr
@@ -57,7 +57,7 @@ LL | const BLUNT: &mut i32 = &mut 42;
 error[E0080]: it is undefined behavior to use this value
   --> $DIR/mutable_references.rs:33:1
    |
-LL | const SUBTLE: &mut i32 = unsafe { static mut STATIC: i32 = 0; &mut STATIC };
+LL | const SUBTLE: &mut i32 = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered reference to mutable memory in `const`
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
@@ -66,7 +66,7 @@ LL | const SUBTLE: &mut i32 = unsafe { static mut STATIC: i32 = 0; &mut STATIC }
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mutable_references.rs:43:1
+  --> $DIR/mutable_references.rs:45:1
    |
 LL | static MEH: Meh = Meh { x: &UnsafeCell::new(42) };
    | ^^^^^^^^^^^^^^^ constructing invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory
@@ -77,7 +77,7 @@ LL | static MEH: Meh = Meh { x: &UnsafeCell::new(42) };
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mutable_references.rs:49:1
+  --> $DIR/mutable_references.rs:51:1
    |
 LL | const MUH: Meh = Meh {
    | ^^^^^^^^^^^^^^ constructing invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory
@@ -88,7 +88,7 @@ LL | const MUH: Meh = Meh {
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mutable_references.rs:61:1
+  --> $DIR/mutable_references.rs:63:1
    |
 LL | const SNEAKY: &dyn Sync = &Synced { x: UnsafeCell::new(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>.<dyn-downcast>.x: encountered `UnsafeCell` in read-only memory
@@ -99,7 +99,7 @@ LL | const SNEAKY: &dyn Sync = &Synced { x: UnsafeCell::new(42) };
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mutable_references.rs:68:1
+  --> $DIR/mutable_references.rs:70:1
    |
 LL | static mut MUT_TO_READONLY: &mut i32 = unsafe { &mut *(&READONLY as *const _ as *mut _) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered mutable reference or box pointing to read-only memory
@@ -110,7 +110,7 @@ LL | static mut MUT_TO_READONLY: &mut i32 = unsafe { &mut *(&READONLY as *const
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mutable_references.rs:75:1
+  --> $DIR/mutable_references.rs:77:1
    |
 LL | const POINTS_TO_MUTABLE: &i32 = unsafe { &MUTABLE };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered reference to mutable memory in `const`
@@ -121,13 +121,13 @@ LL | const POINTS_TO_MUTABLE: &i32 = unsafe { &MUTABLE };
            }
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/mutable_references.rs:78:43
+  --> $DIR/mutable_references.rs:80:43
    |
 LL | const POINTS_TO_MUTABLE2: &i32 = unsafe { &*MUTABLE_REF };
    |                                           ^^^^^^^^^^^^^ constant accesses mutable global memory
 
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:82:1
+  --> $DIR/mutable_references.rs:84:1
    |
 LL | const POINTS_TO_MUTABLE_INNER: *const i32 = &mut 42 as *mut _ as *const _;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL | const POINTS_TO_MUTABLE_INNER: *const i32 = &mut 42 as *mut _ as *const _;
    = note: for more information, see issue #122153 <https://github.com/rust-lang/rust/issues/122153>
 
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:86:1
+  --> $DIR/mutable_references.rs:88:1
    |
 LL | const POINTS_TO_MUTABLE_INNER2: *const i32 = &mut 42 as *const _;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL | const POINTS_TO_MUTABLE_INNER2: *const i32 = &mut 42 as *const _;
    = note: for more information, see issue #122153 <https://github.com/rust-lang/rust/issues/122153>
 
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:90:1
+  --> $DIR/mutable_references.rs:92:1
    |
 LL | const INTERIOR_MUTABLE_BEHIND_RAW: *mut i32 = &UnsafeCell::new(42) as *const _ as *mut _;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL | const INTERIOR_MUTABLE_BEHIND_RAW: *mut i32 = &UnsafeCell::new(42) as *cons
    = note: for more information, see issue #122153 <https://github.com/rust-lang/rust/issues/122153>
 
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:103:1
+  --> $DIR/mutable_references.rs:105:1
    |
 LL | const RAW_SYNC: SyncPtr<AtomicI32> = SyncPtr { x: &AtomicI32::new(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -163,7 +163,7 @@ LL | const RAW_SYNC: SyncPtr<AtomicI32> = SyncPtr { x: &AtomicI32::new(42) };
    = note: for more information, see issue #122153 <https://github.com/rust-lang/rust/issues/122153>
 
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:107:1
+  --> $DIR/mutable_references.rs:109:1
    |
 LL | const RAW_MUT_CAST: SyncPtr<i32> = SyncPtr { x: &mut 42 as *mut _ as *const _ };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -172,7 +172,7 @@ LL | const RAW_MUT_CAST: SyncPtr<i32> = SyncPtr { x: &mut 42 as *mut _ as *const
    = note: for more information, see issue #122153 <https://github.com/rust-lang/rust/issues/122153>
 
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:111:1
+  --> $DIR/mutable_references.rs:113:1
    |
 LL | const RAW_MUT_COERCE: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL | const RAW_MUT_COERCE: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    = note: for more information, see issue #122153 <https://github.com/rust-lang/rust/issues/122153>
 
 error[E0594]: cannot assign to `*OH_YES`, as `OH_YES` is an immutable static item
-  --> $DIR/mutable_references.rs:120:5
+  --> $DIR/mutable_references.rs:121:5
    |
 LL |     *OH_YES = 99;
    |     ^^^^^^^^^^^^ cannot assign
@@ -213,78 +213,63 @@ help: skipping check that does not even have a feature gate
    |
 LL | const BLUNT: &mut i32 = &mut 42;
    |                         ^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/mutable_references.rs:33:68
-   |
-LL | const SUBTLE: &mut i32 = unsafe { static mut STATIC: i32 = 0; &mut STATIC };
-   |                                                                    ^^^^^^
 help: skipping check for `const_mut_refs` feature
-  --> $DIR/mutable_references.rs:33:63
+  --> $DIR/mutable_references.rs:36:5
    |
-LL | const SUBTLE: &mut i32 = unsafe { static mut STATIC: i32 = 0; &mut STATIC };
-   |                                                               ^^^^^^^^^^^
+LL |     &mut STATIC
+   |     ^^^^^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:43:28
+  --> $DIR/mutable_references.rs:45:28
    |
 LL | static MEH: Meh = Meh { x: &UnsafeCell::new(42) };
    |                            ^^^^^^^^^^^^^^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:52:8
+  --> $DIR/mutable_references.rs:54:8
    |
 LL |     x: &UnsafeCell::new(42),
    |        ^^^^^^^^^^^^^^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:61:27
+  --> $DIR/mutable_references.rs:63:27
    |
 LL | const SNEAKY: &dyn Sync = &Synced { x: UnsafeCell::new(42) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: skipping check for `const_mut_refs` feature
-  --> $DIR/mutable_references.rs:68:49
+  --> $DIR/mutable_references.rs:70:49
    |
 LL | static mut MUT_TO_READONLY: &mut i32 = unsafe { &mut *(&READONLY as *const _ as *mut _) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: skipping check for `const_mut_refs` feature
-  --> $DIR/mutable_references.rs:68:49
+  --> $DIR/mutable_references.rs:70:49
    |
 LL | static mut MUT_TO_READONLY: &mut i32 = unsafe { &mut *(&READONLY as *const _ as *mut _) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/mutable_references.rs:75:43
-   |
-LL | const POINTS_TO_MUTABLE: &i32 = unsafe { &MUTABLE };
-   |                                           ^^^^^^^
-help: skipping check for `const_refs_to_static` feature
-  --> $DIR/mutable_references.rs:78:45
-   |
-LL | const POINTS_TO_MUTABLE2: &i32 = unsafe { &*MUTABLE_REF };
-   |                                             ^^^^^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:82:45
+  --> $DIR/mutable_references.rs:84:45
    |
 LL | const POINTS_TO_MUTABLE_INNER: *const i32 = &mut 42 as *mut _ as *const _;
    |                                             ^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:86:46
+  --> $DIR/mutable_references.rs:88:46
    |
 LL | const POINTS_TO_MUTABLE_INNER2: *const i32 = &mut 42 as *const _;
    |                                              ^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:90:47
+  --> $DIR/mutable_references.rs:92:47
    |
 LL | const INTERIOR_MUTABLE_BEHIND_RAW: *mut i32 = &UnsafeCell::new(42) as *const _ as *mut _;
    |                                               ^^^^^^^^^^^^^^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:103:51
+  --> $DIR/mutable_references.rs:105:51
    |
 LL | const RAW_SYNC: SyncPtr<AtomicI32> = SyncPtr { x: &AtomicI32::new(42) };
    |                                                   ^^^^^^^^^^^^^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:107:49
+  --> $DIR/mutable_references.rs:109:49
    |
 LL | const RAW_MUT_CAST: SyncPtr<i32> = SyncPtr { x: &mut 42 as *mut _ as *const _ };
    |                                                 ^^^^^^^
 help: skipping check that does not even have a feature gate
-  --> $DIR/mutable_references.rs:111:51
+  --> $DIR/mutable_references.rs:113:51
    |
 LL | const RAW_MUT_COERCE: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    |                                                   ^^^^^^
@@ -325,7 +310,7 @@ LL | #![deny(const_eval_mutable_ptr_in_final_value)]
 
 Future breakage diagnostic:
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:82:1
+  --> $DIR/mutable_references.rs:84:1
    |
 LL | const POINTS_TO_MUTABLE_INNER: *const i32 = &mut 42 as *mut _ as *const _;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -340,7 +325,7 @@ LL | #![deny(const_eval_mutable_ptr_in_final_value)]
 
 Future breakage diagnostic:
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:86:1
+  --> $DIR/mutable_references.rs:88:1
    |
 LL | const POINTS_TO_MUTABLE_INNER2: *const i32 = &mut 42 as *const _;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -355,7 +340,7 @@ LL | #![deny(const_eval_mutable_ptr_in_final_value)]
 
 Future breakage diagnostic:
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:90:1
+  --> $DIR/mutable_references.rs:92:1
    |
 LL | const INTERIOR_MUTABLE_BEHIND_RAW: *mut i32 = &UnsafeCell::new(42) as *const _ as *mut _;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -370,7 +355,7 @@ LL | #![deny(const_eval_mutable_ptr_in_final_value)]
 
 Future breakage diagnostic:
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:103:1
+  --> $DIR/mutable_references.rs:105:1
    |
 LL | const RAW_SYNC: SyncPtr<AtomicI32> = SyncPtr { x: &AtomicI32::new(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -385,7 +370,7 @@ LL | #![deny(const_eval_mutable_ptr_in_final_value)]
 
 Future breakage diagnostic:
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:107:1
+  --> $DIR/mutable_references.rs:109:1
    |
 LL | const RAW_MUT_CAST: SyncPtr<i32> = SyncPtr { x: &mut 42 as *mut _ as *const _ };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -400,7 +385,7 @@ LL | #![deny(const_eval_mutable_ptr_in_final_value)]
 
 Future breakage diagnostic:
 error: encountered mutable pointer in final value of constant
-  --> $DIR/mutable_references.rs:111:1
+  --> $DIR/mutable_references.rs:113:1
    |
 LL | const RAW_MUT_COERCE: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-const-refs-to-static.rs b/tests/ui/feature-gates/feature-gate-const-refs-to-static.rs
deleted file mode 100644
index 008b754dc6cf3..0000000000000
--- a/tests/ui/feature-gates/feature-gate-const-refs-to-static.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-static S: i32 = 0;
-static mut S_MUT: i32 = 0;
-
-const C1: &i32 = &S; //~ERROR:  referencing statics in constants is unstable
-const C1_READ: () = {
-    assert!(*C1 == 0);
-};
-const C2: *const i32 = unsafe { std::ptr::addr_of!(S_MUT) }; //~ERROR:  referencing statics in constants is unstable
-
-fn main() {
-}
diff --git a/tests/ui/feature-gates/feature-gate-const-refs-to-static.stderr b/tests/ui/feature-gates/feature-gate-const-refs-to-static.stderr
deleted file mode 100644
index 5af484712501e..0000000000000
--- a/tests/ui/feature-gates/feature-gate-const-refs-to-static.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/feature-gate-const-refs-to-static.rs:4:19
-   |
-LL | const C1: &i32 = &S;
-   |                   ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/feature-gate-const-refs-to-static.rs:8:52
-   |
-LL | const C2: *const i32 = unsafe { std::ptr::addr_of!(S_MUT) };
-   |                                                    ^^^^^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/static/issue-18118-2.rs b/tests/ui/static/issue-18118-2.rs
index 6c81eec7d7e4b..a73a77b48ba35 100644
--- a/tests/ui/static/issue-18118-2.rs
+++ b/tests/ui/static/issue-18118-2.rs
@@ -1,6 +1,8 @@
+//@ check-pass
+
 pub fn main() {
-    const z: &'static isize = {
-        static p: isize = 3;
-        &p //~ ERROR referencing statics
+    const Z: &'static isize = {
+        static P: isize = 3;
+        &P
     };
 }
diff --git a/tests/ui/static/issue-18118-2.stderr b/tests/ui/static/issue-18118-2.stderr
deleted file mode 100644
index f084f2b9fdfc4..0000000000000
--- a/tests/ui/static/issue-18118-2.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0658]: referencing statics in constants is unstable
-  --> $DIR/issue-18118-2.rs:4:10
-   |
-LL |         &p
-   |          ^
-   |
-   = note: see issue #119618 <https://github.com/rust-lang/rust/issues/119618> for more information
-   = help: add `#![feature(const_refs_to_static)]` 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: `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
-   = help: to fix this, the value can be extracted to a `const` and then used.
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/statics/const_generics.rs b/tests/ui/statics/const_generics.rs
index 7f64f6995a453..6cc0a65f77d52 100644
--- a/tests/ui/statics/const_generics.rs
+++ b/tests/ui/statics/const_generics.rs
@@ -10,7 +10,6 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 
-#![feature(const_refs_to_static)]
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/statics/mutable_memory_validation.rs b/tests/ui/statics/mutable_memory_validation.rs
index 470229d5fa7cd..3da213a6a9705 100644
--- a/tests/ui/statics/mutable_memory_validation.rs
+++ b/tests/ui/statics/mutable_memory_validation.rs
@@ -5,7 +5,6 @@
 //@ normalize-stderr-test: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
 #![feature(const_mut_refs)]
-#![feature(const_refs_to_static)]
 
 use std::cell::UnsafeCell;
 
diff --git a/tests/ui/statics/mutable_memory_validation.stderr b/tests/ui/statics/mutable_memory_validation.stderr
index f21269235e9b8..60d1356467927 100644
--- a/tests/ui/statics/mutable_memory_validation.stderr
+++ b/tests/ui/statics/mutable_memory_validation.stderr
@@ -1,5 +1,5 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mutable_memory_validation.rs:16:1
+  --> $DIR/mutable_memory_validation.rs:15:1
    |
 LL | const MUH: Meh = Meh { x: unsafe { &mut *(&READONLY as *const _ as *mut _) } };
    | ^^^^^^^^^^^^^^ constructing invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory