feed def_span in resolver

compiler/rustc_ast_lowering/src/lib.rs

@@ -804,12 +804,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// Intercept all spans entering HIR.
     /// Mark a span as relative to the current owning item.
     fn lower_span(&self, span: Span) -> Span {
-        if self.tcx.sess.opts.incremental.is_some() {
-            span.with_parent(Some(self.current_hir_id_owner.def_id))
-        } else {
-            // Do not make spans relative when not using incremental compilation.
-            span
-        }
+        rustc_middle::util::lower_span(self.tcx, span, self.current_hir_id_owner.def_id)
     }
 
     fn lower_ident(&self, ident: Ident) -> Ident {

compiler/rustc_interface/src/queries.rs

@@ -170,11 +170,14 @@ impl<'tcx> Queries<'tcx> {
                     &pre_configured_attrs,
                     crate_name,
                 )));
+                let span = krate.spans.inner_span;
                 feed.crate_for_resolver(tcx.arena.alloc(Steal::new((krate, pre_configured_attrs))));
                 feed.output_filenames(Arc::new(outputs));
 
-                let feed = tcx.feed_local_def_id(CRATE_DEF_ID);
+                let def_id = CRATE_DEF_ID;
+                let feed = tcx.feed_local_def_id(def_id);
                 feed.def_kind(DefKind::Mod);
+                feed.def_span(rustc_middle::util::lower_span(tcx, span, def_id));
             });
             Ok(qcx)
         })

compiler/rustc_middle/src/hir/map/mod.rs

@@ -19,6 +19,25 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_target::spec::abi::Abi;
 
+pub fn until_within(outer: Span, end: Span) -> Span {
+    if let Some(end) = end.find_ancestor_inside(outer) { outer.with_hi(end.hi()) } else { outer }
+}
+
+pub fn named_span(item_span: Span, ident: Ident, generics_span: Option<Span>) -> Span {
+    if ident.name != kw::Empty {
+        let mut span = until_within(item_span, ident.span);
+        if let Some(g) = generics_span
+            && !g.is_dummy()
+            && let Some(g_span) = g.find_ancestor_inside(item_span)
+        {
+            span = span.to(g_span);
+        }
+        span
+    } else {
+        item_span
+    }
+}
+
 #[inline]
 pub fn associated_body(node: Node<'_>) -> Option<(LocalDefId, BodyId)> {
     match node {
@@ -847,110 +866,14 @@ impl<'hir> Map<'hir> {
     }
 
     pub fn opt_span(self, hir_id: HirId) -> Option<Span> {
-        fn until_within(outer: Span, end: Span) -> Span {
-            if let Some(end) = end.find_ancestor_inside(outer) {
-                outer.with_hi(end.hi())
-            } else {
-                outer
-            }
-        }
-
-        fn named_span(item_span: Span, ident: Ident, generics: Option<&Generics<'_>>) -> Span {
-            if ident.name != kw::Empty {
-                let mut span = until_within(item_span, ident.span);
-                if let Some(g) = generics
-                    && !g.span.is_dummy()
-                    && let Some(g_span) = g.span.find_ancestor_inside(item_span)
-                {
-                    span = span.to(g_span);
-                }
-                span
-            } else {
-                item_span
-            }
+        if let Some(owner) = hir_id.as_owner() {
+            let span = self.tcx.def_span(owner.def_id);
+            return Some(span);
         }
 
         let span = match self.tcx.opt_hir_node(hir_id)? {
-            // Function-like.
-            Node::Item(Item { kind: ItemKind::Fn(sig, ..), span: outer_span, .. })
-            | Node::TraitItem(TraitItem {
-                kind: TraitItemKind::Fn(sig, ..),
-                span: outer_span,
-                ..
-            })
-            | Node::ImplItem(ImplItem {
-                kind: ImplItemKind::Fn(sig, ..), span: outer_span, ..
-            }) => {
-                // Ensure that the returned span has the item's SyntaxContext, and not the
-                // SyntaxContext of the visibility.
-                sig.span.find_ancestor_in_same_ctxt(*outer_span).unwrap_or(*outer_span)
-            }
-            // Impls, including their where clauses.
-            Node::Item(Item {
-                kind: ItemKind::Impl(Impl { generics, .. }),
-                span: outer_span,
-                ..
-            }) => until_within(*outer_span, generics.where_clause_span),
-            // Constants and Statics.
-            Node::Item(Item {
-                kind: ItemKind::Const(ty, ..) | ItemKind::Static(ty, ..),
-                span: outer_span,
-                ..
-            })
-            | Node::TraitItem(TraitItem {
-                kind: TraitItemKind::Const(ty, ..),
-                span: outer_span,
-                ..
-            })
-            | Node::ImplItem(ImplItem {
-                kind: ImplItemKind::Const(ty, ..),
-                span: outer_span,
-                ..
-            })
-            | Node::ForeignItem(ForeignItem {
-                kind: ForeignItemKind::Static(ty, ..),
-                span: outer_span,
-                ..
-            }) => until_within(*outer_span, ty.span),
-            // With generics and bounds.
-            Node::Item(Item {
-                kind: ItemKind::Trait(_, _, generics, bounds, _),
-                span: outer_span,
-                ..
-            })
-            | Node::TraitItem(TraitItem {
-                kind: TraitItemKind::Type(bounds, _),
-                generics,
-                span: outer_span,
-                ..
-            }) => {
-                let end = if let Some(b) = bounds.last() { b.span() } else { generics.span };
-                until_within(*outer_span, end)
-            }
-            // Other cases.
-            Node::Item(item) => match &item.kind {
-                ItemKind::Use(path, _) => {
-                    // Ensure that the returned span has the item's SyntaxContext, and not the
-                    // SyntaxContext of the path.
-                    path.span.find_ancestor_in_same_ctxt(item.span).unwrap_or(item.span)
-                }
-                _ => named_span(item.span, item.ident, item.kind.generics()),
-            },
             Node::Variant(variant) => named_span(variant.span, variant.ident, None),
-            Node::ImplItem(item) => named_span(item.span, item.ident, Some(item.generics)),
-            Node::ForeignItem(item) => match item.kind {
-                ForeignItemKind::Fn(decl, _, _) => until_within(item.span, decl.output.span()),
-                _ => named_span(item.span, item.ident, None),
-            },
             Node::Ctor(_) => return self.opt_span(self.parent_id(hir_id)),
-            Node::Expr(Expr {
-                kind: ExprKind::Closure(Closure { fn_decl_span, .. }),
-                span,
-                ..
-            }) => {
-                // Ensure that the returned span has the item's SyntaxContext.
-                fn_decl_span.find_ancestor_inside(*span).unwrap_or(*span)
-            }
             _ => self.span_with_body(hir_id),
         };
         debug_assert_eq!(span.ctxt(), self.span_with_body(hir_id).ctxt());

compiler/rustc_middle/src/hir/mod.rs

@@ -14,7 +14,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
 use rustc_hir::*;
 use rustc_query_system::ich::StableHashingContext;
-use rustc_span::{ErrorGuaranteed, ExpnId, DUMMY_SP};
+use rustc_span::{ErrorGuaranteed, ExpnId};
 
 /// Top-level HIR node for current owner. This only contains the node for which
 /// `HirId::local_id == 0`, and excludes bodies.
@@ -175,10 +175,6 @@ pub fn provide(providers: &mut Providers) {
     providers.hir_attrs = |tcx, id| {
         tcx.hir_crate(()).owners[id.def_id].as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
     };
-    providers.def_span = |tcx, def_id| {
-        let hir_id = tcx.local_def_id_to_hir_id(def_id);
-        tcx.hir().opt_span(hir_id).unwrap_or(DUMMY_SP)
-    };
     providers.def_ident_span = |tcx, def_id| {
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
         tcx.hir().opt_ident_span(hir_id)

compiler/rustc_middle/src/util/lower_span.rs

@@ -0,0 +1,13 @@
+use rustc_hir::def_id::LocalDefId;
+use rustc_span::Span;
+
+use crate::ty::TyCtxt;
+
+pub fn lower_span(tcx: TyCtxt<'_>, span: Span, parent: LocalDefId) -> Span {
+    if tcx.sess.opts.incremental.is_some() {
+        span.with_parent(Some(parent))
+    } else {
+        // Do not make spans relative when not using incremental compilation.
+        span
+    }
+}

compiler/rustc_middle/src/util/mod.rs

@@ -2,9 +2,11 @@ pub mod bug;
 pub mod call_kind;
 pub mod common;
 pub mod find_self_call;
+mod lower_span;
 
 pub use call_kind::{call_kind, CallDesugaringKind, CallKind};
 pub use find_self_call::find_self_call;
+pub use lower_span::lower_span;
 
 #[derive(Default, Copy, Clone)]
 pub struct Providers {

compiler/rustc_monomorphize/src/collector.rs

@@ -1441,7 +1441,7 @@ fn collect_used_items<'tcx>(
     // and abort compilation if any of them errors.
     MirUsedCollector {
         tcx,
-        body: body,
+        body,
         output,
         instance,
         move_size_spans: vec![],