Stabilize transmute in constants and statics but not const fn

Author: oli-obk

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() {}