move intrinsic to alloc::intrinsics

Author: RalfJung

library/alloc/src/boxed.rs

@@ -248,16 +248,6 @@ unsafe fn box_new_uninit(size: usize, align: usize) -> *mut u8 {
     }
 }
 
-/// Writes `x` into `b`.
-///
-/// This is needed for `vec!`, which can't afford any extra copies of the argument (or else debug
-/// builds regress), has to be written fully as a call chain without `let` (or else the temporary
-/// lifetimes of the arguments change), and can't use an `unsafe` block as that would then also
-/// include the user-provided `$x`.
-#[rustc_intrinsic]
-#[unstable(feature = "liballoc_internals", issue = "none")]
-pub fn write_box_via_move<T>(b: Box<MaybeUninit<T>>, x: T) -> Box<MaybeUninit<T>>;
-
 /// Helper internally invoked by `write_box_via_move` (since doing the same in pure MIR,
 /// including all the same lifetime effects, seems impossible).
 #[lang = "box_uninit_as_mut_ptr"]

library/alloc/src/intrinsics.rs

@@ -0,0 +1,15 @@
+//! Intrinsics that cannot be moved to `core` because they depend on `alloc` types.
+#![unstable(feature = "liballoc_internals", issue = "none")]
+
+use core::mem::MaybeUninit;
+
+use crate::boxed::Box;
+
+/// Writes `x` into `b`.
+///
+/// This is needed for `vec!`, which can't afford any extra copies of the argument (or else debug
+/// builds regress), has to be written fully as a call chain without `let` (or else the temporary
+/// lifetimes of the arguments change), and can't use an `unsafe` block as that would then also
+/// include the user-provided `$x`.
+#[rustc_intrinsic]
+pub fn write_box_via_move<T>(b: Box<MaybeUninit<T>>, x: T) -> Box<MaybeUninit<T>>;

library/alloc/src/lib.rs

@@ -218,6 +218,7 @@ pub mod collections;
 #[cfg(all(not(no_rc), not(no_sync), not(no_global_oom_handling)))]
 pub mod ffi;
 pub mod fmt;
+pub mod intrinsics;
 #[cfg(not(no_rc))]
 pub mod rc;
 pub mod slice;

library/alloc/src/macros.rs

@@ -54,7 +54,7 @@ macro_rules! vec {
         // This function isn't actually safe but the way we use it here is. We can't use an
         // unsafe block as that would also wrap `$x`.
         $crate::boxed::box_uninit_array_into_vec_unsafe(
-            $crate::boxed::write_box_via_move($crate::boxed::Box::new_uninit(), [$($x),+])
+            $crate::intrinsics::write_box_via_move($crate::boxed::Box::new_uninit(), [$($x),+])
         )
     );
 }

tests/mir-opt/building/write_box_via_move.rs

@@ -2,6 +2,8 @@
 //@ compile-flags: -Zmir-opt-level=0
 #![feature(liballoc_internals)]
 
+extern crate alloc;
+
 // Can't emit `built.after` here as that contains user type annotations which contain DefId that
 // change all the time.
 // EMIT_MIR write_box_via_move.box_new.CleanupPostBorrowck.after.mir
@@ -11,7 +13,7 @@ fn box_new<T: Copy>(x: T) -> Box<[T; 1024]> {
     let mut b = Box::new_uninit();
     // Ensure the array gets constructed directly into the deref'd pointer.
     // CHECK: (*[[TEMP1:_.+]]) = [{{(move|copy) _.+}}; 1024];
-    unsafe { std::boxed::write_box_via_move(b, [x; 1024]).assume_init() }
+    unsafe { alloc::intrinsics::write_box_via_move(b, [x; 1024]).assume_init() }
 }
 
 // EMIT_MIR write_box_via_move.vec_macro.CleanupPostBorrowck.after.mir