Rename `sty` to `kind`

22 files changed, 129 insertions, 129 deletions

diff --git a/src/librustc/ty/_match.rs b/src/librustc/ty/_match.rs
index f800a70e0be..a0d22789dae 100644
--- a/src/librustc/ty/_match.rs
+++ b/src/librustc/ty/_match.rs
@@ -59,7 +59,7 @@ impl TypeRelation<'tcx> for Match<'tcx> {
                a, b);
         if a == b { return Ok(a); }
 
-        match (&a.sty, &b.sty) {
+        match (&a.kind, &b.kind) {
             (_, &ty::Infer(ty::FreshTy(_))) |
             (_, &ty::Infer(ty::FreshIntTy(_))) |
             (_, &ty::Infer(ty::FreshFloatTy(_))) => {
diff --git a/src/librustc/ty/cast.rs b/src/librustc/ty/cast.rs
index 7ea5c73c5b7..bc12412312d 100644
--- a/src/librustc/ty/cast.rs
+++ b/src/librustc/ty/cast.rs
@@ -52,7 +52,7 @@ impl<'tcx> CastTy<'tcx> {
     /// Returns `Some` for integral/pointer casts.
     /// casts like unsizing casts will return `None`
     pub fn from_ty(t: Ty<'tcx>) -> Option<CastTy<'tcx>> {
-        match t.sty {
+        match t.kind {
             ty::Bool => Some(CastTy::Int(IntTy::Bool)),
             ty::Char => Some(CastTy::Int(IntTy::Char)),
             ty::Int(_) => Some(CastTy::Int(IntTy::I)),
diff --git a/src/librustc/ty/codec.rs b/src/librustc/ty/codec.rs
index 1aa21501129..bd4913c88fd 100644
--- a/src/librustc/ty/codec.rs
+++ b/src/librustc/ty/codec.rs
@@ -31,7 +31,7 @@ pub trait EncodableWithShorthand: Clone + Eq + Hash {
 impl<'tcx> EncodableWithShorthand for Ty<'tcx> {
     type Variant = ty::TyKind<'tcx>;
     fn variant(&self) -> &Self::Variant {
-        &self.sty
+        &self.kind
     }
 }
 
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index c03dbb2b1ed..371ce885ce2 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -138,7 +138,7 @@ impl<'tcx> CtxtInterners<'tcx> {
             let flags = super::flags::FlagComputation::for_sty(&st);
 
             let ty_struct = TyS {
-                sty: st,
+                kind: st,
                 flags: flags.flags,
                 outer_exclusive_binder: flags.outer_exclusive_binder,
             };
@@ -828,7 +828,7 @@ impl CanonicalUserType<'tcx> {
 
                 user_substs.substs.iter().zip(BoundVar::new(0)..).all(|(kind, cvar)| {
                     match kind.unpack() {
-                        UnpackedKind::Type(ty) => match ty.sty {
+                        UnpackedKind::Type(ty) => match ty.kind {
                             ty::Bound(debruijn, b) => {
                                 // We only allow a `ty::INNERMOST` index in substitutions.
                                 assert_eq!(debruijn, ty::INNERMOST);
@@ -1565,7 +1565,7 @@ impl<'tcx> TyCtxt<'tcx> {
         }
 
         let ret_ty = self.type_of(scope_def_id);
-        match ret_ty.sty {
+        match ret_ty.kind {
             ty::FnDef(_, _) => {
                 let sig = ret_ty.fn_sig(*self);
                 let output = self.erase_late_bound_regions(&sig.output());
@@ -2011,7 +2011,7 @@ macro_rules! sty_debug_print {
                 let shards = tcx.interners.type_.lock_shards();
                 let types = shards.iter().flat_map(|shard| shard.keys());
                 for &Interned(t) in types {
-                    let variant = match t.sty {
+                    let variant = match t.kind {
                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
                             ty::Float(..) | ty::Str | ty::Never => continue,
                         ty::Error => /* unimportant */ continue,
@@ -2083,7 +2083,7 @@ impl<'tcx, T: 'tcx+?Sized> Copy for Interned<'tcx, T> {}
 // N.B., an `Interned<Ty>` compares and hashes as a sty.
 impl<'tcx> PartialEq for Interned<'tcx, TyS<'tcx>> {
     fn eq(&self, other: &Interned<'tcx, TyS<'tcx>>) -> bool {
-        self.0.sty == other.0.sty
+        self.0.kind == other.0.kind
     }
 }
 
@@ -2091,14 +2091,14 @@ impl<'tcx> Eq for Interned<'tcx, TyS<'tcx>> {}
 
 impl<'tcx> Hash for Interned<'tcx, TyS<'tcx>> {
     fn hash<H: Hasher>(&self, s: &mut H) {
-        self.0.sty.hash(s)
+        self.0.kind.hash(s)
     }
 }
 
 #[allow(rustc::usage_of_ty_tykind)]
 impl<'tcx> Borrow<TyKind<'tcx>> for Interned<'tcx, TyS<'tcx>> {
     fn borrow<'a>(&'a self) -> &'a TyKind<'tcx> {
-        &self.0.sty
+        &self.0.kind
     }
 }
 
@@ -2292,7 +2292,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// It cannot convert a closure that requires unsafe.
     pub fn coerce_closure_fn_ty(self, sig: PolyFnSig<'tcx>, unsafety: hir::Unsafety) -> Ty<'tcx> {
         let converted_sig = sig.map_bound(|s| {
-            let params_iter = match s.inputs()[0].sty {
+            let params_iter = match s.inputs()[0].kind {
                 ty::Tuple(params) => {
                     params.into_iter().map(|k| k.expect_ty())
                 }
diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs
index 125c48f5f31..8b870884497 100644
--- a/src/librustc/ty/error.rs
+++ b/src/librustc/ty/error.rs
@@ -185,7 +185,7 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
 
 impl<'tcx> ty::TyS<'tcx> {
     pub fn sort_string(&self, tcx: TyCtxt<'_>) -> Cow<'static, str> {
-        match self.sty {
+        match self.kind {
             ty::Bool | ty::Char | ty::Int(_) |
             ty::Uint(_) | ty::Float(_) | ty::Str | ty::Never => self.to_string().into(),
             ty::Tuple(ref tys) if tys.is_empty() => self.to_string().into(),
@@ -275,7 +275,7 @@ impl<'tcx> TyCtxt<'tcx> {
                                  `.await`ing on both of them");
                     }
                 }
-                match (&values.expected.sty, &values.found.sty) {
+                match (&values.expected.kind, &values.found.kind) {
                     (ty::Float(_), ty::Infer(ty::IntVar(_))) => if let Ok( // Issue #53280
                         snippet,
                     ) = self.sess.source_map().span_to_snippet(sp) {
diff --git a/src/librustc/ty/fast_reject.rs b/src/librustc/ty/fast_reject.rs
index ee0d33dbe34..7d6ae3f815a 100644
--- a/src/librustc/ty/fast_reject.rs
+++ b/src/librustc/ty/fast_reject.rs
@@ -60,7 +60,7 @@ pub fn simplify_type(
     ty: Ty<'_>,
     can_simplify_params: bool,
 ) -> Option<SimplifiedType> {
-    match ty.sty {
+    match ty.kind {
         ty::Bool => Some(BoolSimplifiedType),
         ty::Char => Some(CharSimplifiedType),
         ty::Int(int_type) => Some(IntSimplifiedType(int_type)),
diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs
index 1e08ae45951..f6a5092d30d 100644
--- a/src/librustc/ty/fold.rs
+++ b/src/librustc/ty/fold.rs
@@ -472,7 +472,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for BoundVarReplacer<'a, 'tcx> {
     }
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
-        match t.sty {
+        match t.kind {
             ty::Bound(debruijn, bound_ty) => {
                 if debruijn == self.current_index {
                     let fld_t = &mut self.fld_t;
@@ -776,7 +776,7 @@ impl TypeFolder<'tcx> for Shifter<'tcx> {
     }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        match ty.sty {
+        match ty.kind {
             ty::Bound(debruijn, bound_ty) => {
                 if self.amount == 0 || debruijn < self.current_index {
                     ty
@@ -985,7 +985,7 @@ impl<'tcx> TypeVisitor<'tcx> for LateBoundRegionsCollector {
         // ignore the inputs to a projection, as they may not appear
         // in the normalized form
         if self.just_constrained {
-            match t.sty {
+            match t.kind {
                 ty::Projection(..) | ty::Opaque(..) => { return false; }
                 _ => { }
             }
diff --git a/src/librustc/ty/inhabitedness/mod.rs b/src/librustc/ty/inhabitedness/mod.rs
index 1a0e3517338..bc0cf4deaa4 100644
--- a/src/librustc/ty/inhabitedness/mod.rs
+++ b/src/librustc/ty/inhabitedness/mod.rs
@@ -181,7 +181,7 @@ impl<'tcx> FieldDef {
 impl<'tcx> TyS<'tcx> {
     /// Calculates the forest of `DefId`s from which this type is visibly uninhabited.
     fn uninhabited_from(&self, tcx: TyCtxt<'tcx>) -> DefIdForest {
-        match self.sty {
+        match self.kind {
             Adt(def, substs) => def.uninhabited_from(tcx, substs),
 
             Never => DefIdForest::full(tcx),
diff --git a/src/librustc/ty/instance.rs b/src/librustc/ty/instance.rs
index a26fa72f330..ecb512b0cd1 100644
--- a/src/librustc/ty/instance.rs
+++ b/src/librustc/ty/instance.rs
@@ -54,7 +54,7 @@ impl<'tcx> Instance<'tcx> {
 
     fn fn_sig_noadjust(&self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx> {
         let ty = self.ty(tcx);
-        match ty.sty {
+        match ty.kind {
             ty::FnDef(..) |
             // Shims currently have type FnPtr. Not sure this should remain.
             ty::FnPtr(_) => ty.fn_sig(tcx),
@@ -255,7 +255,7 @@ impl<'tcx> Instance<'tcx> {
                 &ty,
             );
 
-            let def = match item_type.sty {
+            let def = match item_type.kind {
                 ty::FnDef(..) if {
                     let f = item_type.fn_sig(tcx);
                     f.abi() == Abi::RustIntrinsic ||
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index e52feea1624..790b0c5cb48 100644
--- a/src/librustc/ty/layout.rs
+++ b/src/librustc/ty/layout.rs
@@ -520,7 +520,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
         };
         debug_assert!(!ty.has_infer_types());
 
-        Ok(match ty.sty {
+        Ok(match ty.kind {
             // Basic scalars.
             ty::Bool => {
                 tcx.intern_layout(LayoutDetails::scalar(self, Scalar {
@@ -573,7 +573,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 }
 
                 let unsized_part = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
-                let metadata = match unsized_part.sty {
+                let metadata = match unsized_part.kind {
                     ty::Foreign(..) => {
                         return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr)));
                     }
@@ -1618,7 +1618,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                                                                    variants);
         };
 
-        let adt_def = match layout.ty.sty {
+        let adt_def = match layout.ty.kind {
             ty::Adt(ref adt_def, _) => {
                 debug!("print-type-size t: `{:?}` process adt", layout.ty);
                 adt_def
@@ -1759,12 +1759,12 @@ impl<'tcx> SizeSkeleton<'tcx> {
             Err(err) => err
         };
 
-        match ty.sty {
+        match ty.kind {
             ty::Ref(_, pointee, _) |
             ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => {
                 let non_zero = !ty.is_unsafe_ptr();
                 let tail = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
-                match tail.sty {
+                match tail.kind {
                     ty::Param(_) | ty::Projection(_) => {
                         debug_assert!(tail.has_param_types());
                         Ok(SizeSkeleton::Pointer {
@@ -2040,7 +2040,7 @@ where
                     assert_eq!(layout.variants, Variants::Single { index });
                 }
 
-                let fields = match this.ty.sty {
+                let fields = match this.ty.kind {
                     ty::Adt(def, _) => def.variants[variant_index].fields.len(),
                     _ => bug!()
                 };
@@ -2078,7 +2078,7 @@ where
             }))
         };
 
-        cx.layout_of(match this.ty.sty {
+        cx.layout_of(match this.ty.kind {
             ty::Bool |
             ty::Char |
             ty::Int(_) |
@@ -2115,7 +2115,7 @@ where
                     }));
                 }
 
-                match tcx.struct_tail_erasing_lifetimes(pointee, cx.param_env()).sty {
+                match tcx.struct_tail_erasing_lifetimes(pointee, cx.param_env()).kind {
                     ty::Slice(_) |
                     ty::Str => tcx.types.usize,
                     ty::Dynamic(_, _) => {
@@ -2202,7 +2202,7 @@ where
         cx: &C,
         offset: Size,
     ) -> Option<PointeeInfo> {
-        match this.ty.sty {
+        match this.ty.kind {
             ty::RawPtr(mt) if offset.bytes() == 0 => {
                 cx.layout_of(mt.ty).to_result().ok()
                     .map(|layout| PointeeInfo {
@@ -2309,7 +2309,7 @@ where
 
                 // FIXME(eddyb) This should be for `ptr::Unique<T>`, not `Box<T>`.
                 if let Some(ref mut pointee) = result {
-                    if let ty::Adt(def, _) = this.ty.sty {
+                    if let ty::Adt(def, _) = this.ty.kind {
                         if def.is_box() && offset.bytes() == 0 {
                             pointee.safe = Some(PointerKind::UniqueOwned);
                         }
@@ -2641,7 +2641,7 @@ where
         let extra_args = if sig.abi == RustCall {
             assert!(!sig.c_variadic && extra_args.is_empty());
 
-            match sig.inputs().last().unwrap().sty {
+            match sig.inputs().last().unwrap().kind {
                 ty::Tuple(tupled_arguments) => {
                     inputs = &sig.inputs()[0..sig.inputs().len() - 1];
                     tupled_arguments.iter().map(|k| k.expect_ty()).collect()
@@ -2753,7 +2753,7 @@ where
                             Some(did) => did,
                             None => bug!("`va_list` lang item required for C-variadic functions"),
                         };
-                        match ty.sty {
+                        match ty.kind {
                             ty::Adt(def, _) if def.did == va_list_did => {
                                 // This is the "spoofed" `VaListImpl`. Set the arguments mode
                                 // so that it will be ignored.
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index ef8bdfb583e..0c1b2a23d44 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -479,7 +479,7 @@ bitflags! {
 
 #[allow(rustc::usage_of_ty_tykind)]
 pub struct TyS<'tcx> {
-    pub sty: TyKind<'tcx>,
+    pub kind: TyKind<'tcx>,
     pub flags: TypeFlags,
 
     /// This is a kind of confusing thing: it stores the smallest
@@ -508,13 +508,13 @@ static_assert_size!(TyS<'_>, 32);
 
 impl<'tcx> Ord for TyS<'tcx> {
     fn cmp(&self, other: &TyS<'tcx>) -> Ordering {
-        self.sty.cmp(&other.sty)
+        self.kind.cmp(&other.kind)
     }
 }
 
 impl<'tcx> PartialOrd for TyS<'tcx> {
     fn partial_cmp(&self, other: &TyS<'tcx>) -> Option<Ordering> {
-        Some(self.sty.cmp(&other.sty))
+        Some(self.kind.cmp(&other.kind))
     }
 }
 
@@ -534,7 +534,7 @@ impl<'tcx> Hash for TyS<'tcx> {
 
 impl<'tcx> TyS<'tcx> {
     pub fn is_primitive_ty(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Bool |
             Char |
             Int(_) |
@@ -550,7 +550,7 @@ impl<'tcx> TyS<'tcx> {
     }
 
     pub fn is_suggestable(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Opaque(..) |
             FnDef(..) |
             FnPtr(..) |
@@ -568,16 +568,16 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ty::TyS<'tcx> {
                                           hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {
         let ty::TyS {
-            ref sty,
+            ref kind,
 
             // The other fields just provide fast access to information that is
-            // also contained in `sty`, so no need to hash them.
+            // also contained in `kind`, so no need to hash them.
             flags: _,
 
             outer_exclusive_binder: _,
         } = *self;
 
-        sty.hash_stable(hcx, hasher);
+        kind.hash_stable(hcx, hasher);
     }
 }
 
@@ -2494,7 +2494,7 @@ impl<'tcx> AdtDef {
     }
 
     fn sized_constraint_for_ty(&self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<'tcx>> {
-        let result = match ty.sty {
+        let result = match ty.kind {
             Bool | Char | Int(..) | Uint(..) | Float(..) |
             RawPtr(..) | Ref(..) | FnDef(..) | FnPtr(_) |
             Array(..) | Closure(..) | Generator(..) | Never => {
@@ -3339,7 +3339,7 @@ fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Ty<'_>> {
     }
 
     let self_ty = trait_ref.self_ty();
-    let self_ty_matches = match self_ty.sty {
+    let self_ty_matches = match self_ty.kind {
         ty::Dynamic(ref data, ty::ReStatic) => data.principal().is_none(),
         _ => false
     };
diff --git a/src/librustc/ty/outlives.rs b/src/librustc/ty/outlives.rs
index 7d1403d1e96..9a2e30f7f45 100644
--- a/src/librustc/ty/outlives.rs
+++ b/src/librustc/ty/outlives.rs
@@ -60,7 +60,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // with `collect()` because of the need to sometimes skip subtrees
         // in the `subtys` iterator (e.g., when encountering a
         // projection).
-        match ty.sty {
+        match ty.kind {
             ty::Closure(def_id, ref substs) => {
                 for upvar_ty in substs.upvar_tys(def_id, *self) {
                     self.compute_components(upvar_ty, out);
diff --git a/src/librustc/ty/print/mod.rs b/src/librustc/ty/print/mod.rs
index 50789bf6213..727397d7a29 100644
--- a/src/librustc/ty/print/mod.rs
+++ b/src/librustc/ty/print/mod.rs
@@ -266,7 +266,7 @@ pub trait Printer<'tcx>: Sized {
 /// type. It's just a heuristic so it makes some questionable
 /// decisions and we may want to adjust it later.
 pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
-    match ty.sty {
+    match ty.kind {
         ty::Adt(adt_def, _) => Some(adt_def.did),
 
         ty::Dynamic(data, ..) => data.principal_def_id(),
diff --git a/src/librustc/ty/print/obsolete.rs b/src/librustc/ty/print/obsolete.rs
index b68e6a74487..d7d43b8203f 100644
--- a/src/librustc/ty/print/obsolete.rs
+++ b/src/librustc/ty/print/obsolete.rs
@@ -34,7 +34,7 @@ impl DefPathBasedNames<'tcx> {
     // When being used for codegen purposes, `debug` should be set to `false`
     // in order to catch unexpected types that should never end up in a type name.
     pub fn push_type_name(&self, t: Ty<'tcx>, output: &mut String, debug: bool) {
-        match t.sty {
+        match t.kind {
             ty::Bool => output.push_str("bool"),
             ty::Char => output.push_str("char"),
             ty::Str => output.push_str("str"),
diff --git a/src/librustc/ty/print/pretty.rs b/src/librustc/ty/print/pretty.rs
index d99580116e4..a38a00ff5b7 100644
--- a/src/librustc/ty/print/pretty.rs
+++ b/src/librustc/ty/print/pretty.rs
@@ -414,7 +414,7 @@ pub trait PrettyPrinter<'tcx>:
             // Inherent impls. Try to print `Foo::bar` for an inherent
             // impl on `Foo`, but fallback to `<Foo>::bar` if self-type is
             // anything other than a simple path.
-            match self_ty.sty {
+            match self_ty.kind {
                 ty::Adt(..) | ty::Foreign(_) |
                 ty::Bool | ty::Char | ty::Str |
                 ty::Int(_) | ty::Uint(_) | ty::Float(_) => {
@@ -463,7 +463,7 @@ pub trait PrettyPrinter<'tcx>:
     ) -> Result<Self::Type, Self::Error> {
         define_scoped_cx!(self);
 
-        match ty.sty {
+        match ty.kind {
             ty::Bool => p!(write("bool")),
             ty::Char => p!(write("char")),
             ty::Int(t) => p!(write("{}", t.ty_to_string())),
@@ -739,7 +739,7 @@ pub trait PrettyPrinter<'tcx>:
             // Special-case `Fn(...) -> ...` and resugar it.
             let fn_trait_kind = self.tcx().lang_items().fn_trait_kind(principal.def_id);
             if !self.tcx().sess.verbose() && fn_trait_kind.is_some() {
-                if let ty::Tuple(ref args) = principal.substs.type_at(0).sty {
+                if let ty::Tuple(ref args) = principal.substs.type_at(0).kind {
                     let mut projections = predicates.projection_bounds();
                     if let (Some(proj), None) = (projections.next(), projections.next()) {
                         let tys: Vec<_> = args.iter().map(|k| k.expect_ty()).collect();
@@ -856,7 +856,7 @@ pub trait PrettyPrinter<'tcx>:
         define_scoped_cx!(self);
 
         let u8 = self.tcx().types.u8;
-        if let ty::FnDef(did, substs) = ct.ty.sty {
+        if let ty::FnDef(did, substs) = ct.ty.kind {
             p!(print_value_path(did, substs));
             return Ok(self);
         }
@@ -887,7 +887,7 @@ pub trait PrettyPrinter<'tcx>:
             return Ok(self);
         }
         if let ConstValue::Scalar(Scalar::Raw { data, .. }) = ct.val {
-            match ct.ty.sty {
+            match ct.ty.kind {
                 ty::Bool => {
                     p!(write("{}", if data == 0 { "false" } else { "true" }));
                     return Ok(self);
@@ -935,8 +935,8 @@ pub trait PrettyPrinter<'tcx>:
                 _ => {},
             }
         }
-        if let ty::Ref(_, ref_ty, _) = ct.ty.sty {
-            let byte_str = match (ct.val, &ref_ty.sty) {
+        if let ty::Ref(_, ref_ty, _) = ct.ty.kind {
+            let byte_str = match (ct.val, &ref_ty.kind) {
                 (ConstValue::Scalar(Scalar::Ptr(ptr)), ty::Array(t, n)) if *t == u8 => {
                     let n = n.eval_usize(self.tcx(), ty::ParamEnv::empty());
                     Some(self.tcx()
diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs
index 565447dd7e1..d6bd4eeb736 100644
--- a/src/librustc/ty/relate.rs
+++ b/src/librustc/ty/relate.rs
@@ -349,7 +349,7 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
 ) -> RelateResult<'tcx, Ty<'tcx>> {
     let tcx = relation.tcx();
     debug!("super_relate_tys: a={:?} b={:?}", a, b);
-    match (&a.sty, &b.sty) {
+    match (&a.kind, &b.kind) {
         (&ty::Infer(_), _) |
         (_, &ty::Infer(_)) =>
         {
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
index ec7cf1a13c5..72e1bd33c6a 100644
--- a/src/librustc/ty/structural_impls.rs
+++ b/src/librustc/ty/structural_impls.rs
@@ -1023,7 +1023,7 @@ impl<'tcx> TypeFoldable<'tcx> for interpret::GlobalId<'tcx> {
 
 impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        let sty = match self.sty {
+        let sty = match self.kind {
             ty::RawPtr(tm) => ty::RawPtr(tm.fold_with(folder)),
             ty::Array(typ, sz) => ty::Array(typ.fold_with(folder), sz.fold_with(folder)),
             ty::Slice(typ) => ty::Slice(typ.fold_with(folder)),
@@ -1067,7 +1067,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             ty::Foreign(..) => return self
         };
 
-        if self.sty == sty {
+        if self.kind == sty {
             self
         } else {
             folder.tcx().mk_ty(sty)
@@ -1079,7 +1079,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        match self.sty {
+        match self.kind {
             ty::RawPtr(ref tm) => tm.visit_with(visitor),
             ty::Array(typ, sz) => typ.visit_with(visitor) || sz.visit_with(visitor),
             ty::Slice(typ) => typ.visit_with(visitor),
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
index e73a51e6f78..e5eca752135 100644
--- a/src/librustc/ty/sty.rs
+++ b/src/librustc/ty/sty.rs
@@ -384,9 +384,9 @@ impl<'tcx> ClosureSubsts<'tcx> {
     /// If you have an inference context, use `infcx.closure_sig()`.
     pub fn closure_sig(self, def_id: DefId, tcx: TyCtxt<'tcx>) -> ty::PolyFnSig<'tcx> {
         let ty = self.closure_sig_ty(def_id, tcx);
-        match ty.sty {
+        match ty.kind {
             ty::FnPtr(sig) => sig,
-            _ => bug!("closure_sig_ty is not a fn-ptr: {:?}", ty.sty),
+            _ => bug!("closure_sig_ty is not a fn-ptr: {:?}", ty.kind),
         }
     }
 }
@@ -1678,7 +1678,7 @@ impl RegionKind {
 impl<'tcx> TyS<'tcx> {
     #[inline]
     pub fn is_unit(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Tuple(ref tys) => tys.is_empty(),
             _ => false,
         }
@@ -1686,7 +1686,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_never(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Never => true,
             _ => false,
         }
@@ -1701,7 +1701,7 @@ impl<'tcx> TyS<'tcx> {
     pub fn conservative_is_privately_uninhabited(&self, tcx: TyCtxt<'tcx>) -> bool {
         // FIXME(varkor): we can make this less conversative by substituting concrete
         // type arguments.
-        match self.sty {
+        match self.kind {
             ty::Never => true,
             ty::Adt(def, _) if def.is_union() => {
                 // For now, `union`s are never considered uninhabited.
@@ -1741,7 +1741,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_primitive(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Bool | Char | Int(_) | Uint(_) | Float(_) => true,
             _ => false,
         }
@@ -1749,7 +1749,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_ty_var(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Infer(TyVar(_)) => true,
             _ => false,
         }
@@ -1757,7 +1757,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_ty_infer(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Infer(_) => true,
             _ => false,
         }
@@ -1765,7 +1765,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_phantom_data(&self) -> bool {
-        if let Adt(def, _) = self.sty {
+        if let Adt(def, _) = self.kind {
             def.is_phantom_data()
         } else {
             false
@@ -1773,11 +1773,11 @@ impl<'tcx> TyS<'tcx> {
     }
 
     #[inline]
-    pub fn is_bool(&self) -> bool { self.sty == Bool }
+    pub fn is_bool(&self) -> bool { self.kind == Bool }
 
     #[inline]
     pub fn is_param(&self, index: u32) -> bool {
-        match self.sty {
+        match self.kind {
             ty::Param(ref data) => data.index == index,
             _ => false,
         }
@@ -1785,8 +1785,8 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_slice(&self) -> bool {
-        match self.sty {
-            RawPtr(TypeAndMut { ty, .. }) | Ref(_, ty, _) => match ty.sty {
+        match self.kind {
+            RawPtr(TypeAndMut { ty, .. }) | Ref(_, ty, _) => match ty.kind {
                 Slice(_) | Str => true,
                 _ => false,
             },
@@ -1796,14 +1796,14 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_simd(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Adt(def, _) => def.repr.simd(),
             _ => false,
         }
     }
 
     pub fn sequence_element_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
-        match self.sty {
+        match self.kind {
             Array(ty, _) | Slice(ty) => ty,
             Str => tcx.mk_mach_uint(ast::UintTy::U8),
             _ => bug!("sequence_element_type called on non-sequence value: {}", self),
@@ -1811,7 +1811,7 @@ impl<'tcx> TyS<'tcx> {
     }
 
     pub fn simd_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
-        match self.sty {
+        match self.kind {
             Adt(def, substs) => {
                 def.non_enum_variant().fields[0].ty(tcx, substs)
             }
@@ -1820,7 +1820,7 @@ impl<'tcx> TyS<'tcx> {
     }
 
     pub fn simd_size(&self, _cx: TyCtxt<'_>) -> usize {
-        match self.sty {
+        match self.kind {
             Adt(def, _) => def.non_enum_variant().fields.len(),
             _ => bug!("simd_size called on invalid type")
         }
@@ -1828,7 +1828,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_region_ptr(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Ref(..) => true,
             _ => false,
         }
@@ -1836,7 +1836,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_mutable_ptr(&self) -> bool {
-        match self.sty {
+        match self.kind {
             RawPtr(TypeAndMut { mutbl: hir::Mutability::MutMutable, .. }) |
             Ref(_, _, hir::Mutability::MutMutable) => true,
             _ => false
@@ -1845,7 +1845,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_unsafe_ptr(&self) -> bool {
-        match self.sty {
+        match self.kind {
             RawPtr(_) => return true,
             _ => return false,
         }
@@ -1860,7 +1860,7 @@ impl<'tcx> TyS<'tcx> {
     /// Returns `true` if this type is an `Arc<T>`.
     #[inline]
     pub fn is_arc(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Adt(def, _) => def.is_arc(),
             _ => false,
         }
@@ -1869,7 +1869,7 @@ impl<'tcx> TyS<'tcx> {
     /// Returns `true` if this type is an `Rc<T>`.
     #[inline]
     pub fn is_rc(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Adt(def, _) => def.is_rc(),
             _ => false,
         }
@@ -1877,7 +1877,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_box(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Adt(def, _) => def.is_box(),
             _ => false,
         }
@@ -1885,7 +1885,7 @@ impl<'tcx> TyS<'tcx> {
 
     /// panics if called on any type other than `Box<T>`
     pub fn boxed_ty(&self) -> Ty<'tcx> {
-        match self.sty {
+        match self.kind {
             Adt(def, substs) if def.is_box() => substs.type_at(0),
             _ => bug!("`boxed_ty` is called on non-box type {:?}", self),
         }
@@ -1896,7 +1896,7 @@ impl<'tcx> TyS<'tcx> {
     /// contents are abstract to rustc.)
     #[inline]
     pub fn is_scalar(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Bool | Char | Int(_) | Float(_) | Uint(_) |
             Infer(IntVar(_)) | Infer(FloatVar(_)) |
             FnDef(..) | FnPtr(_) | RawPtr(_) => true,
@@ -1907,7 +1907,7 @@ impl<'tcx> TyS<'tcx> {
     /// Returns `true` if this type is a floating point type.
     #[inline]
     pub fn is_floating_point(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Float(_) |
             Infer(FloatVar(_)) => true,
             _ => false,
@@ -1916,7 +1916,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_trait(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Dynamic(..) => true,
             _ => false,
         }
@@ -1924,7 +1924,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_enum(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Adt(adt_def, _) => {
                 adt_def.is_enum()
             }
@@ -1934,7 +1934,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_closure(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Closure(..) => true,
             _ => false,
         }
@@ -1942,7 +1942,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_generator(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Generator(..) => true,
             _ => false,
         }
@@ -1950,7 +1950,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_integral(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Infer(IntVar(_)) | Int(_) | Uint(_) => true,
             _ => false
         }
@@ -1958,7 +1958,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_fresh_ty(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Infer(FreshTy(_)) => true,
             _ => false,
         }
@@ -1966,7 +1966,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_fresh(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Infer(FreshTy(_)) => true,
             Infer(FreshIntTy(_)) => true,
             Infer(FreshFloatTy(_)) => true,
@@ -1976,7 +1976,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_char(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Char => true,
             _ => false,
         }
@@ -1989,7 +1989,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_signed(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Int(_) => true,
             _ => false,
         }
@@ -1997,7 +1997,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_ptr_sized_integral(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Int(ast::IntTy::Isize) | Uint(ast::UintTy::Usize) => true,
             _ => false,
         }
@@ -2005,7 +2005,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_machine(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Int(..) | Uint(..) | Float(..) => true,
             _ => false,
         }
@@ -2013,7 +2013,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn has_concrete_skeleton(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Param(_) | Infer(_) | Error => false,
             _ => true,
         }
@@ -2024,7 +2024,7 @@ impl<'tcx> TyS<'tcx> {
     /// The parameter `explicit` indicates if this is an *explicit* dereference.
     /// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
     pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut<'tcx>> {
-        match self.sty {
+        match self.kind {
             Adt(def, _) if def.is_box() => {
                 Some(TypeAndMut {
                     ty: self.boxed_ty(),
@@ -2039,14 +2039,14 @@ impl<'tcx> TyS<'tcx> {
 
     /// Returns the type of `ty[i]`.
     pub fn builtin_index(&self) -> Option<Ty<'tcx>> {
-        match self.sty {
+        match self.kind {
             Array(ty, _) | Slice(ty) => Some(ty),
             _ => None,
         }
     }
 
     pub fn fn_sig(&self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx> {
-        match self.sty {
+        match self.kind {
             FnDef(def_id, substs) => {
                 tcx.fn_sig(def_id).subst(tcx, substs)
             }
@@ -2063,7 +2063,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_fn(&self) -> bool {
-        match self.sty {
+        match self.kind {
             FnDef(..) | FnPtr(_) => true,
             _ => false,
         }
@@ -2071,7 +2071,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_fn_ptr(&self) -> bool {
-        match self.sty {
+        match self.kind {
             FnPtr(_) => true,
             _ => false,
         }
@@ -2079,7 +2079,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_impl_trait(&self) -> bool {
-        match self.sty {
+        match self.kind {
             Opaque(..) => true,
             _ => false,
         }
@@ -2087,7 +2087,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn ty_adt_def(&self) -> Option<&'tcx AdtDef> {
-        match self.sty {
+        match self.kind {
             Adt(adt, _) => Some(adt),
             _ => None,
         }
@@ -2096,7 +2096,7 @@ impl<'tcx> TyS<'tcx> {
     /// Iterates over tuple fields.
     /// Panics when called on anything but a tuple.
     pub fn tuple_fields(&self) -> impl DoubleEndedIterator<Item=Ty<'tcx>> {
-        match self.sty {
+        match self.kind {
             Tuple(substs) => substs.iter().map(|field| field.expect_ty()),
             _ => bug!("tuple_fields called on non-tuple"),
         }
@@ -2106,7 +2106,7 @@ impl<'tcx> TyS<'tcx> {
     /// FIXME This requires the optimized MIR in the case of generators.
     #[inline]
     pub fn variant_range(&self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>> {
-        match self.sty {
+        match self.kind {
             TyKind::Adt(adt, _) => Some(adt.variant_range()),
             TyKind::Generator(def_id, substs, _) => Some(substs.variant_range(def_id, tcx)),
             _ => None,
@@ -2122,7 +2122,7 @@ impl<'tcx> TyS<'tcx> {
         tcx: TyCtxt<'tcx>,
         variant_index: VariantIdx,
     ) -> Option<Discr<'tcx>> {
-        match self.sty {
+        match self.kind {
             TyKind::Adt(adt, _) => Some(adt.discriminant_for_variant(tcx, variant_index)),
             TyKind::Generator(def_id, substs, _) =>
                 Some(substs.discriminant_for_variant(def_id, tcx, variant_index)),
@@ -2134,7 +2134,7 @@ impl<'tcx> TyS<'tcx> {
     /// types reachable from this type via `walk_tys`). This ignores late-bound
     /// regions binders.
     pub fn push_regions(&self, out: &mut SmallVec<[ty::Region<'tcx>; 4]>) {
-        match self.sty {
+        match self.kind {
             Ref(region, _, _) => {
                 out.push(region);
             }
@@ -2190,7 +2190,7 @@ impl<'tcx> TyS<'tcx> {
     /// inferred. Once upvar inference (in `src/librustc_typeck/check/upvar.rs`)
     /// is complete, that type variable will be unified.
     pub fn to_opt_closure_kind(&self) -> Option<ty::ClosureKind> {
-        match self.sty {
+        match self.kind {
             Int(int_ty) => match int_ty {
                 ast::IntTy::I8 => Some(ty::ClosureKind::Fn),
                 ast::IntTy::I16 => Some(ty::ClosureKind::FnMut),
@@ -2211,7 +2211,7 @@ impl<'tcx> TyS<'tcx> {
     /// Returning true means the type is known to be sized. Returning
     /// `false` means nothing -- could be sized, might not be.
     pub fn is_trivially_sized(&self, tcx: TyCtxt<'tcx>) -> bool {
-        match self.sty {
+        match self.kind {
             ty::Infer(ty::IntVar(_)) | ty::Infer(ty::FloatVar(_)) |
             ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) |
             ty::FnDef(..) | ty::FnPtr(_) | ty::RawPtr(..) |
diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs
index ea829da783e..b5debc179e9 100644
--- a/src/librustc/ty/subst.rs
+++ b/src/librustc/ty/subst.rs
@@ -501,7 +501,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
         }
         self.ty_stack_depth += 1;
 
-        let t1 = match t.sty {
+        let t1 = match t.kind {
             ty::Param(p) => {
                 self.ty_for_param(p, t)
             }
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
index 78d94df4fa0..714ebf4c42f 100644
--- a/src/librustc/ty/util.rs
+++ b/src/librustc/ty/util.rs
@@ -33,7 +33,7 @@ pub struct Discr<'tcx> {
 
 impl<'tcx> fmt::Display for Discr<'tcx> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.ty.sty {
+        match self.ty.kind {
             ty::Int(ity) => {
                 let size = ty::tls::with(|tcx| {
                     Integer::from_attr(&tcx, SignedInt(ity)).size()
@@ -54,7 +54,7 @@ impl<'tcx> Discr<'tcx> {
         self.checked_add(tcx, 1).0
     }
     pub fn checked_add(self, tcx: TyCtxt<'tcx>, n: u128) -> (Self, bool) {
-        let (int, signed) = match self.ty.sty {
+        let (int, signed) = match self.ty.kind {
             Int(ity) => (Integer::from_attr(&tcx, SignedInt(ity)), true),
             Uint(uty) => (Integer::from_attr(&tcx, UnsignedInt(uty)), false),
             _ => bug!("non integer discriminant"),
@@ -179,7 +179,7 @@ impl<'tcx> ty::ParamEnv<'tcx> {
     ) -> Result<(), CopyImplementationError<'tcx>> {
         // FIXME: (@jroesch) float this code up
         tcx.infer_ctxt().enter(|infcx| {
-            let (adt, substs) = match self_type.sty {
+            let (adt, substs) = match self_type.kind {
                 // These types used to have a builtin impl.
                 // Now libcore provides that impl.
                 ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) |
@@ -246,10 +246,10 @@ impl<'tcx> TyCtxt<'tcx> {
 
 impl<'tcx> TyCtxt<'tcx> {
     pub fn has_error_field(self, ty: Ty<'tcx>) -> bool {
-        if let ty::Adt(def, substs) = ty.sty {
+        if let ty::Adt(def, substs) = ty.kind {
             for field in def.all_fields() {
                 let field_ty = field.ty(self, substs);
-                if let Error = field_ty.sty {
+                if let Error = field_ty.kind {
                     return true;
                 }
             }
@@ -298,7 +298,7 @@ impl<'tcx> TyCtxt<'tcx> {
                                       -> Ty<'tcx>
     {
         loop {
-            match ty.sty {
+            match ty.kind {
                 ty::Adt(def, substs) => {
                     if !def.is_struct() {
                         break;
@@ -370,7 +370,7 @@ impl<'tcx> TyCtxt<'tcx> {
     {
         let (mut a, mut b) = (source, target);
         loop {
-            match (&a.sty, &b.sty) {
+            match (&a.kind, &b.kind) {
                 (&Adt(a_def, a_substs), &Adt(b_def, b_substs))
                         if a_def == b_def && a_def.is_struct() => {
                     if let Some(f) = a_def.non_enum_variant().fields.last() {
@@ -544,12 +544,12 @@ impl<'tcx> TyCtxt<'tcx> {
         // <P1, P2, P0>, and then look up which of the impl substs refer to
         // parameters marked as pure.
 
-        let impl_substs = match self.type_of(impl_def_id).sty {
+        let impl_substs = match self.type_of(impl_def_id).kind {
             ty::Adt(def_, substs) if def_ == def => substs,
             _ => bug!()
         };
 
-        let item_substs = match self.type_of(def.did).sty {
+        let item_substs = match self.type_of(def.did).kind {
             ty::Adt(def_, substs) if def_ == def => substs,
             _ => bug!()
         };
@@ -561,7 +561,7 @@ impl<'tcx> TyCtxt<'tcx> {
                         !impl_generics.region_param(ebr, self).pure_wrt_drop
                     }
                     UnpackedKind::Type(&ty::TyS {
-                        sty: ty::Param(ref pt), ..
+                        kind: ty::Param(ref pt), ..
                     }) => {
                         !impl_generics.type_param(pt, self).pure_wrt_drop
                     }
@@ -733,7 +733,7 @@ impl<'tcx> TyCtxt<'tcx> {
             }
 
             fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
-                if let ty::Opaque(def_id, substs) = t.sty {
+                if let ty::Opaque(def_id, substs) = t.kind {
                     self.expand_opaque_ty(def_id, substs).unwrap_or(t)
                 } else {
                     t.super_fold_with(self)
@@ -811,7 +811,7 @@ impl<'tcx> ty::TyS<'tcx> {
     }
 
     pub fn same_type(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
-        match (&a.sty, &b.sty) {
+        match (&a.kind, &b.kind) {
             (&Adt(did_a, substs_a), &Adt(did_b, substs_b)) => {
                 if did_a != did_b {
                     return false;
@@ -846,7 +846,7 @@ impl<'tcx> ty::TyS<'tcx> {
             representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>,
             ty: Ty<'tcx>,
         ) -> Representability {
-            match ty.sty {
+            match ty.kind {
                 Tuple(..) => {
                     // Find non representable
                     fold_repr(ty.tuple_fields().map(|ty| {
@@ -889,7 +889,7 @@ impl<'tcx> ty::TyS<'tcx> {
         }
 
         fn same_struct_or_enum<'tcx>(ty: Ty<'tcx>, def: &'tcx ty::AdtDef) -> bool {
-            match ty.sty {
+            match ty.kind {
                 Adt(ty_def, _) => {
                      ty_def == def
                 }
@@ -927,7 +927,7 @@ impl<'tcx> ty::TyS<'tcx> {
             representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>,
             ty: Ty<'tcx>,
         ) -> Representability {
-            match ty.sty {
+            match ty.kind {
                 Adt(def, _) => {
                     {
                         // Iterate through stack of previously seen types.
@@ -1009,7 +1009,7 @@ impl<'tcx> ty::TyS<'tcx> {
     /// - `&'a *const &'b u8 -> *const &'b u8`
     pub fn peel_refs(&'tcx self) -> Ty<'tcx> {
         let mut ty = self;
-        while let Ref(_, inner_ty, _) = ty.sty {
+        while let Ref(_, inner_ty, _) = ty.kind {
             ty = inner_ty;
         }
         ty
@@ -1067,7 +1067,7 @@ fn needs_drop_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>
 
     assert!(!ty.needs_infer());
 
-    NeedsDrop(match ty.sty {
+    NeedsDrop(match ty.kind {
         // Fast-path for primitive types
         ty::Infer(ty::FreshIntTy(_)) | ty::Infer(ty::FreshFloatTy(_)) |
         ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Never |
@@ -1170,7 +1170,7 @@ impl<'tcx> ExplicitSelf<'tcx> {
     {
         use self::ExplicitSelf::*;
 
-        match self_arg_ty.sty {
+        match self_arg_ty.kind {
             _ if is_self_ty(self_arg_ty) => ByValue,
             ty::Ref(region, ty, mutbl) if is_self_ty(ty) => {
                 ByReference(region, mutbl)
diff --git a/src/librustc/ty/walk.rs b/src/librustc/ty/walk.rs
index 8c3110792a8..12f0d80cd0e 100644
--- a/src/librustc/ty/walk.rs
+++ b/src/librustc/ty/walk.rs
@@ -69,7 +69,7 @@ pub fn walk_shallow(ty: Ty<'_>) -> smallvec::IntoIter<TypeWalkerArray<'_>> {
 // natural order one would expect (basically, the order of the
 // types as they are written).
 fn push_subtypes<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent_ty: Ty<'tcx>) {
-    match parent_ty.sty {
+    match parent_ty.kind {
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) |
         ty::Str | ty::Infer(_) | ty::Param(_) | ty::Never | ty::Error |
         ty::Placeholder(..) | ty::Bound(..) | ty::Foreign(..) => {
diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs
index d6de217f79c..020926e7c8d 100644
--- a/src/librustc/ty/wf.rs
+++ b/src/librustc/ty/wf.rs
@@ -236,7 +236,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         let mut subtys = ty0.walk();
         let param_env = self.param_env;
         while let Some(ty) = subtys.next() {
-            match ty.sty {
+            match ty.kind {
                 ty::Bool |
                 ty::Char |
                 ty::Int(..) |
@@ -407,7 +407,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
                 //    is satisfied to ensure termination.)
                 ty::Infer(_) => {
                     let ty = self.infcx.shallow_resolve(ty);
-                    if let ty::Infer(_) = ty.sty { // not yet resolved...
+                    if let ty::Infer(_) = ty.kind { // not yet resolved...
                         if ty == ty0 { // ...this is the type we started from! no progress.
                             return false;
                         }