formatting changes to pass 'test tidy'

Author: x17jiri

compiler/rustc_codegen_llvm/src/builder.rs

@@ -205,16 +205,18 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         cold_br: Option<bool>,
     ) {
         // emit the branch instruction
-        let n = unsafe {
-            llvm::LLVMBuildCondBr(self.llbuilder, cond, then_llbb, else_llbb)
-        };
+        let n = unsafe { llvm::LLVMBuildCondBr(self.llbuilder, cond, then_llbb, else_llbb) };
 
         // if one of the branches is cold, emit metadata with branch weights
         if let Some(cold_br) = cold_br {
             unsafe {
                 let s = "branch_weights";
                 let v = [
-                    llvm::LLVMMDStringInContext(self.cx.llcx, s.as_ptr() as *const c_char, s.len() as c_uint),
+                    llvm::LLVMMDStringInContext(
+                        self.cx.llcx,
+                        s.as_ptr() as *const c_char,
+                        s.len() as c_uint,
+                    ),
                     self.cx.const_u32(if cold_br { 1 } else { 2000 }), // 'then' branch weight
                     self.cx.const_u32(if cold_br { 2000 } else { 1 }), // 'else' branch weight
                 ];

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -327,20 +327,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             let (test_value, target) = target_iter.next().unwrap();
             let lltrue = helper.llbb_with_cleanup(self, target);
             let llfalse = helper.llbb_with_cleanup(self, targets.otherwise());
-            let cold_br = targets.cold_target().and_then(|t| {
-                if t == 0 { Some(true) } else { Some(false) }
-            });
+            let cold_br =
+                targets.cold_target().and_then(|t| if t == 0 { Some(true) } else { Some(false) });
 
             if switch_ty == bx.tcx().types.bool {
                 // Don't generate trivial icmps when switching on bool.
                 match test_value {
                     0 => {
                         let cold_br = cold_br.and_then(|t| Some(!t));
                         bx.cond_br_with_cold_br(discr.immediate(), llfalse, lltrue, cold_br);
-                    },
-                    1 => {
-                        bx.cond_br_with_cold_br(discr.immediate(), lltrue, llfalse, cold_br)
-                    },
+                    }
+                    1 => bx.cond_br_with_cold_br(discr.immediate(), lltrue, llfalse, cold_br),
                     _ => bug!(),
                 }
             } else {

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -2,11 +2,11 @@ use crate::sip128::SipHasher128;
 use rustc_index::bit_set::{self, BitSet};
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use smallvec::SmallVec;
-use thin_vec::ThinVec;
 use std::fmt;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::marker::PhantomData;
 use std::mem;
+use thin_vec::ThinVec;
 
 #[cfg(test)]
 mod tests;

compiler/rustc_middle/src/mir/terminator.rs

@@ -61,12 +61,9 @@ impl SwitchTargets {
         }
     }
 
+    // If this switch has exactly one target, returns it.
     pub fn cold_target(&self) -> Option<usize> {
-        if self.cold_targets.len() == 1 {
-            Some(self.cold_targets[0])
-        } else {
-            None
-        }
+        if self.cold_targets.len() == 1 { Some(self.cold_targets[0]) } else { None }
     }
 
     /// Returns the fallback target that is jumped to when none of the values match the operand.
@@ -402,13 +399,15 @@ impl<'tcx> TerminatorKind<'tcx> {
         t: BasicBlock,
         f: BasicBlock,
         cold_branch: Option<bool>,
-     ) -> TerminatorKind<'tcx> {
+    ) -> TerminatorKind<'tcx> {
         TerminatorKind::SwitchInt {
             discr: cond,
             targets: SwitchTargets::static_if_with_cold_br(
-                0, f, t,
+                0,
+                f,
+                t,
                 // we compare to zero, so have to invert the branch
-                cold_branch.and_then(|b| Some(!b))
+                cold_branch.and_then(|b| Some(!b)),
             ),
         }
     }

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -63,7 +63,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     break_scope,
                     variable_source_info,
                     declare_bindings,
-                    match cold_branch { Some(false) => Some(false), _ => None },
+                    match cold_branch {
+                        Some(false) => Some(false),
+                        _ => None,
+                    },
                 ));
 
                 let rhs_then_block = unpack!(this.then_else_break(
@@ -89,7 +92,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             local_scope,
                             variable_source_info,
                             true,
-                            match cold_branch { Some(true) => Some(true), _ => None },
+                            match cold_branch {
+                                Some(true) => Some(true),
+                                _ => None,
+                            },
                         )
                     });
                 let rhs_success_block = unpack!(this.then_else_break(
@@ -167,12 +173,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 let then_block = this.cfg.start_new_block();
                 let else_block = this.cfg.start_new_block();
-                let term = TerminatorKind::if_with_cold_br(
-                    operand,
-                    then_block,
-                    else_block,
-                    cold_branch
-                );
+                let term =
+                    TerminatorKind::if_with_cold_br(operand, then_block, else_block, cold_branch);
 
                 let source_info = this.source_info(expr_span);
                 this.cfg.terminate(block, source_info, term);
@@ -307,8 +309,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let arm = &self.thir[arm];
                 let arm_has_guard = arm.guard.is_some();
                 let arm_is_cold = arm.is_cold;
-                let arm_candidate =
-                    Candidate::new(scrutinee.clone(), &arm.pattern, arm_has_guard, arm_is_cold, self);
+                let arm_candidate = Candidate::new(
+                    scrutinee.clone(),
+                    &arm.pattern,
+                    arm_has_guard,
+                    arm_is_cold,
+                    self,
+                );
                 (arm, arm_candidate)
             })
             .collect()
@@ -667,7 +674,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         initializer: PlaceBuilder<'tcx>,
         set_match_place: bool,
     ) -> BlockAnd<()> {
-        let mut candidate = Candidate::new(initializer.clone(), irrefutable_pat, false, false, self);
+        let mut candidate =
+            Candidate::new(initializer.clone(), irrefutable_pat, false, false, self);
         let fake_borrow_temps = self.lower_match_tree(
             block,
             irrefutable_pat.span,
@@ -1520,7 +1528,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         debug!("candidate={:#?}\npats={:#?}", candidate, pats);
         let mut or_candidates: Vec<_> = pats
             .iter()
-            .map(|pat| Candidate::new(place.clone(), pat, candidate.has_guard, candidate.is_cold, self))
+            .map(|pat| {
+                Candidate::new(place.clone(), pat, candidate.has_guard, candidate.is_cold, self)
+            })
             .collect();
         let mut or_candidate_refs: Vec<_> = or_candidates.iter_mut().collect();
         let otherwise = if candidate.otherwise_block.is_some() {
@@ -1771,10 +1781,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // Find cold targets.
         let mut cold_targets: ThinVec<usize> = ThinVec::new();
 
-        let is_otherwise_target_cold =
-            candidates.len() > 0 &&
-            candidates.iter().all(|c| c.is_cold);// && c.match_pairs.is_empty());
-        if  is_otherwise_target_cold {
+        let is_otherwise_target_cold = candidates.len() > 0 && candidates.iter().all(|c| c.is_cold);
+        if is_otherwise_target_cold {
             cold_targets.push(target_candidates.len());
         }
 
@@ -1849,7 +1857,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             &match_place,
             &test,
             target_blocks,
-            cold_targets
+            cold_targets,
         );
     }
 
@@ -1948,7 +1956,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let expr_span = self.thir[expr_id].span;
         let expr_place_builder = unpack!(block = self.lower_scrutinee(block, expr_id, expr_span));
         let wildcard = Pat::wildcard_from_ty(pat.ty);
-        let mut guard_candidate = Candidate::new(expr_place_builder.clone(), pat, false, false, self);
+        let mut guard_candidate =
+            Candidate::new(expr_place_builder.clone(), pat, false, false, self);
         let mut otherwise_candidate =
             Candidate::new(expr_place_builder.clone(), &wildcard, false, false, self);
         let fake_borrow_temps = self.lower_match_tree(

compiler/rustc_mir_build/src/build/matches/simplify.rs

@@ -127,7 +127,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) -> Vec<Candidate<'pat, 'tcx>> {
         pats.iter()
             .map(|box pat| {
-                let mut candidate = Candidate::new(place.clone(), pat, candidate.has_guard, candidate.is_cold, self);
+                let mut candidate = Candidate::new(
+                    place.clone(),
+                    pat,
+                    candidate.has_guard,
+                    candidate.is_cold,
+                    self,
+                );
                 self.simplify_candidate(&mut candidate);
                 candidate
             })

compiler/rustc_mir_build/src/build/matches/test.rs

@@ -219,7 +219,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         None
                     } else {
                         for i in cold_targets.iter() {
-                            if *i < 2 { cold_br[*i] = true; }
+                            if *i < 2 {
+                                cold_br[*i] = true;
+                            }
                         }
                         if cold_br[0] != cold_br[1] { Some(cold_br[0]) } else { None }
                     };
@@ -231,7 +233,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         0 => (second_bb, first_bb, cold_br.and_then(|x| Some(!x))),
                         v => span_bug!(test.span, "expected boolean value but got {:?}", v),
                     };
-                    TerminatorKind::if_with_cold_br(Operand::Copy(place), true_bb, false_bb, cold_br)
+                    TerminatorKind::if_with_cold_br(
+                        Operand::Copy(place),
+                        true_bb,
+                        false_bb,
+                        cold_br,
+                    )
                 } else {
                     // The switch may be inexhaustive so we have a catch all block
                     debug_assert_eq!(options.len() + 1, target_blocks.len());