Make core::mem::MaybeUninit::zeroed a const fn

src/libcore/mem.rs

@@ -1039,6 +1039,14 @@ impl<T> MaybeUninit<T> {
     /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.
     /// It is your responsibility to make sure `T` gets dropped if it got initialized.
     #[unstable(feature = "maybe_uninit", issue = "53491")]
+    #[cfg(not(stage0))]
+    pub const fn zeroed() -> MaybeUninit<T> {
+        MaybeUninit { value: unsafe { intrinsics::init() } }
+    }
+
+    #[unstable(feature = "maybe_uninit", issue = "53491")]
+    #[cfg(stage0)]
+    /// Ceci n'est pas la documentation
     pub fn zeroed() -> MaybeUninit<T> {
         let mut u = MaybeUninit::<T>::uninitialized();
         unsafe {

src/librustc_mir/interpret/intrinsics.rs

@@ -150,6 +150,9 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 }
                 self.write_scalar(val, dest)?;
             }
+            "init" => {
+                self.force_allocation(dest)?;
+            }
             "transmute" => {
                 // Go through an allocation, to make sure the completely different layouts
                 // do not pose a problem.  (When the user transmutes through a union,

src/librustc_mir/transform/qualify_consts.rs

@@ -839,6 +839,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
                             | "add_with_overflow"
                             | "sub_with_overflow"
                             | "mul_with_overflow"
+                            | "init"
                             // no need to check feature gates, intrinsics are only callable from the
                             // libstd or with forever unstable feature gates
                             => is_const_fn = true,

src/test/run-pass/const-maybe-init-zeroed.rs

@@ -0,0 +1,26 @@
+// 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.
+#![feature(maybe_uninit)]
+
+use std::mem;
+
+fn main() {
+    const UNIT: mem::MaybeUninit<()> = mem::MaybeUninit::zeroed();
+    let bytes: [u8; 0] = unsafe { mem::transmute(UNIT) };
+    assert_eq!(bytes, [0u8; 0]);
+
+    const STRING: mem::MaybeUninit<String> = mem::MaybeUninit::zeroed();
+    let bytes: [u8; mem::size_of::<String>()] = unsafe { mem::transmute(STRING) };
+    assert_eq!(bytes, [0u8; mem::size_of::<String>()]);
+
+    const U8: mem::MaybeUninit<u8> = mem::MaybeUninit::zeroed();
+    let bytes: [u8; 1] = unsafe { mem::transmute(U8) };
+    assert_eq!(bytes, [0u8; 1]);
+}