Use Arena inside hir::Item.

Author: cjgillot

src/librustc/arena.rs

@@ -125,7 +125,12 @@ macro_rules! arena_types {
             // HIR nodes arenas
             [few] hir_forest: rustc::hir::map::Forest<$tcx>,
             [] attribute: syntax::ast::Attribute,
+            [] global_asm: rustc::hir::GlobalAsm,
+            [] impl_item_ref: rustc::hir::ImplItemRef,
             [] macro_def: rustc::hir::MacroDef,
+            [] path: rustc::hir::Path,
+            [] trait_item_ref: rustc::hir::TraitItemRef,
+            [] ty: rustc::hir::Ty,
         ], $tcx);
     )
 }

src/librustc/hir/check_attr.rs

@@ -86,7 +86,7 @@ impl Display for Target {
 }
 
 impl Target {
-    pub(crate) fn from_item(item: &Item) -> Target {
+    pub(crate) fn from_item(item: &Item<'_>) -> Target {
         match item.kind {
             ItemKind::ExternCrate(..) => Target::ExternCrate,
             ItemKind::Use(..) => Target::Use,
@@ -161,7 +161,7 @@ impl CheckAttrVisitor<'tcx> {
         attrs: &HirVec<Attribute>,
         span: &Span,
         target: Target,
-        item: Option<&Item>,
+        item: Option<&Item<'_>>,
     ) {
         let mut is_valid = true;
         for attr in attrs {
@@ -335,7 +335,7 @@ impl CheckAttrVisitor<'tcx> {
         attrs: &HirVec<Attribute>,
         span: &Span,
         target: Target,
-        item: Option<&Item>,
+        item: Option<&Item<'_>>,
     ) {
         // Extract the names of all repr hints, e.g., [foo, bar, align] for:
         // ```
@@ -492,7 +492,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
         NestedVisitorMap::OnlyBodies(&self.tcx.hir())
     }
 
-    fn visit_item(&mut self, item: &'tcx Item) {
+    fn visit_item(&mut self, item: &'tcx Item<'tcx>) {
         let target = Target::from_item(item);
         self.check_attributes(item.hir_id, &item.attrs, &item.span, target, Some(item));
         intravisit::walk_item(self, item)
@@ -527,7 +527,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
     }
 }
 
-fn is_c_like_enum(item: &Item) -> bool {
+fn is_c_like_enum(item: &Item<'_>) -> bool {
     if let ItemKind::Enum(ref def, _) = item.kind {
         for variant in &def.variants {
             match variant.data {

src/librustc/hir/intravisit.rs

@@ -218,7 +218,7 @@ pub trait Visitor<'v>: Sized {
 
     /// Visits the top-level item and (optionally) nested items / impl items. See
     /// `visit_nested_item` for details.
-    fn visit_item(&mut self, i: &'v Item) {
+    fn visit_item(&mut self, i: &'v Item<'v>) {
         walk_item(self, i)
     }
 
@@ -462,7 +462,7 @@ pub fn walk_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Param) {
     walk_list!(visitor, visit_attribute, &param.attrs);
 }
 
-pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
+pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
     visitor.visit_vis(&item.vis);
     visitor.visit_ident(item.ident);
     match item.kind {
@@ -527,7 +527,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
             ref generics,
             ref opt_trait_reference,
             ref typ,
-            ref impl_item_refs
+            impl_item_refs
         ) => {
             visitor.visit_id(item.hir_id);
             visitor.visit_generics(generics);
@@ -542,7 +542,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
             visitor.visit_variant_data(struct_definition, item.ident.name, generics, item.hir_id,
                                        item.span);
         }
-        ItemKind::Trait(.., ref generics, ref bounds, ref trait_item_refs) => {
+        ItemKind::Trait(.., ref generics, ref bounds, trait_item_refs) => {
             visitor.visit_id(item.hir_id);
             visitor.visit_generics(generics);
             walk_list!(visitor, visit_param_bound, bounds);

src/librustc/hir/itemlikevisit.rs

@@ -45,7 +45,7 @@ use super::intravisit::Visitor;
 /// existing `fn visit_nested` methods to see where changes are
 /// needed.
 pub trait ItemLikeVisitor<'hir> {
-    fn visit_item(&mut self, item: &'hir Item);
+    fn visit_item(&mut self, item: &'hir Item<'hir>);
     fn visit_trait_item(&mut self, trait_item: &'hir TraitItem);
     fn visit_impl_item(&mut self, impl_item: &'hir ImplItem);
 }
@@ -65,7 +65,7 @@ impl<'v, 'hir, V> DeepVisitor<'v, V>
 impl<'v, 'hir, V> ItemLikeVisitor<'hir> for DeepVisitor<'v, V>
     where V: Visitor<'hir>
 {
-    fn visit_item(&mut self, item: &'hir Item) {
+    fn visit_item(&mut self, item: &'hir Item<'hir>) {
         self.visitor.visit_item(item);
     }
 
@@ -80,7 +80,7 @@ impl<'v, 'hir, V> ItemLikeVisitor<'hir> for DeepVisitor<'v, V>
 
 /// A parallel variant of `ItemLikeVisitor`.
 pub trait ParItemLikeVisitor<'hir> {
-    fn visit_item(&self, item: &'hir Item);
+    fn visit_item(&self, item: &'hir Item<'hir>);
     fn visit_trait_item(&self, trait_item: &'hir TraitItem);
     fn visit_impl_item(&self, impl_item: &'hir ImplItem);
 }
@@ -95,7 +95,7 @@ pub struct ParDeepVisitor<V>(pub V);
 impl<'hir, V> ParItemLikeVisitor<'hir> for ParDeepVisitor<V>
     where V: IntoVisitor<'hir>
 {
-    fn visit_item(&self, item: &'hir Item) {
+    fn visit_item(&self, item: &'hir Item<'hir>) {
         self.0.into_visitor().visit_item(item);
     }
 

src/librustc/hir/lowering.rs

@@ -95,7 +95,7 @@ pub struct LoweringContext<'a, 'hir: 'a> {
     arena: &'hir Arena<'hir>,
 
     /// The items being lowered are collected here.
-    items: BTreeMap<hir::HirId, hir::Item>,
+    items: BTreeMap<hir::HirId, hir::Item<'hir>>,
 
     trait_items: BTreeMap<hir::TraitItemId, hir::TraitItem>,
     impl_items: BTreeMap<hir::ImplItemId, hir::ImplItem>,
@@ -566,7 +566,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
-    fn insert_item(&mut self, item: hir::Item) {
+    fn insert_item(&mut self, item: hir::Item<'hir>) {
         let id = item.hir_id;
         // FIXME: Use `debug_asset-rt`.
         assert_eq!(id.local_id, hir::ItemLocalId::from_u32(0));
@@ -873,7 +873,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     // for them.
     fn with_in_scope_lifetime_defs<T, F>(&mut self, params: &[GenericParam], f: F) -> T
     where
-        F: FnOnce(&mut LoweringContext<'_, '_>) -> T,
+        F: FnOnce(&mut LoweringContext<'_, 'hir>) -> T,
     {
         let old_len = self.in_scope_lifetimes.len();
         let lt_def_names = params.iter().filter_map(|param| match param.kind {

src/librustc/hir/lowering/item.rs

@@ -107,7 +107,7 @@ impl<'a, 'lowering, 'hir> Visitor<'a> for ItemLowerer<'a, 'lowering, 'hir> {
     }
 }
 
-impl LoweringContext<'_, '_> {
+impl LoweringContext<'_, 'hir> {
     // Same as the method above, but accepts `hir::GenericParam`s
     // instead of `ast::GenericParam`s.
     // This should only be used with generics that have already had their
@@ -225,7 +225,7 @@ impl LoweringContext<'_, '_> {
         }
     }
 
-    pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item> {
+    pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item<'hir>> {
         let mut ident = i.ident;
         let mut vis = self.lower_visibility(&i.vis, None);
         let attrs = self.lower_attrs(&i.attrs);
@@ -269,7 +269,7 @@ impl LoweringContext<'_, '_> {
         attrs: &hir::HirVec<Attribute>,
         vis: &mut hir::Visibility,
         i: &ItemKind,
-    ) -> hir::ItemKind {
+    ) -> hir::ItemKind<'hir> {
         match *i {
             ItemKind::ExternCrate(orig_name) => hir::ItemKind::ExternCrate(orig_name),
             ItemKind::Use(ref use_tree) => {
@@ -282,29 +282,31 @@ impl LoweringContext<'_, '_> {
                 self.lower_use_tree(use_tree, &prefix, id, vis, ident, attrs)
             }
             ItemKind::Static(ref t, m, ref e) => {
+                let ty = self.lower_ty(
+                    t,
+                    if self.sess.features_untracked().impl_trait_in_bindings {
+                        ImplTraitContext::OpaqueTy(None)
+                    } else {
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
+                    }
+                );
                 hir::ItemKind::Static(
-                    self.lower_ty(
-                        t,
-                        if self.sess.features_untracked().impl_trait_in_bindings {
-                            ImplTraitContext::OpaqueTy(None)
-                        } else {
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
-                        }
-                    ),
+                    self.arena.alloc(ty.into_inner()),
                     m,
                     self.lower_const_body(span, Some(e)),
                 )
             }
             ItemKind::Const(ref t, ref e) => {
+                let ty = self.lower_ty(
+                    t,
+                    if self.sess.features_untracked().impl_trait_in_bindings {
+                        ImplTraitContext::OpaqueTy(None)
+                    } else {
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
+                    }
+                );
                 hir::ItemKind::Const(
-                    self.lower_ty(
-                        t,
-                        if self.sess.features_untracked().impl_trait_in_bindings {
-                            ImplTraitContext::OpaqueTy(None)
-                        } else {
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
-                        }
-                    ),
+                    self.arena.alloc(ty.into_inner()),
                     self.lower_const_body(span, Some(e))
                 )
             }
@@ -346,7 +348,7 @@ impl LoweringContext<'_, '_> {
                 None => {
                     let ty = self.lower_ty(ty, ImplTraitContext::disallowed());
                     let generics = self.lower_generics(generics, ImplTraitContext::disallowed());
-                    hir::ItemKind::TyAlias(ty, generics)
+                    hir::ItemKind::TyAlias(self.arena.alloc(ty.into_inner()), generics)
                 },
                 Some(bounds) => {
                     let ty = hir::OpaqueTy {
@@ -434,10 +436,11 @@ impl LoweringContext<'_, '_> {
                 let new_impl_items = self.with_in_scope_lifetime_defs(
                     &ast_generics.params,
                     |this| {
-                        impl_items
-                            .iter()
-                            .map(|item| this.lower_impl_item_ref(item))
-                            .collect()
+                        this.arena.alloc_from_iter(
+                            impl_items
+                                .iter()
+                                .map(|item| this.lower_impl_item_ref(item))
+                        )
                     },
                 );
 
@@ -447,16 +450,16 @@ impl LoweringContext<'_, '_> {
                     self.lower_defaultness(defaultness, true /* [1] */),
                     generics,
                     trait_ref,
-                    lowered_ty,
+                    self.arena.alloc(lowered_ty.into_inner()),
                     new_impl_items,
                 )
             }
             ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref items) => {
                 let bounds = self.lower_param_bounds(bounds, ImplTraitContext::disallowed());
-                let items = items
+                let items = self.arena.alloc_from_iter(items
                     .iter()
                     .map(|item| self.lower_trait_item_ref(item))
-                    .collect();
+                );
                 hir::ItemKind::Trait(
                     is_auto,
                     unsafety,
@@ -485,7 +488,7 @@ impl LoweringContext<'_, '_> {
         vis: &mut hir::Visibility,
         ident: &mut Ident,
         attrs: &hir::HirVec<Attribute>,
-    ) -> hir::ItemKind {
+    ) -> hir::ItemKind<'hir> {
         debug!("lower_use_tree(tree={:?})", tree);
         debug!("lower_use_tree: vis = {:?}", vis);
 
@@ -540,7 +543,7 @@ impl LoweringContext<'_, '_> {
                         let res = this.lower_res(res);
                         let path =
                             this.lower_path_extra(res, &path, ParamMode::Explicit, None);
-                        let kind = hir::ItemKind::Use(P(path), hir::UseKind::Single);
+                        let kind = hir::ItemKind::Use(this.arena.alloc(path), hir::UseKind::Single);
                         let vis = this.rebuild_vis(&vis);
 
                         this.insert_item(
@@ -556,11 +559,11 @@ impl LoweringContext<'_, '_> {
                     });
                 }
 
-                let path = P(self.lower_path_extra(ret_res, &path, ParamMode::Explicit, None));
+                let path = self.arena.alloc(self.lower_path_extra(ret_res, &path, ParamMode::Explicit, None));
                 hir::ItemKind::Use(path, hir::UseKind::Single)
             }
             UseTreeKind::Glob => {
-                let path = P(self.lower_path(
+                let path = self.arena.alloc(self.lower_path(
                     id,
                     &Path {
                         segments,
@@ -663,7 +666,7 @@ impl LoweringContext<'_, '_> {
 
                 let res = self.expect_full_res_from_use(id).next().unwrap_or(Res::Err);
                 let res = self.lower_res(res);
-                let path = P(self.lower_path_extra(res, &prefix, ParamMode::Explicit, None));
+                let path = self.arena.alloc(self.lower_path_extra(res, &prefix, ParamMode::Explicit, None));
                 hir::ItemKind::Use(path, hir::UseKind::ListStem)
             }
         }
@@ -748,8 +751,8 @@ impl LoweringContext<'_, '_> {
         }
     }
 
-    fn lower_global_asm(&mut self, ga: &GlobalAsm) -> P<hir::GlobalAsm> {
-        P(hir::GlobalAsm { asm: ga.asm })
+    fn lower_global_asm(&mut self, ga: &GlobalAsm) -> &'hir hir::GlobalAsm {
+        self.arena.alloc(hir::GlobalAsm { asm: ga.asm })
     }
 
     fn lower_variant(&mut self, v: &Variant) -> hir::Variant {

src/librustc/hir/map/blocks.rs

@@ -35,7 +35,7 @@ pub struct FnLikeNode<'a> { node: Node<'a> }
 /// corresponds to some FnLikeNode.
 trait MaybeFnLike { fn is_fn_like(&self) -> bool; }
 
-impl MaybeFnLike for ast::Item {
+impl MaybeFnLike for ast::Item<'_> {
     fn is_fn_like(&self) -> bool {
         match self.kind {
             ast::ItemKind::Fn(..) => true,

src/librustc/hir/map/collector.rs

@@ -367,7 +367,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         });
     }
 
-    fn visit_item(&mut self, i: &'hir Item) {
+    fn visit_item(&mut self, i: &'hir Item<'hir>) {
         debug!("visit_item: {:?}", i);
         debug_assert_eq!(i.hir_id.owner,
                          self.definitions.opt_def_index(self.hir_to_node_id[&i.hir_id]).unwrap());

src/librustc/hir/map/hir_id_validator.rs

@@ -53,7 +53,7 @@ impl<'a, 'hir> OuterVisitor<'a, 'hir> {
 }
 
 impl<'a, 'hir> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> {
-    fn visit_item(&mut self, i: &'hir hir::Item) {
+    fn visit_item(&mut self, i: &'hir hir::Item<'hir>) {
         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
         inner_visitor.check(i.hir_id, |this| intravisit::walk_item(this, i));
     }

src/librustc/hir/map/mod.rs

@@ -959,7 +959,7 @@ impl<'hir> Map<'hir> {
         bug!("expected foreign mod or inlined parent, found {}", self.node_to_string(parent))
     }
 
-    pub fn expect_item(&self, id: HirId) -> &'hir Item {
+    pub fn expect_item(&self, id: HirId) -> &'hir Item<'hir> {
         match self.find(id) { // read recorded by `find`
             Some(Node::Item(item)) => item,
             _ => bug!("expected item, found {}", self.node_to_string(id))
@@ -1213,7 +1213,7 @@ impl<'a> NodesMatchingSuffix<'a> {
                 id = parent;
             }
 
-            fn item_is_mod(item: &Item) -> bool {
+            fn item_is_mod(item: &Item<'_>) -> bool {
                 match item.kind {
                     ItemKind::Mod(_) => true,
                     _ => false,
@@ -1248,7 +1248,7 @@ trait Named {
 
 impl<T:Named> Named for Spanned<T> { fn name(&self) -> Name { self.node.name() } }
 
-impl Named for Item { fn name(&self) -> Name { self.ident.name } }
+impl Named for Item<'_> { fn name(&self) -> Name { self.ident.name } }
 impl Named for ForeignItem { fn name(&self) -> Name { self.ident.name } }
 impl Named for Variant { fn name(&self) -> Name { self.ident.name } }
 impl Named for StructField { fn name(&self) -> Name { self.ident.name } }