Organize intrinsics const evaluability checks

src/libcore/intrinsics.rs

@@ -935,6 +935,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,57 @@ impl<'tcx> TyCtxt<'tcx> {
 
 
 pub fn provide(providers: &mut Providers<'_>) {
-    /// only checks whether the function has a `const` modifier
+    fn is_const_intrinsic(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
+        // Const evaluability whitelist is here to check 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: TyCtxt<'_>, 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(hir_id);
-        if let Some(fn_like) = FnLikeNode::from_node(node) {
-            fn_like.constness() == hir::Constness::Const
+
+        if is_const_intrinsic(tcx, def_id) {
+            false
+        } else if let Some(fn_like) = FnLikeNode::from_node(node) {
+            (fn_like.constness() == hir::Constness::Const)
         } else if let hir::Node::Ctor(_) = node {
             true
         } else {

src/librustc_mir/transform/qualify_consts.rs

@@ -528,51 +528,12 @@ impl Qualif for IsNotPromotable {
         let fn_ty = callee.ty(cx.body, cx.tcx);
         match fn_ty.kind {
             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"
-                            | "wrapping_add"
-                            | "wrapping_sub"
-                            | "wrapping_mul"
-                            | "unchecked_shl"
-                            | "unchecked_shr"
-                            | "rotate_left"
-                            | "rotate_right"
-                            | "add_with_overflow"
-                            | "sub_with_overflow"
-                            | "mul_with_overflow"
-                            | "saturating_add"
-                            | "saturating_sub"
-                            | "transmute"
-                            | "simd_insert"
-                            | "simd_extract"
-                            => 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,
@@ -1324,21 +1285,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;
                                 }
@@ -1349,7 +1295,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/active.rs

@@ -429,10 +429,6 @@ declare_features! (
     /// Allows using `#[doc(keyword = "...")]`.
     (active, doc_keyword, "1.28.0", Some(51315), 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),
 

src/test/ui/consts/const-eval/const-eval-intrinsic-promotion.rs

@@ -0,0 +1,5 @@
+#![feature(core_intrinsics)]
+fn main() {
+    let x: &'static usize =
+        &std::intrinsics::size_of::<i32>(); //~ ERROR temporary value dropped while borrowed
+}

src/test/ui/consts/const-eval/const-eval-intrinsic-promotion.stderr

@@ -0,0 +1,13 @@
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/const-eval-intrinsic-promotion.rs:4:10
+   |
+LL |     let x: &'static usize =
+   |            -------------- type annotation requires that borrow lasts for `'static`
+LL |         &std::intrinsics::size_of::<i32>();
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
+LL | }
+   | - temporary value is freed at the end of this statement
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0716`.