get rid of a couple sources of single-def-per-path

Author: QuietMisdreavus

src/librustc/hir/lowering.rs

@@ -149,12 +149,8 @@ pub trait Resolver {
     /// Resolve a hir path generated by the lowerer when expanding `for`, `if let`, etc.
     fn resolve_hir_path(&mut self, path: &mut hir::Path, is_value: bool);
 
-    /// Obtain the resolution for a node id. Prefers resolutions in Types, then Values, then
-    /// Macros.
-    fn get_resolution(&mut self, id: NodeId) -> Option<PathResolution>;
-
     /// Obtain resolutions for the given node id in all namespaces.
-    fn get_all_resolutions(&mut self, id: NodeId) -> PerNS<Option<PathResolution>>;
+    fn get_resolutions(&mut self, id: NodeId) -> PerNS<Option<PathResolution>>;
 
     /// We must keep the set of definitions up to date as we add nodes that weren't in the AST.
     /// This should only return `None` during testing.
@@ -566,19 +562,8 @@ impl<'a> LoweringContext<'a> {
         self.lower_node_id(self.sess.next_node_id())
     }
 
-    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);
-            }
-            pr.base_def()
-        })
-    }
-
-    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| {
+    fn expect_full_defs(&mut self, id: NodeId) -> PerNS<Def> {
+        self.resolver.get_resolutions(id).map(|res| res.map_or(Def::Err, |pr| {
             if pr.unresolved_segments() != 0 {
                 bug!("path not fully resolved: {:?}", pr);
             }
@@ -935,11 +920,12 @@ impl<'a> LoweringContext<'a> {
     fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
         match destination {
             Some((id, label)) => {
-                let target_id = if let Def::Label(loop_id) = self.expect_full_def(id) {
-                    Ok(self.lower_node_id(loop_id).node_id)
-                } else {
-                    Err(hir::LoopIdError::UnresolvedLabel)
-                };
+                let target_id =
+                    if let Def::Label(loop_id) = self.expect_full_defs(id).value_ns {
+                        Ok(self.lower_node_id(loop_id).node_id)
+                    } else {
+                        Err(hir::LoopIdError::UnresolvedLabel)
+                    };
                 hir::Destination {
                     label: self.lower_label(Some(label)),
                     target_id,
@@ -1085,7 +1071,7 @@ impl<'a> LoweringContext<'a> {
             TyKind::ImplicitSelf => hir::TyPath(hir::QPath::Resolved(
                 None,
                 P(hir::Path {
-                    defs: self.expect_full_def_per_ns(t.id),
+                    defs: self.expect_full_defs(t.id),
                     segments: hir_vec![hir::PathSegment::from_name(keywords::SelfType.name())],
                     span: t.span,
                 }),
@@ -1395,12 +1381,15 @@ impl<'a> LoweringContext<'a> {
         let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
 
         let resolutions = self.resolver
-            .get_all_resolutions(id)
+            .get_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));
+        assert!(resolutions.into_iter().filter(|pr| pr.base_def() != Def::Err).count() <= 1,
+                "attempting to lower a QPath resolving to more than one Def: {:?} {:?}", id, p);
+
+        let first_res = resolutions.into_iter()
+                                   .find(|pr| pr.base_def() != Def::Err)
+                                   .unwrap_or(PathResolution::new(Def::Err));
 
         let proj_start = p.segments.len() - first_res.unresolved_segments();
         let path = P(hir::Path {
@@ -1557,7 +1546,7 @@ impl<'a> LoweringContext<'a> {
         param_mode: ParamMode,
     ) -> hir::Path {
         hir::Path {
-            defs: self.expect_full_def_per_ns(id),
+            defs: self.expect_full_defs(id),
             segments: p.segments
                 .iter()
                 .map(|segment| {
@@ -1950,7 +1939,8 @@ impl<'a> LoweringContext<'a> {
                                     && bound_pred.bound_generic_params.is_empty() =>
                             {
                                 if let Some(Def::TyParam(def_id)) = self.resolver
-                                    .get_resolution(bound_pred.bounded_ty.id)
+                                    .get_resolutions(bound_pred.bounded_ty.id)
+                                    .type_ns
                                     .map(|d| d.base_def())
                                 {
                                     if let Some(node_id) =
@@ -2836,10 +2826,11 @@ impl<'a> LoweringContext<'a> {
         let node = match p.node {
             PatKind::Wild => hir::PatKind::Wild,
             PatKind::Ident(ref binding_mode, ident, ref sub) => {
-                match self.resolver.get_resolution(p.id).map(|d| d.base_def()) {
+                match self.resolver.get_resolutions(p.id).map(|d| d.map(|d| d.base_def())) {
                     // `None` can occur in body-less function signatures
-                    def @ None | def @ Some(Def::Local(_)) => {
-                        let canonical_id = match def {
+                    defs @ PerNS { value_ns: None, .. } |
+                    defs @ PerNS { value_ns: Some(Def::Local(_)), .. } => {
+                        let canonical_id = match defs.value_ns {
                             Some(Def::Local(id)) => id,
                             _ => p.id,
                         };
@@ -2850,11 +2841,11 @@ impl<'a> LoweringContext<'a> {
                             sub.as_ref().map(|x| self.lower_pat(x)),
                         )
                     }
-                    Some(def) => hir::PatKind::Path(hir::QPath::Resolved(
+                    defs => hir::PatKind::Path(hir::QPath::Resolved(
                         None,
                         P(hir::Path {
                             span: ident.span,
-                            defs: def.into(),
+                            defs: defs.map(|d| d.unwrap_or(Def::Err)),
                             segments: hir_vec![hir::PathSegment::from_name(ident.name)],
                         }),
                     )),

src/librustc_resolve/lib.rs

@@ -1476,21 +1476,7 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
         path
     }
 
-    fn get_resolution(&mut self, id: NodeId) -> Option<PathResolution> {
-        //for people calling this one, they don't necessarily care which namespace it's in, so just
-        //have a preference but check all of them
-        if let Some(def) = self.def_map.get(&id) {
-            for ns in [TypeNS, ValueNS, MacroNS].iter().cloned() {
-                if let Some(res) = def[ns] {
-                    return Some(res);
-                }
-            }
-        }
-
-        None
-    }
-
-    fn get_all_resolutions(&mut self, id: NodeId) -> PerNS<Option<PathResolution>> {
+    fn get_resolutions(&mut self, id: NodeId) -> PerNS<Option<PathResolution>> {
         self.def_map.get(&id).cloned().unwrap_or_default()
     }
 
@@ -2433,9 +2419,9 @@ impl<'a> Resolver<'a> {
 
         pat.walk(&mut |pat| {
             if let PatKind::Ident(binding_mode, ident, ref sub_pat) = pat.node {
-                //FIXME(misdreavus): `get_resolution` is the "i don't care what namespace" version,
-                //is that valid?
-                if sub_pat.is_some() || match self.get_resolution(pat.id).map(|res| res.base_def()) {
+                if sub_pat.is_some() || match self.get_resolutions(pat.id)
+                                                  .value_ns
+                                                  .map(|res| res.base_def()) {
                     Some(Def::Local(..)) => true,
                     _ => false,
                 } {
@@ -3605,7 +3591,7 @@ impl<'a> Resolver<'a> {
         if filter_fn(Def::Local(ast::DUMMY_NODE_ID)) {
             if let Some(node_id) = self.current_self_type.as_ref().and_then(extract_node_id) {
                 // Look for a field with the same name in the current self_type.
-                if let Some(resolution) = self.get_resolution(node_id) {
+                if let Some(resolution) = self.get_resolutions(node_id).type_ns {
                     match resolution.base_def() {
                         Def::Struct(did) | Def::Union(did)
                                 if resolution.unresolved_segments() == 0 => {