include a Name and Span for each item in the HIR of the impl

Author: nikomatsakis

src/librustc/hir/intravisit.rs

@@ -205,6 +205,9 @@ pub trait Visitor<'v> : Sized {
     fn visit_impl_item(&mut self, ii: &'v ImplItem) {
         walk_impl_item(self, ii)
     }
+    fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) {
+        walk_impl_item_ref(self, ii)
+    }
     fn visit_trait_ref(&mut self, t: &'v TraitRef) {
         walk_trait_ref(self, t)
     }
@@ -399,13 +402,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
             visitor.visit_id(item.id);
             visitor.visit_trait_ref(trait_ref)
         }
-        ItemImpl(.., ref type_parameters, ref opt_trait_reference, ref typ, ref impl_item_ids) => {
+        ItemImpl(.., ref type_parameters, ref opt_trait_reference, ref typ, ref impl_item_refs) => {
             visitor.visit_id(item.id);
             visitor.visit_generics(type_parameters);
             walk_list!(visitor, visit_trait_ref, opt_trait_reference);
             visitor.visit_ty(typ);
-            for &impl_item_id in impl_item_ids {
-                visitor.visit_nested_impl_item(impl_item_id);
+            for impl_item_ref in impl_item_refs {
+                visitor.visit_impl_item_ref(impl_item_ref);
             }
         }
         ItemStruct(ref struct_definition, ref generics) |
@@ -763,6 +766,12 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt
     }
 }
 
+pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, impl_item_ref: &'v ImplItemRef) {
+    visitor.visit_nested_impl_item(impl_item_ref.id);
+    visitor.visit_name(impl_item_ref.span, impl_item_ref.name);
+}
+
+
 pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &'v VariantData) {
     visitor.visit_id(struct_definition.id());
     walk_list!(visitor, visit_struct_field, struct_definition.fields());

src/librustc/hir/lowering.rs

@@ -116,7 +116,7 @@ impl<'a> LoweringContext<'a> {
             }
 
             fn visit_impl_item(&mut self, item: &ImplItem) {
-                let id = self.lctx.lower_impl_item_id(item);
+                let id = self.lctx.lower_impl_item_ref(item).id;
                 self.impl_items.insert(id, self.lctx.lower_impl_item(item));
                 visit::walk_impl_item(self, item);
             }
@@ -641,7 +641,7 @@ impl<'a> LoweringContext<'a> {
             }
             ItemKind::Impl(unsafety, polarity, ref generics, ref ifce, ref ty, ref impl_items) => {
                 let new_impl_items = impl_items.iter()
-                                               .map(|item| self.lower_impl_item_id(item))
+                                               .map(|item| self.lower_impl_item_ref(item))
                                                .collect();
                 let ifce = ifce.as_ref().map(|trait_ref| self.lower_trait_ref(trait_ref));
                 hir::ItemImpl(self.lower_unsafety(unsafety),
@@ -717,8 +717,24 @@ impl<'a> LoweringContext<'a> {
         })
     }
 
-    fn lower_impl_item_id(&mut self, i: &ImplItem) -> hir::ImplItemId {
-        hir::ImplItemId { id: i.id }
+    fn lower_impl_item_ref(&mut self, i: &ImplItem) -> hir::ImplItemRef {
+        hir::ImplItemRef {
+            id: hir::ImplItemId { node_id: i.id },
+            name: i.ident.name,
+            span: i.span,
+            vis: self.lower_visibility(&i.vis),
+            defaultness: self.lower_defaultness(i.defaultness),
+            kind: match i.node {
+                ImplItemKind::Const(..) => hir::AssociatedItemKind::Const,
+                ImplItemKind::Type(..) => hir::AssociatedItemKind::Type,
+                ImplItemKind::Method(ref sig, _) => hir::AssociatedItemKind::Method {
+                    has_self: sig.decl.get_self().is_some(),
+                },
+                ImplItemKind::Macro(..) => unimplemented!(),
+            },
+            // since `default impl` is not yet implemented, this is always true in impls
+            has_value: true,
+        }
     }
 
     fn lower_mod(&mut self, m: &Mod) -> hir::Mod {

src/librustc/hir/map/collector.rs

@@ -93,7 +93,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
     /// deep walking so that we walk nested items in the context of
     /// their outer items.
 
-    fn nested_visit_map(&mut self) -> Option<&hir::map::Map<'v>> {
+    fn nested_visit_map(&mut self) -> Option<&map::Map<'ast>> {
         panic!("visit_nested_xxx must be manually implemented in this visitor")
     }
 

src/librustc/hir/map/mod.rs

@@ -384,7 +384,7 @@ impl<'ast> Map<'ast> {
     }
 
     pub fn impl_item(&self, id: ImplItemId) -> &'ast ImplItem {
-        self.read(id.id);
+        self.read(id.node_id);
 
         // NB: intentionally bypass `self.forest.krate()` so that we
         // do not trigger a read of the whole krate here

src/librustc/hir/mod.rs

@@ -1057,7 +1057,7 @@ pub enum TraitItem_ {
 // so it can fetched later.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct ImplItemId {
-    pub id: NodeId,
+    pub node_id: NodeId,
 }
 
 /// Represents anything within an `impl` block
@@ -1546,7 +1546,7 @@ pub enum Item_ {
              Generics,
              Option<TraitRef>, // (optional) trait this impl implements
              P<Ty>, // self
-             HirVec<ImplItemId>),
+             HirVec<ImplItemRef>),
 }
 
 impl Item_ {
@@ -1570,6 +1570,30 @@ impl Item_ {
     }
 }
 
+/// A reference from an impl to one of its associated items. This
+/// contains the item's id, naturally, but also the item's name and
+/// some other high-level details (like whether it is an associated
+/// type or method, and whether it is public). This allows other
+/// passes to find the impl they want without loading the id (which
+/// means fewer edges in the incremental compilation graph).
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub struct ImplItemRef {
+    pub id: ImplItemId,
+    pub name: Name,
+    pub kind: AssociatedItemKind,
+    pub span: Span,
+    pub vis: Visibility,
+    pub defaultness: Defaultness,
+    pub has_value: bool,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub enum AssociatedItemKind {
+    Const,
+    Method { has_self: bool },
+    Type,
+}
+
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct ForeignItem {
     pub name: Name,

src/librustc/hir/print.rs

@@ -808,8 +808,8 @@ impl<'a> State<'a> {
                 space(&mut self.s)?;
                 self.bopen()?;
                 self.print_inner_attributes(&item.attrs)?;
-                for &impl_item in impl_items {
-                    self.print_impl_item_id(impl_item)?;
+                for impl_item in impl_items {
+                    self.print_impl_item_ref(impl_item)?;
                 }
                 self.bclose(item.span)?;
             }
@@ -1020,10 +1020,10 @@ impl<'a> State<'a> {
         self.ann.post(self, NodeSubItem(ti.id))
     }
 
-    pub fn print_impl_item_id(&mut self, item_id: hir::ImplItemId) -> io::Result<()> {
+    pub fn print_impl_item_ref(&mut self, item_ref: &hir::ImplItemRef) -> io::Result<()> {
         if let Some(krate) = self.krate {
             // skip nested items if krate context was not provided
-            let item = &krate.impl_item(item_id);
+            let item = &krate.impl_item(item_ref.id);
             self.print_impl_item(item)
         } else {
             Ok(())

src/librustc/middle/dead.rs

@@ -359,12 +359,12 @@ impl<'v, 'k> ItemLikeVisitor<'v> for LifeSeeder<'k> {
                     }
                 }
             }
-            hir::ItemImpl(.., ref opt_trait, _, ref impl_item_ids) => {
-                for &impl_item_id in impl_item_ids {
-                    let impl_item = self.krate.impl_item(impl_item_id);
+            hir::ItemImpl(.., ref opt_trait, _, ref impl_item_refs) => {
+                for impl_item_ref in impl_item_refs {
+                    let impl_item = self.krate.impl_item(impl_item_ref.id);
                     if opt_trait.is_some() ||
                             has_allow_dead_code_or_lang_attr(&impl_item.attrs) {
-                        self.worklist.push(impl_item_id.id);
+                        self.worklist.push(impl_item_ref.id.node_id);
                     }
                 }
             }

src/librustc/middle/reachable.rs

@@ -328,10 +328,10 @@ struct CollectPrivateImplItemsVisitor<'a> {
 impl<'a, 'v> ItemLikeVisitor<'v> for CollectPrivateImplItemsVisitor<'a> {
     fn visit_item(&mut self, item: &hir::Item) {
         // We need only trait impls here, not inherent impls, and only non-exported ones
-        if let hir::ItemImpl(.., Some(_), _, ref impl_items) = item.node {
+        if let hir::ItemImpl(.., Some(_), _, ref impl_item_refs) = item.node {
             if !self.access_levels.is_reachable(item.id) {
-                for impl_item in impl_items {
-                    self.worklist.push(impl_item.id);
+                for impl_item_ref in impl_item_refs {
+                    self.worklist.push(impl_item_ref.id.node_id);
                 }
             }
         }

src/librustc/middle/stability.rs

@@ -525,10 +525,10 @@ pub fn check_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         // For implementations of traits, check the stability of each item
         // individually as it's possible to have a stable trait with unstable
         // items.
-        hir::ItemImpl(.., Some(ref t), _, ref impl_item_ids) => {
+        hir::ItemImpl(.., Some(ref t), _, ref impl_item_refs) => {
             let trait_did = tcx.expect_def(t.ref_id).def_id();
-            for &impl_item_id in impl_item_ids {
-                let impl_item = tcx.map.impl_item(impl_item_id);
+            for impl_item_ref in impl_item_refs {
+                let impl_item = tcx.map.impl_item(impl_item_ref.id);
                 let item = tcx.associated_items(trait_did)
                     .find(|item| item.name == impl_item.name).unwrap();
                 if warn_about_defns {

src/librustc/ty/mod.rs

@@ -2190,9 +2190,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                         self.map.local_def_id(trait_item.id)
                     }).collect())
                 }
-                hir::ItemImpl(.., ref impl_items) => {
-                    Rc::new(impl_items.iter().map(|impl_item| {
-                        self.map.local_def_id(impl_item.id)
+                hir::ItemImpl(.., ref impl_item_refs) => {
+                    Rc::new(impl_item_refs.iter().map(|impl_item_ref| {
+                        self.map.local_def_id(impl_item_ref.id.node_id)
                     }).collect())
                 }
                 _ => span_bug!(item.span, "associated_item_def_ids: not impl or trait")