Make core::mem::needs_drop a const fn

Author: mjbshaw

src/libcore/mem.rs

@@ -483,6 +483,15 @@ pub fn align_of_val<T: ?Sized>(val: &T) -> usize {
 /// ```
 #[inline]
 #[stable(feature = "needs_drop", since = "1.21.0")]
+#[cfg(not(stage0))]
+pub const fn needs_drop<T>() -> bool {
+    intrinsics::needs_drop::<T>()
+}
+
+#[inline]
+#[stable(feature = "needs_drop", since = "1.21.0")]
+#[cfg(stage0)]
+/// Ceci n'est pas la documentation
 pub fn needs_drop<T>() -> bool {
     unsafe { intrinsics::needs_drop::<T>() }
 }

src/librustc/ty/context.rs

@@ -1143,6 +1143,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                 match &self.item_name(def_id).as_str()[..] {
                     | "size_of"
                     | "min_align_of"
+                    | "needs_drop"
                     => return true,
                     _ => {},
                 }

src/librustc_mir/interpret/intrinsics.rs

@@ -65,6 +65,13 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 self.write_scalar(align_val, dest)?;
             }
 
+            "needs_drop" => {
+                let ty = substs.type_at(0);
+                let ty_needs_drop = ty.needs_drop(self.tcx.tcx, self.param_env);
+                let val = Scalar::from_bool(ty_needs_drop);
+                self.write_scalar(val, dest)?;
+            }
+
             "size_of" => {
                 let ty = substs.type_at(0);
                 let size = self.layout_of(ty)?.size.bytes() as u128;

src/librustc_mir/transform/qualify_consts.rs

@@ -823,6 +823,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
                         match &self.tcx.item_name(def_id).as_str()[..] {
                             | "size_of"
                             | "min_align_of"
+                            | "needs_drop"
                             | "type_id"
                             | "bswap"
                             | "bitreverse"

src/librustc_typeck/check/intrinsic.rs

@@ -117,7 +117,7 @@ pub fn check_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         (0, Vec::new(), tcx.types.never, hir::Unsafety::Unsafe)
     } else {
         let unsafety = match &name[..] {
-            "size_of" | "min_align_of" => hir::Unsafety::Normal,
+            "size_of" | "min_align_of" | "needs_drop" => hir::Unsafety::Normal,
             _ => hir::Unsafety::Unsafe,
         };
         let (n_tps, inputs, output) = match &name[..] {

src/librustc_typeck/collect.rs

@@ -2003,7 +2003,7 @@ fn compute_sig_of_foreign_fn_decl<'a, 'tcx>(
 ) -> ty::PolyFnSig<'tcx> {
     let unsafety = if abi == abi::Abi::RustIntrinsic {
         match &*tcx.item_name(def_id).as_str() {
-            "size_of" | "min_align_of" => hir::Unsafety::Normal,
+            "size_of" | "min_align_of" | "needs_drop" => hir::Unsafety::Normal,
             _ => hir::Unsafety::Unsafe,
         }
     } else {

src/test/run-pass/const-needs_drop.rs

@@ -0,0 +1,37 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::mem;
+
+struct Trivial(u8, f32);
+
+struct NonTrivial(u8, String);
+
+const CONST_U8: bool = mem::needs_drop::<u8>();
+const CONST_STRING: bool = mem::needs_drop::<String>();
+const CONST_TRIVIAL: bool = mem::needs_drop::<Trivial>();
+const CONST_NON_TRIVIAL: bool = mem::needs_drop::<NonTrivial>();
+
+static STATIC_U8: bool = mem::needs_drop::<u8>();
+static STATIC_STRING: bool = mem::needs_drop::<String>();
+static STATIC_TRIVIAL: bool = mem::needs_drop::<Trivial>();
+static STATIC_NON_TRIVIAL: bool = mem::needs_drop::<NonTrivial>();
+
+fn main() {
+    assert!(!CONST_U8);
+    assert!(CONST_STRING);
+    assert!(!CONST_TRIVIAL);
+    assert!(CONST_NON_TRIVIAL);
+
+    assert!(!STATIC_U8);
+    assert!(STATIC_STRING);
+    assert!(!STATIC_TRIVIAL);
+    assert!(STATIC_NON_TRIVIAL);
+}