Merge pull request rust-lang#3512 from matthiaskrgr/rustup

rustup rust-lang/rust#56502 ( .hir -> .hir() )

.travis.yml

@@ -30,7 +30,7 @@ before_install:
 install:
   - |
     if [ -z ${INTEGRATION} ]; then
-      rustup component add rustfmt-preview || cargo install --git https://github.com/rust-lang/rustfmt/ --force
+      rustup component add rustfmt || cargo install --git https://github.com/rust-lang/rustfmt/ --force
       if [ "$TRAVIS_OS_NAME" == "linux" ]; then
         . $HOME/.nvm/nvm.sh
         nvm install stable

clippy_lints/src/arithmetic.rs

@@ -121,11 +121,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
     }
 
     fn check_body(&mut self, cx: &LateContext<'_, '_>, body: &hir::Body) {
-        let body_owner = cx.tcx.hir.body_owner(body.id());
+        let body_owner = cx.tcx.hir().body_owner(body.id());
 
-        match cx.tcx.hir.body_owner_kind(body_owner) {
+        match cx.tcx.hir().body_owner_kind(body_owner) {
             hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => {
-                let body_span = cx.tcx.hir.span(body_owner);
+                let body_span = cx.tcx.hir().span(body_owner);
 
                 if let Some(span) = self.const_span {
                     if span.contains(body_span) {
@@ -139,8 +139,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
     }
 
     fn check_body_post(&mut self, cx: &LateContext<'_, '_>, body: &hir::Body) {
-        let body_owner = cx.tcx.hir.body_owner(body.id());
-        let body_span = cx.tcx.hir.span(body_owner);
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_span = cx.tcx.hir().span(body_owner);
 
         if let Some(span) = self.const_span {
             if span.contains(body_span) {

clippy_lints/src/assign_ops.rs

@@ -144,12 +144,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                                             return; // useless if the trait doesn't exist
                                         };
                                         // check that we are not inside an `impl AssignOp` of this exact operation
-                                        let parent_fn = cx.tcx.hir.get_parent(e.id);
-                                        let parent_impl = cx.tcx.hir.get_parent(parent_fn);
+                                        let parent_fn = cx.tcx.hir().get_parent(e.id);
+                                        let parent_impl = cx.tcx.hir().get_parent(parent_fn);
                                         // the crate node is the only one that is not in the map
                                         if_chain! {
                                             if parent_impl != ast::CRATE_NODE_ID;
-                                            if let hir::Node::Item(item) = cx.tcx.hir.get(parent_impl);
+                                            if let hir::Node::Item(item) = cx.tcx.hir().get(parent_impl);
                                             if let hir::ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) =
                                                 item.node;
                                             if trait_ref.path.def.def_id() == trait_id;

clippy_lints/src/attrs.rs

@@ -354,15 +354,15 @@ fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) {
 
 fn is_relevant_item(tcx: TyCtxt<'_, '_, '_>, item: &Item) -> bool {
     if let ItemKind::Fn(_, _, _, eid) = item.node {
-        is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
+        is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir().body(eid).value)
     } else {
         true
     }
 }
 
 fn is_relevant_impl(tcx: TyCtxt<'_, '_, '_>, item: &ImplItem) -> bool {
     match item.node {
-        ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value),
+        ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir().body(eid).value),
         _ => false,
     }
 }
@@ -371,7 +371,7 @@ fn is_relevant_trait(tcx: TyCtxt<'_, '_, '_>, item: &TraitItem) -> bool {
     match item.node {
         TraitItemKind::Method(_, TraitMethod::Required(_)) => true,
         TraitItemKind::Method(_, TraitMethod::Provided(eid)) => {
-            is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
+            is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir().body(eid).value)
         },
         _ => false,
     }

clippy_lints/src/block_in_if_condition.rs

@@ -68,7 +68,7 @@ struct ExVisitor<'a, 'tcx: 'a> {
 impl<'a, 'tcx: 'a> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr) {
         if let ExprKind::Closure(_, _, eid, _, _) = expr.node {
-            let body = self.cx.tcx.hir.body(eid);
+            let body = self.cx.tcx.hir().body(eid);
             let ex = &body.value;
             if matches!(ex.node, ExprKind::Block(_, _)) && !in_macro(body.value.span) {
                 self.found_block = Some(ex);

clippy_lints/src/bytecount.rs

@@ -60,7 +60,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
             if filter_args.len() == 2;
             if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].node;
             then {
-                let body = cx.tcx.hir.body(body_id);
+                let body = cx.tcx.hir().body(body_id);
                 if_chain! {
                     if body.arguments.len() == 1;
                     if let Some(argname) = get_pat_name(&body.arguments[0].pat);

clippy_lints/src/copy_iterator.rs

@@ -49,7 +49,7 @@ impl LintPass for CopyIterator {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyIterator {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
         if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node {
-            let ty = cx.tcx.type_of(cx.tcx.hir.local_def_id(item.id));
+            let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id(item.id));
 
             if is_copy(cx, ty) && match_path(&trait_ref.path, &paths::ITERATOR) {
                 span_note_and_lint(

clippy_lints/src/cyclomatic_complexity.rs

@@ -130,7 +130,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CyclomaticComplexity {
         span: Span,
         node_id: NodeId,
     ) {
-        let def_id = cx.tcx.hir.local_def_id(node_id);
+        let def_id = cx.tcx.hir().local_def_id(node_id);
         if !cx.tcx.has_attr(def_id, "test") {
             self.check(cx, body, span);
         }

clippy_lints/src/derive.rs

@@ -82,7 +82,7 @@ impl LintPass for Derive {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
         if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node {
-            let ty = cx.tcx.type_of(cx.tcx.hir.local_def_id(item.id));
+            let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id(item.id));
             let is_automatically_derived = is_automatically_derived(&*item.attrs);
 
             check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
@@ -129,9 +129,9 @@ fn check_hash_peq<'a, 'tcx>(
                         cx, DERIVE_HASH_XOR_EQ, span,
                         mess,
                         |db| {
-                        if let Some(node_id) = cx.tcx.hir.as_local_node_id(impl_id) {
+                        if let Some(node_id) = cx.tcx.hir().as_local_node_id(impl_id) {
                             db.span_note(
-                                cx.tcx.hir.span(node_id),
+                                cx.tcx.hir().span(node_id),
                                 "`PartialEq` implemented here"
                             );
                         }

clippy_lints/src/empty_enum.rs

@@ -43,7 +43,7 @@ impl LintPass for EmptyEnum {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EmptyEnum {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item) {
-        let did = cx.tcx.hir.local_def_id(item.id);
+        let did = cx.tcx.hir().local_def_id(item.id);
         if let ItemKind::Enum(..) = item.node {
             let ty = cx.tcx.type_of(did);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");

clippy_lints/src/enum_clike.rs

@@ -62,7 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant {
                 let variant = &var.node;
                 if let Some(ref anon_const) = variant.disr_expr {
                     let param_env = ty::ParamEnv::empty();
-                    let def_id = cx.tcx.hir.body_owner_def_id(anon_const.body);
+                    let def_id = cx.tcx.hir().body_owner_def_id(anon_const.body);
                     let substs = Substs::identity_for_item(cx.tcx.global_tcx(), def_id);
                     let instance = ty::Instance::new(def_id, substs);
                     let c_id = GlobalId {

clippy_lints/src/enum_glob_use.rs

@@ -47,7 +47,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EnumGlobUse {
     fn check_mod(&mut self, cx: &LateContext<'a, 'tcx>, m: &'tcx Mod, _: Span, _: NodeId) {
         // only check top level `use` statements
         for item in &m.item_ids {
-            self.lint_item(cx, cx.tcx.hir.expect_item(item.id));
+            self.lint_item(cx, cx.tcx.hir().expect_item(item.id));
         }
     }
 }

clippy_lints/src/escape.rs

@@ -74,8 +74,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         node_id: NodeId,
     ) {
         // If the method is an impl for a trait, don't warn
-        let parent_id = cx.tcx.hir.get_parent(node_id);
-        let parent_node = cx.tcx.hir.find(parent_id);
+        let parent_id = cx.tcx.hir().get_parent(node_id);
+        let parent_node = cx.tcx.hir().find(parent_id);
 
         if let Some(Node::Item(item)) = parent_node {
             if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.node {
@@ -89,15 +89,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
             too_large_for_stack: self.too_large_for_stack,
         };
 
-        let fn_def_id = cx.tcx.hir.local_def_id(node_id);
+        let fn_def_id = cx.tcx.hir().local_def_id(node_id);
         let region_scope_tree = &cx.tcx.region_scope_tree(fn_def_id);
         ExprUseVisitor::new(&mut v, cx.tcx, cx.param_env, region_scope_tree, cx.tables, None).consume_body(body);
 
         for node in v.set {
             span_lint(
                 cx,
                 BOXED_LOCAL,
-                cx.tcx.hir.span(node),
+                cx.tcx.hir().span(node),
                 "local variable doesn't need to be boxed here",
             );
         }
@@ -115,7 +115,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
     }
     fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}
     fn consume_pat(&mut self, consume_pat: &Pat, cmt: &cmt_<'tcx>, _: ConsumeMode) {
-        let map = &self.cx.tcx.hir;
+        let map = &self.cx.tcx.hir();
         if map.is_argument(consume_pat.id) {
             // Skip closure arguments
             if let Some(Node::Expr(..)) = map.find(map.get_parent_node(consume_pat.id)) {

clippy_lints/src/eta_reduction.rs

@@ -62,7 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaPass {
 
 fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
     if let ExprKind::Closure(_, ref decl, eid, _, _) = expr.node {
-        let body = cx.tcx.hir.body(eid);
+        let body = cx.tcx.hir().body(eid);
         let ex = &body.value;
         if let ExprKind::Call(ref caller, ref args) = ex.node {
             if args.len() != decl.inputs.len() {

clippy_lints/src/eval_order_dependence.rs

@@ -191,7 +191,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
 ///
 /// When such a read is found, the lint is triggered.
 fn check_for_unsequenced_reads(vis: &mut ReadVisitor<'_, '_>) {
-    let map = &vis.cx.tcx.hir;
+    let map = &vis.cx.tcx.hir();
     let mut cur_id = vis.write_expr.id;
     loop {
         let parent_id = map.get_parent_node(cur_id);

clippy_lints/src/fallible_impl_from.rs

@@ -48,7 +48,7 @@ impl LintPass for FallibleImplFrom {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FallibleImplFrom {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
         // check for `impl From<???> for ..`
-        let impl_def_id = cx.tcx.hir.local_def_id(item.id);
+        let impl_def_id = cx.tcx.hir().local_def_id(item.id);
         if_chain! {
             if let hir::ItemKind::Impl(.., ref impl_items) = item.node;
             if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id);
@@ -106,11 +106,11 @@ fn lint_impl_body<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, impl_span: Span, impl_it
         if_chain! {
             if impl_item.ident.name == "from";
             if let ImplItemKind::Method(_, body_id) =
-                cx.tcx.hir.impl_item(impl_item.id).node;
+                cx.tcx.hir().impl_item(impl_item.id).node;
             then {
                 // check the body for `begin_panic` or `unwrap`
-                let body = cx.tcx.hir.body(body_id);
-                let impl_item_def_id = cx.tcx.hir.local_def_id(impl_item.id.node_id);
+                let body = cx.tcx.hir().body(body_id);
+                let impl_item_def_id = cx.tcx.hir().local_def_id(impl_item.id.node_id);
                 let mut fpu = FindPanicUnwrap {
                     tcx: cx.tcx,
                     tables: cx.tcx.typeck_tables_of(impl_item_def_id),

clippy_lints/src/functions.rs

@@ -95,7 +95,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
         span: Span,
         nodeid: ast::NodeId,
     ) {
-        let is_impl = if let Some(hir::Node::Item(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent_node(nodeid)) {
+        let is_impl = if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(nodeid)) {
             matches!(item.node, hir::ItemKind::Impl(_, _, _, _, Some(_), _, _))
         } else {
             false
@@ -138,7 +138,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
             }
 
             if let hir::TraitMethod::Provided(eid) = *eid {
-                let body = cx.tcx.hir.body(eid);
+                let body = cx.tcx.hir().body(eid);
                 self.check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.id);
             }
         }

clippy_lints/src/implicit_return.rs

@@ -119,7 +119,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         _: Span,
         _: NodeId,
     ) {
-        let def_id = cx.tcx.hir.body_owner_def_id(body.id());
+        let def_id = cx.tcx.hir().body_owner_def_id(body.id());
         let mir = cx.tcx.optimized_mir(def_id);
 
         // checking return type through MIR, HIR is not able to determine inferred closure return types

clippy_lints/src/infinite_iter.rs

@@ -165,7 +165,7 @@ fn is_infinite(cx: &LateContext<'_, '_>, expr: &Expr) -> Finiteness {
             }
             if method.ident.name == "flat_map" && args.len() == 2 {
                 if let ExprKind::Closure(_, _, body_id, _, _) = args[1].node {
-                    let body = cx.tcx.hir.body(body_id);
+                    let body = cx.tcx.hir().body(body_id);
                     return is_infinite(cx, &body.value);
                 }
             }

clippy_lints/src/large_enum_variant.rs

@@ -59,7 +59,7 @@ impl LintPass for LargeEnumVariant {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LargeEnumVariant {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item) {
-        let did = cx.tcx.hir.local_def_id(item.id);
+        let did = cx.tcx.hir().local_def_id(item.id);
         if let ItemKind::Enum(ref def, _) = item.node {
             let ty = cx.tcx.type_of(did);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");

clippy_lints/src/len_zero.rs

@@ -137,7 +137,7 @@ fn check_trait_items(cx: &LateContext<'_, '_>, visited_trait: &Item, trait_items
         item.ident.name == name
             && if let AssociatedItemKind::Method { has_self } = item.kind {
                 has_self && {
-                    let did = cx.tcx.hir.local_def_id(item.id.node_id);
+                    let did = cx.tcx.hir().local_def_id(item.id.node_id);
                     cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
                 }
             } else {
@@ -156,7 +156,7 @@ fn check_trait_items(cx: &LateContext<'_, '_>, visited_trait: &Item, trait_items
 
     if cx.access_levels.is_exported(visited_trait.id) && trait_items.iter().any(|i| is_named_self(cx, i, "len")) {
         let mut current_and_super_traits = FxHashSet::default();
-        let visited_trait_def_id = cx.tcx.hir.local_def_id(visited_trait.id);
+        let visited_trait_def_id = cx.tcx.hir().local_def_id(visited_trait.id);
         fill_trait_set(visited_trait_def_id, &mut current_and_super_traits, cx);
 
         let is_empty_method_found = current_and_super_traits
@@ -188,7 +188,7 @@ fn check_impl_items(cx: &LateContext<'_, '_>, item: &Item, impl_items: &[ImplIte
         item.ident.name == name
             && if let AssociatedItemKind::Method { has_self } = item.kind {
                 has_self && {
-                    let did = cx.tcx.hir.local_def_id(item.id.node_id);
+                    let did = cx.tcx.hir().local_def_id(item.id.node_id);
                     cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
                 }
             } else {
@@ -208,7 +208,7 @@ fn check_impl_items(cx: &LateContext<'_, '_>, item: &Item, impl_items: &[ImplIte
 
     if let Some(i) = impl_items.iter().find(|i| is_named_self(cx, i, "len")) {
         if cx.access_levels.is_exported(i.id.node_id) {
-            let def_id = cx.tcx.hir.local_def_id(item.id);
+            let def_id = cx.tcx.hir().local_def_id(item.id);
             let ty = cx.tcx.type_of(def_id);
 
             span_lint(

clippy_lints/src/lifetimes.rs

@@ -204,7 +204,7 @@ fn could_use_elision<'a, 'tcx: 'a>(
         let mut checker = BodyLifetimeChecker {
             lifetimes_used_in_body: false,
         };
-        checker.visit_expr(&cx.tcx.hir.body(body_id).value);
+        checker.visit_expr(&cx.tcx.hir().body(body_id).value);
         if checker.lifetimes_used_in_body {
             return false;
         }
@@ -324,7 +324,7 @@ impl<'v, 't> RefVisitor<'v, 't> {
                     GenericArg::Type(_) => false,
                 })
             {
-                let hir_id = self.cx.tcx.hir.node_to_hir_id(ty.id);
+                let hir_id = self.cx.tcx.hir().node_to_hir_id(ty.id);
                 match self.cx.tables.qpath_def(qpath, hir_id) {
                     Def::TyAlias(def_id) | Def::Struct(def_id) => {
                         let generics = self.cx.tcx.generics_of(def_id);
@@ -360,7 +360,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
                 self.collect_anonymous_lifetimes(path, ty);
             },
             TyKind::Def(item, _) => {
-                if let ItemKind::Existential(ref exist_ty) = self.cx.tcx.hir.expect_item(item.id).node {
+                if let ItemKind::Existential(ref exist_ty) = self.cx.tcx.hir().expect_item(item.id).node {
                     for bound in &exist_ty.bounds {
                         if let GenericBound::Outlives(_) = *bound {
                             self.record(&None);