Remove span from hir::ForeignItem.

Author: cjgillot

compiler/rustc_ast_lowering/src/item.rs

@@ -728,7 +728,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ForeignItemKind::MacCall(_) => panic!("macro shouldn't exist here"),
             },
             vis: self.lower_visibility(&i.vis, None),
-            span: i.span,
         }
     }
 

compiler/rustc_hir/src/hir.rs

@@ -2880,7 +2880,6 @@ pub struct ForeignItem<'hir> {
     pub ident: Ident,
     pub kind: ForeignItemKind<'hir>,
     pub def_id: LocalDefId,
-    pub span: Span,
     pub vis: Visibility<'hir>,
 }
 
@@ -3044,5 +3043,5 @@ mod size_asserts {
     rustc_data_structures::static_assert_size!(super::Item<'static>, 176);
     rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 120);
     rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 144);
-    rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 136);
+    rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 128);
 }

compiler/rustc_hir/src/stable_hash_impls.rs

@@ -165,12 +165,11 @@ impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for ImplItem<'_> {
 
 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for ForeignItem<'_> {
     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
-        let ForeignItem { def_id: _, ident, ref kind, span, ref vis } = *self;
+        let ForeignItem { def_id: _, ident, ref kind, ref vis } = *self;
 
         hcx.hash_hir_item_like(|hcx| {
             ident.name.hash_stable(hcx, hasher);
             kind.hash_stable(hcx, hasher);
-            span.hash_stable(hcx, hasher);
             vis.hash_stable(hcx, hasher);
         });
     }

compiler/rustc_lint/src/builtin.rs

@@ -2927,11 +2927,13 @@ impl<'tcx> LateLintPass<'tcx> for ClashingExternDeclarations {
 
                     // We want to ensure that we use spans for both decls that include where the
                     // name was defined, whether that was from the link_name attribute or not.
-                    let get_relevant_span =
-                        |fi: &hir::ForeignItem<'_>| match Self::name_of_extern_decl(tcx, fi) {
-                            SymbolName::Normal(_) => fi.span,
-                            SymbolName::Link(_, annot_span) => fi.span.to(annot_span),
-                        };
+                    let get_relevant_span = |fi: &hir::ForeignItem<'_>| {
+                        let fi_span = tcx.hir().span(fi.hir_id());
+                        match Self::name_of_extern_decl(tcx, fi) {
+                            SymbolName::Normal(_) => fi_span,
+                            SymbolName::Link(_, annot_span) => fi_span.to(annot_span),
+                        }
+                    };
                     // Finally, emit the diagnostic.
                     tcx.struct_span_lint_hir(
                         CLASHING_EXTERN_DECLARATIONS,

compiler/rustc_passes/src/dead.rs

@@ -646,7 +646,12 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> {
 
     fn visit_foreign_item(&mut self, fi: &'tcx hir::ForeignItem<'tcx>) {
         if self.should_warn_about_foreign_item(fi) {
-            self.warn_dead_code(fi.hir_id(), fi.span, fi.ident.name, "used");
+            self.warn_dead_code(
+                fi.hir_id(),
+                self.tcx.hir().span(fi.hir_id()),
+                fi.ident.name,
+                "used",
+            );
         }
         intravisit::walk_foreign_item(self, fi);
     }

compiler/rustc_passes/src/weak_lang_items.rs

@@ -99,7 +99,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
         let check_name = |attr, sym| self.tcx.sess.check_name(attr, sym);
         let attrs = self.tcx.hir().attrs(i.hir_id());
         if let Some((lang_item, _)) = lang_items::extract(check_name, attrs) {
-            self.register(lang_item, i.span);
+            self.register(lang_item, self.tcx.hir().span(i.hir_id()));
         }
         intravisit::walk_foreign_item(self, i)
     }

compiler/rustc_typeck/src/check/check.rs

@@ -835,7 +835,12 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
                     let item = tcx.hir().foreign_item(item.id);
                     match item.kind {
                         hir::ForeignItemKind::Fn(ref fn_decl, _, _) => {
-                            require_c_abi_if_c_variadic(tcx, fn_decl, abi, item.span);
+                            require_c_abi_if_c_variadic(
+                                tcx,
+                                fn_decl,
+                                abi,
+                                tcx.hir().span(item.hir_id()),
+                            );
                         }
                         hir::ForeignItemKind::Static(..) => {
                             check_static_inhabited(tcx, item.def_id);

compiler/rustc_typeck/src/check/intrinsic.rs

@@ -23,11 +23,12 @@ fn equate_intrinsic_type<'tcx>(
     n_tps: usize,
     sig: ty::PolyFnSig<'tcx>,
 ) {
+    let it_span = tcx.hir().span(it.hir_id());
     match it.kind {
         hir::ForeignItemKind::Fn(..) => {}
         _ => {
-            struct_span_err!(tcx.sess, it.span, E0622, "intrinsic must be a function")
-                .span_label(it.span, "expected a function")
+            struct_span_err!(tcx.sess, it_span, E0622, "intrinsic must be a function")
+                .span_label(it_span, "expected a function")
                 .emit();
             return;
         }
@@ -49,7 +50,7 @@ fn equate_intrinsic_type<'tcx>(
     }
 
     let fty = tcx.mk_fn_ptr(sig);
-    let cause = ObligationCause::new(it.span, it.hir_id(), ObligationCauseCode::IntrinsicType);
+    let cause = ObligationCause::new(it_span, it.hir_id(), ObligationCauseCode::IntrinsicType);
     require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(it.def_id)), fty);
 }
 
@@ -130,7 +131,8 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
             | "umin" => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], param(0)),
             "fence" | "singlethreadfence" => (0, Vec::new(), tcx.mk_unit()),
             op => {
-                tcx.sess.emit_err(UnrecognizedAtomicOperation { span: it.span, op });
+                let it_span = tcx.hir().span(it.hir_id());
+                tcx.sess.emit_err(UnrecognizedAtomicOperation { span: it_span, op });
                 return;
             }
         };
@@ -359,7 +361,8 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
             sym::nontemporal_store => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
 
             other => {
-                tcx.sess.emit_err(UnrecognizedIntrinsicFunction { span: it.span, name: other });
+                let it_span = tcx.hir().span(it.hir_id());
+                tcx.sess.emit_err(UnrecognizedIntrinsicFunction { span: it_span, name: other });
                 return;
             }
         };
@@ -440,14 +443,16 @@ pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>)
                     (2, params, param(1))
                 }
                 Err(_) => {
-                    tcx.sess.emit_err(SimdShuffleMissingLength { span: it.span, name });
+                    let it_span = tcx.hir().span(it.hir_id());
+                    tcx.sess.emit_err(SimdShuffleMissingLength { span: it_span, name });
                     return;
                 }
             }
         }
         _ => {
             let msg = format!("unrecognized platform-specific intrinsic function: `{}`", name);
-            tcx.sess.struct_span_err(it.span, &msg).emit();
+            let it_span = tcx.hir().span(it.hir_id());
+            tcx.sess.struct_span_err(it_span, &msg).emit();
             return;
         }
     };

src/librustdoc/doctest.rs

@@ -1075,7 +1075,8 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx>
     }
 
     fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem<'_>) {
-        self.visit_testable(item.ident.to_string(), item.hir_id(), item.span, |this| {
+        let item_span = self.tcx.hir().span(item.hir_id());
+        self.visit_testable(item.ident.to_string(), item.hir_id(), item_span, |this| {
             intravisit::walk_foreign_item(this, item);
         });
     }