Auto merge of #64513 - varkor:sty-begone, r=eddyb

Rename `TyS.sty` to `TyS.kind`

Fixes https://github.com/rust-lang/rust/issues/64353.

r? @eddyb

6 files changed, 51 insertions, 51 deletions

diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
index 423a01ad1f9..b8b0e77d098 100644
--- a/src/librustc_codegen_llvm/builder.rs
+++ b/src/librustc_codegen_llvm/builder.rs
@@ -324,7 +324,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         use syntax::ast::UintTy::*;
         use rustc::ty::{Int, Uint};
 
-        let new_sty = match ty.sty {
+        let new_sty = match ty.kind {
             Int(Isize) => Int(self.tcx.sess.target.isize_ty),
             Uint(Usize) => Uint(self.tcx.sess.target.usize_ty),
             ref t @ Uint(_) | ref t @ Int(_) => t.clone(),
diff --git a/src/librustc_codegen_llvm/consts.rs b/src/librustc_codegen_llvm/consts.rs
index e71d1fc1692..4fd971ca115 100644
--- a/src/librustc_codegen_llvm/consts.rs
+++ b/src/librustc_codegen_llvm/consts.rs
@@ -134,7 +134,7 @@ fn check_and_apply_linkage(
         // extern "C" fn() from being non-null, so we can't just declare a
         // static and call it a day. Some linkages (like weak) will make it such
         // that the static actually has a null value.
-        let llty2 = if let ty::RawPtr(ref mt) = ty.sty {
+        let llty2 = if let ty::RawPtr(ref mt) = ty.kind {
             cx.layout_of(mt.ty).llvm_type(cx)
         } else {
             cx.sess().span_fatal(
diff --git a/src/librustc_codegen_llvm/debuginfo/metadata.rs b/src/librustc_codegen_llvm/debuginfo/metadata.rs
index d0b607bd88e..02d68f47c7e 100644
--- a/src/librustc_codegen_llvm/debuginfo/metadata.rs
+++ b/src/librustc_codegen_llvm/debuginfo/metadata.rs
@@ -340,7 +340,7 @@ fn fixed_vec_metadata(
 
     let (size, align) = cx.size_and_align_of(array_or_slice_type);
 
-    let upper_bound = match array_or_slice_type.sty {
+    let upper_bound = match array_or_slice_type.kind {
         ty::Array(_, len) => len.eval_usize(cx.tcx, ty::ParamEnv::reveal_all()) as c_longlong,
         _ => -1
     };
@@ -427,7 +427,7 @@ fn subroutine_type_metadata(
 
     let signature_metadata: Vec<_> = iter::once(
         // return type
-        match signature.output().sty {
+        match signature.output().kind {
             ty::Tuple(ref tys) if tys.is_empty() => None,
             _ => Some(type_metadata(cx, signature.output(), span))
         }
@@ -466,7 +466,7 @@ fn trait_pointer_metadata(
     // type is assigned the correct name, size, namespace, and source location.
     // However, it does not describe the trait's methods.
 
-    let containing_scope = match trait_type.sty {
+    let containing_scope = match trait_type.kind {
         ty::Dynamic(ref data, ..) =>
             data.principal_def_id().map(|did| get_namespace_for_item(cx, did)),
         _ => {
@@ -563,7 +563,7 @@ pub fn type_metadata(
     debug!("type_metadata: {:?}", t);
 
     let ptr_metadata = |ty: Ty<'tcx>| {
-        match ty.sty {
+        match ty.kind {
             ty::Slice(typ) => {
                 Ok(vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span))
             }
@@ -591,7 +591,7 @@ pub fn type_metadata(
         }
     };
 
-    let MetadataCreationResult { metadata, already_stored_in_typemap } = match t.sty {
+    let MetadataCreationResult { metadata, already_stored_in_typemap } = match t.kind {
         ty::Never    |
         ty::Bool     |
         ty::Char     |
@@ -835,7 +835,7 @@ fn file_metadata_raw(cx: &CodegenCx<'ll, '_>,
 fn basic_type_metadata(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
     debug!("basic_type_metadata: {:?}", t);
 
-    let (name, encoding) = match t.sty {
+    let (name, encoding) = match t.kind {
         ty::Never => ("!", DW_ATE_unsigned),
         ty::Tuple(ref elements) if elements.is_empty() =>
             ("()", DW_ATE_unsigned),
@@ -1145,7 +1145,7 @@ fn prepare_struct_metadata(
 ) -> RecursiveTypeDescription<'ll, 'tcx> {
     let struct_name = compute_debuginfo_type_name(cx.tcx, struct_type, false);
 
-    let (struct_def_id, variant) = match struct_type.sty {
+    let (struct_def_id, variant) = match struct_type.kind {
         ty::Adt(def, _) => (def.did, def.non_enum_variant()),
         _ => bug!("prepare_struct_metadata on a non-ADT")
     };
@@ -1268,7 +1268,7 @@ fn prepare_union_metadata(
 ) -> RecursiveTypeDescription<'ll, 'tcx> {
     let union_name = compute_debuginfo_type_name(cx.tcx, union_type, false);
 
-    let (union_def_id, variant) = match union_type.sty {
+    let (union_def_id, variant) = match union_type.kind {
         ty::Adt(def, _) => (def.did, def.non_enum_variant()),
         _ => bug!("prepare_union_metadata on a non-ADT")
     };
@@ -1334,7 +1334,7 @@ impl EnumMemberDescriptionFactory<'ll, 'tcx> {
     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
                                   -> Vec<MemberDescription<'ll>> {
         let variant_info_for = |index: VariantIdx| {
-            match &self.enum_type.sty {
+            match &self.enum_type.kind {
                 ty::Adt(adt, _) => VariantInfo::Adt(&adt.variants[index]),
                 ty::Generator(def_id, substs, _) => {
                     let generator_layout = cx.tcx.generator_layout(*def_id);
@@ -1354,7 +1354,7 @@ impl EnumMemberDescriptionFactory<'ll, 'tcx> {
 
         match self.layout.variants {
             layout::Variants::Single { index } => {
-                if let ty::Adt(adt, _) = &self.enum_type.sty {
+                if let ty::Adt(adt, _) = &self.enum_type.kind {
                     if adt.variants.is_empty() {
                         return vec![];
                     }
@@ -1747,7 +1747,7 @@ fn prepare_enum_metadata(
     let file_metadata = unknown_file_metadata(cx);
 
     let discriminant_type_metadata = |discr: layout::Primitive| {
-        let enumerators_metadata: Vec<_> = match enum_type.sty {
+        let enumerators_metadata: Vec<_> = match enum_type.kind {
             ty::Adt(def, _) => def
                 .discriminants(cx.tcx)
                 .zip(&def.variants)
@@ -1790,7 +1790,7 @@ fn prepare_enum_metadata(
                 let discriminant_base_type_metadata =
                     type_metadata(cx, discr.to_ty(cx.tcx), syntax_pos::DUMMY_SP);
 
-                let discriminant_name = match enum_type.sty {
+                let discriminant_name = match enum_type.kind {
                     ty::Adt(..) => SmallCStr::new(&cx.tcx.item_name(enum_def_id).as_str()),
                     ty::Generator(..) => SmallCStr::new(&enum_name),
                     _ => bug!(),
@@ -1881,7 +1881,7 @@ fn prepare_enum_metadata(
         );
     }
 
-    let discriminator_name = match &enum_type.sty {
+    let discriminator_name = match &enum_type.kind {
         ty::Generator(..) => Some(SmallCStr::new(&"__state")),
         _ => None,
     };
@@ -2091,7 +2091,7 @@ fn set_members_of_composite_type(cx: &CodegenCx<'ll, 'tcx>,
 // Compute the type parameters for a type, if any, for the given
 // metadata.
 fn compute_type_parameters(cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>) -> Option<&'ll DIArray> {
-    if let ty::Adt(def, substs) = ty.sty {
+    if let ty::Adt(def, substs) = ty.kind {
         if !substs.types().next().is_none() {
             let generics = cx.tcx.generics_of(def.did);
             let names = get_parameter_names(cx, generics);
diff --git a/src/librustc_codegen_llvm/debuginfo/mod.rs b/src/librustc_codegen_llvm/debuginfo/mod.rs
index 6dedf10f0ab..08a37ce9bbf 100644
--- a/src/librustc_codegen_llvm/debuginfo/mod.rs
+++ b/src/librustc_codegen_llvm/debuginfo/mod.rs
@@ -377,7 +377,7 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             let mut signature = Vec::with_capacity(sig.inputs().len() + 1);
 
             // Return type -- llvm::DIBuilder wants this at index 0
-            signature.push(match sig.output().sty {
+            signature.push(match sig.output().kind {
                 ty::Tuple(ref tys) if tys.is_empty() => None,
                 _ => Some(type_metadata(cx, sig.output(), syntax_pos::DUMMY_SP))
             });
@@ -401,7 +401,7 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 // This transformed type is wrong, but these function types are
                 // already inaccurate due to ABI adjustments (see #42800).
                 signature.extend(inputs.iter().map(|&t| {
-                    let t = match t.sty {
+                    let t = match t.kind {
                         ty::Array(ct, _)
                             if (ct == cx.tcx.types.u8) || cx.layout_of(ct).is_zst() => {
                             cx.tcx.mk_imm_ptr(ct)
@@ -417,7 +417,7 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             }
 
             if sig.abi == Abi::RustCall && !sig.inputs().is_empty() {
-                if let ty::Tuple(args) = sig.inputs()[sig.inputs().len() - 1].sty {
+                if let ty::Tuple(args) = sig.inputs()[sig.inputs().len() - 1].kind {
                     signature.extend(
                         args.iter().map(|argument_type| {
                             Some(type_metadata(cx, argument_type.expect_ty(), syntax_pos::DUMMY_SP))
@@ -516,7 +516,7 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
                     // Only "class" methods are generally understood by LLVM,
                     // so avoid methods on other types (e.g., `<*mut T>::null`).
-                    match impl_self_ty.sty {
+                    match impl_self_ty.kind {
                         ty::Adt(def, ..) if !def.is_box() => {
                             Some(type_metadata(cx, impl_self_ty, syntax_pos::DUMMY_SP))
                         }
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index 3f3c5ac1460..b7a410c3760 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -91,7 +91,7 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         let tcx = self.tcx;
         let callee_ty = instance.ty(tcx);
 
-        let (def_id, substs) = match callee_ty.sty {
+        let (def_id, substs) = match callee_ty.kind {
             ty::FnDef(def_id, substs) => (def_id, substs),
             _ => bug!("expected fn item type, found {}", callee_ty)
         };
@@ -1074,7 +1074,7 @@ fn generic_simd_intrinsic(
 
     if name == "simd_select_bitmask" {
         let in_ty = arg_tys[0];
-        let m_len = match in_ty.sty {
+        let m_len = match in_ty.kind {
             // Note that this `.unwrap()` crashes for isize/usize, that's sort
             // of intentional as there's not currently a use case for that.
             ty::Int(i) => i.bit_width().unwrap(),
@@ -1203,7 +1203,7 @@ fn generic_simd_intrinsic(
                  "mismatched lengths: mask length `{}` != other vector length `{}`",
                  m_len, v_len
         );
-        match m_elem_ty.sty {
+        match m_elem_ty.kind {
             ty::Int(_) => {},
             _ => return_error!("mask element type is `{}`, expected `i_`", m_elem_ty)
         }
@@ -1223,7 +1223,7 @@ fn generic_simd_intrinsic(
         // If the vector has less than 8 lanes, an u8 is returned with zeroed
         // trailing bits.
         let expected_int_bits = in_len.max(8);
-        match ret_ty.sty {
+        match ret_ty.kind {
            ty::Uint(i) if i.bit_width() == Some(expected_int_bits) => (),
             _ => return_error!(
                 "bitmask `{}`, expected `u{}`",
@@ -1232,7 +1232,7 @@ fn generic_simd_intrinsic(
         }
 
         // Integer vector <i{in_bitwidth} x in_len>:
-        let (i_xn, in_elem_bitwidth) = match in_elem.sty {
+        let (i_xn, in_elem_bitwidth) = match in_elem.kind {
             ty::Int(i) => (
                 args[0].immediate(),
                 i.bit_width().unwrap_or(bx.data_layout().pointer_size.bits() as _)
@@ -1288,7 +1288,7 @@ fn generic_simd_intrinsic(
                 }
             }
         }
-        let ety = match in_elem.sty {
+        let ety = match in_elem.kind {
             ty::Float(f) if f.bit_width() == 32 => {
                 if in_len < 2 || in_len > 16 {
                     return_error!(
@@ -1375,7 +1375,7 @@ fn generic_simd_intrinsic(
     //  https://github.com/llvm-mirror/llvm/blob/master/include/llvm/IR/Intrinsics.h#L81
     fn llvm_vector_str(elem_ty: Ty<'_>, vec_len: usize, no_pointers: usize) -> String {
         let p0s: String = "p0".repeat(no_pointers);
-        match elem_ty.sty {
+        match elem_ty.kind {
             ty::Int(v) => format!("v{}{}i{}", vec_len, p0s, v.bit_width().unwrap()),
             ty::Uint(v) => format!("v{}{}i{}", vec_len, p0s, v.bit_width().unwrap()),
             ty::Float(v) => format!("v{}{}f{}", vec_len, p0s, v.bit_width()),
@@ -1386,7 +1386,7 @@ fn generic_simd_intrinsic(
     fn llvm_vector_ty(cx: &CodegenCx<'ll, '_>, elem_ty: Ty<'_>, vec_len: usize,
                       mut no_pointers: usize) -> &'ll Type {
         // FIXME: use cx.layout_of(ty).llvm_type() ?
-        let mut elem_ty = match elem_ty.sty {
+        let mut elem_ty = match elem_ty.kind {
             ty::Int(v) => cx.type_int_from_ty( v),
             ty::Uint(v) => cx.type_uint_from_ty( v),
             ty::Float(v) => cx.type_float_from_ty( v),
@@ -1430,7 +1430,7 @@ fn generic_simd_intrinsic(
 
         // This counts how many pointers
         fn ptr_count(t: Ty<'_>) -> usize {
-            match t.sty {
+            match t.kind {
                 ty::RawPtr(p) => 1 + ptr_count(p.ty),
                 _ => 0,
             }
@@ -1438,7 +1438,7 @@ fn generic_simd_intrinsic(
 
         // Non-ptr type
         fn non_ptr(t: Ty<'_>) -> Ty<'_> {
-            match t.sty {
+            match t.kind {
                 ty::RawPtr(p) => non_ptr(p.ty),
                 _ => t,
             }
@@ -1446,7 +1446,7 @@ fn generic_simd_intrinsic(
 
         // The second argument must be a simd vector with an element type that's a pointer
         // to the element type of the first argument
-        let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).sty {
+        let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).kind {
             ty::RawPtr(p) if p.ty == in_elem => (ptr_count(arg_tys[1].simd_type(tcx)),
                                                  non_ptr(arg_tys[1].simd_type(tcx))),
             _ => {
@@ -1463,7 +1463,7 @@ fn generic_simd_intrinsic(
         assert_eq!(underlying_ty, non_ptr(arg_tys[0].simd_type(tcx)));
 
         // The element type of the third argument must be a signed integer type of any width:
-        match arg_tys[2].simd_type(tcx).sty {
+        match arg_tys[2].simd_type(tcx).kind {
             ty::Int(_) => (),
             _ => {
                 require!(false, "expected element type `{}` of third argument `{}` \
@@ -1529,7 +1529,7 @@ fn generic_simd_intrinsic(
 
         // This counts how many pointers
         fn ptr_count(t: Ty<'_>) -> usize {
-            match t.sty {
+            match t.kind {
                 ty::RawPtr(p) => 1 + ptr_count(p.ty),
                 _ => 0,
             }
@@ -1537,7 +1537,7 @@ fn generic_simd_intrinsic(
 
         // Non-ptr type
         fn non_ptr(t: Ty<'_>) -> Ty<'_> {
-            match t.sty {
+            match t.kind {
                 ty::RawPtr(p) => non_ptr(p.ty),
                 _ => t,
             }
@@ -1545,7 +1545,7 @@ fn generic_simd_intrinsic(
 
         // The second argument must be a simd vector with an element type that's a pointer
         // to the element type of the first argument
-        let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).sty {
+        let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).kind {
             ty::RawPtr(p) if p.ty == in_elem && p.mutbl == hir::MutMutable
                 => (ptr_count(arg_tys[1].simd_type(tcx)),
                     non_ptr(arg_tys[1].simd_type(tcx))),
@@ -1563,7 +1563,7 @@ fn generic_simd_intrinsic(
         assert_eq!(underlying_ty, non_ptr(arg_tys[0].simd_type(tcx)));
 
         // The element type of the third argument must be a signed integer type of any width:
-        match arg_tys[2].simd_type(tcx).sty {
+        match arg_tys[2].simd_type(tcx).kind {
             ty::Int(_) => (),
             _ => {
                 require!(false, "expected element type `{}` of third argument `{}` \
@@ -1612,7 +1612,7 @@ fn generic_simd_intrinsic(
                 require!(ret_ty == in_elem,
                          "expected return type `{}` (element of input `{}`), found `{}`",
                          in_elem, in_ty, ret_ty);
-                return match in_elem.sty {
+                return match in_elem.kind {
                     ty::Int(_) | ty::Uint(_) => {
                         let r = bx.$integer_reduce(args[0].immediate());
                         if $ordered {
@@ -1669,7 +1669,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
                 require!(ret_ty == in_elem,
                          "expected return type `{}` (element of input `{}`), found `{}`",
                          in_elem, in_ty, ret_ty);
-                return match in_elem.sty {
+                return match in_elem.kind {
                     ty::Int(_i) => {
                         Ok(bx.$int_red(args[0].immediate(), true))
                     },
@@ -1704,7 +1704,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
                              in_elem, in_ty, ret_ty);
                     args[0].immediate()
                 } else {
-                    match in_elem.sty {
+                    match in_elem.kind {
                         ty::Int(_) | ty::Uint(_) => {},
                         _ => {
                             return_error!("unsupported {} from `{}` with element `{}` to `{}`",
@@ -1717,7 +1717,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
                     let i1xn = bx.type_vector(i1, in_len as u64);
                     bx.trunc(args[0].immediate(), i1xn)
                 };
-                return match in_elem.sty {
+                return match in_elem.kind {
                     ty::Int(_) | ty::Uint(_) => {
                         let r = bx.$red(input);
                         Ok(
@@ -1758,7 +1758,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
 
         enum Style { Float, Int(/* is signed? */ bool), Unsupported }
 
-        let (in_style, in_width) = match in_elem.sty {
+        let (in_style, in_width) = match in_elem.kind {
             // vectors of pointer-sized integers should've been
             // disallowed before here, so this unwrap is safe.
             ty::Int(i) => (Style::Int(true), i.bit_width().unwrap()),
@@ -1766,7 +1766,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
             ty::Float(f) => (Style::Float, f.bit_width()),
             _ => (Style::Unsupported, 0)
         };
-        let (out_style, out_width) = match out_elem.sty {
+        let (out_style, out_width) = match out_elem.kind {
             ty::Int(i) => (Style::Int(true), i.bit_width().unwrap()),
             ty::Uint(u) => (Style::Int(false), u.bit_width().unwrap()),
             ty::Float(f) => (Style::Float, f.bit_width()),
@@ -1816,7 +1816,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
     macro_rules! arith {
         ($($name: ident: $($($p: ident),* => $call: ident),*;)*) => {
             $(if name == stringify!($name) {
-                match in_elem.sty {
+                match in_elem.kind {
                     $($(ty::$p(_))|* => {
                         return Ok(bx.$call(args[0].immediate(), args[1].immediate()))
                     })*
@@ -1850,7 +1850,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
         let rhs = args[1].immediate();
         let is_add = name == "simd_saturating_add";
         let ptr_bits = bx.tcx().data_layout.pointer_size.bits() as _;
-        let (signed, elem_width, elem_ty) = match in_elem.sty {
+        let (signed, elem_width, elem_ty) = match in_elem.kind {
             ty::Int(i) =>
                 (
                     true,
@@ -1896,7 +1896,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
 // FIXME: there’s multiple of this functions, investigate using some of the already existing
 // stuffs.
 fn int_type_width_signed(ty: Ty<'_>, cx: &CodegenCx<'_, '_>) -> Option<(u64, bool)> {
-    match ty.sty {
+    match ty.kind {
         ty::Int(t) => Some((match t {
             ast::IntTy::Isize => cx.tcx.sess.target.isize_ty.bit_width().unwrap() as u64,
             ast::IntTy::I8 => 8,
@@ -1920,7 +1920,7 @@ fn int_type_width_signed(ty: Ty<'_>, cx: &CodegenCx<'_, '_>) -> Option<(u64, boo
 // Returns the width of a float Ty
 // Returns None if the type is not a float
 fn float_type_width(ty: Ty<'_>) -> Option<u64> {
-    match ty.sty {
+    match ty.kind {
         ty::Float(t) => Some(t.bit_width() as u64),
         _ => None,
     }
diff --git a/src/librustc_codegen_llvm/type_of.rs b/src/librustc_codegen_llvm/type_of.rs
index 36a9ff0a2d2..81a99bc5019 100644
--- a/src/librustc_codegen_llvm/type_of.rs
+++ b/src/librustc_codegen_llvm/type_of.rs
@@ -43,7 +43,7 @@ fn uncached_llvm_type<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>,
         layout::Abi::Aggregate { .. } => {}
     }
 
-    let name = match layout.ty.sty {
+    let name = match layout.ty.kind {
         ty::Closure(..) |
         ty::Generator(..) |
         ty::Adt(..) |
@@ -56,14 +56,14 @@ fn uncached_llvm_type<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>,
             let printer = DefPathBasedNames::new(cx.tcx, true, true);
             printer.push_type_name(layout.ty, &mut name, false);
             if let (&ty::Adt(def, _), &layout::Variants::Single { index })
-                 = (&layout.ty.sty, &layout.variants)
+                 = (&layout.ty.kind, &layout.variants)
             {
                 if def.is_enum() && !def.variants.is_empty() {
                     write!(&mut name, "::{}", def.variants[index].ident).unwrap();
                 }
             }
             if let (&ty::Generator(_, substs, _), &layout::Variants::Single { index })
-                 = (&layout.ty.sty, &layout.variants)
+                 = (&layout.ty.kind, &layout.variants)
             {
                 write!(&mut name, "::{}", substs.variant_name(index)).unwrap();
             }
@@ -226,7 +226,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyLayout<'tcx> {
             if let Some(&llty) = cx.scalar_lltypes.borrow().get(&self.ty) {
                 return llty;
             }
-            let llty = match self.ty.sty {
+            let llty = match self.ty.kind {
                 ty::Ref(_, ty, _) |
                 ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
                     cx.type_ptr_to(cx.layout_of(ty).llvm_type(cx))
@@ -318,7 +318,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyLayout<'tcx> {
                                          index: usize, immediate: bool) -> &'a Type {
         // HACK(eddyb) special-case fat pointers until LLVM removes
         // pointee types, to avoid bitcasting every `OperandRef::deref`.
-        match self.ty.sty {
+        match self.ty.kind {
             ty::Ref(..) |
             ty::RawPtr(_) => {
                 return self.field(cx, index).llvm_type(cx);