HirIdify hir::Def

src/librustc/hir/def.rs

@@ -2,10 +2,12 @@ use crate::hir::def_id::DefId;
 use crate::util::nodemap::{NodeMap, DefIdMap};
 use syntax::ast;
 use syntax::ext::base::MacroKind;
+use syntax::ast::NodeId;
 use syntax_pos::Span;
 use rustc_macros::HashStable;
 use crate::hir;
 use crate::ty;
+use std::fmt::Debug;
 
 use self::Namespace::*;
 
@@ -43,7 +45,7 @@ pub enum NonMacroAttrKind {
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, HashStable)]
-pub enum Def {
+pub enum Def<Id = hir::HirId> {
     // Type namespace
     Mod(DefId),
     /// `DefId` refers to the struct itself, `Def::Ctor` refers to its constructor if it exists.
@@ -78,8 +80,8 @@ pub enum Def {
     Method(DefId),
     AssociatedConst(DefId),
 
-    Local(ast::NodeId),
-    Upvar(ast::NodeId,  // `NodeId` of closed over local
+    Local(Id),
+    Upvar(Id,           // `HirId` of closed over local
           usize,        // index in the `freevars` list of the closure
           ast::NodeId), // expr node that creates the closure
     Label(ast::NodeId),
@@ -108,22 +110,22 @@ pub enum Def {
 /// ```
 #[derive(Copy, Clone, Debug)]
 pub struct PathResolution {
-    base_def: Def,
+    base_def: Def<NodeId>,
     unresolved_segments: usize,
 }
 
 impl PathResolution {
-    pub fn new(def: Def) -> Self {
+    pub fn new(def: Def<NodeId>) -> Self {
         PathResolution { base_def: def, unresolved_segments: 0 }
     }
 
-    pub fn with_unresolved_segments(def: Def, mut unresolved_segments: usize) -> Self {
+    pub fn with_unresolved_segments(def: Def<NodeId>, mut unresolved_segments: usize) -> Self {
         if def == Def::Err { unresolved_segments = 0 }
         PathResolution { base_def: def, unresolved_segments: unresolved_segments }
     }
 
     #[inline]
-    pub fn base_def(&self) -> Def {
+    pub fn base_def(&self) -> Def<NodeId> {
         self.base_def
     }
 
@@ -215,25 +217,36 @@ pub type DefMap = NodeMap<PathResolution>;
 
 /// This is the replacement export map. It maps a module to all of the exports
 /// within.
-pub type ExportMap = DefIdMap<Vec<Export>>;
+pub type ExportMap<Id> = DefIdMap<Vec<Export<Id>>>;
 
 /// Map used to track the `use` statements within a scope, matching it with all the items in every
 /// namespace.
 pub type ImportMap = NodeMap<PerNS<Option<PathResolution>>>;
 
 #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
-pub struct Export {
+pub struct Export<Id> {
     /// The name of the target.
     pub ident: ast::Ident,
     /// The definition of the target.
-    pub def: Def,
+    pub def: Def<Id>,
     /// The span of the target definition.
     pub span: Span,
     /// The visibility of the export.
     /// We include non-`pub` exports for hygienic macros that get used from extern crates.
     pub vis: ty::Visibility,
 }
 
+impl<Id> Export<Id> {
+    pub fn map_id<R>(self, map: impl FnMut(Id) -> R) -> Export<R> {
+        Export {
+            ident: self.ident,
+            def: self.def.map_id(map),
+            span: self.span,
+            vis: self.vis,
+        }
+    }
+}
+
 impl CtorKind {
     pub fn from_ast(vdata: &ast::VariantData) -> CtorKind {
         match *vdata {
@@ -264,9 +277,12 @@ impl NonMacroAttrKind {
     }
 }
 
-impl Def {
+impl<Id> Def<Id> {
     /// Return the `DefId` of this `Def` if it has an id, else panic.
-    pub fn def_id(&self) -> DefId {
+    pub fn def_id(&self) -> DefId
+    where
+        Id: Debug,
+    {
         self.opt_def_id().unwrap_or_else(|| {
             bug!("attempted .def_id() on invalid def: {:?}", self)
         })
@@ -358,4 +374,43 @@ impl Def {
             _ => "a",
         }
     }
+
+    pub fn map_id<R>(self, mut map: impl FnMut(Id) -> R) -> Def<R> {
+        match self {
+            Def::Fn(id) => Def::Fn(id),
+            Def::Mod(id) => Def::Mod(id),
+            Def::Static(id, is_mutbl) => Def::Static(id, is_mutbl),
+            Def::Enum(id) => Def::Enum(id),
+            Def::Variant(id) => Def::Variant(id),
+            Def::Ctor(a, b, c) => Def::Ctor(a, b, c),
+            Def::Struct(id) => Def::Struct(id),
+            Def::Existential(id) => Def::Existential(id),
+            Def::TyAlias(id) => Def::TyAlias(id),
+            Def::TraitAlias(id) => Def::TraitAlias(id),
+            Def::AssociatedTy(id) => Def::AssociatedTy(id),
+            Def::AssociatedExistential(id) => Def::AssociatedExistential(id),
+            Def::SelfCtor(id) => Def::SelfCtor(id),
+            Def::Union(id) => Def::Union(id),
+            Def::Trait(id) => Def::Trait(id),
+            Def::ForeignTy(id) => Def::ForeignTy(id),
+            Def::Method(id) => Def::Method(id),
+            Def::Const(id) => Def::Const(id),
+            Def::AssociatedConst(id) => Def::AssociatedConst(id),
+            Def::TyParam(id) => Def::TyParam(id),
+            Def::ConstParam(id) => Def::ConstParam(id),
+            Def::PrimTy(id) => Def::PrimTy(id),
+            Def::Local(id) => Def::Local(map(id)),
+            Def::Upvar(id, index, closure) => Def::Upvar(
+                map(id),
+                index,
+                closure
+            ),
+            Def::Label(id) => Def::Label(id),
+            Def::SelfTy(a, b) => Def::SelfTy(a, b),
+            Def::Macro(id, macro_kind) => Def::Macro(id, macro_kind),
+            Def::ToolMod => Def::ToolMod,
+            Def::NonMacroAttr(attr_kind) => Def::NonMacroAttr(attr_kind),
+            Def::Err => Def::Err,
+        }
+    }
 }