Rename subst::Kind to subst::GenericArg

src/librustc/ich/impls_ty.rs

@@ -56,7 +56,7 @@ fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> Fingerprint {
     }
 }
 
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ty::subst::Kind<'tcx> {
+impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ty::subst::GenericArg<'tcx> {
     fn hash_stable<W: StableHasherResult>(&self,
                                           hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {

src/librustc/infer/canonical/canonicalizer.rs

@@ -13,7 +13,7 @@
 use crate::mir::interpret::ConstValue;
 use std::sync::atomic::Ordering;
 use crate::ty::fold::{TypeFoldable, TypeFolder};
-use crate::ty::subst::Kind;
+use crate::ty::subst::GenericArg;
 use crate::ty::{self, BoundVar, InferConst, List, Ty, TyCtxt, TypeFlags};
 use crate::ty::flags::FlagComputation;
 
@@ -282,7 +282,7 @@ struct Canonicalizer<'cx, 'tcx> {
     query_state: &'cx mut OriginalQueryValues<'tcx>,
     // Note that indices is only used once `var_values` is big enough to be
     // heap-allocated.
-    indices: FxHashMap<Kind<'tcx>, BoundVar>,
+    indices: FxHashMap<GenericArg<'tcx>, BoundVar>,
     canonicalize_region_mode: &'cx dyn CanonicalizeRegionMode,
     needs_canonical_flags: TypeFlags,
 
@@ -566,7 +566,7 @@ fn canonicalize<V>(
     /// or returns an existing variable if `kind` has already been
     /// seen. `kind` is expected to be an unbound variable (or
     /// potentially a free region).
-    fn canonical_var(&mut self, info: CanonicalVarInfo, kind: Kind<'tcx>) -> BoundVar {
+    fn canonical_var(&mut self, info: CanonicalVarInfo, kind: GenericArg<'tcx>) -> BoundVar {
         let Canonicalizer {
             variables,
             query_state,

src/librustc/infer/canonical/mod.rs

@@ -32,7 +32,7 @@
 use std::ops::Index;
 use syntax::source_map::Span;
 use crate::ty::fold::TypeFoldable;
-use crate::ty::subst::Kind;
+use crate::ty::subst::GenericArg;
 use crate::ty::{self, BoundVar, InferConst, Lift, List, Region, TyCtxt};
 
 mod canonicalizer;
@@ -66,7 +66,7 @@ impl<'tcx> UseSpecializedDecodable for CanonicalVarInfos<'tcx> {}
 /// canonicalized query response.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, RustcDecodable, RustcEncodable, HashStable)]
 pub struct CanonicalVarValues<'tcx> {
-    pub var_values: IndexVec<BoundVar, Kind<'tcx>>,
+    pub var_values: IndexVec<BoundVar, GenericArg<'tcx>>,
 }
 
 /// When we canonicalize a value to form a query, we wind up replacing
@@ -83,7 +83,7 @@ pub struct OriginalQueryValues<'tcx> {
 
     /// This is equivalent to `CanonicalVarValues`, but using a
     /// `SmallVec` yields a significant performance win.
-    pub var_values: SmallVec<[Kind<'tcx>; 8]>,
+    pub var_values: SmallVec<[GenericArg<'tcx>; 8]>,
 }
 
 impl Default for OriginalQueryValues<'tcx> {
@@ -308,7 +308,7 @@ pub fn unchecked_map<W>(self, map_op: impl FnOnce(V) -> W) -> Canonical<'tcx, W>
 }
 
 pub type QueryOutlivesConstraint<'tcx> =
-    ty::Binder<ty::OutlivesPredicate<Kind<'tcx>, Region<'tcx>>>;
+    ty::Binder<ty::OutlivesPredicate<GenericArg<'tcx>, Region<'tcx>>>;
 
 impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// Creates a substitution S for the canonical value with fresh
@@ -359,7 +359,7 @@ fn instantiate_canonical_vars(
         variables: &List<CanonicalVarInfo>,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> CanonicalVarValues<'tcx> {
-        let var_values: IndexVec<BoundVar, Kind<'tcx>> = variables
+        let var_values: IndexVec<BoundVar, GenericArg<'tcx>> = variables
             .iter()
             .map(|info| self.instantiate_canonical_var(span, *info, &universe_map))
             .collect();
@@ -376,7 +376,7 @@ fn instantiate_canonical_var(
         span: Span,
         cv_info: CanonicalVarInfo,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
-    ) -> Kind<'tcx> {
+    ) -> GenericArg<'tcx> {
         match cv_info.kind {
             CanonicalVarKind::Ty(ty_kind) => {
                 let ty = match ty_kind {
@@ -495,19 +495,19 @@ pub fn len(&self) -> usize {
     /// we'll return a substitution `subst` with:
     /// `subst.var_values == [Type(^0), Lifetime(^1), Type(^2)]`.
     pub fn make_identity(&self, tcx: TyCtxt<'tcx>) -> Self {
-        use crate::ty::subst::UnpackedKind;
+        use crate::ty::subst::GenericArgKind;
 
         CanonicalVarValues {
             var_values: self.var_values.iter()
                 .zip(0..)
                 .map(|(kind, i)| match kind.unpack() {
-                    UnpackedKind::Type(..) => tcx.mk_ty(
+                    GenericArgKind::Type(..) => tcx.mk_ty(
                         ty::Bound(ty::INNERMOST, ty::BoundVar::from_u32(i).into())
                     ).into(),
-                    UnpackedKind::Lifetime(..) => tcx.mk_region(
+                    GenericArgKind::Lifetime(..) => tcx.mk_region(
                         ty::ReLateBound(ty::INNERMOST, ty::BoundRegion::BrAnon(i))
                     ).into(),
-                    UnpackedKind::Const(ct) => {
+                    GenericArgKind::Const(ct) => {
                         tcx.mk_const(ty::Const {
                             ty: ct.ty,
                             val: ConstValue::Infer(
@@ -522,8 +522,8 @@ pub fn make_identity(&self, tcx: TyCtxt<'tcx>) -> Self {
 }
 
 impl<'a, 'tcx> IntoIterator for &'a CanonicalVarValues<'tcx> {
-    type Item = Kind<'tcx>;
-    type IntoIter = ::std::iter::Cloned<::std::slice::Iter<'a, Kind<'tcx>>>;
+    type Item = GenericArg<'tcx>;
+    type IntoIter = ::std::iter::Cloned<::std::slice::Iter<'a, GenericArg<'tcx>>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.var_values.iter().cloned()
@@ -570,9 +570,9 @@ impl<'a, 'tcx> Lift<'tcx> for QueryRegionConstraints<'a> {
 }
 
 impl<'tcx> Index<BoundVar> for CanonicalVarValues<'tcx> {
-    type Output = Kind<'tcx>;
+    type Output = GenericArg<'tcx>;
 
-    fn index(&self, value: BoundVar) -> &Kind<'tcx> {
+    fn index(&self, value: BoundVar) -> &GenericArg<'tcx> {
         &self.var_values[value]
     }
 }

src/librustc/infer/canonical/query_response.rs

@@ -25,7 +25,7 @@
 use crate::traits::TraitEngine;
 use crate::traits::{Obligation, ObligationCause, PredicateObligation};
 use crate::ty::fold::TypeFoldable;
-use crate::ty::subst::{Kind, UnpackedKind};
+use crate::ty::subst::{GenericArg, GenericArgKind};
 use crate::ty::{self, BoundVar, InferConst, Ty, TyCtxt};
 use crate::util::captures::Captures;
 
@@ -298,11 +298,14 @@ pub fn instantiate_nll_query_response_and_region_obligations<R>(
                 &v.var_values[BoundVar::new(index)]
             });
             match (original_value.unpack(), result_value.unpack()) {
-                (UnpackedKind::Lifetime(ty::ReErased), UnpackedKind::Lifetime(ty::ReErased)) => {
-                    // no action needed
+                (
+                    GenericArgKind::Lifetime(ty::ReErased),
+                    GenericArgKind::Lifetime(ty::ReErased),
+                ) => {
+                    // No action needed.
                 }
 
-                (UnpackedKind::Lifetime(v_o), UnpackedKind::Lifetime(v_r)) => {
+                (GenericArgKind::Lifetime(v_o), GenericArgKind::Lifetime(v_r)) => {
                     // To make `v_o = v_r`, we emit `v_o: v_r` and `v_r: v_o`.
                     if v_o != v_r {
                         output_query_region_constraints
@@ -314,12 +317,12 @@ pub fn instantiate_nll_query_response_and_region_obligations<R>(
                     }
                 }
 
-                (UnpackedKind::Type(v1), UnpackedKind::Type(v2)) => {
+                (GenericArgKind::Type(v1), GenericArgKind::Type(v2)) => {
                     let ok = self.at(cause, param_env).eq(v1, v2)?;
                     obligations.extend(ok.into_obligations());
                 }
 
-                (UnpackedKind::Const(v1), UnpackedKind::Const(v2)) => {
+                (GenericArgKind::Const(v1), GenericArgKind::Const(v2)) => {
                     let ok = self.at(cause, param_env).eq(v1, v2)?;
                     obligations.extend(ok.into_obligations());
                 }
@@ -462,14 +465,14 @@ fn query_response_substitution_guess<R>(
         // is directly equal to one of the canonical variables in the
         // result, then we can type the corresponding value from the
         // input. See the example above.
-        let mut opt_values: IndexVec<BoundVar, Option<Kind<'tcx>>> =
+        let mut opt_values: IndexVec<BoundVar, Option<GenericArg<'tcx>>> =
             IndexVec::from_elem_n(None, query_response.variables.len());
 
         // In terms of our example above, we are iterating over pairs like:
         // [(?A, Vec<?0>), ('static, '?1), (?B, ?0)]
         for (original_value, result_value) in original_values.var_values.iter().zip(result_values) {
             match result_value.unpack() {
-                UnpackedKind::Type(result_value) => {
+                GenericArgKind::Type(result_value) => {
                     // e.g., here `result_value` might be `?0` in the example above...
                     if let ty::Bound(debruijn, b) = result_value.kind {
                         // ...in which case we would set `canonical_vars[0]` to `Some(?U)`.
@@ -479,7 +482,7 @@ fn query_response_substitution_guess<R>(
                         opt_values[b.var] = Some(*original_value);
                     }
                 }
-                UnpackedKind::Lifetime(result_value) => {
+                GenericArgKind::Lifetime(result_value) => {
                     // e.g., here `result_value` might be `'?1` in the example above...
                     if let &ty::RegionKind::ReLateBound(debruijn, br) = result_value {
                         // ... in which case we would set `canonical_vars[0]` to `Some('static)`.
@@ -489,7 +492,7 @@ fn query_response_substitution_guess<R>(
                         opt_values[br.assert_bound_var()] = Some(*original_value);
                     }
                 }
-                UnpackedKind::Const(result_value) => {
+                GenericArgKind::Const(result_value) => {
                     if let ty::Const {
                         val: ConstValue::Infer(InferConst::Canonical(debrujin, b)),
                         ..
@@ -553,7 +556,7 @@ fn unify_query_response_substitution_guess<R>(
         // canonical variable; this is taken from
         // `query_response.var_values` after applying the substitution
         // `result_subst`.
-        let substituted_query_response = |index: BoundVar| -> Kind<'tcx> {
+        let substituted_query_response = |index: BoundVar| -> GenericArg<'tcx> {
             query_response.substitute_projected(self.tcx, &result_subst, |v| &v.var_values[index])
         };
 
@@ -586,17 +589,17 @@ fn query_outlives_constraints_into_obligations<'a>(
                     cause.clone(),
                     param_env,
                     match k1.unpack() {
-                        UnpackedKind::Lifetime(r1) => ty::Predicate::RegionOutlives(
+                        GenericArgKind::Lifetime(r1) => ty::Predicate::RegionOutlives(
                             ty::Binder::bind(
                                 ty::OutlivesPredicate(r1, r2)
                             )
                         ),
-                        UnpackedKind::Type(t1) => ty::Predicate::TypeOutlives(
+                        GenericArgKind::Type(t1) => ty::Predicate::TypeOutlives(
                             ty::Binder::bind(
                                 ty::OutlivesPredicate(t1, r2)
                             )
                         ),
-                        UnpackedKind::Const(..) => {
+                        GenericArgKind::Const(..) => {
                             // Consts cannot outlive one another, so we don't expect to
                             // ecounter this branch.
                             span_bug!(cause.span, "unexpected const outlives {:?}", constraint);
@@ -613,7 +616,7 @@ fn unify_canonical_vars(
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         variables1: &OriginalQueryValues<'tcx>,
-        variables2: impl Fn(BoundVar) -> Kind<'tcx>,
+        variables2: impl Fn(BoundVar) -> GenericArg<'tcx>,
     ) -> InferResult<'tcx, ()> {
         self.commit_if_ok(|_| {
             let mut obligations = vec![];
@@ -621,21 +624,21 @@ fn unify_canonical_vars(
                 let value2 = variables2(BoundVar::new(index));
 
                 match (value1.unpack(), value2.unpack()) {
-                    (UnpackedKind::Type(v1), UnpackedKind::Type(v2)) => {
+                    (GenericArgKind::Type(v1), GenericArgKind::Type(v2)) => {
                         obligations
                             .extend(self.at(cause, param_env).eq(v1, v2)?.into_obligations());
                     }
                     (
-                        UnpackedKind::Lifetime(ty::ReErased),
-                        UnpackedKind::Lifetime(ty::ReErased),
+                        GenericArgKind::Lifetime(ty::ReErased),
+                        GenericArgKind::Lifetime(ty::ReErased),
                     ) => {
                         // no action needed
                     }
-                    (UnpackedKind::Lifetime(v1), UnpackedKind::Lifetime(v2)) => {
+                    (GenericArgKind::Lifetime(v1), GenericArgKind::Lifetime(v2)) => {
                         obligations
                             .extend(self.at(cause, param_env).eq(v1, v2)?.into_obligations());
                     }
-                    (UnpackedKind::Const(v1), UnpackedKind::Const(v2)) => {
+                    (GenericArgKind::Const(v1), GenericArgKind::Const(v2)) => {
                         let ok = self.at(cause, param_env).eq(v1, v2)?;
                         obligations.extend(ok.into_obligations());
                     }

src/librustc/infer/canonical/substitute.rs

@@ -8,7 +8,7 @@
 
 use crate::infer::canonical::{Canonical, CanonicalVarValues};
 use crate::ty::fold::TypeFoldable;
-use crate::ty::subst::UnpackedKind;
+use crate::ty::subst::GenericArgKind;
 use crate::ty::{self, TyCtxt};
 
 impl<'tcx, V> Canonical<'tcx, V> {
@@ -58,21 +58,21 @@ pub(super) fn substitute_value<'a, 'tcx, T>(
     } else {
         let fld_r = |br: ty::BoundRegion| {
             match var_values.var_values[br.assert_bound_var()].unpack() {
-                UnpackedKind::Lifetime(l) => l,
+                GenericArgKind::Lifetime(l) => l,
                 r => bug!("{:?} is a region but value is {:?}", br, r),
             }
         };
 
         let fld_t = |bound_ty: ty::BoundTy| {
             match var_values.var_values[bound_ty.var].unpack() {
-                UnpackedKind::Type(ty) => ty,
+                GenericArgKind::Type(ty) => ty,
                 r => bug!("{:?} is a type but value is {:?}", bound_ty, r),
             }
         };
 
         let fld_c = |bound_ct: ty::BoundVar, _| {
             match var_values.var_values[bound_ct].unpack() {
-                UnpackedKind::Const(ct) => ct,
+                GenericArgKind::Const(ct) => ct,
                 c => bug!("{:?} is a const but value is {:?}", bound_ct, c),
             }
         };

src/librustc/infer/error_reporting/mod.rs

@@ -464,7 +464,7 @@ fn check_and_note_conflicting_crates(
         use hir::def_id::CrateNum;
         use hir::map::DisambiguatedDefPathData;
         use ty::print::Printer;
-        use ty::subst::Kind;
+        use ty::subst::GenericArg;
 
         struct AbsolutePathPrinter<'tcx> {
             tcx: TyCtxt<'tcx>,
@@ -548,7 +548,7 @@ fn path_append(
             fn path_generic_args(
                 self,
                 print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-                _args: &[Kind<'tcx>],
+                _args: &[GenericArg<'tcx>],
             ) -> Result<Self::Path, Self::Error> {
                 print_prefix(self)
             }

src/librustc/infer/mod.rs

@@ -20,7 +20,7 @@
 use crate::ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
 use crate::ty::fold::{TypeFolder, TypeFoldable};
 use crate::ty::relate::RelateResult;
-use crate::ty::subst::{Kind, InternalSubsts, SubstsRef};
+use crate::ty::subst::{GenericArg, InternalSubsts, SubstsRef};
 use crate::ty::{self, GenericParamDefKind, Ty, TyCtxt, InferConst};
 use crate::ty::{FloatVid, IntVid, TyVid, ConstVid};
 use crate::util::nodemap::FxHashMap;
@@ -1110,7 +1110,7 @@ pub fn next_nll_region_var_in_universe(
         self.next_region_var_in_universe(RegionVariableOrigin::NLL(origin), universe)
     }
 
-    pub fn var_for_def(&self, span: Span, param: &ty::GenericParamDef) -> Kind<'tcx> {
+    pub fn var_for_def(&self, span: Span, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
         match param.kind {
             GenericParamDefKind::Lifetime => {
                 // Create a region inference variable for the given

src/librustc/infer/nll_relate/mod.rs

@@ -26,7 +26,7 @@
 use crate::ty::error::TypeError;
 use crate::ty::fold::{TypeFoldable, TypeVisitor};
 use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
-use crate::ty::subst::Kind;
+use crate::ty::subst::GenericArg;
 use crate::ty::{self, Ty, TyCtxt, InferConst};
 use crate::mir::interpret::ConstValue;
 use rustc_data_structures::fx::FxHashMap;
@@ -124,7 +124,7 @@ pub trait TypeRelatingDelegate<'tcx> {
 #[derive(Clone, Debug)]
 struct ScopesAndKind<'tcx> {
     scopes: Vec<BoundRegionScope<'tcx>>,
-    kind: Kind<'tcx>,
+    kind: GenericArg<'tcx>,
 }
 
 #[derive(Clone, Debug, Default)]

src/librustc/infer/opaque_types/mod.rs

@@ -7,7 +7,7 @@
 use crate::mir::interpret::ConstValue;
 use crate::traits::{self, PredicateObligation};
 use crate::ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder, TypeVisitor};
-use crate::ty::subst::{InternalSubsts, Kind, SubstsRef, UnpackedKind};
+use crate::ty::subst::{InternalSubsts, GenericArg, SubstsRef, GenericArgKind};
 use crate::ty::{self, GenericParamDefKind, Ty, TyCtxt};
 use crate::util::nodemap::DefIdMap;
 use errors::DiagnosticBuilder;
@@ -570,7 +570,7 @@ pub fn infer_opaque_definition_from_instantiation(
         // `impl Trait` return type, resulting in the parameters
         // shifting.
         let id_substs = InternalSubsts::identity_for_item(gcx, def_id);
-        let map: FxHashMap<Kind<'tcx>, Kind<'tcx>> = opaque_defn
+        let map: FxHashMap<GenericArg<'tcx>, GenericArg<'tcx>> = opaque_defn
             .substs
             .iter()
             .enumerate()
@@ -759,7 +759,7 @@ struct ReverseMapper<'tcx> {
     tainted_by_errors: bool,
 
     opaque_type_def_id: DefId,
-    map: FxHashMap<Kind<'tcx>, Kind<'tcx>>,
+    map: FxHashMap<GenericArg<'tcx>, GenericArg<'tcx>>,
     map_missing_regions_to_empty: bool,
 
     /// initially `Some`, set to `None` once error has been reported
@@ -774,7 +774,7 @@ fn new(
         tcx: TyCtxt<'tcx>,
         tainted_by_errors: bool,
         opaque_type_def_id: DefId,
-        map: FxHashMap<Kind<'tcx>, Kind<'tcx>>,
+        map: FxHashMap<GenericArg<'tcx>, GenericArg<'tcx>>,
         hidden_ty: Ty<'tcx>,
         span: Span,
     ) -> Self {
@@ -789,7 +789,10 @@ fn new(
         }
     }
 
-    fn fold_kind_mapping_missing_regions_to_empty(&mut self, kind: Kind<'tcx>) -> Kind<'tcx> {
+    fn fold_kind_mapping_missing_regions_to_empty(
+        &mut self,
+        kind: GenericArg<'tcx>,
+    ) -> GenericArg<'tcx> {
         assert!(!self.map_missing_regions_to_empty);
         self.map_missing_regions_to_empty = true;
         let kind = kind.fold_with(self);
@@ -797,7 +800,7 @@ fn fold_kind_mapping_missing_regions_to_empty(&mut self, kind: Kind<'tcx>) -> Ki
         kind
     }
 
-    fn fold_kind_normally(&mut self, kind: Kind<'tcx>) -> Kind<'tcx> {
+    fn fold_kind_normally(&mut self, kind: GenericArg<'tcx>) -> GenericArg<'tcx> {
         assert!(!self.map_missing_regions_to_empty);
         kind.fold_with(self)
     }
@@ -822,7 +825,7 @@ fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
 
         let generics = self.tcx().generics_of(self.opaque_type_def_id);
         match self.map.get(&r.into()).map(|k| k.unpack()) {
-            Some(UnpackedKind::Lifetime(r1)) => r1,
+            Some(GenericArgKind::Lifetime(r1)) => r1,
             Some(u) => panic!("region mapped to unexpected kind: {:?}", u),
             None if generics.parent.is_some() => {
                 if !self.map_missing_regions_to_empty && !self.tainted_by_errors {
@@ -919,7 +922,7 @@ fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
                 match self.map.get(&ty.into()).map(|k| k.unpack()) {
                     // Found it in the substitution list; replace with the parameter from the
                     // opaque type.
-                    Some(UnpackedKind::Type(t1)) => t1,
+                    Some(GenericArgKind::Type(t1)) => t1,
                     Some(u) => panic!("type mapped to unexpected kind: {:?}", u),
                     None => {
                         self.tcx.sess
@@ -949,7 +952,7 @@ fn fold_const(&mut self, ct: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
                 match self.map.get(&ct.into()).map(|k| k.unpack()) {
                     // Found it in the substitution list, replace with the parameter from the
                     // opaque type.
-                    Some(UnpackedKind::Const(c1)) => c1,
+                    Some(GenericArgKind::Const(c1)) => c1,
                     Some(u) => panic!("const mapped to unexpected kind: {:?}", u),
                     None => {
                         self.tcx.sess

src/librustc/infer/outlives/obligations.rs

@@ -67,7 +67,7 @@
 use crate::traits::ObligationCause;
 use crate::ty::outlives::Component;
 use crate::ty::{self, Region, Ty, TyCtxt, TypeFoldable};
-use crate::ty::subst::UnpackedKind;
+use crate::ty::subst::GenericArgKind;
 
 impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// Registers that the given region obligation must be resolved
@@ -433,13 +433,13 @@ fn projection_must_outlive(
 
             for k in projection_ty.substs {
                 match k.unpack() {
-                    UnpackedKind::Lifetime(lt) => {
+                    GenericArgKind::Lifetime(lt) => {
                         self.delegate.push_sub_region_constraint(origin.clone(), region, lt);
                     }
-                    UnpackedKind::Type(ty) => {
+                    GenericArgKind::Type(ty) => {
                         self.type_must_outlive(origin.clone(), ty, region);
                     }
-                    UnpackedKind::Const(_) => {
+                    GenericArgKind::Const(_) => {
                         // Const parameters don't impose constraints.
                     }
                 }

src/librustc/lint/context.rs

@@ -27,7 +27,7 @@
 use crate::lint::levels::{LintLevelSets, LintLevelsBuilder};
 use crate::middle::privacy::AccessLevels;
 use crate::session::{config, early_error, Session};
-use crate::ty::{self, print::Printer, subst::Kind, TyCtxt, Ty};
+use crate::ty::{self, print::Printer, subst::GenericArg, TyCtxt, Ty};
 use crate::ty::layout::{LayoutError, LayoutOf, TyLayout};
 use crate::util::nodemap::FxHashMap;
 use crate::util::common::time;
@@ -882,7 +882,7 @@ fn path_append(
             fn path_generic_args(
                 self,
                 print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-                _args: &[Kind<'tcx>],
+                _args: &[GenericArg<'tcx>],
             ) -> Result<Self::Path, Self::Error> {
                 print_prefix(self)
             }

src/librustc/mir/interpret/mod.rs

@@ -109,7 +109,7 @@ macro_rules! throw_exhaust {
 
 use crate::mir;
 use crate::hir::def_id::DefId;
-use crate::ty::{self, TyCtxt, Instance, subst::UnpackedKind};
+use crate::ty::{self, TyCtxt, Instance, subst::GenericArgKind};
 use crate::ty::codec::TyDecoder;
 use crate::ty::layout::{self, Size};
 use std::io;
@@ -426,7 +426,7 @@ pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> AllocId {
         // this for generic functions.  Lifetime parameters are ignored.
         let is_generic = instance.substs.into_iter().any(|kind| {
             match kind.unpack() {
-                UnpackedKind::Lifetime(_) => false,
+                GenericArgKind::Lifetime(_) => false,
                 _ => true,
             }
         });

src/librustc/traits/query/dropck_outlives.rs

@@ -3,7 +3,7 @@
 use crate::infer::canonical::OriginalQueryValues;
 use std::iter::FromIterator;
 use syntax::source_map::Span;
-use crate::ty::subst::Kind;
+use crate::ty::subst::GenericArg;
 use crate::ty::{self, Ty, TyCtxt};
 
 impl<'cx, 'tcx> At<'cx, 'tcx> {
@@ -24,7 +24,7 @@ impl<'cx, 'tcx> At<'cx, 'tcx> {
     ///
     /// [#1238]: https://github.com/rust-lang/rfcs/blob/master/text/1238-nonparametric-dropck.md
     /// [#1327]: https://github.com/rust-lang/rfcs/blob/master/text/1327-dropck-param-eyepatch.md
-    pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<Kind<'tcx>>> {
+    pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<GenericArg<'tcx>>> {
         debug!(
             "dropck_outlives(ty={:?}, param_env={:?})",
             ty, self.param_env,
@@ -80,7 +80,7 @@ pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<Kind<'tcx>>> {
 
 #[derive(Clone, Debug, Default)]
 pub struct DropckOutlivesResult<'tcx> {
-    pub kinds: Vec<Kind<'tcx>>,
+    pub kinds: Vec<GenericArg<'tcx>>,
     pub overflows: Vec<Ty<'tcx>>,
 }
 
@@ -104,7 +104,7 @@ pub fn into_kinds_reporting_overflows(
         tcx: TyCtxt<'tcx>,
         span: Span,
         ty: Ty<'tcx>,
-    ) -> Vec<Kind<'tcx>> {
+    ) -> Vec<GenericArg<'tcx>> {
         self.report_overflows(tcx, span, ty);
         let DropckOutlivesResult { kinds, overflows: _ } = self;
         kinds
@@ -117,7 +117,7 @@ pub fn into_kinds_reporting_overflows(
 pub struct DtorckConstraint<'tcx> {
     /// Types that are required to be alive in order for this
     /// type to be valid for destruction.
-    pub outlives: Vec<ty::subst::Kind<'tcx>>,
+    pub outlives: Vec<ty::subst::GenericArg<'tcx>>,
 
     /// Types that could not be resolved: projections and params.
     pub dtorck_types: Vec<Ty<'tcx>>,

src/librustc/traits/util.rs

@@ -7,7 +7,7 @@
 use crate::traits::specialize::specialization_graph::NodeItem;
 use crate::ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef};
 use crate::ty::outlives::Component;
-use crate::ty::subst::{Kind, Subst, SubstsRef};
+use crate::ty::subst::{GenericArg, Subst, SubstsRef};
 use crate::util::nodemap::FxHashSet;
 
 use super::{Obligation, ObligationCause, PredicateObligation, SelectionContext, Normalized};
@@ -551,7 +551,7 @@ pub fn predicate_for_trait_def(self,
                                    trait_def_id: DefId,
                                    recursion_depth: usize,
                                    self_ty: Ty<'tcx>,
-                                   params: &[Kind<'tcx>])
+                                   params: &[GenericArg<'tcx>])
         -> PredicateObligation<'tcx>
     {
         let trait_ref = ty::TraitRef {

src/librustc/ty/context.rs

@@ -23,7 +23,7 @@
 use crate::middle::stability;
 use crate::mir::{Body, interpret, ProjectionKind, Promoted};
 use crate::mir::interpret::{ConstValue, Allocation, Scalar};
-use crate::ty::subst::{Kind, InternalSubsts, SubstsRef, Subst};
+use crate::ty::subst::{GenericArg, InternalSubsts, SubstsRef, Subst};
 use crate::ty::ReprOptions;
 use crate::traits;
 use crate::traits::{Clause, Clauses, GoalKind, Goal, Goals};
@@ -39,7 +39,7 @@
 use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx};
 use crate::ty::query;
 use crate::ty::steal::Steal;
-use crate::ty::subst::{UserSubsts, UnpackedKind};
+use crate::ty::subst::{UserSubsts, GenericArgKind};
 use crate::ty::{BoundVar, BindingMode};
 use crate::ty::CanonicalPolyFnSig;
 use crate::util::common::ErrorReported;
@@ -828,7 +828,7 @@ pub fn is_identity(&self) -> bool {
 
                 user_substs.substs.iter().zip(BoundVar::new(0)..).all(|(kind, cvar)| {
                     match kind.unpack() {
-                        UnpackedKind::Type(ty) => match ty.kind {
+                        GenericArgKind::Type(ty) => match ty.kind {
                             ty::Bound(debruijn, b) => {
                                 // We only allow a `ty::INNERMOST` index in substitutions.
                                 assert_eq!(debruijn, ty::INNERMOST);
@@ -837,7 +837,7 @@ pub fn is_identity(&self) -> bool {
                             _ => false,
                         },
 
-                        UnpackedKind::Lifetime(r) => match r {
+                        GenericArgKind::Lifetime(r) => match r {
                             ty::ReLateBound(debruijn, br) => {
                                 // We only allow a `ty::INNERMOST` index in substitutions.
                                 assert_eq!(*debruijn, ty::INNERMOST);
@@ -846,7 +846,7 @@ pub fn is_identity(&self) -> bool {
                             _ => false,
                         },
 
-                        UnpackedKind::Const(ct) => match ct.val {
+                        GenericArgKind::Const(ct) => match ct.val {
                             ConstValue::Infer(InferConst::Canonical(debruijn, b)) => {
                                 // We only allow a `ty::INNERMOST` index in substitutions.
                                 assert_eq!(debruijn, ty::INNERMOST);
@@ -1701,7 +1701,7 @@ fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
 nop_list_lift!{ProjectionKind => ProjectionKind}
 
 // This is the impl for `&'a InternalSubsts<'a>`.
-nop_list_lift!{Kind<'a> => Kind<'tcx>}
+nop_list_lift!{GenericArg<'a> => GenericArg<'tcx>}
 
 pub mod tls {
     use super::{GlobalCtxt, TyCtxt, ptr_eq};
@@ -2129,8 +2129,8 @@ fn borrow(&self) -> &[CanonicalVarInfo] {
     }
 }
 
-impl<'tcx> Borrow<[Kind<'tcx>]> for Interned<'tcx, InternalSubsts<'tcx>> {
-    fn borrow<'a>(&'a self) -> &'a [Kind<'tcx>] {
+impl<'tcx> Borrow<[GenericArg<'tcx>]> for Interned<'tcx, InternalSubsts<'tcx>> {
+    fn borrow<'a>(&'a self) -> &'a [GenericArg<'tcx>] {
         &self.0[..]
     }
 }
@@ -2250,7 +2250,7 @@ macro_rules! slice_interners {
     existential_predicates: _intern_existential_predicates(ExistentialPredicate<'tcx>),
     predicates: _intern_predicates(Predicate<'tcx>),
     type_list: _intern_type_list(Ty<'tcx>),
-    substs: _intern_substs(Kind<'tcx>),
+    substs: _intern_substs(GenericArg<'tcx>),
     clauses: _intern_clauses(Clause<'tcx>),
     goal_list: _intern_goals(Goal<'tcx>),
     projs: _intern_projs(ProjectionKind)
@@ -2452,13 +2452,13 @@ pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
 
     #[inline]
     pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
-        let kinds: Vec<_> = ts.into_iter().map(|&t| Kind::from(t)).collect();
+        let kinds: Vec<_> = ts.into_iter().map(|&t| GenericArg::from(t)).collect();
         self.mk_ty(Tuple(self.intern_substs(&kinds)))
     }
 
     pub fn mk_tup<I: InternAs<[Ty<'tcx>], Ty<'tcx>>>(self, iter: I) -> I::Output {
         iter.intern_with(|ts| {
-            let kinds: Vec<_> = ts.into_iter().map(|&t| Kind::from(t)).collect();
+            let kinds: Vec<_> = ts.into_iter().map(|&t| GenericArg::from(t)).collect();
             self.mk_ty(Tuple(self.intern_substs(&kinds)))
         })
     }
@@ -2592,7 +2592,7 @@ pub fn mk_const_param(
     }
 
 
-    pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> Kind<'tcx> {
+    pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
         match param.kind {
             GenericParamDefKind::Lifetime => {
                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
@@ -2637,7 +2637,7 @@ pub fn intern_type_list(self, ts: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
         }
     }
 
-    pub fn intern_substs(self, ts: &[Kind<'tcx>]) -> &'tcx List<Kind<'tcx>> {
+    pub fn intern_substs(self, ts: &[GenericArg<'tcx>]) -> &'tcx List<GenericArg<'tcx>> {
         if ts.len() == 0 {
             List::empty()
         } else {
@@ -2710,14 +2710,14 @@ pub fn mk_type_list<I: InternAs<[Ty<'tcx>],
         iter.intern_with(|xs| self.intern_type_list(xs))
     }
 
-    pub fn mk_substs<I: InternAs<[Kind<'tcx>],
-                     &'tcx List<Kind<'tcx>>>>(self, iter: I) -> I::Output {
+    pub fn mk_substs<I: InternAs<[GenericArg<'tcx>],
+                     &'tcx List<GenericArg<'tcx>>>>(self, iter: I) -> I::Output {
         iter.intern_with(|xs| self.intern_substs(xs))
     }
 
     pub fn mk_substs_trait(self,
                      self_ty: Ty<'tcx>,
-                     rest: &[Kind<'tcx>])
+                     rest: &[GenericArg<'tcx>])
                     -> SubstsRef<'tcx>
     {
         self.mk_substs(iter::once(self_ty.into()).chain(rest.iter().cloned()))

src/librustc/ty/flags.rs

@@ -1,4 +1,4 @@
-use crate::ty::subst::{SubstsRef, UnpackedKind};
+use crate::ty::subst::{SubstsRef, GenericArgKind};
 use crate::ty::{self, Ty, TypeFlags, InferConst};
 use crate::mir::interpret::ConstValue;
 
@@ -266,9 +266,9 @@ fn add_projection_ty(&mut self, projection_ty: &ty::ProjectionTy<'_>) {
     fn add_substs(&mut self, substs: SubstsRef<'_>) {
         for kind in substs {
             match kind.unpack() {
-                UnpackedKind::Type(ty) => self.add_ty(ty),
-                UnpackedKind::Lifetime(lt) => self.add_region(lt),
-                UnpackedKind::Const(ct) => self.add_const(ct),
+                GenericArgKind::Type(ty) => self.add_ty(ty),
+                GenericArgKind::Lifetime(lt) => self.add_region(lt),
+                GenericArgKind::Const(ct) => self.add_const(ct),
             }
         }
     }

src/librustc/ty/print/mod.rs

@@ -1,7 +1,7 @@
 use crate::hir::map::{DefPathData, DisambiguatedDefPathData};
 use crate::hir::def_id::{CrateNum, DefId};
 use crate::ty::{self, DefIdTree, Ty, TyCtxt};
-use crate::ty::subst::{Kind, Subst};
+use crate::ty::subst::{GenericArg, Subst};
 
 use rustc_data_structures::fx::FxHashSet;
 
@@ -43,7 +43,7 @@ pub trait Printer<'tcx>: Sized {
     fn print_def_path(
         self,
         def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         self.default_print_def_path(def_id, substs)
     }
@@ -51,7 +51,7 @@ fn print_def_path(
     fn print_impl_path(
         self,
         impl_def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
         self_ty: Ty<'tcx>,
         trait_ref: Option<ty::TraitRef<'tcx>>,
     ) -> Result<Self::Path, Self::Error> {
@@ -106,7 +106,7 @@ fn path_append(
     fn path_generic_args(
         self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-        args: &[Kind<'tcx>],
+        args: &[GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error>;
 
     // Defaults (should not be overriden):
@@ -114,7 +114,7 @@ fn path_generic_args(
     fn default_print_def_path(
         self,
         def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         debug!("default_print_def_path: def_id={:?}, substs={:?}", def_id, substs);
         let key = self.tcx().def_key(def_id);
@@ -189,8 +189,8 @@ fn default_print_def_path(
     fn generic_args_to_print(
         &self,
         generics: &'tcx ty::Generics,
-        substs: &'tcx [Kind<'tcx>],
-    ) -> &'tcx [Kind<'tcx>] {
+        substs: &'tcx [GenericArg<'tcx>],
+    ) -> &'tcx [GenericArg<'tcx>] {
         let mut own_params = generics.parent_count..generics.count();
 
         // Don't print args for `Self` parameters (of traits).
@@ -203,7 +203,7 @@ fn generic_args_to_print(
             match param.kind {
                 ty::GenericParamDefKind::Lifetime => false,
                 ty::GenericParamDefKind::Type { has_default, .. } => {
-                    has_default && substs[param.index as usize] == Kind::from(
+                    has_default && substs[param.index as usize] == GenericArg::from(
                         self.tcx().type_of(param.def_id).subst(self.tcx(), substs)
                     )
                 }
@@ -217,7 +217,7 @@ fn generic_args_to_print(
     fn default_print_impl_path(
         self,
         impl_def_id: DefId,
-        _substs: &'tcx [Kind<'tcx>],
+        _substs: &'tcx [GenericArg<'tcx>],
         self_ty: Ty<'tcx>,
         impl_trait_ref: Option<ty::TraitRef<'tcx>>,
     ) -> Result<Self::Path, Self::Error> {

src/librustc/ty/print/pretty.rs

@@ -5,7 +5,7 @@
 use crate::middle::cstore::{ExternCrate, ExternCrateSource};
 use crate::middle::region;
 use crate::ty::{self, DefIdTree, ParamConst, Ty, TyCtxt, TypeFoldable};
-use crate::ty::subst::{Kind, Subst, UnpackedKind};
+use crate::ty::subst::{GenericArg, Subst, GenericArgKind};
 use crate::ty::layout::{Integer, IntegerExt, Size};
 use crate::mir::interpret::{ConstValue, sign_extend, Scalar, truncate};
 
@@ -183,7 +183,7 @@ pub trait PrettyPrinter<'tcx>:
     fn print_value_path(
         self,
         def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         self.print_def_path(def_id, substs)
     }
@@ -764,13 +764,13 @@ fn pretty_print_dyn_existential(
                 // Don't print `'_` if there's no unerased regions.
                 let print_regions = args.iter().any(|arg| {
                     match arg.unpack() {
-                        UnpackedKind::Lifetime(r) => *r != ty::ReErased,
+                        GenericArgKind::Lifetime(r) => *r != ty::ReErased,
                         _ => false,
                     }
                 });
                 let mut args = args.iter().cloned().filter(|arg| {
                     match arg.unpack() {
-                        UnpackedKind::Lifetime(_) => print_regions,
+                        GenericArgKind::Lifetime(_) => print_regions,
                         _ => true,
                     }
                 });
@@ -1081,7 +1081,7 @@ fn tcx(&'a self) -> TyCtxt<'tcx> {
     fn print_def_path(
         mut self,
         def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         define_scoped_cx!(self);
 
@@ -1245,20 +1245,20 @@ fn path_append(
     fn path_generic_args(
         mut self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-        args: &[Kind<'tcx>],
+        args: &[GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         self = print_prefix(self)?;
 
         // Don't print `'_` if there's no unerased regions.
         let print_regions = args.iter().any(|arg| {
             match arg.unpack() {
-                UnpackedKind::Lifetime(r) => *r != ty::ReErased,
+                GenericArgKind::Lifetime(r) => *r != ty::ReErased,
                 _ => false,
             }
         });
         let args = args.iter().cloned().filter(|arg| {
             match arg.unpack() {
-                UnpackedKind::Lifetime(_) => print_regions,
+                GenericArgKind::Lifetime(_) => print_regions,
                 _ => true,
             }
         });
@@ -1282,7 +1282,7 @@ fn infer_ty_name(&self, id: ty::TyVid) -> Option<String> {
     fn print_value_path(
         mut self,
         def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         let was_in_value = std::mem::replace(&mut self.in_value, true);
         self = self.print_def_path(def_id, substs)?;
@@ -1778,11 +1778,11 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         }
     }
 
-    Kind<'tcx> {
+    GenericArg<'tcx> {
         match self.unpack() {
-            UnpackedKind::Lifetime(lt) => p!(print(lt)),
-            UnpackedKind::Type(ty) => p!(print(ty)),
-            UnpackedKind::Const(ct) => p!(print(ct)),
+            GenericArgKind::Lifetime(lt) => p!(print(lt)),
+            GenericArgKind::Type(ty) => p!(print(ty)),
+            GenericArgKind::Const(ct) => p!(print(ct)),
         }
     }
 }

src/librustc/ty/relate.rs

@@ -5,7 +5,7 @@
 //! subtyping, type equality, etc.
 
 use crate::hir::def_id::DefId;
-use crate::ty::subst::{Kind, UnpackedKind, SubstsRef};
+use crate::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use crate::ty::{self, Ty, TyCtxt, TypeFoldable};
 use crate::ty::error::{ExpectedFound, TypeError};
 use crate::mir::interpret::{ConstValue, Scalar};
@@ -711,29 +711,29 @@ fn relate<R: TypeRelation<'tcx>>(
     }
 }
 
-impl<'tcx> Relate<'tcx> for Kind<'tcx> {
+impl<'tcx> Relate<'tcx> for GenericArg<'tcx> {
     fn relate<R: TypeRelation<'tcx>>(
         relation: &mut R,
-        a: &Kind<'tcx>,
-        b: &Kind<'tcx>,
-    ) -> RelateResult<'tcx, Kind<'tcx>> {
+        a: &GenericArg<'tcx>,
+        b: &GenericArg<'tcx>,
+    ) -> RelateResult<'tcx, GenericArg<'tcx>> {
         match (a.unpack(), b.unpack()) {
-            (UnpackedKind::Lifetime(a_lt), UnpackedKind::Lifetime(b_lt)) => {
+            (GenericArgKind::Lifetime(a_lt), GenericArgKind::Lifetime(b_lt)) => {
                 Ok(relation.relate(&a_lt, &b_lt)?.into())
             }
-            (UnpackedKind::Type(a_ty), UnpackedKind::Type(b_ty)) => {
+            (GenericArgKind::Type(a_ty), GenericArgKind::Type(b_ty)) => {
                 Ok(relation.relate(&a_ty, &b_ty)?.into())
             }
-            (UnpackedKind::Const(a_ct), UnpackedKind::Const(b_ct)) => {
+            (GenericArgKind::Const(a_ct), GenericArgKind::Const(b_ct)) => {
                 Ok(relation.relate(&a_ct, &b_ct)?.into())
             }
-            (UnpackedKind::Lifetime(unpacked), x) => {
+            (GenericArgKind::Lifetime(unpacked), x) => {
                 bug!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
             }
-            (UnpackedKind::Type(unpacked), x) => {
+            (GenericArgKind::Type(unpacked), x) => {
                 bug!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
             }
-            (UnpackedKind::Const(unpacked), x) => {
+            (GenericArgKind::Const(unpacked), x) => {
                 bug!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
             }
         }

src/librustc/ty/sty.rs

@@ -10,7 +10,7 @@
 use polonius_engine::Atom;
 use rustc_data_structures::indexed_vec::Idx;
 use rustc_macros::HashStable;
-use crate::ty::subst::{InternalSubsts, Subst, SubstsRef, Kind, UnpackedKind};
+use crate::ty::subst::{InternalSubsts, Subst, SubstsRef, GenericArg, GenericArgKind};
 use crate::ty::{self, AdtDef, Discr, DefIdTree, TypeFlags, Ty, TyCtxt, TypeFoldable};
 use crate::ty::{List, TyS, ParamEnvAnd, ParamEnv};
 use crate::ty::layout::VariantIdx;
@@ -320,7 +320,7 @@ pub struct ClosureSubsts<'tcx> {
 struct SplitClosureSubsts<'tcx> {
     closure_kind_ty: Ty<'tcx>,
     closure_sig_ty: Ty<'tcx>,
-    upvar_kinds: &'tcx [Kind<'tcx>],
+    upvar_kinds: &'tcx [GenericArg<'tcx>],
 }
 
 impl<'tcx> ClosureSubsts<'tcx> {
@@ -345,7 +345,7 @@ pub fn upvar_tys(
     ) -> impl Iterator<Item = Ty<'tcx>> + 'tcx {
         let SplitClosureSubsts { upvar_kinds, .. } = self.split(def_id, tcx);
         upvar_kinds.iter().map(|t| {
-            if let UnpackedKind::Type(ty) = t.unpack() {
+            if let GenericArgKind::Type(ty) = t.unpack() {
                 ty
             } else {
                 bug!("upvar should be type")
@@ -402,7 +402,7 @@ struct SplitGeneratorSubsts<'tcx> {
     yield_ty: Ty<'tcx>,
     return_ty: Ty<'tcx>,
     witness: Ty<'tcx>,
-    upvar_kinds: &'tcx [Kind<'tcx>],
+    upvar_kinds: &'tcx [GenericArg<'tcx>],
 }
 
 impl<'tcx> GeneratorSubsts<'tcx> {
@@ -434,7 +434,7 @@ pub fn upvar_tys(
     ) -> impl Iterator<Item = Ty<'tcx>> + 'tcx {
         let SplitGeneratorSubsts { upvar_kinds, .. } = self.split(def_id, tcx);
         upvar_kinds.iter().map(|t| {
-            if let UnpackedKind::Type(ty) = t.unpack() {
+            if let GenericArgKind::Type(ty) = t.unpack() {
                 ty
             } else {
                 bug!("upvar should be type")
@@ -584,7 +584,7 @@ pub fn upvar_tys(
             UpvarSubsts::Generator(substs) => substs.split(def_id, tcx).upvar_kinds,
         };
         upvar_kinds.iter().map(|t| {
-            if let UnpackedKind::Type(ty) = t.unpack() {
+            if let GenericArgKind::Type(ty) = t.unpack() {
                 ty
             } else {
                 bug!("upvar should be type")

src/librustc/ty/subst.rs

@@ -20,11 +20,11 @@
 
 /// An entity in the Rust type system, which can be one of
 /// several kinds (types, lifetimes, and consts).
-/// To reduce memory usage, a `Kind` is a interned pointer,
+/// To reduce memory usage, a `GenericArg` is a interned pointer,
 /// with the lowest 2 bits being reserved for a tag to
 /// indicate the type (`Ty`, `Region`, or `Const`) it points to.
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Kind<'tcx> {
+pub struct GenericArg<'tcx> {
     ptr: NonZeroUsize,
     marker: PhantomData<(Ty<'tcx>, ty::Region<'tcx>, &'tcx ty::Const<'tcx>)>
 }
@@ -35,33 +35,33 @@ pub struct Kind<'tcx> {
 const CONST_TAG: usize = 0b10;
 
 #[derive(Debug, RustcEncodable, RustcDecodable, PartialEq, Eq, PartialOrd, Ord, HashStable)]
-pub enum UnpackedKind<'tcx> {
+pub enum GenericArgKind<'tcx> {
     Lifetime(ty::Region<'tcx>),
     Type(Ty<'tcx>),
     Const(&'tcx ty::Const<'tcx>),
 }
 
-impl<'tcx> UnpackedKind<'tcx> {
-    fn pack(self) -> Kind<'tcx> {
+impl<'tcx> GenericArgKind<'tcx> {
+    fn pack(self) -> GenericArg<'tcx> {
         let (tag, ptr) = match self {
-            UnpackedKind::Lifetime(lt) => {
+            GenericArgKind::Lifetime(lt) => {
                 // Ensure we can use the tag bits.
                 assert_eq!(mem::align_of_val(lt) & TAG_MASK, 0);
                 (REGION_TAG, lt as *const _ as usize)
             }
-            UnpackedKind::Type(ty) => {
+            GenericArgKind::Type(ty) => {
                 // Ensure we can use the tag bits.
                 assert_eq!(mem::align_of_val(ty) & TAG_MASK, 0);
                 (TYPE_TAG, ty as *const _ as usize)
             }
-            UnpackedKind::Const(ct) => {
+            GenericArgKind::Const(ct) => {
                 // Ensure we can use the tag bits.
                 assert_eq!(mem::align_of_val(ct) & TAG_MASK, 0);
                 (CONST_TAG, ct as *const _ as usize)
             }
         };
 
-        Kind {
+        GenericArg {
             ptr: unsafe {
                 NonZeroUsize::new_unchecked(ptr | tag)
             },
@@ -70,115 +70,115 @@ fn pack(self) -> Kind<'tcx> {
     }
 }
 
-impl fmt::Debug for Kind<'tcx> {
+impl fmt::Debug for GenericArg<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.unpack() {
-            UnpackedKind::Lifetime(lt) => lt.fmt(f),
-            UnpackedKind::Type(ty) => ty.fmt(f),
-            UnpackedKind::Const(ct) => ct.fmt(f),
+            GenericArgKind::Lifetime(lt) => lt.fmt(f),
+            GenericArgKind::Type(ty) => ty.fmt(f),
+            GenericArgKind::Const(ct) => ct.fmt(f),
         }
     }
 }
 
-impl<'tcx> Ord for Kind<'tcx> {
-    fn cmp(&self, other: &Kind<'_>) -> Ordering {
+impl<'tcx> Ord for GenericArg<'tcx> {
+    fn cmp(&self, other: &GenericArg<'_>) -> Ordering {
         self.unpack().cmp(&other.unpack())
     }
 }
 
-impl<'tcx> PartialOrd for Kind<'tcx> {
-    fn partial_cmp(&self, other: &Kind<'_>) -> Option<Ordering> {
+impl<'tcx> PartialOrd for GenericArg<'tcx> {
+    fn partial_cmp(&self, other: &GenericArg<'_>) -> Option<Ordering> {
         Some(self.cmp(&other))
     }
 }
 
-impl<'tcx> From<ty::Region<'tcx>> for Kind<'tcx> {
-    fn from(r: ty::Region<'tcx>) -> Kind<'tcx> {
-        UnpackedKind::Lifetime(r).pack()
+impl<'tcx> From<ty::Region<'tcx>> for GenericArg<'tcx> {
+    fn from(r: ty::Region<'tcx>) -> GenericArg<'tcx> {
+        GenericArgKind::Lifetime(r).pack()
     }
 }
 
-impl<'tcx> From<Ty<'tcx>> for Kind<'tcx> {
-    fn from(ty: Ty<'tcx>) -> Kind<'tcx> {
-        UnpackedKind::Type(ty).pack()
+impl<'tcx> From<Ty<'tcx>> for GenericArg<'tcx> {
+    fn from(ty: Ty<'tcx>) -> GenericArg<'tcx> {
+        GenericArgKind::Type(ty).pack()
     }
 }
 
-impl<'tcx> From<&'tcx ty::Const<'tcx>> for Kind<'tcx> {
-    fn from(c: &'tcx ty::Const<'tcx>) -> Kind<'tcx> {
-        UnpackedKind::Const(c).pack()
+impl<'tcx> From<&'tcx ty::Const<'tcx>> for GenericArg<'tcx> {
+    fn from(c: &'tcx ty::Const<'tcx>) -> GenericArg<'tcx> {
+        GenericArgKind::Const(c).pack()
     }
 }
 
-impl<'tcx> Kind<'tcx> {
+impl<'tcx> GenericArg<'tcx> {
     #[inline]
-    pub fn unpack(self) -> UnpackedKind<'tcx> {
+    pub fn unpack(self) -> GenericArgKind<'tcx> {
         let ptr = self.ptr.get();
         unsafe {
             match ptr & TAG_MASK {
-                REGION_TAG => UnpackedKind::Lifetime(&*((ptr & !TAG_MASK) as *const _)),
-                TYPE_TAG => UnpackedKind::Type(&*((ptr & !TAG_MASK) as *const _)),
-                CONST_TAG => UnpackedKind::Const(&*((ptr & !TAG_MASK) as *const _)),
+                REGION_TAG => GenericArgKind::Lifetime(&*((ptr & !TAG_MASK) as *const _)),
+                TYPE_TAG => GenericArgKind::Type(&*((ptr & !TAG_MASK) as *const _)),
+                CONST_TAG => GenericArgKind::Const(&*((ptr & !TAG_MASK) as *const _)),
                 _ => intrinsics::unreachable()
             }
         }
     }
 
-    /// Unpack the `Kind` as a type when it is known certainly to be a type.
+    /// Unpack the `GenericArg` as a type when it is known certainly to be a type.
     /// This is true in cases where `Substs` is used in places where the kinds are known
     /// to be limited (e.g. in tuples, where the only parameters are type parameters).
     pub fn expect_ty(self) -> Ty<'tcx> {
         match self.unpack() {
-            UnpackedKind::Type(ty) => ty,
+            GenericArgKind::Type(ty) => ty,
             _ => bug!("expected a type, but found another kind"),
         }
     }
 }
 
-impl<'a, 'tcx> Lift<'tcx> for Kind<'a> {
-    type Lifted = Kind<'tcx>;
+impl<'a, 'tcx> Lift<'tcx> for GenericArg<'a> {
+    type Lifted = GenericArg<'tcx>;
 
     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
         match self.unpack() {
-            UnpackedKind::Lifetime(lt) => tcx.lift(&lt).map(|lt| lt.into()),
-            UnpackedKind::Type(ty) => tcx.lift(&ty).map(|ty| ty.into()),
-            UnpackedKind::Const(ct) => tcx.lift(&ct).map(|ct| ct.into()),
+            GenericArgKind::Lifetime(lt) => tcx.lift(&lt).map(|lt| lt.into()),
+            GenericArgKind::Type(ty) => tcx.lift(&ty).map(|ty| ty.into()),
+            GenericArgKind::Const(ct) => tcx.lift(&ct).map(|ct| ct.into()),
         }
     }
 }
 
-impl<'tcx> TypeFoldable<'tcx> for Kind<'tcx> {
+impl<'tcx> TypeFoldable<'tcx> for GenericArg<'tcx> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         match self.unpack() {
-            UnpackedKind::Lifetime(lt) => lt.fold_with(folder).into(),
-            UnpackedKind::Type(ty) => ty.fold_with(folder).into(),
-            UnpackedKind::Const(ct) => ct.fold_with(folder).into(),
+            GenericArgKind::Lifetime(lt) => lt.fold_with(folder).into(),
+            GenericArgKind::Type(ty) => ty.fold_with(folder).into(),
+            GenericArgKind::Const(ct) => ct.fold_with(folder).into(),
         }
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         match self.unpack() {
-            UnpackedKind::Lifetime(lt) => lt.visit_with(visitor),
-            UnpackedKind::Type(ty) => ty.visit_with(visitor),
-            UnpackedKind::Const(ct) => ct.visit_with(visitor),
+            GenericArgKind::Lifetime(lt) => lt.visit_with(visitor),
+            GenericArgKind::Type(ty) => ty.visit_with(visitor),
+            GenericArgKind::Const(ct) => ct.visit_with(visitor),
         }
     }
 }
 
-impl<'tcx> Encodable for Kind<'tcx> {
+impl<'tcx> Encodable for GenericArg<'tcx> {
     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
         self.unpack().encode(e)
     }
 }
 
-impl<'tcx> Decodable for Kind<'tcx> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Kind<'tcx>, D::Error> {
-        Ok(UnpackedKind::decode(d)?.pack())
+impl<'tcx> Decodable for GenericArg<'tcx> {
+    fn decode<D: Decoder>(d: &mut D) -> Result<GenericArg<'tcx>, D::Error> {
+        Ok(GenericArgKind::decode(d)?.pack())
     }
 }
 
 /// A substitution mapping generic parameters to new values.
-pub type InternalSubsts<'tcx> = List<Kind<'tcx>>;
+pub type InternalSubsts<'tcx> = List<GenericArg<'tcx>>;
 
 pub type SubstsRef<'tcx> = &'tcx InternalSubsts<'tcx>;
 
@@ -232,7 +232,7 @@ pub fn bound_vars_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> SubstsRef<'tcx>
     /// substitute defaults of generic parameters.
     pub fn for_item<F>(tcx: TyCtxt<'tcx>, def_id: DefId, mut mk_kind: F) -> SubstsRef<'tcx>
     where
-        F: FnMut(&ty::GenericParamDef, &[Kind<'tcx>]) -> Kind<'tcx>,
+        F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
     {
         let defs = tcx.generics_of(def_id);
         let count = defs.count();
@@ -243,7 +243,7 @@ pub fn for_item<F>(tcx: TyCtxt<'tcx>, def_id: DefId, mut mk_kind: F) -> SubstsRe
 
     pub fn extend_to<F>(&self, tcx: TyCtxt<'tcx>, def_id: DefId, mut mk_kind: F) -> SubstsRef<'tcx>
     where
-        F: FnMut(&ty::GenericParamDef, &[Kind<'tcx>]) -> Kind<'tcx>,
+        F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
     {
         Self::for_item(tcx, def_id, |param, substs| {
             self.get(param.index as usize)
@@ -253,12 +253,12 @@ pub fn extend_to<F>(&self, tcx: TyCtxt<'tcx>, def_id: DefId, mut mk_kind: F) ->
     }
 
     fn fill_item<F>(
-        substs: &mut SmallVec<[Kind<'tcx>; 8]>,
+        substs: &mut SmallVec<[GenericArg<'tcx>; 8]>,
         tcx: TyCtxt<'tcx>,
         defs: &ty::Generics,
         mk_kind: &mut F,
     ) where
-        F: FnMut(&ty::GenericParamDef, &[Kind<'tcx>]) -> Kind<'tcx>,
+        F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
     {
         if let Some(def_id) = defs.parent {
             let parent_defs = tcx.generics_of(def_id);
@@ -267,10 +267,10 @@ fn fill_item<F>(
         Self::fill_single(substs, defs, mk_kind)
     }
 
-    fn fill_single<F>(substs: &mut SmallVec<[Kind<'tcx>; 8]>,
+    fn fill_single<F>(substs: &mut SmallVec<[GenericArg<'tcx>; 8]>,
                       defs: &ty::Generics,
                       mk_kind: &mut F)
-    where F: FnMut(&ty::GenericParamDef, &[Kind<'tcx>]) -> Kind<'tcx>
+    where F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>
     {
         substs.reserve(defs.params.len());
         for param in &defs.params {
@@ -287,7 +287,7 @@ pub fn is_noop(&self) -> bool {
     #[inline]
     pub fn types(&'a self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> + 'a {
         self.iter().filter_map(|k| {
-            if let UnpackedKind::Type(ty) = k.unpack() {
+            if let GenericArgKind::Type(ty) = k.unpack() {
                 Some(ty)
             } else {
                 None
@@ -298,7 +298,7 @@ pub fn types(&'a self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> + 'a {
     #[inline]
     pub fn regions(&'a self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> + 'a {
         self.iter().filter_map(|k| {
-            if let UnpackedKind::Lifetime(lt) = k.unpack() {
+            if let GenericArgKind::Lifetime(lt) = k.unpack() {
                 Some(lt)
             } else {
                 None
@@ -309,7 +309,7 @@ pub fn regions(&'a self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> +
     #[inline]
     pub fn consts(&'a self) -> impl DoubleEndedIterator<Item = &'tcx ty::Const<'tcx>> + 'a {
         self.iter().filter_map(|k| {
-            if let UnpackedKind::Const(ct) = k.unpack() {
+            if let GenericArgKind::Const(ct) = k.unpack() {
                 Some(ct)
             } else {
                 None
@@ -320,10 +320,10 @@ pub fn consts(&'a self) -> impl DoubleEndedIterator<Item = &'tcx ty::Const<'tcx>
     #[inline]
     pub fn non_erasable_generics(
         &'a self
-    ) -> impl DoubleEndedIterator<Item = UnpackedKind<'tcx>> + 'a {
+    ) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> + 'a {
         self.iter().filter_map(|k| {
             match k.unpack() {
-                UnpackedKind::Lifetime(_) => None,
+                GenericArgKind::Lifetime(_) => None,
                 generic => Some(generic),
             }
         })
@@ -331,7 +331,7 @@ pub fn non_erasable_generics(
 
     #[inline]
     pub fn type_at(&self, i: usize) -> Ty<'tcx> {
-        if let UnpackedKind::Type(ty) = self[i].unpack() {
+        if let GenericArgKind::Type(ty) = self[i].unpack() {
             ty
         } else {
             bug!("expected type for param #{} in {:?}", i, self);
@@ -340,7 +340,7 @@ pub fn type_at(&self, i: usize) -> Ty<'tcx> {
 
     #[inline]
     pub fn region_at(&self, i: usize) -> ty::Region<'tcx> {
-        if let UnpackedKind::Lifetime(lt) = self[i].unpack() {
+        if let GenericArgKind::Lifetime(lt) = self[i].unpack() {
             lt
         } else {
             bug!("expected region for param #{} in {:?}", i, self);
@@ -349,7 +349,7 @@ pub fn region_at(&self, i: usize) -> ty::Region<'tcx> {
 
     #[inline]
     pub fn const_at(&self, i: usize) -> &'tcx ty::Const<'tcx> {
-        if let UnpackedKind::Const(ct) = self[i].unpack() {
+        if let GenericArgKind::Const(ct) = self[i].unpack() {
             ct
         } else {
             bug!("expected const for param #{} in {:?}", i, self);
@@ -357,7 +357,7 @@ pub fn const_at(&self, i: usize) -> &'tcx ty::Const<'tcx> {
     }
 
     #[inline]
-    pub fn type_for_def(&self, def: &ty::GenericParamDef) -> Kind<'tcx> {
+    pub fn type_for_def(&self, def: &ty::GenericParamDef) -> GenericArg<'tcx> {
         self.type_at(def.index as usize).into()
     }
 
@@ -409,15 +409,25 @@ impl<'tcx> rustc_serialize::UseSpecializedDecodable for SubstsRef<'tcx> {}
 // there is more information available (for better errors).
 
 pub trait Subst<'tcx>: Sized {
-    fn subst(&self, tcx: TyCtxt<'tcx>, substs: &[Kind<'tcx>]) -> Self {
+    fn subst(&self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> Self {
         self.subst_spanned(tcx, substs, None)
     }
 
-    fn subst_spanned(&self, tcx: TyCtxt<'tcx>, substs: &[Kind<'tcx>], span: Option<Span>) -> Self;
+    fn subst_spanned(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        substs: &[GenericArg<'tcx>],
+        span: Option<Span>,
+    ) -> Self;
 }
 
 impl<'tcx, T: TypeFoldable<'tcx>> Subst<'tcx> for T {
-    fn subst_spanned(&self, tcx: TyCtxt<'tcx>, substs: &[Kind<'tcx>], span: Option<Span>) -> T {
+    fn subst_spanned(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        substs: &[GenericArg<'tcx>],
+        span: Option<Span>,
+    ) -> T {
         let mut folder = SubstFolder { tcx,
                                        substs,
                                        span,
@@ -433,7 +443,7 @@ fn subst_spanned(&self, tcx: TyCtxt<'tcx>, substs: &[Kind<'tcx>], span: Option<S
 
 struct SubstFolder<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
-    substs: &'a [Kind<'tcx>],
+    substs: &'a [GenericArg<'tcx>],
 
     /// The location for which the substitution is performed, if available.
     span: Option<Span>,
@@ -468,7 +478,7 @@ fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
             ty::ReEarlyBound(data) => {
                 let rk = self.substs.get(data.index as usize).map(|k| k.unpack());
                 match rk {
-                    Some(UnpackedKind::Lifetime(lt)) => {
+                    Some(GenericArgKind::Lifetime(lt)) => {
                         self.shift_region_through_binders(lt)
                     }
                     _ => {
@@ -537,7 +547,7 @@ fn ty_for_param(&self, p: ty::ParamTy, 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.index as usize).map(|k| k.unpack());
         let ty = match opt_ty {
-            Some(UnpackedKind::Type(ty)) => ty,
+            Some(GenericArgKind::Type(ty)) => ty,
             Some(kind) => {
                 let span = self.span.unwrap_or(DUMMY_SP);
                 span_bug!(
@@ -578,7 +588,7 @@ fn const_for_param(
         // Look up the const in the substitutions. It really should be in there.
         let opt_ct = self.substs.get(p.index as usize).map(|k| k.unpack());
         let ct = match opt_ct {
-            Some(UnpackedKind::Const(ct)) => ct,
+            Some(GenericArgKind::Const(ct)) => ct,
             Some(kind) => {
                 let span = self.span.unwrap_or(DUMMY_SP);
                 span_bug!(

src/librustc/ty/util.rs

@@ -8,7 +8,7 @@
 use crate::ich::NodeIdHashingMode;
 use crate::traits::{self, ObligationCause};
 use crate::ty::{self, DefIdTree, Ty, TyCtxt, GenericParamDefKind, TypeFoldable};
-use crate::ty::subst::{Subst, InternalSubsts, SubstsRef, UnpackedKind};
+use crate::ty::subst::{Subst, InternalSubsts, SubstsRef, GenericArgKind};
 use crate::ty::query::TyCtxtAt;
 use crate::ty::TyKind::*;
 use crate::ty::layout::{Integer, IntegerExt};
@@ -510,7 +510,7 @@ pub fn calculate_dtor(
     /// destructor of `def` itself. For the destructors of the
     /// contents, you need `adt_dtorck_constraint`.
     pub fn destructor_constraints(self, def: &'tcx ty::AdtDef)
-                                  -> Vec<ty::subst::Kind<'tcx>>
+                                  -> Vec<ty::subst::GenericArg<'tcx>>
     {
         let dtor = match def.destructor(self) {
             None => {
@@ -557,23 +557,23 @@ pub fn destructor_constraints(self, def: &'tcx ty::AdtDef)
         let result = item_substs.iter().zip(impl_substs.iter())
             .filter(|&(_, &k)| {
                 match k.unpack() {
-                    UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => {
+                    GenericArgKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => {
                         !impl_generics.region_param(ebr, self).pure_wrt_drop
                     }
-                    UnpackedKind::Type(&ty::TyS {
+                    GenericArgKind::Type(&ty::TyS {
                         kind: ty::Param(ref pt), ..
                     }) => {
                         !impl_generics.type_param(pt, self).pure_wrt_drop
                     }
-                    UnpackedKind::Const(&ty::Const {
+                    GenericArgKind::Const(&ty::Const {
                         val: ConstValue::Param(ref pc),
                         ..
                     }) => {
                         !impl_generics.const_param(pc, self).pure_wrt_drop
                     }
-                    UnpackedKind::Lifetime(_) |
-                    UnpackedKind::Type(_) |
-                    UnpackedKind::Const(_) => {
+                    GenericArgKind::Lifetime(_) |
+                    GenericArgKind::Type(_) |
+                    GenericArgKind::Const(_) => {
                         // Not a type, const or region param: this should be reported
                         // as an error.
                         false

src/librustc_codegen_llvm/debuginfo/metadata.rs

@@ -30,7 +30,7 @@
 use rustc::ty::{self, AdtKind, ParamEnv, Ty, TyCtxt};
 use rustc::ty::layout::{self, Align, Integer, IntegerExt, LayoutOf,
                         PrimitiveExt, Size, TyLayout, VariantIdx};
-use rustc::ty::subst::UnpackedKind;
+use rustc::ty::subst::GenericArgKind;
 use rustc::session::config::{self, DebugInfo};
 use rustc::util::nodemap::FxHashMap;
 use rustc_fs_util::path_to_c_string;
@@ -2096,7 +2096,7 @@ fn compute_type_parameters(cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>) -> Option<&'
             let generics = cx.tcx.generics_of(def.did);
             let names = get_parameter_names(cx, generics);
             let template_params: Vec<_> = substs.iter().zip(names).filter_map(|(kind, name)| {
-                if let UnpackedKind::Type(ty) = kind.unpack() {
+                if let GenericArgKind::Type(ty) = kind.unpack() {
                     let actual_type = cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
                     let actual_type_metadata =
                         type_metadata(cx, actual_type, syntax_pos::DUMMY_SP);

src/librustc_codegen_llvm/debuginfo/mod.rs

@@ -15,7 +15,7 @@
     DISPFlags, DILexicalBlock};
 use rustc::hir::CodegenFnAttrFlags;
 use rustc::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};
-use rustc::ty::subst::{SubstsRef, UnpackedKind};
+use rustc::ty::subst::{SubstsRef, GenericArgKind};
 
 use crate::abi::Abi;
 use crate::common::CodegenCx;
@@ -460,7 +460,7 @@ fn get_template_parameters<'ll, 'tcx>(
             let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full {
                 let names = get_parameter_names(cx, generics);
                 substs.iter().zip(names).filter_map(|(kind, name)| {
-                    if let UnpackedKind::Type(ty) = kind.unpack() {
+                    if let GenericArgKind::Type(ty) = kind.unpack() {
                         let actual_type =
                             cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
                         let actual_type_metadata =

src/librustc_codegen_utils/symbol_names/legacy.rs

@@ -3,7 +3,7 @@
 use rustc::ich::NodeIdHashingMode;
 use rustc::mir::interpret::{ConstValue, Scalar};
 use rustc::ty::print::{PrettyPrinter, Printer, Print};
-use rustc::ty::subst::{Kind, UnpackedKind};
+use rustc::ty::subst::{GenericArg, GenericArgKind};
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable, Instance};
 use rustc::util::common::record_time;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -341,13 +341,13 @@ fn path_append(
     fn path_generic_args(
         mut self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-        args: &[Kind<'tcx>],
+        args: &[GenericArg<'tcx>],
     )  -> Result<Self::Path, Self::Error> {
         self = print_prefix(self)?;
 
         let args = args.iter().cloned().filter(|arg| {
             match arg.unpack() {
-                UnpackedKind::Lifetime(_) => false,
+                GenericArgKind::Lifetime(_) => false,
                 _ => true,
             }
         });

src/librustc_codegen_utils/symbol_names/v0.rs

@@ -3,7 +3,7 @@
 use rustc::hir::map::{DefPathData, DisambiguatedDefPathData};
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable, Instance};
 use rustc::ty::print::{Printer, Print};
-use rustc::ty::subst::{Kind, Subst, UnpackedKind};
+use rustc::ty::subst::{GenericArg, Subst, GenericArgKind};
 use rustc_data_structures::base_n;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_target::spec::abi::Abi;
@@ -56,7 +56,7 @@ struct CompressionCaches<'tcx> {
     start_offset: usize,
 
     // The values are start positions in `out`, in bytes.
-    paths: FxHashMap<(DefId, &'tcx [Kind<'tcx>]), usize>,
+    paths: FxHashMap<(DefId, &'tcx [GenericArg<'tcx>]), usize>,
     types: FxHashMap<Ty<'tcx>, usize>,
     consts: FxHashMap<&'tcx ty::Const<'tcx>, usize>,
 }
@@ -234,7 +234,7 @@ fn tcx(&self) -> TyCtxt<'tcx> {
     fn print_def_path(
         mut self,
         def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         if let Some(&i) = self.compress.as_ref().and_then(|c| c.paths.get(&(def_id, substs))) {
             return self.print_backref(i);
@@ -256,7 +256,7 @@ fn print_def_path(
     fn print_impl_path(
         self,
         impl_def_id: DefId,
-        substs: &'tcx [Kind<'tcx>],
+        substs: &'tcx [GenericArg<'tcx>],
         mut self_ty: Ty<'tcx>,
         mut impl_trait_ref: Option<ty::TraitRef<'tcx>>,
     ) -> Result<Self::Path, Self::Error> {
@@ -619,18 +619,18 @@ fn path_append(
     fn path_generic_args(
         mut self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-        args: &[Kind<'tcx>],
+        args: &[GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         // Don't print any regions if they're all erased.
         let print_regions = args.iter().any(|arg| {
             match arg.unpack() {
-                UnpackedKind::Lifetime(r) => *r != ty::ReErased,
+                GenericArgKind::Lifetime(r) => *r != ty::ReErased,
                 _ => false,
             }
         });
         let args = args.iter().cloned().filter(|arg| {
             match arg.unpack() {
-                UnpackedKind::Lifetime(_) => print_regions,
+                GenericArgKind::Lifetime(_) => print_regions,
                 _ => true,
             }
         });
@@ -643,13 +643,13 @@ fn path_generic_args(
         self = print_prefix(self)?;
         for arg in args {
             match arg.unpack() {
-                UnpackedKind::Lifetime(lt) => {
+                GenericArgKind::Lifetime(lt) => {
                     self = lt.print(self)?;
                 }
-                UnpackedKind::Type(ty) => {
+                GenericArgKind::Type(ty) => {
                     self = ty.print(self)?;
                 }
-                UnpackedKind::Const(c) => {
+                GenericArgKind::Const(c) => {
                     self.push("K");
                     // FIXME(const_generics) implement `ty::print::Print` on `ty::Const`.
                     // self = c.print(self)?;

src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs

@@ -12,7 +12,7 @@
 use rustc::hir::def_id::DefId;
 use rustc::infer::InferCtxt;
 use rustc::mir::Body;
-use rustc::ty::subst::{SubstsRef, UnpackedKind};
+use rustc::ty::subst::{SubstsRef, GenericArgKind};
 use rustc::ty::{self, RegionKind, RegionVid, Ty, TyCtxt};
 use rustc::ty::print::RegionHighlightMode;
 use rustc_errors::DiagnosticBuilder;
@@ -667,24 +667,24 @@ fn try_match_adt_and_generic_args<'hir>(
     ) -> Option<&'hir hir::Lifetime> {
         for (kind, hir_arg) in substs.iter().zip(&args.args) {
             match (kind.unpack(), hir_arg) {
-                (UnpackedKind::Lifetime(r), hir::GenericArg::Lifetime(lt)) => {
+                (GenericArgKind::Lifetime(r), hir::GenericArg::Lifetime(lt)) => {
                     if r.to_region_vid() == needle_fr {
                         return Some(lt);
                     }
                 }
 
-                (UnpackedKind::Type(ty), hir::GenericArg::Type(hir_ty)) => {
+                (GenericArgKind::Type(ty), hir::GenericArg::Type(hir_ty)) => {
                     search_stack.push((ty, hir_ty));
                 }
 
-                (UnpackedKind::Const(_ct), hir::GenericArg::Const(_hir_ct)) => {
+                (GenericArgKind::Const(_ct), hir::GenericArg::Const(_hir_ct)) => {
                     // Lifetimes cannot be found in consts, so we don't need
                     // to search anything here.
                 }
 
-                (UnpackedKind::Lifetime(_), _)
-                | (UnpackedKind::Type(_), _)
-                | (UnpackedKind::Const(_), _) => {
+                (GenericArgKind::Lifetime(_), _)
+                | (GenericArgKind::Type(_), _)
+                | (GenericArgKind::Const(_), _) => {
                     // I *think* that HIR lowering should ensure this
                     // doesn't happen, even in erroneous
                     // programs. Else we should use delay-span-bug.

src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs

@@ -10,7 +10,7 @@
 use rustc::infer::region_constraints::{GenericKind, VerifyBound};
 use rustc::infer::{self, InferCtxt, SubregionOrigin};
 use rustc::mir::ConstraintCategory;
-use rustc::ty::subst::UnpackedKind;
+use rustc::ty::subst::GenericArgKind;
 use rustc::ty::{self, TyCtxt};
 use syntax_pos::DUMMY_SP;
 
@@ -101,13 +101,13 @@ pub(super) fn convert(&mut self, query_constraint: &QueryOutlivesConstraint<'tcx
             });
 
         match k1.unpack() {
-            UnpackedKind::Lifetime(r1) => {
+            GenericArgKind::Lifetime(r1) => {
                 let r1_vid = self.to_region_vid(r1);
                 let r2_vid = self.to_region_vid(r2);
                 self.add_outlives(r1_vid, r2_vid);
             }
 
-            UnpackedKind::Type(t1) => {
+            GenericArgKind::Type(t1) => {
                 // we don't actually use this for anything, but
                 // the `TypeOutlives` code needs an origin.
                 let origin = infer::RelateParamBound(DUMMY_SP, t1);
@@ -121,7 +121,7 @@ pub(super) fn convert(&mut self, query_constraint: &QueryOutlivesConstraint<'tcx
                 ).type_must_outlive(origin, t1, r2);
             }
 
-            UnpackedKind::Const(_) => {
+            GenericArgKind::Const(_) => {
                 // Consts cannot outlive one another, so we
                 // don't need to handle any relations here.
             }

src/librustc_mir/borrow_check/nll/type_check/liveness/polonius.rs

@@ -4,7 +4,7 @@
 use crate::util::liveness::{categorize, DefUse};
 use rustc::mir::visit::{MutatingUseContext, PlaceContext, Visitor};
 use rustc::mir::{Body, Local, Location, Place};
-use rustc::ty::subst::Kind;
+use rustc::ty::subst::GenericArg;
 use rustc::ty::Ty;
 
 use super::TypeChecker;
@@ -125,7 +125,7 @@ pub(super) fn populate_access_facts(
 pub(super) fn add_var_drops_regions(
     typeck: &mut TypeChecker<'_, 'tcx>,
     local: Local,
-    kind: &Kind<'tcx>,
+    kind: &GenericArg<'tcx>,
 ) {
     debug!("add_var_drops_region(local={:?}, kind={:?}", local, kind);
     let tcx = typeck.tcx();

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -36,7 +36,7 @@
 use rustc::traits::{self, ObligationCause, PredicateObligations};
 use rustc::ty::adjustment::{PointerCast};
 use rustc::ty::fold::TypeFoldable;
-use rustc::ty::subst::{Subst, SubstsRef, UnpackedKind, UserSubsts};
+use rustc::ty::subst::{Subst, SubstsRef, GenericArgKind, UserSubsts};
 use rustc::ty::{
     self, RegionVid, ToPolyTraitRef, Ty, TyCtxt, UserType,
     CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations,
@@ -2575,7 +2575,7 @@ fn prove_closure_bounds(
                         });
 
                     match k1.unpack() {
-                        UnpackedKind::Lifetime(r1) => {
+                        GenericArgKind::Lifetime(r1) => {
                             // constraint is r1: r2
                             let r1_vid = self.borrowck_context.universal_regions.to_region_vid(r1);
                             let r2_vid = self.borrowck_context.universal_regions.to_region_vid(r2);
@@ -2589,7 +2589,7 @@ fn prove_closure_bounds(
                                 ),
                             ))
                         }
-                        UnpackedKind::Type(_) | UnpackedKind::Const(_) => None,
+                        GenericArgKind::Type(_) | GenericArgKind::Const(_) => None,
                     }
                 })
                 .collect();

src/librustc_mir/hair/cx/mod.rs

@@ -12,7 +12,7 @@
 use rustc::infer::InferCtxt;
 use rustc::ty::subst::Subst;
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::subst::{Kind, InternalSubsts};
+use rustc::ty::subst::{GenericArg, InternalSubsts};
 use rustc::ty::layout::VariantIdx;
 use syntax::ast;
 use syntax::attr;
@@ -169,7 +169,7 @@ pub fn trait_method(&mut self,
                         trait_def_id: DefId,
                         method_name: Symbol,
                         self_ty: Ty<'tcx>,
-                        params: &[Kind<'tcx>])
+                        params: &[GenericArg<'tcx>])
                         -> &'tcx ty::Const<'tcx> {
         let substs = self.tcx.mk_substs_trait(self_ty, params);
         for item in self.tcx.associated_items(trait_def_id) {

src/librustc_mir/hair/pattern/mod.rs

@@ -17,7 +17,7 @@
 use rustc::traits::{ObligationCause, PredicateObligation};
 use rustc::ty::{self, Region, TyCtxt, AdtDef, Ty, UserType, DefIdTree};
 use rustc::ty::{CanonicalUserType, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations};
-use rustc::ty::subst::{SubstsRef, Kind};
+use rustc::ty::subst::{SubstsRef, GenericArg};
 use rustc::ty::layout::{VariantIdx, Size};
 use rustc::hir::{self, PatKind, RangeEnd};
 use rustc::hir::def::{CtorOf, Res, DefKind, CtorKind};
@@ -1357,7 +1357,7 @@ fn super_fold_with<F: PatternFolder<$lt_tcx>>(&self, _: &mut F) -> Self {
 CloneImpls!{ <'tcx>
     Span, Field, Mutability, ast::Name, hir::HirId, usize, ty::Const<'tcx>,
     Region<'tcx>, Ty<'tcx>, BindingMode, &'tcx AdtDef,
-    SubstsRef<'tcx>, &'tcx Kind<'tcx>, UserType<'tcx>,
+    SubstsRef<'tcx>, &'tcx GenericArg<'tcx>, UserType<'tcx>,
     UserTypeProjection, PatternTypeProjection<'tcx>
 }
 

src/librustc_mir/interpret/intrinsics/type_name.rs

@@ -1,6 +1,6 @@
 use rustc::ty::{
     TyCtxt, Ty,
-    subst::{UnpackedKind, Kind},
+    subst::{GenericArgKind, GenericArg},
     print::{Printer, PrettyPrinter, Print},
     self,
 };
@@ -156,12 +156,12 @@ fn path_append(
     fn path_generic_args(
         mut self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
-        args: &[Kind<'tcx>],
+        args: &[GenericArg<'tcx>],
     ) -> Result<Self::Path, Self::Error> {
         self = print_prefix(self)?;
         let args = args.iter().cloned().filter(|arg| {
             match arg.unpack() {
-                UnpackedKind::Lifetime(_) => false,
+                GenericArgKind::Lifetime(_) => false,
                 _ => true,
             }
         });

src/librustc_traits/chalk_context/mod.rs

@@ -36,7 +36,7 @@
 use rustc::ty::{self, TyCtxt, InferConst};
 use rustc::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 use rustc::ty::query::Providers;
-use rustc::ty::subst::{Kind, UnpackedKind};
+use rustc::ty::subst::{GenericArg, GenericArgKind};
 use rustc::mir::interpret::ConstValue;
 use syntax_pos::DUMMY_SP;
 
@@ -64,7 +64,7 @@
 #[derive(Copy, Clone, Debug)]
 crate struct UniverseMap;
 
-crate type RegionConstraint<'tcx> = ty::OutlivesPredicate<Kind<'tcx>, ty::Region<'tcx>>;
+crate type RegionConstraint<'tcx> = ty::OutlivesPredicate<GenericArg<'tcx>, ty::Region<'tcx>>;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 crate struct ConstrainedSubst<'tcx> {
@@ -109,7 +109,7 @@ impl context::Context for ChalkArenas<'tcx> {
 
     type BindersGoal = ty::Binder<Goal<'tcx>>;
 
-    type Parameter = Kind<'tcx>;
+    type Parameter = GenericArg<'tcx>;
 
     type ProgramClause = Clause<'tcx>;
 
@@ -271,21 +271,21 @@ fn is_trivial_substitution(
         subst.var_values
             .iter_enumerated()
             .all(|(cvar, kind)| match kind.unpack() {
-                UnpackedKind::Lifetime(r) => match r {
+                GenericArgKind::Lifetime(r) => match r {
                     &ty::ReLateBound(debruijn, br) => {
                         debug_assert_eq!(debruijn, ty::INNERMOST);
                         cvar == br.assert_bound_var()
                     }
                     _ => false,
                 },
-                UnpackedKind::Type(ty) => match ty.kind {
+                GenericArgKind::Type(ty) => match ty.kind {
                     ty::Bound(debruijn, bound_ty) => {
                         debug_assert_eq!(debruijn, ty::INNERMOST);
                         cvar == bound_ty.var
                     }
                     _ => false,
                 },
-                UnpackedKind::Const(ct) => match ct.val {
+                GenericArgKind::Const(ct) => match ct.val {
                     ConstValue::Infer(InferConst::Canonical(debruijn, bound_ct)) => {
                         debug_assert_eq!(debruijn, ty::INNERMOST);
                         cvar == bound_ct
@@ -454,8 +454,8 @@ fn unify_parameters(
         &mut self,
         environment: &Environment<'tcx>,
         variance: ty::Variance,
-        a: &Kind<'tcx>,
-        b: &Kind<'tcx>,
+        a: &GenericArg<'tcx>,
+        b: &GenericArg<'tcx>,
     ) -> Fallible<UnificationResult<'tcx>> {
         self.infcx.commit_if_ok(|_| {
             unify(self.infcx, *environment, variance, a, b)

src/librustc_traits/chalk_context/program_clauses/builtin.rs

@@ -5,7 +5,7 @@
     ProgramClauseCategory,
 };
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::subst::{Kind, InternalSubsts, Subst};
+use rustc::ty::subst::{GenericArg, InternalSubsts, Subst};
 use rustc::hir;
 use rustc::hir::def_id::DefId;
 use crate::lowering::Lower;
@@ -17,7 +17,7 @@
 fn builtin_impl_clause(
     tcx: TyCtxt<'tcx>,
     ty: Ty<'tcx>,
-    nested: &[Kind<'tcx>],
+    nested: &[GenericArg<'tcx>],
     trait_def_id: DefId,
 ) -> ProgramClause<'tcx> {
     ProgramClause {
@@ -124,7 +124,7 @@ fn builtin_impl_clause(
     ty: Ty<'tcx>,
     clauses: &mut Vec<Clause<'tcx>>,
 ) {
-    let mut push_builtin_impl = |ty: Ty<'tcx>, nested: &[Kind<'tcx>]| {
+    let mut push_builtin_impl = |ty: Ty<'tcx>, nested: &[GenericArg<'tcx>]| {
         let clause = builtin_impl_clause(tcx, ty, nested, sized_def_id);
         // Bind innermost bound vars that may exist in `ty` and `nested`.
         clauses.push(Clause::ForAll(ty::Binder::bind(clause)));
@@ -185,7 +185,7 @@ fn builtin_impl_clause(
             let adt = tcx.mk_ty(ty::Adt(adt_def, substs));
             let sized_constraint = adt_def.sized_constraint(tcx)
                 .iter()
-                .map(|ty| Kind::from(ty.subst(tcx, substs)))
+                .map(|ty| GenericArg::from(ty.subst(tcx, substs)))
                 .collect::<Vec<_>>();
             push_builtin_impl(adt, &sized_constraint);
         }
@@ -228,7 +228,7 @@ fn builtin_impl_clause(
     ty: Ty<'tcx>,
     clauses: &mut Vec<Clause<'tcx>>,
 ) {
-    let mut push_builtin_impl = |ty: Ty<'tcx>, nested: &[Kind<'tcx>]| {
+    let mut push_builtin_impl = |ty: Ty<'tcx>, nested: &[GenericArg<'tcx>]| {
         let clause = builtin_impl_clause(tcx, ty, nested, trait_def_id);
         // Bind innermost bound vars that may exist in `ty` and `nested`.
         clauses.push(Clause::ForAll(ty::Binder::bind(clause)));
@@ -255,7 +255,7 @@ fn builtin_impl_clause(
             let element_ty = generic_types::bound(tcx, 0);
             push_builtin_impl(
                 tcx.mk_ty(ty::Array(element_ty, length)),
-                &[Kind::from(element_ty)],
+                &[GenericArg::from(element_ty)],
             );
         }
         &ty::Tuple(type_list) => {
@@ -266,7 +266,7 @@ fn builtin_impl_clause(
             let closure_ty = generic_types::closure(tcx, def_id);
             let upvar_tys: Vec<_> = match &closure_ty.kind {
                 ty::Closure(_, substs) => {
-                    substs.upvar_tys(def_id, tcx).map(|ty| Kind::from(ty)).collect()
+                    substs.upvar_tys(def_id, tcx).map(|ty| GenericArg::from(ty)).collect()
                 },
                 _ => bug!(),
             };

src/librustc_traits/chalk_context/resolvent_ops.rs

@@ -17,7 +17,7 @@
     InEnvironment,
 };
 use rustc::ty::{self, Ty, TyCtxt, InferConst};
-use rustc::ty::subst::Kind;
+use rustc::ty::subst::GenericArg;
 use rustc::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc::mir::interpret::ConstValue;
 use syntax_pos::DUMMY_SP;
@@ -151,7 +151,7 @@ impl AnswerSubstitutor<'cx, 'tcx> {
     fn unify_free_answer_var(
         &mut self,
         answer_var: ty::BoundVar,
-        pending: Kind<'tcx>
+        pending: GenericArg<'tcx>
     ) -> RelateResult<'tcx, ()> {
         let answer_param = &self.answer_subst.var_values[answer_var];
         let pending = &ty::fold::shift_out_vars(

src/librustc_traits/generic_types.rs

@@ -1,7 +1,7 @@
 //! Utilities for creating generic types with bound vars in place of parameter values.
 
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::subst::{Kind, SubstsRef, InternalSubsts};
+use rustc::ty::subst::{GenericArg, SubstsRef, InternalSubsts};
 use rustc::hir;
 use rustc::hir::def_id::DefId;
 use rustc_target::spec::abi;
@@ -49,7 +49,7 @@
         (0..arity).into_iter()
             .map(|i| ty::BoundVar::from(i))
             .map(|var| tcx.mk_ty(ty::Bound(ty::INNERMOST, var.into())))
-            .map(|ty| Kind::from(ty))
+            .map(|ty| GenericArg::from(ty))
     )
 }
 

src/librustc_traits/type_op.rs

@@ -13,7 +13,7 @@
     Normalized, Obligation, ObligationCause, TraitEngine, TraitEngineExt,
 };
 use rustc::ty::query::Providers;
-use rustc::ty::subst::{Kind, Subst, UserSubsts, UserSelfTy};
+use rustc::ty::subst::{GenericArg, Subst, UserSubsts, UserSelfTy};
 use rustc::ty::{
     FnSig, Lift, ParamEnv, ParamEnvAnd, PolyFnSig, Predicate, Ty, TyCtxt, TypeFoldable, Variance,
 };
@@ -98,7 +98,7 @@ fn tcx(&self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }
 
-    fn subst<T>(&self, value: T, substs: &[Kind<'tcx>]) -> T
+    fn subst<T>(&self, value: T, substs: &[GenericArg<'tcx>]) -> T
     where
         T: TypeFoldable<'tcx>,
     {

src/librustc_typeck/astconv.rs

@@ -16,7 +16,7 @@
 use rustc::traits;
 use rustc::ty::{self, DefIdTree, Ty, TyCtxt, Const, ToPredicate, TypeFoldable};
 use rustc::ty::{GenericParamDef, GenericParamDefKind};
-use rustc::ty::subst::{Kind, Subst, InternalSubsts, SubstsRef};
+use rustc::ty::subst::{self, Subst, InternalSubsts, SubstsRef};
 use rustc::ty::wf::object_region_bounds;
 use rustc::mir::interpret::ConstValue;
 use rustc_target::spec::abi;
@@ -465,18 +465,19 @@ fn check_generic_arg_count(
     ///   `[T]`. The boolean value indicates whether to infer values
     ///   for arguments whose values were not explicitly provided.
     /// - `provided_kind`: given the generic parameter and the value from `args_for_def_id`,
-    ///   instantiate a `Kind`.
+    ///   instantiate a `GenericArg`.
     /// - `inferred_kind`: if no parameter was provided, and inference is enabled, then
     ///   creates a suitable inference variable.
     pub fn create_substs_for_generic_args<'b>(
         tcx: TyCtxt<'tcx>,
         def_id: DefId,
-        parent_substs: &[Kind<'tcx>],
+        parent_substs: &[subst::GenericArg<'tcx>],
         has_self: bool,
         self_ty: Option<Ty<'tcx>>,
         args_for_def_id: impl Fn(DefId) -> (Option<&'b GenericArgs>, bool),
-        provided_kind: impl Fn(&GenericParamDef, &GenericArg) -> Kind<'tcx>,
-        inferred_kind: impl Fn(Option<&[Kind<'tcx>]>, &GenericParamDef, bool) -> Kind<'tcx>,
+        provided_kind: impl Fn(&GenericParamDef, &GenericArg) -> subst::GenericArg<'tcx>,
+        inferred_kind: impl Fn(Option<&[subst::GenericArg<'tcx>]>, &GenericParamDef, bool)
+            -> subst::GenericArg<'tcx>,
     ) -> SubstsRef<'tcx> {
         // Collect the segments of the path; we need to substitute arguments
         // for parameters throughout the entire path (wherever there are
@@ -492,7 +493,7 @@ pub fn create_substs_for_generic_args<'b>(
         // We manually build up the substitution, rather than using convenience
         // methods in `subst.rs`, so that we can iterate over the arguments and
         // parameters in lock-step linearly, instead of trying to match each pair.
-        let mut substs: SmallVec<[Kind<'tcx>; 8]> = SmallVec::with_capacity(count);
+        let mut substs: SmallVec<[subst::GenericArg<'tcx>; 8]> = SmallVec::with_capacity(count);
 
         // Iterate over each segment of the path.
         while let Some((def_id, defs)) = stack.pop() {

src/librustc_typeck/check/dropck.rs

@@ -6,7 +6,7 @@
 use rustc::infer::{self, InferOk, SuppressRegionErrors};
 use rustc::middle::region;
 use rustc::traits::{ObligationCause, TraitEngine, TraitEngineExt};
-use rustc::ty::subst::{Subst, SubstsRef, UnpackedKind};
+use rustc::ty::subst::{Subst, SubstsRef, GenericArgKind};
 use rustc::ty::{self, Ty, TyCtxt};
 use crate::util::common::ErrorReported;
 
@@ -308,9 +308,9 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(
     let kinds = rcx.fcx.register_infer_ok_obligations(infer_ok);
     for kind in kinds {
         match kind.unpack() {
-            UnpackedKind::Lifetime(r) => rcx.sub_regions(origin(), parent_scope, r),
-            UnpackedKind::Type(ty) => rcx.type_must_outlive(origin(), ty, parent_scope),
-            UnpackedKind::Const(_) => {
+            GenericArgKind::Lifetime(r) => rcx.sub_regions(origin(), parent_scope, r),
+            GenericArgKind::Type(ty) => rcx.type_must_outlive(origin(), ty, parent_scope),
+            GenericArgKind::Const(_) => {
                 // Generic consts don't add constraints.
             }
         }

src/librustc_typeck/check/mod.rs

@@ -116,7 +116,9 @@
 };
 use rustc::ty::fold::TypeFoldable;
 use rustc::ty::query::Providers;
-use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
+use rustc::ty::subst::{
+    GenericArgKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts,
+};
 use rustc::ty::util::{Representability, IntTypeExt, Discr};
 use rustc::ty::layout::VariantIdx;
 use syntax_pos::{self, BytePos, Span, MultiSpan};
@@ -2213,7 +2215,7 @@ fn re_infer(
 
     fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
         if let Some(param) = param {
-            if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
+            if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
                 return ty;
             }
             unreachable!()
@@ -2232,7 +2234,7 @@ fn ct_infer(
         span: Span,
     ) -> &'tcx Const<'tcx> {
         if let Some(param) = param {
-            if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
+            if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
                 return ct;
             }
             unreachable!()

src/librustc_typeck/check/pat.rs

@@ -8,7 +8,7 @@
 use rustc::infer;
 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc::ty::{self, Ty, BindingMode, TypeFoldable};
-use rustc::ty::subst::Kind;
+use rustc::ty::subst::GenericArg;
 use syntax::ast;
 use syntax::util::lev_distance::find_best_match_for_name;
 use syntax_pos::Span;
@@ -797,7 +797,7 @@ fn check_pat_tuple(
         let max_len = cmp::max(expected_len, elements.len());
 
         let element_tys_iter = (0..max_len).map(|_| {
-            Kind::from(self.next_ty_var(
+            GenericArg::from(self.next_ty_var(
                 // FIXME: `MiscVariable` for now -- obtaining the span and name information
                 // from all tuple elements isn't trivial.
                 TypeVariableOrigin {

src/librustc_typeck/check/regionck.rs

@@ -81,7 +81,7 @@
 use rustc::infer::outlives::env::OutlivesEnvironment;
 use rustc::infer::{self, RegionObligation, SuppressRegionErrors};
 use rustc::ty::adjustment;
-use rustc::ty::subst::{SubstsRef, UnpackedKind};
+use rustc::ty::subst::{SubstsRef, GenericArgKind};
 use rustc::ty::{self, Ty};
 
 use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
@@ -1401,14 +1401,14 @@ fn substs_wf_in_scope(
 
         for kind in substs {
             match kind.unpack() {
-                UnpackedKind::Lifetime(lt) => {
+                GenericArgKind::Lifetime(lt) => {
                     self.sub_regions(origin.clone(), expr_region, lt);
                 }
-                UnpackedKind::Type(ty) => {
+                GenericArgKind::Type(ty) => {
                     let ty = self.resolve_type(ty);
                     self.type_must_outlive(origin.clone(), ty, expr_region);
                 }
-                UnpackedKind::Const(_) => {
+                GenericArgKind::Const(_) => {
                     // Const parameters don't impose constraints.
                 }
             }

src/librustc_typeck/check/wfcheck.rs

@@ -646,7 +646,7 @@ fn check_opaque_types<'fcx, 'tcx>(
                         let mut seen: FxHashMap<_, Vec<_>> = FxHashMap::default();
                         for (subst, param) in substs.iter().zip(&generics.params) {
                             match subst.unpack() {
-                                ty::subst::UnpackedKind::Type(ty) => match ty.kind {
+                                ty::subst::GenericArgKind::Type(ty) => match ty.kind {
                                     ty::Param(..) => {}
                                     // Prevent `fn foo() -> Foo<u32>` from being defining.
                                     _ => {
@@ -668,7 +668,7 @@ fn check_opaque_types<'fcx, 'tcx>(
                                     }
                                 }
 
-                                ty::subst::UnpackedKind::Lifetime(region) => {
+                                ty::subst::GenericArgKind::Lifetime(region) => {
                                     let param_span = tcx.def_span(param.def_id);
                                     if let ty::ReStatic = region {
                                         tcx
@@ -690,7 +690,7 @@ fn check_opaque_types<'fcx, 'tcx>(
                                     }
                                 }
 
-                                ty::subst::UnpackedKind::Const(ct) => match ct.val {
+                                ty::subst::GenericArgKind::Const(ct) => match ct.val {
                                     ConstValue::Param(_) => {}
                                     _ => {
                                         tcx.sess

src/librustc_typeck/collect.rs

@@ -25,7 +25,7 @@
 use rustc::ty::subst::{Subst, InternalSubsts};
 use rustc::ty::util::Discr;
 use rustc::ty::util::IntTypeExt;
-use rustc::ty::subst::UnpackedKind;
+use rustc::ty::subst::GenericArgKind;
 use rustc::ty::{self, AdtKind, DefIdTree, ToPolyTraitRef, Ty, TyCtxt, Const};
 use rustc::ty::{ReprOptions, ToPredicate};
 use rustc::util::captures::Captures;
@@ -1580,7 +1580,7 @@ fn check(&mut self, def_id: DefId) {
                 // Skipping binder is ok, since we only use this to find generic parameters and
                 // their positions.
                 for (idx, subst) in substs.iter().enumerate() {
-                    if let UnpackedKind::Type(ty) = subst.unpack() {
+                    if let GenericArgKind::Type(ty) = subst.unpack() {
                         if let ty::Param(p) = ty.kind {
                             if index_map.insert(p, idx).is_some() {
                                 // There was already an entry for `p`, meaning a generic parameter

src/librustc_typeck/outlives/implicit_infer.rs

@@ -1,7 +1,7 @@
 use rustc::hir::{self, Node};
 use rustc::hir::def_id::DefId;
 use rustc::hir::itemlikevisit::ItemLikeVisitor;
-use rustc::ty::subst::{Kind, Subst, UnpackedKind};
+use rustc::ty::subst::{GenericArg, Subst, GenericArgKind};
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::util::nodemap::FxHashMap;
 
@@ -253,7 +253,7 @@ fn insert_required_predicates_to_be_wf<'tcx>(
 pub fn check_explicit_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
-    substs: &[Kind<'tcx>],
+    substs: &[GenericArg<'tcx>],
     required_predicates: &mut RequiredPredicates<'tcx>,
     explicit_map: &mut ExplicitPredicatesMap<'tcx>,
     ignored_self_ty: Option<Ty<'tcx>>,
@@ -310,7 +310,7 @@ pub fn check_explicit_predicates<'tcx>(
         // binding) and thus infer an outlives requirement that `X:
         // 'b`.
         if let Some(self_ty) = ignored_self_ty {
-            if let UnpackedKind::Type(ty) = outlives_predicate.0.unpack() {
+            if let GenericArgKind::Type(ty) = outlives_predicate.0.unpack() {
                 if ty.walk().any(|ty| ty == self_ty) {
                     debug!("skipping self ty = {:?}", &ty);
                     continue;

src/librustc_typeck/outlives/mod.rs

@@ -2,7 +2,7 @@
 use rustc::hir;
 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc::ty::query::Providers;
-use rustc::ty::subst::UnpackedKind;
+use rustc::ty::subst::GenericArgKind;
 use rustc::ty::{self, CratePredicatesMap, TyCtxt};
 use syntax::symbol::sym;
 
@@ -100,17 +100,17 @@ fn inferred_outlives_crate(
                 .iter()
                 .filter_map(
                     |ty::OutlivesPredicate(kind1, region2)| match kind1.unpack() {
-                        UnpackedKind::Type(ty1) => {
+                        GenericArgKind::Type(ty1) => {
                             Some(ty::Predicate::TypeOutlives(ty::Binder::bind(
                                 ty::OutlivesPredicate(ty1, region2)
                             )))
                         }
-                        UnpackedKind::Lifetime(region1) => {
+                        GenericArgKind::Lifetime(region1) => {
                             Some(ty::Predicate::RegionOutlives(
                                 ty::Binder::bind(ty::OutlivesPredicate(region1, region2))
                             ))
                         }
-                        UnpackedKind::Const(_) => {
+                        GenericArgKind::Const(_) => {
                             // Generic consts don't impose any constraints.
                             None
                         }

src/librustc_typeck/outlives/utils.rs

@@ -1,18 +1,19 @@
 use rustc::ty::outlives::Component;
-use rustc::ty::subst::{Kind, UnpackedKind};
+use rustc::ty::subst::{GenericArg, GenericArgKind};
 use rustc::ty::{self, Region, RegionKind, Ty, TyCtxt};
 use smallvec::smallvec;
 use std::collections::BTreeSet;
 
 /// Tracks the `T: 'a` or `'a: 'a` predicates that we have inferred
 /// must be added to the struct header.
-pub type RequiredPredicates<'tcx> = BTreeSet<ty::OutlivesPredicate<Kind<'tcx>, ty::Region<'tcx>>>;
+pub type RequiredPredicates<'tcx> =
+    BTreeSet<ty::OutlivesPredicate<GenericArg<'tcx>, ty::Region<'tcx>>>;
 
 /// Given a requirement `T: 'a` or `'b: 'a`, deduce the
 /// outlives_component and add it to `required_predicates`
 pub fn insert_outlives_predicate<'tcx>(
     tcx: TyCtxt<'tcx>,
-    kind: Kind<'tcx>,
+    kind: GenericArg<'tcx>,
     outlived_region: Region<'tcx>,
     required_predicates: &mut RequiredPredicates<'tcx>,
 ) {
@@ -23,7 +24,7 @@ pub fn insert_outlives_predicate<'tcx>(
     }
 
     match kind.unpack() {
-        UnpackedKind::Type(ty) => {
+        GenericArgKind::Type(ty) => {
             // `T: 'outlived_region` for some type `T`
             // But T could be a lot of things:
             // e.g., if `T = &'b u32`, then `'b: 'outlived_region` is
@@ -112,14 +113,14 @@ pub fn insert_outlives_predicate<'tcx>(
             }
         }
 
-        UnpackedKind::Lifetime(r) => {
+        GenericArgKind::Lifetime(r) => {
             if !is_free_region(tcx, r) {
                 return;
             }
             required_predicates.insert(ty::OutlivesPredicate(kind, outlived_region));
         }
 
-        UnpackedKind::Const(_) => {
+        GenericArgKind::Const(_) => {
             // Generic consts don't impose any constraints.
         }
     }

src/librustc_typeck/variance/constraints.rs

@@ -4,7 +4,7 @@
 //! We walk the set of items and, for each member, generate new constraints.
 
 use hir::def_id::DefId;
-use rustc::ty::subst::{SubstsRef, UnpackedKind};
+use rustc::ty::subst::{SubstsRef, GenericArgKind};
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::hir;
 use rustc::hir::itemlikevisit::ItemLikeVisitor;
@@ -232,13 +232,13 @@ fn add_constraints_from_invariant_substs(&mut self,
 
         for k in substs {
             match k.unpack() {
-                UnpackedKind::Lifetime(lt) => {
+                GenericArgKind::Lifetime(lt) => {
                     self.add_constraints_from_region(current, lt, variance_i)
                 }
-                UnpackedKind::Type(ty) => {
+                GenericArgKind::Type(ty) => {
                     self.add_constraints_from_ty(current, ty, variance_i)
                 }
-                UnpackedKind::Const(_) => {
+                GenericArgKind::Const(_) => {
                     // Consts impose no constraints.
                 }
             }
@@ -387,13 +387,13 @@ fn add_constraints_from_substs(&mut self,
                    variance_decl,
                    variance_i);
             match k.unpack() {
-                UnpackedKind::Lifetime(lt) => {
+                GenericArgKind::Lifetime(lt) => {
                     self.add_constraints_from_region(current, lt, variance_i)
                 }
-                UnpackedKind::Type(ty) => {
+                GenericArgKind::Type(ty) => {
                     self.add_constraints_from_ty(current, ty, variance_i)
                 }
-                UnpackedKind::Const(_) => {
+                GenericArgKind::Const(_) => {
                     // Consts impose no constraints.
                 }
             }

src/librustdoc/clean/mod.rs

@@ -21,7 +21,7 @@
 use rustc::hir::def::{CtorKind, DefKind, Res};
 use rustc::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use rustc::hir::ptr::P;
-use rustc::ty::subst::{InternalSubsts, SubstsRef, UnpackedKind};
+use rustc::ty::subst::{InternalSubsts, SubstsRef, GenericArgKind};
 use rustc::ty::{self, DefIdTree, TyCtxt, Region, RegionVid, Ty, AdtKind};
 use rustc::ty::fold::TypeFolder;
 use rustc::ty::layout::VariantIdx;
@@ -1100,18 +1100,18 @@ fn external_generic_args(
     let mut skip_self = has_self;
     let mut ty_sty = None;
     let args: Vec<_> = substs.iter().filter_map(|kind| match kind.unpack() {
-        UnpackedKind::Lifetime(lt) => {
+        GenericArgKind::Lifetime(lt) => {
             lt.clean(cx).and_then(|lt| Some(GenericArg::Lifetime(lt)))
         }
-        UnpackedKind::Type(_) if skip_self => {
+        GenericArgKind::Type(_) if skip_self => {
             skip_self = false;
             None
         }
-        UnpackedKind::Type(ty) => {
+        GenericArgKind::Type(ty) => {
             ty_sty = Some(&ty.kind);
             Some(GenericArg::Type(ty.clean(cx)))
         }
-        UnpackedKind::Const(ct) => Some(GenericArg::Const(ct.clean(cx))),
+        GenericArgKind::Const(ct) => Some(GenericArg::Const(ct.clean(cx))),
     }).collect();
 
     match trait_did {