Run x.py fmt

est31 · est31 · commit 75dbbbaf4d8c · 2021-08-05T22:38:27.000+02:00
diff --git a/compiler/rustc_builtin_macros/src/deriving/clone.rs b/compiler/rustc_builtin_macros/src/deriving/clone.rs
@@ -45,9 +45,9 @@ pub fn expand_deriving_clone(
                 {
                     bounds = vec![];
                     is_shallow = true;
-                    substructure = combine_substructure(box (|c, s, sub| {
-                        cs_clone_shallow("Clone", c, s, sub, false)
-                    }));
+                    substructure = combine_substructure(
+                        box (|c, s, sub| cs_clone_shallow("Clone", c, s, sub, false)),
+                    );
                 } else {
                     bounds = vec![];
                     is_shallow = false;
@@ -58,15 +58,14 @@ pub fn expand_deriving_clone(
             ItemKind::Union(..) => {
                 bounds = vec![Literal(path_std!(marker::Copy))];
                 is_shallow = true;
-                substructure = combine_substructure(box (|c, s, sub| {
-                    cs_clone_shallow("Clone", c, s, sub, true)
-                }));
+                substructure = combine_substructure(
+                    box (|c, s, sub| cs_clone_shallow("Clone", c, s, sub, true)),
+                );
             }
             _ => {
                 bounds = vec![];
                 is_shallow = false;
-                substructure =
-                    combine_substructure(box (|c, s, sub| cs_clone("Clone", c, s, sub)));
+                substructure = combine_substructure(box (|c, s, sub| cs_clone("Clone", c, s, sub)));
             }
         },
 
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
@@ -38,9 +38,7 @@ pub fn expand_deriving_eq(
             attributes: attrs,
             is_unsafe: false,
             unify_fieldless_variants: true,
-            combine_substructure: combine_substructure(box (|a, b, c| {
-                cs_total_eq_assert(a, b, c)
-            })),
+            combine_substructure: combine_substructure(box (|a, b, c| cs_total_eq_assert(a, b, c))),
         }],
         associated_types: Vec::new(),
     };
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
@@ -35,9 +35,9 @@ pub fn expand_deriving_partial_ord(
         attributes: attrs,
         is_unsafe: false,
         unify_fieldless_variants: true,
-        combine_substructure: combine_substructure(box (|cx, span, substr| {
-            cs_partial_cmp(cx, span, substr)
-        })),
+        combine_substructure: combine_substructure(
+            box (|cx, span, substr| cs_partial_cmp(cx, span, substr)),
+        ),
     };
 
     let trait_def = TraitDef {
diff --git a/compiler/rustc_builtin_macros/src/deriving/debug.rs b/compiler/rustc_builtin_macros/src/deriving/debug.rs
@@ -20,8 +20,7 @@ pub fn expand_deriving_debug(
     push: &mut dyn FnMut(Annotatable),
 ) {
     // &mut ::std::fmt::Formatter
-    let fmtr =
-        Ptr(box (Literal(path_std!(fmt::Formatter))), Borrowed(None, ast::Mutability::Mut));
+    let fmtr = Ptr(box (Literal(path_std!(fmt::Formatter))), Borrowed(None, ast::Mutability::Mut));
 
     let trait_def = TraitDef {
         span,
@@ -40,9 +39,7 @@ pub fn expand_deriving_debug(
             attributes: Vec::new(),
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(box (|a, b, c| {
-                show_substructure(a, b, c)
-            })),
+            combine_substructure: combine_substructure(box (|a, b, c| show_substructure(a, b, c))),
         }],
         associated_types: Vec::new(),
     };
diff --git a/compiler/rustc_builtin_macros/src/deriving/decodable.rs b/compiler/rustc_builtin_macros/src/deriving/decodable.rs
@@ -58,9 +58,9 @@ pub fn expand_deriving_rustc_decodable(
             attributes: Vec::new(),
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(box (|a, b, c| {
-                decodable_substructure(a, b, c, krate)
-            })),
+            combine_substructure: combine_substructure(
+                box (|a, b, c| decodable_substructure(a, b, c, krate)),
+            ),
         }],
         associated_types: Vec::new(),
     };
diff --git a/compiler/rustc_builtin_macros/src/deriving/default.rs b/compiler/rustc_builtin_macros/src/deriving/default.rs
@@ -41,8 +41,8 @@ pub fn expand_deriving_default(
             attributes: attrs,
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(box (|cx, trait_span, substr| {
-                match substr.fields {
+            combine_substructure: combine_substructure(
+                box (|cx, trait_span, substr| match substr.fields {
                     StaticStruct(_, fields) => {
                         default_struct_substructure(cx, trait_span, substr, fields)
                     }
@@ -59,8 +59,8 @@ pub fn expand_deriving_default(
                         default_enum_substructure(cx, trait_span, enum_def)
                     }
                     _ => cx.span_bug(trait_span, "method in `derive(Default)`"),
-                }
-            })),
+                }),
+            ),
         }],
         associated_types: Vec::new(),
     };
diff --git a/compiler/rustc_builtin_macros/src/deriving/encodable.rs b/compiler/rustc_builtin_macros/src/deriving/encodable.rs
@@ -143,9 +143,9 @@ pub fn expand_deriving_rustc_encodable(
             attributes: Vec::new(),
             is_unsafe: false,
             unify_fieldless_variants: false,
-            combine_substructure: combine_substructure(box (|a, b, c| {
-                encodable_substructure(a, b, c, krate)
-            })),
+            combine_substructure: combine_substructure(
+                box (|a, b, c| encodable_substructure(a, b, c, krate)),
+            ),
         }],
         associated_types: Vec::new(),
     };
diff --git a/compiler/rustc_builtin_macros/src/deriving/hash.rs b/compiler/rustc_builtin_macros/src/deriving/hash.rs
@@ -37,9 +37,7 @@ pub fn expand_deriving_hash(
             attributes: vec![],
             is_unsafe: false,
             unify_fieldless_variants: true,
-            combine_substructure: combine_substructure(box (|a, b, c| {
-                hash_substructure(a, b, c)
-            })),
+            combine_substructure: combine_substructure(box (|a, b, c| hash_substructure(a, b, c))),
         }],
         associated_types: Vec::new(),
     };
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -1934,10 +1934,12 @@ pub fn submit_pre_lto_module_to_llvm<B: ExtraBackendMethods>(
         })
     };
     // Schedule the module to be loaded
-    drop(tx_to_llvm_workers.send(box (Message::AddImportOnlyModule::<B> {
-        module_data: SerializedModule::FromUncompressedFile(mmap),
-        work_product: module.source,
-    })));
+    drop(tx_to_llvm_workers.send(
+        box (Message::AddImportOnlyModule::<B> {
+            module_data: SerializedModule::FromUncompressedFile(mmap),
+            work_product: module.source,
+        }),
+    ));
 }
 
 pub fn pre_lto_bitcode_filename(module_name: &str) -> String {
diff --git a/compiler/rustc_data_structures/src/owning_ref/tests.rs b/compiler/rustc_data_structures/src/owning_ref/tests.rs
@@ -465,9 +465,8 @@ mod owning_ref_mut {
 
     #[test]
     fn map_chained_inference() {
-        let or = BoxRefMut::new(box (example().1))
-            .map_mut(|x| &mut x[..5])
-            .map_mut(|x| &mut x[1..3]);
+        let or =
+            BoxRefMut::new(box (example().1)).map_mut(|x| &mut x[..5]).map_mut(|x| &mut x[1..3]);
         assert_eq!(&*or, "el");
     }
 
@@ -509,11 +508,9 @@ mod owning_ref_mut {
 
     #[test]
     fn erased_owner() {
-        let o1: BoxRefMut<Example, str> =
-            BoxRefMut::new(box (example())).map_mut(|x| &mut x.1[..]);
+        let o1: BoxRefMut<Example, str> = BoxRefMut::new(box (example())).map_mut(|x| &mut x.1[..]);
 
-        let o2: BoxRefMut<String, str> =
-            BoxRefMut::new(box (example().1)).map_mut(|x| &mut x[..]);
+        let o2: BoxRefMut<String, str> = BoxRefMut::new(box (example().1)).map_mut(|x| &mut x[..]);
 
         let os: Vec<ErasedBoxRefMut<str>> = vec![o1.erase_owner(), o2.erase_owner()];
         assert!(os.iter().all(|e| &e[..] == "hello world"));
diff --git a/compiler/rustc_driver/src/lib.rs b/compiler/rustc_driver/src/lib.rs
@@ -1163,16 +1163,18 @@ pub fn catch_with_exit_code(f: impl FnOnce() -> interface::Result<()>) -> i32 {
 static DEFAULT_HOOK: SyncLazy<Box<dyn Fn(&panic::PanicInfo<'_>) + Sync + Send + 'static>> =
     SyncLazy::new(|| {
         let hook = panic::take_hook();
-        panic::set_hook(box (|info| {
-            // Invoke the default handler, which prints the actual panic message and optionally a backtrace
-            (*DEFAULT_HOOK)(info);
+        panic::set_hook(
+            box (|info| {
+                // Invoke the default handler, which prints the actual panic message and optionally a backtrace
+                (*DEFAULT_HOOK)(info);
 
-            // Separate the output with an empty line
-            eprintln!();
+                // Separate the output with an empty line
+                eprintln!();
 
-            // Print the ICE message
-            report_ice(info, BUG_REPORT_URL);
-        }));
+                // Print the ICE message
+                report_ice(info, BUG_REPORT_URL);
+            }),
+        );
         hook
     });
 
diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs
@@ -409,11 +409,9 @@ impl<'a> DiagnosticBuilder<'a> {
     /// diagnostic.
     crate fn new_diagnostic(handler: &'a Handler, diagnostic: Diagnostic) -> DiagnosticBuilder<'a> {
         debug!("Created new diagnostic");
-        DiagnosticBuilder(box (DiagnosticBuilderInner {
-            handler,
-            diagnostic,
-            allow_suggestions: true,
-        }))
+        DiagnosticBuilder(
+            box (DiagnosticBuilderInner { handler, diagnostic, allow_suggestions: true }),
+        )
     }
 }
 
diff --git a/compiler/rustc_expand/src/mbe/macro_parser.rs b/compiler/rustc_expand/src/mbe/macro_parser.rs
@@ -544,18 +544,20 @@ fn inner_parse_loop<'root, 'tt>(
                     }
 
                     let matches = create_matches(item.matches.len());
-                    cur_items.push(MatcherPosHandle::Box(box (MatcherPos {
-                        stack: smallvec![],
-                        sep: seq.separator.clone(),
-                        seq_op: Some(seq.kleene.op),
-                        idx: 0,
-                        matches,
-                        match_lo: item.match_cur,
-                        match_cur: item.match_cur,
-                        match_hi: item.match_cur + seq.num_captures,
-                        up: Some(item),
-                        top_elts: Tt(TokenTree::Sequence(sp, seq)),
-                    })));
+                    cur_items.push(MatcherPosHandle::Box(
+                        box (MatcherPos {
+                            stack: smallvec![],
+                            sep: seq.separator.clone(),
+                            seq_op: Some(seq.kleene.op),
+                            idx: 0,
+                            matches,
+                            match_lo: item.match_cur,
+                            match_cur: item.match_cur,
+                            match_hi: item.match_cur + seq.num_captures,
+                            up: Some(item),
+                            top_elts: Tt(TokenTree::Sequence(sp, seq)),
+                        }),
+                    ));
                 }
 
                 // We need to match a metavar (but the identifier is invalid)... this is an error
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -546,17 +546,19 @@ pub fn compile_declarative_macro(
         None => {}
     }
 
-    mk_syn_ext(box (MacroRulesMacroExpander {
-        name: def.ident,
-        span: def.span,
-        transparency,
-        lhses,
-        rhses,
-        valid,
-        // Macros defined in the current crate have a real node id,
-        // whereas macros from an external crate have a dummy id.
-        is_local: def.id != DUMMY_NODE_ID,
-    }))
+    mk_syn_ext(
+        box (MacroRulesMacroExpander {
+            name: def.ident,
+            span: def.span,
+            transparency,
+            lhses,
+            rhses,
+            valid,
+            // Macros defined in the current crate have a real node id,
+            // whereas macros from an external crate have a dummy id.
+            is_local: def.id != DUMMY_NODE_ID,
+        }),
+    )
 }
 
 fn check_lhs_nt_follows(
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -812,11 +812,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         );
         let sugg = arm_spans
             .flat_map(|sp| {
-                vec![
-                    (sp.shrink_to_lo(), "box (".to_string()),
-                    (sp.shrink_to_hi(), ")".to_string()),
-                ]
-                .into_iter()
+                vec![(sp.shrink_to_lo(), "box (".to_string()), (sp.shrink_to_hi(), ")".to_string())]
+                    .into_iter()
             })
             .collect::<Vec<_>>();
         err.multipart_suggestion(
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1304,19 +1304,21 @@ impl<F> DerefMut for FmtPrinter<'_, '_, F> {
 
 impl<F> FmtPrinter<'a, 'tcx, F> {
     pub fn new(tcx: TyCtxt<'tcx>, fmt: F, ns: Namespace) -> Self {
-        FmtPrinter(box (FmtPrinterData {
-            tcx,
-            fmt,
-            empty_path: false,
-            in_value: ns == Namespace::ValueNS,
-            print_alloc_ids: false,
-            used_region_names: Default::default(),
-            region_index: 0,
-            binder_depth: 0,
-            printed_type_count: 0,
-            region_highlight_mode: RegionHighlightMode::default(),
-            name_resolver: None,
-        }))
+        FmtPrinter(
+            box (FmtPrinterData {
+                tcx,
+                fmt,
+                empty_path: false,
+                in_value: ns == Namespace::ValueNS,
+                print_alloc_ids: false,
+                used_region_names: Default::default(),
+                region_index: 0,
+                binder_depth: 0,
+                printed_type_count: 0,
+                region_highlight_mode: RegionHighlightMode::default(),
+                name_resolver: None,
+            }),
+        )
     }
 }
 
diff --git a/compiler/rustc_mir/src/transform/const_prop.rs b/compiler/rustc_mir/src/transform/const_prop.rs
@@ -798,11 +798,13 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
 
     /// Creates a new `Operand::Constant` from a `Scalar` value
     fn operand_from_scalar(&self, scalar: Scalar, ty: Ty<'tcx>, span: Span) -> Operand<'tcx> {
-        Operand::Constant(box (Constant {
-            span,
-            user_ty: None,
-            literal: ty::Const::from_scalar(self.tcx, scalar, ty).into(),
-        }))
+        Operand::Constant(
+            box (Constant {
+                span,
+                user_ty: None,
+                literal: ty::Const::from_scalar(self.tcx, scalar, ty).into(),
+            }),
+        )
     }
 
     fn replace_with_const(
@@ -881,21 +883,23 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                             if let Some(Some(alloc)) = alloc {
                                 // Assign entire constant in a single statement.
                                 // We can't use aggregates, as we run after the aggregate-lowering `MirPhase`.
-                                *rval = Rvalue::Use(Operand::Constant(box (Constant {
-                                    span: source_info.span,
-                                    user_ty: None,
-                                    literal: self
-                                        .ecx
-                                        .tcx
-                                        .mk_const(ty::Const {
-                                            ty,
-                                            val: ty::ConstKind::Value(ConstValue::ByRef {
-                                                alloc,
-                                                offset: Size::ZERO,
-                                            }),
-                                        })
-                                        .into(),
-                                })));
+                                *rval = Rvalue::Use(Operand::Constant(
+                                    box (Constant {
+                                        span: source_info.span,
+                                        user_ty: None,
+                                        literal: self
+                                            .ecx
+                                            .tcx
+                                            .mk_const(ty::Const {
+                                                ty,
+                                                val: ty::ConstKind::Value(ConstValue::ByRef {
+                                                    alloc,
+                                                    offset: Size::ZERO,
+                                                }),
+                                            })
+                                            .into(),
+                                    }),
+                                ));
                             }
                         }
                     }
diff --git a/compiler/rustc_mir/src/transform/elaborate_drops.rs b/compiler/rustc_mir/src/transform/elaborate_drops.rs
diff --git a/compiler/rustc_mir/src/transform/promote_consts.rs b/compiler/rustc_mir/src/transform/promote_consts.rs
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
diff --git a/compiler/rustc_typeck/src/check/method/confirm.rs b/compiler/rustc_typeck/src/check/method/confirm.rs
