Auto merge of #147907 - RalfJung:box_new, r=<try>

perf experiment: try to replace box_new with write_via_move

Author: rust-bors[bot]

library/alloc/src/boxed.rs

@@ -237,10 +237,10 @@ pub struct Box<
 /// the newly allocated memory. This is an intrinsic to avoid unnecessary copies.
 ///
 /// This is the surface syntax for `box <expr>` expressions.
-#[doc(hidden)]
-#[rustc_intrinsic]
-#[unstable(feature = "liballoc_internals", issue = "none")]
-pub fn box_new<T>(x: T) -> Box<T>;
+// #[doc(hidden)]
+// #[rustc_intrinsic]
+// #[unstable(feature = "liballoc_internals", issue = "none")]
+// pub fn box_new<T>(x: T) -> Box<T>;
 
 impl<T> Box<T> {
     /// Allocates memory on the heap and then places `x` into it.
@@ -259,7 +259,12 @@ impl<T> Box<T> {
     #[rustc_diagnostic_item = "box_new"]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn new(x: T) -> Self {
-        return box_new(x);
+        let mut b = Box::new_uninit();
+        let ptr = mem::MaybeUninit::as_mut_ptr(&mut *b);
+        // SAFETY: we just allocated the box to store `x`.
+        unsafe { core::intrinsics::write_via_move(ptr, x) };
+        // SAFETY: we just initialized `b`.
+        unsafe { b.assume_init() }
     }
 
     /// Constructs a new box with uninitialized contents.

library/alloc/src/lib.rs

@@ -235,4 +235,6 @@ pub mod wtf8;
 pub mod __export {
     pub use core::format_args;
     pub use core::hint::must_use;
+    pub use core::intrinsics::write_via_move;
+    pub use core::mem::MaybeUninit;
 }

library/alloc/src/macros.rs

@@ -38,7 +38,7 @@
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "vec_macro"]
-#[allow_internal_unstable(rustc_attrs, liballoc_internals)]
+#[allow_internal_unstable(rustc_attrs, liballoc_internals, core_intrinsics)]
 macro_rules! vec {
     () => (
         $crate::vec::Vec::new()
@@ -48,9 +48,20 @@ macro_rules! vec {
     );
     ($($x:expr),+ $(,)?) => (
         <[_]>::into_vec(
-            // Using the intrinsic produces a dramatic improvement in stack usage for
-            // unoptimized programs using this code path to construct large Vecs.
-            $crate::boxed::box_new([$($x),+])
+            if false {
+                // This arm exists only to control type inference, and to ensure
+                // `$x` can be written outside an unsafe block.
+                $crate::boxed::Box::new([$($x),+])
+            } else {
+                unsafe {
+                    // Using the intrinsic produces a dramatic improvement in stack usage for
+                    // unoptimized programs using this code path to construct large Vecs.
+                    let mut b = $crate::boxed::Box::new_uninit();
+                    let ptr = $crate::__export::MaybeUninit::as_mut_ptr(&mut *b);
+                    $crate::__export::write_via_move(ptr, [$($x),+]);
+                    b.assume_init()
+                }
+            }
         )
     );
 }