replace box_new with lower-level intrinsics

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

@@ -543,18 +543,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
+```ignore (no longer emitted)
 const CON : Vec<i32> = vec![1, 2, 3];
 ```

compiler/rustc_error_codes/src/lib.rs

@@ -26,7 +26,8 @@
 //
 // Do *not* remove entries from this list. Instead, just add a note th the corresponding markdown
 // file saying that this error is not emitted by the compiler any more (see E0001.md for an
-// example), and remove all code examples that do not build any more.
+// example), and remove all code examples that do not build any more by marking them
+// with `ignore (no longer emitted)`.
 #[macro_export]
 macro_rules! error_codes {
     ($macro:path) => (

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

@@ -3033,6 +3033,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) =

compiler/rustc_middle/src/thir.rs

@@ -284,10 +284,6 @@ pub enum ExprKind<'tcx> {
         lint_level: LintLevel,
         value: ExprId,
     },
-    /// A `box <value>` expression.
-    Box {
-        value: ExprId,
-    },
     /// An `if` expression.
     If {
         if_then_scope: region::Scope,

compiler/rustc_middle/src/thir/visit.rs

@@ -50,7 +50,6 @@ pub fn walk_expr<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
         Scope { value, region_scope: _, lint_level: _ } => {
             visitor.visit_expr(&visitor.thir()[value])
         }
-        Box { value } => visitor.visit_expr(&visitor.thir()[value]),
         If { cond, then, else_opt, if_then_scope: _ } => {
             visitor.visit_expr(&visitor.thir()[cond]);
             visitor.visit_expr(&visitor.thir()[then]);

compiler/rustc_mir_build/src/builder/expr/as_place.rs

@@ -553,7 +553,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::Unary { .. }
             | ExprKind::Binary { .. }
             | ExprKind::LogicalOp { .. }
-            | ExprKind::Box { .. }
             | ExprKind::Cast { .. }
             | ExprKind::Use { .. }
             | ExprKind::NeverToAny { .. }

compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs

@@ -1,7 +1,6 @@
 //! See docs in `build/expr/mod.rs`.
 
 use rustc_abi::FieldIdx;
-use rustc_hir::lang_items::LangItem;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::bug;
 use rustc_middle::middle::region;
@@ -121,65 +120,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 }
                 block.and(Rvalue::UnaryOp(op, arg))
             }
-            ExprKind::Box { value } => {
-                let value_ty = this.thir[value].ty;
-                let tcx = this.tcx;
-                let source_info = this.source_info(expr_span);
-
-                let size = tcx.require_lang_item(LangItem::SizeOf, expr_span);
-                let size = Operand::unevaluated_constant(tcx, size, &[value_ty.into()], expr_span);
-
-                let align = tcx.require_lang_item(LangItem::AlignOf, expr_span);
-                let align =
-                    Operand::unevaluated_constant(tcx, align, &[value_ty.into()], expr_span);
-
-                // malloc some memory of suitable size and align:
-                let exchange_malloc = Operand::function_handle(
-                    tcx,
-                    tcx.require_lang_item(LangItem::ExchangeMalloc, expr_span),
-                    [],
-                    expr_span,
-                );
-                let storage = this.temp(Ty::new_mut_ptr(tcx, tcx.types.u8), expr_span);
-                let success = this.cfg.start_new_block();
-                this.cfg.terminate(
-                    block,
-                    source_info,
-                    TerminatorKind::Call {
-                        func: exchange_malloc,
-                        args: [
-                            Spanned { node: size, span: DUMMY_SP },
-                            Spanned { node: align, span: DUMMY_SP },
-                        ]
-                        .into(),
-                        destination: storage,
-                        target: Some(success),
-                        unwind: UnwindAction::Continue,
-                        call_source: CallSource::Misc,
-                        fn_span: expr_span,
-                    },
-                );
-                this.diverge_from(block);
-                block = success;
-
-                let result = this.local_decls.push(LocalDecl::new(expr.ty, expr_span));
-                this.cfg
-                    .push(block, Statement::new(source_info, StatementKind::StorageLive(result)));
-                if let Some(scope) = scope.temp_lifetime {
-                    // schedule a shallow free of that memory, lest we unwind:
-                    this.schedule_drop_storage_and_value(expr_span, scope, result);
-                }
-
-                // Transmute `*mut u8` to the box (thus far, uninitialized):
-                let box_ = Rvalue::ShallowInitBox(Operand::Move(storage), value_ty);
-                this.cfg.push_assign(block, source_info, Place::from(result), box_);
-
-                // initialize the box contents:
-                block = this
-                    .expr_into_dest(this.tcx.mk_place_deref(Place::from(result)), block, value)
-                    .into_block();
-                block.and(Rvalue::Use(Operand::Move(Place::from(result))))
-            }
             ExprKind::Cast { source } => {
                 let source_expr = &this.thir[source];
 

compiler/rustc_mir_build/src/builder/expr/category.rs

@@ -64,7 +64,6 @@ impl Category {
             | ExprKind::Closure { .. }
             | ExprKind::Unary { .. }
             | ExprKind::Binary { .. }
-            | ExprKind::Box { .. }
             | ExprKind::Cast { .. }
             | ExprKind::PointerCoercion { .. }
             | ExprKind::Repeat { .. }