Pass HirId in librustc_lint.

Author: cjgillot

src/librustc_lint/builtin.rs

@@ -104,10 +104,11 @@ declare_lint! {
 declare_lint_pass!(BoxPointers => [BOX_POINTERS]);
 
 impl BoxPointers {
-    fn check_heap_type(&self, cx: &LateContext<'_, '_>, span: Span, ty: Ty<'_>) {
+    fn check_heap_type(&self, cx: &LateContext<'_, '_>, hir_id: hir::HirId, ty: Ty<'_>) {
         for leaf in ty.walk() {
             if let GenericArgKind::Type(leaf_ty) = leaf.unpack() {
                 if leaf_ty.is_box() {
+                    let span = cx.tcx.hir().span(hir_id);
                     cx.struct_span_lint(BOX_POINTERS, span, |lint| {
                         lint.build(&format!("type uses owned (Box type) pointers: {}", ty)).emit()
                     });
@@ -126,7 +127,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers {
             | hir::ItemKind::Struct(..)
             | hir::ItemKind::Union(..) => {
                 let def_id = cx.tcx.hir().local_def_id(it.hir_id);
-                self.check_heap_type(cx, it.span, cx.tcx.type_of(def_id))
+                self.check_heap_type(cx, it.hir_id, cx.tcx.type_of(def_id))
             }
             _ => (),
         }
@@ -136,8 +137,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers {
             hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => {
                 for struct_field in struct_def.fields() {
                     let def_id = cx.tcx.hir().local_def_id(struct_field.hir_id);
-                    let span = cx.tcx.hir().span(struct_field.hir_id);
-                    self.check_heap_type(cx, span, cx.tcx.type_of(def_id));
+                    self.check_heap_type(cx, struct_field.hir_id, cx.tcx.type_of(def_id));
                 }
             }
             _ => (),
@@ -146,7 +146,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers {
 
     fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr<'_>) {
         let ty = cx.tables.node_type(e.hir_id);
-        self.check_heap_type(cx, e.span, ty);
+        self.check_heap_type(cx, e.hir_id, ty);
     }
 }
 
@@ -351,9 +351,8 @@ impl MissingDoc {
     fn check_missing_docs_attrs(
         &self,
         cx: &LateContext<'_, '_>,
-        id: Option<hir::HirId>,
+        id: hir::HirId,
         attrs: &[ast::Attribute],
-        sp: Span,
         article: &'static str,
         desc: &'static str,
     ) {
@@ -371,14 +370,15 @@ impl MissingDoc {
         // Only check publicly-visible items, using the result from the privacy pass.
         // It's an option so the crate root can also use this function (it doesn't
         // have a `NodeId`).
-        if let Some(id) = id {
+        if id != hir::CRATE_HIR_ID {
             if !cx.access_levels.is_exported(id) {
                 return;
             }
         }
 
         let has_doc = attrs.iter().any(|a| has_doc(a));
         if !has_doc {
+            let sp = cx.tcx.hir().span(id);
             cx.struct_span_lint(
                 MISSING_DOCS,
                 cx.tcx.sess.source_map().guess_head_span(sp),
@@ -408,7 +408,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
     }
 
     fn check_crate(&mut self, cx: &LateContext<'_, '_>, krate: &hir::Crate<'_>) {
-        self.check_missing_docs_attrs(cx, None, &krate.item.attrs, krate.item.span, "the", "crate");
+        self.check_missing_docs_attrs(cx, hir::CRATE_HIR_ID, &krate.item.attrs, "the", "crate");
 
         for macro_def in krate.exported_macros {
             let has_doc = macro_def.attrs.iter().any(|a| has_doc(a));
@@ -467,7 +467,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
         let def_id = cx.tcx.hir().local_def_id(it.hir_id);
         let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id());
 
-        self.check_missing_docs_attrs(cx, Some(it.hir_id), &it.attrs, it.span, article, desc);
+        self.check_missing_docs_attrs(cx, it.hir_id, &it.attrs, article, desc);
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, trait_item: &hir::TraitItem<'_>) {
@@ -478,14 +478,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
         let def_id = cx.tcx.hir().local_def_id(trait_item.hir_id);
         let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id());
 
-        self.check_missing_docs_attrs(
-            cx,
-            Some(trait_item.hir_id),
-            &trait_item.attrs,
-            trait_item.span,
-            article,
-            desc,
-        );
+        self.check_missing_docs_attrs(cx, trait_item.hir_id, &trait_item.attrs, article, desc);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem<'_>) {
@@ -496,26 +489,17 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
 
         let def_id = cx.tcx.hir().local_def_id(impl_item.hir_id);
         let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id());
-        self.check_missing_docs_attrs(
-            cx,
-            Some(impl_item.hir_id),
-            &impl_item.attrs,
-            impl_item.span,
-            article,
-            desc,
-        );
+        self.check_missing_docs_attrs(cx, impl_item.hir_id, &impl_item.attrs, article, desc);
     }
 
     fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, sf: &hir::StructField<'_>) {
         if !sf.is_positional() {
-            let span = cx.tcx.hir().span(sf.hir_id);
-            self.check_missing_docs_attrs(cx, Some(sf.hir_id), &sf.attrs, span, "a", "struct field")
+            self.check_missing_docs_attrs(cx, sf.hir_id, &sf.attrs, "a", "struct field")
         }
     }
 
     fn check_variant(&mut self, cx: &LateContext<'_, '_>, v: &hir::Variant<'_>) {
-        let span = cx.tcx.hir().span(v.id);
-        self.check_missing_docs_attrs(cx, Some(v.id), &v.attrs, span, "a", "variant");
+        self.check_missing_docs_attrs(cx, v.id, &v.attrs, "a", "variant");
     }
 }
 
@@ -965,12 +949,12 @@ impl UnreachablePub {
         what: &str,
         id: hir::HirId,
         vis: &hir::Visibility<'_>,
-        span: Span,
         exportable: bool,
     ) {
         let mut applicability = Applicability::MachineApplicable;
         match vis.node {
             hir::VisibilityKind::Public if !cx.access_levels.is_reachable(id) => {
+                let span = cx.tcx.hir().span(id);
                 if span.from_expansion() {
                     applicability = Applicability::MaybeIncorrect;
                 }
@@ -1003,31 +987,23 @@ impl UnreachablePub {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
-        self.perform_lint(cx, "item", item.hir_id, &item.vis, item.span, true);
+        self.perform_lint(cx, "item", item.hir_id, &item.vis, true);
     }
 
     fn check_foreign_item(
         &mut self,
         cx: &LateContext<'_, '_>,
         foreign_item: &hir::ForeignItem<'tcx>,
     ) {
-        self.perform_lint(
-            cx,
-            "item",
-            foreign_item.hir_id,
-            &foreign_item.vis,
-            foreign_item.span,
-            true,
-        );
+        self.perform_lint(cx, "item", foreign_item.hir_id, &foreign_item.vis, true);
     }
 
     fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField<'_>) {
-        let span = cx.tcx.hir().span(field.hir_id);
-        self.perform_lint(cx, "field", field.hir_id, &field.vis, span, false);
+        self.perform_lint(cx, "field", field.hir_id, &field.vis, false);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem<'_>) {
-        self.perform_lint(cx, "item", impl_item.hir_id, &impl_item.vis, impl_item.span, false);
+        self.perform_lint(cx, "item", impl_item.hir_id, &impl_item.vis, false);
     }
 }