mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustc: use LocalDefId instead of DefIndex in hir::lowering.

Browse Source
This commit is contained in:
Eduard-Mihai Burtescu 2019-11-03 21:29:40 +02:00
parent 42b2adfab0
commit 6130b9959c
2 changed files with 72 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/librustc_ast_lowering/item.rs
View File

@ -11,7 +11,7 @@ use rustc_ast::visit::{self, AssocCtxt, Visitor};
use rustc_errors::struct_span_err;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::DefId;
use rustc_hir::def_id::LocalDefId;
use rustc_span::source_map::{respan, DesugaringKind};
use rustc_span::symbol::{kw, sym};
use rustc_span::Span;
@ -269,7 +269,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
hir::ItemKind::Const(ty, body_id)
}
ItemKind::Fn(_, FnSig { ref decl, header }, ref generics, ref body) => {
let fn_def_id = self.resolver.definitions().local_def_id(id);
let fn_def_id = self.resolver.definitions().local_def_id(id).expect_local();
self.with_new_scopes(|this| {
this.current_item = Some(ident.span);
@ -287,7 +287,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
AnonymousLifetimeMode::PassThrough,
|this, idty| {
let ret_id = asyncness.opt_return_id();
this.lower_fn_decl(&decl, Some((fn_def_id, idty)), true, ret_id)
this.lower_fn_decl(
&decl,
Some((fn_def_id.to_def_id(), idty)),
true,
ret_id,
)
},
);
let sig = hir::FnSig { decl, header: this.lower_fn_header(header) };
@ -351,7 +356,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
self_ty: ref ty,
items: ref impl_items,
} => {
let def_id = self.resolver.definitions().local_def_id(id);
let def_id = self.resolver.definitions().local_def_id(id).expect_local();
// Lower the "impl header" first. This ordering is important
// for in-band lifetimes! Consider `'a` here:
@ -648,7 +653,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem<'hir> {
let def_id = self.resolver.definitions().local_def_id(i.id);
let def_id = self.resolver.definitions().local_def_id(i.id).expect_local();
hir::ForeignItem {
hir_id: self.lower_node_id(i.id),
ident: i.ident,
@ -749,7 +754,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
fn lower_trait_item(&mut self, i: &AssocItem) -> hir::TraitItem<'hir> {
let trait_item_def_id = self.resolver.definitions().local_def_id(i.id);
let trait_item_def_id = self.resolver.definitions().local_def_id(i.id).expect_local();
let (generics, kind) = match i.kind {
AssocItemKind::Const(_, ref ty, ref default) => {
@ -814,7 +819,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
fn lower_impl_item(&mut self, i: &AssocItem) -> hir::ImplItem<'hir> {
let impl_item_def_id = self.resolver.definitions().local_def_id(i.id);
let impl_item_def_id = self.resolver.definitions().local_def_id(i.id).expect_local();
let (generics, kind) = match &i.kind {
AssocItemKind::Const(_, ty, expr) => {
@ -1211,7 +1216,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&mut self,
generics: &Generics,
sig: &FnSig,
fn_def_id: DefId,
fn_def_id: LocalDefId,
impl_trait_return_allow: bool,
is_async: Option<NodeId>,
) -> (hir::Generics<'hir>, hir::FnSig<'hir>) {
@ -1223,7 +1228,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
|this, idty| {
this.lower_fn_decl(
&sig.decl,
Some((fn_def_id, idty)),
Some((fn_def_id.to_def_id(), idty)),
impl_trait_return_allow,
is_async,
)

106
src/librustc_ast_lowering/lib.rs
View File

@ -53,7 +53,7 @@ use rustc_data_structures::sync::Lrc;
use rustc_errors::struct_span_err;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Namespace, PartialRes, PerNS, Res};
use rustc_hir::def_id::{DefId, DefIdMap, DefIndex, CRATE_DEF_INDEX};
use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX};
use rustc_hir::intravisit;
use rustc_hir::{ConstArg, GenericArg, ParamName};
use rustc_index::vec::IndexVec;
@ -160,7 +160,7 @@ struct LoweringContext<'a, 'hir: 'a> {
type_def_lifetime_params: DefIdMap<usize>,
current_hir_id_owner: Vec<(DefIndex, u32)>,
current_hir_id_owner: Vec<(LocalDefId, u32)>,
item_local_id_counters: NodeMap<u32>,
node_id_to_hir_id: IndexVec<NodeId, hir::HirId>,
@ -290,7 +290,7 @@ pub fn lower_crate<'a, 'hir>(
anonymous_lifetime_mode: AnonymousLifetimeMode::PassThrough,
type_def_lifetime_params: Default::default(),
current_module: hir::CRATE_HIR_ID,
current_hir_id_owner: vec![(CRATE_DEF_INDEX, 0)],
current_hir_id_owner: vec![(LocalDefId { local_def_index: CRATE_DEF_INDEX }, 0)],
item_local_id_counters: Default::default(),
node_id_to_hir_id: IndexVec::new(),
generator_kind: None,
@ -407,12 +407,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
impl MiscCollector<'_, '_, '_> {
fn allocate_use_tree_hir_id_counters(&mut self, tree: &UseTree, owner: DefIndex) {
fn allocate_use_tree_hir_id_counters(&mut self, tree: &UseTree, owner: LocalDefId) {
match tree.kind {
UseTreeKind::Simple(_, id1, id2) => {
for &id in &[id1, id2] {
self.lctx.resolver.definitions().create_def_with_parent(
owner,
owner.local_def_index,
id,
DefPathData::Misc,
ExpnId::root(),
@ -425,7 +425,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
UseTreeKind::Nested(ref trees) => {
for &(ref use_tree, id) in trees {
let hir_id = self.lctx.allocate_hir_id_counter(id);
self.allocate_use_tree_hir_id_counters(use_tree, hir_id.owner);
self.allocate_use_tree_hir_id_counters(
use_tree,
hir_id.owner_local_def_id(),
);
}
}
}
@ -463,7 +466,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
| ItemKind::Enum(_, ref generics)
| ItemKind::TyAlias(_, ref generics, ..)
| ItemKind::Trait(_, _, ref generics, ..) => {
let def_id = self.lctx.resolver.definitions().local_def_id(item.id);
let def_id =
self.lctx.resolver.definitions().local_def_id(item.id).expect_local();
let count = generics
.params
.iter()
@ -472,10 +476,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
_ => false,
})
.count();
self.lctx.type_def_lifetime_params.insert(def_id, count);
self.lctx.type_def_lifetime_params.insert(def_id.to_def_id(), count);
}
ItemKind::Use(ref use_tree) => {
self.allocate_use_tree_hir_id_counters(use_tree, hir_id.owner);
self.allocate_use_tree_hir_id_counters(
use_tree,
hir_id.owner_local_def_id(),
);
}
_ => {}
}
@ -598,12 +605,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
.item_local_id_counters
.insert(owner, HIR_ID_COUNTER_LOCKED)
.unwrap_or_else(|| panic!("no `item_local_id_counters` entry for {:?}", owner));
let def_index = self.resolver.definitions().opt_def_index(owner).unwrap();
self.current_hir_id_owner.push((def_index, counter));
let def_id = self.resolver.definitions().local_def_id(owner).expect_local();
self.current_hir_id_owner.push((def_id, counter));
let ret = f(self);
let (new_def_index, new_counter) = self.current_hir_id_owner.pop().unwrap();
let (new_def_id, new_counter) = self.current_hir_id_owner.pop().unwrap();
debug_assert!(def_index == new_def_index);
debug_assert!(def_id == new_def_id);
debug_assert!(new_counter >= counter);
let prev = self.item_local_id_counters.insert(owner, new_counter).unwrap();
@ -619,11 +626,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
/// properly. Calling the method twice with the same `NodeId` is fine though.
fn lower_node_id(&mut self, ast_node_id: NodeId) -> hir::HirId {
self.lower_node_id_generic(ast_node_id, |this| {
let &mut (def_index, ref mut local_id_counter) =
let &mut (def_id, ref mut local_id_counter) =
this.current_hir_id_owner.last_mut().unwrap();
let local_id = *local_id_counter;
*local_id_counter += 1;
hir::HirId { owner: def_index, local_id: hir::ItemLocalId::from_u32(local_id) }
hir::HirId {
owner: def_id.local_def_index,
local_id: hir::ItemLocalId::from_u32(local_id),
}
})
}
@ -724,7 +734,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
/// parameter while `f` is running (and restored afterwards).
fn collect_in_band_defs<T>(
&mut self,
parent_id: DefId,
parent_def_id: LocalDefId,
anonymous_lifetime_mode: AnonymousLifetimeMode,
f: impl FnOnce(&mut Self) -> (Vec<hir::GenericParam<'hir>>, T),
) -> (Vec<hir::GenericParam<'hir>>, T) {
@ -744,7 +754,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let params = lifetimes_to_define
.into_iter()
.map(|(span, hir_name)| self.lifetime_to_generic_param(span, hir_name, parent_id.index))
.map(|(span, hir_name)| self.lifetime_to_generic_param(span, hir_name, parent_def_id))
.chain(in_band_ty_params.into_iter())
.collect();
@ -756,7 +766,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
span: Span,
hir_name: ParamName,
parent_index: DefIndex,
parent_def_id: LocalDefId,
) -> hir::GenericParam<'hir> {
let node_id = self.resolver.next_node_id();
@ -771,7 +781,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// Add a definition for the in-band lifetime def.
self.resolver.definitions().create_def_with_parent(
parent_index,
parent_def_id.local_def_index,
node_id,
DefPathData::LifetimeNs(str_name),
ExpnId::root(),
@ -860,13 +870,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn add_in_band_defs<T>(
&mut self,
generics: &Generics,
parent_id: DefId,
parent_def_id: LocalDefId,
anonymous_lifetime_mode: AnonymousLifetimeMode,
f: impl FnOnce(&mut Self, &mut Vec<hir::GenericParam<'hir>>) -> T,
) -> (hir::Generics<'hir>, T) {
let (in_band_defs, (mut lowered_generics, res)) =
self.with_in_scope_lifetime_defs(&generics.params, |this| {
this.collect_in_band_defs(parent_id, anonymous_lifetime_mode, |this| {
this.collect_in_band_defs(parent_def_id, anonymous_lifetime_mode, |this| {
let mut params = Vec::new();
// Note: it is necessary to lower generics *before* calling `f`.
// When lowering `async fn`, there's a final step when lowering
@ -1048,9 +1058,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// constructing the HIR for `impl bounds...` and then lowering that.
let impl_trait_node_id = self.resolver.next_node_id();
let parent_def_index = self.current_hir_id_owner.last().unwrap().0;
let parent_def_id = self.current_hir_id_owner.last().unwrap().0;
self.resolver.definitions().create_def_with_parent(
parent_def_index,
parent_def_id.local_def_index,
impl_trait_node_id,
DefPathData::ImplTrait,
ExpnId::root(),
@ -1111,12 +1121,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// Construct a AnonConst where the expr is the "ty"'s path.
let parent_def_index = self.current_hir_id_owner.last().unwrap().0;
let parent_def_id = self.current_hir_id_owner.last().unwrap().0;
let node_id = self.resolver.next_node_id();
// Add a definition for the in-band const def.
self.resolver.definitions().create_def_with_parent(
parent_def_index,
parent_def_id.local_def_index,
node_id,
DefPathData::AnonConst,
ExpnId::root(),
@ -1278,8 +1288,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
ImplTraitContext::Universal(in_band_ty_params) => {
// Add a definition for the in-band `Param`.
let def_index =
self.resolver.definitions().opt_def_index(def_node_id).unwrap();
let def_id =
self.resolver.definitions().local_def_id(def_node_id).expect_local();
let hir_bounds = self.lower_param_bounds(
bounds,
@ -1304,7 +1314,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
None,
self.arena.alloc(hir::Path {
span,
res: Res::Def(DefKind::TyParam, DefId::local(def_index)),
res: Res::Def(DefKind::TyParam, def_id.to_def_id()),
segments: arena_vec![self; hir::PathSegment::from_ident(ident)],
}),
))
@ -1367,18 +1377,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// frequently opened issues show.
let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::OpaqueTy, span, None);
let opaque_ty_def_index =
self.resolver.definitions().opt_def_index(opaque_ty_node_id).unwrap();
let opaque_ty_def_id =
self.resolver.definitions().local_def_id(opaque_ty_node_id).expect_local();
self.allocate_hir_id_counter(opaque_ty_node_id);
let hir_bounds = self.with_hir_id_owner(opaque_ty_node_id, lower_bounds);
let (lifetimes, lifetime_defs) = self.lifetimes_from_impl_trait_bounds(
opaque_ty_node_id,
opaque_ty_def_index,
&hir_bounds,
);
let (lifetimes, lifetime_defs) =
self.lifetimes_from_impl_trait_bounds(opaque_ty_node_id, opaque_ty_def_id, &hir_bounds);
debug!("lower_opaque_impl_trait: lifetimes={:#?}", lifetimes,);
@ -1396,7 +1403,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
origin,
};
trace!("lower_opaque_impl_trait: {:#?}", opaque_ty_def_index);
trace!("lower_opaque_impl_trait: {:#?}", opaque_ty_def_id);
let opaque_ty_id =
lctx.generate_opaque_type(opaque_ty_node_id, opaque_ty_item, span, opaque_ty_span);
@ -1437,14 +1444,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lifetimes_from_impl_trait_bounds(
&mut self,
opaque_ty_id: NodeId,
parent_index: DefIndex,
parent_def_id: LocalDefId,
bounds: hir::GenericBounds<'hir>,
) -> (&'hir [hir::GenericArg<'hir>], &'hir [hir::GenericParam<'hir>]) {
debug!(
"lifetimes_from_impl_trait_bounds(opaque_ty_id={:?}, \
parent_index={:?}, \
parent_def_id={:?}, \
bounds={:#?})",
opaque_ty_id, parent_index, bounds,
opaque_ty_id, parent_def_id, bounds,
);
// This visitor walks over `impl Trait` bounds and creates defs for all lifetimes that
@ -1452,7 +1459,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// E.g., `'a`, `'b`, but not `'c` in `impl for<'c> SomeTrait<'a, 'b, 'c>`.
struct ImplTraitLifetimeCollector<'r, 'a, 'hir> {
context: &'r mut LoweringContext<'a, 'hir>,
parent: DefIndex,
parent: LocalDefId,
opaque_ty_id: NodeId,
collect_elided_lifetimes: bool,
currently_bound_lifetimes: Vec<hir::LifetimeName>,
@ -1557,7 +1564,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let hir_id =
self.context.lower_node_id_with_owner(def_node_id, self.opaque_ty_id);
self.context.resolver.definitions().create_def_with_parent(
self.parent,
self.parent.local_def_index,
def_node_id,
DefPathData::LifetimeNs(name.ident().name),
ExpnId::root(),
@ -1590,7 +1597,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let mut lifetime_collector = ImplTraitLifetimeCollector {
context: self,
parent: parent_index,
parent: parent_def_id,
opaque_ty_id,
collect_elided_lifetimes: true,
currently_bound_lifetimes: Vec::new(),
@ -1620,12 +1627,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
visitor.visit_ty(ty);
}
}
let parent_def_id = DefId::local(self.current_hir_id_owner.last().unwrap().0);
let parent_def_id = self.current_hir_id_owner.last().unwrap().0;
let ty = l.ty.as_ref().map(|t| {
self.lower_ty(
t,
if self.sess.features_untracked().impl_trait_in_bindings {
ImplTraitContext::OpaqueTy(Some(parent_def_id), hir::OpaqueTyOrigin::Misc)
ImplTraitContext::OpaqueTy(
Some(parent_def_id.to_def_id()),
hir::OpaqueTyOrigin::Misc,
)
} else {
ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
},
@ -1797,8 +1807,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::Async, span, None);
let opaque_ty_def_index =
self.resolver.definitions().opt_def_index(opaque_ty_node_id).unwrap();
let opaque_ty_def_id =
self.resolver.definitions().local_def_id(opaque_ty_node_id).expect_local();
self.allocate_hir_id_counter(opaque_ty_node_id);
@ -1886,7 +1896,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let generic_params =
this.arena.alloc_from_iter(lifetime_params.iter().map(|(span, hir_name)| {
this.lifetime_to_generic_param(*span, *hir_name, opaque_ty_def_index)
this.lifetime_to_generic_param(*span, *hir_name, opaque_ty_def_id)
}));
let opaque_ty_item = hir::OpaqueTy {
@ -1900,7 +1910,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
origin: hir::OpaqueTyOrigin::AsyncFn,
};
trace!("exist ty from async fn def index: {:#?}", opaque_ty_def_index);
trace!("exist ty from async fn def id: {:#?}", opaque_ty_def_id);
let opaque_ty_id =
this.generate_opaque_type(opaque_ty_node_id, opaque_ty_item, span, opaque_ty_span);