Move BoundTy debruijn index to the TyKind enum variant

scalexm · scalexm · commit 95861b159072 · 2018-11-24T01:24:40.000+01:00
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
@@ -684,7 +684,8 @@ for ty::TyKind<'gcx>
             Param(param_ty) => {
                 param_ty.hash_stable(hcx, hasher);
             }
-            Bound(bound_ty) => {
+            Bound(debruijn, bound_ty) => {
+                debruijn.hash_stable(hcx, hasher);
                 bound_ty.hash_stable(hcx, hasher);
             }
             ty::Placeholder(placeholder_ty) => {
diff --git a/src/librustc/infer/canonical/canonicalizer.rs b/src/librustc/infer/canonical/canonicalizer.rs
@@ -23,7 +23,7 @@ use infer::InferCtxt;
 use std::sync::atomic::Ordering;
 use ty::fold::{TypeFoldable, TypeFolder};
 use ty::subst::Kind;
-use ty::{self, BoundTy, BoundVar, Lift, List, Ty, TyCtxt, TypeFlags};
+use ty::{self, BoundVar, Lift, List, Ty, TyCtxt, TypeFlags};
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexed_vec::Idx;
@@ -382,8 +382,8 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx>
                 t
             ),
 
-            ty::Bound(bound_ty) => {
-                if bound_ty.index >= self.binder_index {
+            ty::Bound(debruijn, _) => {
+                if debruijn >= self.binder_index {
                     bug!("escaping bound type during canonicalization")
                 } else {
                     t
@@ -616,7 +616,7 @@ impl<'cx, 'gcx, 'tcx> Canonicalizer<'cx, 'gcx, 'tcx> {
             self.fold_ty(bound_to)
         } else {
             let var = self.canonical_var(info, ty_var.into());
-            self.tcx().mk_ty(ty::Bound(BoundTy::new(self.binder_index, var)))
+            self.tcx().mk_ty(ty::Bound(self.binder_index, var.into()))
         }
     }
 }
diff --git a/src/librustc/infer/canonical/query_response.rs b/src/librustc/infer/canonical/query_response.rs
@@ -435,21 +435,21 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
             match result_value.unpack() {
                 UnpackedKind::Type(result_value) => {
                     // e.g., here `result_value` might be `?0` in the example above...
-                    if let ty::Bound(b) = result_value.sty {
+                    if let ty::Bound(debruijn, b) = result_value.sty {
                         // ...in which case we would set `canonical_vars[0]` to `Some(?U)`.
 
                         // We only allow a `ty::INNERMOST` index in substitutions.
-                        assert_eq!(b.index, ty::INNERMOST);
+                        assert_eq!(debruijn, ty::INNERMOST);
                         opt_values[b.var] = Some(*original_value);
                     }
                 }
                 UnpackedKind::Lifetime(result_value) => {
                     // e.g., here `result_value` might be `'?1` in the example above...
-                    if let &ty::RegionKind::ReLateBound(index, br) = result_value {
+                    if let &ty::RegionKind::ReLateBound(debruijn, br) = result_value {
                         // ... in which case we would set `canonical_vars[0]` to `Some('static)`.
 
                         // We only allow a `ty::INNERMOST` index in substitutions.
-                        assert_eq!(index, ty::INNERMOST);
+                        assert_eq!(debruijn, ty::INNERMOST);
                         opt_values[br.assert_bound_var()] = Some(*original_value);
                     }
                 }
diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs
@@ -2471,7 +2471,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
 
             ty::UnnormalizedProjection(..)
             | ty::Placeholder(..)
-            | ty::Bound(_)
+            | ty::Bound(..)
             | ty::Infer(ty::FreshTy(_))
             | ty::Infer(ty::FreshIntTy(_))
             | ty::Infer(ty::FreshFloatTy(_)) => {
@@ -2557,7 +2557,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
 
             ty::UnnormalizedProjection(..)
             | ty::Placeholder(..)
-            | ty::Bound(_)
+            | ty::Bound(..)
             | ty::Infer(ty::FreshTy(_))
             | ty::Infer(ty::FreshIntTy(_))
             | ty::Infer(ty::FreshFloatTy(_)) => {
@@ -2601,7 +2601,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
             | ty::Param(..)
             | ty::Foreign(..)
             | ty::Projection(..)
-            | ty::Bound(_)
+            | ty::Bound(..)
             | ty::Infer(ty::TyVar(_))
             | ty::Infer(ty::FreshTy(_))
             | ty::Infer(ty::FreshIntTy(_))
diff --git a/src/librustc/traits/structural_impls.rs b/src/librustc/traits/structural_impls.rs
@@ -324,7 +324,7 @@ impl<'tcx> TypeVisitor<'tcx> for BoundNamesCollector {
         use syntax::symbol::Symbol;
 
         match t.sty {
-            ty::Bound(bound_ty) if bound_ty.index == self.binder_index => {
+            ty::Bound(debruijn, bound_ty) if debruijn == self.binder_index => {
                 self.types.insert(
                     bound_ty.var.as_u32(),
                     match bound_ty.kind {
diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs
@@ -213,7 +213,7 @@ impl<'a, 'gcx, 'lcx, 'tcx> ty::TyS<'tcx> {
             ty::Infer(ty::IntVar(_)) => "integral variable".into(),
             ty::Infer(ty::FloatVar(_)) => "floating-point variable".into(),
             ty::Placeholder(..) => "placeholder type".into(),
-            ty::Bound(_) |
+            ty::Bound(..) => "bound type".into(),
             ty::Infer(ty::FreshTy(_)) => "fresh type".into(),
             ty::Infer(ty::FreshIntTy(_)) => "fresh integral type".into(),
             ty::Infer(ty::FreshFloatTy(_)) => "fresh floating-point type".into(),
diff --git a/src/librustc/ty/flags.rs b/src/librustc/ty/flags.rs
@@ -115,8 +115,8 @@ impl FlagComputation {
                 self.add_substs(&substs.substs);
             }
 
-            &ty::Bound(bound_ty) => {
-                self.add_binder(bound_ty.index);
+            &ty::Bound(debruijn, _) => {
+                self.add_binder(debruijn);
             }
 
             &ty::Placeholder(..) => {
diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs
@@ -460,8 +460,8 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for BoundVarReplacer<'a, 'gcx, 'tcx>
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
         match t.sty {
-            ty::Bound(bound_ty) => {
-                if bound_ty.index == self.current_index {
+            ty::Bound(debruijn, bound_ty) => {
+                if debruijn == self.current_index {
                     let fld_t = &mut self.fld_t;
                     let ty = fld_t(bound_ty);
                     ty::fold::shift_vars(
@@ -526,7 +526,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
               T: TypeFoldable<'tcx>
     {
         // identity for bound types
-        let fld_t = |bound_ty| self.mk_ty(ty::Bound(bound_ty));
+        let fld_t = |bound_ty| self.mk_ty(ty::Bound(ty::INNERMOST, bound_ty));
         self.replace_escaping_bound_vars(value.skip_binder(), fld_r, fld_t)
     }
 
@@ -722,16 +722,13 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Shifter<'a, 'gcx, 'tcx> {
 
     fn fold_ty(&mut self, ty: ty::Ty<'tcx>) -> ty::Ty<'tcx> {
         match ty.sty {
-            ty::Bound(bound_ty) => {
-                if self.amount == 0 || bound_ty.index < self.current_index {
+            ty::Bound(debruijn, bound_ty) => {
+                if self.amount == 0 || debruijn < self.current_index {
                     ty
                 } else {
-                    let shifted = ty::BoundTy {
-                        index: bound_ty.index.shifted_in(self.amount),
-                        var: bound_ty.var,
-                        kind: bound_ty.kind,
-                    };
-                    self.tcx.mk_ty(ty::Bound(shifted))
+                    self.tcx.mk_ty(
+                        ty::Bound(debruijn.shifted_in(self.amount), bound_ty)
+                    )
                 }
             }
 
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -201,7 +201,7 @@ pub enum TyKind<'tcx> {
     Param(ParamTy),
 
     /// Bound type variable, used only when preparing a trait query.
-    Bound(BoundTy),
+    Bound(ty::DebruijnIndex, BoundTy),
 
     /// A placeholder type - universally quantified higher-ranked type.
     Placeholder(ty::PlaceholderType),
@@ -1245,7 +1245,6 @@ newtype_index! {
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
 pub struct BoundTy {
-    pub index: DebruijnIndex,
     pub var: BoundVar,
     pub kind: BoundTyKind,
 }
@@ -1256,13 +1255,12 @@ pub enum BoundTyKind {
     Param(InternedString),
 }
 
-impl_stable_hash_for!(struct BoundTy { index, var, kind });
+impl_stable_hash_for!(struct BoundTy { var, kind });
 impl_stable_hash_for!(enum self::BoundTyKind { Anon, Param(a) });
 
-impl BoundTy {
-    pub fn new(index: DebruijnIndex, var: BoundVar) -> Self {
+impl From<BoundVar> for BoundTy {
+    fn from(var: BoundVar) -> Self {
         BoundTy {
-            index,
             var,
             kind: BoundTyKind::Anon,
         }
@@ -1957,7 +1955,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
 
             ty::Infer(ty::TyVar(_)) => false,
 
-            ty::Bound(_) |
+            ty::Bound(..) |
             ty::Placeholder(..) |
             ty::Infer(ty::FreshTy(_)) |
             ty::Infer(ty::FreshIntTy(_)) |
diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs
@@ -190,11 +190,12 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
         Substs::for_item(tcx, def_id, |param, _| {
             match param.kind {
                 ty::GenericParamDefKind::Type { .. } => {
-                    tcx.mk_ty(ty::Bound(ty::BoundTy {
-                        index: ty::INNERMOST,
-                        var: ty::BoundVar::from(param.index),
-                        kind: ty::BoundTyKind::Param(param.name),
-                    })).into()
+                    tcx.mk_ty(
+                        ty::Bound(ty::INNERMOST, ty::BoundTy {
+                            var: ty::BoundVar::from(param.index),
+                            kind: ty::BoundTyKind::Param(param.name),
+                        })
+                    ).into()
                 }
 
                 ty::GenericParamDefKind::Lifetime => {
@@ -584,18 +585,18 @@ impl CanonicalUserSubsts<'tcx> {
         self.value.substs.iter().zip(BoundVar::new(0)..).all(|(kind, cvar)| {
             match kind.unpack() {
                 UnpackedKind::Type(ty) => match ty.sty {
-                    ty::Bound(b) => {
+                    ty::Bound(debruijn, b) => {
                         // We only allow a `ty::INNERMOST` index in substitutions.
-                        assert_eq!(b.index, ty::INNERMOST);
+                        assert_eq!(debruijn, ty::INNERMOST);
                         cvar == b.var
                     }
                     _ => false,
                 },
 
                 UnpackedKind::Lifetime(r) => match r {
-                    ty::ReLateBound(index, br) => {
+                    ty::ReLateBound(debruijn, br) => {
                         // We only allow a `ty::INNERMOST` index in substitutions.
-                        assert_eq!(*index, ty::INNERMOST);
+                        assert_eq!(*debruijn, ty::INNERMOST);
                         cvar == br.assert_bound_var()
                     }
                     _ => false,
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -1110,13 +1110,13 @@ define_print! {
                 Infer(infer_ty) => write!(f, "{}", infer_ty),
                 Error => write!(f, "[type error]"),
                 Param(ref param_ty) => write!(f, "{}", param_ty),
-                Bound(bound_ty) => {
+                Bound(debruijn, bound_ty) => {
                     match bound_ty.kind {
                         ty::BoundTyKind::Anon => {
-                            if bound_ty.index == ty::INNERMOST {
+                            if debruijn == ty::INNERMOST {
                                 write!(f, "^{}", bound_ty.var.index())
                             } else {
-                                write!(f, "^{}_{}", bound_ty.index.index(), bound_ty.var.index())
+                                write!(f, "^{}_{}", debruijn.index(), bound_ty.var.index())
                             }
                         }
 
diff --git a/src/librustc_traits/chalk_context/program_clauses.rs b/src/librustc_traits/chalk_context/program_clauses.rs
@@ -59,7 +59,8 @@ fn assemble_clauses_from_assoc_ty_values<'tcx>(
 
 fn program_clauses_for_raw_ptr<'tcx>(tcx: ty::TyCtxt<'_, '_, 'tcx>) -> Clauses<'tcx> {
     let ty = ty::Bound(
-        ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from_u32(0))
+        ty::INNERMOST,
+        ty::BoundVar::from_u32(0).into()
     );
     let ty = tcx.mk_ty(ty);
 
@@ -88,9 +89,9 @@ fn program_clauses_for_fn_ptr<'tcx>(
 ) -> Clauses<'tcx> {
     let inputs_and_output = tcx.mk_type_list(
         (0..arity_and_output).into_iter()
+            .map(|i| ty::BoundVar::from(i))
             // DebruijnIndex(1) because we are going to inject these in a `PolyFnSig`
-            .map(|i| ty::BoundTy::new(ty::DebruijnIndex::from(1usize), ty::BoundVar::from(i)))
-            .map(|t| tcx.mk_ty(ty::Bound(t)))
+            .map(|var| tcx.mk_ty(ty::Bound(ty::DebruijnIndex::from(1usize), var.into())))
     );
 
     let fn_sig = ty::Binder::bind(ty::FnSig {
@@ -115,7 +116,8 @@ fn program_clauses_for_fn_ptr<'tcx>(
 
 fn program_clauses_for_slice<'tcx>(tcx: ty::TyCtxt<'_, '_, 'tcx>) -> Clauses<'tcx> {
     let ty = ty::Bound(
-        ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from_u32(0))
+        ty::INNERMOST,
+        ty::BoundVar::from_u32(0).into()
     );
     let ty = tcx.mk_ty(ty);
 
@@ -151,7 +153,8 @@ fn program_clauses_for_array<'tcx>(
     length: &'tcx ty::Const<'tcx>
 ) -> Clauses<'tcx> {
     let ty = ty::Bound(
-        ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from_u32(0))
+        ty::INNERMOST,
+        ty::BoundVar::from_u32(0).into()
     );
     let ty = tcx.mk_ty(ty);
 
@@ -188,8 +191,8 @@ fn program_clauses_for_tuple<'tcx>(
 ) -> Clauses<'tcx> {
     let type_list = tcx.mk_type_list(
         (0..arity).into_iter()
-            .map(|i| ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from(i)))
-            .map(|t| tcx.mk_ty(ty::Bound(t)))
+            .map(|i| ty::BoundVar::from(i))
+            .map(|var| tcx.mk_ty(ty::Bound(ty::INNERMOST, var.into())))
     );
 
     let tuple_ty = tcx.mk_ty(ty::Tuple(type_list));
@@ -233,7 +236,7 @@ fn program_clauses_for_ref<'tcx>(tcx: ty::TyCtxt<'_, '_, 'tcx>) -> Clauses<'tcx>
         ty::ReLateBound(ty::INNERMOST, ty::BoundRegion::BrAnon(0))
     );
     let ty = tcx.mk_ty(
-        ty::Bound(ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from_u32(1)))
+        ty::Bound(ty::INNERMOST, ty::BoundVar::from_u32(1).into())
     );
 
     let ref_ty = tcx.mk_ref(region, ty::TypeAndMut {
diff --git a/src/librustc_traits/lowering/environment.rs b/src/librustc_traits/lowering/environment.rs
@@ -55,7 +55,7 @@ impl ClauseVisitor<'set, 'a, 'tcx> {
                     ty::ReLateBound(ty::INNERMOST, ty::BoundRegion::BrAnon(0))
                 );
                 let ty = self.tcx.mk_ty(
-                    ty::Bound(ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from_u32(1)))
+                    ty::Bound(ty::INNERMOST, ty::BoundVar::from_u32(1).into())
                 );
 
                 let ref_ty = self.tcx.mk_ref(region, ty::TypeAndMut {
diff --git a/src/librustc_traits/lowering/mod.rs b/src/librustc_traits/lowering/mod.rs
@@ -515,7 +515,8 @@ pub fn program_clauses_for_associated_type_def<'a, 'tcx>(
         .unwrap_or(0);
     // Add a new type param after the existing ones (`U` in the comment above).
     let ty_var = ty::Bound(
-        ty::BoundTy::new(ty::INNERMOST, ty::BoundVar::from_u32(offset + 1))
+        ty::INNERMOST,
+        ty::BoundVar::from_u32(offset + 1).into()
     );
 
     // `ProjectionEq(<Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> = U)`

Original file line number	Diff line number	Diff line change
`@@ -684,7 +684,8 @@ for ty::TyKind<'gcx>`
`684`	`684`	`Param(param_ty) => {`
`685`	`685`	`param_ty.hash_stable(hcx, hasher);`
`686`	`686`	`}`
`687`		`- Bound(bound_ty) => {`
	`687`	`+ Bound(debruijn, bound_ty) => {`
	`688`	`+ debruijn.hash_stable(hcx, hasher);`
`688`	`689`	`bound_ty.hash_stable(hcx, hasher);`
`689`	`690`	`}`
`690`	`691`	`ty::Placeholder(placeholder_ty) => {`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ use infer::InferCtxt;`
`23`	`23`	`use std::sync::atomic::Ordering;`
`24`	`24`	`use ty::fold::{TypeFoldable, TypeFolder};`
`25`	`25`	`use ty::subst::Kind;`
`26`		`-use ty::{self, BoundTy, BoundVar, Lift, List, Ty, TyCtxt, TypeFlags};`
	`26`	`+use ty::{self, BoundVar, Lift, List, Ty, TyCtxt, TypeFlags};`
`27`	`27`
`28`	`28`	`use rustc_data_structures::fx::FxHashMap;`
`29`	`29`	`use rustc_data_structures::indexed_vec::Idx;`
`@@ -382,8 +382,8 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx>`
`382`	`382`	`t`
`383`	`383`	`),`
`384`	`384`
`385`		`- ty::Bound(bound_ty) => {`
`386`		`- if bound_ty.index >= self.binder_index {`
	`385`	`+ ty::Bound(debruijn, _) => {`
	`386`	`+ if debruijn >= self.binder_index {`
`387`	`387`	`bug!("escaping bound type during canonicalization")`
`388`	`388`	`} else {`
`389`	`389`	`t`
`@@ -616,7 +616,7 @@ impl<'cx, 'gcx, 'tcx> Canonicalizer<'cx, 'gcx, 'tcx> {`
`616`	`616`	`self.fold_ty(bound_to)`
`617`	`617`	`} else {`
`618`	`618`	`let var = self.canonical_var(info, ty_var.into());`
`619`		`- self.tcx().mk_ty(ty::Bound(BoundTy::new(self.binder_index, var)))`
	`619`	`+ self.tcx().mk_ty(ty::Bound(self.binder_index, var.into()))`
`620`	`620`	`}`
`621`	`621`	`}`
`622`	`622`	`}`
Original file line number	Diff line number	Diff line change
`@@ -435,21 +435,21 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`435`	`435`	`match result_value.unpack() {`
`436`	`436`	`UnpackedKind::Type(result_value) => {`
`437`	`437`	// e.g., here `result_value` might be `?0` in the example above...
`438`		`- if let ty::Bound(b) = result_value.sty {`
	`438`	`+ if let ty::Bound(debruijn, b) = result_value.sty {`
`439`	`439`	// ...in which case we would set `canonical_vars[0]` to `Some(?U)`.
`440`	`440`
`441`	`441`	// We only allow a `ty::INNERMOST` index in substitutions.
`442`		`- assert_eq!(b.index, ty::INNERMOST);`
	`442`	`+ assert_eq!(debruijn, ty::INNERMOST);`
`443`	`443`	`opt_values[b.var] = Some(*original_value);`
`444`	`444`	`}`
`445`	`445`	`}`
`446`	`446`	`UnpackedKind::Lifetime(result_value) => {`
`447`	`447`	// e.g., here `result_value` might be `'?1` in the example above...
`448`		`- if let &ty::RegionKind::ReLateBound(index, br) = result_value {`
	`448`	`+ if let &ty::RegionKind::ReLateBound(debruijn, br) = result_value {`
`449`	`449`	// ... in which case we would set `canonical_vars[0]` to `Some('static)`.
`450`	`450`
`451`	`451`	// We only allow a `ty::INNERMOST` index in substitutions.
`452`		`- assert_eq!(index, ty::INNERMOST);`
	`452`	`+ assert_eq!(debruijn, ty::INNERMOST);`
`453`	`453`	`opt_values[br.assert_bound_var()] = Some(*original_value);`
`454`	`454`	`}`
`455`	`455`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,8 +115,8 @@ impl FlagComputation {`
`115`	`115`	`self.add_substs(&substs.substs);`
`116`	`116`	`}`
`117`	`117`
`118`		`- &ty::Bound(bound_ty) => {`
`119`		`- self.add_binder(bound_ty.index);`
	`118`	`+ &ty::Bound(debruijn, _) => {`
	`119`	`+ self.add_binder(debruijn);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`&ty::Placeholder(..) => {`