fix ui test fallout

Author: RalfJung

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

@@ -368,7 +368,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             // 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()
+                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::init_box_via_move) =>
             {
@@ -396,15 +396,18 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         this.expr_into_dest(ptr_deref, block, val)
                     }
                     sym::init_box_via_move => {
-                        // `write_via_move(b, val)` becomes
+                        // `init_box_via_move(b, val)` becomes
                         // ```
-                        // *transmute::<_, *mut T>(b) = val;
+                        // *transmute::<_, *mut T>(b.0) = val;
                         // transmute::<_, Box<T>>(b)
                         // ```
-                        let t = generic_args.type_at(0);
                         let [b, val] = **args else {
                             span_bug!(expr_span, "invalid init_box_via_move call")
                         };
+                        // We get the type from `val` to (hopefully) ensure the lifetimes match.
+                        // FIXME: That does not work.
+                        let t = this.thir.exprs[val].ty;
+
                         let Some(b) = unpack!(block = this.as_local_operand(block, b)).place()
                         else {
                             span_bug!(expr_span, "invalid init_box_via_move call")
@@ -435,7 +438,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             &[ProjectionElem::Field(rustc_abi::FieldIdx::ZERO, unique_ty)],
                             this.tcx,
                         );
-                        // `ptr` is `b` transmuted to `*mut T`.
+                        // `ptr` is `b.0` transmuted to `*mut T`.
                         let ptr_ty = Ty::new_mut_ptr(this.tcx, t);
                         let ptr = this.local_decls.push(LocalDecl::new(ptr_ty, expr_span));
                         this.cfg.push(

library/alloc/src/boxed.rs

@@ -248,7 +248,7 @@ unsafe fn box_new_uninit(size: usize, align: usize) -> *mut u8 {
     }
 }
 
-/// Writes `x` into `b`, then returns `b` at its new type`.
+/// Writes `x` into `b`, then returns `b` at its new type.
 ///
 /// 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

tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs

@@ -1,7 +1,7 @@
 const fn foo(a: i32) -> Vec<i32> {
     vec![1, 2, 3]
-    //~^ ERROR allocations are not allowed
-    //~| ERROR cannot call non-const method
+    //~^ ERROR cannot call non-const
+    //~| ERROR cannot call non-const
 }
 
 fn main() {}

tests/ui/consts/min_const_fn/bad_const_fn_body_ice.stderr

@@ -1,12 +1,13 @@
-error[E0010]: allocations are not allowed in constant functions
+error[E0015]: cannot call non-const associated function `Box::<[i32; 3]>::new_uninit` in constant functions
   --> $DIR/bad_const_fn_body_ice.rs:2:5
    |
 LL |     vec![1, 2, 3]
-   |     ^^^^^^^^^^^^^ allocation not allowed in constant functions
+   |     ^^^^^^^^^^^^^
    |
+   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0015]: cannot call non-const method `slice::<impl [i32]>::into_vec::<std::alloc::Global>` in constant functions
+error[E0015]: cannot call non-const function `box_array_into_vec::<i32, 3>` in constant functions
   --> $DIR/bad_const_fn_body_ice.rs:2:5
    |
 LL |     vec![1, 2, 3]
@@ -17,5 +18,4 @@ LL |     vec![1, 2, 3]
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0010, E0015.
-For more information about an error, try `rustc --explain E0010`.
+For more information about this error, try `rustc --explain E0015`.

tests/ui/coroutine/issue-105084.rs

@@ -14,12 +14,12 @@ fn copy<T: Copy>(x: T) -> T {
 fn main() {
     let mut g = #[coroutine]
     || {
-        // This is desuraged as 4 stages:
-        // - allocate a `*mut u8` with `exchange_malloc`;
-        // - create a Box that is ignored for trait computations;
+        // This is desuraged as 3 stages:
+        // - `init_box_via_move`
         // - compute fields (and yields);
         // - assign to `t`.
-        let t = std::boxed::box_new((5, yield));
+        let t = Box::new_uninit();
+        let t = std::boxed::init_box_via_move(t, (5, yield));
         drop(t);
     };
 
@@ -30,7 +30,7 @@ fn main() {
     // As it is not taken into account for trait computation,
     // the coroutine is `Copy`.
     let mut h = copy(g);
-    //~^ ERROR the trait bound `Box<(i32, ())>: Copy` is not satisfied in
+    //~^ ERROR the trait bound `Box<MaybeUninit<(i32, ())>>: Copy` is not satisfied in
 
     // We now have 2 boxes with the same backing allocation:
     // one inside `g` and one inside `h`.

tests/ui/coroutine/issue-105084.stderr

@@ -22,23 +22,22 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     let mut h = copy(g.clone());
    |                       ++++++++
 
-error[E0277]: the trait bound `Box<(i32, ())>: Copy` is not satisfied in `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`
+error[E0277]: the trait bound `Box<MaybeUninit<(i32, ())>>: Copy` is not satisfied in `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`
   --> $DIR/issue-105084.rs:32:17
    |
 LL |     || {
    |     -- within this `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`
 ...
 LL |     let mut h = copy(g);
-   |                 ^^^^^^^ within `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`, the trait `Copy` is not implemented for `Box<(i32, ())>`
+   |                 ^^^^^^^ within `{coroutine@$DIR/issue-105084.rs:16:5: 16:7}`, the trait `Copy` is not implemented for `Box<MaybeUninit<(i32, ())>>`
    |
 note: coroutine does not implement `Copy` as this value is used across a yield
-  --> $DIR/issue-105084.rs:22:41
+  --> $DIR/issue-105084.rs:22:54
    |
-LL |         let t = std::boxed::box_new((5, yield));
-   |                 ------------------------^^^^^--
-   |                 |                       |
-   |                 |                       yield occurs here, with `std::boxed::box_new((5, yield))` maybe used later
-   |                 has type `Box<(i32, ())>` which does not implement `Copy`
+LL |         let t = std::boxed::init_box_via_move(t, (5, yield));
+   |                                               -      ^^^^^ yield occurs here, with `t` maybe used later
+   |                                               |
+   |                                               has type `Box<MaybeUninit<(i32, ())>>` which does not implement `Copy`
 note: required by a bound in `copy`
   --> $DIR/issue-105084.rs:10:12
    |