Address review comments and add notes

Author: varkor

src/librustc/hir/def.rs

@@ -60,13 +60,13 @@ pub enum Def {
     AssociatedExistential(DefId),
     PrimTy(hir::PrimTy),
     TyParam(DefId),
-    ConstParam(DefId),
     SelfTy(Option<DefId> /* trait */, Option<DefId> /* impl */),
     ToolMod, // e.g. `rustfmt` in `#[rustfmt::skip]`
 
     // Value namespace
     Fn(DefId),
     Const(DefId),
+    ConstParam(DefId),
     Static(DefId, bool /* is_mutbl */),
     StructCtor(DefId, CtorKind), // DefId refers to NodeId of the struct's constructor
     VariantCtor(DefId, CtorKind),

src/librustc/hir/lowering.rs

@@ -2266,6 +2266,7 @@ impl<'a> LoweringContext<'a> {
                            mut itctx: ImplTraitContext)
                            -> hir::GenericParam {
         let mut bounds = self.lower_param_bounds(&param.bounds, itctx.reborrow());
+        // TODO(const_generics): only create `hir::GenericParam` once.
         match param.kind {
             GenericParamKind::Lifetime => {
                 let was_collecting_in_band = self.is_collecting_in_band_lifetimes;

src/librustc/hir/map/mod.rs

@@ -241,11 +241,6 @@ impl<'hir> MapEntry<'hir> {
                 }
             }
 
-            EntryGenericParam(_, _, _) => {
-                // TODO(const_generics): defaults
-                None
-            }
-
             _ => None
         }
     }

src/librustc/hir/mod.rs

@@ -1303,7 +1303,7 @@ pub enum BodyOwnerKind {
 /// These are usually found nested inside types (e.g. array lengths)
 /// or expressions (e.g. repeat counts), and also used to define
 /// explicit discriminant values for enum variants.
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)]
 pub struct AnonConst {
     pub id: NodeId,
     pub hir_id: HirId,

src/librustc/infer/canonical/query_result.rs

@@ -434,7 +434,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                     }
                 }
                 UnpackedKind::Const(_) => {
-                    unimplemented!() // TODO(const_generics)
+                    if let &ty::ConstValue(ty::InferConst::Canonical(index)) = result_value {
+                        opt_values[index] = Some(*original_value);
+                    }
                 }
             }
         }

src/librustc/infer/combine.rs

@@ -170,14 +170,14 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
     fn unify_const_variable(&self,
                             vid_is_expected: bool,
                             vid: ty::ConstVid,
-                            val: ty::ConstVarValue)
+                            val: &'tcx ty::Const<'tcx>)
                             -> RelateResult<'tcx, &'tcx Const<'tcx>>
     {
         self.const_unification_table
             .borrow_mut()
             .unify_var_value(vid, Some(val))
             .map_err(|e| const_unification_error(vid_is_expected, e))?;
-        Ok(self.tcx.mk_mach_const(val))
+        Ok(val)
     }
 
     fn unify_integral_variable(&self,
@@ -574,8 +574,10 @@ impl<'tcx, T:Clone + PartialEq> RelateResultCompare<'tcx, T> for RelateResult<'t
     }
 }
 
-pub fn const_unification_error<'tcx>(a_is_expected: bool, v: (ty::ConstVarValue, ty::ConstVarValue))
-                                     -> TypeError<'tcx>
+pub fn const_unification_error<'tcx>(
+    a_is_expected: bool,
+    v: (&'tcx ty::Const<'tcx>, &'tcx ty::Const<'tcx>)
+) -> TypeError<'tcx>
 {
     let (a, b) = v;
     TypeError::ConstError(

src/librustc/infer/equate.rs

@@ -112,6 +112,7 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
 
     fn consts(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>)
         -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
+        // TODO(const_generics): missing handling for when only one side is an InferVar
         debug!("{}.consts({:?}, {:?})", self.tag(), a, b);
         if a == b { return Ok(a); }
 

src/librustc/infer/mod.rs

@@ -902,9 +902,12 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         self.tcx.mk_ty_var(self.next_ty_var_id(true, origin))
     }
 
-    pub fn next_const_var(&self, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
-        // TODO(const_generics): do we need this function?
-        self.tcx.mk_const_var(self.next_const_var_id(), ty)
+    pub fn next_const_var(
+        &self,
+        ty: Ty<'tcx>,
+        origin: ConstVariableOrigin
+    ) -> &'tcx ty::Const<'tcx> {
+        self.tcx.mk_const_var(self.next_const_var_id(origin), ty)
     }
 
     pub fn next_const_var_id(&self) -> ConstVid {

src/librustc/infer/region_constraints/mod.rs

@@ -149,7 +149,6 @@ pub struct Verify<'tcx> {
     pub bound: VerifyBound<'tcx>,
 }
 
-//TODO:const generics?
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum GenericKind<'tcx> {
     Param(ty::ParamTy),

src/librustc/infer/sub.rs

@@ -146,6 +146,7 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
 
     fn consts(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>)
         -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
+        // TODO(const_generics): missing handling for when only one side is an InferVar
         debug!("{}.consts({:?}, {:?})", self.tag(), a, b);
         if a == b { return Ok(a); }