From 68046642c460dfd8b8042f37bd392b15f4e158e6 Mon Sep 17 00:00:00 2001 From: Ana-Maria Mihalache Date: Wed, 4 Mar 2020 14:13:00 +0000 Subject: [PATCH] Rename LayoutDetails to just Layout. --- src/librustc/arena.rs | 2 +- src/librustc/query/mod.rs | 2 +- src/librustc/ty/context.rs | 6 +- src/librustc/ty/layout.rs | 85 +++++++++---------- src/librustc_mir/interpret/operand.rs | 2 +- src/librustc_mir/interpret/place.rs | 4 +- src/librustc_mir/transform/const_prop.rs | 2 +- .../transform/uninhabited_enum_branching.rs | 2 +- src/librustc_target/abi/mod.rs | 23 ++--- src/librustc_typeck/coherence/builtin.rs | 2 +- 10 files changed, 62 insertions(+), 68 deletions(-) diff --git a/src/librustc/arena.rs b/src/librustc/arena.rs index 0384a9f781578..da0f63c0f99cd 100644 --- a/src/librustc/arena.rs +++ b/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, diff --git a/src/librustc/query/mod.rs b/src/librustc/query/mod.rs index 9277f5a380b40..c08c28adbb104 100644 --- a/src/librustc/query/mod.rs +++ b/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 } } diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 20736b50831bb..51cc77df9a5a3 100644 --- a/src/librustc/ty/context.rs +++ b/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>, - layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>, + layout_interner: ShardedHashMap<&'tcx Layout, ()>, output_filenames: Arc, } @@ -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)) } diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index f1b4b828c71fa..d5ca9fa65b694 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -184,7 +184,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(); @@ -243,7 +243,7 @@ fn invert_mapping(map: &[u32]) -> Vec { } 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); @@ -257,7 +257,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], @@ -276,7 +276,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> { fields: &[TyLayout<'_>], repr: &ReprOptions, kind: StructKind, - ) -> Result> { + ) -> Result> { let dl = self.data_layout(); let pack = repr.pack; if pack.is_some() && repr.align.is_some() { @@ -429,17 +429,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, ) => { @@ -477,7 +471,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, @@ -487,7 +481,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(); @@ -496,8 +490,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)?)) @@ -506,11 +499,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 }, )), @@ -523,11 +516,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, @@ -545,13 +538,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(..) => { @@ -588,7 +581,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, @@ -599,7 +592,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 }, @@ -608,7 +601,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 }, @@ -677,7 +670,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 }, @@ -753,7 +746,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, @@ -977,7 +970,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 { @@ -1172,7 +1165,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; @@ -1219,7 +1212,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, @@ -1250,7 +1243,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)); @@ -1397,7 +1390,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; @@ -1563,7 +1556,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, @@ -1946,8 +1939,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`. @@ -1970,8 +1963,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`. @@ -2020,13 +2013,13 @@ 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 { @@ -2034,7 +2027,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, @@ -2047,17 +2040,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 44b46d65bf1c7..f25691290e68c 100644 --- a/src/librustc_mir/interpret/operand.rs +++ b/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 ); diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs index 4f96cb698915d..80ea108b48b20 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 c196e748df381..9ccc4a01d17e5 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/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) { 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 { - 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 ffef38cedfc17..eaa91533517c7 100644 --- a/src/librustc_target/abi/mod.rs +++ b/src/librustc_target/abi/mod.rs @@ -787,7 +787,7 @@ pub enum Variants { discr: Scalar, discr_kind: DiscriminantKind, discr_index: usize, - variants: IndexVec, + variants: IndexVec, }, } @@ -870,7 +870,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 fieldless enums appear as unions without fields. pub fields: FieldPlacement, @@ -901,12 +901,12 @@ pub struct LayoutDetails { pub size: Size, } -impl LayoutDetails { +impl Layout { pub fn scalar(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), @@ -917,23 +917,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 } } diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index aa39a191b3df6..f061dad5a9d10 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -217,7 +217,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; }