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)
             })),
         }],

compiler/rustc_builtin_macros/src/deriving/default.rs

@@ -41,7 +41,7 @@ pub fn expand_deriving_default(
             attributes: attrs,
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(Box::new(|cx, trait_span, substr| {
+            combine_substructure: combine_substructure(box (|cx, trait_span, substr| {
                 match substr.fields {
                     StaticStruct(_, fields) => {
                         default_struct_substructure(cx, trait_span, substr, fields)

compiler/rustc_builtin_macros/src/deriving/encodable.rs

@@ -123,15 +123,15 @@ pub fn expand_deriving_rustc_encodable(
             },
             explicit_self: borrowed_explicit_self(),
             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::s,
             )],
             ret_ty: Literal(Path::new_(
                 pathvec_std!(result::Result),
                 None,
                 vec![
-                    Box::new(Tuple(Vec::new())),
-                    Box::new(Literal(Path::new_(
+                    box (Tuple(Vec::new())),
+                    box (Literal(Path::new_(
                         vec![typaram, sym::Error],
                         None,
                         vec![],
@@ -143,7 +143,7 @@ pub fn expand_deriving_rustc_encodable(
             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| {
                 encodable_substructure(a, b, c, krate)
             })),
         }],

compiler/rustc_builtin_macros/src/deriving/generic/ty.rs

@@ -113,7 +113,7 @@ pub fn borrowed_explicit_self() -> Option<Option<PtrTy>> {
 }
 
 pub fn borrowed_self() -> Ty {
-    borrowed(Box::new(Self_))
+    borrowed(box (Self_))
 }
 
 pub fn nil_ty() -> Ty {

compiler/rustc_builtin_macros/src/deriving/hash.rs

@@ -32,12 +32,12 @@ pub fn expand_deriving_hash(
             name: sym::hash,
             generics: Bounds { bounds: vec![(typaram, vec![path_std!(hash::Hasher)])] },
             explicit_self: borrowed_explicit_self(),
-            args: vec![(Ptr(Box::new(Literal(arg)), Borrowed(None, Mutability::Mut)), sym::state)],
+            args: vec![(Ptr(box (Literal(arg)), Borrowed(None, Mutability::Mut)), sym::state)],
             ret_ty: nil_ty(),
             attributes: vec![],
             is_unsafe: false,
             unify_fieldless_variants: true,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
+            combine_substructure: combine_substructure(box (|a, b, c| {
                 hash_substructure(a, b, c)
             })),
         }],

compiler/rustc_builtin_macros/src/lib.rs

@@ -51,13 +51,13 @@ pub mod test_harness;
 pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
     let mut register = |name, kind| resolver.register_builtin_macro(name, kind);
     macro register_bang($($name:ident: $f:expr,)*) {
-        $(register(sym::$name, SyntaxExtensionKind::LegacyBang(Box::new($f as MacroExpanderFn)));)*
+        $(register(sym::$name, SyntaxExtensionKind::LegacyBang(box ($f as MacroExpanderFn)));)*
     }
     macro register_attr($($name:ident: $f:expr,)*) {
-        $(register(sym::$name, SyntaxExtensionKind::LegacyAttr(Box::new($f)));)*
+        $(register(sym::$name, SyntaxExtensionKind::LegacyAttr(box ($f)));)*
     }
     macro register_derive($($name:ident: $f:expr,)*) {
-        $(register(sym::$name, SyntaxExtensionKind::LegacyDerive(Box::new(BuiltinDerive($f))));)*
+        $(register(sym::$name, SyntaxExtensionKind::LegacyDerive(box (BuiltinDerive($f))));)*
     }
 
     register_bang! {
@@ -113,5 +113,5 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
     }
 
     let client = proc_macro::bridge::client::Client::expand1(proc_macro::quote);
-    register(sym::quote, SyntaxExtensionKind::Bang(Box::new(BangProcMacro { client })));
+    register(sym::quote, SyntaxExtensionKind::Bang(box (BangProcMacro { client })));
 }

compiler/rustc_builtin_macros/src/source_util.rs

@@ -159,7 +159,7 @@ pub fn expand_include<'cx>(
         }
     }
 
-    Box::new(ExpandResult { p, node_id: cx.current_expansion.lint_node_id })
+    box (ExpandResult { p, node_id: cx.current_expansion.lint_node_id })
 }
 
 // include_str! : read the given file, insert it as a literal string expr

compiler/rustc_codegen_llvm/src/back/archive.rs

@@ -284,7 +284,7 @@ impl<'a> LlvmArchiveBuilder<'a> {
         self.additions.push(Addition::Archive {
             path: archive.to_path_buf(),
             archive: archive_ro,
-            skip: Box::new(skip),
+            skip: box (skip),
         });
         Ok(())
     }

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -249,7 +249,7 @@ impl<'a> DiagnosticHandlers<'a> {
         handler: &'a Handler,
         llcx: &'a llvm::Context,
     ) -> Self {
-        let data = Box::into_raw(Box::new((cgcx, handler)));
+        let data = Box::into_raw(box ((cgcx, handler)));
         unsafe {
             llvm::LLVMRustSetInlineAsmDiagnosticHandler(llcx, inline_asm_handler, data.cast());
             llvm::LLVMContextSetDiagnosticHandler(llcx, diagnostic_handler, data.cast());

compiler/rustc_codegen_llvm/src/lib.rs

@@ -197,7 +197,7 @@ unsafe impl Sync for LlvmCodegenBackend {}
 
 impl LlvmCodegenBackend {
     pub fn new() -> Box<dyn CodegenBackend> {
-        Box::new(LlvmCodegenBackend(()))
+        box (LlvmCodegenBackend(()))
     }
 }
 
@@ -253,7 +253,7 @@ impl CodegenBackend for LlvmCodegenBackend {
         metadata: EncodedMetadata,
         need_metadata_module: bool,
     ) -> Box<dyn Any> {
-        Box::new(rustc_codegen_ssa::base::codegen_crate(
+        box (rustc_codegen_ssa::base::codegen_crate(
             LlvmCodegenBackend(()),
             tcx,
             crate::llvm_util::target_cpu(tcx.sess).to_string(),

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -130,26 +130,26 @@ pub fn get_linker<'a>(
 
     match flavor {
         LinkerFlavor::Lld(LldFlavor::Link) | LinkerFlavor::Msvc => {
-            Box::new(MsvcLinker { cmd, sess }) as Box<dyn Linker>
+            box (MsvcLinker { cmd, sess }) as Box<dyn Linker>
         }
-        LinkerFlavor::Em => Box::new(EmLinker { cmd, sess }) as Box<dyn Linker>,
+        LinkerFlavor::Em => box (EmLinker { cmd, sess }) as Box<dyn Linker>,
         LinkerFlavor::Gcc => {
-            Box::new(GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: false })
+            box (GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: false })
                 as Box<dyn Linker>
         }
 
         LinkerFlavor::Lld(LldFlavor::Ld)
         | LinkerFlavor::Lld(LldFlavor::Ld64)
         | LinkerFlavor::Ld => {
-            Box::new(GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: true })
+            box (GccLinker { cmd, sess, target_cpu, hinted_static: false, is_ld: true })
                 as Box<dyn Linker>
         }
 
-        LinkerFlavor::Lld(LldFlavor::Wasm) => Box::new(WasmLd::new(cmd, sess)) as Box<dyn Linker>,
+        LinkerFlavor::Lld(LldFlavor::Wasm) => box (WasmLd::new(cmd, sess)) as Box<dyn Linker>,
 
-        LinkerFlavor::PtxLinker => Box::new(PtxLinker { cmd, sess }) as Box<dyn Linker>,
+        LinkerFlavor::PtxLinker => box (PtxLinker { cmd, sess }) as Box<dyn Linker>,
 
-        LinkerFlavor::BpfLinker => Box::new(BpfLinker { cmd, sess }) as Box<dyn Linker>,
+        LinkerFlavor::BpfLinker => box (BpfLinker { cmd, sess }) as Box<dyn Linker>,
     }
 }