Formatting fixes, making tidy happy

Author: VFLashM

src/librustc_infer/infer/outlives/verify.rs

@@ -36,11 +36,17 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         let mut visited = FxHashSet::default();
         match generic {
             GenericKind::Param(param_ty) => self.param_bound(param_ty),
-            GenericKind::Projection(projection_ty) => self.projection_bound(projection_ty, &mut visited),
+            GenericKind::Projection(projection_ty) => {
+                self.projection_bound(projection_ty, &mut visited)
+            }
         }
     }
 
-    fn type_bound(&self, ty: Ty<'tcx>, visited: &mut FxHashSet<GenericArg<'tcx>>) -> VerifyBound<'tcx> {
+    fn type_bound(
+        &self,
+        ty: Ty<'tcx>,
+        visited: &mut FxHashSet<GenericArg<'tcx>>,
+    ) -> VerifyBound<'tcx> {
         match ty.kind {
             ty::Param(p) => self.param_bound(p),
             ty::Projection(data) => self.projection_bound(data, visited),
@@ -140,7 +146,11 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         self.declared_projection_bounds_from_trait(projection_ty)
     }
 
-    pub fn projection_bound(&self, projection_ty: ty::ProjectionTy<'tcx>, visited: &mut FxHashSet<GenericArg<'tcx>>) -> VerifyBound<'tcx> {
+    pub fn projection_bound(
+        &self,
+        projection_ty: ty::ProjectionTy<'tcx>,
+        visited: &mut FxHashSet<GenericArg<'tcx>>,
+    ) -> VerifyBound<'tcx> {
         debug!("projection_bound(projection_ty={:?})", projection_ty);
 
         let projection_ty_as_ty =
@@ -174,7 +184,11 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         VerifyBound::AnyBound(env_bounds.chain(trait_bounds).collect()).or(recursive_bound)
     }
 
-    fn recursive_bound(&self, parent: GenericArg<'tcx>, visited: &mut FxHashSet<GenericArg<'tcx>>) -> VerifyBound<'tcx> {
+    fn recursive_bound(
+        &self,
+        parent: GenericArg<'tcx>,
+        visited: &mut FxHashSet<GenericArg<'tcx>>,
+    ) -> VerifyBound<'tcx> {
         let mut bounds = parent
             .walk_shallow(visited)
             .filter_map(|child| match child.unpack() {

src/librustc_middle/ty/outlives.rs

@@ -57,7 +57,12 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
-fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Component<'tcx>; 4]>, visited: &mut FxHashSet<GenericArg<'tcx>>) {
+fn compute_components(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+    out: &mut SmallVec<[Component<'tcx>; 4]>,
+    visited: &mut FxHashSet<GenericArg<'tcx>>,
+) {
     // Descend through the types, looking for the various "base"
     // components and collecting them into `out`. This is not written
     // with `collect()` because of the need to sometimes skip subtrees

src/librustc_middle/ty/walk.rs

@@ -3,8 +3,8 @@
 
 use crate::ty;
 use crate::ty::subst::{GenericArg, GenericArgKind};
-use smallvec::{self, SmallVec};
 use rustc_data_structures::fx::FxHashSet;
+use smallvec::{self, SmallVec};
 
 // The TypeWalker's stack is hot enough that it's worth going to some effort to
 // avoid heap allocations.
@@ -85,12 +85,13 @@ impl GenericArg<'tcx> {
     /// Iterator only walks items once.
     /// It accepts visited set, updates it with all visited types
     /// and skips any types that are already there.
-    pub fn walk_shallow(self, visited: &mut FxHashSet<GenericArg<'tcx>>) -> impl Iterator<Item = GenericArg<'tcx>> {
+    pub fn walk_shallow(
+        self,
+        visited: &mut FxHashSet<GenericArg<'tcx>>,
+    ) -> impl Iterator<Item = GenericArg<'tcx>> {
         let mut stack = SmallVec::new();
         push_inner(&mut stack, self);
-        stack.retain(|a| {
-            visited.insert(*a)
-        });
+        stack.retain(|a| visited.insert(*a));
         stack.into_iter()
     }
 }

src/test/ui/closures/issue-72408-nested-closures-exponential.rs

@@ -56,4 +56,4 @@ fn main() {
     let f = dup(f);
 
     println!("Type size was at least {}", f(1));
-}
+}