make HIR paths store Defs per-namespace

Author: QuietMisdreavus

src/librustc/hir/def.rs

@@ -71,6 +71,12 @@ pub enum Def {
     Err,
 }
 
+impl Default for Def {
+    fn default() -> Self {
+        Def::Err
+    }
+}
+
 /// The result of resolving a path before lowering to HIR.
 /// `base_def` is definition of resolved part of the
 /// path, `unresolved_segments` is the number of unresolved
@@ -131,7 +137,7 @@ pub enum Namespace {
 }
 
 /// Just a helper ‒ separate structure for each namespace.
-#[derive(Clone, Default, Debug)]
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
 pub struct PerNS<T> {
     pub value_ns: T,
     pub type_ns: T,
@@ -156,6 +162,35 @@ impl<T> PerNS<Option<T>> {
     }
 }
 
+impl PerNS<Def> {
+    /// Ensures that no more than one namespace has a valid `Def`, then returns that `Def` (or
+    /// `Err` if no namespaces had valid `Def`s).
+    pub fn assert_single_ns(self) -> Def {
+        let mut valid_defs = self.into_iter().filter(|d| *d != Def::Err).collect::<Vec<Def>>();
+        if valid_defs.len() > 1 {
+            bug!("single Def was requested but multiple were available: {:?}", valid_defs);
+        }
+        valid_defs.pop().unwrap_or(Def::Err)
+    }
+
+    /// Returns whether all the `Def`s in this collection are `Err`.
+    pub fn all_err(self) -> bool {
+        self.into_iter().all(|d| d == Def::Err)
+    }
+
+    /// Returns an iterator over the valid `Def`s in this collection. If all the `Def`s are `Err`,
+    /// the iterator will yield a single `Err`.
+    pub fn valid_defs(self) -> impl Iterator<Item=Def> {
+        if self.all_err() {
+            vec![Def::Err].into_iter()
+        } else {
+            let mut ret = Vec::with_capacity(3);
+            ret.extend(self.into_iter().filter(|&d| d != Def::Err));
+            ret.into_iter()
+        }
+    }
+}
+
 impl<T> ::std::ops::Index<Namespace> for PerNS<T> {
     type Output = T;
     fn index(&self, ns: Namespace) -> &T {
@@ -187,6 +222,18 @@ impl<T> IntoIterator for PerNS<T> {
     }
 }
 
+impl From<Def> for PerNS<Def> {
+    fn from(src: Def) -> PerNS<Def> {
+        let mut ret = PerNS::<Def>::default();
+
+        if let Some(ns) = src.namespace() {
+            ret[ns] = src;
+        }
+
+        ret
+    }
+}
+
 /// Definition mapping
 pub type DefMap = NodeMap<PerNS<Option<PathResolution>>>;
 
@@ -283,4 +330,39 @@ impl Def {
             Def::Err => "unresolved item",
         }
     }
+
+    /// The namespace associated with this Def. Returns `None` for `Err`.
+    pub fn namespace(&self) -> Option<Namespace> {
+        match *self {
+            Def::Mod(..) |
+            Def::Struct(..) |
+            Def::Union(..) |
+            Def::Enum(..) |
+            Def::Variant(..) |
+            Def::Trait(..) |
+            Def::TyAlias(..) |
+            Def::TyForeign(..) |
+            Def::TraitAlias(..) |
+            Def::AssociatedTy(..) |
+            Def::PrimTy(..) |
+            Def::TyParam(..) |
+            Def::SelfTy(..) => Some(TypeNS),
+
+            Def::Fn(..) |
+            Def::Const(..) |
+            Def::Static(..) |
+            Def::StructCtor(..) |
+            Def::VariantCtor(..) |
+            Def::Method(..) |
+            Def::AssociatedConst(..) |
+            Def::Local(..) |
+            Def::Upvar(..) |
+            Def::Label(..) => Some(ValueNS),
+
+            Def::Macro(..) |
+            Def::GlobalAsm(..) => Some(MacroNS),
+
+            Def::Err => None,
+        }
+    }
 }

src/librustc/hir/intravisit.rs

@@ -625,7 +625,9 @@ pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: Nod
 }
 
 pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
-    visitor.visit_def_mention(path.def);
+    for def in path.defs {
+        visitor.visit_def_mention(def);
+    }
     for segment in &path.segments {
         visitor.visit_path_segment(path.span, segment);
     }

src/librustc/hir/lowering.rs

@@ -567,6 +567,8 @@ impl<'a> LoweringContext<'a> {
     }
 
     fn expect_full_def(&mut self, id: NodeId) -> Def {
+        //FIXME: this grabs the first valid resolution - should all users of this function ask for
+        //a specific namespace?
         self.resolver.get_resolution(id).map_or(Def::Err, |pr| {
             if pr.unresolved_segments() != 0 {
                 bug!("path not fully resolved: {:?}", pr);
@@ -575,6 +577,15 @@ impl<'a> LoweringContext<'a> {
         })
     }
 
+    fn expect_full_def_per_ns(&mut self, id: NodeId) -> PerNS<Def> {
+        self.resolver.get_all_resolutions(id).map(|res| res.map_or(Def::Err, |pr| {
+            if pr.unresolved_segments() != 0 {
+                bug!("path not fully resolved: {:?}", pr);
+            }
+            pr.base_def()
+        }))
+    }
+
     fn diagnostic(&self) -> &errors::Handler {
         self.sess.diagnostic()
     }
@@ -1074,7 +1085,7 @@ impl<'a> LoweringContext<'a> {
             TyKind::ImplicitSelf => hir::TyPath(hir::QPath::Resolved(
                 None,
                 P(hir::Path {
-                    def: self.expect_full_def(t.id),
+                    defs: self.expect_full_def_per_ns(t.id),
                     segments: hir_vec![hir::PathSegment::from_name(keywords::SelfType.name())],
                     span: t.span,
                 }),
@@ -1164,7 +1175,7 @@ impl<'a> LoweringContext<'a> {
                             None,
                             P(hir::Path {
                                 span,
-                                def: Def::TyParam(DefId::local(def_index)),
+                                defs: Def::TyParam(DefId::local(def_index)).into(),
                                 segments: hir_vec![hir::PathSegment::from_name(name)],
                             }),
                         ))
@@ -1383,13 +1394,17 @@ impl<'a> LoweringContext<'a> {
         let qself_position = qself.as_ref().map(|q| q.position);
         let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
 
-        let resolution = self.resolver
-            .get_resolution(id)
-            .unwrap_or(PathResolution::new(Def::Err));
+        let resolutions = self.resolver
+            .get_all_resolutions(id)
+            .map(|res| res.unwrap_or(PathResolution::new(Def::Err)));
+
+        //FIXME(misdreavus): when constructing the segments below, the code assumes only one
+        //resolution/def
+        let first_res = self.resolver.get_resolution(id).unwrap_or(PathResolution::new(Def::Err));
 
-        let proj_start = p.segments.len() - resolution.unresolved_segments();
+        let proj_start = p.segments.len() - first_res.unresolved_segments();
         let path = P(hir::Path {
-            def: resolution.base_def(),
+            defs: resolutions.map(|pr| pr.base_def()),
             segments: p.segments[..proj_start]
                 .iter()
                 .enumerate()
@@ -1410,7 +1425,7 @@ impl<'a> LoweringContext<'a> {
                         krate: def_id.krate,
                         index: this.def_key(def_id).parent.expect("missing parent"),
                     };
-                    let type_def_id = match resolution.base_def() {
+                    let type_def_id = match first_res.base_def() {
                         Def::AssociatedTy(def_id) if i + 2 == proj_start => {
                             Some(parent_def_id(self, def_id))
                         }
@@ -1427,7 +1442,7 @@ impl<'a> LoweringContext<'a> {
                         }
                         _ => None,
                     };
-                    let parenthesized_generic_args = match resolution.base_def() {
+                    let parenthesized_generic_args = match first_res.base_def() {
                         // `a::b::Trait(Args)`
                         Def::Trait(..) if i + 1 == proj_start => ParenthesizedGenericArgs::Ok,
                         // `a::b::Trait(Args)::TraitItem`
@@ -1477,7 +1492,7 @@ impl<'a> LoweringContext<'a> {
 
         // Simple case, either no projections, or only fully-qualified.
         // E.g. `std::mem::size_of` or `<I as Iterator>::Item`.
-        if resolution.unresolved_segments() == 0 {
+        if first_res.unresolved_segments() == 0 {
             return hir::QPath::Resolved(qself, path);
         }
 
@@ -1542,7 +1557,7 @@ impl<'a> LoweringContext<'a> {
         param_mode: ParamMode,
     ) -> hir::Path {
         hir::Path {
-            def: self.expect_full_def(id),
+            defs: self.expect_full_def_per_ns(id),
             segments: p.segments
                 .iter()
                 .map(|segment| {
@@ -2296,7 +2311,7 @@ impl<'a> LoweringContext<'a> {
                         });
 
                         if let Some(ref trait_ref) = trait_ref {
-                            if let Def::Trait(def_id) = trait_ref.path.def {
+                            if let Def::Trait(def_id) = trait_ref.path.defs.type_ns {
                                 this.trait_impls.entry(def_id).or_insert(vec![]).push(id);
                             }
                         }
@@ -2839,7 +2854,7 @@ impl<'a> LoweringContext<'a> {
                         None,
                         P(hir::Path {
                             span: ident.span,
-                            def,
+                            defs: def.into(),
                             segments: hir_vec![hir::PathSegment::from_name(ident.name)],
                         }),
                     )),
@@ -3820,7 +3835,7 @@ impl<'a> LoweringContext<'a> {
             None,
             P(hir::Path {
                 span,
-                def: Def::Local(binding),
+                defs: Def::Local(binding).into(),
                 segments: hir_vec![hir::PathSegment::from_name(id)],
             }),
         ));
@@ -4020,7 +4035,7 @@ impl<'a> LoweringContext<'a> {
         let node = match qpath {
             hir::QPath::Resolved(None, path) => {
                 // Turn trait object paths into `TyTraitObject` instead.
-                if let Def::Trait(_) = path.def {
+                if let Def::Trait(_) = path.defs.type_ns {
                     let principal = hir::PolyTraitRef {
                         bound_generic_params: hir::HirVec::new(),
                         trait_ref: hir::TraitRef {

src/librustc/hir/mod.rs

@@ -27,7 +27,7 @@ pub use self::UnOp::*;
 pub use self::UnsafeSource::*;
 pub use self::Visibility::{Public, Inherited};
 
-use hir::def::Def;
+use hir::def::{Def, PerNS};
 use hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
 use util::nodemap::{NodeMap, FxHashSet};
 use mir::mono::Linkage;
@@ -291,8 +291,10 @@ pub struct LifetimeDef {
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)]
 pub struct Path {
     pub span: Span,
-    /// The definition that the path resolved to.
-    pub def: Def,
+    /// The definitions that the path resolved to. Since the same path can reference items in
+    /// different namespaces, that information is stored here. Any namespaces without a resolution
+    /// will contain `Def::Err`.
+    pub defs: PerNS<Def>,
     /// The segments in the path: the things separated by `::`.
     pub segments: HirVec<PathSegment>,
 }

src/librustc/hir/pat_util.rs

@@ -65,10 +65,9 @@ impl hir::Pat {
             PatKind::Path(hir::QPath::Resolved(_, ref path)) |
             PatKind::TupleStruct(hir::QPath::Resolved(_, ref path), ..) |
             PatKind::Struct(hir::QPath::Resolved(_, ref path), ..) => {
-                match path.def {
-                    Def::Variant(..) | Def::VariantCtor(..) => true,
-                    _ => false
-                }
+                if let Def::Variant(..) = path.defs.type_ns { true }
+                else if let Def::VariantCtor(..) = path.defs.value_ns { true }
+                else { false }
             }
             PatKind::Slice(..) => true,
             _ => false
@@ -79,7 +78,7 @@ impl hir::Pat {
         match self.node {
             PatKind::Path(hir::QPath::TypeRelative(..)) => true,
             PatKind::Path(hir::QPath::Resolved(_, ref path)) => {
-                match path.def {
+                match path.defs.value_ns {
                     Def::Const(..) | Def::AssociatedConst(..) => true,
                     _ => false
                 }
@@ -158,10 +157,10 @@ impl hir::Pat {
                 PatKind::Path(hir::QPath::Resolved(_, ref path)) |
                 PatKind::TupleStruct(hir::QPath::Resolved(_, ref path), ..) |
                 PatKind::Struct(hir::QPath::Resolved(_, ref path), ..) => {
-                    match path.def {
-                        Def::Variant(id) |
-                        Def::VariantCtor(id, ..) => variants.push(id),
-                        _ => ()
+                    if let Def::Variant(id) = path.defs.type_ns {
+                        variants.push(id);
+                    } else if let Def::VariantCtor(id, ..) = path.defs.value_ns {
+                        variants.push(id);
                     }
                 }
                 _ => ()

src/librustc/ich/impls_hir.rs

@@ -170,7 +170,7 @@ impl_stable_hash_for!(struct hir::LifetimeDef {
 
 impl_stable_hash_for!(struct hir::Path {
     span,
-    def,
+    defs,
     segments
 });
 
@@ -1070,6 +1070,12 @@ impl_stable_hash_for!(enum hir::def::Def {
     Err
 });
 
+impl_stable_hash_for!(struct hir::def::PerNS<hir::def::Def> {
+    value_ns,
+    type_ns,
+    macro_ns
+});
+
 impl_stable_hash_for!(enum hir::Mutability {
     MutMutable,
     MutImmutable