./x.py fmt

compiler/rustc_mir/src/interpret/eval_context.rs

@@ -577,24 +577,25 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 // the last field).  Can't have foreign types here, how would we
                 // adjust alignment and size for them?
                 let field = layout.field(self, layout.fields.count() - 1)?;
-                let (unsized_size, unsized_align) = match self.size_and_align_of(metadata, &field)? {
+                let (unsized_size, unsized_align) =
-                    Some(size_and_align) => size_and_align,
+                    match self.size_and_align_of(metadata, &field)? {
-                    None => {
+                        Some(size_and_align) => size_and_align,
-                        // A field with extern type.  If this field is at offset 0, we behave
+                        None => {
-                        // like the underlying extern type.
+                            // A field with extern type.  If this field is at offset 0, we behave
-                        // FIXME: Once we have made decisions for how to handle size and alignment
+                            // like the underlying extern type.
-                        // of `extern type`, this should be adapted.  It is just a temporary hack
+                            // FIXME: Once we have made decisions for how to handle size and alignment
-                        // to get some code to work that probably ought to work.
+                            // of `extern type`, this should be adapted.  It is just a temporary hack
-                        if sized_size == Size::ZERO {
+                            // to get some code to work that probably ought to work.
-                            return Ok(None);
+                            if sized_size == Size::ZERO {
-                        } else {
+                                return Ok(None);
-                            span_bug!(
+                            } else {
-                                self.cur_span(),
+                                span_bug!(
-                                "Fields cannot be extern types, unless they are at offset 0"
+                                    self.cur_span(),
-                            )
+                                    "Fields cannot be extern types, unless they are at offset 0"
+                                )
+                            }
                         }
-                    }
+                    };
-                };
 
                 // FIXME (#26403, #27023): We should be adding padding
                 // to `sized_size` (to accommodate the `unsized_align`

compiler/rustc_mir/src/interpret/intrinsics.rs

@@ -226,8 +226,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let l = self.read_immediate(&args[0])?;
                 let r = self.read_immediate(&args[1])?;
                 let is_add = intrinsic_name == sym::saturating_add;
-                let (val, overflowed, _ty) =
+                let (val, overflowed, _ty) = self.overflowing_binary_op(
-                    self.overflowing_binary_op(if is_add { BinOp::Add } else { BinOp::Sub }, &l, &r)?;
+                    if is_add { BinOp::Add } else { BinOp::Sub },
+                    &l,
+                    &r,
+                )?;
                 let val = if overflowed {
                     let num_bits = l.layout.size.bits();
                     if l.layout.abi.is_signed() {

compiler/rustc_mir/src/interpret/terminator.rs

@@ -83,7 +83,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     Some((dest, ret)) => {
                         dest_place = self.eval_place(dest)?;
                         Some((&dest_place, ret))
-                    },
+                    }
                     None => None,
                 };
                 self.eval_fn_call(fn_val, abi, &args[..], ret, *cleanup)?;

compiler/rustc_mir/src/interpret/visitor.rs

@@ -18,7 +18,8 @@ pub trait Value<'mir, 'tcx, M: Machine<'mir, 'tcx>>: Copy {
     fn layout(&self) -> TyAndLayout<'tcx>;
 
     /// Makes this into an `OpTy`.
-    fn to_op(&self, ecx: &InterpCx<'mir, 'tcx, M>) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>;
+    fn to_op(&self, ecx: &InterpCx<'mir, 'tcx, M>)
+    -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>;
 
     /// Creates this from an `MPlaceTy`.
     fn from_mem_place(mplace: MPlaceTy<'tcx, M::PointerTag>) -> Self;
@@ -31,8 +32,11 @@ pub trait Value<'mir, 'tcx, M: Machine<'mir, 'tcx>>: Copy {
     ) -> InterpResult<'tcx, Self>;
 
     /// Projects to the n-th field.
-    fn project_field(&self, ecx: &InterpCx<'mir, 'tcx, M>, field: usize)
+    fn project_field(
-    -> InterpResult<'tcx, Self>;
+        &self,
+        ecx: &InterpCx<'mir, 'tcx, M>,
+        field: usize,
+    ) -> InterpResult<'tcx, Self>;
 }
 
 // Operands and memory-places are both values.

compiler/rustc_mir/src/transform/const_prop.rs

@@ -1198,9 +1198,9 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
                             // This can be `None` if the lhs wasn't const propagated and we just
                             // triggered the assert on the value of the rhs.
                             match self.eval_operand(op, source_info) {
-                                Some(op) => {
+                                Some(op) => DbgVal::Val(
-                                    DbgVal::Val(self.ecx.read_immediate(&op).unwrap().to_const_int())
+                                    self.ecx.read_immediate(&op).unwrap().to_const_int(),
-                                }
+                                ),
                                 None => DbgVal::Underscore,
                             }
                         };