Continue addressing review comments

Author: varkor

src/librustc/ich/impls_ty.rs

@@ -379,7 +379,6 @@ for ::mir::interpret::ConstValue<'gcx> {
                                           hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {
         use mir::interpret::ConstValue::*;
-        use mir::interpret::InferConst::*;
 
         mem::discriminant(self).hash_stable(hcx, hasher);
 
@@ -403,6 +402,8 @@ for ::mir::interpret::ConstValue<'gcx> {
                 param.hash_stable(hcx, hasher);
             }
             Infer(infer) => {
+                use ty::InferConst::*;
+
                 match infer {
                     Var(vid) => vid.hash_stable(hcx, hasher),
                     Fresh(i) => i.hash_stable(hcx, hasher),

src/librustc/infer/canonical/query_result.rs

@@ -36,7 +36,8 @@ use traits::{FulfillmentContext, TraitEngine};
 use traits::{Obligation, ObligationCause, PredicateObligation};
 use ty::fold::TypeFoldable;
 use ty::subst::{Kind, UnpackedKind};
-use ty::{self, CanonicalVar, Lift, TyCtxt};
+use ty::{self, CanonicalVar, Lift, TyCtxt, InferConst};
+use mir::interpret::ConstValue;
 
 impl<'cx, 'gcx, 'tcx> InferCtxtBuilder<'cx, 'gcx, 'tcx> {
     /// The "main method" for a canonicalized trait query. Given the
@@ -434,7 +435,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                     }
                 }
                 UnpackedKind::Const(_) => {
-                    if let &ty::ConstValue(ty::InferConst::Canonical(index)) = result_value {
+                    if let &ConstValue(InferConst::Canonical(index)) = result_value {
                         opt_values[index] = Some(*original_value);
                     }
                 }

src/librustc/infer/combine.rs

@@ -41,10 +41,10 @@ use super::type_variable::TypeVariableValue;
 
 use hir::def_id::DefId;
 use ty::{IntType, UintType};
-use ty::{self, Ty, TyCtxt, Const};
+use ty::{self, Ty, TyCtxt, Const, InferConst};
 use ty::error::{TypeError, ConstError};
 use ty::relate::{self, Relate, RelateResult, TypeRelation};
-use mir::interpret::{ConstValue, InferConst};
+use mir::interpret::ConstValue;
 use ty::subst::Substs;
 use traits::{Obligation, PredicateObligations};
 

src/librustc/infer/equate.rs

@@ -13,11 +13,11 @@ use super::{Subtype};
 
 use hir::def_id::DefId;
 
-use ty::{self, Ty, TyCtxt};
+use ty::{self, Ty, TyCtxt, InferConst};
 use ty::TyVar;
 use ty::subst::Substs;
 use ty::relate::{self, Relate, RelateResult, TypeRelation};
-use mir::interpret::{ConstValue, InferConst};
+use mir::interpret::ConstValue;
 
 /// Ensures `a` is made equal to `b`. Returns `a` on success.
 pub struct Equate<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {

src/librustc/infer/mod.rs

@@ -45,7 +45,7 @@ use self::region_constraints::{RegionConstraintCollector, RegionSnapshot};
 use self::region_constraints::{GenericKind, VerifyBound, RegionConstraintData, VarInfos};
 use self::lexical_region_resolve::LexicalRegionResolutions;
 use self::outlives::env::OutlivesEnvironment;
-use self::type_variable::TypeVariableOrigin;
+use self::type_variable::{TypeVariableOrigin, ConstVariableOrigin};
 use self::unify_key::ToType;
 
 pub mod anon_types;

src/librustc/infer/sub.rs

@@ -12,11 +12,11 @@ use super::SubregionOrigin;
 use super::combine::{CombineFields, RelationDir, const_unification_error};
 
 use traits::Obligation;
-use ty::{self, Ty, TyCtxt};
+use ty::{self, Ty, TyCtxt, InferConst};
 use ty::TyVar;
 use ty::fold::TypeFoldable;
 use ty::relate::{Cause, Relate, RelateResult, TypeRelation};
-use mir::interpret::{ConstValue, InferConst};
+use mir::interpret::ConstValue;
 use std::mem;
 
 /// Ensures `a` is made a subtype of `b`. Returns `a` on success.

src/librustc/infer/type_variable.rs

@@ -68,6 +68,14 @@ pub enum TypeVariableOrigin {
     Generalized(ty::TyVid),
 }
 
+/// Reasons to create a type inference variable
+// TODO(const_generics): move this somewhere more sensible
+#[derive(Copy, Clone, Debug)]
+pub enum ConstVariableOrigin {
+    ConstInference(Span),
+    ConstParameterDefinition(Span, InternedString),
+}
+
 pub type TypeVariableMap = FxHashMap<ty::TyVid, TypeVariableOrigin>;
 
 struct TypeVariableData {
@@ -462,4 +470,3 @@ impl ut::UnifyKey for ty::TyVid {
     fn from_index(i: u32) -> ty::TyVid { ty::TyVid { index: i } }
     fn tag() -> &'static str { "TyVid" }
 }
-

src/librustc/mir/interpret/mod.rs

@@ -13,7 +13,7 @@ pub use self::error::{
     FrameInfo, ConstEvalResult,
 };
 
-pub use self::value::{Scalar, ConstValue, ScalarMaybeUndef, InferConst};
+pub use self::value::{Scalar, ConstValue, ScalarMaybeUndef};
 
 use std::fmt;
 use mir;

src/librustc/mir/interpret/value.rs

@@ -3,7 +3,6 @@
 use ty::layout::{HasDataLayout, Size};
 use ty::subst::Substs;
 use hir::def_id::DefId;
-use ty::CanonicalVar;
 
 use super::{EvalResult, Pointer, PointerArithmetic, Allocation};
 
@@ -18,7 +17,7 @@ pub enum ConstValue<'tcx> {
     /// A const generic parameter.
     Param(ty::ParamConst),
     /// Infer the value of the const.
-    Infer(InferConst),
+    Infer(ty::InferConst),
     /// Used only for types with layout::abi::Scalar ABI and ZSTs
     ///
     /// Not using the enum `Value` to encode that this must not be `Undef`

src/librustc/ty/_match.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ty::{self, Ty, TyCtxt};
+use ty::{self, Ty, TyCtxt, InferConst};
 use ty::error::{TypeError, ConstError};
 use ty::relate::{self, Relate, TypeRelation, RelateResult};
-use mir::interpret::{ConstValue, InferConst};
+use mir::interpret::ConstValue;
 
 /// A type "A" *matches* "B" if the fresh types in B could be
 /// substituted with values so as to make it equal to A. Matching is