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

replace box_new with lower-level intrinsics

Author: rust-bors[bot]

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1535,6 +1535,36 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             .unwrap();
                         }
                     }
+                    CastKind::ConstToMut => {
+                        let ty::RawPtr(ty_from, hir::Mutability::Not) =
+                            op.ty(self.body, tcx).kind()
+                        else {
+                            span_mirbug!(self, rvalue, "unexpected base type for cast {:?}", ty,);
+                            return;
+                        };
+                        let ty::RawPtr(ty_to, hir::Mutability::Mut) = ty.kind() else {
+                            span_mirbug!(self, rvalue, "unexpected target type for cast {:?}", ty,);
+                            return;
+                        };
+                        if let Err(terr) = self.sub_types(
+                            *ty_from,
+                            *ty_to,
+                            location.to_locations(),
+                            ConstraintCategory::Cast {
+                                is_implicit_coercion: false,
+                                unsize_to: None,
+                            },
+                        ) {
+                            span_mirbug!(
+                                self,
+                                rvalue,
+                                "relating {:?} with {:?} yields {:?}",
+                                ty_from,
+                                ty_to,
+                                terr
+                            );
+                        }
+                    }
                     CastKind::Transmute => {
                         let ty_from = op.ty(self.body, tcx);
                         match ty_from.kind() {

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -622,11 +622,6 @@ impl<T: ?Sized> Deref for Box<T> {
     }
 }
 
-#[lang = "exchange_malloc"]
-unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
-    unsafe { 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_codegen_ssa/src/mir/rvalue.rs

@@ -444,7 +444,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     ) => {
                         bug!("{kind:?} is for borrowck, and should never appear in codegen");
                     }
-                    mir::CastKind::PtrToPtr
+                    mir::CastKind::PtrToPtr | mir::CastKind::ConstToMut
                         if bx.cx().is_backend_scalar_pair(operand.layout) =>
                     {
                         if let OperandValue::Pair(data_ptr, meta) = operand.val {
@@ -463,6 +463,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     | mir::CastKind::FloatToFloat
                     | mir::CastKind::IntToFloat
                     | mir::CastKind::PtrToPtr
+                    | mir::CastKind::ConstToMut
                     | mir::CastKind::FnPtrToPtr
                     // Since int2ptr can have arbitrary integer types as input (so we have to do
                     // sign extension and all that), it is currently best handled in the same code

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

@@ -845,13 +845,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

@@ -541,18 +541,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_const_eval/src/interpret/cast.rs

@@ -61,7 +61,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.write_immediate(*res, dest)?;
             }
 
-            CastKind::FnPtrToPtr | CastKind::PtrToPtr => {
+            CastKind::FnPtrToPtr | CastKind::PtrToPtr | CastKind::ConstToMut => {
                 let src = self.read_immediate(src)?;
                 let res = self.ptr_to_ptr(&src, cast_layout)?;
                 self.write_immediate(*res, dest)?;

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];
 ```