stop assuming which namespace a thing has if we can assume there's just one

QuietMisdreavus · QuietMisdreavus · commit 329d89211765 · 2018-06-07T17:20:43.000-05:00
diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs
@@ -17,6 +17,7 @@ use hir;
 use ty;
 
 use std::iter::{once, Once, Chain};
+use std::fmt::Debug;
 
 use self::Namespace::*;
 
@@ -160,6 +161,14 @@ impl<T> PerNS<Option<T>> {
     pub fn is_empty(&self) -> bool {
         self.value_ns.is_none() && self.type_ns.is_none() && self.macro_ns.is_none()
     }
+
+    pub fn assert_single_ns(self) -> Option<T> where T: Debug {
+        let mut res = self.into_iter().filter_map(|it| it).collect::<Vec<_>>();
+        if res.len() > 1 {
+            bug!("single item was requested but multiple were available: {:?}", res);
+        }
+        res.pop()
+    }
 }
 
 impl PerNS<Def> {
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -921,7 +921,7 @@ impl<'a> LoweringContext<'a> {
         match destination {
             Some((id, label)) => {
                 let target_id =
-                    if let Def::Label(loop_id) = self.expect_full_defs(id).value_ns {
+                    if let Def::Label(loop_id) = self.expect_full_defs(id).assert_single_ns() {
                         Ok(self.lower_node_id(loop_id).node_id)
                     } else {
                         Err(hir::LoopIdError::UnresolvedLabel)
@@ -1940,7 +1940,7 @@ impl<'a> LoweringContext<'a> {
                             {
                                 if let Some(Def::TyParam(def_id)) = self.resolver
                                     .get_resolutions(bound_pred.bounded_ty.id)
-                                    .type_ns
+                                    .assert_single_ns()
                                     .map(|d| d.base_def())
                                 {
                                     if let Some(node_id) =
@@ -2301,7 +2301,7 @@ impl<'a> LoweringContext<'a> {
                         });
 
                         if let Some(ref trait_ref) = trait_ref {
-                            if let Def::Trait(def_id) = trait_ref.path.defs.type_ns {
+                            if let Def::Trait(def_id) = trait_ref.path.defs.assert_single_ns() {
                                 this.trait_impls.entry(def_id).or_insert(vec![]).push(id);
                             }
                         }
@@ -2830,7 +2830,7 @@ impl<'a> LoweringContext<'a> {
                     // `None` can occur in body-less function signatures
                     defs @ PerNS { value_ns: None, .. } |
                     defs @ PerNS { value_ns: Some(Def::Local(_)), .. } => {
-                        let canonical_id = match defs.value_ns {
+                        let canonical_id = match defs.assert_single_ns() {
                             Some(Def::Local(id)) => id,
                             _ => p.id,
                         };
@@ -4026,7 +4026,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.defs.type_ns {
+                if let Def::Trait(_) = path.defs.assert_single_ns() {
                     let principal = hir::PolyTraitRef {
                         bound_generic_params: hir::HirVec::new(),
                         trait_ref: hir::TraitRef {
diff --git a/src/librustc/hir/pat_util.rs b/src/librustc/hir/pat_util.rs
@@ -65,8 +65,8 @@ impl hir::Pat {
             PatKind::Path(hir::QPath::Resolved(_, ref path)) |
             PatKind::TupleStruct(hir::QPath::Resolved(_, ref path), ..) |
             PatKind::Struct(hir::QPath::Resolved(_, ref path), ..) => {
-                if let Def::Variant(..) = path.defs.type_ns { true }
-                else if let Def::VariantCtor(..) = path.defs.value_ns { true }
+                if let Def::Variant(..) = path.defs.assert_single_ns() { true }
+                else if let Def::VariantCtor(..) = path.defs.assert_single_ns() { true }
                 else { false }
             }
             PatKind::Slice(..) => true,
@@ -78,7 +78,7 @@ impl hir::Pat {
         match self.node {
             PatKind::Path(hir::QPath::TypeRelative(..)) => true,
             PatKind::Path(hir::QPath::Resolved(_, ref path)) => {
-                match path.defs.value_ns {
+                match path.defs.assert_single_ns() {
                     Def::Const(..) | Def::AssociatedConst(..) => true,
                     _ => false
                 }
@@ -157,9 +157,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), ..) => {
-                    if let Def::Variant(id) = path.defs.type_ns {
+                    if let Def::Variant(id) = path.defs.assert_single_ns() {
                         variants.push(id);
-                    } else if let Def::VariantCtor(id, ..) = path.defs.value_ns {
+                    } else if let Def::VariantCtor(id, ..) = path.defs.assert_single_ns() {
                         variants.push(id);
                     }
                 }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -458,7 +458,7 @@ fn visit_expr<'a, 'tcx>(ir: &mut IrMaps<'a, 'tcx>, expr: &'tcx Expr) {
       // live nodes required for uses or definitions of variables:
       hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
         debug!("expr {}: path that leads to {:?}", expr.id, path.defs);
-        if let Def::Local(..) = path.defs.value_ns {
+        if let Def::Local(..) = path.defs.assert_single_ns() {
             ir.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
         }
         intravisit::walk_expr(ir, expr);
@@ -1268,7 +1268,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
     fn access_path(&mut self, hir_id: HirId, path: &hir::Path, succ: LiveNode, acc: u32)
                    -> LiveNode {
-        match path.defs.value_ns {
+        match path.defs.assert_single_ns() {
           Def::Local(nid) => {
             self.access_var(hir_id, nid, succ, acc, path.span)
           }
@@ -1445,7 +1445,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
     fn check_place(&mut self, expr: &'tcx Expr) {
         match expr.node {
             hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
-                if let Def::Local(nid) = path.defs.value_ns {
+                if let Def::Local(nid) = path.defs.assert_single_ns() {
                     // Assignment to an immutable variable or argument: only legal
                     // if there is no later assignment. If this local is actually
                     // mutable, then check for a reassignment to flag the mutability
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
@@ -348,7 +348,7 @@ impl<'a, 'tcx: 'a> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a,
                     self.worklist.push(impl_item_ref.id.node_id);
                 }
 
-                let trait_def_id = match trait_ref.path.defs.type_ns {
+                let trait_def_id = match trait_ref.path.defs.assert_single_ns() {
                     Def::Trait(def_id) => def_id,
                     _ => unreachable!()
                 };
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -1230,7 +1230,7 @@ fn object_lifetime_defaults_for_item(
                 }
 
                 let def = match data.bounded_ty.node {
-                    hir::TyPath(hir::QPath::Resolved(None, ref path)) => path.defs.type_ns,
+                    hir::TyPath(hir::QPath::Resolved(None, ref path)) => path.defs.assert_single_ns(),
                     _ => continue,
                 };
 
@@ -1821,12 +1821,12 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                 // to the way elision rules were originally specified.
                 let impl_self = impl_self.map(|ty| &ty.node);
                 if let Some(&hir::TyPath(hir::QPath::Resolved(None, ref path))) = impl_self {
-                    match path.defs.type_ns {
+                    match path.defs.assert_single_ns() {
                         // Whitelist the types that unambiguously always
                         // result in the same type constructor being used
                         // (it can't differ between `Self` and `self`).
                         Def::Struct(_) | Def::Union(_) | Def::Enum(_) | Def::PrimTy(_) => {
-                            return def == path.defs.type_ns
+                            return def == path.defs.assert_single_ns()
                         }
                         _ => {}
                     }
@@ -1837,7 +1837,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
 
             if let hir::TyRptr(lifetime_ref, ref mt) = inputs[0].node {
                 if let hir::TyPath(hir::QPath::Resolved(None, ref path)) = mt.ty.node {
-                    if is_self_ty(path.defs.type_ns) {
+                    if is_self_ty(path.defs.assert_single_ns()) {
                         if let Some(&lifetime) = self.map.defs.get(&lifetime_ref.id) {
                             let scope = Scope::Elision {
                                 elide: Elide::Exact(lifetime),
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
@@ -738,7 +738,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
             // individually as it's possible to have a stable trait with unstable
             // items.
             hir::ItemImpl(.., Some(ref t), _, ref impl_item_refs) => {
-                if let Def::Trait(trait_did) = t.path.defs.type_ns {
+                if let Def::Trait(trait_did) = t.path.defs.assert_single_ns() {
                     for impl_item_ref in impl_item_refs {
                         let impl_item = self.tcx.hir.impl_item(impl_item_ref.id);
                         let trait_item_def_id = self.tcx.associated_items(trait_did)
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -271,7 +271,7 @@ impl Visibility {
         match *visibility {
             hir::Public => Visibility::Public,
             hir::Visibility::Crate(_) => Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)),
-            hir::Visibility::Restricted { ref path, .. } => match path.defs.type_ns {
+            hir::Visibility::Restricted { ref path, .. } => match path.defs.assert_single_ns() {
                 // If there is no resolution, `resolve` will have already reported an error, so
                 // assume that the visibility is public to avoid reporting more privacy errors.
                 Def::Err => Visibility::Public,
diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs
@@ -401,7 +401,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals {
     fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
         // Lint for constants that look like binding identifiers (#7526)
         if let PatKind::Path(hir::QPath::Resolved(None, ref path)) = p.node {
-            if let Def::Const(..) = path.defs.value_ns {
+            if let Def::Const(..) = path.defs.assert_single_ns() {
                 if path.segments.len() == 1 {
                     NonUpperCaseGlobals::check_upper_case(cx,
                                                           "constant in pattern",
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -413,7 +413,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
             hir::ItemImpl(.., Some(ref trait_ref), _, ref impl_item_refs) => {
                 // If the trait is private, add the impl items to private_traits so they don't get
                 // reported for missing docs.
-                let real_trait = trait_ref.path.defs.type_ns.def_id();
+                let real_trait = trait_ref.path.defs.assert_single_ns().def_id();
                 if let Some(node_id) = cx.tcx.hir.as_local_node_id(real_trait) {
                     match cx.tcx.hir.find(node_id) {
                         Some(hir_map::NodeItem(item)) => {
@@ -1391,7 +1391,7 @@ impl TypeAliasBounds {
                 // If this is a type variable, we found a `T::Assoc`.
                 match ty.node {
                     hir::TyPath(hir::QPath::Resolved(None, ref path)) => {
-                        match path.defs.type_ns {
+                        match path.defs.assert_single_ns() {
                             Def::TyParam(_) => true,
                             _ => false
                         }
diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs
@@ -241,7 +241,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
                 let adt_data = if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = fun.node {
                     // Tuple-like ADTs are represented as ExprCall. We convert them here.
                     expr_ty.ty_adt_def().and_then(|adt_def| {
-                        match path.defs.value_ns {
+                        match path.defs.assert_single_ns() {
                             Def::VariantCtor(variant_id, CtorKind::Fn) => {
                                 Some((adt_def, adt_def.variant_index_with_id(variant_id)))
                             }
@@ -436,7 +436,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
                         }
                         AdtKind::Enum => {
                             let def = match *qpath {
-                                hir::QPath::Resolved(_, ref path) => path.defs.type_ns,
+                                hir::QPath::Resolved(_, ref path) => path.defs.assert_single_ns(),
                                 hir::QPath::TypeRelative(..) => Def::Err,
                             };
                             match def {
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -1134,7 +1134,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
                 let not_private_trait =
                     trait_ref.as_ref().map_or(true, // no trait counts as public trait
                                               |tr| {
-                        let did = tr.path.defs.type_ns.def_id();
+                        let did = tr.path.defs.assert_single_ns().def_id();
 
                         if let Some(node_id) = self.tcx.hir.as_local_node_id(did) {
                             self.trait_is_public(node_id)
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -2420,7 +2420,7 @@ impl<'a> Resolver<'a> {
         pat.walk(&mut |pat| {
             if let PatKind::Ident(binding_mode, ident, ref sub_pat) = pat.node {
                 if sub_pat.is_some() || match self.get_resolutions(pat.id)
-                                                  .value_ns
+                                                  .assert_single_ns()
                                                   .map(|res| res.base_def()) {
                     Some(Def::Local(..)) => true,
                     _ => false,
@@ -3591,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_resolutions(node_id).type_ns {
+                if let Some(resolution) = self.get_resolutions(node_id).assert_single_ns() {
                     match resolution.base_def() {
                         Def::Struct(did) | Def::Union(did)
                                 if resolution.unresolved_segments() == 0 => {
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -367,7 +367,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
     /// Get the DefId of the given trait ref. It _must_ actually be a trait.
     fn trait_def_id(&self, trait_ref: &hir::TraitRef) -> DefId {
         let path = &trait_ref.path;
-        match path.defs.type_ns {
+        match path.defs.assert_single_ns() {
             Def::Trait(trait_def_id) => trait_def_id,
             Def::TraitAlias(alias_def_id) => alias_def_id,
             Def::Err => {
@@ -1008,7 +1008,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
                path.defs, opt_self_ty, path.segments);
 
         let span = path.span;
-        match path.defs.type_ns {
+        match path.defs.assert_single_ns() {
             Def::Enum(did) | Def::TyAlias(did) | Def::Struct(did) |
             Def::Union(did) | Def::TyForeign(did) => {
                 assert_eq!(opt_self_ty, None);
@@ -1130,7 +1130,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
                 let ty = self.ast_ty_to_ty(qself);
 
                 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
-                    path.defs.type_ns
+                    path.defs.assert_single_ns()
                 } else {
                     Def::Err
                 };
@@ -1327,7 +1327,7 @@ fn split_auto_traits<'a, 'b, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
 {
     let (auto_traits, trait_bounds): (Vec<_>, _) = trait_bounds.iter().partition(|bound| {
         // Checks whether `trait_did` is an auto trait and adds it to `auto_traits` if so.
-        match bound.trait_ref.path.defs.type_ns {
+        match bound.trait_ref.path.defs.assert_single_ns() {
             Def::Trait(trait_did) if tcx.trait_is_auto(trait_did) => {
                 true
             }
@@ -1336,7 +1336,7 @@ fn split_auto_traits<'a, 'b, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
     });
 
     let auto_traits = auto_traits.into_iter().map(|tr| {
-        if let Def::Trait(trait_did) = tr.trait_ref.path.defs.type_ns {
+        if let Def::Trait(trait_did) = tr.trait_ref.path.defs.assert_single_ns() {
             trait_did
         } else {
             unreachable!()
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
@@ -822,7 +822,7 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                 hir::intravisit::walk_ty(self, ty);
                                 match ty.node {
                                     hir::TyPath(hir::QPath::Resolved(None, ref path)) => {
-                                        if let hir::def::Def::TyParam(def_id) = path.defs.type_ns {
+                                        if let hir::def::Def::TyParam(def_id) = path.defs.assert_single_ns() {
                                             if def_id == self.1 {
                                                 self.0 = Some(ty.span);
                                             }
diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
@@ -212,7 +212,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     /// ```
     fn can_use_as_ref(&self, expr: &hir::Expr) -> Option<(Span, &'static str, String)> {
         if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = expr.node {
-            if let hir::def::Def::Local(id) = path.defs.value_ns {
+            if let hir::def::Def::Local(id) = path.defs.assert_single_ns() {
                 let parent = self.tcx.hir.get_parent_node(id);
                 if let Some(NodeExpr(hir::Expr {
                     id,
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
@@ -260,7 +260,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                             }
                             hir::ExprPath(ref qpath) => {  // local binding
                                 if let &hir::QPath::Resolved(_, ref path) = &qpath {
-                                    if let hir::def::Def::Local(node_id) = path.defs.value_ns {
+                                    if let hir::def::Def::Local(node_id) = path.defs.assert_single_ns() {
                                         let span = tcx.hir.span(node_id);
                                         let snippet = tcx.sess.codemap().span_to_snippet(span)
                                             .unwrap();
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -348,7 +348,7 @@ impl<'a, 'tcx: 'a> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a,`
`348`	`348`	`self.worklist.push(impl_item_ref.id.node_id);`
`349`	`349`	`}`
`350`	`350`
`351`		`- let trait_def_id = match trait_ref.path.defs.type_ns {`
	`351`	`+ let trait_def_id = match trait_ref.path.defs.assert_single_ns() {`
`352`	`352`	`Def::Trait(def_id) => def_id,`
`353`	`353`	`_ => unreachable!()`
`354`	`354`	`};`