Rollup merge of #141559 - RalfJung:less-rustc_allow_const_fn_unstable, r=compiler-errors

jhpratt · web-flow · commit 5a8cb6f892b7 · 2025-05-26T03:38:19.000+02:00
const-check: stop recommending the use of rustc_allow_const_fn_unstable I have seen way too many people see the compiler suggest this attribute and then just apply it without a second thought. This is bad. So let's just stop recommending it; for the rare case where someone needs it, they'll eventually ask us and that way we can be sure that it is truly needed. The dev-guide still also explains `rustc_allow_const_fn_unstable`. Cc ``@rust-lang/wg-const-eval``
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
@@ -424,8 +424,7 @@ const_eval_unstable_in_stable_exposed =
     .unstable_sugg = if the {$is_function_call2 ->
             [true] caller
             *[false] function
-        } is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
-    .bypass_sugg = otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
+        } is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
 
 const_eval_unstable_intrinsic = `{$name}` is not yet stable as a const intrinsic
 const_eval_unstable_intrinsic_suggestion = add `#![feature({$feature})]` to the crate attributes to enable
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
@@ -58,11 +58,6 @@ pub(crate) struct UnstableInStableExposed {
         code = "#[rustc_const_unstable(feature = \"...\", issue = \"...\")]\n",
         applicability = "has-placeholders"
     )]
-    #[suggestion(
-        const_eval_bypass_sugg,
-        code = "#[rustc_allow_const_fn_unstable({gate})]\n",
-        applicability = "has-placeholders"
-    )]
     pub attr_span: Span,
 }
 
diff --git a/tests/ui/consts/const-eval/dont_promote_unstable_const_fn.stderr b/tests/ui/consts/const-eval/dont_promote_unstable_const_fn.stderr
@@ -5,14 +5,9 @@ LL | const fn bar() -> u32 { foo() }
    |                         ^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar() -> u32 { foo() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo)]
 LL | const fn bar() -> u32 { foo() }
    |
 
diff --git a/tests/ui/consts/const-unstable-intrinsic.stderr b/tests/ui/consts/const-unstable-intrinsic.stderr
@@ -46,14 +46,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL |         size_of_val(&x);
    |         ^^^^^^^^^^^^^^^
    |
-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn const_main() {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(local)]
 LL | const fn const_main() {
    |
 
@@ -63,14 +58,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL |         min_align_of_val(&x);
    |         ^^^^^^^^^^^^^^^^^^^^
    |
-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn const_main() {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(local)]
 LL | const fn const_main() {
    |
 
@@ -88,14 +78,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL |         super::size_of_val(src);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL +     #[rustc_const_unstable(feature = "...", issue = "...")]
-LL |     const unsafe fn copy<T>(src: *const T, _dst: *mut T, _count: usize) {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL +     #[rustc_allow_const_fn_unstable(local)]
 LL |     const unsafe fn copy<T>(src: *const T, _dst: *mut T, _count: usize) {
    |
 
diff --git a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
@@ -5,14 +5,9 @@ LL | const fn bar() -> u32 { foo() }
    |                         ^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar() -> u32 { foo() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo)]
 LL | const fn bar() -> u32 { foo() }
    |
 
@@ -23,14 +18,9 @@ LL | const fn bar2() -> u32 { foo2() }
    |                          ^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar2() -> u32 { foo2() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const fn bar2() -> u32 { foo2() }
    |
 
@@ -40,14 +30,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL |     let x = async { 13 };
    |             ^^^^^^^^^^^^
    |
-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar3() -> u32 {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(const_async_blocks)]
 LL | const fn bar3() -> u32 {
    |
 
@@ -58,14 +43,9 @@ LL |     foo()
    |     ^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar3() -> u32 {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo)]
 LL | const fn bar3() -> u32 {
    |
 
@@ -76,14 +56,9 @@ LL | const fn bar2_gated() -> u32 { foo2_gated() }
    |                                ^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar2_gated() -> u32 { foo2_gated() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const fn bar2_gated() -> u32 { foo2_gated() }
    |
 
@@ -94,14 +69,9 @@ LL |     pub(crate) const fn bar2_gated_stable_indirect() -> u32 { super::foo2_g
    |                                                               ^^^^^^^^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL +     #[rustc_const_unstable(feature = "...", issue = "...")]
-LL |     pub(crate) const fn bar2_gated_stable_indirect() -> u32 { super::foo2_gated() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL +     #[rustc_allow_const_fn_unstable(foo2)]
 LL |     pub(crate) const fn bar2_gated_stable_indirect() -> u32 { super::foo2_gated() }
    |
 
@@ -112,14 +82,9 @@ LL | const fn stable_indirect() -> u32 { foo2_gated() }
    |                                     ^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn stable_indirect() -> u32 { foo2_gated() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const fn stable_indirect() -> u32 { foo2_gated() }
    |
 
diff --git a/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr b/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr
@@ -5,14 +5,9 @@ LL | const unsafe fn bar() -> u32 { unsafe { foo() } }
    |                                         ^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar() -> u32 { unsafe { foo() } }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo)]
 LL | const unsafe fn bar() -> u32 { unsafe { foo() } }
    |
 
@@ -23,14 +18,9 @@ LL | const unsafe fn bar2() -> u32 { unsafe { foo2() } }
    |                                          ^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar2() -> u32 { unsafe { foo2() } }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const unsafe fn bar2() -> u32 { unsafe { foo2() } }
    |
 
@@ -41,14 +31,9 @@ LL | const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }
    |                                                ^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }
    |
 
diff --git a/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability2.stderr b/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability2.stderr
@@ -5,14 +5,9 @@ LL | const unsafe fn bar() -> u32 { foo() }
    |                                ^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar() -> u32 { foo() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo)]
 LL | const unsafe fn bar() -> u32 { foo() }
    |
 
@@ -23,14 +18,9 @@ LL | const unsafe fn bar2() -> u32 { foo2() }
    |                                 ^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar2() -> u32 { foo2() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const unsafe fn bar2() -> u32 { foo2() }
    |
 
@@ -41,14 +31,9 @@ LL | const unsafe fn bar2_gated() -> u32 { foo2_gated() }
    |                                       ^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar2_gated() -> u32 { foo2_gated() }
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(foo2)]
 LL | const unsafe fn bar2_gated() -> u32 { foo2_gated() }
    |
 
diff --git a/tests/ui/consts/min_const_fn/recursive_const_stab_unmarked_crate_imports.stderr b/tests/ui/consts/min_const_fn/recursive_const_stab_unmarked_crate_imports.stderr
@@ -5,14 +5,9 @@ LL |     unstable_if_unmarked_const_fn_crate::not_stably_const();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn stable_fn() {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(rustc_private)]
 LL | const fn stable_fn() {
    |
 
diff --git a/tests/ui/consts/min_const_fn/recursive_const_stab_unstable_if_unmarked.stderr b/tests/ui/consts/min_const_fn/recursive_const_stab_unstable_if_unmarked.stderr
@@ -5,14 +5,9 @@ LL |     not_stably_const();
    |     ^^^^^^^^^^^^^^^^^^
    |
    = help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | pub const fn expose_on_stable() {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(rustc_private)]
 LL | pub const fn expose_on_stable() {
    |
 
@@ -22,14 +17,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL |     let _x = async { 15 };
    |              ^^^^^^^^^^^^
    |
-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | pub const fn expose_on_stable() {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(const_async_blocks)]
 LL | pub const fn expose_on_stable() {
    |
 
diff --git a/tests/ui/intrinsics/const-eval-select-stability.stderr b/tests/ui/intrinsics/const-eval-select-stability.stderr
@@ -4,14 +4,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
 LL |     const_eval_select((), nothing, log);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | pub const fn hey() {
-   |
-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
-   |
-LL + #[rustc_allow_const_fn_unstable(const_eval_select)]
 LL | pub const fn hey() {
    |
 
diff --git a/tests/ui/traits/const-traits/staged-api.stderr b/tests/ui/traits/const-traits/staged-api.stderr

Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,9 @@ LL \| const fn bar() -> u32 { foo() }`
`5`	`5`	`\| ^^^^^`
`6`	`6`	`\|`
`7`	`7`	= help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
`8`		-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`8`	+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`9`	`9`	`\|`
`10`	`10`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`11`		`-LL \| const fn bar() -> u32 { foo() }`
`12`		`- \|`
`13`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`14`		`- \|`
`15`		`-LL + #[rustc_allow_const_fn_unstable(foo)]`
`16`	`11`	`LL \| const fn bar() -> u32 { foo() }`
`17`	`12`	`\|`
`18`	`13`
Original file line number	Diff line number	Diff line change
@@ -46,14 +46,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
`46`	`46`	`LL \| size_of_val(&x);`
`47`	`47`	`\| ^^^^^^^^^^^^^^^`
`48`	`48`	`\|`
`49`		-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`49`	+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`50`	`50`	`\|`
`51`	`51`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`52`		`-LL \| const fn const_main() {`
`53`		`- \|`
`54`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`55`		`- \|`
`56`		`-LL + #[rustc_allow_const_fn_unstable(local)]`
`57`	`52`	`LL \| const fn const_main() {`
`58`	`53`	`\|`
`59`	`54`
@@ -63,14 +58,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
`63`	`58`	`LL \| min_align_of_val(&x);`
`64`	`59`	`\| ^^^^^^^^^^^^^^^^^^^^`
`65`	`60`	`\|`
`66`		-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`61`	+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`67`	`62`	`\|`
`68`	`63`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`69`		`-LL \| const fn const_main() {`
`70`		`- \|`
`71`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`72`		`- \|`
`73`		`-LL + #[rustc_allow_const_fn_unstable(local)]`
`74`	`64`	`LL \| const fn const_main() {`
`75`	`65`	`\|`
`76`	`66`
@@ -88,14 +78,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
`88`	`78`	`LL \| super::size_of_val(src);`
`89`	`79`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`90`	`80`	`\|`
`91`		-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`81`	+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`92`	`82`	`\|`
`93`	`83`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`94`		`-LL \| const unsafe fn copy<T>(src: const T, _dst: mut T, _count: usize) {`
`95`		`- \|`
`96`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`97`		`- \|`
`98`		`-LL + #[rustc_allow_const_fn_unstable(local)]`
`99`	`84`	`LL \| const unsafe fn copy<T>(src: const T, _dst: mut T, _count: usize) {`
`100`	`85`	`\|`
`101`	`86`
Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,9 @@ LL \| const unsafe fn bar() -> u32 { unsafe { foo() } }`
`5`	`5`	`\| ^^^^^`
`6`	`6`	`\|`
`7`	`7`	= help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
`8`		-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`8`	+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`9`	`9`	`\|`
`10`	`10`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`11`		`-LL \| const unsafe fn bar() -> u32 { unsafe { foo() } }`
`12`		`- \|`
`13`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`14`		`- \|`
`15`		`-LL + #[rustc_allow_const_fn_unstable(foo)]`
`16`	`11`	`LL \| const unsafe fn bar() -> u32 { unsafe { foo() } }`
`17`	`12`	`\|`
`18`	`13`
`@@ -23,14 +18,9 @@ LL \| const unsafe fn bar2() -> u32 { unsafe { foo2() } }`
`23`	`18`	`\| ^^^^^^`
`24`	`19`	`\|`
`25`	`20`	= help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
`26`		-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`21`	+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`27`	`22`	`\|`
`28`	`23`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`29`		`-LL \| const unsafe fn bar2() -> u32 { unsafe { foo2() } }`
`30`		`- \|`
`31`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`32`		`- \|`
`33`		`-LL + #[rustc_allow_const_fn_unstable(foo2)]`
`34`	`24`	`LL \| const unsafe fn bar2() -> u32 { unsafe { foo2() } }`
`35`	`25`	`\|`
`36`	`26`
`@@ -41,14 +31,9 @@ LL \| const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }`
`41`	`31`	`\| ^^^^^^^^^^^^`
`42`	`32`	`\|`
`43`	`33`	= help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
`44`		-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`34`	+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`45`	`35`	`\|`
`46`	`36`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`47`		`-LL \| const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }`
`48`		`- \|`
`49`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`50`		`- \|`
`51`		`-LL + #[rustc_allow_const_fn_unstable(foo2)]`
`52`	`37`	`LL \| const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }`
`53`	`38`	`\|`
`54`	`39`
Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,9 @@ LL \| unstable_if_unmarked_const_fn_crate::not_stably_const();`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
`8`		-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`8`	+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`9`	`9`	`\|`
`10`	`10`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`11`		`-LL \| const fn stable_fn() {`
`12`		`- \|`
`13`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`14`		`- \|`
`15`		`-LL + #[rustc_allow_const_fn_unstable(rustc_private)]`
`16`	`11`	`LL \| const fn stable_fn() {`
`17`	`12`	`\|`
`18`	`13`
Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,9 @@ LL \| not_stably_const();`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= help: mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features
`8`		-help: if the caller is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`8`	+help: if the caller is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`9`	`9`	`\|`
`10`	`10`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`11`		`-LL \| pub const fn expose_on_stable() {`
`12`		`- \|`
`13`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`14`		`- \|`
`15`		`-LL + #[rustc_allow_const_fn_unstable(rustc_private)]`
`16`	`11`	`LL \| pub const fn expose_on_stable() {`
`17`	`12`	`\|`
`18`	`13`
@@ -22,14 +17,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
`22`	`17`	`LL \| let _x = async { 15 };`
`23`	`18`	`\| ^^^^^^^^^^^^`
`24`	`19`	`\|`
`25`		-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`20`	+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`26`	`21`	`\|`
`27`	`22`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`28`		`-LL \| pub const fn expose_on_stable() {`
`29`		`- \|`
`30`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`31`		`- \|`
`32`		`-LL + #[rustc_allow_const_fn_unstable(const_async_blocks)]`
`33`	`23`	`LL \| pub const fn expose_on_stable() {`
`34`	`24`	`\|`
`35`	`25`
Original file line number	Diff line number	Diff line change
@@ -4,14 +4,9 @@ error: const function that might be (indirectly) exposed to stable cannot use `#
`4`	`4`	`LL \| const_eval_select((), nothing, log);`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`		-help: if the function is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do)
	`7`	+help: if the function is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`
`8`	`8`	`\|`
`9`	`9`	`LL + #[rustc_const_unstable(feature = "...", issue = "...")]`
`10`		`-LL \| pub const fn hey() {`
`11`		`- \|`
`12`		-help: otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
`13`		`- \|`
`14`		`-LL + #[rustc_allow_const_fn_unstable(const_eval_select)]`
`15`	`10`	`LL \| pub const fn hey() {`
`16`	`11`	`\|`
`17`	`12`