Add make tidy fixes

flodiebold · flodiebold · commit c7d698143c01 · 2016-11-21T20:34:18.000+01:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -124,7 +124,10 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_items(&mut self, c: &Crate) -> (BTreeMap<NodeId, hir::Item>, BTreeMap<hir::ImplItemId, hir::ImplItem>) {
+    fn lower_items(&mut self,
+                   c: &Crate)
+                   -> (BTreeMap<NodeId, hir::Item>,
+                       BTreeMap<hir::ImplItemId, hir::ImplItem>) {
         struct ItemLowerer<'lcx, 'interner: 'lcx> {
             items: BTreeMap<NodeId, hir::Item>,
             impl_items: BTreeMap<hir::ImplItemId, hir::ImplItem>,
diff --git a/src/librustc/hir/map/blocks.rs b/src/librustc/hir/map/blocks.rs
@@ -184,7 +184,10 @@ impl<'a> FnLikeNode<'a> {
     }
 
     pub fn decl(self) -> &'a FnDecl {
-        if let map::NodeInlinedItem(&InlinedItem { kind: InlinedItemKind::Fn(ref decl), .. }) = self.node {
+        if let map::NodeInlinedItem(&InlinedItem {
+            kind: InlinedItemKind::Fn(ref decl),
+            ..
+        }) = self.node {
             return &decl;
         }
         self.handle(|i: ItemFnParts<'a>|  &*i.decl,
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -589,7 +589,7 @@ impl<'ast> Map<'ast> {
     pub fn get_parent_did(&self, id: NodeId) -> DefId {
         let parent = self.get_parent(id);
         match self.find_entry(parent) {
-            Some(RootInlinedParent(ii)) => ii.def_id, // TODO: is this wrong for items?
+            Some(RootInlinedParent(ii)) => ii.def_id,
             _ => self.local_def_id(parent)
         }
     }
diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs
@@ -128,9 +128,13 @@ pub enum InlinedItemKindRef<'a> {
 }
 
 impl<'a> InlinedItemRef<'a> {
-    pub fn from_item<'ast: 'a>(def_id: DefId, item: &'a hir::Item, map: &hir_map::Map<'ast>) -> InlinedItemRef<'a> {
+    pub fn from_item<'ast: 'a>(def_id: DefId,
+                               item: &'a hir::Item,
+                               map: &hir_map::Map<'ast>)
+                               -> InlinedItemRef<'a> {
         let (body, kind) = match item.node {
-            hir::ItemFn(ref decl, _, _, _, _, body_id) => (map.expr(body_id), InlinedItemKindRef::Fn(&decl)),
+            hir::ItemFn(ref decl, _, _, _, _, body_id) =>
+                (map.expr(body_id), InlinedItemKindRef::Fn(&decl)),
             hir::ItemConst(ref ty, ref body) => (&**body, InlinedItemKindRef::Const(ty)),
             _ => bug!("InlinedItemRef::from_item wrong kind")
         };
@@ -141,10 +145,15 @@ impl<'a> InlinedItemRef<'a> {
         }
     }
 
-    pub fn from_trait_item(def_id: DefId, item: &'a hir::TraitItem, _map: &hir_map::Map) -> InlinedItemRef<'a> {
+    pub fn from_trait_item(def_id: DefId,
+                           item: &'a hir::TraitItem,
+                           _map: &hir_map::Map)
+                           -> InlinedItemRef<'a> {
         let (body, kind) = match item.node {
             hir::ConstTraitItem(ref ty, Some(ref body)) => (&**body, InlinedItemKindRef::Const(ty)),
-            hir::ConstTraitItem(_, None) => bug!("InlinedItemRef::from_trait_item called for const without body"),
+            hir::ConstTraitItem(_, None) => {
+                bug!("InlinedItemRef::from_trait_item called for const without body")
+            },
             _ => bug!("InlinedItemRef::from_trait_item wrong kind")
         };
         InlinedItemRef {
@@ -154,9 +163,13 @@ impl<'a> InlinedItemRef<'a> {
         }
     }
 
-    pub fn from_impl_item<'ast: 'a>(def_id: DefId, item: &'a hir::ImplItem, map: &hir_map::Map<'ast>) -> InlinedItemRef<'a> {
+    pub fn from_impl_item<'ast: 'a>(def_id: DefId,
+                                    item: &'a hir::ImplItem,
+                                    map: &hir_map::Map<'ast>)
+                                    -> InlinedItemRef<'a> {
         let (body, kind) = match item.node {
-            hir::ImplItemKind::Method(ref sig, body_id) => (map.expr(body_id), InlinedItemKindRef::Fn(&sig.decl)),
+            hir::ImplItemKind::Method(ref sig, body_id) =>
+                (map.expr(body_id), InlinedItemKindRef::Fn(&sig.decl)),
             hir::ImplItemKind::Const(ref ty, ref body) => (&**body, InlinedItemKindRef::Const(ty)),
             _ => bug!("InlinedItemRef::from_impl_item wrong kind")
         };
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -850,7 +850,8 @@ fn resolve_expr<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>, expr:
     visitor.cx = prev_cx;
 }
 
-fn resolve_local<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>, local: &'tcx hir::Local) {
+fn resolve_local<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>,
+                           local: &'tcx hir::Local) {
     debug!("resolve_local(local.id={:?},local.init={:?})",
            local.id,local.init.is_some());
 
diff --git a/src/librustc_const_eval/eval.rs b/src/librustc_const_eval/eval.rs
@@ -111,7 +111,8 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                         // or the default.
                         let trait_id = tcx.map.get_parent(node_id);
                         let trait_id = tcx.map.local_def_id(trait_id);
-                        let default_value = expr_option.as_ref().map(|expr| (&**expr, tcx.ast_ty_to_prim_ty(ty)));
+                        let default_value = expr_option.as_ref()
+                            .map(|expr| (&**expr, tcx.ast_ty_to_prim_ty(ty)));
                         resolve_trait_associated_const(tcx, def_id, default_value, trait_id, substs)
                     } else {
                         // Technically, without knowing anything about the
@@ -143,7 +144,8 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         }
         let mut used_substs = false;
         let expr_ty = match tcx.sess.cstore.maybe_get_item_ast(tcx, def_id) {
-            Some((&InlinedItem { body: ref const_expr, kind: InlinedItemKind::Const(ref ty), .. }, _)) => {
+            Some((&InlinedItem { body: ref const_expr,
+                                 kind: InlinedItemKind::Const(ref ty), .. }, _)) => {
                 Some((&**const_expr, tcx.ast_ty_to_prim_ty(ty)))
             }
             _ => None
@@ -1044,12 +1046,13 @@ fn infer<'a, 'tcx>(i: ConstInt,
     }
 }
 
-fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                                                trait_item_id: DefId,
-                                                default_value: Option<(&'tcx Expr, Option<ty::Ty<'tcx>>)>,
-                                                trait_id: DefId,
-                                                rcvr_substs: &'tcx Substs<'tcx>)
-                                                -> Option<(&'tcx Expr, Option<ty::Ty<'tcx>>)>
+fn resolve_trait_associated_const<'a, 'tcx: 'a>(
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    trait_item_id: DefId,
+    default_value: Option<(&'tcx Expr, Option<ty::Ty<'tcx>>)>,
+    trait_id: DefId,
+    rcvr_substs: &'tcx Substs<'tcx>
+) -> Option<(&'tcx Expr, Option<ty::Ty<'tcx>>)>
 {
     let trait_ref = ty::Binder(ty::TraitRef::new(trait_id, rcvr_substs));
     debug!("resolve_trait_associated_const: trait_ref={:?}",
diff --git a/src/librustc_incremental/calculate_svh/mod.rs b/src/librustc_incremental/calculate_svh/mod.rs
@@ -153,7 +153,10 @@ impl<'a, 'tcx> HashItemsVisitor<'a, 'tcx> {
         self.calculate_def_hash(DepNode::HirBody(def_id), true, &mut walk_op);
     }
 
-    fn calculate_def_hash<W>(&mut self, dep_node: DepNode<DefId>, hash_bodies: bool, walk_op: &mut W)
+    fn calculate_def_hash<W>(&mut self,
+                             dep_node: DepNode<DefId>,
+                             hash_bodies: bool,
+                             walk_op: &mut W)
         where W: for<'v> FnMut(&mut StrictVersionHashVisitor<'v, 'a, 'tcx>)
     {
         let mut state = IchHasher::new();
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
@@ -520,7 +520,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 // We only save the HIR for associated consts with bodies
                 // (InlinedItemRef::from_trait_item panics otherwise)
                 let trait_def_id = trait_item.container.id();
-                Some(self.encode_inlined_item(InlinedItemRef::from_trait_item(trait_def_id, ast_item, &tcx.map)))
+                Some(self.encode_inlined_item(
+                    InlinedItemRef::from_trait_item(trait_def_id, ast_item, &tcx.map)
+                ))
             } else {
                 None
             },
@@ -591,7 +593,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             predicates: Some(self.encode_predicates(def_id)),
 
             ast: if ast {
-                Some(self.encode_inlined_item(InlinedItemRef::from_impl_item(impl_def_id, ast_item, &tcx.map)))
+                Some(self.encode_inlined_item(
+                    InlinedItemRef::from_impl_item(impl_def_id, ast_item, &tcx.map)
+                ))
             } else {
                 None
             },
@@ -821,7 +825,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             ast: match item.node {
                 hir::ItemConst(..) |
                 hir::ItemFn(_, _, hir::Constness::Const, ..) => {
-                    Some(self.encode_inlined_item(InlinedItemRef::from_item(def_id, item, &tcx.map)))
+                    Some(self.encode_inlined_item(
+                        InlinedItemRef::from_item(def_id, item, &tcx.map)
+                    ))
                 }
                 _ => None,
             },
diff --git a/src/librustc_passes/consts.rs b/src/librustc_passes/consts.rs
@@ -181,7 +181,8 @@ impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
     /// Returns true if the call is to a const fn or method.
     fn handle_const_fn_call(&mut self, _expr: &hir::Expr, def_id: DefId, ret_ty: Ty<'gcx>) -> bool {
         if let Some(fn_like) = lookup_const_fn_by_id(self.tcx, def_id) {
-            let qualif = match self.tcx.const_qualif_map.borrow_mut().entry(fn_like.body().node_id()) {
+            let node_id = fn_like.body().node_id();
+            let qualif = match self.tcx.const_qualif_map.borrow_mut().entry(node_id) {
                 Entry::Occupied(entry) => Some(*entry.get()),
                 _ => None
             };
diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs
@@ -144,7 +144,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                        decl: &hir::FnDecl,
                        body_id: hir::ExprId) {
         debug!("regionck_fn(id={})", fn_id);
-        let mut rcx = RegionCtxt::new(self, RepeatingScope(body_id.node_id()), body_id.node_id(), Subject(fn_id));
+        let node_id = body_id.node_id();
+        let mut rcx = RegionCtxt::new(self, RepeatingScope(node_id), node_id, Subject(fn_id));
 
         if self.err_count_since_creation() == 0 {
             // regionck assumes typeck succeeded

Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,10 @@ impl<'a> LoweringContext<'a> {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`- fn lower_items(&mut self, c: &Crate) -> (BTreeMap<NodeId, hir::Item>, BTreeMap<hir::ImplItemId, hir::ImplItem>) {`
	`127`	`+ fn lower_items(&mut self,`
	`128`	`+ c: &Crate)`
	`129`	`+ -> (BTreeMap<NodeId, hir::Item>,`
	`130`	`+ BTreeMap<hir::ImplItemId, hir::ImplItem>) {`
`128`	`131`	`struct ItemLowerer<'lcx, 'interner: 'lcx> {`
`129`	`132`	`items: BTreeMap<NodeId, hir::Item>,`
`130`	`133`	`impl_items: BTreeMap<hir::ImplItemId, hir::ImplItem>,`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,10 @@ impl<'a> FnLikeNode<'a> {`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`pub fn decl(self) -> &'a FnDecl {`
`187`		`- if let map::NodeInlinedItem(&InlinedItem { kind: InlinedItemKind::Fn(ref decl), .. }) = self.node {`
	`187`	`+ if let map::NodeInlinedItem(&InlinedItem {`
	`188`	`+ kind: InlinedItemKind::Fn(ref decl),`
	`189`	`+ ..`
	`190`	`+ }) = self.node {`
`188`	`191`	`return &decl;`
`189`	`192`	`}`
`190`	`193`	`self.handle(\|i: ItemFnParts<'a>\| &*i.decl,`
Original file line number	Diff line number	Diff line change
`@@ -589,7 +589,7 @@ impl<'ast> Map<'ast> {`
`589`	`589`	`pub fn get_parent_did(&self, id: NodeId) -> DefId {`
`590`	`590`	`let parent = self.get_parent(id);`
`591`	`591`	`match self.find_entry(parent) {`
`592`		`- Some(RootInlinedParent(ii)) => ii.def_id, // TODO: is this wrong for items?`
	`592`	`+ Some(RootInlinedParent(ii)) => ii.def_id,`
`593`	`593`	`_ => self.local_def_id(parent)`
`594`	`594`	`}`
`595`	`595`	`}`
Original file line number	Diff line number	Diff line change
`@@ -850,7 +850,8 @@ fn resolve_expr<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>, expr:`
`850`	`850`	`visitor.cx = prev_cx;`
`851`	`851`	`}`
`852`	`852`
`853`		`-fn resolve_local<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>, local: &'tcx hir::Local) {`
	`853`	`+fn resolve_local<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>,`
	`854`	`+ local: &'tcx hir::Local) {`
`854`	`855`	`debug!("resolve_local(local.id={:?},local.init={:?})",`
`855`	`856`	`local.id,local.init.is_some());`
`856`	`857`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,10 @@ impl<'a, 'tcx> HashItemsVisitor<'a, 'tcx> {`
`153`	`153`	`self.calculate_def_hash(DepNode::HirBody(def_id), true, &mut walk_op);`
`154`	`154`	`}`
`155`	`155`
`156`		`- fn calculate_def_hash<W>(&mut self, dep_node: DepNode<DefId>, hash_bodies: bool, walk_op: &mut W)`
	`156`	`+ fn calculate_def_hash<W>(&mut self,`
	`157`	`+ dep_node: DepNode<DefId>,`
	`158`	`+ hash_bodies: bool,`
	`159`	`+ walk_op: &mut W)`
`157`	`160`	`where W: for<'v> FnMut(&mut StrictVersionHashVisitor<'v, 'a, 'tcx>)`
`158`	`161`	`{`
`159`	`162`	`let mut state = IchHasher::new();`