Rustfmt

13 files changed, 353 insertions, 253 deletions

diff --git a/compiler/rustc_mir_build/src/builder/cfg.rs b/compiler/rustc_mir_build/src/builder/cfg.rs
index 42212f2518b..082cdc2e2a4 100644
--- a/compiler/rustc_mir_build/src/builder/cfg.rs
+++ b/compiler/rustc_mir_build/src/builder/cfg.rs
@@ -40,10 +40,10 @@ impl<'tcx> CFG<'tcx> {
         place: Place<'tcx>,
         rvalue: Rvalue<'tcx>,
     ) {
-        self.push(block, Statement {
-            source_info,
-            kind: StatementKind::Assign(Box::new((place, rvalue))),
-        });
+        self.push(
+            block,
+            Statement { source_info, kind: StatementKind::Assign(Box::new((place, rvalue))) },
+        );
     }
 
     pub(crate) fn push_assign_constant(
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
index 482f1e3840b..308ca442b40 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -484,16 +484,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         });
 
                     let place = place_builder.to_place(this);
-                    this.cfg.push(block, Statement {
-                        source_info: ty_source_info,
-                        kind: StatementKind::AscribeUserType(
-                            Box::new((place, UserTypeProjection {
-                                base: annotation_index,
-                                projs: vec![],
-                            })),
-                            Variance::Invariant,
-                        ),
-                    });
+                    this.cfg.push(
+                        block,
+                        Statement {
+                            source_info: ty_source_info,
+                            kind: StatementKind::AscribeUserType(
+                                Box::new((
+                                    place,
+                                    UserTypeProjection { base: annotation_index, projs: vec![] },
+                                )),
+                                Variance::Invariant,
+                            ),
+                        },
+                    );
                 }
                 block.and(place_builder)
             }
@@ -510,16 +513,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             user_ty: user_ty.clone(),
                             inferred_ty: expr.ty,
                         });
-                    this.cfg.push(block, Statement {
-                        source_info: ty_source_info,
-                        kind: StatementKind::AscribeUserType(
-                            Box::new((Place::from(temp), UserTypeProjection {
-                                base: annotation_index,
-                                projs: vec![],
-                            })),
-                            Variance::Invariant,
-                        ),
-                    });
+                    this.cfg.push(
+                        block,
+                        Statement {
+                            source_info: ty_source_info,
+                            kind: StatementKind::AscribeUserType(
+                                Box::new((
+                                    Place::from(temp),
+                                    UserTypeProjection { base: annotation_index, projs: vec![] },
+                                )),
+                                Variance::Invariant,
+                            ),
+                        },
+                    );
                 }
                 block.and(PlaceBuilder::from(temp))
             }
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index e7713f0a1d6..2c9a1de7f99 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -151,19 +151,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 );
                 let storage = this.temp(Ty::new_mut_ptr(tcx, tcx.types.u8), expr_span);
                 let success = this.cfg.start_new_block();
-                this.cfg.terminate(block, source_info, TerminatorKind::Call {
-                    func: exchange_malloc,
-                    args: [Spanned { node: Operand::Move(size), span: DUMMY_SP }, Spanned {
-                        node: Operand::Move(align),
-                        span: DUMMY_SP,
-                    }]
-                    .into(),
-                    destination: storage,
-                    target: Some(success),
-                    unwind: UnwindAction::Continue,
-                    call_source: CallSource::Misc,
-                    fn_span: expr_span,
-                });
+                this.cfg.terminate(
+                    block,
+                    source_info,
+                    TerminatorKind::Call {
+                        func: exchange_malloc,
+                        args: [
+                            Spanned { node: Operand::Move(size), span: DUMMY_SP },
+                            Spanned { node: Operand::Move(align), span: DUMMY_SP },
+                        ]
+                        .into(),
+                        destination: storage,
+                        target: Some(success),
+                        unwind: UnwindAction::Continue,
+                        call_source: CallSource::Misc,
+                        fn_span: expr_span,
+                    },
+                );
                 this.diverge_from(block);
                 block = success;
 
@@ -171,10 +175,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // and therefore is not considered during coroutine auto-trait
                 // determination. See the comment about `box` at `yield_in_scope`.
                 let result = this.local_decls.push(LocalDecl::new(expr.ty, expr_span));
-                this.cfg.push(block, Statement {
-                    source_info,
-                    kind: StatementKind::StorageLive(result),
-                });
+                this.cfg.push(
+                    block,
+                    Statement { source_info, kind: StatementKind::StorageLive(result) },
+                );
                 if let Some(scope) = scope.temp_lifetime {
                     // schedule a shallow free of that memory, lest we unwind:
                     this.schedule_drop_storage_and_value(expr_span, scope, result);
@@ -272,12 +276,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             );
                             merge_place
                         };
-                        this.cfg.push(block, Statement {
-                            source_info,
-                            kind: StatementKind::Intrinsic(Box::new(
-                                NonDivergingIntrinsic::Assume(Operand::Move(assert_place)),
-                            )),
-                        });
+                        this.cfg.push(
+                            block,
+                            Statement {
+                                source_info,
+                                kind: StatementKind::Intrinsic(Box::new(
+                                    NonDivergingIntrinsic::Assume(Operand::Move(assert_place)),
+                                )),
+                            },
+                        );
                     }
 
                     (op, ty)
@@ -739,12 +746,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             );
             if let Operand::Move(to_drop) = value_operand {
                 let success = this.cfg.start_new_block();
-                this.cfg.terminate(block, outer_source_info, TerminatorKind::Drop {
-                    place: to_drop,
-                    target: success,
-                    unwind: UnwindAction::Continue,
-                    replace: false,
-                });
+                this.cfg.terminate(
+                    block,
+                    outer_source_info,
+                    TerminatorKind::Drop {
+                        place: to_drop,
+                        target: success,
+                        unwind: UnwindAction::Continue,
+                        replace: false,
+                    },
+                );
                 this.diverge_from(block);
                 block = success;
             }
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
index b25cd0f4426..65dd061003d 100644
--- a/compiler/rustc_mir_build/src/builder/expr/into.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -220,10 +220,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.in_breakable_scope(Some(loop_block), destination, expr_span, move |this| {
                     // conduct the test, if necessary
                     let body_block = this.cfg.start_new_block();
-                    this.cfg.terminate(loop_block, source_info, TerminatorKind::FalseUnwind {
-                        real_target: body_block,
-                        unwind: UnwindAction::Continue,
-                    });
+                    this.cfg.terminate(
+                        loop_block,
+                        source_info,
+                        TerminatorKind::FalseUnwind {
+                            real_target: body_block,
+                            unwind: UnwindAction::Continue,
+                        },
+                    );
                     this.diverge_from(loop_block);
 
                     // The “return” value of the loop body must always be a unit. We therefore
@@ -254,30 +258,34 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 debug!("expr_into_dest: fn_span={:?}", fn_span);
 
-                this.cfg.terminate(block, source_info, TerminatorKind::Call {
-                    func: fun,
-                    args,
-                    unwind: UnwindAction::Continue,
-                    destination,
-                    // The presence or absence of a return edge affects control-flow sensitive
-                    // MIR checks and ultimately whether code is accepted or not. We can only
-                    // omit the return edge if a return type is visibly uninhabited to a module
-                    // that makes the call.
-                    target: expr
-                        .ty
-                        .is_inhabited_from(
-                            this.tcx,
-                            this.parent_module,
-                            this.infcx.typing_env(this.param_env),
-                        )
-                        .then_some(success),
-                    call_source: if from_hir_call {
-                        CallSource::Normal
-                    } else {
-                        CallSource::OverloadedOperator
+                this.cfg.terminate(
+                    block,
+                    source_info,
+                    TerminatorKind::Call {
+                        func: fun,
+                        args,
+                        unwind: UnwindAction::Continue,
+                        destination,
+                        // The presence or absence of a return edge affects control-flow sensitive
+                        // MIR checks and ultimately whether code is accepted or not. We can only
+                        // omit the return edge if a return type is visibly uninhabited to a module
+                        // that makes the call.
+                        target: expr
+                            .ty
+                            .is_inhabited_from(
+                                this.tcx,
+                                this.parent_module,
+                                this.infcx.typing_env(this.param_env),
+                            )
+                            .then_some(success),
+                        call_source: if from_hir_call {
+                            CallSource::Normal
+                        } else {
+                            CallSource::OverloadedOperator
+                        },
+                        fn_span,
                     },
-                    fn_span,
-                });
+                );
                 this.diverge_from(block);
                 success.unit()
             }
@@ -494,9 +502,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             let tmp = this.get_unit_temp();
                             let target =
                                 this.ast_block(tmp, target, block, source_info).into_block();
-                            this.cfg.terminate(target, source_info, TerminatorKind::Goto {
-                                target: destination_block,
-                            });
+                            this.cfg.terminate(
+                                target,
+                                source_info,
+                                TerminatorKind::Goto { target: destination_block },
+                            );
 
                             mir::InlineAsmOperand::Label { target_index }
                         }
@@ -515,19 +525,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     AsmMacro::NakedAsm => InlineAsmMacro::NakedAsm,
                 };
 
-                this.cfg.terminate(block, source_info, TerminatorKind::InlineAsm {
-                    asm_macro,
-                    template,
-                    operands,
-                    options,
-                    line_spans,
-                    targets: targets.into_boxed_slice(),
-                    unwind: if options.contains(InlineAsmOptions::MAY_UNWIND) {
-                        UnwindAction::Continue
-                    } else {
-                        UnwindAction::Unreachable
+                this.cfg.terminate(
+                    block,
+                    source_info,
+                    TerminatorKind::InlineAsm {
+                        asm_macro,
+                        template,
+                        operands,
+                        options,
+                        line_spans,
+                        targets: targets.into_boxed_slice(),
+                        unwind: if options.contains(InlineAsmOptions::MAY_UNWIND) {
+                            UnwindAction::Continue
+                        } else {
+                            UnwindAction::Unreachable
+                        },
                     },
-                });
+                );
                 if options.contains(InlineAsmOptions::MAY_UNWIND) {
                     this.diverge_from(block);
                 }
@@ -587,12 +601,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         this.as_operand(block, scope, value, LocalInfo::Boring, NeedsTemporary::No)
                 );
                 let resume = this.cfg.start_new_block();
-                this.cfg.terminate(block, source_info, TerminatorKind::Yield {
-                    value,
-                    resume,
-                    resume_arg: destination,
-                    drop: None,
-                });
+                this.cfg.terminate(
+                    block,
+                    source_info,
+                    TerminatorKind::Yield { value, resume, resume_arg: destination, drop: None },
+                );
                 this.coroutine_drop_cleanup(block);
                 resume.unit()
             }
diff --git a/compiler/rustc_mir_build/src/builder/expr/stmt.rs b/compiler/rustc_mir_build/src/builder/expr/stmt.rs
index 4ae3536d9c2..58090d3748b 100644
--- a/compiler/rustc_mir_build/src/builder/expr/stmt.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/stmt.rs
@@ -123,11 +123,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                     unpack!(block = this.break_for_tail_call(block, &args, source_info));
 
-                    this.cfg.terminate(block, source_info, TerminatorKind::TailCall {
-                        func: fun,
-                        args,
-                        fn_span,
-                    });
+                    this.cfg.terminate(
+                        block,
+                        source_info,
+                        TerminatorKind::TailCall { func: fun, args, fn_span },
+                    );
 
                     this.cfg.start_new_block().unit()
                 })
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index bca57817d66..ee331713736 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -173,10 +173,13 @@ impl<'tcx> MatchPairTree<'tcx> {
                 let ascription = place.map(|source| {
                     let span = pattern.span;
                     let parent_id = cx.tcx.typeck_root_def_id(cx.def_id.to_def_id());
-                    let args = ty::InlineConstArgs::new(cx.tcx, ty::InlineConstArgsParts {
-                        parent_args: ty::GenericArgs::identity_for_item(cx.tcx, parent_id),
-                        ty: cx.infcx.next_ty_var(span),
-                    })
+                    let args = ty::InlineConstArgs::new(
+                        cx.tcx,
+                        ty::InlineConstArgsParts {
+                            parent_args: ty::GenericArgs::identity_for_item(cx.tcx, parent_id),
+                            ty: cx.infcx.next_ty_var(span),
+                        },
+                    )
                     .args;
                     let user_ty = cx.infcx.canonicalize_user_type_annotation(ty::UserType::new(
                         ty::UserTypeKind::TypeOf(def_id, ty::UserArgs { args, user_self_ty: None }),
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index a2f92a93ec5..ed577f7adeb 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -104,11 +104,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         variable_source_info: SourceInfo,
         declare_let_bindings: DeclareLetBindings,
     ) -> BlockAnd<()> {
-        self.then_else_break_inner(block, expr_id, ThenElseArgs {
-            temp_scope_override,
-            variable_source_info,
-            declare_let_bindings,
-        })
+        self.then_else_break_inner(
+            block,
+            expr_id,
+            ThenElseArgs { temp_scope_override, variable_source_info, declare_let_bindings },
+        )
     }
 
     fn then_else_break_inner(
@@ -134,16 +134,24 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let local_scope = this.local_scope();
                 let (lhs_success_block, failure_block) =
                     this.in_if_then_scope(local_scope, expr_span, |this| {
-                        this.then_else_break_inner(block, lhs, ThenElseArgs {
-                            declare_let_bindings: DeclareLetBindings::LetNotPermitted,
-                            ..args
-                        })
+                        this.then_else_break_inner(
+                            block,
+                            lhs,
+                            ThenElseArgs {
+                                declare_let_bindings: DeclareLetBindings::LetNotPermitted,
+                                ..args
+                            },
+                        )
                     });
                 let rhs_success_block = this
-                    .then_else_break_inner(failure_block, rhs, ThenElseArgs {
-                        declare_let_bindings: DeclareLetBindings::LetNotPermitted,
-                        ..args
-                    })
+                    .then_else_break_inner(
+                        failure_block,
+                        rhs,
+                        ThenElseArgs {
+                            declare_let_bindings: DeclareLetBindings::LetNotPermitted,
+                            ..args
+                        },
+                    )
                     .into_block();
 
                 // Make the LHS and RHS success arms converge to a common block.
@@ -170,10 +178,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         if this.tcx.sess.instrument_coverage() {
                             this.cfg.push_coverage_span_marker(block, this.source_info(expr_span));
                         }
-                        this.then_else_break_inner(block, arg, ThenElseArgs {
-                            declare_let_bindings: DeclareLetBindings::LetNotPermitted,
-                            ..args
-                        })
+                        this.then_else_break_inner(
+                            block,
+                            arg,
+                            ThenElseArgs {
+                                declare_let_bindings: DeclareLetBindings::LetNotPermitted,
+                                ..args
+                            },
+                        )
                     });
                 this.break_for_else(success_block, args.variable_source_info);
                 failure_block.unit()
@@ -629,27 +641,30 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let ty_source_info = self.source_info(annotation.span);
 
                 let base = self.canonical_user_type_annotations.push(annotation.clone());
-                self.cfg.push(block, Statement {
-                    source_info: ty_source_info,
-                    kind: StatementKind::AscribeUserType(
-                        Box::new((place, UserTypeProjection { base, projs: Vec::new() })),
-                        // We always use invariant as the variance here. This is because the
-                        // variance field from the ascription refers to the variance to use
-                        // when applying the type to the value being matched, but this
-                        // ascription applies rather to the type of the binding. e.g., in this
-                        // example:
-                        //
-                        // ```
-                        // let x: T = <expr>
-                        // ```
-                        //
-                        // We are creating an ascription that defines the type of `x` to be
-                        // exactly `T` (i.e., with invariance). The variance field, in
-                        // contrast, is intended to be used to relate `T` to the type of
-                        // `<expr>`.
-                        ty::Invariant,
-                    ),
-                });
+                self.cfg.push(
+                    block,
+                    Statement {
+                        source_info: ty_source_info,
+                        kind: StatementKind::AscribeUserType(
+                            Box::new((place, UserTypeProjection { base, projs: Vec::new() })),
+                            // We always use invariant as the variance here. This is because the
+                            // variance field from the ascription refers to the variance to use
+                            // when applying the type to the value being matched, but this
+                            // ascription applies rather to the type of the binding. e.g., in this
+                            // example:
+                            //
+                            // ```
+                            // let x: T = <expr>
+                            // ```
+                            //
+                            // We are creating an ascription that defines the type of `x` to be
+                            // exactly `T` (i.e., with invariance). The variance field, in
+                            // contrast, is intended to be used to relate `T` to the type of
+                            // `<expr>`.
+                            ty::Invariant,
+                        ),
+                    },
+                );
 
                 self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
                 block.unit()
@@ -2549,13 +2564,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let source_info = self.source_info(ascription.annotation.span);
 
             let base = self.canonical_user_type_annotations.push(ascription.annotation);
-            self.cfg.push(block, Statement {
-                source_info,
-                kind: StatementKind::AscribeUserType(
-                    Box::new((ascription.source, UserTypeProjection { base, projs: Vec::new() })),
-                    ascription.variance,
-                ),
-            });
+            self.cfg.push(
+                block,
+                Statement {
+                    source_info,
+                    kind: StatementKind::AscribeUserType(
+                        Box::new((
+                            ascription.source,
+                            UserTypeProjection { base, projs: Vec::new() },
+                        )),
+                        ascription.variance,
+                    ),
+                },
+            );
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/builder/matches/test.rs b/compiler/rustc_mir_build/src/builder/matches/test.rs
index 834f8be0d00..a7a028bff97 100644
--- a/compiler/rustc_mir_build/src/builder/matches/test.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/test.rs
@@ -327,15 +327,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         );
         // `let temp = <Ty as Deref>::deref(ref_src);`
         // or `let temp = <Ty as DerefMut>::deref_mut(ref_src);`
-        self.cfg.terminate(block, source_info, TerminatorKind::Call {
-            func: Operand::Constant(Box::new(ConstOperand { span, user_ty: None, const_: method })),
-            args: [Spanned { node: Operand::Move(ref_src), span }].into(),
-            destination: temp,
-            target: Some(target_block),
-            unwind: UnwindAction::Continue,
-            call_source: CallSource::Misc,
-            fn_span: source_info.span,
-        });
+        self.cfg.terminate(
+            block,
+            source_info,
+            TerminatorKind::Call {
+                func: Operand::Constant(Box::new(ConstOperand {
+                    span,
+                    user_ty: None,
+                    const_: method,
+                })),
+                args: [Spanned { node: Operand::Move(ref_src), span }].into(),
+                destination: temp,
+                target: Some(target_block),
+                unwind: UnwindAction::Continue,
+                call_source: CallSource::Misc,
+                fn_span: source_info.span,
+            },
+        );
     }
 
     /// Compare using the provided built-in comparison operator
@@ -463,26 +471,33 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let bool_ty = self.tcx.types.bool;
         let eq_result = self.temp(bool_ty, source_info.span);
         let eq_block = self.cfg.start_new_block();
-        self.cfg.terminate(block, source_info, TerminatorKind::Call {
-            func: Operand::Constant(Box::new(ConstOperand {
-                span: source_info.span,
-
-                // FIXME(#54571): This constant comes from user input (a
-                // constant in a pattern). Are there forms where users can add
-                // type annotations here?  For example, an associated constant?
-                // Need to experiment.
-                user_ty: None,
-
-                const_: method,
-            })),
-            args: [Spanned { node: val, span: DUMMY_SP }, Spanned { node: expect, span: DUMMY_SP }]
+        self.cfg.terminate(
+            block,
+            source_info,
+            TerminatorKind::Call {
+                func: Operand::Constant(Box::new(ConstOperand {
+                    span: source_info.span,
+
+                    // FIXME(#54571): This constant comes from user input (a
+                    // constant in a pattern). Are there forms where users can add
+                    // type annotations here?  For example, an associated constant?
+                    // Need to experiment.
+                    user_ty: None,
+
+                    const_: method,
+                })),
+                args: [
+                    Spanned { node: val, span: DUMMY_SP },
+                    Spanned { node: expect, span: DUMMY_SP },
+                ]
                 .into(),
-            destination: eq_result,
-            target: Some(eq_block),
-            unwind: UnwindAction::Continue,
-            call_source: CallSource::MatchCmp,
-            fn_span: source_info.span,
-        });
+                destination: eq_result,
+                target: Some(eq_block),
+                unwind: UnwindAction::Continue,
+                call_source: CallSource::MatchCmp,
+                fn_span: source_info.span,
+            },
+        );
         self.diverge_from(block);
 
         // check the result
diff --git a/compiler/rustc_mir_build/src/builder/matches/util.rs b/compiler/rustc_mir_build/src/builder/matches/util.rs
index 83e79572b2a..589e350a03f 100644
--- a/compiler/rustc_mir_build/src/builder/matches/util.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/util.rs
@@ -20,10 +20,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         source_info: SourceInfo,
     ) {
         if imaginary_target != real_target {
-            self.cfg.terminate(from_block, source_info, TerminatorKind::FalseEdge {
-                real_target,
-                imaginary_target,
-            });
+            self.cfg.terminate(
+                from_block,
+                source_info,
+                TerminatorKind::FalseEdge { real_target, imaginary_target },
+            );
         } else {
             self.cfg.goto(from_block, source_info, real_target)
         }
diff --git a/compiler/rustc_mir_build/src/builder/misc.rs b/compiler/rustc_mir_build/src/builder/misc.rs
index 9ea56a9574f..6e8e74fd4fc 100644
--- a/compiler/rustc_mir_build/src/builder/misc.rs
+++ b/compiler/rustc_mir_build/src/builder/misc.rs
@@ -45,11 +45,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) -> Place<'tcx> {
         let usize_ty = self.tcx.types.usize;
         let temp = self.temp(usize_ty, source_info.span);
-        self.cfg.push_assign_constant(block, source_info, temp, ConstOperand {
-            span: source_info.span,
-            user_ty: None,
-            const_: Const::from_usize(self.tcx, value),
-        });
+        self.cfg.push_assign_constant(
+            block,
+            source_info,
+            temp,
+            ConstOperand {
+                span: source_info.span,
+                user_ty: None,
+                const_: Const::from_usize(self.tcx, value),
+            },
+        );
         temp
     }
 
diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index 945f02821d9..d3551ea3a97 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -532,12 +532,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             (Some(normal_block), Some(exit_block)) => {
                 let target = self.cfg.start_new_block();
                 let source_info = self.source_info(span);
-                self.cfg.terminate(normal_block.into_block(), source_info, TerminatorKind::Goto {
-                    target,
-                });
-                self.cfg.terminate(exit_block.into_block(), source_info, TerminatorKind::Goto {
-                    target,
-                });
+                self.cfg.terminate(
+                    normal_block.into_block(),
+                    source_info,
+                    TerminatorKind::Goto { target },
+                );
+                self.cfg.terminate(
+                    exit_block.into_block(),
+                    source_info,
+                    TerminatorKind::Goto { target },
+                );
                 target.unit()
             }
         }
@@ -833,30 +837,37 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         unwind_drops.add_entry_point(block, unwind_entry_point);
 
                         let next = self.cfg.start_new_block();
-                        self.cfg.terminate(block, source_info, TerminatorKind::Drop {
-                            place: local.into(),
-                            target: next,
-                            unwind: UnwindAction::Continue,
-                            replace: false,
-                        });
+                        self.cfg.terminate(
+                            block,
+                            source_info,
+                            TerminatorKind::Drop {
+                                place: local.into(),
+                                target: next,
+                                unwind: UnwindAction::Continue,
+                                replace: false,
+                            },
+                        );
                         block = next;
                     }
                     DropKind::ForLint => {
-                        self.cfg.push(block, Statement {
-                            source_info,
-                            kind: StatementKind::BackwardIncompatibleDropHint {
-                                place: Box::new(local.into()),
-                                reason: BackwardIncompatibleDropReason::Edition2024,
+                        self.cfg.push(
+                            block,
+                            Statement {
+                                source_info,
+                                kind: StatementKind::BackwardIncompatibleDropHint {
+                                    place: Box::new(local.into()),
+                                    reason: BackwardIncompatibleDropReason::Edition2024,
+                                },
                             },
-                        });
+                        );
                     }
                     DropKind::Storage => {
                         // Only temps and vars need their storage dead.
                         assert!(local.index() > self.arg_count);
-                        self.cfg.push(block, Statement {
-                            source_info,
-                            kind: StatementKind::StorageDead(local),
-                        });
+                        self.cfg.push(
+                            block,
+                            Statement { source_info, kind: StatementKind::StorageDead(local) },
+                        );
                     }
                 }
             }
@@ -1350,12 +1361,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let assign_unwind = self.cfg.start_new_cleanup_block();
         self.cfg.push_assign(assign_unwind, source_info, place, value.clone());
 
-        self.cfg.terminate(block, source_info, TerminatorKind::Drop {
-            place,
-            target: assign,
-            unwind: UnwindAction::Cleanup(assign_unwind),
-            replace: true,
-        });
+        self.cfg.terminate(
+            block,
+            source_info,
+            TerminatorKind::Drop {
+                place,
+                target: assign,
+                unwind: UnwindAction::Cleanup(assign_unwind),
+                replace: true,
+            },
+        );
         self.diverge_from(block);
 
         assign.unit()
@@ -1375,13 +1390,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let source_info = self.source_info(span);
         let success_block = self.cfg.start_new_block();
 
-        self.cfg.terminate(block, source_info, TerminatorKind::Assert {
-            cond,
-            expected,
-            msg: Box::new(msg),
-            target: success_block,
-            unwind: UnwindAction::Continue,
-        });
+        self.cfg.terminate(
+            block,
+            source_info,
+            TerminatorKind::Assert {
+                cond,
+                expected,
+                msg: Box::new(msg),
+                target: success_block,
+                unwind: UnwindAction::Continue,
+            },
+        );
         self.diverge_from(block);
 
         success_block
@@ -1481,12 +1500,16 @@ fn build_scope_drops<'tcx>(
 
                 unwind_drops.add_entry_point(block, unwind_to);
                 let next = cfg.start_new_block();
-                cfg.terminate(block, source_info, TerminatorKind::Drop {
-                    place: local.into(),
-                    target: next,
-                    unwind: UnwindAction::Continue,
-                    replace: false,
-                });
+                cfg.terminate(
+                    block,
+                    source_info,
+                    TerminatorKind::Drop {
+                        place: local.into(),
+                        target: next,
+                        unwind: UnwindAction::Continue,
+                        replace: false,
+                    },
+                );
                 block = next;
             }
             DropKind::ForLint => {
@@ -1509,13 +1532,16 @@ fn build_scope_drops<'tcx>(
                     continue;
                 }
 
-                cfg.push(block, Statement {
-                    source_info,
-                    kind: StatementKind::BackwardIncompatibleDropHint {
-                        place: Box::new(local.into()),
-                        reason: BackwardIncompatibleDropReason::Edition2024,
+                cfg.push(
+                    block,
+                    Statement {
+                        source_info,
+                        kind: StatementKind::BackwardIncompatibleDropHint {
+                            place: Box::new(local.into()),
+                            reason: BackwardIncompatibleDropReason::Edition2024,
+                        },
                     },
-                });
+                );
             }
             DropKind::Storage => {
                 // Ordinarily, storage-dead nodes are not emitted on unwind, so we don't
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index b6494173b0f..2b9b948763f 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -525,11 +525,10 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                             .copied()
                             .filter(|feature| missing.contains(feature))
                             .collect();
-                        self.requires_unsafe(expr.span, CallToFunctionWith {
-                            function: func_did,
-                            missing,
-                            build_enabled,
-                        });
+                        self.requires_unsafe(
+                            expr.span,
+                            CallToFunctionWith { function: func_did, missing, build_enabled },
+                        );
                     }
                 }
             }
@@ -1186,9 +1185,11 @@ pub(crate) fn check_unsafety(tcx: TyCtxt<'_>, def: LocalDefId) {
     warnings.sort_by_key(|w| w.block_span);
     for UnusedUnsafeWarning { hir_id, block_span, enclosing_unsafe } in warnings {
         let block_span = tcx.sess.source_map().guess_head_span(block_span);
-        tcx.emit_node_span_lint(UNUSED_UNSAFE, hir_id, block_span, UnusedUnsafe {
-            span: block_span,
-            enclosing: enclosing_unsafe,
-        });
+        tcx.emit_node_span_lint(
+            UNUSED_UNSAFE,
+            hir_id,
+            block_span,
+            UnusedUnsafe { span: block_span, enclosing: enclosing_unsafe },
+        );
     }
 }
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 9d114e67559..a01609012b8 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -186,11 +186,9 @@ impl<'tcx> ThirBuildCx<'tcx> {
             let ty = if fn_decl.c_variadic && index == fn_decl.inputs.len() {
                 let va_list_did = self.tcx.require_lang_item(LangItem::VaList, Some(param.span));
 
-                self.tcx.type_of(va_list_did).instantiate(self.tcx, &[self
-                    .tcx
-                    .lifetimes
-                    .re_erased
-                    .into()])
+                self.tcx
+                    .type_of(va_list_did)
+                    .instantiate(self.tcx, &[self.tcx.lifetimes.re_erased.into()])
             } else {
                 fn_sig.inputs()[index]
             };