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

replace box_new with lower-level intrinsics

Author: rust-bors[bot]

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_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
@@ -132,6 +131,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::forget
         | sym::frem_algebraic
         | sym::fsub_algebraic
+        | sym::init_box_via_move
         | sym::is_val_statically_known
         | sym::log2f16
         | sym::log2f32
@@ -215,6 +215,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::wrapping_add
         | sym::wrapping_mul
         | sym::wrapping_sub
+        | sym::write_via_move_for_vec_unsafe
         // tidy-alphabetical-end
         => hir::Safety::Safe,
         _ => hir::Safety::Unsafe,
@@ -550,7 +551,7 @@ pub(crate) fn check_intrinsic_type(
         sym::cold_path => (0, 0, vec![], tcx.types.unit),
 
         sym::read_via_copy => (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], param(0)),
-        sym::write_via_move => {
+        sym::write_via_move | sym::write_via_move_for_vec_unsafe => {
             (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
         }
 
@@ -645,8 +646,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

@@ -3024,6 +3024,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 { .. }

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

@@ -9,8 +9,8 @@ use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::thir::*;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
-use rustc_span::DUMMY_SP;
 use rustc_span::source_map::Spanned;
+use rustc_span::{DUMMY_SP, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::{debug, instrument};
 
@@ -365,6 +365,97 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     None
                 })
             }
+            // Some intrinsics are handled here because they desperately want to avoid introducing
+            // unnecessary copies.
+            ExprKind::Call { ty, fun, ref args, .. }
+                if let ty::FnDef(def_id, _generic_args) = ty.kind()
+                    && let Some(intrinsic) = this.tcx.intrinsic(def_id)
+                    && matches!(
+                        intrinsic.name,
+                        sym::write_via_move
+                            | sym::write_via_move_for_vec_unsafe
+                            | sym::init_box_via_move
+                    ) =>
+            {
+                // We still have to evaluate the callee expression as normal (but we don't care
+                // about its result).
+                let _fun = unpack!(block = this.as_local_operand(block, fun));
+
+                match intrinsic.name {
+                    sym::write_via_move | sym::write_via_move_for_vec_unsafe => {
+                        // `write_via_move(ptr, val)` becomes `*ptr = val` but without any dropping.
+
+                        // The destination must have unit type (so we don't actually have to store anything
+                        // into it).
+                        assert!(destination.ty(&this.local_decls, this.tcx).ty.is_unit());
+
+                        // Compile this to an assignment of the argument into the destination.
+                        let [ptr, val] = **args else {
+                            span_bug!(expr_span, "invalid write_via_move call")
+                        };
+                        let Some(ptr) = unpack!(block = this.as_local_operand(block, ptr)).place()
+                        else {
+                            span_bug!(expr_span, "invalid write_via_move call")
+                        };
+                        let ptr_deref = ptr.project_deeper(&[ProjectionElem::Deref], this.tcx);
+                        this.expr_into_dest(ptr_deref, block, val)
+                    }
+                    // sym::init_box_via_move => {
+                    //     use rustc_abi::FieldIdx;
+                    //     // `init_box_via_move(b, val)` becomes
+                    //     // ```
+                    //     // *(b.0.0.0) = val;
+                    //     // ```
+                    //     let [b, val] = **args else {
+                    //         span_bug!(expr_span, "invalid init_box_via_move call")
+                    //     };
+                    //     let Some(b) = unpack!(block = this.as_local_operand(block, b)).place()
+                    //     else {
+                    //         span_bug!(expr_span, "invalid init_box_via_move call")
+                    //     };
+                    //     // Project to the pointer inside `b`. First we need to get the types of all
+                    //     // the fields we are projecting through.
+                    //     let field_ty = |adt: &ty::AdtDef<'tcx>, idx: FieldIdx| {
+                    //         let field = adt.non_enum_variant().fields[idx].did;
+                    //         this.tcx.type_of(field).instantiate_identity()
+                    //     };
+                    //     let ty::Adt(box_adt, box_adt_args) =
+                    //         b.ty(&this.local_decls, this.tcx).ty.kind()
+                    //     else {
+                    //         span_bug!(expr_span, "invalid init_box_via_move call")
+                    //     };
+                    //     // The `<T>` shared by Box, Unique, NonNull.
+                    //     let ty_arg = this.tcx.mk_args(&[box_adt_args[0]]);
+                    //     let ty::Adt(unique_adt, _args) = field_ty(box_adt, FieldIdx::Zero).kind()
+                    //     else {
+                    //         span_bug!(expr_span, "invalid init_box_via_move call")
+                    //     };
+                    //     let unique_ty = Ty::new_adt(this.tcx, unique_def, ty_arg);
+                    //     let ty::Adt(nonnull_adt, _args) =
+                    //         field_ty(unique_adt, FieldIdx::Zero).kind()
+                    //     else {
+                    //         span_bug!(expr_span, "invalid init_box_via_move call")
+                    //     };
+                    //     let nonnull_ty = Ty::new_adt(this.tcx, nonnull_adt, ty_arg);
+                    //     // Then we can construct the projection.
+                    //     let b_ptr_deref = b.project_deeper(
+                    //         &[
+                    //             ProjectionElem::Field(FieldIdx::ZERO, unique_ty),
+                    //             ProjectionElem::Field(FieldIdx::ZERO, nonnull_ty),
+                    //             ProjectionElem::Field(
+                    //                 FieldIdx::ZERO,
+                    //                 Ty::new_mut_ptr(tcx, ty_arg.type_at(0)),
+                    //             ),
+                    //             ProjectionElem::Deref,
+                    //         ],
+                    //         this.tcx,
+                    //     );
+                    //     // Store `val` into `b_ptr`.
+                    //     this.expr_into_dest(b_ptr_deref, block, val)
+                    // }
+                    _ => rustc_middle::bug!(),
+                }
+            }
             ExprKind::Call { ty: _, fun, ref args, from_hir_call, fn_span } => {
                 let fun = unpack!(block = this.as_local_operand(block, fun));
                 let args: Box<[_]> = args
@@ -769,7 +860,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             // these are the cases that are more naturally handled by some other mode
             ExprKind::Unary { .. }
             | ExprKind::Binary { .. }
-            | ExprKind::Box { .. }
             | ExprKind::Cast { .. }
             | ExprKind::PointerCoercion { .. }
             | ExprKind::Repeat { .. }

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -474,7 +474,6 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             | ExprKind::LoopMatch { .. }
             | ExprKind::Let { .. }
             | ExprKind::Match { .. }
-            | ExprKind::Box { .. }
             | ExprKind::If { .. }
             | ExprKind::InlineAsm { .. }
             | ExprKind::OffsetOf { .. }