Auto merge of #108471 - clubby789:unbox-the-syntax, r=Nilstrieb,est31

Remove `box_syntax`

r? `@Nilstrieb`

This removes the feature `box_syntax`, which allows the use of `box <expr>` to create a Box, and finalises removing use of the feature from the compiler. `box_patterns` (allowing the use of `box <pat>` in a pattern) is unaffected.
It also removes `ast::ExprKind::Box` - the only way to create a 'box' expression now is with the rustc-internal `#[rustc_box]` attribute.
As a temporary measure to help users move away, `box <expr>` now parses the inner expression, and emits a `MachineApplicable` lint to replace it with `Box::new`

Closes #49733

Author: bors

tests/fail/function_pointers/execute_memory.rs

@@ -1,10 +1,8 @@
 // Validation makes this fail in the wrong place
 //@compile-flags: -Zmiri-disable-validation
 
-#![feature(box_syntax)]
-
 fn main() {
-    let x = box 42;
+    let x = Box::new(42);
     unsafe {
         let f = std::mem::transmute::<Box<i32>, fn()>(x);
         f() //~ ERROR: function pointer but it does not point to a function

tests/pass/drop_empty_slice.rs

@@ -1,7 +1,5 @@
-#![feature(box_syntax)]
-
 fn main() {
     // With the nested Vec, this is calling Offset(Unique::empty(), 0) on drop.
     let args: Vec<Vec<i32>> = Vec::new();
-    let _val = box args;
+    let _val = Box::new(args);
 }

tests/pass/dst-struct.rs

@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 struct Fat<T: ?Sized> {
     f1: isize,
     f2: &'static str,
@@ -109,14 +107,14 @@ pub fn main() {
     assert_eq!((*f2)[1], 2);
 
     // Nested Box.
-    let f1: Box<Fat<[isize; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+    let f1: Box<Fat<[isize; 3]>> = Box::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
     foo(&*f1);
     let f2: Box<Fat<[isize]>> = f1;
     foo(&*f2);
 
     let f3: Box<Fat<[isize]>> =
         Box::<Fat<[_; 3]>>::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
     foo(&*f3);
-    let f4: Box<Fat<[isize]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+    let f4: Box<Fat<[isize]>> = Box::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
     foo(&*f4);
 }

tests/pass/heap.rs

@@ -1,13 +1,7 @@
-#![feature(box_syntax)]
-
 fn make_box() -> Box<(i16, i16)> {
     Box::new((1, 2))
 }
 
-fn make_box_syntax() -> Box<(i16, i16)> {
-    box (1, 2)
-}
-
 fn allocate_reallocate() {
     let mut s = String::new();
 
@@ -29,6 +23,5 @@ fn allocate_reallocate() {
 
 fn main() {
     assert_eq!(*make_box(), (1, 2));
-    assert_eq!(*make_box_syntax(), (1, 2));
     allocate_reallocate();
 }

tests/pass/issues/issue-3794.rs

@@ -1,5 +1,3 @@
-#![feature(box_syntax)]
-
 trait T {
     fn print(&self);
 }
@@ -25,7 +23,7 @@ fn print_s(s: &S) {
 }
 
 pub fn main() {
-    let s: Box<S> = box S { s: 5 };
+    let s: Box<S> = Box::new(S { s: 5 });
     print_s(&*s);
     let t: Box<dyn T> = s as Box<dyn T>;
     print_t(&*t);

tests/pass/move-arg-2-unique.rs

@@ -1,11 +1,9 @@
-#![feature(box_syntax)]
-
 fn test(foo: Box<Vec<isize>>) {
     assert_eq!((*foo)[0], 10);
 }
 
 pub fn main() {
-    let x = box vec![10];
+    let x = Box::new(vec![10]);
     // Test forgetting a local by move-in
     test(x);
 }

tests/pass/move-arg-3-unique.rs

@@ -1,7 +1,5 @@
-#![feature(box_syntax)]
-
 pub fn main() {
-    let x = box 10;
+    let x = Box::new(10);
     let y = x;
     assert_eq!(*y, 10);
 }

tests/pass/mpsc.rs

@@ -1,15 +1,13 @@
-#![feature(box_syntax)]
-
 use std::sync::mpsc::channel;
 
 pub fn main() {
     let (tx, rx) = channel::<Box<_>>();
-    tx.send(box 100).unwrap();
+    tx.send(Box::new(100)).unwrap();
     let v = rx.recv().unwrap();
-    assert_eq!(v, box 100);
+    assert_eq!(v, Box::new(100));
 
-    tx.send(box 101).unwrap();
-    tx.send(box 102).unwrap();
-    assert_eq!(rx.recv().unwrap(), box 101);
-    assert_eq!(rx.recv().unwrap(), box 102);
+    tx.send(Box::new(101)).unwrap();
+    tx.send(Box::new(102)).unwrap();
+    assert_eq!(rx.recv().unwrap(), Box::new(101));
+    assert_eq!(rx.recv().unwrap(), Box::new(102));
 }

tests/pass/regions-lifetime-nonfree-late-bound.rs

@@ -12,16 +12,14 @@
 // doing region-folding, when really all clients of the region-folding
 // case only want to see *free* lifetime variables, not bound ones.
 
-#![feature(box_syntax)]
-
 pub fn main() {
     fn explicit() {
         fn test<F>(_x: Option<Box<F>>)
         where
             F: FnMut(Box<dyn for<'a> FnMut(&'a isize)>),
         {
         }
-        test(Some(box |_f: Box<dyn for<'a> FnMut(&'a isize)>| {}));
+        test(Some(Box::new(|_f: Box<dyn for<'a> FnMut(&'a isize)>| {})));
     }
 
     // The code below is shorthand for the code above (and more likely
@@ -32,7 +30,7 @@ pub fn main() {
             F: FnMut(Box<dyn FnMut(&isize)>),
         {
         }
-        test(Some(box |_f: Box<dyn FnMut(&isize)>| {}));
+        test(Some(Box::new(|_f: Box<dyn FnMut(&isize)>| {})));
     }
 
     explicit();