Use box syntax everywhere

Result of running:

rg -l "Box::new" compiler/ | rg '.rs$' | rg -v 'cranelift' | xargs sed -i 's/Box::new(/box (/'

Author: est31

compiler/rustc_arena/src/tests.rs

@@ -93,7 +93,7 @@ pub fn bench_copy(b: &mut Bencher) {
 #[bench]
 pub fn bench_copy_nonarena(b: &mut Bencher) {
     b.iter(|| {
-        let _: Box<_> = Box::new(Point { x: 1, y: 2, z: 3 });
+        let _: Box<_> = box (Point { x: 1, y: 2, z: 3 });
     })
 }
 
@@ -227,6 +227,6 @@ pub fn bench_noncopy(b: &mut Bencher) {
 pub fn bench_noncopy_nonarena(b: &mut Bencher) {
     b.iter(|| {
         let _: Box<_> =
-            Box::new(Noncopy { string: "hello world".to_string(), array: vec![1, 2, 3, 4, 5] });
+            box (Noncopy { string: "hello world".to_string(), array: vec![1, 2, 3, 4, 5] });
     })
 }

compiler/rustc_ast/src/tokenstream.rs

@@ -141,7 +141,7 @@ pub struct LazyTokenStream(Lrc<Box<dyn CreateTokenStream>>);
 
 impl LazyTokenStream {
     pub fn new(inner: impl CreateTokenStream + 'static) -> LazyTokenStream {
-        LazyTokenStream(Lrc::new(Box::new(inner)))
+        LazyTokenStream(Lrc::new(box (inner)))
     }
 
     pub fn create_token_stream(&self) -> AttrAnnotatedTokenStream {

compiler/rustc_builtin_macros/src/concat_idents.rs

@@ -66,5 +66,5 @@ pub fn expand_concat_idents<'cx>(
         }
     }
 
-    Box::new(ConcatIdentsResult { ident })
+    box (ConcatIdentsResult { ident })
 }

compiler/rustc_builtin_macros/src/deriving/clone.rs

@@ -45,28 +45,28 @@ pub fn expand_deriving_clone(
                 {
                     bounds = vec![];
                     is_shallow = true;
-                    substructure = combine_substructure(Box::new(|c, s, sub| {
+                    substructure = combine_substructure(box (|c, s, sub| {
                         cs_clone_shallow("Clone", c, s, sub, false)
                     }));
                 } else {
                     bounds = vec![];
                     is_shallow = false;
                     substructure =
-                        combine_substructure(Box::new(|c, s, sub| cs_clone("Clone", c, s, sub)));
+                        combine_substructure(box (|c, s, sub| cs_clone("Clone", c, s, sub)));
                 }
             }
             ItemKind::Union(..) => {
                 bounds = vec![Literal(path_std!(marker::Copy))];
                 is_shallow = true;
-                substructure = combine_substructure(Box::new(|c, s, sub| {
+                substructure = combine_substructure(box (|c, s, sub| {
                     cs_clone_shallow("Clone", c, s, sub, true)
                 }));
             }
             _ => {
                 bounds = vec![];
                 is_shallow = false;
                 substructure =
-                    combine_substructure(Box::new(|c, s, sub| cs_clone("Clone", c, s, sub)));
+                    combine_substructure(box (|c, s, sub| cs_clone("Clone", c, s, sub)));
             }
         },
 

compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs

@@ -38,7 +38,7 @@ pub fn expand_deriving_eq(
             attributes: attrs,
             is_unsafe: false,
             unify_fieldless_variants: true,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
+            combine_substructure: combine_substructure(box (|a, b, c| {
                 cs_total_eq_assert(a, b, c)
             })),
         }],

compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs

@@ -34,7 +34,7 @@ pub fn expand_deriving_ord(
             attributes: attrs,
             is_unsafe: false,
             unify_fieldless_variants: true,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| cs_cmp(a, b, c))),
+            combine_substructure: combine_substructure(box (|a, b, c| cs_cmp(a, b, c))),
         }],
         associated_types: Vec::new(),
     };
@@ -100,7 +100,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P<
             cx.expr_match(span, new, vec![eq_arm, neq_arm])
         },
         cx.expr_path(equals_path.clone()),
-        Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| {
+        box (|cx, span, (self_args, tag_tuple), _non_self_args| {
             if self_args.len() != 2 {
                 cx.span_bug(span, "not exactly 2 arguments in `derive(Ord)`")
             } else {

compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs

@@ -49,7 +49,7 @@ pub fn expand_deriving_partial_eq(
                     None => cx.expr_bool(span, base),
                 }
             },
-            Box::new(|cx, span, _, _| cx.expr_bool(span, !base)),
+            box (|cx, span, _, _| cx.expr_bool(span, !base)),
             cx,
             span,
             substr,
@@ -76,7 +76,7 @@ pub fn expand_deriving_partial_eq(
                 attributes: attrs,
                 is_unsafe: false,
                 unify_fieldless_variants: true,
-                combine_substructure: combine_substructure(Box::new(|a, b, c| $f(a, b, c))),
+                combine_substructure: combine_substructure(box (|a, b, c| $f(a, b, c))),
             }
         }};
     }

compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs

@@ -19,7 +19,7 @@ pub fn expand_deriving_partial_ord(
     let ret_ty = Literal(Path::new_(
         pathvec_std!(option::Option),
         None,
-        vec![Box::new(ordering_ty)],
+        vec![box (ordering_ty)],
         PathKind::Std,
     ));
 
@@ -35,7 +35,7 @@ pub fn expand_deriving_partial_ord(
         attributes: attrs,
         is_unsafe: false,
         unify_fieldless_variants: true,
-        combine_substructure: combine_substructure(Box::new(|cx, span, substr| {
+        combine_substructure: combine_substructure(box (|cx, span, substr| {
             cs_partial_cmp(cx, span, substr)
         })),
     };
@@ -103,7 +103,7 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_
             cx.expr_match(span, new, vec![eq_arm, neq_arm])
         },
         equals_expr,
-        Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| {
+        box (|cx, span, (self_args, tag_tuple), _non_self_args| {
             if self_args.len() != 2 {
                 cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`")
             } else {

compiler/rustc_builtin_macros/src/deriving/debug.rs

@@ -21,7 +21,7 @@ pub fn expand_deriving_debug(
 ) {
     // &mut ::std::fmt::Formatter
     let fmtr =
-        Ptr(Box::new(Literal(path_std!(fmt::Formatter))), Borrowed(None, ast::Mutability::Mut));
+        Ptr(box (Literal(path_std!(fmt::Formatter))), Borrowed(None, ast::Mutability::Mut));
 
     let trait_def = TraitDef {
         span,
@@ -40,7 +40,7 @@ pub fn expand_deriving_debug(
             attributes: Vec::new(),
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
+            combine_substructure: combine_substructure(box (|a, b, c| {
                 show_substructure(a, b, c)
             })),
         }],

compiler/rustc_builtin_macros/src/deriving/decodable.rs

@@ -38,15 +38,15 @@ pub fn expand_deriving_rustc_decodable(
             },
             explicit_self: None,
             args: vec![(
-                Ptr(Box::new(Literal(Path::new_local(typaram))), Borrowed(None, Mutability::Mut)),
+                Ptr(box (Literal(Path::new_local(typaram))), Borrowed(None, Mutability::Mut)),
                 sym::d,
             )],
             ret_ty: Literal(Path::new_(
                 pathvec_std!(result::Result),
                 None,
                 vec![
-                    Box::new(Self_),
-                    Box::new(Literal(Path::new_(
+                    box (Self_),
+                    box (Literal(Path::new_(
                         vec![typaram, sym::Error],
                         None,
                         vec![],
@@ -58,7 +58,7 @@ pub fn expand_deriving_rustc_decodable(
             attributes: Vec::new(),
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
+            combine_substructure: combine_substructure(box (|a, b, c| {
                 decodable_substructure(a, b, c, krate)
             })),
         }],