add write_box_via_move intrinsic and use it for vec!

This allows us to get rid of box_new entirely

Author: RalfJung

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -620,11 +620,6 @@ impl<T: ?Sized> Deref for Box<T> {
     }
 }
 
-#[lang = "exchange_malloc"]
-unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
-    libc::malloc(size)
-}
-
 #[lang = "drop"]
 pub trait Drop {
     fn drop(&mut self);

compiler/rustc_codegen_gcc/example/mini_core.rs

@@ -628,11 +628,6 @@ impl<T: ?Sized, A: Allocator> Deref for Box<T, A> {
     }
 }
 
-#[lang = "exchange_malloc"]
-unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
-    libc::malloc(size)
-}
-
 #[lang = "drop"]
 pub trait Drop {
     fn drop(&mut self);

compiler/rustc_const_eval/messages.ftl

@@ -384,12 +384,6 @@ const_eval_too_many_caller_args =
 
 const_eval_unallowed_fn_pointer_call = function pointer calls are not allowed in {const_eval_const_context}s
 
-const_eval_unallowed_heap_allocations =
-    allocations are not allowed in {const_eval_const_context}s
-    .label = allocation not allowed in {const_eval_const_context}s
-    .teach_note =
-        The runtime heap is not yet available at compile-time, so no runtime heap allocations can be created.
-
 const_eval_unallowed_inline_asm =
     inline assembly is not allowed in {const_eval_const_context}s
 

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -848,13 +848,6 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     return;
                 }
 
-                // This can be called on stable via the `vec!` macro.
-                if tcx.is_lang_item(callee, LangItem::ExchangeMalloc) {
-                    self.check_op(ops::HeapAllocation);
-                    // Allow this call, skip all the checks below.
-                    return;
-                }
-
                 // Intrinsics are language primitives, not regular calls, so treat them separately.
                 if let Some(intrinsic) = tcx.intrinsic(callee) {
                     if !tcx.is_const_fn(callee) {

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -490,18 +490,6 @@ impl<'tcx> NonConstOp<'tcx> for Coroutine {
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct HeapAllocation;
-impl<'tcx> NonConstOp<'tcx> for HeapAllocation {
-    fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        ccx.dcx().create_err(errors::UnallowedHeapAllocations {
-            span,
-            kind: ccx.const_kind(),
-            teach: ccx.tcx.sess.teach(E0010),
-        })
-    }
-}
-
 #[derive(Debug)]
 pub(crate) struct InlineAsm;
 impl<'tcx> NonConstOp<'tcx> for InlineAsm {

compiler/rustc_const_eval/src/errors.rs

@@ -215,17 +215,6 @@ pub(crate) struct UnallowedOpInConstContext {
     pub msg: String,
 }
 
-#[derive(Diagnostic)]
-#[diag(const_eval_unallowed_heap_allocations, code = E0010)]
-pub(crate) struct UnallowedHeapAllocations {
-    #[primary_span]
-    #[label]
-    pub span: Span,
-    pub kind: ConstContext,
-    #[note(const_eval_teach_note)]
-    pub teach: bool,
-}
-
 #[derive(Diagnostic)]
 #[diag(const_eval_unallowed_inline_asm, code = E0015)]
 pub(crate) struct UnallowedInlineAsm {

compiler/rustc_error_codes/src/error_codes/E0010.md

@@ -1,9 +1,11 @@
+#### Note: this error code is no longer emitted by the compiler.
+
 The value of statics and constants must be known at compile time, and they live
 for the entire lifetime of a program. Creating a boxed value allocates memory on
 the heap at runtime, and therefore cannot be done at compile time.
 
 Erroneous code example:
 
-```compile_fail,E0010
+```
 const CON : Vec<i32> = vec![1, 2, 3];
 ```

compiler/rustc_hir/src/lang_items.rs

@@ -332,7 +332,7 @@ language_item_table! {
     FormatPlaceholder,       sym::format_placeholder,  format_placeholder,         Target::Struct,         GenericRequirement::None;
     FormatUnsafeArg,         sym::format_unsafe_arg,   format_unsafe_arg,          Target::Struct,         GenericRequirement::None;
 
-    ExchangeMalloc,          sym::exchange_malloc,     exchange_malloc_fn,         Target::Fn,             GenericRequirement::None;
+    BoxUninitAsMutPtr,       sym::box_uninit_as_mut_ptr, box_uninit_as_mut_ptr_fn, Target::Fn,             GenericRequirement::Exact(1);
     DropInPlace,             sym::drop_in_place,       drop_in_place_fn,           Target::Fn,             GenericRequirement::Minimum(1);
     AllocLayout,             sym::alloc_layout,        alloc_layout,               Target::Struct,         GenericRequirement::None;
 

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -76,7 +76,6 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::autodiff
         | sym::bitreverse
         | sym::black_box
-        | sym::box_new
         | sym::breakpoint
         | sym::bswap
         | sym::caller_location
@@ -215,6 +214,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::wrapping_add
         | sym::wrapping_mul
         | sym::wrapping_sub
+        | sym::write_box_via_move
         // tidy-alphabetical-end
         => hir::Safety::Safe,
         _ => hir::Safety::Unsafe,
@@ -553,6 +553,13 @@ pub(crate) fn check_intrinsic_type(
         sym::write_via_move => {
             (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
         }
+        sym::write_box_via_move => {
+            let t = param(0);
+            let maybe_uninit_t = Ty::new_maybe_uninit(tcx, t);
+            let box_mu_t = Ty::new_box(tcx, maybe_uninit_t);
+
+            (1, 0, vec![box_mu_t, param(0)], box_mu_t)
+        }
 
         sym::typed_swap_nonoverlapping => {
             (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)); 2], tcx.types.unit)
@@ -645,8 +652,6 @@ pub(crate) fn check_intrinsic_type(
 
         sym::ub_checks => (0, 0, Vec::new(), tcx.types.bool),
 
-        sym::box_new => (1, 0, vec![param(0)], Ty::new_box(tcx, param(0))),
-
         // contract_check_requires::<C>(C) -> bool, where C: impl Fn() -> bool
         sym::contract_check_requires => (1, 0, vec![param(0)], tcx.types.unit),
         sym::contract_check_ensures => {

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -3022,6 +3022,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     {
                         let deref_kind = if checked_ty.is_box() {
                             // detect Box::new(..)
+                            // FIXME: use `box_new` diagnostic item instead?
                             if let ExprKind::Call(box_new, [_]) = expr.kind
                                 && let ExprKind::Path(qpath) = &box_new.kind
                                 && let Res::Def(DefKind::AssocFn, fn_id) =