diff --git a/src/librustc/arena.rs b/src/librustc/arena.rs
index 57c1e5521a9d9..ae542cec170a3 100644
--- a/src/librustc/arena.rs
+++ b/src/librustc/arena.rs
@@ -11,7 +11,7 @@
 macro_rules! arena_types {
     ($macro:path, $args:tt, $tcx:lifetime) => (
         $macro!($args, [
-            [] layouts: rustc::ty::layout::LayoutDetails,
+            [] layouts: rustc::ty::layout::Layout,
             [] generics: rustc::ty::Generics,
             [] trait_def: rustc::ty::TraitDef,
             [] adt_def: rustc::ty::AdtDef,
diff --git a/src/librustc/query/mod.rs b/src/librustc/query/mod.rs
index 54f5103f736ec..1ca72def9b908 100644
--- a/src/librustc/query/mod.rs
+++ b/src/librustc/query/mod.rs
@@ -738,7 +738,7 @@ rustc_queries! {
 
         query layout_raw(
             env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>
-        ) -> Result<&'tcx ty::layout::LayoutDetails, ty::layout::LayoutError<'tcx>> {
+        ) -> Result<&'tcx ty::layout::Layout, ty::layout::LayoutError<'tcx>> {
             desc { "computing layout of `{}`", env.value }
         }
     }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index ef1532bbf2500..c1d13b0353ebb 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -20,7 +20,7 @@ use crate::mir::{
 };
 use crate::traits;
 use crate::traits::{Clause, Clauses, Goal, GoalKind, Goals};
-use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx};
+use crate::ty::layout::{Layout, TargetDataLayout, VariantIdx};
 use crate::ty::query;
 use crate::ty::steal::Steal;
 use crate::ty::subst::{GenericArg, InternalSubsts, Subst, SubstsRef};
@@ -985,7 +985,7 @@ pub struct GlobalCtxt<'tcx> {
     /// Stores memory for globals (statics/consts).
     pub alloc_map: Lock<interpret::AllocMap<'tcx>>,
 
-    layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>,
+    layout_interner: ShardedHashMap<&'tcx Layout, ()>,
 
     output_filenames: Arc<OutputFilenames>,
 }
@@ -1040,7 +1040,7 @@ impl<'tcx> TyCtxt<'tcx> {
         self.const_stability_interner.intern(stab, |stab| self.arena.alloc(stab))
     }
 
-    pub fn intern_layout(self, layout: LayoutDetails) -> &'tcx LayoutDetails {
+    pub fn intern_layout(self, layout: Layout) -> &'tcx Layout {
         self.layout_interner.intern(layout, |layout| self.arena.alloc(layout))
     }
 
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index c54360e03933e..1ce3d4d6bec4d 100644
--- a/src/librustc/ty/layout.rs
+++ b/src/librustc/ty/layout.rs
@@ -181,7 +181,7 @@ impl<'tcx> fmt::Display for LayoutError<'tcx> {
 fn layout_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
     query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
-) -> Result<&'tcx LayoutDetails, LayoutError<'tcx>> {
+) -> Result<&'tcx Layout, LayoutError<'tcx>> {
     ty::tls::with_related_context(tcx, move |icx| {
         let rec_limit = *tcx.sess.recursion_limit.get();
         let (param_env, ty) = query.into_parts();
@@ -240,7 +240,7 @@ fn invert_mapping(map: &[u32]) -> Vec<u32> {
 }
 
 impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
-    fn scalar_pair(&self, a: Scalar, b: Scalar) -> LayoutDetails {
+    fn scalar_pair(&self, a: Scalar, b: Scalar) -> Layout {
         let dl = self.data_layout();
         let b_align = b.value.align(dl);
         let align = a.value.align(dl).max(b_align).max(dl.aggregate_align);
@@ -254,7 +254,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             .chain(Niche::from_scalar(dl, Size::ZERO, a.clone()))
             .max_by_key(|niche| niche.available(dl));
 
-        LayoutDetails {
+        Layout {
             variants: Variants::Single { index: VariantIdx::new(0) },
             fields: FieldPlacement::Arbitrary {
                 offsets: vec![Size::ZERO, b_offset],
@@ -273,7 +273,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
         fields: &[TyLayout<'_>],
         repr: &ReprOptions,
         kind: StructKind,
-    ) -> Result<LayoutDetails, LayoutError<'tcx>> {
+    ) -> Result<Layout, LayoutError<'tcx>> {
         let dl = self.data_layout();
         let pack = repr.pack;
         if pack.is_some() && repr.align.is_some() {
@@ -422,17 +422,11 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                     (
                         Some((
                             i,
-                            &TyLayout {
-                                details: &LayoutDetails { abi: Abi::Scalar(ref a), .. },
-                                ..
-                            },
+                            &TyLayout { layout: &Layout { abi: Abi::Scalar(ref a), .. }, .. },
                         )),
                         Some((
                             j,
-                            &TyLayout {
-                                details: &LayoutDetails { abi: Abi::Scalar(ref b), .. },
-                                ..
-                            },
+                            &TyLayout { layout: &Layout { abi: Abi::Scalar(ref b), .. }, .. },
                         )),
                         None,
                     ) => {
@@ -470,7 +464,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             abi = Abi::Uninhabited;
         }
 
-        Ok(LayoutDetails {
+        Ok(Layout {
             variants: Variants::Single { index: VariantIdx::new(0) },
             fields: FieldPlacement::Arbitrary { offsets, memory_index },
             abi,
@@ -480,7 +474,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
         })
     }
 
-    fn layout_raw_uncached(&self, ty: Ty<'tcx>) -> Result<&'tcx LayoutDetails, LayoutError<'tcx>> {
+    fn layout_raw_uncached(&self, ty: Ty<'tcx>) -> Result<&'tcx Layout, LayoutError<'tcx>> {
         let tcx = self.tcx;
         let param_env = self.param_env;
         let dl = self.data_layout();
@@ -489,8 +483,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             assert!(bits <= 128);
             Scalar { value, valid_range: 0..=(!0 >> (128 - bits)) }
         };
-        let scalar =
-            |value: Primitive| tcx.intern_layout(LayoutDetails::scalar(self, scalar_unit(value)));
+        let scalar = |value: Primitive| tcx.intern_layout(Layout::scalar(self, scalar_unit(value)));
 
         let univariant = |fields: &[TyLayout<'_>], repr: &ReprOptions, kind| {
             Ok(tcx.intern_layout(self.univariant_uninterned(ty, fields, repr, kind)?))
@@ -499,11 +492,11 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
 
         Ok(match ty.kind {
             // Basic scalars.
-            ty::Bool => tcx.intern_layout(LayoutDetails::scalar(
+            ty::Bool => tcx.intern_layout(Layout::scalar(
                 self,
                 Scalar { value: Int(I8, false), valid_range: 0..=1 },
             )),
-            ty::Char => tcx.intern_layout(LayoutDetails::scalar(
+            ty::Char => tcx.intern_layout(Layout::scalar(
                 self,
                 Scalar { value: Int(I32, false), valid_range: 0..=0x10FFFF },
             )),
@@ -516,11 +509,11 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             ty::FnPtr(_) => {
                 let mut ptr = scalar_unit(Pointer);
                 ptr.valid_range = 1..=*ptr.valid_range.end();
-                tcx.intern_layout(LayoutDetails::scalar(self, ptr))
+                tcx.intern_layout(Layout::scalar(self, ptr))
             }
 
             // The never type.
-            ty::Never => tcx.intern_layout(LayoutDetails {
+            ty::Never => tcx.intern_layout(Layout {
                 variants: Variants::Single { index: VariantIdx::new(0) },
                 fields: FieldPlacement::Union(0),
                 abi: Abi::Uninhabited,
@@ -538,13 +531,13 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
 
                 let pointee = tcx.normalize_erasing_regions(param_env, pointee);
                 if pointee.is_sized(tcx.at(DUMMY_SP), param_env) {
-                    return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr)));
+                    return Ok(tcx.intern_layout(Layout::scalar(self, data_ptr)));
                 }
 
                 let unsized_part = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
                 let metadata = match unsized_part.kind {
                     ty::Foreign(..) => {
-                        return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr)));
+                        return Ok(tcx.intern_layout(Layout::scalar(self, data_ptr)));
                     }
                     ty::Slice(_) | ty::Str => scalar_unit(Int(dl.ptr_sized_integer(), false)),
                     ty::Dynamic(..) => {
@@ -581,7 +574,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
 
                 let largest_niche = if count != 0 { element.largest_niche.clone() } else { None };
 
-                tcx.intern_layout(LayoutDetails {
+                tcx.intern_layout(Layout {
                     variants: Variants::Single { index: VariantIdx::new(0) },
                     fields: FieldPlacement::Array { stride: element.size, count },
                     abi,
@@ -592,7 +585,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             }
             ty::Slice(element) => {
                 let element = self.layout_of(element)?;
-                tcx.intern_layout(LayoutDetails {
+                tcx.intern_layout(Layout {
                     variants: Variants::Single { index: VariantIdx::new(0) },
                     fields: FieldPlacement::Array { stride: element.size, count: 0 },
                     abi: Abi::Aggregate { sized: false },
@@ -601,7 +594,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                     size: Size::ZERO,
                 })
             }
-            ty::Str => tcx.intern_layout(LayoutDetails {
+            ty::Str => tcx.intern_layout(Layout {
                 variants: Variants::Single { index: VariantIdx::new(0) },
                 fields: FieldPlacement::Array { stride: Size::from_bytes(1), count: 0 },
                 abi: Abi::Aggregate { sized: false },
@@ -670,7 +663,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 let align = dl.vector_align(size);
                 let size = size.align_to(align.abi);
 
-                tcx.intern_layout(LayoutDetails {
+                tcx.intern_layout(Layout {
                     variants: Variants::Single { index: VariantIdx::new(0) },
                     fields: FieldPlacement::Array { stride: element.size, count },
                     abi: Abi::Vector { element: scalar, count },
@@ -746,7 +739,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                         align = align.min(AbiAndPrefAlign::new(pack));
                     }
 
-                    return Ok(tcx.intern_layout(LayoutDetails {
+                    return Ok(tcx.intern_layout(Layout {
                         variants: Variants::Single { index },
                         fields: FieldPlacement::Union(variants[index].len()),
                         abi,
@@ -970,7 +963,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                             let largest_niche =
                                 Niche::from_scalar(dl, offset, niche_scalar.clone());
 
-                            return Ok(tcx.intern_layout(LayoutDetails {
+                            return Ok(tcx.intern_layout(Layout {
                                 variants: Variants::Multiple {
                                     discr: niche_scalar,
                                     discr_kind: DiscriminantKind::Niche {
@@ -1165,7 +1158,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                                 break;
                             }
                         };
-                        let prim = match field.details.abi {
+                        let prim = match field.abi {
                             Abi::Scalar(ref scalar) => scalar.value,
                             _ => {
                                 common_prim = None;
@@ -1212,7 +1205,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
 
                 let largest_niche = Niche::from_scalar(dl, Size::ZERO, tag.clone());
 
-                tcx.intern_layout(LayoutDetails {
+                tcx.intern_layout(Layout {
                     variants: Variants::Multiple {
                         discr: tag,
                         discr_kind: DiscriminantKind::Tag,
@@ -1243,7 +1236,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             | ty::Placeholder(..)
             | ty::UnnormalizedProjection(..)
             | ty::GeneratorWitness(..)
-            | ty::Infer(_) => bug!("LayoutDetails::compute: unexpected type `{}`", ty),
+            | ty::Infer(_) => bug!("Layout::compute: unexpected type `{}`", ty),
 
             ty::Param(_) | ty::Error => {
                 return Err(LayoutError::Unknown(ty));
@@ -1390,7 +1383,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
         ty: Ty<'tcx>,
         def_id: hir::def_id::DefId,
         substs: SubstsRef<'tcx>,
-    ) -> Result<&'tcx LayoutDetails, LayoutError<'tcx>> {
+    ) -> Result<&'tcx Layout, LayoutError<'tcx>> {
         use SavedLocalEligibility::*;
         let tcx = self.tcx;
 
@@ -1409,8 +1402,8 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
         let discr_int = Integer::fit_unsigned(max_discr);
         let discr_int_ty = discr_int.to_ty(tcx, false);
         let discr = Scalar { value: Primitive::Int(discr_int, false), valid_range: 0..=max_discr };
-        let discr_layout = self.tcx.intern_layout(LayoutDetails::scalar(self, discr.clone()));
-        let discr_layout = TyLayout { ty: discr_int_ty, details: discr_layout };
+        let discr_layout = self.tcx.intern_layout(Layout::scalar(self, discr.clone()));
+        let discr_layout = TyLayout { ty: discr_int_ty, layout: discr_layout };
 
         let promoted_layouts = ineligible_locals
             .iter()
@@ -1559,7 +1552,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             Abi::Aggregate { sized: true }
         };
 
-        let layout = tcx.intern_layout(LayoutDetails {
+        let layout = tcx.intern_layout(Layout {
             variants: Variants::Multiple {
                 discr,
                 discr_kind: DiscriminantKind::Tag,
@@ -1908,8 +1901,8 @@ impl<'tcx> LayoutOf for LayoutCx<'tcx, TyCtxt<'tcx>> {
     fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyLayout {
         let param_env = self.param_env.with_reveal_all();
         let ty = self.tcx.normalize_erasing_regions(param_env, ty);
-        let details = self.tcx.layout_raw(param_env.and(ty))?;
-        let layout = TyLayout { ty, details };
+        let layout = self.tcx.layout_raw(param_env.and(ty))?;
+        let layout = TyLayout { ty, layout };
 
         // N.B., this recording is normally disabled; when enabled, it
         // can however trigger recursive invocations of `layout_of`.
@@ -1932,8 +1925,8 @@ impl LayoutOf for LayoutCx<'tcx, ty::query::TyCtxtAt<'tcx>> {
     fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyLayout {
         let param_env = self.param_env.with_reveal_all();
         let ty = self.tcx.normalize_erasing_regions(param_env, ty);
-        let details = self.tcx.layout_raw(param_env.and(ty))?;
-        let layout = TyLayout { ty, details };
+        let layout = self.tcx.layout_raw(param_env.and(ty))?;
+        let layout = TyLayout { ty, layout };
 
         // N.B., this recording is normally disabled; when enabled, it
         // can however trigger recursive invocations of `layout_of`.
@@ -1982,7 +1975,7 @@ where
         + HasParamEnv<'tcx>,
 {
     fn for_variant(this: TyLayout<'tcx>, cx: &C, variant_index: VariantIdx) -> TyLayout<'tcx> {
-        let details = match this.variants {
+        let layout = match this.variants {
             Variants::Single { index }
                 // If all variants but one are uninhabited, the variant layout is the enum layout.
                 if index == variant_index &&
@@ -1990,13 +1983,13 @@ where
                 // For more details see https://github.com/rust-lang/rust/issues/69763.
                 this.fields != FieldPlacement::Union(0) =>
             {
-                this.details
+                this.layout
             }
 
             Variants::Single { index } => {
                 // Deny calling for_variant more than once for non-Single enums.
-                if let Ok(layout) = cx.layout_of(this.ty).to_result() {
-                    assert_eq!(layout.variants, Variants::Single { index });
+                if let Ok(original_layout) = cx.layout_of(this.ty).to_result() {
+                    assert_eq!(original_layout.variants, Variants::Single { index });
                 }
 
                 let fields = match this.ty.kind {
@@ -2004,7 +1997,7 @@ where
                     _ => bug!(),
                 };
                 let tcx = cx.tcx();
-                tcx.intern_layout(LayoutDetails {
+                tcx.intern_layout(Layout {
                     variants: Variants::Single { index: variant_index },
                     fields: FieldPlacement::Union(fields),
                     abi: Abi::Uninhabited,
@@ -2017,17 +2010,17 @@ where
             Variants::Multiple { ref variants, .. } => &variants[variant_index],
         };
 
-        assert_eq!(details.variants, Variants::Single { index: variant_index });
+        assert_eq!(layout.variants, Variants::Single { index: variant_index });
 
-        TyLayout { ty: this.ty, details }
+        TyLayout { ty: this.ty, layout }
     }
 
     fn field(this: TyLayout<'tcx>, cx: &C, i: usize) -> C::TyLayout {
         let tcx = cx.tcx();
         let discr_layout = |discr: &Scalar| -> C::TyLayout {
-            let layout = LayoutDetails::scalar(cx, discr.clone());
+            let layout = Layout::scalar(cx, discr.clone());
             MaybeResult::from(Ok(TyLayout {
-                details: tcx.intern_layout(layout),
+                layout: tcx.intern_layout(layout),
                 ty: discr.value.to_ty(tcx),
             }))
         };
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index 90fb7eb2bb3ac..e885132fe2a0e 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -219,7 +219,7 @@ pub(super) fn from_known_layout<'tcx>(
             if cfg!(debug_assertions) {
                 let layout2 = compute()?;
                 assert_eq!(
-                    layout.details, layout2.details,
+                    layout.layout, layout2.layout,
                     "mismatch in layout of supposedly equal-layout types {:?} and {:?}",
                     layout.ty, layout2.ty
                 );
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
index 6cf11c071e4f7..9c08ac9fc771d 100644
--- a/src/librustc_mir/interpret/place.rs
+++ b/src/librustc_mir/interpret/place.rs
@@ -853,7 +853,7 @@ where
         // We do NOT compare the types for equality, because well-typed code can
         // actually "transmute" `&mut T` to `&T` in an assignment without a cast.
         assert!(
-            src.layout.details == dest.layout.details,
+            src.layout.layout == dest.layout.layout,
             "Layout mismatch when copying!\nsrc: {:#?}\ndest: {:#?}",
             src,
             dest
@@ -907,7 +907,7 @@ where
         src: OpTy<'tcx, M::PointerTag>,
         dest: PlaceTy<'tcx, M::PointerTag>,
     ) -> InterpResult<'tcx> {
-        if src.layout.details == dest.layout.details {
+        if src.layout.layout == dest.layout.layout {
             // Fast path: Just use normal `copy_op`
             return self.copy_op(src, dest);
         }
diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
index cbb79637076bc..3dc7d646825d1 100644
--- a/src/librustc_mir/transform/const_prop.rs
+++ b/src/librustc_mir/transform/const_prop.rs
@@ -688,7 +688,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                                 let ty1 = substs[0].expect_ty();
                                 let ty2 = substs[1].expect_ty();
                                 let ty_is_scalar = |ty| {
-                                    this.ecx.layout_of(ty).ok().map(|ty| ty.details.abi.is_scalar())
+                                    this.ecx.layout_of(ty).ok().map(|layout| layout.abi.is_scalar())
                                         == Some(true)
                                 };
                                 if ty_is_scalar(ty1) && ty_is_scalar(ty2) {
diff --git a/src/librustc_mir/transform/uninhabited_enum_branching.rs b/src/librustc_mir/transform/uninhabited_enum_branching.rs
index bbaa66f5954cb..7178e614f0a97 100644
--- a/src/librustc_mir/transform/uninhabited_enum_branching.rs
+++ b/src/librustc_mir/transform/uninhabited_enum_branching.rs
@@ -53,7 +53,7 @@ fn variant_discriminants<'tcx>(
     ty: Ty<'tcx>,
     tcx: TyCtxt<'tcx>,
 ) -> Vec<u128> {
-    match &layout.details.variants {
+    match &layout.variants {
         Variants::Single { index } => vec![index.as_u32() as u128],
         Variants::Multiple { variants, .. } => variants
             .iter_enumerated()
diff --git a/src/librustc_target/abi/mod.rs b/src/librustc_target/abi/mod.rs
index 635fb80b65980..f59a2c2ea8760 100644
--- a/src/librustc_target/abi/mod.rs
+++ b/src/librustc_target/abi/mod.rs
@@ -790,7 +790,7 @@ pub enum Variants {
         discr: Scalar,
         discr_kind: DiscriminantKind,
         discr_index: usize,
-        variants: IndexVec<VariantIdx, LayoutDetails>,
+        variants: IndexVec<VariantIdx, Layout>,
     },
 }
 
@@ -873,7 +873,7 @@ impl Niche {
 }
 
 #[derive(PartialEq, Eq, Hash, Debug, HashStable_Generic)]
-pub struct LayoutDetails {
+pub struct Layout {
     /// Says where the fields are located within the layout.
     /// Primitives and uninhabited enums appear as unions without fields.
     pub fields: FieldPlacement,
@@ -904,12 +904,12 @@ pub struct LayoutDetails {
     pub size: Size,
 }
 
-impl LayoutDetails {
+impl Layout {
     pub fn scalar<C: HasDataLayout>(cx: &C, scalar: Scalar) -> Self {
         let largest_niche = Niche::from_scalar(cx, Size::ZERO, scalar.clone());
         let size = scalar.value.size(cx);
         let align = scalar.value.align(cx);
-        LayoutDetails {
+        Layout {
             variants: Variants::Single { index: VariantIdx::new(0) },
             fields: FieldPlacement::Union(0),
             abi: Abi::Scalar(scalar),
@@ -920,23 +920,24 @@ impl LayoutDetails {
     }
 }
 
-/// The details of the layout of a type, alongside the type itself.
+/// The layout of a type, alongside the type itself.
 /// Provides various type traversal APIs (e.g., recursing into fields).
 ///
-/// Note that the details are NOT guaranteed to always be identical
-/// to those obtained from `layout_of(ty)`, as we need to produce
+/// Note that the layout is NOT guaranteed to always be identical
+/// to that obtained from `layout_of(ty)`, as we need to produce
 /// layouts for which Rust types do not exist, such as enum variants
 /// or synthetic fields of enums (i.e., discriminants) and fat pointers.
+// FIXME: rename to TyAndLayout.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TyLayout<'a, Ty> {
     pub ty: Ty,
-    pub details: &'a LayoutDetails,
+    pub layout: &'a Layout,
 }
 
 impl<'a, Ty> Deref for TyLayout<'a, Ty> {
-    type Target = &'a LayoutDetails;
-    fn deref(&self) -> &&'a LayoutDetails {
-        &self.details
+    type Target = &'a Layout;
+    fn deref(&self) -> &&'a Layout {
+        &self.layout
     }
 }
 
@@ -1097,7 +1098,7 @@ impl<'a, Ty> TyLayout<'a, Ty> {
         };
         if !valid {
             // This is definitely not okay.
-            trace!("might_permit_raw_init({:?}, zero={}): not valid", self.details, zero);
+            trace!("might_permit_raw_init({:?}, zero={}): not valid", self.layout, zero);
             return Ok(false);
         }
 
diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs
index d0a87e240da89..c71f2331759b0 100644
--- a/src/librustc_typeck/coherence/builtin.rs
+++ b/src/librustc_typeck/coherence/builtin.rs
@@ -215,7 +215,7 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: DefId) {
                             let ty_b = field.ty(tcx, substs_b);
 
                             if let Ok(layout) = tcx.layout_of(param_env.and(ty_a)) {
-                                if layout.is_zst() && layout.details.align.abi.bytes() == 1 {
+                                if layout.is_zst() && layout.align.abi.bytes() == 1 {
                                     // ignore ZST fields with alignment of 1 byte
                                     return None;
                                 }
diff --git a/src/test/ui/layout/debug.stderr b/src/test/ui/layout/debug.stderr
index 0ce538285f8c4..ef88cf1e4c13a 100644
--- a/src/test/ui/layout/debug.stderr
+++ b/src/test/ui/layout/debug.stderr
@@ -1,4 +1,4 @@
-error: layout debugging: LayoutDetails {
+error: layout debugging: Layout {
     fields: Arbitrary {
         offsets: [
             Size {
@@ -20,7 +20,7 @@ error: layout debugging: LayoutDetails {
         discr_kind: Tag,
         discr_index: 0,
         variants: [
-            LayoutDetails {
+            Layout {
                 fields: Arbitrary {
                     offsets: [],
                     memory_index: [],
@@ -42,7 +42,7 @@ error: layout debugging: LayoutDetails {
                     raw: 4,
                 },
             },
-            LayoutDetails {
+            Layout {
                 fields: Arbitrary {
                     offsets: [
                         Size {
@@ -110,7 +110,7 @@ error: layout debugging: LayoutDetails {
 LL | enum E { Foo, Bar(!, i32, i32) }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: layout debugging: LayoutDetails {
+error: layout debugging: Layout {
     fields: Arbitrary {
         offsets: [
             Size {
@@ -164,7 +164,7 @@ error: layout debugging: LayoutDetails {
 LL | struct S { f1: i32, f2: (), f3: i32 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: layout debugging: LayoutDetails {
+error: layout debugging: Layout {
     fields: Union(
         2,
     ),
@@ -190,7 +190,7 @@ error: layout debugging: LayoutDetails {
 LL | union U { f1: (i32, i32), f3: i32 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: layout debugging: LayoutDetails {
+error: layout debugging: Layout {
     fields: Arbitrary {
         offsets: [
             Size {
@@ -212,7 +212,7 @@ error: layout debugging: LayoutDetails {
         discr_kind: Tag,
         discr_index: 0,
         variants: [
-            LayoutDetails {
+            Layout {
                 fields: Arbitrary {
                     offsets: [
                         Size {
@@ -240,7 +240,7 @@ error: layout debugging: LayoutDetails {
                     raw: 8,
                 },
             },
-            LayoutDetails {
+            Layout {
                 fields: Arbitrary {
                     offsets: [
                         Size {