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 {

src/librustc_mir/build/mod.rs

@@ -45,11 +45,9 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t
         hir::map::NodeStructCtor(ctor) =>
             return create_constructor_shim(tcx, id, ctor),
 
-        _ => match tcx.hir.maybe_body_owned_by(id) {
+        x => match tcx.hir.maybe_body_owned_by(id) {
             Some(body) => body,
-            None => {
-                span_bug!(tcx.hir.span(id), "can't build MIR for {:?}", def_id)
-            }
+            None => span_bug!(tcx.hir.span(id), "can't build MIR for {:?} ({:?}", def_id, x),
         },
     };
 

src/librustc_typeck/collect.rs

@@ -1188,23 +1188,20 @@ fn type_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                             Def::Fn(def_id) => {
                                 let generics = tcx.generics_of(def_id);
                                 for param in &generics.params {
-                                    // if param.id == node_id {
-                                        // generics.param_def_id_to_index
-                                        return tcx.type_of(param.def_id);
-                                    // }
+                                    // TODO(const_generics): this should obviously pick the correct
+                                    // parameter, and not just the first one.
+                                    return tcx.type_of(param.def_id);
                                 }
-                                bug!("no such param");
+                                bug!("there was no generic parameter associated with the arg");
                             }
-                            x => bug!("other def {:?}", x),
+                            x => bug!("unexpected const parent path def {:?}", x),
                         }
                     }
-                    _ => bug!("other path"),
+                    x => bug!("unexpected const parent path {:?}", x),
                 }
             }
 
-            x => {
-                bug!("unexpected const parent in type_of_def_id(): {:?}", x);
-            }
+            x => bug!("unexpected const parent in type_of_def_id(): {:?}", x),
         },
 
         NodeGenericParam(param) => {

src/libsyntax/feature_gate.rs

@@ -429,8 +429,8 @@ declare_features! (
     // `existential type`
     (active, existential_type, "1.28.0", Some(34511), None),
 
-    // const generic types
-    (active, const_generics, "1.29.0", Some(44580), None),
+    // Const generic types
+    (active, const_generics, "1.30.0", Some(44580), None),
 
     // unstable #[target_feature] directives
     (active, arm_target_feature, "1.27.0", Some(44839), None),