Make rustc check

varkor · varkor · commit 0fd722172d93 · 2018-08-23T18:55:19.000+01:00
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
@@ -149,7 +149,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::RegionVid {
     }
 }
 
-impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::ConstVid {
+impl<'gcx, 'tcx> HashStable<StableHashingContext<'gcx>> for ty::ConstVid<'tcx> {
     #[inline]
     fn hash_stable<W: StableHasherResult>(&self,
                                           hcx: &mut StableHashingContext<'gcx>,
diff --git a/src/librustc/infer/canonical/query_result.rs b/src/librustc/infer/canonical/query_result.rs
@@ -434,8 +434,8 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                         opt_values[index] = Some(*original_value);
                     }
                 }
-                UnpackedKind::Const(_) => {
-                    if let &ConstValue(InferConst::Canonical(index)) = result_value {
+                UnpackedKind::Const(result_value) => {
+                    if let ConstValue::Infer(InferConst::Canonical(index)) = result_value.val {
                         opt_values[index] = Some(*original_value);
                     }
                 }
diff --git a/src/librustc/infer/combine.rs b/src/librustc/infer/combine.rs
@@ -153,12 +153,12 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
             }
 
 
-            (ConstValue::Infer(InferConst::Var(vid)), v) => {
-                self.unify_const_variable(a_is_expected, vid, v)
+            (ConstValue::Infer(InferConst::Var(vid)), _) => {
+                self.unify_const_variable(a_is_expected, vid, b)
             }
 
-            (v, ConstValue::Infer(InferConst::Var(vid))) => {
-                self.unify_const_variable(!a_is_expected, vid, v)
+            (_, ConstValue::Infer(InferConst::Var(vid))) => {
+                self.unify_const_variable(!a_is_expected, vid, a)
             }
 
             _ => {
@@ -169,8 +169,8 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
 
     fn unify_const_variable(&self,
                             vid_is_expected: bool,
-                            vid: ty::ConstVid,
-                            val: &'tcx ty::Const<'tcx>)
+                            vid: ty::ConstVid<'tcx>,
+                            val: &'tcx Const<'tcx>)
                             -> RelateResult<'tcx, &'tcx Const<'tcx>>
     {
         self.const_unification_table
diff --git a/src/librustc/infer/equate.rs b/src/librustc/infer/equate.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use super::combine::{CombineFields, RelationDir, const_unification_error};
-use super::{Subtype};
+use super::{Subtype, replace_const_if_possible};
 
 use hir::def_id::DefId;
 
@@ -117,8 +117,8 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         if a == b { return Ok(a); }
 
         let infcx = self.fields.infcx;
-        let a = infcx.const_unification_table.borrow_mut().replace_if_possible(a);
-        let b = infcx.const_unification_table.borrow_mut().replace_if_possible(b);
+        let a = replace_const_if_possible(infcx.const_unification_table.borrow_mut(), a);
+        let b = replace_const_if_possible(infcx.const_unification_table.borrow_mut(), b);
         match (a.val, b.val) {
             (ConstValue::Infer(InferConst::Var(a_vid)),
              ConstValue::Infer(InferConst::Var(b_vid))) => {
@@ -130,11 +130,11 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
                 Ok(a)
             }
 
-            (ConstValue::Infer(InferConst::Var(a_vid)), _) => {
+            (ConstValue::Infer(InferConst::Var(_)), _) => {
                 Ok(a)
             }
 
-            (_, ConstValue::Infer(InferConst::Var(b_vid))) => {
+            (_, ConstValue::Infer(InferConst::Var(_))) => {
                 Ok(a)
             }
 
@@ -153,3 +153,5 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         self.fields.higher_ranked_sub(b, a, self.a_is_expected)
     }
 }
+
+
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
@@ -23,7 +23,7 @@ use middle::region;
 use middle::lang_items;
 use ty::subst::{Kind, Substs};
 use ty::{TyVid, IntVid, FloatVid, ConstVid};
-use ty::{self, Ty, TyCtxt, GenericParamDefKind};
+use ty::{self, Ty, TyCtxt, GenericParamDefKind, InferConst};
 use ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
 use ty::fold::TypeFoldable;
 use ty::relate::RelateResult;
@@ -38,6 +38,7 @@ use syntax_pos::{self, Span};
 use syntax_pos::symbol::InternedString;
 use util::nodemap::FxHashMap;
 use arena::SyncDroplessArena;
+use mir::interpret::ConstValue;
 
 use self::combine::CombineFields;
 use self::higher_ranked::HrMatchResult;
@@ -101,7 +102,7 @@ pub struct InferCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     pub type_variables: RefCell<type_variable::TypeVariableTable<'tcx>>,
 
     // Map from const parameter variable to the kind of const it represents
-    const_unification_table: RefCell<ut::UnificationTable<ut::InPlace<ty::ConstVid>>>,
+    const_unification_table: RefCell<ut::UnificationTable<ut::InPlace<ty::ConstVid<'tcx>>>>,
 
     // Map from integral variable to the kind of integer it represents
     int_unification_table: RefCell<ut::UnificationTable<ut::InPlace<ty::IntVid>>>,
@@ -530,7 +531,7 @@ impl<'tcx> InferOk<'tcx, ()> {
 pub struct CombinedSnapshot<'a, 'tcx:'a> {
     projection_cache_snapshot: traits::ProjectionCacheSnapshot,
     type_snapshot: type_variable::Snapshot<'tcx>,
-    const_snapshot: ut::Snapshot<ut::InPlace<ty::ConstVid>>,
+    const_snapshot: ut::Snapshot<ut::InPlace<ty::ConstVid<'tcx>>>,
     int_snapshot: ut::Snapshot<ut::InPlace<ty::IntVid>>,
     float_snapshot: ut::Snapshot<ut::InPlace<ty::FloatVid>>,
     region_constraints_snapshot: RegionSnapshot,
@@ -910,7 +911,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         self.tcx.mk_const_var(self.next_const_var_id(origin), ty)
     }
 
-    pub fn next_const_var_id(&self) -> ConstVid {
+    pub fn next_const_var_id(&self, _origin: ConstVariableOrigin) -> ConstVid<'tcx> {
+        // TODO(const_generics): integrate _origin
         self.const_unification_table
             .borrow_mut()
             .new_key(None)
@@ -1567,3 +1569,18 @@ impl<'tcx> fmt::Debug for RegionObligation<'tcx> {
                self.sup_type)
     }
 }
+
+pub fn replace_const_if_possible<'tcx>(
+    mut table: RefMut<ut::UnificationTable<ut::InPlace<ty::ConstVid<'tcx>>>>,
+    c: &'tcx ty::Const<'tcx>,
+) -> &'tcx ty::Const<'tcx> {
+    match c.val {
+        ConstValue::Infer(InferConst::Var(vid)) => {
+            match table.probe_value(vid) {
+                Some(c) => c,
+                None => c,
+            }
+        }
+        _ => c,
+    }
+}
diff --git a/src/librustc/infer/sub.rs b/src/librustc/infer/sub.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use super::SubregionOrigin;
 use super::combine::{CombineFields, RelationDir, const_unification_error};
+use super::{SubregionOrigin, replace_const_if_possible};
 
 use traits::Obligation;
 use ty::{self, Ty, TyCtxt, InferConst};
@@ -151,8 +151,8 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         if a == b { return Ok(a); }
 
         let infcx = self.fields.infcx;
-        let a = infcx.const_unification_table.borrow_mut().replace_if_possible(a);
-        let b = infcx.const_unification_table.borrow_mut().replace_if_possible(b);
+        let a = replace_const_if_possible(infcx.const_unification_table.borrow_mut(), a);
+        let b = replace_const_if_possible(infcx.const_unification_table.borrow_mut(), b);
 
         // Consts can only be equal or unequal to each other: there's no subtyping
         // relation, so we're just going to perform equating here instead.
diff --git a/src/librustc/infer/unify_key.rs b/src/librustc/infer/unify_key.rs
@@ -10,6 +10,7 @@
 
 use ty::{self, FloatVarValue, IntVarValue, Ty, TyCtxt, Const};
 use rustc_data_structures::unify::{NoError, EqUnifyValue, UnifyKey, UnifyValue};
+use std::marker::PhantomData;
 
 pub trait ToType {
     fn to_type<'a, 'gcx, 'tcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx>;
@@ -18,7 +19,7 @@ pub trait ToType {
 impl<'tcx> UnifyKey for ty::ConstVid<'tcx> {
     type Value = Option<&'tcx Const<'tcx>>;
     fn index(&self) -> u32 { self.index }
-    fn from_index(i: u32) -> ty::ConstVid { ty::ConstVid { index: i } }
+    fn from_index(i: u32) -> ty::ConstVid<'tcx> { ty::ConstVid { index: i, phantom: PhantomData } }
     fn tag() -> &'static str { "ConstVid" }
 }
 
diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs
@@ -17,7 +17,7 @@ pub enum ConstValue<'tcx> {
     /// A const generic parameter.
     Param(ty::ParamConst),
     /// Infer the value of the const.
-    Infer(ty::InferConst),
+    Infer(ty::InferConst<'tcx>),
     /// Used only for types with layout::abi::Scalar ABI and ZSTs
     ///
     /// Not using the enum `Value` to encode that this must not be `Undef`
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -51,6 +51,7 @@ use ty::query;
 use ty::steal::Steal;
 use ty::BindingMode;
 use ty::CanonicalTy;
+use ty::fold::TypeFoldable;
 use util::nodemap::{DefIdSet, ItemLocalMap};
 use util::nodemap::{FxHashMap, FxHashSet};
 use rustc_data_structures::accumulate_vec::AccumulateVec;
@@ -2523,7 +2524,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_infer(TyVar(v))
     }
 
-    pub fn mk_const_var(self, v: ConstVid, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
+    pub fn mk_const_var(self, v: ConstVid<'tcx>, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
         self.mk_const(ty::Const {
             val: ConstValue::Infer(InferConst::Var(v)),
             ty,
diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs
@@ -177,6 +177,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
             OldStyleLUB(ref err) => {
                 write!(f, "{}", err)
             }
+            ConstError(..) => {
+                unreachable!() // TODO(const_generics)
+            }
         }
     }
 }
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -466,6 +466,8 @@ bitflags! {
         /// if a global bound is safe to evaluate.
         const HAS_RE_LATE_BOUND = 1 << 14;
 
+        const HAS_CT_INFER = 1 << 15;
+
         const NEEDS_SUBST        = TypeFlags::HAS_PARAMS.bits |
                                    TypeFlags::HAS_SELF.bits |
                                    TypeFlags::HAS_RE_EARLY_BOUND.bits;
diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs
@@ -623,7 +623,8 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
             if a_def_id == b_def_id =>
         {
             // TODO(const_generics): should just using an invariant (covariance) method
-            let substs = relation.relate_substs(a_def_id, a_substs, b_substs)?;
+            let substs =
+                relation.relate_with_variance(ty::Variance::Invariant, &a_substs, &b_substs)?;
             Ok(tcx.mk_const(ty::Const {
                 val: ConstValue::Unevaluated(a_def_id, substs),
                 ty: a.ty,
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
@@ -454,11 +454,24 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::TypeError<'a> {
 
             Sorts(ref x) => return tcx.lift(x).map(Sorts),
             OldStyleLUB(ref x) => return tcx.lift(x).map(OldStyleLUB),
-            ExistentialMismatch(ref x) => return tcx.lift(x).map(ExistentialMismatch)
+            ExistentialMismatch(ref x) => return tcx.lift(x).map(ExistentialMismatch),
+            ConstError(ref x) => return tcx.lift(x).map(ConstError),
         })
     }
 }
 
+impl<'a, 'tcx> Lift<'tcx> for ty::error::ConstError<'a> {
+    type Lifted = ty::error::ConstError<'tcx>;
+    fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
+        use ty::error::ConstError::*;
+
+        match *self {
+            Types(ref x) => return tcx.lift(x).map(Types),
+            Mismatch(ref x) => return tcx.lift(x).map(Mismatch),
+        }
+    }
+}
+
 impl<'a, 'tcx> Lift<'tcx> for ConstEvalErr<'a> {
     type Lifted = ConstEvalErr<'tcx>;
     fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
@@ -1131,6 +1144,14 @@ EnumTypeFoldableImpl! {
         (ty::error::TypeError::Sorts)(x),
         (ty::error::TypeError::ExistentialMismatch)(x),
         (ty::error::TypeError::OldStyleLUB)(x),
+        (ty::error::TypeError::ConstError)(x),
+    }
+}
+
+EnumTypeFoldableImpl! {
+    impl<'tcx> TypeFoldable<'tcx> for ty::error::ConstError<'tcx> {
+        (ty::error::ConstError::Types)(x),
+        (ty::error::ConstError::Mismatch)(x),
     }
 }
 
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -24,6 +24,7 @@ use mir::interpret::{Scalar, Pointer};
 
 use std::iter;
 use std::cmp::Ordering;
+use std::marker::PhantomData;
 use rustc_target::spec::abi;
 use syntax::ast::{self, Ident};
 use syntax::symbol::{keywords, InternedString};
@@ -1188,8 +1189,9 @@ pub struct TyVid {
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
-pub struct ConstVid {
+pub struct ConstVid<'tcx> {
     pub index: u32,
+    pub phantom: PhantomData<&'tcx ()>,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
@@ -2057,9 +2059,9 @@ impl<'tcx> serialize::UseSpecializedDecodable for &'tcx Const<'tcx> {}
 
 /// An inference variable for a const, for use in const generics.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)]
-pub enum InferConst {
+pub enum InferConst<'tcx> {
     /// Infer the value of the const.
-    Var(ty::ConstVid),
+    Var(ty::ConstVid<'tcx>),
     /// A fresh const variable. See `infer::freshen` for more details.
     Fresh(u32),
     /// Canonicalized const variable, used only when preparing a trait query.
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -909,7 +909,7 @@ impl fmt::Debug for ty::TyVid {
     }
 }
 
-impl fmt::Debug for ty::ConstVid {
+impl<'tcx> fmt::Debug for ty::ConstVid<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "_#{}f", self.index)
     }
diff --git a/src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs b/src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs
@@ -18,7 +18,8 @@ use rustc::traits::query::Fallible;
 use rustc::ty::fold::{TypeFoldable, TypeVisitor};
 use rustc::ty::relate::{self, Relate, RelateResult, TypeRelation};
 use rustc::ty::subst::Kind;
-use rustc::ty::{self, CanonicalTy, CanonicalVar, RegionVid, Ty, TyCtxt};
+use rustc::ty::{self, CanonicalTy, CanonicalVar, RegionVid, Ty, TyCtxt, InferConst};
+use rustc::mir::interpret::ConstValue;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use std::mem;
@@ -379,7 +380,7 @@ impl<'cx, 'bccx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx>
 
     fn consts(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>)
         -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
-        if let ty::ConstValue::Infer(ty::InferConst::Canonical(var)) = a.val {
+        if let ConstValue::Infer(InferConst::Canonical(var)) = a.val {
             self.equate_var(var, b.into())?;
             Ok(a)
         } else {
diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
@@ -20,6 +20,7 @@ use std::path;
 use std::rc::Rc;
 use std::cell::{Cell, RefCell};
 use std::sync::Arc;
+use std::marker::PhantomData;
 
 pub trait Encoder {
     type Error;
@@ -895,3 +896,6 @@ impl<T: UseSpecializedDecodable> Decodable for T {
 impl<'a, T: ?Sized + Encodable> UseSpecializedEncodable for &'a T {}
 impl<T: ?Sized + Encodable> UseSpecializedEncodable for Box<T> {}
 impl<T: Decodable> UseSpecializedDecodable for Box<T> {}
+
+impl<'tcx> UseSpecializedEncodable for PhantomData<&'tcx ()> {}
+impl<'tcx> UseSpecializedDecodable for PhantomData<&'tcx ()> {}

Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::RegionVid {`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`-impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::ConstVid {`
	`152`	`+impl<'gcx, 'tcx> HashStable<StableHashingContext<'gcx>> for ty::ConstVid<'tcx> {`
`153`	`153`	`#[inline]`
`154`	`154`	`fn hash_stable<W: StableHasherResult>(&self,`
`155`	`155`	`hcx: &mut StableHashingContext<'gcx>,`
Original file line number	Diff line number	Diff line change
`@@ -434,8 +434,8 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`434`	`434`	`opt_values[index] = Some(*original_value);`
`435`	`435`	`}`
`436`	`436`	`}`
`437`		`- UnpackedKind::Const(_) => {`
`438`		`- if let &ConstValue(InferConst::Canonical(index)) = result_value {`
	`437`	`+ UnpackedKind::Const(result_value) => {`
	`438`	`+ if let ConstValue::Infer(InferConst::Canonical(index)) = result_value.val {`
`439`	`439`	`opt_values[index] = Some(*original_value);`
`440`	`440`	`}`
`441`	`441`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,12 +153,12 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {`
`153`	`153`	`}`
`154`	`154`
`155`	`155`
`156`		`- (ConstValue::Infer(InferConst::Var(vid)), v) => {`
`157`		`- self.unify_const_variable(a_is_expected, vid, v)`
	`156`	`+ (ConstValue::Infer(InferConst::Var(vid)), _) => {`
	`157`	`+ self.unify_const_variable(a_is_expected, vid, b)`
`158`	`158`	`}`
`159`	`159`
`160`		`- (v, ConstValue::Infer(InferConst::Var(vid))) => {`
`161`		`- self.unify_const_variable(!a_is_expected, vid, v)`
	`160`	`+ (_, ConstValue::Infer(InferConst::Var(vid))) => {`
	`161`	`+ self.unify_const_variable(!a_is_expected, vid, a)`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`_ => {`
`@@ -169,8 +169,8 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {`
`169`	`169`
`170`	`170`	`fn unify_const_variable(&self,`
`171`	`171`	`vid_is_expected: bool,`
`172`		`- vid: ty::ConstVid,`
`173`		`- val: &'tcx ty::Const<'tcx>)`
	`172`	`+ vid: ty::ConstVid<'tcx>,`
	`173`	`+ val: &'tcx Const<'tcx>)`
`174`	`174`	`-> RelateResult<'tcx, &'tcx Const<'tcx>>`
`175`	`175`	`{`
`176`	`176`	`self.const_unification_table`
Original file line number	Diff line number	Diff line change
`@@ -177,6 +177,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {`
`177`	`177`	`OldStyleLUB(ref err) => {`
`178`	`178`	`write!(f, "{}", err)`
`179`	`179`	`}`
	`180`	`+ ConstError(..) => {`
	`181`	`+ unreachable!() // TODO(const_generics)`
	`182`	`+ }`
`180`	`183`	`}`
`181`	`184`	`}`
`182`	`185`	`}`