Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit e4c5f03

Browse files
bvanjoibvanjoi
committedDec 6, 2023
feed def_span in resolver
1 parent 1dd4db5 commit e4c5f03

File tree

9 files changed

+147
-60
lines changed

9 files changed

+147
-60
lines changed
 

‎compiler/rustc_ast_lowering/src/lib.rs

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -778,12 +778,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
778778
/// Intercept all spans entering HIR.
779779
/// Mark a span as relative to the current owning item.
780780
fn lower_span(&self, span: Span) -> Span {
781-
if self.tcx.sess.opts.incremental.is_some() {
782-
span.with_parent(Some(self.current_hir_id_owner.def_id))
783-
} else {
784-
// Do not make spans relative when not using incremental compilation.
785-
span
786-
}
781+
rustc_middle::util::lower_span(self.tcx, span, self.current_hir_id_owner.def_id)
787782
}
788783

789784
fn lower_ident(&self, ident: Ident) -> Ident {

‎compiler/rustc_interface/src/queries.rs

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -170,11 +170,14 @@ impl<'tcx> Queries<'tcx> {
170170
&pre_configured_attrs,
171171
crate_name,
172172
)));
173+
let span = krate.spans.inner_span;
173174
feed.crate_for_resolver(tcx.arena.alloc(Steal::new((krate, pre_configured_attrs))));
174175
feed.output_filenames(Arc::new(outputs));
175176

176-
let feed = tcx.feed_local_def_id(CRATE_DEF_ID);
177+
let def_id = CRATE_DEF_ID;
178+
let feed = tcx.feed_local_def_id(def_id);
177179
feed.def_kind(DefKind::Mod);
180+
feed.def_span(rustc_middle::util::lower_span(tcx, span, def_id));
178181
});
179182
Ok(qcx)
180183
})

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

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,25 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol};
1919
use rustc_span::{ErrorGuaranteed, Span};
2020
use rustc_target::spec::abi::Abi;
2121

22+
pub fn until_within(outer: Span, end: Span) -> Span {
23+
if let Some(end) = end.find_ancestor_inside(outer) { outer.with_hi(end.hi()) } else { outer }
24+
}
25+
26+
pub fn named_span(item_span: Span, ident: Ident, generics_span: Option<Span>) -> Span {
27+
if ident.name != kw::Empty {
28+
let mut span = until_within(item_span, ident.span);
29+
if let Some(g) = generics_span
30+
&& !g.is_dummy()
31+
&& let Some(g_span) = g.find_ancestor_inside(item_span)
32+
{
33+
span = span.to(g_span);
34+
}
35+
span
36+
} else {
37+
item_span
38+
}
39+
}
40+
2241
#[inline]
2342
pub fn associated_body(node: Node<'_>) -> Option<(LocalDefId, BodyId)> {
2443
match node {
@@ -839,29 +858,10 @@ impl<'hir> Map<'hir> {
839858
}
840859

841860
pub fn opt_span(self, hir_id: HirId) -> Option<Span> {
842-
fn until_within(outer: Span, end: Span) -> Span {
843-
if let Some(end) = end.find_ancestor_inside(outer) {
844-
outer.with_hi(end.hi())
845-
} else {
846-
outer
847-
}
848-
}
849-
850-
fn named_span(item_span: Span, ident: Ident, generics: Option<&Generics<'_>>) -> Span {
851-
if ident.name != kw::Empty {
852-
let mut span = until_within(item_span, ident.span);
853-
if let Some(g) = generics
854-
&& !g.span.is_dummy()
855-
&& let Some(g_span) = g.span.find_ancestor_inside(item_span)
856-
{
857-
span = span.to(g_span);
858-
}
859-
span
860-
} else {
861-
item_span
862-
}
861+
if let Some(owner) = hir_id.as_owner() {
862+
let span = self.tcx.def_span(owner.def_id);
863+
return Some(span);
863864
}
864-
865865
let span = match self.find(hir_id)? {
866866
// Function-like.
867867
Node::Item(Item { kind: ItemKind::Fn(sig, ..), span: outer_span, .. })
@@ -926,10 +926,10 @@ impl<'hir> Map<'hir> {
926926
// SyntaxContext of the path.
927927
path.span.find_ancestor_in_same_ctxt(item.span).unwrap_or(item.span)
928928
}
929-
_ => named_span(item.span, item.ident, item.kind.generics()),
929+
_ => named_span(item.span, item.ident, item.kind.generics().map(|g| g.span)),
930930
},
931931
Node::Variant(variant) => named_span(variant.span, variant.ident, None),
932-
Node::ImplItem(item) => named_span(item.span, item.ident, Some(item.generics)),
932+
Node::ImplItem(item) => named_span(item.span, item.ident, Some(item.generics.span)),
933933
Node::ForeignItem(item) => match item.kind {
934934
ForeignItemKind::Fn(decl, _, _) => until_within(item.span, decl.output.span()),
935935
_ => named_span(item.span, item.ident, None),

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

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ use rustc_hir::def::DefKind;
1414
use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
1515
use rustc_hir::*;
1616
use rustc_query_system::ich::StableHashingContext;
17-
use rustc_span::{ErrorGuaranteed, ExpnId, DUMMY_SP};
17+
use rustc_span::{ErrorGuaranteed, ExpnId};
1818

1919
/// Top-level HIR node for current owner. This only contains the node for which
2020
/// `HirId::local_id == 0`, and excludes bodies.
@@ -175,10 +175,6 @@ pub fn provide(providers: &mut Providers) {
175175
providers.hir_attrs = |tcx, id| {
176176
tcx.hir_crate(()).owners[id.def_id].as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
177177
};
178-
providers.def_span = |tcx, def_id| {
179-
let hir_id = tcx.local_def_id_to_hir_id(def_id);
180-
tcx.hir().opt_span(hir_id).unwrap_or(DUMMY_SP)
181-
};
182178
providers.def_ident_span = |tcx, def_id| {
183179
let hir_id = tcx.local_def_id_to_hir_id(def_id);
184180
tcx.hir().opt_ident_span(hir_id)

‎compiler/rustc_middle/src/util/lower_span.rs

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
use rustc_hir::def_id::LocalDefId;
2+
use rustc_span::Span;
3+
4+
use crate::ty::TyCtxt;
5+
6+
pub fn lower_span(tcx: TyCtxt<'_>, span: Span, parent: LocalDefId) -> Span {
7+
if tcx.sess.opts.incremental.is_some() {
8+
span.with_parent(Some(parent))
9+
} else {
10+
// Do not make spans relative when not using incremental compilation.
11+
span
12+
}
13+
}

‎compiler/rustc_middle/src/util/mod.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,11 @@ pub mod bug;
22
pub mod call_kind;
33
pub mod common;
44
pub mod find_self_call;
5+
mod lower_span;
56

67
pub use call_kind::{call_kind, CallDesugaringKind, CallKind};
78
pub use find_self_call::find_self_call;
9+
pub use lower_span::lower_span;
810

911
#[derive(Default, Copy, Clone)]
1012
pub struct Providers {

‎compiler/rustc_monomorphize/src/collector.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1422,7 +1422,7 @@ fn collect_used_items<'tcx>(
14221422
// and abort compilation if any of them errors.
14231423
MirUsedCollector {
14241424
tcx,
1425-
body: body,
1425+
body,
14261426
output,
14271427
instance,
14281428
move_size_spans: vec![],

‎compiler/rustc_resolve/src/def_collector.rs

Lines changed: 99 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ use rustc_ast::*;
44
use rustc_expand::expand::AstFragment;
55
use rustc_hir::def::{CtorKind, CtorOf, DefKind};
66
use rustc_hir::def_id::LocalDefId;
7+
use rustc_middle::hir::map::{named_span, until_within};
78
use rustc_span::hygiene::LocalExpnId;
89
use rustc_span::symbol::{kw, sym, Symbol};
910
use rustc_span::Span;
@@ -31,18 +32,20 @@ impl<'a, 'b, 'tcx> DefCollector<'a, 'b, 'tcx> {
3132
node_id: NodeId,
3233
name: Symbol,
3334
def_kind: DefKind,
35+
def_span: Span,
3436
span: Span,
3537
) -> LocalDefId {
3638
let parent_def = self.parent_def;
3739
debug!(
38-
"create_def(node_id={:?}, def_kind={:?}, parent_def={:?})",
39-
node_id, def_kind, parent_def
40+
"create_def(node_id={:?}, def_kind={:?}, parent_def={:?}, def_span={:?})",
41+
node_id, def_kind, parent_def, def_span
4042
);
4143
self.resolver.create_def(
4244
parent_def,
4345
node_id,
4446
name,
4547
def_kind,
48+
def_span,
4649
self.expansion.to_expn_id(),
4750
span.with_parent(None),
4851
)
@@ -78,7 +81,7 @@ impl<'a, 'b, 'tcx> DefCollector<'a, 'b, 'tcx> {
7881
self.visit_macro_invoc(field.id);
7982
} else {
8083
let name = field.ident.map_or_else(|| sym::integer(index(self)), |ident| ident.name);
81-
let def = self.create_def(field.id, name, DefKind::Field, field.span);
84+
let def = self.create_def(field.id, name, DefKind::Field, field.span, field.span);
8285
self.with_parent(def, |this| visit::walk_field_def(this, field));
8386
}
8487
}
@@ -91,6 +94,33 @@ impl<'a, 'b, 'tcx> DefCollector<'a, 'b, 'tcx> {
9194
}
9295
}
9396

97+
fn def_span_for_item(i: &Item) -> Span {
98+
match &i.kind {
99+
ItemKind::ForeignMod(_) => i.span,
100+
ItemKind::GlobalAsm(_) => i.span,
101+
ItemKind::Fn(f) => f.sig.span.find_ancestor_in_same_ctxt(i.span).unwrap_or(i.span),
102+
ItemKind::Static(s) => until_within(i.span, s.ty.span),
103+
ItemKind::Const(c) => until_within(i.span, c.ty.span),
104+
ItemKind::Impl(im) => until_within(i.span, im.generics.where_clause.span),
105+
ItemKind::MacroDef(_) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
106+
ItemKind::Mod(_, _) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
107+
ItemKind::TyAlias(_) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
108+
ItemKind::TraitAlias(_, _) => {
109+
named_span(i.span, i.ident, i.kind.generics().map(|g| g.span))
110+
}
111+
ItemKind::ExternCrate(_) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
112+
ItemKind::Union(_, _) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
113+
ItemKind::Enum(..) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
114+
ItemKind::Struct(..) => named_span(i.span, i.ident, i.kind.generics().map(|g| g.span)),
115+
ItemKind::Trait(t) => {
116+
let end = if let Some(b) = t.bounds.last() { b.span() } else { t.generics.span };
117+
until_within(i.span, end)
118+
}
119+
ItemKind::Use(_) => unreachable!(),
120+
ItemKind::MacCall(_) => unreachable!(),
121+
}
122+
}
123+
94124
impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
95125
fn visit_item(&mut self, i: &'a Item) {
96126
debug!("visit_item: {:?}", i);
@@ -127,7 +157,7 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
127157
return visit::walk_item(self, i);
128158
}
129159
};
130-
let def_id = self.create_def(i.id, i.ident.name, def_kind, i.span);
160+
let def_id = self.create_def(i.id, i.ident.name, def_kind, def_span_for_item(i), i.span);
131161

132162
if let Some(macro_data) = opt_macro_data {
133163
self.resolver.macro_map.insert(def_id.to_def_id(), macro_data);
@@ -143,6 +173,7 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
143173
ctor_node_id,
144174
kw::Empty,
145175
DefKind::Ctor(CtorOf::Struct, ctor_kind),
176+
this.resolver.tcx.def_span(this.parent_def),
146177
i.span,
147178
);
148179
}
@@ -174,8 +205,13 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
174205
// then the closure_def will never be used, and we should avoid generating a
175206
// def-id for it.
176207
if let Some(body) = body {
177-
let closure_def =
178-
self.create_def(closure_id, kw::Empty, DefKind::Closure, span);
208+
let closure_def = self.create_def(
209+
closure_id,
210+
kw::Empty,
211+
DefKind::Closure,
212+
body.span.find_ancestor_in_same_ctxt(span).unwrap_or(span),
213+
span,
214+
);
179215
self.with_parent(closure_def, |this| this.visit_block(body));
180216
}
181217
return;
@@ -186,19 +222,27 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
186222
}
187223

188224
fn visit_use_tree(&mut self, use_tree: &'a UseTree, id: NodeId, _nested: bool) {
189-
self.create_def(id, kw::Empty, DefKind::Use, use_tree.span);
225+
let def_span =
226+
use_tree.prefix.span.find_ancestor_in_same_ctxt(use_tree.span).unwrap_or(use_tree.span);
227+
self.create_def(id, kw::Empty, DefKind::Use, def_span, use_tree.span);
190228
visit::walk_use_tree(self, use_tree, id);
191229
}
192230

193231
fn visit_foreign_item(&mut self, fi: &'a ForeignItem) {
194-
let def_kind = match fi.kind {
195-
ForeignItemKind::Static(_, mt, _) => DefKind::Static(mt),
196-
ForeignItemKind::Fn(_) => DefKind::Fn,
197-
ForeignItemKind::TyAlias(_) => DefKind::ForeignTy,
232+
let (def_kind, def_span) = match &fi.kind {
233+
ForeignItemKind::Static(ty, mt, _) => {
234+
(DefKind::Static(*mt), until_within(fi.span, ty.span))
235+
}
236+
ForeignItemKind::Fn(f) => {
237+
(DefKind::Fn, until_within(fi.span, f.sig.decl.output.span()))
238+
}
239+
ForeignItemKind::TyAlias(_) => {
240+
(DefKind::ForeignTy, named_span(fi.span, fi.ident, None))
241+
}
198242
ForeignItemKind::MacCall(_) => return self.visit_macro_invoc(fi.id),
199243
};
200244

201-
let def = self.create_def(fi.id, fi.ident.name, def_kind, fi.span);
245+
let def = self.create_def(fi.id, fi.ident.name, def_kind, def_span, fi.span);
202246

203247
self.with_parent(def, |this| visit::walk_foreign_item(this, fi));
204248
}
@@ -207,13 +251,20 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
207251
if v.is_placeholder {
208252
return self.visit_macro_invoc(v.id);
209253
}
210-
let def = self.create_def(v.id, v.ident.name, DefKind::Variant, v.span);
254+
let def = self.create_def(
255+
v.id,
256+
v.ident.name,
257+
DefKind::Variant,
258+
named_span(v.span, v.ident, None),
259+
v.span,
260+
);
211261
self.with_parent(def, |this| {
212262
if let Some((ctor_kind, ctor_node_id)) = CtorKind::from_ast(&v.data) {
213263
this.create_def(
214264
ctor_node_id,
215265
kw::Empty,
216266
DefKind::Ctor(CtorOf::Variant, ctor_kind),
267+
this.resolver.tcx.def_span(this.parent_def),
217268
v.span,
218269
);
219270
}
@@ -240,7 +291,7 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
240291
GenericParamKind::Type { .. } => DefKind::TyParam,
241292
GenericParamKind::Const { .. } => DefKind::ConstParam,
242293
};
243-
self.create_def(param.id, param.ident.name, def_kind, param.ident.span);
294+
self.create_def(param.id, param.ident.name, def_kind, param.span(), param.ident.span);
244295

245296
// impl-Trait can happen inside generic parameters, like
246297
// ```
@@ -254,14 +305,19 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
254305
}
255306

256307
fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) {
257-
let def_kind = match &i.kind {
258-
AssocItemKind::Fn(..) => DefKind::AssocFn,
259-
AssocItemKind::Const(..) => DefKind::AssocConst,
260-
AssocItemKind::Type(..) => DefKind::AssocTy,
308+
let (def_kind, def_span) = match &i.kind {
309+
AssocItemKind::Fn(f) => {
310+
(DefKind::AssocFn, f.sig.span.find_ancestor_in_same_ctxt(i.span).unwrap_or(i.span))
311+
}
312+
AssocItemKind::Const(c) => (DefKind::AssocConst, until_within(i.span, c.ty.span)),
313+
AssocItemKind::Type(ty) => (DefKind::AssocTy, {
314+
let end = if let Some(b) = ty.bounds.last() { b.span() } else { ty.generics.span };
315+
until_within(i.span, end)
316+
}),
261317
AssocItemKind::MacCall(..) => return self.visit_macro_invoc(i.id),
262318
};
263319

264-
let def = self.create_def(i.id, i.ident.name, def_kind, i.span);
320+
let def = self.create_def(i.id, i.ident.name, def_kind, def_span, i.span);
265321
self.with_parent(def, |this| visit::walk_assoc_item(this, i, ctxt));
266322
}
267323

@@ -273,7 +329,13 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
273329
}
274330

275331
fn visit_anon_const(&mut self, constant: &'a AnonConst) {
276-
let def = self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span);
332+
let def = self.create_def(
333+
constant.id,
334+
kw::Empty,
335+
DefKind::AnonConst,
336+
constant.value.span,
337+
constant.value.span,
338+
);
277339
self.with_parent(def, |this| visit::walk_anon_const(this, constant));
278340
}
279341

@@ -283,24 +345,38 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
283345
ExprKind::Closure(ref closure) => {
284346
// Async closures desugar to closures inside of closures, so
285347
// we must create two defs.
286-
let closure_def = self.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span);
348+
let def_span =
349+
closure.fn_decl_span.find_ancestor_inside(expr.span).unwrap_or(expr.span);
350+
let closure_def =
351+
self.create_def(expr.id, kw::Empty, DefKind::Closure, def_span, expr.span);
287352
match closure.coro_kind {
288353
Some(
289354
CoroutineKind::Async { closure_id, .. }
290355
| CoroutineKind::Gen { closure_id, .. },
291-
) => self.create_def(closure_id, kw::Empty, DefKind::Closure, expr.span),
356+
) => self.create_def(
357+
closure_id,
358+
kw::Empty,
359+
DefKind::Closure,
360+
closure
361+
.body
362+
.span
363+
.find_ancestor_in_same_ctxt(expr.span)
364+
.unwrap_or(expr.span),
365+
expr.span,
366+
),
292367
None => closure_def,
293368
}
294369
}
295370
ExprKind::Gen(_, _, _) => {
296-
self.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span)
371+
self.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span, expr.span)
297372
}
298373
ExprKind::ConstBlock(ref constant) => {
299374
let def = self.create_def(
300375
constant.id,
301376
kw::Empty,
302377
DefKind::InlineConst,
303378
constant.value.span,
379+
constant.value.span,
304380
);
305381
self.with_parent(def, |this| visit::walk_anon_const(this, constant));
306382
return;

‎compiler/rustc_resolve/src/lib.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1213,6 +1213,7 @@ impl<'tcx> Resolver<'_, 'tcx> {
12131213
node_id: ast::NodeId,
12141214
name: Symbol,
12151215
def_kind: DefKind,
1216+
def_span: Span,
12161217
expn_id: ExpnId,
12171218
span: Span,
12181219
) -> LocalDefId {
@@ -1230,6 +1231,7 @@ impl<'tcx> Resolver<'_, 'tcx> {
12301231

12311232
let feed = self.tcx.feed_local_def_id(def_id);
12321233
feed.def_kind(def_kind);
1234+
feed.def_span(rustc_middle::util::lower_span(self.tcx, def_span, def_id));
12331235

12341236
// Create the definition.
12351237
if expn_id != ExpnId::root() {

0 commit comments

Comments
 (0)
Please sign in to comment.