Organize intrinsics const evaluability checks

src/libcore/intrinsics.rs

@@ -913,6 +913,7 @@ extern "rust-intrinsic" {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_unstable(feature = "const_transmute")]
     pub fn transmute<T, U>(e: T) -> U;
 
     /// Returns `true` if the actual type given as `T` requires drop

src/librustc/ty/constness.rs

@@ -3,6 +3,7 @@ use crate::hir::def_id::DefId;
 use crate::hir;
 use crate::ty::TyCtxt;
 use syntax_pos::symbol::{sym, Symbol};
+use rustc_target::spec::abi::Abi;
 use crate::hir::map::blocks::FnLikeNode;
 use syntax::attr;
 
@@ -68,14 +69,54 @@ impl<'tcx> TyCtxt<'tcx, 'tcx> {
 
 
 pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
-    /// only checks whether the function has a `const` modifier
+    fn is_const_evaluatable(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) -> bool {
+        // Intrinsics promotion whitelist is here to check const evaluability at the
+        // top level beforehand.
+        match tcx.fn_sig(def_id).abi() {
+            Abi::RustIntrinsic |
+            Abi::PlatformIntrinsic => {
+                match &tcx.item_name(def_id).as_str()[..] {
+                    | "size_of"
+                    | "min_align_of"
+                    | "needs_drop"
+                    | "type_id"
+                    | "bswap"
+                    | "bitreverse"
+                    | "ctpop"
+                    | "cttz"
+                    | "cttz_nonzero"
+                    | "ctlz"
+                    | "ctlz_nonzero"
+                    | "overflowing_add"
+                    | "overflowing_sub"
+                    | "overflowing_mul"
+                    | "unchecked_shl"
+                    | "unchecked_shr"
+                    | "rotate_left"
+                    | "rotate_right"
+                    | "add_with_overflow"
+                    | "sub_with_overflow"
+                    | "mul_with_overflow"
+                    | "saturating_add"
+                    | "saturating_sub"
+                    | "transmute"
+                    => true,
+
+                    _ => false
+                }
+            }
+            _ => false
+        }
+    }
+
+    /// Checks whether the function has a `const` modifier and intrinsics can be promotable in it
     fn is_const_fn_raw<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) -> bool {
         let hir_id = tcx.hir().as_local_hir_id(def_id)
                               .expect("Non-local call to local provider is_const_fn");
 
         let node = tcx.hir().get_by_hir_id(hir_id);
         if let Some(fn_like) = FnLikeNode::from_node(node) {
-            fn_like.constness() == hir::Constness::Const
+            (fn_like.constness() == hir::Constness::Const) || is_const_evaluatable(tcx, def_id)
         } else if let hir::Node::Ctor(_) = node {
             true
         } else {

src/librustc_mir/transform/qualify_consts.rs

@@ -489,49 +489,12 @@ impl Qualif for IsNotPromotable {
         let fn_ty = callee.ty(cx.body, cx.tcx);
         match fn_ty.sty {
             ty::FnDef(def_id, _) => {
-                match cx.tcx.fn_sig(def_id).abi() {
-                    Abi::RustIntrinsic |
-                    Abi::PlatformIntrinsic => {
-                        assert!(!cx.tcx.is_const_fn(def_id));
-                        match &cx.tcx.item_name(def_id).as_str()[..] {
-                            | "size_of"
-                            | "min_align_of"
-                            | "needs_drop"
-                            | "type_id"
-                            | "bswap"
-                            | "bitreverse"
-                            | "ctpop"
-                            | "cttz"
-                            | "cttz_nonzero"
-                            | "ctlz"
-                            | "ctlz_nonzero"
-                            | "overflowing_add"
-                            | "overflowing_sub"
-                            | "overflowing_mul"
-                            | "unchecked_shl"
-                            | "unchecked_shr"
-                            | "rotate_left"
-                            | "rotate_right"
-                            | "add_with_overflow"
-                            | "sub_with_overflow"
-                            | "mul_with_overflow"
-                            | "saturating_add"
-                            | "saturating_sub"
-                            | "transmute"
-                            => return true,
-
-                            _ => {}
-                        }
-                    }
-                    _ => {
-                        let is_const_fn =
-                            cx.tcx.is_const_fn(def_id) ||
-                            cx.tcx.is_unstable_const_fn(def_id).is_some() ||
-                            cx.is_const_panic_fn(def_id);
-                        if !is_const_fn {
-                            return true;
-                        }
-                    }
+                let is_const_fn =
+                    cx.tcx.is_const_fn(def_id) ||
+                    cx.tcx.is_unstable_const_fn(def_id).is_some() ||
+                    cx.is_const_panic_fn(def_id);
+                if !is_const_fn {
+                    return true;
                 }
             }
             _ => return true,
@@ -1251,21 +1214,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
                         Abi::PlatformIntrinsic => {
                             assert!(!self.tcx.is_const_fn(def_id));
                             match &self.tcx.item_name(def_id).as_str()[..] {
-                                // special intrinsic that can be called diretly without an intrinsic
-                                // feature gate needs a language feature gate
-                                "transmute" => {
-                                    if self.mode.requires_const_checking() {
-                                        // const eval transmute calls only with the feature gate
-                                        if !self.tcx.features().const_transmute {
-                                            emit_feature_err(
-                                                &self.tcx.sess.parse_sess, sym::const_transmute,
-                                                self.span, GateIssue::Language,
-                                                &format!("The use of std::mem::transmute() \
-                                                is gated in {}s", self.mode));
-                                        }
-                                    }
-                                }
-
                                 name if name.starts_with("simd_shuffle") => {
                                     is_shuffle = true;
                                 }
@@ -1276,7 +1224,9 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
                             }
                         }
                         _ => {
-                            // In normal functions no calls are feature-gated.
+                            // Only in non-const functions it is perfectly fine to call any
+                            // function, even ones whose constness is unstable. Everywhere else
+                            // we need to check the appropriate feature gates.
                             if self.mode.requires_const_checking() {
                                 let unleash_miri = self
                                     .tcx

src/libsyntax/feature_gate.rs

@@ -489,9 +489,6 @@ declare_features! (
     // This will likely be removed prior to stabilization of async/await.
     (active, await_macro, "1.28.0", Some(50547), None),
 
-    // Allows reinterpretation of the bits of a value of one type as another type during const eval.
-    (active, const_transmute, "1.29.0", Some(53605), None),
-
     // Allows using `try {...}` expressions.
     (active, try_blocks, "1.29.0", Some(31436), None),