rustc: combine ty::{ParamTy, EarlyBoundRegion} into GenericParam.

eddyb · eddyb · commit 299a72295d33 · 2018-08-25T07:53:44.000+03:00
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
@@ -114,7 +114,7 @@ for ty::RegionKind {
             ty::ReLateBound(db, ty::BrEnv) => {
                 db.hash_stable(hcx, hasher);
             }
-            ty::ReEarlyBound(ty::EarlyBoundRegion { def_id, index }) => {
+            ty::ReEarlyBound(ty::GenericParam { def_id, index }) => {
                 def_id.hash_stable(hcx, hasher);
                 index.hash_stable(hcx, hasher);
             }
@@ -935,8 +935,8 @@ for ty::FloatVid
     }
 }
 
-impl_stable_hash_for!(struct ty::ParamTy {
-    idx,
+impl_stable_hash_for!(struct ty::GenericParam {
+    index,
     def_id
 });
 
diff --git a/src/librustc/infer/outlives/obligations.rs b/src/librustc/infer/outlives/obligations.rs
@@ -330,7 +330,7 @@ where
         &mut self,
         origin: infer::SubregionOrigin<'tcx>,
         region: ty::Region<'tcx>,
-        param_ty: ty::ParamTy,
+        param_ty: ty::GenericParam,
     ) {
         debug!(
             "param_ty_must_outlive(region={:?}, param_ty={:?}, origin={:?})",
@@ -459,7 +459,7 @@ where
         }
     }
 
-    fn param_bound(&self, param_ty: ty::ParamTy) -> VerifyBound<'tcx> {
+    fn param_bound(&self, param_ty: ty::GenericParam) -> VerifyBound<'tcx> {
         debug!("param_bound(param_ty={:?})", param_ty);
 
         let mut param_bounds = self.declared_generic_bounds_from_env(GenericKind::Param(param_ty));
diff --git a/src/librustc/infer/region_constraints/mod.rs b/src/librustc/infer/region_constraints/mod.rs
@@ -151,7 +151,7 @@ pub struct Verify<'tcx> {
 
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum GenericKind<'tcx> {
-    Param(ty::ParamTy),
+    Param(ty::GenericParam),
     Projection(ty::ProjectionTy<'tcx>),
 }
 
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -720,7 +720,7 @@ impl<'tcx> ScopeTree {
     /// Assuming that the provided region was defined within this `ScopeTree`,
     /// returns the outermost `Scope` that the region outlives.
     pub fn early_free_scope<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>,
-                                       br: &ty::EarlyBoundRegion)
+                                       br: &ty::GenericParam)
                                        -> Scope {
         let param_owner = tcx.parent_def_id(br.def_id).unwrap();
 
diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
@@ -1348,7 +1348,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.infcx.tcx }
 
             fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-                if let ty::Param(ty::ParamTy {def_id, ..}) = ty.sty {
+                if let ty::Param(ty::GenericParam {def_id, ..}) = ty.sty {
                     let infcx = self.infcx;
                     self.var_map.entry(ty).or_insert_with(||
                         infcx.next_ty_var(
diff --git a/src/librustc/traits/query/outlives_bounds.rs b/src/librustc/traits/query/outlives_bounds.rs
@@ -31,7 +31,7 @@ use std::mem;
 #[derive(Clone, Debug)]
 pub enum OutlivesBound<'tcx> {
     RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),
-    RegionSubParam(ty::Region<'tcx>, ty::ParamTy),
+    RegionSubParam(ty::Region<'tcx>, ty::GenericParam),
     RegionSubProjection(ty::Region<'tcx>, ty::ProjectionTy<'tcx>),
 }
 
diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs
@@ -3073,7 +3073,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                 let mut found = false;
                 for ty in field.walk() {
                     if let ty::Param(p) = ty.sty {
-                        ty_params.insert(p.idx as usize);
+                        ty_params.insert(p.index as usize);
                         found = true;
                     }
                 }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -2557,15 +2557,15 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     }
 
     pub fn mk_ty_param(self, def: &ty::GenericParamDef) -> Ty<'tcx> {
-        self.mk_ty(ty::Param(ty::ParamTy {
-            idx: def.index,
+        self.mk_ty(ty::Param(ty::GenericParam {
+            index: def.index,
             def_id: def.def_id,
         }))
     }
 
     pub fn mk_self_type(self, trait_def_id: DefId) -> Ty<'tcx> {
-        self.mk_ty(ty::Param(ty::ParamTy {
-            idx: 0,
+        self.mk_ty(ty::Param(ty::GenericParam {
+            index: 0,
             def_id: trait_def_id,
         }))
     }
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -63,12 +63,12 @@ use hir;
 
 pub use self::sty::{Binder, CanonicalVar, DebruijnIndex, INNERMOST};
 pub use self::sty::{FnSig, GenSig, PolyFnSig, PolyGenSig};
-pub use self::sty::{InferTy, ParamTy, ProjectionTy, ExistentialPredicate};
+pub use self::sty::{InferTy, GenericParam, ProjectionTy, ExistentialPredicate};
 pub use self::sty::{ClosureSubsts, GeneratorSubsts, UpvarSubsts, TypeAndMut};
 pub use self::sty::{TraitRef, TyKind, PolyTraitRef};
 pub use self::sty::{ExistentialTraitRef, PolyExistentialTraitRef};
 pub use self::sty::{ExistentialProjection, PolyExistentialProjection, Const};
-pub use self::sty::{BoundRegion, EarlyBoundRegion, FreeRegion, Region};
+pub use self::sty::{BoundRegion, FreeRegion, Region};
 pub use self::sty::RegionKind;
 pub use self::sty::{TyVid, IntVid, FloatVid, RegionVid};
 pub use self::sty::BoundRegion::*;
@@ -819,7 +819,7 @@ pub enum IntVarValue {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct FloatVarValue(pub ast::FloatTy);
 
-impl ty::EarlyBoundRegion {
+impl ty::GenericParam {
     pub fn to_bound_region(&self) -> ty::BoundRegion {
         ty::BoundRegion::BrNamed(self.def_id)
     }
@@ -856,10 +856,10 @@ pub struct GenericParamDef {
 }
 
 impl GenericParamDef {
-    pub fn to_early_bound_region_data(&self) -> ty::EarlyBoundRegion {
+    pub fn to_early_bound_region_data(&self) -> ty::GenericParam {
         match self.kind {
             GenericParamDefKind::Lifetime => {
-                ty::EarlyBoundRegion {
+                ty::GenericParam {
                     def_id: self.def_id,
                     index: self.index,
                 }
@@ -2657,7 +2657,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                     if let Some(trait_ref) = predicate.to_opt_poly_trait_ref() {
                         // Ignore bounds other than those on this parameter.
                         match trait_ref.self_ty().sty {
-                            ty::TyParam(p) if p.def_id == id => {}
+                            ty::Param(p) if p.def_id == id => {}
                             _ => continue,
                         }
 
diff --git a/src/librustc/ty/outlives.rs b/src/librustc/ty/outlives.rs
@@ -17,7 +17,7 @@ use ty::{self, Ty, TyCtxt, TypeFoldable};
 #[derive(Debug)]
 pub enum Component<'tcx> {
     Region(ty::Region<'tcx>),
-    Param(ty::ParamTy),
+    Param(ty::GenericParam),
     UnresolvedInferenceVariable(ty::InferTy),
 
     // Projections like `T::Foo` are tricky because a constraint like
diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs
@@ -388,7 +388,7 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
         }
 
         (&ty::Param(ref a_p), &ty::Param(ref b_p))
-            if a_p.idx == b_p.idx =>
+            if a_p.index == b_p.index =>
         {
             Ok(a)
         }
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
@@ -56,7 +56,7 @@ CloneTypeFoldableAndLiftImpls! {
     ::ty::BoundRegion,
     ::ty::ClosureKind,
     ::ty::IntVarValue,
-    ::ty::ParamTy,
+    ::ty::GenericParam,
     ::syntax_pos::Span,
 }
 
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -165,7 +165,7 @@ pub enum TyKind<'tcx> {
     Anon(DefId, &'tcx Substs<'tcx>),
 
     /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
-    Param(ParamTy),
+    Param(GenericParam),
 
     /// A type variable used during type-checking.
     Infer(InferTy),
@@ -959,12 +959,6 @@ impl<'tcx> PolyFnSig<'tcx> {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
-pub struct ParamTy {
-    pub idx: u32,
-    pub def_id: DefId,
-}
-
 /// A [De Bruijn index][dbi] is a standard means of representing
 /// regions (and perhaps later types) in a higher-ranked setting. In
 /// particular, imagine a type like this:
@@ -1074,7 +1068,7 @@ pub enum RegionKind {
     // Region bound in a type or fn declaration which will be
     // substituted 'early' -- that is, at the same time when type
     // parameters are substituted.
-    ReEarlyBound(EarlyBoundRegion),
+    ReEarlyBound(GenericParam),
 
     // Region bound in a function scope, which will be substituted when the
     // function is called.
@@ -1124,8 +1118,8 @@ pub enum RegionKind {
 
 impl<'tcx> serialize::UseSpecializedDecodable for Region<'tcx> {}
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug, PartialOrd, Ord)]
-pub struct EarlyBoundRegion {
+#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, PartialOrd, Ord)]
+pub struct GenericParam {
     pub def_id: DefId,
     pub index: u32,
 }
@@ -1483,7 +1477,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
 
     pub fn is_param(&self, index: u32) -> bool {
         match self.sty {
-            ty::Param(ref data) => data.idx == index,
+            ty::Param(ref data) => data.index == index,
             _ => false,
         }
     }
diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs
@@ -495,9 +495,9 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for SubstFolder<'a, 'gcx, 'tcx> {
 }
 
 impl<'a, 'gcx, 'tcx> SubstFolder<'a, 'gcx, 'tcx> {
-    fn ty_for_param(&self, p: ty::ParamTy, source_ty: Ty<'tcx>) -> Ty<'tcx> {
+    fn ty_for_param(&self, p: ty::GenericParam, source_ty: Ty<'tcx>) -> Ty<'tcx> {
         // Look up the type in the substitutions. It really should be in there.
-        let opt_ty = self.substs.get(p.idx as usize).map(|k| k.unpack());
+        let opt_ty = self.substs.get(p.index as usize).map(|k| k.unpack());
         let ty = match opt_ty {
             Some(UnpackedKind::Type(ty)) => ty,
             _ => {
@@ -508,7 +508,7 @@ impl<'a, 'gcx, 'tcx> SubstFolder<'a, 'gcx, 'tcx> {
                          when substituting (root type={:?}) substs={:?}",
                     p,
                     source_ty,
-                    p.idx,
+                    p.index,
                     self.root_ty,
                     self.substs);
             }
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
@@ -498,19 +498,18 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
         let result = item_substs.iter().zip(impl_substs.iter())
             .filter(|&(_, &k)| {
-                let index = match k.unpack() {
-                    UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) =>
-                        ebr.index,
+                let param = match k.unpack() {
+                    UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => ebr,
                     UnpackedKind::Type(&ty::TyS {
                         sty: ty::Param(ref pt), ..
-                    }) => pt.idx,
+                    }) => pt,
                     UnpackedKind::Lifetime(_) | UnpackedKind::Type(_) => {
                         // not a type or region param - this should be reported
                         // as an error.
                         return false;
                     }
                 };
-                !impl_generics.param_at(index, self).pure_wrt_drop
+                !impl_generics.param_at(param.index, self).pure_wrt_drop
             }).map(|(&item_param, _)| item_param).collect();
         debug!("destructor_constraint({:?}) = {:?}", def.did, result);
         result
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -805,7 +805,7 @@ define_print! {
             // `explain_region()` or `note_and_explain_region()`.
             match *self {
                 ty::ReEarlyBound(ref data) => {
-                    write!(f, "{}", ty::tls::with(|tcx| tcx.generic_param_name(data.def_id)))
+                    print!(f, cx, print_display(data))
                 }
                 ty::ReCanonical(_) => {
                     write!(f, "'_")
@@ -846,9 +846,7 @@ define_print! {
         debug {
             match *self {
                 ty::ReEarlyBound(ref data) => {
-                    write!(f, "ReEarlyBound({}, {})",
-                           data.index,
-                           ty::tls::with(|tcx| tcx.generic_param_name(data.def_id)))
+                    print!(f, cx, print_debug(data))
                 }
 
                 ty::ReClosureBound(ref vid) => {
@@ -1311,12 +1309,13 @@ define_print! {
 }
 
 define_print! {
-    () ty::ParamTy, (self, f, cx) {
+    () ty::GenericParam, (self, f, cx) {
         display {
             write!(f, "{}", ty::tls::with(|tcx| tcx.generic_param_name(self.def_id)))
         }
         debug {
-            write!(f, "{}/#{}", ty::tls::with(|tcx| tcx.generic_param_name(self.def_id)), self.idx)
+            write!(f, "{}/#{}",
+                ty::tls::with(|tcx| tcx.generic_param_name(self.def_id)), self.index)
         }
     }
 }
diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
@@ -313,15 +313,15 @@ impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> {
 
     pub fn t_param(&self, index: u32) -> Ty<'tcx> {
         let def_id = self.infcx.tcx.hir.local_def_id(ast::CRATE_NODE_ID);
-        self.infcx.tcx.mk_ty(ty::TyParam(ty::ParamTy {
+        self.infcx.tcx.mk_ty(ty::TyParam(ty::GenericParam {
             idx: index,
             def_id,
         }))
     }
 
     pub fn re_early_bound(&self, index: u32, name: &'static str) -> ty::Region<'tcx> {
         let name = Symbol::intern(name).as_interned_str();
-        self.infcx.tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
+        self.infcx.tcx.mk_region(ty::ReEarlyBound(ty::GenericParam {
             def_id: self.infcx.tcx.hir.local_def_id(ast::CRATE_NODE_ID),
             index,
             name,
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -133,7 +133,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
             }
 
             Some(rl::Region::EarlyBound(index, id, _)) => {
-                tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
+                tcx.mk_region(ty::ReEarlyBound(ty::GenericParam {
                     def_id: id,
                     index,
                 }))
diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs
@@ -81,7 +81,7 @@ enum PointerKind<'tcx> {
     /// The unsize info of this anon ty
     OfAnon(DefId, &'tcx Substs<'tcx>),
     /// The unsize info of this parameter
-    OfParam(&'tcx ty::ParamTy),
+    OfParam(&'tcx ty::GenericParam),
 }
 
 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
@@ -642,7 +642,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
 
     fn assemble_inherent_candidates_from_param(&mut self,
                                                _rcvr_ty: Ty<'tcx>,
-                                               param_ty: ty::ParamTy) {
+                                               param_ty: ty::GenericParam) {
         // FIXME -- Do we want to commit to this behavior for param bounds?
 
         let bounds: Vec<_> = self.param_env
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -5242,9 +5242,9 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let mut types_used = vec![false; own_counts.types];
 
     for leaf_ty in ty.walk() {
-        if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
-            debug!("Found use of ty param num {}", idx);
-            types_used[idx as usize - own_counts.lifetimes] = true;
+        if let ty::Param(ref p) = leaf_ty.sty {
+            debug!("Found use of ty param num {}", p.index);
+            types_used[p.index as usize - own_counts.lifetimes] = true;
         } else if let ty::Error = leaf_ty.sty {
             // If there is already another error, do not emit
             // an error for not using a type Parameter.
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -455,7 +455,7 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(
             fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
                 match t.sty {
                     ty::Param(p) => {
-                        self.params.insert(p.idx);
+                        self.params.insert(p.index);
                         t.super_visit_with(self)
                     }
                     _ => t.super_visit_with(self)
diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs
@@ -463,7 +463,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
                                         if subst == region {
                                             // found it in the substitution list, replace with the
                                             // parameter from the existential type
-                                            let reg = ty::EarlyBoundRegion {
+                                            let reg = ty::GenericParam {
                                                 def_id: p.def_id,
                                                 index: p.index,
                                             };
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -1740,7 +1740,7 @@ fn explicit_predicates_of<'a, 'tcx>(
     // have to be careful to only iterate over early-bound regions.
     let mut index = parent_count + has_own_self as u32;
     for param in early_bound_lifetimes_from_generics(tcx, ast_generics) {
-        let region = tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
+        let region = tcx.mk_region(ty::ReEarlyBound(ty::GenericParam {
             def_id: tcx.hir.local_def_id(param.id),
             index,
         }));
diff --git a/src/librustc_typeck/constrained_type_params.rs b/src/librustc_typeck/constrained_type_params.rs
diff --git a/src/librustc_typeck/outlives/utils.rs b/src/librustc_typeck/outlives/utils.rs
diff --git a/src/librustc_typeck/variance/constraints.rs b/src/librustc_typeck/variance/constraints.rs
diff --git a/src/test/ui/nll/closure-requirements/propagate-from-trait-match.stderr b/src/test/ui/nll/closure-requirements/propagate-from-trait-match.stderr
diff --git a/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr b/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr
diff --git a/src/test/ui/nll/ty-outlives/impl-trait-outlives.stderr b/src/test/ui/nll/ty-outlives/impl-trait-outlives.stderr
diff --git a/src/test/ui/nll/ty-outlives/projection-no-regions-closure.stderr b/src/test/ui/nll/ty-outlives/projection-no-regions-closure.stderr
diff --git a/src/test/ui/nll/ty-outlives/projection-no-regions-fn.stderr b/src/test/ui/nll/ty-outlives/projection-no-regions-fn.stderr
diff --git a/src/test/ui/nll/ty-outlives/projection-one-region-closure.stderr b/src/test/ui/nll/ty-outlives/projection-one-region-closure.stderr
diff --git a/src/test/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr b/src/test/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr
diff --git a/src/test/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr b/src/test/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ for ty::RegionKind {`
`114`	`114`	`ty::ReLateBound(db, ty::BrEnv) => {`
`115`	`115`	`db.hash_stable(hcx, hasher);`
`116`	`116`	`}`
`117`		`- ty::ReEarlyBound(ty::EarlyBoundRegion { def_id, index }) => {`
	`117`	`+ ty::ReEarlyBound(ty::GenericParam { def_id, index }) => {`
`118`	`118`	`def_id.hash_stable(hcx, hasher);`
`119`	`119`	`index.hash_stable(hcx, hasher);`
`120`	`120`	`}`
`@@ -935,8 +935,8 @@ for ty::FloatVid`
`935`	`935`	`}`
`936`	`936`	`}`
`937`	`937`
`938`		`-impl_stable_hash_for!(struct ty::ParamTy {`
`939`		`- idx,`
	`938`	`+impl_stable_hash_for!(struct ty::GenericParam {`
	`939`	`+ index,`
`940`	`940`	`def_id`
`941`	`941`	`});`
`942`	`942`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ pub struct Verify<'tcx> {`
`151`	`151`
`152`	`152`	`#[derive(Copy, Clone, PartialEq, Eq)]`
`153`	`153`	`pub enum GenericKind<'tcx> {`
`154`		`- Param(ty::ParamTy),`
	`154`	`+ Param(ty::GenericParam),`
`155`	`155`	`Projection(ty::ProjectionTy<'tcx>),`
`156`	`156`	`}`
`157`	`157`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ use std::mem;`
`31`	`31`	`#[derive(Clone, Debug)]`
`32`	`32`	`pub enum OutlivesBound<'tcx> {`
`33`	`33`	`RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),`
`34`		`- RegionSubParam(ty::Region<'tcx>, ty::ParamTy),`
	`34`	`+ RegionSubParam(ty::Region<'tcx>, ty::GenericParam),`
`35`	`35`	`RegionSubProjection(ty::Region<'tcx>, ty::ProjectionTy<'tcx>),`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -3073,7 +3073,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {`
`3073`	`3073`	`let mut found = false;`
`3074`	`3074`	`for ty in field.walk() {`
`3075`	`3075`	`if let ty::Param(p) = ty.sty {`
`3076`		`- ty_params.insert(p.idx as usize);`
	`3076`	`+ ty_params.insert(p.index as usize);`
`3077`	`3077`	`found = true;`
`3078`	`3078`	`}`
`3079`	`3079`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2557,15 +2557,15 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2557`	`2557`	`}`
`2558`	`2558`
`2559`	`2559`	`pub fn mk_ty_param(self, def: &ty::GenericParamDef) -> Ty<'tcx> {`
`2560`		`- self.mk_ty(ty::Param(ty::ParamTy {`
`2561`		`- idx: def.index,`
	`2560`	`+ self.mk_ty(ty::Param(ty::GenericParam {`
	`2561`	`+ index: def.index,`
`2562`	`2562`	`def_id: def.def_id,`
`2563`	`2563`	`}))`
`2564`	`2564`	`}`
`2565`	`2565`
`2566`	`2566`	`pub fn mk_self_type(self, trait_def_id: DefId) -> Ty<'tcx> {`
`2567`		`- self.mk_ty(ty::Param(ty::ParamTy {`
`2568`		`- idx: 0,`
	`2567`	`+ self.mk_ty(ty::Param(ty::GenericParam {`
	`2568`	`+ index: 0,`
`2569`	`2569`	`def_id: trait_def_id,`
`2570`	`2570`	`}))`
`2571`	`2571`	`}`