Be more conservative with Def::ConstParam in general

Author: varkor

src/librustc/middle/dead.rs

@@ -75,7 +75,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
 
     fn handle_definition(&mut self, def: Def) {
         match def {
-            Def::ConstParam(_) | Def::Const(_) |
+            Def::Const(_) |
             Def::AssociatedConst(..) | Def::TyAlias(_) => {
                 self.check_def_id(def.def_id());
             }

src/librustc/middle/reachable.rs

@@ -126,7 +126,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReachableContext<'a, 'tcx> {
                             // If this path leads to a constant, then we need to
                             // recurse into the constant to continue finding
                             // items that are reachable.
-                            Def::Const(..) | Def::ConstParam(..) | Def::AssociatedConst(..) => {
+                            Def::Const(..) | Def::AssociatedConst(..) => {
                                 self.worklist.push(node_id);
                             }
 
@@ -321,8 +321,9 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
             hir_map::NodeTy(_) |
             hir_map::NodeMacroDef(_) => {}
             _ => {
-                bug!("found unexpected thingy in worklist: {}",
-                     self.tcx.hir.node_to_string(search_item))
+                bug!("found unexpected thingy in worklist: {} ({:?})",
+                     self.tcx.hir.node_to_string(search_item),
+                     node);
             }
         }
     }

src/librustc_mir/hair/pattern/mod.rs

@@ -681,13 +681,9 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
                   -> Pattern<'tcx> {
         let ty = self.tables.node_id_to_type(id);
         let def = self.tables.qpath_def(qpath, id);
-        let (is_associated_const, is_const_param) = match def {
-            Def::AssociatedConst(_) => (true, false),
-            Def::ConstParam(_) => (false, true),
-            _ => (false, false),
-        };
+        let is_associated_const = if let Def::AssociatedConst(_) = def { true } else { false };
         let kind = match def {
-            Def::ConstParam(def_id) | Def::Const(def_id) | Def::AssociatedConst(def_id) => {
+            Def::Const(def_id) | Def::AssociatedConst(def_id) => {
                 let substs = self.tables.node_substs(id);
                 match ty::Instance::resolve(
                     self.tcx,
@@ -716,8 +712,6 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
                     None => {
                         self.errors.push(if is_associated_const {
                             PatternError::AssociatedConstInPattern(span)
-                        } else if is_const_param {
-                            PatternError::ConstParamInPattern(span)
                         } else {
                             PatternError::StaticInPattern(span)
                         });

src/librustc_mir/interpret/eval_context.rs

@@ -569,8 +569,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             // Now mark those locals as dead that we do not want to initialize
             match self.tcx.describe_def(instance.def_id()) {
                 // statics and constants don't have `Storage*` statements, no need to look for them
-                Some(Def::Static(..)) | Some(Def::ConstParam(..)) |
-                Some(Def::Const(..)) | Some(Def::AssociatedConst(..)) => {},
+                Some(Def::Static(..)) | Some(Def::Const(..)) | Some(Def::AssociatedConst(..)) => {}
                 _ => {
                     trace!("push_stack_frame: {:?}: num_bbs: {}", span, mir.basic_blocks().len());
                     for block in mir.basic_blocks() {

src/librustc_typeck/check/_match.rs

@@ -60,7 +60,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             PatKind::Path(ref qpath) => {
                 let (def, _, _) = self.resolve_ty_and_def_ufcs(qpath, pat.id, pat.span);
                 match def {
-                    Def::ConstParam(..) | Def::Const(..) | Def::AssociatedConst(..) => false,
+                    Def::Const(..) | Def::AssociatedConst(..) => false,
                     _ => true,
                 }
             }

src/librustdoc/clean/mod.rs

@@ -2526,7 +2526,8 @@ impl Clean<Type> for hir::Ty {
                                     indices.types += 1;
                                 }
                                 hir::GenericParamKind::Const { .. } => {
-                                    let const_param_def = Def::ConstParam(cx.tcx.hir.local_def_id(param.id));
+                                    let const_param_def =
+                                        Def::ConstParam(cx.tcx.hir.local_def_id(param.id));
                                     let mut j = 0;
                                     let const_ = generic_args.args.iter().find_map(|arg| {
                                         match arg {