Rollup merge of #69700 - anyska:layout-details-rename, r=Dylan-DPC

Rename LayoutDetails to just Layout.

src/librustc/arena.rs

@@ -19,7 +19,7 @@ use std::slice;
 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,

src/librustc/query/mod.rs

@@ -711,7 +711,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>> {
             no_force
             desc { "computing layout of `{}`", env.value }
         }

src/librustc/ty/context.rs

@@ -23,7 +23,7 @@ use crate::mir::{
 use crate::traits;
 use crate::traits::{Clause, Clauses, Goal, GoalKind, Goals};
 use crate::ty::free_region_map::FreeRegionMap;
-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};
@@ -1019,7 +1019,7 @@ pub struct GlobalCtxt<'tcx> {
 
     pub alloc_map: Lock<interpret::AllocMap<'tcx>>,
 
-    layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>,
+    layout_interner: ShardedHashMap<&'tcx Layout, ()>,
 
     output_filenames: Arc<OutputFilenames>,
 }
@@ -1074,7 +1074,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))
     }
 

src/librustc/ty/layout.rs

@@ -183,7 +183,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();
@@ -242,7 +242,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);
@@ -256,7 +256,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],
@@ -275,7 +275,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() {
@@ -428,17 +428,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,
                     ) => {
@@ -476,7 +470,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,
@@ -486,7 +480,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();
@@ -495,8 +489,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)?))
@@ -505,11 +498,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 },
             )),
@@ -522,11 +515,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,
@@ -544,13 +537,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(..) => {
@@ -587,7 +580,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,
@@ -598,7 +591,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 },
@@ -607,7 +600,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 },
@@ -676,7 +669,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 },
@@ -752,7 +745,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,
@@ -976,7 +969,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 {
@@ -1171,7 +1164,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;
@@ -1218,7 +1211,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,
@@ -1249,7 +1242,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));
@@ -1396,7 +1389,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;
 
@@ -1562,7 +1555,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,
@@ -1945,8 +1938,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`.
@@ -1969,8 +1962,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`.
@@ -2019,21 +2012,21 @@ where
         + HasParamEnv<'tcx>,
 {
     fn for_variant(this: TyLayout<'tcx>, cx: &C, variant_index: VariantIdx) -> TyLayout<'tcx> {
-        let details = match this.variants {
-            Variants::Single { index } if index == variant_index => this.details,
+        let layout = match this.variants {
+            Variants::Single { index } if index == variant_index => 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 {
                     ty::Adt(def, _) => def.variants[variant_index].fields.len(),
                     _ => 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,
@@ -2046,17 +2039,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),
             }))
         };

src/librustc_mir/interpret/operand.rs

@@ -220,7 +220,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
                 );

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);
         }

src/librustc_mir/transform/const_prop.rs

@@ -692,7 +692,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) {

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()