Do some housekeeping

Author: varkor

src/librustc/hir/pat_util.rs

@@ -74,21 +74,6 @@ impl hir::Pat {
         }
     }
 
-    pub fn is_const(&self) -> bool {
-        match self.node {
-            PatKind::Path(hir::QPath::TypeRelative(..)) => true,
-            PatKind::Path(hir::QPath::Resolved(_, ref path)) => {
-                match path.def {
-                    Def::Const(..) |
-                    Def::ConstParam(..) |
-                    Def::AssociatedConst(..) => true,
-                    _ => false
-                }
-            }
-            _ => false
-        }
-    }
-
     /// Call `f` on every "binding" in a pattern, e.g., on `a` in
     /// `match foo() { Some(a) => (), None => () }`
     pub fn each_binding<F>(&self, mut f: F)

src/librustc/infer/combine.rs

@@ -149,7 +149,6 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
                 bug!("tried to combine ConstValue::Infer/ConstValue::Infer(InferConst::Var)")
             }
 
-
             (ConstValue::Infer(InferConst::Var(vid)), _) => {
                 self.unify_const_variable(a_is_expected, vid, b)
             }
@@ -592,7 +591,8 @@ pub fn const_unification_error<'tcx>(
 {
     let (a, b) = v;
     TypeError::ConstError(
-        ConstError::Mismatch(ty::relate::expected_found_bool(a_is_expected, &a, &b)))
+        ConstError::Mismatch(ty::relate::expected_found_bool(a_is_expected, &a, &b))
+    )
 }
 
 fn int_unification_error<'tcx>(a_is_expected: bool, v: (ty::IntVarValue, ty::IntVarValue))

src/librustc/infer/mod.rs

@@ -994,8 +994,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
-    /// Given a set of generics defined on a type or impl, returns a substitution mapping each
-    /// type/const/lifetime parameter to a fresh inference variable.
+    /// Given a set of generics defined on a type or impl, returns a substitution
+    /// mapping each generic parameter to a fresh inference variable.
     pub fn fresh_substs_for_item(&self,
                                  span: Span,
                                  def_id: DefId)

src/librustc/ty/_match.rs

@@ -101,7 +101,8 @@ impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Match<'a, 'gcx, 'tcx> {
 
             (ConstValue::Infer(_), _) | (_, ConstValue::Infer(_)) => {
                 Err(TypeError::ConstError(
-                    ConstError::Mismatch(relate::expected_found(self, &a, &b))))
+                    ConstError::Mismatch(relate::expected_found(self, &a, &b))
+                ))
             }
 
             _ => {

src/librustc/ty/fold.rs

@@ -128,7 +128,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
     }
 
     /// Indicates whether this value references only 'global'
-    /// types/lifetimes/consts that are the same regardless of what fn we are
+    /// generic params that are the same regardless of what fn we are
     /// in. This is used for caching.
     fn is_global(&self) -> bool {
         !self.has_type_flags(TypeFlags::HAS_FREE_LOCAL_NAMES)

src/librustc/ty/mod.rs

@@ -28,7 +28,6 @@ use middle::resolve_lifetime::ObjectLifetimeDefault;
 use mir::Mir;
 use mir::interpret::GlobalId;
 use mir::GeneratorLayout;
-// use mir::interpret::ConstValue;
 use session::CrateDisambiguator;
 use traits::{self, Reveal};
 use ty;

src/librustc/ty/structural_impls.rs

@@ -1165,9 +1165,9 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {
             ConstValue::Param(param) => ConstValue::Param(param),
             ConstValue::Infer(infer) => {
                 ConstValue::Infer(match infer {
-                    InferConst::Var(vid) =>InferConst::Var(vid),
-                    InferConst::Fresh(i) =>InferConst::Fresh(i),
-                    InferConst::Canonical(var) =>InferConst::Canonical(var),
+                    InferConst::Var(vid) => InferConst::Var(vid),
+                    InferConst::Fresh(i) => InferConst::Fresh(i),
+                    InferConst::Canonical(var) => InferConst::Canonical(var),
                 })
             }
         }

src/librustc/ty/subst.rs

@@ -277,7 +277,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
     }
 
     #[inline]
-    pub fn types(&'a self) -> impl DoubleEndedIterator<Item=Ty<'tcx>> + 'a {
+    pub fn types(&'a self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> + 'a {
         self.iter().filter_map(|k| {
             if let UnpackedKind::Type(ty) = k.unpack() {
                 Some(ty)
@@ -288,7 +288,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
     }
 
     #[inline]
-    pub fn regions(&'a self) -> impl DoubleEndedIterator<Item=ty::Region<'tcx>> + 'a {
+    pub fn regions(&'a self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> + 'a {
         self.iter().filter_map(|k| {
             if let UnpackedKind::Lifetime(lt) = k.unpack() {
                 Some(lt)
@@ -299,7 +299,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
     }
 
     #[inline]
-    pub fn consts(&'a self) -> impl DoubleEndedIterator<Item=&'tcx ty::Const<'tcx>> + 'a {
+    pub fn consts(&'a self) -> impl DoubleEndedIterator<Item = &'tcx ty::Const<'tcx>> + 'a {
         self.iter().filter_map(|k| {
             if let UnpackedKind::Const(ct) = k.unpack() {
                 Some(ct)

src/librustc_codegen_llvm/mir/constant.rs

@@ -156,8 +156,9 @@ impl FunctionCx<'a, 'll, 'tcx> {
                     promoted: None,
                 };
                 tcx.const_eval(param_env.and(cid))
-            },
-            // TODO(const_generics:param/infer)
+            }
+            ConstValue::Param(_) => bug!(),
+            ConstValue::Infer(_) => bug!(),
             _ => Ok(constant),
         }
     }

src/librustc_codegen_llvm/mir/operand.rs

@@ -90,7 +90,7 @@ impl OperandRef<'ll, 'tcx> {
 
         let val = match val.val {
             ConstValue::Unevaluated(..) => bug!(),
-            ConstValue::Param(_) => bug!(),
+            ConstValue::Param(_) => bug!("encountered a ConstValue::Param in codegen"),
             ConstValue::Infer(_) => bug!(),
             ConstValue::Scalar(x) => {
                 let scalar = match layout.abi {