Rollup merge of rust-lang#72920 - oli-obk:const_transmute, r=RalfJung

Stabilize `transmute` in constants and statics but not const fn

cc rust-lang#53605 (leaving issue open so we can add `transmute` to `const fn` later)

Previous attempt: rust-lang#64011

r? @RalfJung

cc @rust-lang/wg-const-eval

Author: Manishearth

src/libcore/intrinsics.rs

@@ -1285,7 +1285,9 @@ extern "rust-intrinsic" {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_transmute", issue = "53605")]
+    // NOTE: While this makes the intrinsic const stable, we have some custom code in const fn
+    // checks that prevent its use within `const fn`.
+    #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")]
     pub fn transmute<T, U>(e: T) -> U;
 
     /// Returns `true` if the actual type given as `T` requires drop

src/libcore/lib.rs

@@ -140,7 +140,7 @@
 #![feature(rtm_target_feature)]
 #![feature(f16c_target_feature)]
 #![feature(hexagon_target_feature)]
-#![feature(const_transmute)]
+#![cfg_attr(not(bootstrap), feature(const_fn_transmute))]
 #![feature(abi_unadjusted)]
 #![feature(adx_target_feature)]
 #![feature(maybe_uninit_slice)]

src/librustc_ast/lib.rs

@@ -10,7 +10,7 @@
 #![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_fn)] // For the `transmute` in `P::new`
 #![feature(const_panic)]
-#![feature(const_transmute)]
+#![cfg_attr(not(bootstrap), feature(const_fn_transmute))]
 #![feature(crate_visibility_modifier)]
 #![feature(label_break_value)]
 #![feature(nll)]

src/librustc_feature/active.rs

@@ -573,6 +573,9 @@ declare_features! (
     /// Lazily evaluate constants. This allows constants to depend on type parameters.
     (active, lazy_normalization_consts, "1.46.0", Some(72219), None),
 
+    /// Alloc calling `transmute` in const fn
+    (active, const_fn_transmute, "1.46.0", Some(53605), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------

src/librustc_middle/lib.rs

@@ -30,7 +30,7 @@
 #![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_fn)]
 #![feature(const_panic)]
-#![feature(const_transmute)]
+#![cfg_attr(not(bootstrap), feature(const_fn_transmute))]
 #![feature(core_intrinsics)]
 #![feature(discriminant_kind)]
 #![feature(drain_filter)]

src/librustc_mir/transform/qualify_min_const_fn.rs

@@ -6,6 +6,7 @@ use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
+use rustc_target::spec::abi::Abi::RustIntrinsic;
 use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
@@ -409,6 +410,20 @@ fn check_terminator(
                     ));
                 }
 
+                // HACK: This is to "unstabilize" the `transmute` intrinsic
+                // within const fns. `transmute` is allowed in all other const contexts.
+                // This won't really scale to more intrinsics or functions. Let's allow const
+                // transmutes in const fn before we add more hacks to this.
+                if tcx.fn_sig(fn_def_id).abi() == RustIntrinsic
+                    && tcx.item_name(fn_def_id) == sym::transmute
+                    && !feature_allowed(tcx, def_id, sym::const_fn_transmute)
+                {
+                    return Err((
+                        span,
+                        "can only call `transmute` from const items, not `const fn`".into(),
+                    ));
+                }
+
                 check_operand(tcx, func, span, fn_def_id, body)?;
 
                 for arg in args {

src/librustc_span/symbol.rs

@@ -848,6 +848,7 @@ symbols! {
         track_caller,
         trait_alias,
         transmute,
+        const_fn_transmute,
         transparent,
         transparent_enums,
         transparent_unions,

src/test/ui/consts/const-eval/dangling.rs

@@ -1,4 +1,4 @@
-#![feature(const_transmute, const_raw_ptr_deref)]
+#![feature(const_raw_ptr_deref)]
 
 use std::{mem, usize};
 

src/test/ui/consts/const-eval/double_check.rs

@@ -20,4 +20,6 @@ static FOO: (&Foo, &Bar) = unsafe {(
     Union { u8: &BAR }.bar,
 )};
 
+static FOO2: (&Foo, &Bar) = unsafe {(std::mem::transmute(&BAR), std::mem::transmute(&BAR))};
+
 fn main() {}

src/test/ui/consts/const-eval/double_check2.rs

@@ -17,5 +17,7 @@ static FOO: (&Foo, &Bar) = unsafe {( //~ undefined behavior
     Union { u8: &BAR }.foo,
     Union { u8: &BAR }.bar,
 )};
+static FOO2: (&Foo, &Bar) = unsafe {(std::mem::transmute(&BAR), std::mem::transmute(&BAR))};
+//~^ undefined behavior
 
 fn main() {}

src/test/ui/consts/const-eval/double_check2.stderr

@@ -9,6 +9,14 @@ LL | | )};
    |
    = 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.
 
-error: aborting due to previous error
+error[E0080]: it is undefined behavior to use this value
+  --> $DIR/double_check2.rs:20:1
+   |
+LL | static FOO2: (&Foo, &Bar) = unsafe {(std::mem::transmute(&BAR), std::mem::transmute(&BAR))};
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x05 at .1.<deref>.<enum-tag>, but expected a valid enum tag
+   |
+   = 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.
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0080`.

src/test/ui/consts/const-eval/issue-55541.rs

@@ -2,7 +2,7 @@
 
 // Test that we can handle newtypes wrapping extern types
 
-#![feature(extern_types, const_transmute)]
+#![feature(extern_types)]
 
 use std::marker::PhantomData;
 

src/test/ui/consts/const-eval/transmute-const.rs

@@ -1,5 +1,3 @@
-#![feature(const_transmute)]
-
 use std::mem;
 
 static FOO: bool = unsafe { mem::transmute(3u8) };

src/test/ui/consts/const-eval/transmute-const.stderr

@@ -1,5 +1,5 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/transmute-const.rs:5:1
+  --> $DIR/transmute-const.rs:3:1
    |
 LL | static FOO: bool = unsafe { mem::transmute(3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x03, but expected a boolean

src/test/ui/consts/const-eval/ub-enum.rs

@@ -1,5 +1,5 @@
 // normalize-stderr-64bit "0x0000000000" -> "0x00"
-#![feature(const_transmute, never_type)]
+#![feature(never_type)]
 #![allow(const_err)] // make sure we cannot allow away the errors tested here
 
 use std::mem;

src/test/ui/consts/const-eval/ub-int-array.rs

@@ -1,4 +1,3 @@
-#![feature(const_transmute)]
 #![allow(const_err)] // make sure we cannot allow away the errors tested here
 
 //! Test the "array of int" fast path in validity checking, and in particular whether it

src/test/ui/consts/const-eval/ub-int-array.stderr

@@ -1,5 +1,5 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-int-array.rs:15:1
+  --> $DIR/ub-int-array.rs:14:1
    |
 LL | / const UNINIT_INT_0: [u32; 3] = unsafe {
 LL | |
@@ -13,7 +13,7 @@ LL | | };
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-int-array.rs:24:1
+  --> $DIR/ub-int-array.rs:23:1
    |
 LL | / const UNINIT_INT_1: [u32; 3] = unsafe {
 LL | |
@@ -27,7 +27,7 @@ LL | | };
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-int-array.rs:44:1
+  --> $DIR/ub-int-array.rs:43:1
    |
 LL | / const UNINIT_INT_2: [u32; 3] = unsafe {
 LL | |

src/test/ui/consts/const-eval/ub-nonnull.rs

@@ -1,4 +1,4 @@
-#![feature(rustc_attrs, const_transmute)]
+#![feature(rustc_attrs)]
 #![allow(const_err, invalid_value)] // make sure we cannot allow away the errors tested here
 
 use std::mem;

src/test/ui/consts/const-eval/ub-ref.rs

@@ -1,5 +1,4 @@
 // ignore-tidy-linelength
-#![feature(const_transmute)]
 #![allow(const_err, invalid_value)] // make sure we cannot allow away the errors tested here
 
 use std::mem;

src/test/ui/consts/const-eval/ub-ref.stderr

@@ -1,69 +1,69 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:7:1
+  --> $DIR/ub-ref.rs:6:1
    |
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered an unaligned reference (required 2 byte alignment but found 1)
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:11:1
+  --> $DIR/ub-ref.rs:10:1
    |
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered an unaligned box (required 2 byte alignment but found 1)
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:15:1
+  --> $DIR/ub-ref.rs:14:1
    |
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL reference
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:18:1
+  --> $DIR/ub-ref.rs:17:1
    |
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL box
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:24:1
+  --> $DIR/ub-ref.rs:23:1
    |
 LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc16, but expected initialized plain (non-pointer) bytes
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:27:1
+  --> $DIR/ub-ref.rs:26:1
    |
 LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a pointer at .<deref>, but expected plain (non-pointer) bytes
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:30:1
+  --> $DIR/ub-ref.rs:29:1
    |
 LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[usize], _>(&[mem::transmute(&0)]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a pointer at .<deref>, but expected plain (non-pointer) bytes
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:33:1
+  --> $DIR/ub-ref.rs:32:1
    |
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling reference (created from integer)
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-ref.rs:36:1
+  --> $DIR/ub-ref.rs:35:1
    |
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling box (created from integer)

src/test/ui/consts/const-eval/ub-uninhabit.rs

@@ -1,4 +1,3 @@
-#![feature(const_transmute)]
 #![allow(const_err)] // make sure we cannot allow away the errors tested here
 
 use std::mem;

src/test/ui/consts/const-eval/ub-uninhabit.stderr

@@ -1,21 +1,21 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-uninhabit.rs:15:1
+  --> $DIR/ub-uninhabit.rs:14:1
    |
 LL | const BAD_BAD_BAD: Bar = unsafe { MaybeUninit { uninit: () }.init };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Bar
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-uninhabit.rs:18:1
+  --> $DIR/ub-uninhabit.rs:17:1
    |
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Bar at .<deref>
    |
    = 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.
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-uninhabit.rs:21:1
+  --> $DIR/ub-uninhabit.rs:20:1
    |
 LL | const BAD_BAD_ARRAY: [Bar; 1] = unsafe { MaybeUninit { uninit: () }.init };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Bar at [0]

src/test/ui/consts/const-eval/ub-upvars.rs

@@ -1,4 +1,3 @@
-#![feature(const_transmute)]
 #![allow(const_err, invalid_value)] // make sure we cannot allow away the errors tested here
 
 use std::mem;

src/test/ui/consts/const-eval/ub-upvars.stderr

@@ -1,5 +1,5 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-upvars.rs:6:1
+  --> $DIR/ub-upvars.rs:5:1
    |
 LL | / const BAD_UPVAR: &dyn FnOnce() = &{
 LL | |     let bad_ref: &'static u16 = unsafe { mem::transmute(0usize) };

src/test/ui/consts/const-eval/ub-wide-ptr.rs

@@ -1,5 +1,4 @@
 // ignore-tidy-linelength
-#![feature(const_transmute)]
 #![allow(unused)]
 #![allow(const_err)] // make sure we cannot allow away the errors tested here
 

src/test/ui/consts/const-eval/ub-wide-ptr.stderr

@@ -1,7 +1,6 @@
 // check-pass
 
 // Some constants that *are* valid
-#![feature(const_transmute)]
 #![deny(const_err)]
 
 use std::mem;

src/test/ui/consts/const-eval/valid-const.rs

@@ -1,5 +1,5 @@
 #![feature(const_fn)]
-#![feature(const_transmute)]
+#![feature(const_fn_transmute)]
 
 const fn foo() -> ! {
     unsafe { std::mem::transmute(()) }

src/test/ui/consts/const-eval/validate_uninhabited_zsts.rs

@@ -1,5 +1,4 @@
 // run-pass
-#![feature(const_transmute)]
 
 const FOO: isize = 10;
 const BAR: isize = 3;

src/test/ui/consts/consts-in-patterns.rs

@@ -17,11 +17,6 @@ help: skipping check that does not even have a feature gate
    |
 LL |     my_fn();
    |     ^^^^^^^
-help: skipping check that does not even have a feature gate
-  --> $DIR/abi-mismatch.rs:16:40
-   |
-LL | static VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) });
-   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 

src/test/ui/consts/miri_unleashed/abi-mismatch.stderr

@@ -17,11 +17,6 @@ help: skipping check that does not even have a feature gate
    |
 LL |     let _v = x == x;
    |              ^^^^^^
-help: skipping check that does not even have a feature gate
-  --> $DIR/ptr_arith.rs:15:20
-   |
-LL |     let x: usize = std::mem::transmute(&0);
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors; 1 warning emitted
 

src/test/ui/consts/miri_unleashed/ptr_arith.stderr

@@ -1,7 +1,5 @@
 // run-pass
 
-#![feature(const_transmute)]
-
 use std::mem;
 
 #[repr(transparent)]

src/test/ui/consts/transmute-const.rs

@@ -0,0 +1,38 @@
+use std::mem;
+
+#[repr(transparent)]
+struct Foo(u32);
+
+const TRANSMUTED_U32: u32 = unsafe { mem::transmute(Foo(3)) };
+
+const fn transmute_fn() -> u32 { unsafe { mem::transmute(Foo(3)) } }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const fn transmute_fn_intrinsic() -> u32 { unsafe { std::intrinsics::transmute(Foo(3)) } }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const fn transmute_fn_core_intrinsic() -> u32 { unsafe { core::intrinsics::transmute(Foo(3)) } }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const unsafe fn unsafe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const unsafe fn unsafe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const unsafe fn unsafe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const fn safe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+//~| ERROR call to unsafe function is unsafe and requires unsafe function or block
+
+const fn safe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+//~| ERROR call to unsafe function is unsafe and requires unsafe function or block
+
+const fn safe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+//~| ERROR call to unsafe function is unsafe and requires unsafe function or block
+
+fn main() {}

src/test/ui/feature-gates/feature-gate-const_fn_transmute.rs

@@ -0,0 +1,109 @@
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:8:43
+   |
+LL | const fn transmute_fn() -> u32 { unsafe { mem::transmute(Foo(3)) } }
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:11:53
+   |
+LL | const fn transmute_fn_intrinsic() -> u32 { unsafe { std::intrinsics::transmute(Foo(3)) } }
+   |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:14:58
+   |
+LL | const fn transmute_fn_core_intrinsic() -> u32 { unsafe { core::intrinsics::transmute(Foo(3)) } }
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:17:48
+   |
+LL | const unsafe fn unsafe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:20:58
+   |
+LL | const unsafe fn unsafe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:23:63
+   |
+LL | const unsafe fn unsafe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+   |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:26:39
+   |
+LL | const fn safe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:30:49
+   |
+LL | const fn safe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0723]: can only call `transmute` from const items, not `const fn`
+  --> $DIR/feature-gate-const_fn_transmute.rs:34:54
+   |
+LL | const fn safe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+   |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+   = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+  --> $DIR/feature-gate-const_fn_transmute.rs:26:39
+   |
+LL | const fn safe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+  --> $DIR/feature-gate-const_fn_transmute.rs:30:49
+   |
+LL | const fn safe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+  --> $DIR/feature-gate-const_fn_transmute.rs:34:54
+   |
+LL | const fn safe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+   |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error: aborting due to 12 previous errors
+
+Some errors have detailed explanations: E0133, E0723.
+For more information about an error, try `rustc --explain E0133`.

src/test/ui/feature-gates/feature-gate-const_fn_transmute.stderr

@@ -8,7 +8,7 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(feature = "rust1", since = "1.0.0")]
 pub const fn foo() -> i32 {
-    unsafe { std::mem::transmute(4u32) } //~ ERROR is not stable as `const fn`
+    unsafe { std::mem::transmute(4u32) } //~ ERROR can only call `transmute` from const items
 }
 
 fn main() {}

src/test/ui/feature-gates/feature-gate-const_transmute.rs

@@ -1,4 +1,4 @@
-error[E0723]: can only call other `const fn` within a `const fn`, but `const std::intrinsics::transmute::<u32, i32>` is not stable as `const fn`
+error[E0723]: can only call `transmute` from const items, not `const fn`
   --> $DIR/internal-unstable-const.rs:11:14
    |
 LL |     unsafe { std::mem::transmute(4u32) }