impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> {
fn visit_item(&mut self, item: &'a Item) {
let hir_id = self.lctx.with_hir_id_owner(item.id, |lctx| {
- lctx.without_in_scope_lifetime_defs(|lctx| {
- let hir_item = lctx.lower_item(item);
- lctx.insert_item(hir_item)
- })
+ let node = lctx.without_in_scope_lifetime_defs(|lctx| lctx.lower_item(item));
+ hir::OwnerNode::Item(node)
});
self.lctx.with_parent_item_lifetime_defs(hir_id, |this| {
let this = &mut ItemLowerer { lctx: this };
match item.kind {
- ItemKind::Mod(..) => {
- let def_id = this.lctx.lower_node_id(item.id).expect_owner();
- let old_current_module = mem::replace(&mut this.lctx.current_module, def_id);
- visit::walk_item(this, item);
- this.lctx.current_module = old_current_module;
- }
ItemKind::Impl(box ImplKind { ref of_trait, .. }) => {
this.with_trait_impl_ref(of_trait, |this| visit::walk_item(this, item));
}
fn visit_assoc_item(&mut self, item: &'a AssocItem, ctxt: AssocCtxt) {
self.lctx.with_hir_id_owner(item.id, |lctx| match ctxt {
- AssocCtxt::Trait => {
- let hir_item = lctx.lower_trait_item(item);
- lctx.insert_trait_item(hir_item);
- }
- AssocCtxt::Impl => {
- let hir_item = lctx.lower_impl_item(item);
- lctx.insert_impl_item(hir_item);
- }
+ AssocCtxt::Trait => hir::OwnerNode::TraitItem(lctx.lower_trait_item(item)),
+ AssocCtxt::Impl => hir::OwnerNode::ImplItem(lctx.lower_impl_item(item)),
});
visit::walk_assoc_item(self, item, ctxt);
}
fn visit_foreign_item(&mut self, item: &'a ForeignItem) {
- self.lctx.allocate_hir_id_counter(item.id);
self.lctx.with_hir_id_owner(item.id, |lctx| {
- let hir_item = lctx.lower_foreign_item(item);
- lctx.insert_foreign_item(hir_item);
+ hir::OwnerNode::ForeignItem(lctx.lower_foreign_item(item))
});
visit::walk_foreign_item(self, item);
// only used when lowering a child item of a trait or impl.
fn with_parent_item_lifetime_defs<T>(
&mut self,
- parent_hir_id: hir::ItemId,
+ parent_hir_id: LocalDefId,
f: impl FnOnce(&mut Self) -> T,
) -> T {
let old_len = self.in_scope_lifetimes.len();
- let parent_generics = match self.owners[parent_hir_id.def_id].unwrap().expect_item().kind {
+ let parent_generics = match self.owners[parent_hir_id].unwrap().expect_item().kind {
hir::ItemKind::Impl(hir::Impl { ref generics, .. })
| hir::ItemKind::Trait(_, _, ref generics, ..) => generics.params,
_ => &[],
pub(super) fn lower_mod(&mut self, items: &[P<Item>], inner: Span) -> hir::Mod<'hir> {
hir::Mod {
inner: self.lower_span(inner),
- item_ids: self.arena.alloc_from_iter(items.iter().flat_map(|x| self.lower_item_id(x))),
+ item_ids: self.arena.alloc_from_iter(items.iter().flat_map(|x| self.lower_item_ref(x))),
}
}
- pub(super) fn lower_item_id(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
- let node_ids = match i.kind {
- ItemKind::Use(ref use_tree) => {
- let mut vec = smallvec![i.id];
- self.lower_item_id_use_tree(use_tree, i.id, &mut vec);
- vec
- }
- ItemKind::Fn(..) | ItemKind::Impl(box ImplKind { of_trait: None, .. }) => {
- smallvec![i.id]
- }
- _ => smallvec![i.id],
- };
-
+ pub(super) fn lower_item_ref(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
+ let mut node_ids = smallvec![hir::ItemId { def_id: self.resolver.local_def_id(i.id) }];
+ if let ItemKind::Use(ref use_tree) = &i.kind {
+ self.lower_item_id_use_tree(use_tree, i.id, &mut node_ids);
+ }
node_ids
- .into_iter()
- .map(|node_id| hir::ItemId {
- def_id: self.allocate_hir_id_counter(node_id).expect_owner(),
- })
- .collect()
}
fn lower_item_id_use_tree(
&mut self,
tree: &UseTree,
base_id: NodeId,
- vec: &mut SmallVec<[NodeId; 1]>,
+ vec: &mut SmallVec<[hir::ItemId; 1]>,
) {
match tree.kind {
UseTreeKind::Nested(ref nested_vec) => {
for &(ref nested, id) in nested_vec {
- vec.push(id);
+ vec.push(hir::ItemId { def_id: self.resolver.local_def_id(id) });
self.lower_item_id_use_tree(nested, id, vec);
}
}
for (_, &id) in
iter::zip(self.expect_full_res_from_use(base_id).skip(1), &[id1, id2])
{
- vec.push(id);
+ vec.push(hir::ItemId { def_id: self.resolver.local_def_id(id) });
}
}
}
}
- pub fn lower_item(&mut self, i: &Item) -> hir::Item<'hir> {
+ fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
let mut ident = i.ident;
- let mut vis = self.lower_visibility(&i.vis, None);
+ let mut vis = self.lower_visibility(&i.vis);
let hir_id = self.lower_node_id(i.id);
let attrs = self.lower_attrs(hir_id, &i.attrs);
let kind = self.lower_item_kind(i.span, i.id, hir_id, &mut ident, attrs, &mut vis, &i.kind);
- hir::Item {
+ let item = hir::Item {
def_id: hir_id.expect_owner(),
ident: self.lower_ident(ident),
kind,
vis,
span: self.lower_span(i.span),
- }
+ };
+ self.arena.alloc(item)
}
fn lower_item_kind(
}
}
- let mut resolutions = self.expect_full_res_from_use(id);
+ let mut resolutions = self.expect_full_res_from_use(id).fuse();
// We want to return *something* from this function, so hold onto the first item
// for later.
let ret_res = self.lower_res(resolutions.next().unwrap_or(Res::Err));
// won't be dealing with macros in the rest of the compiler.
// Essentially a single `use` which imports two names is desugared into
// two imports.
- for (res, &new_node_id) in iter::zip(resolutions, &[id1, id2]) {
+ for new_node_id in [id1, id2] {
+ let new_id = self.resolver.local_def_id(new_node_id);
+ let res = if let Some(res) = resolutions.next() {
+ res
+ } else {
+ // Associate an HirId to both ids even if there is no resolution.
+ let _old = self
+ .node_id_to_hir_id
+ .insert(new_node_id, hir::HirId::make_owner(new_id));
+ debug_assert!(_old.is_none());
+ continue;
+ };
let ident = *ident;
let mut path = path.clone();
for seg in &mut path.segments {
let span = path.span;
self.with_hir_id_owner(new_node_id, |this| {
- let new_id = this.lower_node_id(new_node_id);
let res = this.lower_res(res);
- let path = this.lower_path_extra(res, &path, ParamMode::Explicit, None);
+ let path = this.lower_path_extra(res, &path, ParamMode::Explicit);
let kind = hir::ItemKind::Use(path, hir::UseKind::Single);
let vis = this.rebuild_vis(&vis);
if let Some(attrs) = attrs {
- this.attrs.insert(new_id, attrs);
+ this.attrs.insert(hir::HirId::make_owner(new_id), attrs);
}
- this.insert_item(hir::Item {
- def_id: new_id.expect_owner(),
+ let item = hir::Item {
+ def_id: new_id,
ident: this.lower_ident(ident),
kind,
vis,
span: this.lower_span(span),
- });
+ };
+ hir::OwnerNode::Item(this.arena.alloc(item))
});
}
- let path = self.lower_path_extra(ret_res, &path, ParamMode::Explicit, None);
+ let path = self.lower_path_extra(ret_res, &path, ParamMode::Explicit);
hir::ItemKind::Use(path, hir::UseKind::Single)
}
UseTreeKind::Glob => {
// Add all the nested `PathListItem`s to the HIR.
for &(ref use_tree, id) in trees {
- let new_hir_id = self.lower_node_id(id);
+ let new_hir_id = self.resolver.local_def_id(id);
let mut prefix = prefix.clone();
let kind =
this.lower_use_tree(use_tree, &prefix, id, &mut vis, &mut ident, attrs);
if let Some(attrs) = attrs {
- this.attrs.insert(new_hir_id, attrs);
+ this.attrs.insert(hir::HirId::make_owner(new_hir_id), attrs);
}
- this.insert_item(hir::Item {
- def_id: new_hir_id.expect_owner(),
+ let item = hir::Item {
+ def_id: new_hir_id,
ident: this.lower_ident(ident),
kind,
vis,
span: this.lower_span(use_tree.span),
- });
+ };
+ hir::OwnerNode::Item(this.arena.alloc(item))
});
}
let res = self.expect_full_res_from_use(id).next().unwrap_or(Res::Err);
let res = self.lower_res(res);
- let path = self.lower_path_extra(res, &prefix, ParamMode::Explicit, None);
+ let path = self.lower_path_extra(res, &prefix, ParamMode::Explicit);
hir::ItemKind::Use(path, hir::UseKind::ListStem)
}
}
respan(self.lower_span(vis.span), vis_kind)
}
- fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem<'hir> {
+ fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
let hir_id = self.lower_node_id(i.id);
let def_id = hir_id.expect_owner();
self.lower_attrs(hir_id, &i.attrs);
- hir::ForeignItem {
+ let item = hir::ForeignItem {
def_id,
ident: self.lower_ident(i.ident),
kind: match i.kind {
ForeignItemKind::TyAlias(..) => hir::ForeignItemKind::Type,
ForeignItemKind::MacCall(_) => panic!("macro shouldn't exist here"),
},
- vis: self.lower_visibility(&i.vis, None),
+ vis: self.lower_visibility(&i.vis),
span: self.lower_span(i.span),
- }
+ };
+ self.arena.alloc(item)
}
- fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemRef<'hir> {
+ fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemRef {
hir::ForeignItemRef {
- id: hir::ForeignItemId { def_id: self.lower_node_id(i.id).expect_owner() },
+ id: hir::ForeignItemId { def_id: self.resolver.local_def_id(i.id) },
ident: self.lower_ident(i.ident),
span: self.lower_span(i.span),
- vis: self.lower_visibility(&i.vis, Some(i.id)),
}
}
}
}
- pub(super) fn lower_field_def(
- &mut self,
- (index, f): (usize, &FieldDef),
- ) -> hir::FieldDef<'hir> {
+ fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> hir::FieldDef<'hir> {
let ty = if let TyKind::Path(ref qself, ref path) = f.ty.kind {
let t = self.lower_path_ty(
&f.ty,
// FIXME(jseyfried): positional field hygiene.
None => Ident::new(sym::integer(index), self.lower_span(f.span)),
},
- vis: self.lower_visibility(&f.vis, None),
+ vis: self.lower_visibility(&f.vis),
ty,
}
}
- fn lower_trait_item(&mut self, i: &AssocItem) -> hir::TraitItem<'hir> {
+ fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
let hir_id = self.lower_node_id(i.id);
let trait_item_def_id = hir_id.expect_owner();
};
self.lower_attrs(hir_id, &i.attrs);
- hir::TraitItem {
+ let item = hir::TraitItem {
def_id: trait_item_def_id,
ident: self.lower_ident(i.ident),
generics,
kind,
span: self.lower_span(i.span),
- }
+ };
+ self.arena.alloc(item)
}
fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemRef {
}
AssocItemKind::MacCall(..) => unimplemented!(),
};
- let id = hir::TraitItemId { def_id: self.lower_node_id(i.id).expect_owner() };
+ let id = hir::TraitItemId { def_id: self.resolver.local_def_id(i.id) };
let defaultness = hir::Defaultness::Default { has_value: has_default };
hir::TraitItemRef {
id,
self.expr(span, hir::ExprKind::Err, AttrVec::new())
}
- fn lower_impl_item(&mut self, i: &AssocItem) -> hir::ImplItem<'hir> {
+ fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
let impl_item_def_id = self.resolver.local_def_id(i.id);
let (generics, kind) = match &i.kind {
let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
let hir_id = self.lower_node_id(i.id);
self.lower_attrs(hir_id, &i.attrs);
- hir::ImplItem {
+ let item = hir::ImplItem {
def_id: hir_id.expect_owner(),
ident: self.lower_ident(i.ident),
generics,
- vis: self.lower_visibility(&i.vis, None),
+ vis: self.lower_visibility(&i.vis),
defaultness,
kind,
span: self.lower_span(i.span),
- }
+ };
+ self.arena.alloc(item)
}
- fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef<'hir> {
+ fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
// Since `default impl` is not yet implemented, this is always true in impls.
let has_value = true;
let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
hir::ImplItemRef {
- id: hir::ImplItemId { def_id: self.lower_node_id(i.id).expect_owner() },
+ id: hir::ImplItemId { def_id: self.resolver.local_def_id(i.id) },
ident: self.lower_ident(i.ident),
span: self.lower_span(i.span),
- vis: self.lower_visibility(&i.vis, Some(i.id)),
defaultness,
kind: match &i.kind {
AssocItemKind::Const(..) => hir::AssocItemKind::Const,
/// lowered. This can happen during `lower_impl_item_ref()` where we need to
/// lower a `Visibility` value although we haven't lowered the owning
/// `ImplItem` in question yet.
- fn lower_visibility(
- &mut self,
- v: &Visibility,
- explicit_owner: Option<NodeId>,
- ) -> hir::Visibility<'hir> {
+ fn lower_visibility(&mut self, v: &Visibility) -> hir::Visibility<'hir> {
let node = match v.kind {
VisibilityKind::Public => hir::VisibilityKind::Public,
VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
VisibilityKind::Restricted { ref path, id } => {
debug!("lower_visibility: restricted path id = {:?}", id);
- let lowered_id = if let Some(owner) = explicit_owner {
- self.lower_node_id_with_owner(id, owner)
- } else {
- self.lower_node_id(id)
- };
- let res = self.expect_full_res(id);
- let res = self.lower_res(res);
+ let lowered_id = self.lower_node_id(id);
hir::VisibilityKind::Restricted {
- path: self.lower_path_extra(res, path, ParamMode::Explicit, explicit_owner),
+ path: self.lower_path(id, path, ParamMode::Explicit),
hir_id: lowered_id,
}
}