Convert EntryKind to a struct, Entry

src/librustc/hir/map/collector.rs

@@ -29,7 +29,7 @@ pub(super) struct NodeCollector<'a, 'hir> {
     /// The crate
     krate: &'hir Crate,
     /// The node map
-    map: Vec<EntryKind<'hir>>,
+    map: Vec<Option<Entry<'hir>>>,
     /// The parent of this node
     parent_node: NodeId,
 
@@ -114,7 +114,11 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
             hcx,
             hir_body_nodes,
         };
-        collector.insert_entry(CRATE_NODE_ID, EntryKind::RootCrate(root_mod_sig_dep_index));
+        collector.insert_entry(CRATE_NODE_ID, Entry {
+            parent: ast::DUMMY_NODE_ID,
+            dep_node: root_mod_sig_dep_index,
+            node: NodeKind::Crate,
+        });
 
         collector
     }
@@ -124,9 +128,8 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
                                                   cstore: &dyn CrateStore,
                                                   source_map: &SourceMap,
                                                   commandline_args_hash: u64)
-                                                  -> (Vec<EntryKind<'hir>>, Svh) {
+                                                  -> (Vec<Option<Entry<'hir>>>, Svh) {
-        self
+        self.hir_body_nodes
-            .hir_body_nodes
             .sort_unstable_by(|&(ref d1, _), &(ref d2, _)| d1.cmp(d2));
 
         let node_hashes = self
@@ -178,44 +181,24 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         (self.map, svh)
     }
 
-    fn insert_entry(&mut self, id: NodeId, entry: EntryKind<'hir>) {
+    fn insert_entry(&mut self, id: NodeId, entry: Entry<'hir>) {
         debug!("hir_map: {:?} => {:?}", id, entry);
         let len = self.map.len();
         if id.as_usize() >= len {
-            self.map.extend(repeat(EntryKind::NotPresent).take(id.as_usize() - len + 1));
+            self.map.extend(repeat(None).take(id.as_usize() - len + 1));
         }
-        self.map[id.as_usize()] = entry;
+        self.map[id.as_usize()] = Some(entry);
     }
 
     fn insert(&mut self, id: NodeId, node: NodeKind<'hir>) {
-        let parent = self.parent_node;
+        let entry = Entry {
-        let dep_node_index = if self.currently_in_body {
+            parent: self.parent_node,
+            dep_node: if self.currently_in_body {
                 self.current_full_dep_index
             } else {
                 self.current_signature_dep_index
-        };
+            },
-
+            node,
-        let entry = match node {
-            NodeKind::Item(n) => EntryKind::Item(parent, dep_node_index, n),
-            NodeKind::ForeignItem(n) => EntryKind::ForeignItem(parent, dep_node_index, n),
-            NodeKind::TraitItem(n) => EntryKind::TraitItem(parent, dep_node_index, n),
-            NodeKind::ImplItem(n) => EntryKind::ImplItem(parent, dep_node_index, n),
-            NodeKind::Variant(n) => EntryKind::Variant(parent, dep_node_index, n),
-            NodeKind::Field(n) => EntryKind::Field(parent, dep_node_index, n),
-            NodeKind::AnonConst(n) => EntryKind::AnonConst(parent, dep_node_index, n),
-            NodeKind::Expr(n) => EntryKind::Expr(parent, dep_node_index, n),
-            NodeKind::Stmt(n) => EntryKind::Stmt(parent, dep_node_index, n),
-            NodeKind::Ty(n) => EntryKind::Ty(parent, dep_node_index, n),
-            NodeKind::TraitRef(n) => EntryKind::TraitRef(parent, dep_node_index, n),
-            NodeKind::Binding(n) => EntryKind::Binding(parent, dep_node_index, n),
-            NodeKind::Pat(n) => EntryKind::Pat(parent, dep_node_index, n),
-            NodeKind::Block(n) => EntryKind::Block(parent, dep_node_index, n),
-            NodeKind::StructCtor(n) => EntryKind::StructCtor(parent, dep_node_index, n),
-            NodeKind::Lifetime(n) => EntryKind::Lifetime(parent, dep_node_index, n),
-            NodeKind::GenericParam(n) => EntryKind::GenericParam(parent, dep_node_index, n),
-            NodeKind::Visibility(n) => EntryKind::Visibility(parent, dep_node_index, n),
-            NodeKind::Local(n) => EntryKind::Local(parent, dep_node_index, n),
-            NodeKind::MacroDef(n) => EntryKind::MacroDef(dep_node_index, n),
         };
 
         // Make sure that the DepNode of some node coincides with the HirId

src/librustc/hir/map/mod.rs

@@ -69,142 +69,72 @@ pub enum NodeKind<'hir> {
     Lifetime(&'hir Lifetime),
     GenericParam(&'hir GenericParam),
     Visibility(&'hir Visibility),
+
+    /// Roots for node trees. Its DepNodeIndex when in `Entry`
+    /// is the dependency node of the crate's root module.
+    Crate,
 }
 
-/// Represents an entry and its parent NodeID.
+/// Represents an entry and its parent NodeId.
-/// The odd layout is to bring down the total size.
+#[derive(Copy, Clone, Debug)]
-#[derive(Copy, Debug)]
+pub struct Entry<'hir> {
-pub enum EntryKind<'hir> {
+    parent: NodeId,
-    /// Placeholder for holes in the map.
+    dep_node: DepNodeIndex,
-    NotPresent,
+    node: NodeKind<'hir>,
-
-    /// All the node types, with a parent ID.
-    Item(NodeId, DepNodeIndex, &'hir Item),
-    ForeignItem(NodeId, DepNodeIndex, &'hir ForeignItem),
-    TraitItem(NodeId, DepNodeIndex, &'hir TraitItem),
-    ImplItem(NodeId, DepNodeIndex, &'hir ImplItem),
-    Variant(NodeId, DepNodeIndex, &'hir Variant),
-    Field(NodeId, DepNodeIndex, &'hir StructField),
-    AnonConst(NodeId, DepNodeIndex, &'hir AnonConst),
-    Expr(NodeId, DepNodeIndex, &'hir Expr),
-    Stmt(NodeId, DepNodeIndex, &'hir Stmt),
-    Ty(NodeId, DepNodeIndex, &'hir Ty),
-    TraitRef(NodeId, DepNodeIndex, &'hir TraitRef),
-    Binding(NodeId, DepNodeIndex, &'hir Pat),
-    Pat(NodeId, DepNodeIndex, &'hir Pat),
-    Block(NodeId, DepNodeIndex, &'hir Block),
-    StructCtor(NodeId, DepNodeIndex, &'hir VariantData),
-    Lifetime(NodeId, DepNodeIndex, &'hir Lifetime),
-    GenericParam(NodeId, DepNodeIndex, &'hir GenericParam),
-    Visibility(NodeId, DepNodeIndex, &'hir Visibility),
-    Local(NodeId, DepNodeIndex, &'hir Local),
-    MacroDef(DepNodeIndex, &'hir MacroDef),
-
-    /// Roots for node trees. The DepNodeIndex is the dependency node of the
-    /// crate's root module.
-    RootCrate(DepNodeIndex),
 }
 
-impl<'hir> Clone for EntryKind<'hir> {
+impl<'hir> Entry<'hir> {
-    fn clone(&self) -> EntryKind<'hir> {
-        *self
-    }
-}
-
-impl<'hir> EntryKind<'hir> {
     fn parent_node(self) -> Option<NodeId> {
-        Some(match self {
+        match self.node {
-            EntryKind::Item(id, _, _) => id,
+            NodeKind::Crate | NodeKind::MacroDef(_) => None,
-            EntryKind::ForeignItem(id, _, _) => id,
+            _ => Some(self.parent),
-            EntryKind::TraitItem(id, _, _) => id,
+        }
-            EntryKind::ImplItem(id, _, _) => id,
-            EntryKind::Variant(id, _, _) => id,
-            EntryKind::Field(id, _, _) => id,
-            EntryKind::AnonConst(id, _, _) => id,
-            EntryKind::Expr(id, _, _) => id,
-            EntryKind::Stmt(id, _, _) => id,
-            EntryKind::Ty(id, _, _) => id,
-            EntryKind::TraitRef(id, _, _) => id,
-            EntryKind::Binding(id, _, _) => id,
-            EntryKind::Pat(id, _, _) => id,
-            EntryKind::Block(id, _, _) => id,
-            EntryKind::StructCtor(id, _, _) => id,
-            EntryKind::Lifetime(id, _, _) => id,
-            EntryKind::GenericParam(id, _, _) => id,
-            EntryKind::Visibility(id, _, _) => id,
-            EntryKind::Local(id, _, _) => id,
-
-            EntryKind::NotPresent |
-            EntryKind::MacroDef(..) |
-            EntryKind::RootCrate(_) => return None,
-        })
     }
 
     fn to_node(self) -> Option<NodeKind<'hir>> {
-        Some(match self {
+        match self.node {
-            EntryKind::Item(_, _, n) => NodeKind::Item(n),
+            NodeKind::Crate => None,
-            EntryKind::ForeignItem(_, _, n) => NodeKind::ForeignItem(n),
+            _ => Some(self.node),
-            EntryKind::TraitItem(_, _, n) => NodeKind::TraitItem(n),
+        }
-            EntryKind::ImplItem(_, _, n) => NodeKind::ImplItem(n),
-            EntryKind::Variant(_, _, n) => NodeKind::Variant(n),
-            EntryKind::Field(_, _, n) => NodeKind::Field(n),
-            EntryKind::AnonConst(_, _, n) => NodeKind::AnonConst(n),
-            EntryKind::Expr(_, _, n) => NodeKind::Expr(n),
-            EntryKind::Stmt(_, _, n) => NodeKind::Stmt(n),
-            EntryKind::Ty(_, _, n) => NodeKind::Ty(n),
-            EntryKind::TraitRef(_, _, n) => NodeKind::TraitRef(n),
-            EntryKind::Binding(_, _, n) => NodeKind::Binding(n),
-            EntryKind::Pat(_, _, n) => NodeKind::Pat(n),
-            EntryKind::Block(_, _, n) => NodeKind::Block(n),
-            EntryKind::StructCtor(_, _, n) => NodeKind::StructCtor(n),
-            EntryKind::Lifetime(_, _, n) => NodeKind::Lifetime(n),
-            EntryKind::GenericParam(_, _, n) => NodeKind::GenericParam(n),
-            EntryKind::Visibility(_, _, n) => NodeKind::Visibility(n),
-            EntryKind::Local(_, _, n) => NodeKind::Local(n),
-            EntryKind::MacroDef(_, n) => NodeKind::MacroDef(n),
-
-            EntryKind::NotPresent |
-            EntryKind::RootCrate(_) => return None
-        })
     }
 
     fn fn_decl(&self) -> Option<&FnDecl> {
-        match self {
+        match self.node {
-            EntryKind::Item(_, _, ref item) => {
+            NodeKind::Item(ref item) => {
                 match item.node {
                     ItemKind::Fn(ref fn_decl, _, _, _) => Some(&fn_decl),
                     _ => None,
                 }
             }
 
-            EntryKind::TraitItem(_, _, ref item) => {
+            NodeKind::TraitItem(ref item) => {
                 match item.node {
                     TraitItemKind::Method(ref method_sig, _) => Some(&method_sig.decl),
                     _ => None
                 }
             }
 
-            EntryKind::ImplItem(_, _, ref item) => {
+            NodeKind::ImplItem(ref item) => {
                 match item.node {
                     ImplItemKind::Method(ref method_sig, _) => Some(&method_sig.decl),
                     _ => None,
                 }
             }
 
-            EntryKind::Expr(_, _, ref expr) => {
+            NodeKind::Expr(ref expr) => {
                 match expr.node {
                     ExprKind::Closure(_, ref fn_decl, ..) => Some(&fn_decl),
                     _ => None,
                 }
             }
 
-            _ => None
+            _ => None,
         }
     }
 
     fn associated_body(self) -> Option<BodyId> {
-        match self {
+        match self.node {
-            EntryKind::Item(_, _, item) => {
+            NodeKind::Item(item) => {
                 match item.node {
                     ItemKind::Const(_, body) |
                     ItemKind::Static(.., body) |
@@ -213,7 +143,7 @@ impl<'hir> EntryKind<'hir> {
                 }
             }
 
-            EntryKind::TraitItem(_, _, item) => {
+            NodeKind::TraitItem(item) => {
                 match item.node {
                     TraitItemKind::Const(_, Some(body)) |
                     TraitItemKind::Method(_, TraitMethod::Provided(body)) => Some(body),
@@ -221,7 +151,7 @@ impl<'hir> EntryKind<'hir> {
                 }
             }
 
-            EntryKind::ImplItem(_, _, item) => {
+            NodeKind::ImplItem(item) => {
                 match item.node {
                     ImplItemKind::Const(_, body) |
                     ImplItemKind::Method(_, body) => Some(body),
@@ -229,9 +159,9 @@ impl<'hir> EntryKind<'hir> {
                 }
             }
 
-            EntryKind::AnonConst(_, _, constant) => Some(constant.body),
+            NodeKind::AnonConst(constant) => Some(constant.body),
 
-            EntryKind::Expr(_, _, expr) => {
+            NodeKind::Expr(expr) => {
                 match expr.node {
                     ExprKind::Closure(.., body, _, _) => Some(body),
                     _ => None,
@@ -284,16 +214,16 @@ pub struct Map<'hir> {
     /// The SVH of the local crate.
     pub crate_hash: Svh,
 
-    /// NodeIds are sequential integers from 0, so we can be
+    /// `NodeId`s are sequential integers from 0, so we can be
     /// super-compact by storing them in a vector. Not everything with
-    /// a NodeId is in the map, but empirically the occupancy is about
+    /// a `NodeId` is in the map, but empirically the occupancy is about
     /// 75-80%, so there's not too much overhead (certainly less than
     /// a hashmap, since they (at the time of writing) have a maximum
     /// of 75% occupancy).
     ///
     /// Also, indexing is pretty quick when you've got a vector and
     /// plain old integers.
-    map: Vec<EntryKind<'hir>>,
+    map: Vec<Option<Entry<'hir>>>,
 
     definitions: &'hir Definitions,
 
@@ -310,34 +240,10 @@ impl<'hir> Map<'hir> {
     /// read recorded). If the function just returns a DefId or
     /// NodeId, no actual content was returned, so no read is needed.
     pub fn read(&self, id: NodeId) {
-        let entry = self.map[id.as_usize()];
+        if let Some(entry) = self.map[id.as_usize()] {
-        match entry {
+            self.dep_graph.read_index(entry.dep_node);
-            EntryKind::Item(_, dep_node_index, _) |
+        } else {
-            EntryKind::TraitItem(_, dep_node_index, _) |
+            bug!("called `HirMap::read()` with invalid `NodeId`")
-            EntryKind::ImplItem(_, dep_node_index, _) |
-            EntryKind::Variant(_, dep_node_index, _) |
-            EntryKind::ForeignItem(_, dep_node_index, _) |
-            EntryKind::Field(_, dep_node_index, _) |
-            EntryKind::Stmt(_, dep_node_index, _) |
-            EntryKind::Ty(_, dep_node_index, _) |
-            EntryKind::TraitRef(_, dep_node_index, _) |
-            EntryKind::Binding(_, dep_node_index, _) |
-            EntryKind::Pat(_, dep_node_index, _) |
-            EntryKind::Block(_, dep_node_index, _) |
-            EntryKind::StructCtor(_, dep_node_index, _) |
-            EntryKind::Lifetime(_, dep_node_index, _) |
-            EntryKind::GenericParam(_, dep_node_index, _) |
-            EntryKind::Visibility(_, dep_node_index, _) |
-            EntryKind::AnonConst(_, dep_node_index, _) |
-            EntryKind::Expr(_, dep_node_index, _) |
-            EntryKind::Local(_, dep_node_index, _) |
-            EntryKind::MacroDef(dep_node_index, _) |
-            EntryKind::RootCrate(dep_node_index) => {
-                self.dep_graph.read_index(dep_node_index);
-            }
-            EntryKind::NotPresent => {
-                bug!("called HirMap::read() with invalid NodeId")
-            }
         }
     }
 
@@ -485,7 +391,8 @@ impl<'hir> Map<'hir> {
             NodeKind::StructCtor(_) |
             NodeKind::Lifetime(_) |
             NodeKind::Visibility(_) |
-            NodeKind::Block(_) => None,
+            NodeKind::Block(_) |
+            NodeKind::Crate => None,
             NodeKind::Local(local) => {
                 Some(Def::Local(local.id))
             }
@@ -506,8 +413,8 @@ impl<'hir> Map<'hir> {
         self.map.len()
     }
 
-    fn find_entry(&self, id: NodeId) -> Option<EntryKind<'hir>> {
+    fn find_entry(&self, id: NodeId) -> Option<Entry<'hir>> {
-        self.map.get(id.as_usize()).cloned()
+        self.map.get(id.as_usize()).cloned().unwrap_or(None)
     }
 
     pub fn krate(&self) -> &'hir Crate {
@@ -551,7 +458,7 @@ impl<'hir> Map<'hir> {
     /// item (possibly associated), a closure, or a `hir::AnonConst`.
     pub fn body_owner(&self, BodyId { node_id }: BodyId) -> NodeId {
         let parent = self.get_parent_node(node_id);
-        assert!(self.map[parent.as_usize()].is_body_owner(node_id));
+        assert!(self.map[parent.as_usize()].map_or(false, |e| e.is_body_owner(node_id)));
         parent
     }
 
@@ -763,12 +670,8 @@ impl<'hir> Map<'hir> {
                 return Err(id);
             }
 
-            let node = self.find_entry(parent_node);
+            if let Some(node) = self.find_entry(parent_node) {
-            if node.is_none() {
+                match node.to_node() {
-                return Err(id);
-            }
-            let node = node.unwrap().to_node();
-            match node {
                     Some(ref node) => {
                         if found(node) {
                             return Ok(parent_node);
@@ -776,11 +679,12 @@ impl<'hir> Map<'hir> {
                             return Err(parent_node);
                         }
                     }
-                None => {
+                    None => return Err(parent_node),
-                    return Err(parent_node);
-                }
                 }
                 id = parent_node;
+            } else {
+                return Err(id);
+            }
         }
     }
 
@@ -888,24 +792,18 @@ impl<'hir> Map<'hir> {
 
     pub fn get_foreign_abi(&self, id: NodeId) -> Abi {
         let parent = self.get_parent(id);
-        let abi = match self.find_entry(parent) {
+        if let Some(entry) = self.find_entry(parent) {
-            Some(EntryKind::Item(_, _, i)) => {
+            match entry {
-                match i.node {
+                Entry { node: NodeKind::Item(Item { node: ItemKind::ForeignMod(ref nm), .. }), .. }
-                    ItemKind::ForeignMod(ref nm) => Some(nm.abi),
+                    => {
-                    _ => None
-                }
-            }
-            _ => None
-        };
-        match abi {
-            Some(abi) => {
                     self.read(id); // reveals some of the content of a node
-                abi
+                    return nm.abi;
                 }
-            None => bug!("expected foreign mod or inlined parent, found {}",
+                _ => {}
-                          self.node_to_string(parent))
             }
         }
+        bug!("expected foreign mod or inlined parent, found {}", self.node_to_string(parent))
+    }
 
     pub fn expect_item(&self, id: NodeId) -> &'hir Item {
         match self.find(id) { // read recorded by `find`
@@ -1030,35 +928,33 @@ impl<'hir> Map<'hir> {
 
     pub fn span(&self, id: NodeId) -> Span {
         self.read(id); // reveals span from node
-        match self.find_entry(id) {
+        match self.find_entry(id).map(|entry| entry.node) {
-            Some(EntryKind::Item(_, _, item)) => item.span,
+            Some(NodeKind::Item(item)) => item.span,
-            Some(EntryKind::ForeignItem(_, _, foreign_item)) => foreign_item.span,
+            Some(NodeKind::ForeignItem(foreign_item)) => foreign_item.span,
-            Some(EntryKind::TraitItem(_, _, trait_method)) => trait_method.span,
+            Some(NodeKind::TraitItem(trait_method)) => trait_method.span,
-            Some(EntryKind::ImplItem(_, _, impl_item)) => impl_item.span,
+            Some(NodeKind::ImplItem(impl_item)) => impl_item.span,
-            Some(EntryKind::Variant(_, _, variant)) => variant.span,
+            Some(NodeKind::Variant(variant)) => variant.span,
-            Some(EntryKind::Field(_, _, field)) => field.span,
+            Some(NodeKind::Field(field)) => field.span,
-            Some(EntryKind::AnonConst(_, _, constant)) => self.body(constant.body).value.span,
+            Some(NodeKind::AnonConst(constant)) => self.body(constant.body).value.span,
-            Some(EntryKind::Expr(_, _, expr)) => expr.span,
+            Some(NodeKind::Expr(expr)) => expr.span,
-            Some(EntryKind::Stmt(_, _, stmt)) => stmt.span,
+            Some(NodeKind::Stmt(stmt)) => stmt.span,
-            Some(EntryKind::Ty(_, _, ty)) => ty.span,
+            Some(NodeKind::Ty(ty)) => ty.span,
-            Some(EntryKind::TraitRef(_, _, tr)) => tr.path.span,
+            Some(NodeKind::TraitRef(tr)) => tr.path.span,
-            Some(EntryKind::Binding(_, _, pat)) => pat.span,
+            Some(NodeKind::Binding(pat)) => pat.span,
-            Some(EntryKind::Pat(_, _, pat)) => pat.span,
+            Some(NodeKind::Pat(pat)) => pat.span,
-            Some(EntryKind::Block(_, _, block)) => block.span,
+            Some(NodeKind::Block(block)) => block.span,
-            Some(EntryKind::StructCtor(_, _, _)) => self.expect_item(self.get_parent(id)).span,
+            Some(NodeKind::StructCtor(_)) => self.expect_item(self.get_parent(id)).span,
-            Some(EntryKind::Lifetime(_, _, lifetime)) => lifetime.span,
+            Some(NodeKind::Lifetime(lifetime)) => lifetime.span,
-            Some(EntryKind::GenericParam(_, _, param)) => param.span,
+            Some(NodeKind::GenericParam(param)) => param.span,
-            Some(EntryKind::Visibility(_, _, &Spanned {
+            Some(NodeKind::Visibility(&Spanned {
                 node: VisibilityKind::Restricted { ref path, .. }, ..
             })) => path.span,
-            Some(EntryKind::Visibility(_, _, v)) => bug!("unexpected Visibility {:?}", v),
+            Some(NodeKind::Visibility(v)) => bug!("unexpected Visibility {:?}", v),
-            Some(EntryKind::Local(_, _, local)) => local.span,
+            Some(NodeKind::Local(local)) => local.span,
-            Some(EntryKind::MacroDef(_, macro_def)) => macro_def.span,
+            Some(NodeKind::MacroDef(macro_def)) => macro_def.span,
 
-            Some(EntryKind::RootCrate(_)) => self.forest.krate.span,
+            Some(NodeKind::Crate) => self.forest.krate.span,
-            Some(EntryKind::NotPresent) | None => {
+            None => bug!("hir::map::Map::span: id not in map: {:?}", id),
-                bug!("hir::map::Map::span: id not in map: {:?}", id)
-            }
         }
     }
 
@@ -1151,13 +1047,13 @@ impl<'a, 'hir> Iterator for NodesMatchingSuffix<'a, 'hir> {
                 return None;
             }
             self.idx = NodeId::from_u32(self.idx.as_u32() + 1);
-            let name = match self.map.find_entry(idx) {
+            let name = match self.map.find_entry(idx).map(|entry| entry.node) {
-                Some(EntryKind::Item(_, _, n))       => n.name(),
+                Some(NodeKind::Item(n)) => n.name(),
-                Some(EntryKind::ForeignItem(_, _, n))=> n.name(),
+                Some(NodeKind::ForeignItem(n)) => n.name(),
-                Some(EntryKind::TraitItem(_, _, n))  => n.name(),
+                Some(NodeKind::TraitItem(n)) => n.name(),
-                Some(EntryKind::ImplItem(_, _, n))   => n.name(),
+                Some(NodeKind::ImplItem(n)) => n.name(),
-                Some(EntryKind::Variant(_, _, n))    => n.name(),
+                Some(NodeKind::Variant(n)) => n.name(),
-                Some(EntryKind::Field(_, _, n))      => n.name(),
+                Some(NodeKind::Field(n)) => n.name(),
                 _ => continue,
             };
             if self.matches_names(self.map.get_parent(idx), name) {
@@ -1206,12 +1102,8 @@ pub fn map_crate<'hir>(sess: &::session::Session,
     if log_enabled!(::log::Level::Debug) {
         // This only makes sense for ordered stores; note the
         // enumerate to count the number of entries.
-        let (entries_less_1, _) = map.iter().filter(|&x| {
+        let (entries_less_1, _) = map.iter().filter_map(|x| *x).enumerate().last()
-            match *x {
+            .expect("AST map was empty after folding?");
-                EntryKind::NotPresent => false,
-                _ => true
-            }
-        }).enumerate().last().expect("AST map was empty after folding?");
 
         let entries = entries_less_1 + 1;
         let vector_length = map.len();
@@ -1285,6 +1177,7 @@ impl<'a> print::State<'a> {
             NodeKind::StructCtor(_)   => bug!("cannot print isolated StructCtor"),
             NodeKind::Local(a)        => self.print_local_decl(&a),
             NodeKind::MacroDef(_)     => bug!("cannot print MacroDef"),
+            NodeKind::Crate     => bug!("cannot print Crate"),
         }
     }
 }
@@ -1411,9 +1304,8 @@ fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String {
         Some(NodeKind::MacroDef(_)) => {
             format!("macro {}{}",  path_str(), id_str)
         }
-        None => {
+        Some(NodeKind::Crate) => format!("root_crate"),
-            format!("unknown node{}", id_str)
+        None => format!("unknown node{}", id_str),
-        }
     }
 }