Compute data layout of types

crates/hir-def/src/adt.rs

@@ -1,6 +1,6 @@
 //! Defines hir-level representation of structs, enums and unions
 
-use std::{num::NonZeroU32, sync::Arc};
+use std::sync::Arc;
 
 use base_db::CrateId;
 use either::Either;
@@ -18,6 +18,7 @@ use crate::{
     db::DefDatabase,
     intern::Interned,
     item_tree::{AttrOwner, Field, FieldAstId, Fields, ItemTree, ModItem, RawVisibilityId},
+    layout::{Align, ReprFlags, ReprOptions},
     nameres::diagnostics::DefDiagnostic,
     src::HasChildSource,
     src::HasSource,
@@ -34,7 +35,7 @@ use cfg::CfgOptions;
 pub struct StructData {
     pub name: Name,
     pub variant_data: Arc<VariantData>,
-    pub repr: Option<ReprData>,
+    pub repr: Option<ReprOptions>,
     pub visibility: RawVisibility,
 }
 
@@ -42,7 +43,7 @@ pub struct StructData {
 pub struct EnumData {
     pub name: Name,
     pub variants: Arena<EnumVariantData>,
-    pub repr: Option<ReprData>,
+    pub repr: Option<ReprOptions>,
     pub visibility: RawVisibility,
 }
 
@@ -67,80 +68,74 @@ pub struct FieldData {
     pub visibility: RawVisibility,
 }
 
-#[derive(Copy, Debug, Clone, PartialEq, Eq)]
-pub enum ReprKind {
-    C,
-    BuiltinInt { builtin: Either<BuiltinInt, BuiltinUint>, is_c: bool },
-    Transparent,
-    Default,
-}
-
-#[derive(Copy, Debug, Clone, PartialEq, Eq)]
-pub struct ReprData {
-    pub kind: ReprKind,
-    pub packed: bool,
-    pub align: Option<NonZeroU32>,
-}
-
 fn repr_from_value(
     db: &dyn DefDatabase,
     krate: CrateId,
     item_tree: &ItemTree,
     of: AttrOwner,
-) -> Option<ReprData> {
+) -> Option<ReprOptions> {
     item_tree.attrs(db, krate, of).by_key("repr").tt_values().find_map(parse_repr_tt)
 }
 
-fn parse_repr_tt(tt: &Subtree) -> Option<ReprData> {
+fn parse_repr_tt(tt: &Subtree) -> Option<ReprOptions> {
     match tt.delimiter {
         Some(Delimiter { kind: DelimiterKind::Parenthesis, .. }) => {}
         _ => return None,
     }
 
-    let mut data = ReprData { kind: ReprKind::Default, packed: false, align: None };
+    let mut flags = ReprFlags::empty();
+    let mut int = None;
+    let mut max_align: Option<Align> = None;
+    let mut min_pack: Option<Align> = None;
 
     let mut tts = tt.token_trees.iter().peekable();
     while let Some(tt) = tts.next() {
         if let TokenTree::Leaf(Leaf::Ident(ident)) = tt {
-            match &*ident.text {
+            flags.insert(match &*ident.text {
                 "packed" => {
-                    data.packed = true;
+                    let pack = if let Some(TokenTree::Subtree(tt)) = tts.peek() {
-                    if let Some(TokenTree::Subtree(_)) = tts.peek() {
                         tts.next();
+                        if let Some(TokenTree::Leaf(Leaf::Literal(lit))) = tt.token_trees.first() {
+                            lit.text.parse().unwrap_or_default()
+                        } else {
+                            0
                         }
+                    } else {
+                        0
+                    };
+                    let pack = Align::from_bytes(pack).unwrap();
+                    min_pack =
+                        Some(if let Some(min_pack) = min_pack { min_pack.min(pack) } else { pack });
+                    ReprFlags::empty()
                 }
                 "align" => {
                     if let Some(TokenTree::Subtree(tt)) = tts.peek() {
                         tts.next();
                         if let Some(TokenTree::Leaf(Leaf::Literal(lit))) = tt.token_trees.first() {
                             if let Ok(align) = lit.text.parse() {
-                                data.align = Some(align);
+                                let align = Align::from_bytes(align).ok();
+                                max_align = max_align.max(align);
                             }
                         }
                     }
+                    ReprFlags::empty()
                 }
-                "C" => {
+                "C" => ReprFlags::IS_C,
-                    if let ReprKind::BuiltinInt { is_c, .. } = &mut data.kind {
+                "transparent" => ReprFlags::IS_TRANSPARENT,
-                        *is_c = true;
-                    } else {
-                        data.kind = ReprKind::C;
-                    }
-                }
-                "transparent" => data.kind = ReprKind::Transparent,
                 repr => {
-                    let is_c = matches!(data.kind, ReprKind::C);
                     if let Some(builtin) = BuiltinInt::from_suffix(repr)
                         .map(Either::Left)
                         .or_else(|| BuiltinUint::from_suffix(repr).map(Either::Right))
                     {
-                        data.kind = ReprKind::BuiltinInt { builtin, is_c };
+                        int = Some(builtin);
-                    }
                     }
+                    ReprFlags::empty()
                 }
+            })
         }
     }
 
-    Some(data)
+    Some(ReprOptions { int, align: max_align, pack: min_pack, flags })
 }
 
 impl StructData {
@@ -283,7 +278,7 @@ impl EnumData {
 
     pub fn variant_body_type(&self) -> Either<BuiltinInt, BuiltinUint> {
         match self.repr {
-            Some(ReprData { kind: ReprKind::BuiltinInt { builtin, .. }, .. }) => builtin,
+            Some(ReprOptions { int: Some(builtin), .. }) => builtin,
             _ => Either::Left(BuiltinInt::Isize),
         }
     }

crates/hir-def/src/lib.rs

@@ -34,6 +34,7 @@ pub mod adt;
 pub mod data;
 pub mod generics;
 pub mod lang_item;
+pub mod layout;
 
 pub mod expr;
 pub mod body;

crates/hir-expand/src/name.rs

@@ -419,6 +419,7 @@ pub mod known {
         shr,
         sub_assign,
         sub,
+        unsafe_cell,
         va_list
     );
 

crates/hir-ty/src/db.rs

@@ -6,8 +6,11 @@ use std::sync::Arc;
 use arrayvec::ArrayVec;
 use base_db::{impl_intern_key, salsa, CrateId, Upcast};
 use hir_def::{
-    db::DefDatabase, expr::ExprId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId,
+    db::DefDatabase,
-    FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId,
+    expr::ExprId,
+    layout::{Layout, LayoutError, TargetDataLayout},
+    AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId, GenericDefId,
+    ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId,
 };
 use la_arena::ArenaMap;
 
@@ -16,7 +19,7 @@ use crate::{
     consteval::{ComputedExpr, ConstEvalError},
     method_resolution::{InherentImpls, TraitImpls, TyFingerprint},
     Binders, CallableDefId, FnDefId, GenericArg, ImplTraitId, InferenceResult, Interner, PolyFnSig,
-    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
+    QuantifiedWhereClause, ReturnTypeImplTraits, Substitution, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
 
@@ -57,6 +60,13 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     #[salsa::invoke(crate::lower::field_types_query)]
     fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;
 
+    #[salsa::invoke(crate::layout::layout_of_adt_query)]
+    #[salsa::cycle(crate::layout::layout_of_adt_recover)]
+    fn layout_of_adt(&self, def: AdtId, subst: Substitution) -> Result<Layout, LayoutError>;
+
+    #[salsa::invoke(crate::layout::current_target_data_layout_query)]
+    fn current_target_data_layout(&self) -> Arc<TargetDataLayout>;
+
     #[salsa::invoke(crate::lower::callable_item_sig)]
     fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig;
 

crates/hir-ty/src/diagnostics/match_check.rs

@@ -12,16 +12,16 @@ pub(crate) mod usefulness;
 
 use chalk_ir::Mutability;
 use hir_def::{
-    adt::VariantData, body::Body, expr::PatId, AdtId, EnumVariantId, HasModule, LocalFieldId,
+    adt::VariantData, body::Body, expr::PatId, AdtId, EnumVariantId, LocalFieldId, VariantId,
-    VariantId,
 };
-use hir_expand::name::{name, Name};
+use hir_expand::name::Name;
 use stdx::{always, never};
 
 use crate::{
     db::HirDatabase,
     display::{HirDisplay, HirDisplayError, HirFormatter},
     infer::BindingMode,
+    lang_items::is_box,
     InferenceResult, Interner, Substitution, Ty, TyExt, TyKind,
 };
 
@@ -405,13 +405,6 @@ where
     }
 }
 
-fn is_box(adt: AdtId, db: &dyn HirDatabase) -> bool {
-    let owned_box = name![owned_box].to_smol_str();
-    let krate = adt.module(db.upcast()).krate();
-    let box_adt = db.lang_item(krate, owned_box).and_then(|it| it.as_struct()).map(AdtId::from);
-    Some(adt) == box_adt
-}
-
 pub(crate) trait PatternFoldable: Sized {
     fn fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self {
         self.super_fold_with(folder)

crates/hir-ty/src/lang_items.rs

@@ -0,0 +1,20 @@
+//! Functions to detect special lang items
+
+use hir_def::{AdtId, HasModule};
+use hir_expand::name;
+
+use crate::db::HirDatabase;
+
+pub fn is_box(adt: AdtId, db: &dyn HirDatabase) -> bool {
+    let owned_box = name![owned_box].to_smol_str();
+    let krate = adt.module(db.upcast()).krate();
+    let box_adt = db.lang_item(krate, owned_box).and_then(|it| it.as_struct()).map(AdtId::from);
+    Some(adt) == box_adt
+}
+
+pub fn is_unsafe_cell(adt: AdtId, db: &dyn HirDatabase) -> bool {
+    let owned_box = name![unsafe_cell].to_smol_str();
+    let krate = adt.module(db.upcast()).krate();
+    let box_adt = db.lang_item(krate, owned_box).and_then(|it| it.as_struct()).map(AdtId::from);
+    Some(adt) == box_adt
+}

crates/hir-ty/src/layout.rs

@@ -0,0 +1,271 @@
+//! Compute the binary representation of a type
+
+use chalk_ir::{AdtId, TyKind};
+pub(self) use hir_def::layout::*;
+use hir_def::LocalFieldId;
+
+use crate::{db::HirDatabase, Interner, Substitution, Ty};
+
+use self::adt::univariant;
+pub use self::{
+    adt::{layout_of_adt_query, layout_of_adt_recover},
+    target::current_target_data_layout_query,
+};
+
+macro_rules! user_error {
+    ($x: expr) => {
+        return Err(LayoutError::UserError(format!($x)))
+    };
+}
+
+mod adt;
+mod target;
+
+fn scalar_unit(dl: &TargetDataLayout, value: Primitive) -> Scalar {
+    Scalar::Initialized { value, valid_range: WrappingRange::full(value.size(dl)) }
+}
+
+fn scalar(dl: &TargetDataLayout, value: Primitive) -> Layout {
+    Layout::scalar(dl, scalar_unit(dl, value))
+}
+
+fn scalar_pair(dl: &TargetDataLayout, a: Scalar, b: Scalar) -> Layout {
+    let b_align = b.align(dl);
+    let align = a.align(dl).max(b_align).max(dl.aggregate_align);
+    let b_offset = a.size(dl).align_to(b_align.abi);
+    let size = b_offset.checked_add(b.size(dl), dl).unwrap().align_to(align.abi);
+
+    // HACK(nox): We iter on `b` and then `a` because `max_by_key`
+    // returns the last maximum.
+    let largest_niche = Niche::from_scalar(dl, b_offset, b)
+        .into_iter()
+        .chain(Niche::from_scalar(dl, Size::ZERO, a))
+        .max_by_key(|niche| niche.available(dl));
+
+    Layout {
+        variants: Variants::Single,
+        fields: FieldsShape::Arbitrary {
+            offsets: vec![Size::ZERO, b_offset],
+            memory_index: vec![0, 1],
+        },
+        abi: Abi::ScalarPair(a, b),
+        largest_niche,
+        align,
+        size,
+    }
+}
+
+pub fn layout_of_ty(db: &dyn HirDatabase, ty: &Ty) -> Result<Layout, LayoutError> {
+    let dl = &*db.current_target_data_layout();
+    Ok(match ty.kind(Interner) {
+        TyKind::Adt(AdtId(def), subst) => db.layout_of_adt(*def, subst.clone())?,
+        TyKind::Scalar(s) => match s {
+            chalk_ir::Scalar::Bool => Layout::scalar(
+                dl,
+                Scalar::Initialized {
+                    value: Primitive::Int(Integer::I8, false),
+                    valid_range: WrappingRange { start: 0, end: 1 },
+                },
+            ),
+            chalk_ir::Scalar::Char => Layout::scalar(
+                dl,
+                Scalar::Initialized {
+                    value: Primitive::Int(Integer::I32, false),
+                    valid_range: WrappingRange { start: 0, end: 0x10FFFF },
+                },
+            ),
+            chalk_ir::Scalar::Int(i) => scalar(
+                dl,
+                Primitive::Int(
+                    match i {
+                        chalk_ir::IntTy::Isize => dl.ptr_sized_integer(),
+                        chalk_ir::IntTy::I8 => Integer::I8,
+                        chalk_ir::IntTy::I16 => Integer::I16,
+                        chalk_ir::IntTy::I32 => Integer::I32,
+                        chalk_ir::IntTy::I64 => Integer::I64,
+                        chalk_ir::IntTy::I128 => Integer::I128,
+                    },
+                    false,
+                ),
+            ),
+            chalk_ir::Scalar::Uint(i) => scalar(
+                dl,
+                Primitive::Int(
+                    match i {
+                        chalk_ir::UintTy::Usize => dl.ptr_sized_integer(),
+                        chalk_ir::UintTy::U8 => Integer::I8,
+                        chalk_ir::UintTy::U16 => Integer::I16,
+                        chalk_ir::UintTy::U32 => Integer::I32,
+                        chalk_ir::UintTy::U64 => Integer::I64,
+                        chalk_ir::UintTy::U128 => Integer::I128,
+                    },
+                    true,
+                ),
+            ),
+            chalk_ir::Scalar::Float(f) => scalar(
+                dl,
+                match f {
+                    chalk_ir::FloatTy::F32 => Primitive::F32,
+                    chalk_ir::FloatTy::F64 => Primitive::F64,
+                },
+            ),
+        },
+        TyKind::Tuple(len, tys) => {
+            let kind = if *len == 0 { StructKind::AlwaysSized } else { StructKind::MaybeUnsized };
+
+            univariant(
+                dl,
+                &tys.iter(Interner)
+                    .map(|k| layout_of_ty(db, k.assert_ty_ref(Interner)))
+                    .collect::<Result<Vec<_>, _>>()?,
+                &ReprOptions::default(),
+                kind,
+            )?
+        }
+        TyKind::Array(element, count) => {
+            let count = match count.data(Interner).value {
+                chalk_ir::ConstValue::Concrete(c) => match c.interned {
+                    hir_def::type_ref::ConstScalar::Int(x) => x as u64,
+                    hir_def::type_ref::ConstScalar::UInt(x) => x as u64,
+                    hir_def::type_ref::ConstScalar::Unknown => {
+                        user_error!("unknown const generic parameter")
+                    }
+                    _ => user_error!("mismatched type of const generic parameter"),
+                },
+                _ => return Err(LayoutError::HasPlaceholder),
+            };
+            let element = layout_of_ty(db, element)?;
+            let size = element.size.checked_mul(count, dl).ok_or(LayoutError::SizeOverflow)?;
+
+            let abi = if count != 0 && matches!(element.abi, Abi::Uninhabited) {
+                Abi::Uninhabited
+            } else {
+                Abi::Aggregate { sized: true }
+            };
+
+            let largest_niche = if count != 0 { element.largest_niche } else { None };
+
+            Layout {
+                variants: Variants::Single,
+                fields: FieldsShape::Array { stride: element.size, count },
+                abi,
+                largest_niche,
+                align: element.align,
+                size,
+            }
+        }
+        TyKind::Slice(element) => {
+            let element = layout_of_ty(db, element)?;
+            Layout {
+                variants: Variants::Single,
+                fields: FieldsShape::Array { stride: element.size, count: 0 },
+                abi: Abi::Aggregate { sized: false },
+                largest_niche: None,
+                align: element.align,
+                size: Size::ZERO,
+            }
+        }
+        // Potentially-wide pointers.
+        TyKind::Ref(_, _, pointee) | TyKind::Raw(_, pointee) => {
+            let mut data_ptr = scalar_unit(dl, Primitive::Pointer);
+            if matches!(ty.kind(Interner), TyKind::Ref(..)) {
+                data_ptr.valid_range_mut().start = 1;
+            }
+
+            // let pointee = tcx.normalize_erasing_regions(param_env, pointee);
+            // if pointee.is_sized(tcx.at(DUMMY_SP), param_env) {
+            //     return Ok(tcx.intern_layout(LayoutS::scalar(cx, data_ptr)));
+            // }
+
+            let unsized_part = struct_tail_erasing_lifetimes(db, pointee.clone());
+            let metadata = match unsized_part.kind(Interner) {
+                TyKind::Slice(_) | TyKind::Str => {
+                    scalar_unit(dl, Primitive::Int(dl.ptr_sized_integer(), false))
+                }
+                TyKind::Dyn(..) => {
+                    let mut vtable = scalar_unit(dl, Primitive::Pointer);
+                    vtable.valid_range_mut().start = 1;
+                    vtable
+                }
+                _ => {
+                    // pointee is sized
+                    return Ok(Layout::scalar(dl, data_ptr));
+                }
+            };
+
+            // Effectively a (ptr, meta) tuple.
+            scalar_pair(dl, data_ptr, metadata)
+        }
+        TyKind::FnDef(_, _) => {
+            univariant(dl, &[], &ReprOptions::default(), StructKind::AlwaysSized)?
+        }
+        TyKind::Str => Layout {
+            variants: Variants::Single,
+            fields: FieldsShape::Array { stride: Size::from_bytes(1), count: 0 },
+            abi: Abi::Aggregate { sized: false },
+            largest_niche: None,
+            align: dl.i8_align,
+            size: Size::ZERO,
+        },
+        TyKind::Never => Layout {
+            variants: Variants::Single,
+            fields: FieldsShape::Primitive,
+            abi: Abi::Uninhabited,
+            largest_niche: None,
+            align: dl.i8_align,
+            size: Size::ZERO,
+        },
+        TyKind::Dyn(_) | TyKind::Foreign(_) => {
+            let mut unit = univariant(dl, &[], &ReprOptions::default(), StructKind::AlwaysSized)?;
+            match unit.abi {
+                Abi::Aggregate { ref mut sized } => *sized = false,
+                _ => user_error!("bug"),
+            }
+            unit
+        }
+        TyKind::Function(_) => {
+            let mut ptr = scalar_unit(dl, Primitive::Pointer);
+            ptr.valid_range_mut().start = 1;
+            Layout::scalar(dl, ptr)
+        }
+        TyKind::Closure(_, _)
+        | TyKind::OpaqueType(_, _)
+        | TyKind::Generator(_, _)
+        | TyKind::GeneratorWitness(_, _) => return Err(LayoutError::NotImplemented),
+        TyKind::AssociatedType(_, _)
+        | TyKind::Error
+        | TyKind::Alias(_)
+        | TyKind::Placeholder(_)
+        | TyKind::BoundVar(_)
+        | TyKind::InferenceVar(_, _) => return Err(LayoutError::HasPlaceholder),
+    })
+}
+
+fn struct_tail_erasing_lifetimes(db: &dyn HirDatabase, pointee: Ty) -> Ty {
+    match pointee.kind(Interner) {
+        TyKind::Adt(AdtId(adt), subst) => match adt {
+            &hir_def::AdtId::StructId(i) => {
+                let data = db.struct_data(i);
+                let mut it = data.variant_data.fields().iter().rev();
+                match it.next() {
+                    Some((f, _)) => field_ty(db, i.into(), f, subst),
+                    None => pointee,
+                }
+            }
+            _ => pointee,
+        },
+        _ => pointee,
+    }
+}
+
+fn field_ty(
+    db: &dyn HirDatabase,
+    def: hir_def::VariantId,
+    fd: LocalFieldId,
+    subst: &Substitution,
+) -> Ty {
+    db.field_types(def)[fd].clone().substitute(Interner, subst)
+}
+
+#[cfg(test)]
+mod tests;

crates/hir-ty/src/layout/adt.rs

@@ -0,0 +1,900 @@
+//! Compute the binary representation of structs, unions and enums
+
+use std::{
+    cmp::{self, Ordering},
+    iter,
+    num::NonZeroUsize,
+};
+
+use chalk_ir::TyKind;
+use hir_def::{
+    adt::VariantData,
+    layout::{
+        Abi, AbiAndPrefAlign, Align, FieldsShape, Integer, Layout, LayoutError, Niche, Primitive,
+        ReprOptions, Scalar, Size, StructKind, TagEncoding, TargetDataLayout, Variants,
+        WrappingRange,
+    },
+    AdtId, EnumVariantId, LocalEnumVariantId, UnionId, VariantId,
+};
+use la_arena::{ArenaMap, RawIdx};
+
+use crate::{
+    db::HirDatabase,
+    lang_items::is_unsafe_cell,
+    layout::{field_ty, scalar_unit},
+    Interner, Substitution,
+};
+
+use super::layout_of_ty;
+
+pub fn layout_of_adt_query(
+    db: &dyn HirDatabase,
+    def: AdtId,
+    subst: Substitution,
+) -> Result<Layout, LayoutError> {
+    let handle_variant = |def: VariantId, var: &VariantData| {
+        var.fields()
+            .iter()
+            .map(|(fd, _)| layout_of_ty(db, &field_ty(db, def, fd, &subst)))
+            .collect::<Result<Vec<_>, _>>()
+    };
+    fn struct_variant_idx() -> LocalEnumVariantId {
+        LocalEnumVariantId::from_raw(RawIdx::from(0))
+    }
+    let (variants, is_enum, repr) = match def {
+        AdtId::StructId(s) => {
+            let data = db.struct_data(s);
+            let mut r = ArenaMap::new();
+            r.insert(struct_variant_idx(), handle_variant(s.into(), &data.variant_data)?);
+            (r, false, data.repr.unwrap_or_default())
+        }
+        AdtId::UnionId(id) => return layout_of_union(db, id, &subst),
+        AdtId::EnumId(e) => {
+            let data = db.enum_data(e);
+            let r = data
+                .variants
+                .iter()
+                .map(|(idx, v)| {
+                    Ok((
+                        idx,
+                        handle_variant(
+                            EnumVariantId { parent: e, local_id: idx }.into(),
+                            &v.variant_data,
+                        )?,
+                    ))
+                })
+                .collect::<Result<_, _>>()?;
+            (r, true, data.repr.unwrap_or_default())
+        }
+    };
+
+    // A variant is absent if it's uninhabited and only has ZST fields.
+    // Present uninhabited variants only require space for their fields,
+    // but *not* an encoding of the discriminant (e.g., a tag value).
+    // See issue #49298 for more details on the need to leave space
+    // for non-ZST uninhabited data (mostly partial initialization).
+    let absent = |fields: &[Layout]| {
+        let uninhabited = fields.iter().any(|f| f.abi.is_uninhabited());
+        let is_zst = fields.iter().all(|f| f.is_zst());
+        uninhabited && is_zst
+    };
+    let (present_first, present_second) = {
+        let mut present_variants =
+            variants.iter().filter_map(|(i, v)| if absent(v) { None } else { Some(i) });
+        (present_variants.next(), present_variants.next())
+    };
+    let present_first = match present_first {
+        Some(present_first) => present_first,
+        // Uninhabited because it has no variants, or only absent ones.
+        None if is_enum => return layout_of_ty(db, &TyKind::Never.intern(Interner)),
+        // If it's a struct, still compute a layout so that we can still compute the
+        // field offsets.
+        None => struct_variant_idx(),
+    };
+
+    let is_univariant = !is_enum ||
+                    // Only one variant is present.
+                    (present_second.is_none() &&
+                        // Representation optimizations are allowed.
+                        !repr.inhibit_enum_layout_opt());
+    let dl = &*db.current_target_data_layout();
+
+    if is_univariant {
+        // Struct, or univariant enum equivalent to a struct.
+        // (Typechecking will reject discriminant-sizing attrs.)
+
+        let v = present_first;
+        let kind = if is_enum || variants[v].is_empty() {
+            StructKind::AlwaysSized
+        } else {
+            let always_sized = !variants[v].last().unwrap().is_unsized();
+            if !always_sized {
+                StructKind::MaybeUnsized
+            } else {
+                StructKind::AlwaysSized
+            }
+        };
+
+        let mut st = univariant(dl, &variants[v], &repr, kind)?;
+        st.variants = Variants::Single;
+
+        if is_unsafe_cell(def, db) {
+            let hide_niches = |scalar: &mut _| match scalar {
+                Scalar::Initialized { value, valid_range } => {
+                    *valid_range = WrappingRange::full(value.size(dl))
+                }
+                // Already doesn't have any niches
+                Scalar::Union { .. } => {}
+            };
+            match &mut st.abi {
+                Abi::Uninhabited => {}
+                Abi::Scalar(scalar) => hide_niches(scalar),
+                Abi::ScalarPair(a, b) => {
+                    hide_niches(a);
+                    hide_niches(b);
+                }
+                Abi::Vector { element, count: _ } => hide_niches(element),
+                Abi::Aggregate { sized: _ } => {}
+            }
+            st.largest_niche = None;
+        }
+        return Ok(st);
+    }
+
+    // Until we've decided whether to use the tagged or
+    // niche filling LayoutS, we don't want to intern the
+    // variant layouts, so we can't store them in the
+    // overall LayoutS. Store the overall LayoutS
+    // and the variant LayoutSs here until then.
+    struct TmpLayout {
+        layout: Layout,
+        variants: ArenaMap<LocalEnumVariantId, Layout>,
+    }
+
+    let calculate_niche_filling_layout = || -> Result<Option<TmpLayout>, LayoutError> {
+        // The current code for niche-filling relies on variant indices
+        // instead of actual discriminants, so enums with
+        // explicit discriminants (RFC #2363) would misbehave.
+        if repr.inhibit_enum_layout_opt()
+        // FIXME: bring these codes back
+        // || def
+        //     .variants()
+        //     .iter_enumerated()
+        //     .any(|(i, v)| v.discr != ty::VariantDiscr::Relative(i.as_u32()))
+        {
+            return Ok(None);
+        }
+
+        if variants.iter().count() < 2 {
+            return Ok(None);
+        }
+
+        let mut align = dl.aggregate_align;
+        let mut variant_layouts = variants
+            .iter()
+            .map(|(j, v)| {
+                let mut st = univariant(dl, v, &repr, StructKind::AlwaysSized)?;
+                st.variants = Variants::Single;
+
+                align = align.max(st.align);
+
+                Ok((j, st))
+            })
+            .collect::<Result<ArenaMap<_, _>, _>>()?;
+
+        let largest_variant_index = match variant_layouts
+            .iter()
+            .max_by_key(|(_i, layout)| layout.size.bytes())
+            .map(|(i, _layout)| i)
+        {
+            None => return Ok(None),
+            Some(i) => i,
+        };
+
+        let count = variants
+            .iter()
+            .map(|(i, _)| i)
+            .filter(|x| *x != largest_variant_index && !absent(&variants[*x]))
+            .count() as u128;
+
+        // Find the field with the largest niche
+        let (field_index, niche, (niche_start, niche_scalar)) = match variants
+            [largest_variant_index]
+            .iter()
+            .enumerate()
+            .filter_map(|(j, field)| Some((j, field.largest_niche?)))
+            .max_by_key(|(_, niche)| niche.available(dl))
+            .and_then(|(j, niche)| Some((j, niche, niche.reserve(dl, count)?)))
+        {
+            None => return Ok(None),
+            Some(x) => x,
+        };
+
+        let niche_offset =
+            niche.offset + variant_layouts[largest_variant_index].fields.offset(field_index, dl);
+        let niche_size = niche.value.size(dl);
+        let size = variant_layouts[largest_variant_index].size.align_to(align.abi);
+
+        let all_variants_fit = variant_layouts.iter_mut().all(|(i, layout)| {
+            if i == largest_variant_index {
+                return true;
+            }
+
+            layout.largest_niche = None;
+
+            if layout.size <= niche_offset {
+                // This variant will fit before the niche.
+                return true;
+            }
+
+            // Determine if it'll fit after the niche.
+            let this_align = layout.align.abi;
+            let this_offset = (niche_offset + niche_size).align_to(this_align);
+
+            if this_offset + layout.size > size {
+                return false;
+            }
+
+            // It'll fit, but we need to make some adjustments.
+            match layout.fields {
+                FieldsShape::Arbitrary { ref mut offsets, .. } => {
+                    for (j, offset) in offsets.iter_mut().enumerate() {
+                        if !variants[i][j].is_zst() {
+                            *offset += this_offset;
+                        }
+                    }
+                }
+                _ => {
+                    panic!("Layout of fields should be Arbitrary for variants")
+                }
+            }
+
+            // It can't be a Scalar or ScalarPair because the offset isn't 0.
+            if !layout.abi.is_uninhabited() {
+                layout.abi = Abi::Aggregate { sized: true };
+            }
+            layout.size += this_offset;
+
+            true
+        });
+
+        if !all_variants_fit {
+            return Ok(None);
+        }
+
+        let largest_niche = Niche::from_scalar(dl, niche_offset, niche_scalar);
+
+        let others_zst = variant_layouts
+            .iter()
+            .all(|(i, layout)| i == largest_variant_index || layout.size == Size::ZERO);
+        let same_size = size == variant_layouts[largest_variant_index].size;
+        let same_align = align == variant_layouts[largest_variant_index].align;
+
+        let abi = if variant_layouts.iter().all(|(_, v)| v.abi.is_uninhabited()) {
+            Abi::Uninhabited
+        } else if same_size && same_align && others_zst {
+            match variant_layouts[largest_variant_index].abi {
+                // When the total alignment and size match, we can use the
+                // same ABI as the scalar variant with the reserved niche.
+                Abi::Scalar(_) => Abi::Scalar(niche_scalar),
+                Abi::ScalarPair(first, second) => {
+                    // Only the niche is guaranteed to be initialised,
+                    // so use union layouts for the other primitive.
+                    if niche_offset == Size::ZERO {
+                        Abi::ScalarPair(niche_scalar, second.to_union())
+                    } else {
+                        Abi::ScalarPair(first.to_union(), niche_scalar)
+                    }
+                }
+                _ => Abi::Aggregate { sized: true },
+            }
+        } else {
+            Abi::Aggregate { sized: true }
+        };
+
+        let layout = Layout {
+            variants: Variants::Multiple {
+                tag: niche_scalar,
+                tag_encoding: TagEncoding::Niche {
+                    untagged_variant: largest_variant_index,
+                    niche_start,
+                },
+                tag_field: 0,
+                variants: ArenaMap::new(),
+            },
+            fields: FieldsShape::Arbitrary { offsets: vec![niche_offset], memory_index: vec![0] },
+            abi,
+            largest_niche,
+            size,
+            align,
+        };
+
+        Ok(Some(TmpLayout { layout, variants: variant_layouts }))
+    };
+
+    let niche_filling_layout = calculate_niche_filling_layout()?;
+
+    let (mut min, mut max) = (i128::MAX, i128::MIN);
+    // FIXME: bring these back
+    // let discr_type = repr.discr_type();
+    // let bits = Integer::from_attr(dl, discr_type).size().bits();
+    // for (i, discr) in def.discriminants(tcx) {
+    //     if variants[i].iter().any(|f| f.abi.is_uninhabited()) {
+    //         continue;
+    //     }
+    //     let mut x = discr.val as i128;
+    //     if discr_type.is_signed() {
+    //         // sign extend the raw representation to be an i128
+    //         x = (x << (128 - bits)) >> (128 - bits);
+    //     }
+    //     if x < min {
+    //         min = x;
+    //     }
+    //     if x > max {
+    //         max = x;
+    //     }
+    // }
+    // We might have no inhabited variants, so pretend there's at least one.
+    if (min, max) == (i128::MAX, i128::MIN) {
+        min = 0;
+        max = 0;
+    }
+    assert!(min <= max, "discriminant range is {}...{}", min, max);
+    let (min_ity, signed) = Integer::repr_discr(dl, &repr, min, max)?;
+
+    let mut align = dl.aggregate_align;
+    let mut size = Size::ZERO;
+
+    // We're interested in the smallest alignment, so start large.
+    let mut start_align = Align::from_bytes(256).unwrap();
+    assert_eq!(Integer::for_align(dl, start_align), None);
+
+    // repr(C) on an enum tells us to make a (tag, union) layout,
+    // so we need to grow the prefix alignment to be at least
+    // the alignment of the union. (This value is used both for
+    // determining the alignment of the overall enum, and the
+    // determining the alignment of the payload after the tag.)
+    let mut prefix_align = min_ity.align(dl).abi;
+    if repr.c() {
+        for (_, fields) in variants.iter() {
+            for field in fields {
+                prefix_align = prefix_align.max(field.align.abi);
+            }
+        }
+    }
+
+    // Create the set of structs that represent each variant.
+    let mut layout_variants = variants
+        .iter()
+        .map(|(i, field_layouts)| {
+            let mut st = univariant(
+                dl,
+                &field_layouts,
+                &repr,
+                StructKind::Prefixed(min_ity.size(), prefix_align),
+            )?;
+            st.variants = Variants::Single;
+            // Find the first field we can't move later
+            // to make room for a larger discriminant.
+            for field in st.fields.index_by_increasing_offset().map(|j| &field_layouts[j]) {
+                if !field.is_zst() || field.align.abi.bytes() != 1 {
+                    start_align = start_align.min(field.align.abi);
+                    break;
+                }
+            }
+            size = cmp::max(size, st.size);
+            align = align.max(st.align);
+            Ok((i, st))
+        })
+        .collect::<Result<ArenaMap<_, _>, _>>()?;
+
+    // Align the maximum variant size to the largest alignment.
+    size = size.align_to(align.abi);
+
+    if size.bytes() >= dl.obj_size_bound() {
+        return Err(LayoutError::SizeOverflow);
+    }
+
+    // Check to see if we should use a different type for the
+    // discriminant. We can safely use a type with the same size
+    // as the alignment of the first field of each variant.
+    // We increase the size of the discriminant to avoid LLVM copying
+    // padding when it doesn't need to. This normally causes unaligned
+    // load/stores and excessive memcpy/memset operations. By using a
+    // bigger integer size, LLVM can be sure about its contents and
+    // won't be so conservative.
+
+    // Use the initial field alignment
+    let mut ity = if repr.c() || repr.int.is_some() {
+        min_ity
+    } else {
+        Integer::for_align(dl, start_align).unwrap_or(min_ity)
+    };
+
+    // If the alignment is not larger than the chosen discriminant size,
+    // don't use the alignment as the final size.
+    if ity <= min_ity {
+        ity = min_ity;
+    } else {
+        // Patch up the variants' first few fields.
+        // Patch up the variants' first few fields.
+        let old_ity_size = min_ity.size();
+        let new_ity_size = ity.size();
+        for (_, variant) in layout_variants.iter_mut() {
+            match variant.fields {
+                FieldsShape::Arbitrary { ref mut offsets, .. } => {
+                    for i in offsets {
+                        if *i <= old_ity_size {
+                            assert_eq!(*i, old_ity_size);
+                            *i = new_ity_size;
+                        }
+                    }
+                    // We might be making the struct larger.
+                    if variant.size <= old_ity_size {
+                        variant.size = new_ity_size;
+                    }
+                }
+                _ => user_error!("bug"),
+            }
+        }
+    }
+
+    let tag_mask = ity.size().unsigned_int_max();
+    let tag = Scalar::Initialized {
+        value: Primitive::Int(ity, signed),
+        valid_range: WrappingRange {
+            start: (min as u128 & tag_mask),
+            end: (max as u128 & tag_mask),
+        },
+    };
+    let mut abi = Abi::Aggregate { sized: true };
+
+    if layout_variants.iter().all(|(_, v)| v.abi.is_uninhabited()) {
+        abi = Abi::Uninhabited;
+    } else if tag.size(dl) == size {
+        // Make sure we only use scalar layout when the enum is entirely its
+        // own tag (i.e. it has no padding nor any non-ZST variant fields).
+        abi = Abi::Scalar(tag);
+    } else {
+        // Try to use a ScalarPair for all tagged enums.
+        let mut common_prim = None;
+        let mut common_prim_initialized_in_all_variants = true;
+        for ((_, field_layouts), (_, layout_variant)) in
+            iter::zip(variants.iter(), layout_variants.iter())
+        {
+            let offsets = match layout_variant.fields {
+                FieldsShape::Arbitrary { ref offsets, .. } => offsets,
+                _ => user_error!("bug"),
+            };
+            let mut fields = iter::zip(field_layouts, offsets).filter(|p| !p.0.is_zst());
+            let (field, offset) = match (fields.next(), fields.next()) {
+                (None, None) => {
+                    common_prim_initialized_in_all_variants = false;
+                    continue;
+                }
+                (Some(pair), None) => pair,
+                _ => {
+                    common_prim = None;
+                    break;
+                }
+            };
+            let prim = match field.abi {
+                Abi::Scalar(scalar) => {
+                    common_prim_initialized_in_all_variants &=
+                        matches!(scalar, Scalar::Initialized { .. });
+                    scalar.primitive()
+                }
+                _ => {
+                    common_prim = None;
+                    break;
+                }
+            };
+            if let Some(pair) = common_prim {
+                // This is pretty conservative. We could go fancier
+                // by conflating things like i32 and u32, or even
+                // realising that (u8, u8) could just cohabit with
+                // u16 or even u32.
+                if pair != (prim, offset) {
+                    common_prim = None;
+                    break;
+                }
+            } else {
+                common_prim = Some((prim, offset));
+            }
+        }
+        if let Some((prim, offset)) = common_prim {
+            let prim_scalar = if common_prim_initialized_in_all_variants {
+                scalar_unit(dl, prim)
+            } else {
+                // Common prim might be uninit.
+                Scalar::Union { value: prim }
+            };
+            let pair = scalar_pair(dl, tag, prim_scalar);
+            let pair_offsets = match pair.fields {
+                FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
+                    assert_eq!(memory_index, &[0, 1]);
+                    offsets
+                }
+                _ => user_error!("bug"),
+            };
+            if pair_offsets[0] == Size::ZERO
+                && pair_offsets[1] == *offset
+                && align == pair.align
+                && size == pair.size
+            {
+                // We can use `ScalarPair` only when it matches our
+                // already computed layout (including `#[repr(C)]`).
+                abi = pair.abi;
+            }
+        }
+    }
+
+    // If we pick a "clever" (by-value) ABI, we might have to adjust the ABI of the
+    // variants to ensure they are consistent. This is because a downcast is
+    // semantically a NOP, and thus should not affect layout.
+    if matches!(abi, Abi::Scalar(..) | Abi::ScalarPair(..)) {
+        for (_, variant) in layout_variants.iter_mut() {
+            // We only do this for variants with fields; the others are not accessed anyway.
+            // Also do not overwrite any already existing "clever" ABIs.
+            if variant.fields.count() > 0 && matches!(variant.abi, Abi::Aggregate { .. }) {
+                variant.abi = abi;
+                // Also need to bump up the size and alignment, so that the entire value fits in here.
+                variant.size = cmp::max(variant.size, size);
+                variant.align.abi = cmp::max(variant.align.abi, align.abi);
+            }
+        }
+    }
+
+    let largest_niche = Niche::from_scalar(dl, Size::ZERO, tag);
+
+    let tagged_layout = Layout {
+        variants: Variants::Multiple {
+            tag,
+            tag_encoding: TagEncoding::Direct,
+            tag_field: 0,
+            variants: ArenaMap::new(),
+        },
+        fields: FieldsShape::Arbitrary { offsets: vec![Size::ZERO], memory_index: vec![0] },
+        largest_niche,
+        abi,
+        align,
+        size,
+    };
+
+    let tagged_layout = TmpLayout { layout: tagged_layout, variants: layout_variants };
+
+    let mut best_layout = match (tagged_layout, niche_filling_layout) {
+        (tl, Some(nl)) => {
+            // Pick the smaller layout; otherwise,
+            // pick the layout with the larger niche; otherwise,
+            // pick tagged as it has simpler codegen.
+            use Ordering::*;
+            let niche_size =
+                |tmp_l: &TmpLayout| tmp_l.layout.largest_niche.map_or(0, |n| n.available(dl));
+            match (tl.layout.size.cmp(&nl.layout.size), niche_size(&tl).cmp(&niche_size(&nl))) {
+                (Greater, _) => nl,
+                (Equal, Less) => nl,
+                _ => tl,
+            }
+        }
+        (tl, None) => tl,
+    };
+
+    // Now we can intern the variant layouts and store them in the enum layout.
+    best_layout.layout.variants = match best_layout.layout.variants {
+        Variants::Multiple { tag, tag_encoding, tag_field, .. } => {
+            Variants::Multiple { tag, tag_encoding, tag_field, variants: best_layout.variants }
+        }
+        _ => user_error!("bug"),
+    };
+
+    Ok(best_layout.layout)
+}
+
+pub fn layout_of_adt_recover(
+    _: &dyn HirDatabase,
+    _: &[String],
+    _: &AdtId,
+    _: &Substitution,
+) -> Result<Layout, LayoutError> {
+    user_error!("infinite sized recursive type");
+}
+
+pub(crate) fn univariant(
+    dl: &TargetDataLayout,
+    fields: &[Layout],
+    repr: &ReprOptions,
+    kind: StructKind,
+) -> Result<Layout, LayoutError> {
+    let pack = repr.pack;
+    if pack.is_some() && repr.align.is_some() {
+        user_error!("Struct can not be packed and aligned");
+    }
+
+    let mut align = if pack.is_some() { dl.i8_align } else { dl.aggregate_align };
+
+    let mut inverse_memory_index: Vec<u32> = (0..fields.len() as u32).collect();
+
+    let optimize = !repr.inhibit_struct_field_reordering_opt();
+    if optimize {
+        let end = if let StructKind::MaybeUnsized = kind { fields.len() - 1 } else { fields.len() };
+        let optimizing = &mut inverse_memory_index[..end];
+        let field_align = |f: &Layout| {
+            if let Some(pack) = pack {
+                f.align.abi.min(pack)
+            } else {
+                f.align.abi
+            }
+        };
+
+        match kind {
+            StructKind::AlwaysSized | StructKind::MaybeUnsized => {
+                optimizing.sort_by_key(|&x| {
+                    // Place ZSTs first to avoid "interesting offsets",
+                    // especially with only one or two non-ZST fields.
+                    let f = &fields[x as usize];
+                    (!f.is_zst(), cmp::Reverse(field_align(f)))
+                });
+            }
+
+            StructKind::Prefixed(..) => {
+                // Sort in ascending alignment so that the layout stays optimal
+                // regardless of the prefix
+                optimizing.sort_by_key(|&x| field_align(&fields[x as usize]));
+            }
+        }
+    }
+
+    // inverse_memory_index holds field indices by increasing memory offset.
+    // That is, if field 5 has offset 0, the first element of inverse_memory_index is 5.
+    // We now write field offsets to the corresponding offset slot;
+    // field 5 with offset 0 puts 0 in offsets[5].
+    // At the bottom of this function, we invert `inverse_memory_index` to
+    // produce `memory_index` (see `invert_mapping`).
+
+    let mut sized = true;
+    let mut offsets = vec![Size::ZERO; fields.len()];
+    let mut offset = Size::ZERO;
+    let mut largest_niche = None;
+    let mut largest_niche_available = 0;
+
+    if let StructKind::Prefixed(prefix_size, prefix_align) = kind {
+        let prefix_align =
+            if let Some(pack) = pack { prefix_align.min(pack) } else { prefix_align };
+        align = align.max(AbiAndPrefAlign::new(prefix_align));
+        offset = prefix_size.align_to(prefix_align);
+    }
+
+    for &i in &inverse_memory_index {
+        let field = &fields[i as usize];
+        if !sized {
+            user_error!("Unsized field is not last field");
+        }
+
+        if field.is_unsized() {
+            sized = false;
+        }
+
+        // Invariant: offset < dl.obj_size_bound() <= 1<<61
+        let field_align = if let Some(pack) = pack {
+            field.align.min(AbiAndPrefAlign::new(pack))
+        } else {
+            field.align
+        };
+        offset = offset.align_to(field_align.abi);
+        align = align.max(field_align);
+
+        offsets[i as usize] = offset;
+
+        if let Some(mut niche) = field.largest_niche {
+            let available = niche.available(dl);
+            if available > largest_niche_available {
+                largest_niche_available = available;
+                niche.offset =
+                    niche.offset.checked_add(offset, dl).ok_or(LayoutError::SizeOverflow)?;
+                largest_niche = Some(niche);
+            }
+        }
+
+        offset = offset.checked_add(field.size, dl).ok_or(LayoutError::SizeOverflow)?;
+    }
+
+    if let Some(repr_align) = repr.align {
+        align = align.max(AbiAndPrefAlign::new(repr_align));
+    }
+
+    let min_size = offset;
+
+    // As stated above, inverse_memory_index holds field indices by increasing offset.
+    // This makes it an already-sorted view of the offsets vec.
+    // To invert it, consider:
+    // If field 5 has offset 0, offsets[0] is 5, and memory_index[5] should be 0.
+    // Field 5 would be the first element, so memory_index is i:
+    // Note: if we didn't optimize, it's already right.
+
+    let memory_index =
+        if optimize { invert_mapping(&inverse_memory_index) } else { inverse_memory_index };
+
+    let size = min_size.align_to(align.abi);
+    let mut abi = Abi::Aggregate { sized };
+
+    // Unpack newtype ABIs and find scalar pairs.
+    if sized && size.bytes() > 0 {
+        // All other fields must be ZSTs.
+        let mut non_zst_fields = fields.iter().enumerate().filter(|&(_, f)| !f.is_zst());
+
+        match (non_zst_fields.next(), non_zst_fields.next(), non_zst_fields.next()) {
+            // We have exactly one non-ZST field.
+            (Some((i, field)), None, None) => {
+                // Field fills the struct and it has a scalar or scalar pair ABI.
+                if offsets[i].bytes() == 0 && align.abi == field.align.abi && size == field.size {
+                    match field.abi {
+                        // For plain scalars, or vectors of them, we can't unpack
+                        // newtypes for `#[repr(C)]`, as that affects C ABIs.
+                        Abi::Scalar(_) | Abi::Vector { .. } if optimize => {
+                            abi = field.abi;
+                        }
+                        // But scalar pairs are Rust-specific and get
+                        // treated as aggregates by C ABIs anyway.
+                        Abi::ScalarPair(..) => {
+                            abi = field.abi;
+                        }
+                        _ => {}
+                    }
+                }
+            }
+
+            // Two non-ZST fields, and they're both scalars.
+            (Some((i, a)), Some((j, b)), None) => {
+                match (a.abi, b.abi) {
+                    (Abi::Scalar(a), Abi::Scalar(b)) => {
+                        // Order by the memory placement, not source order.
+                        let ((i, a), (j, b)) = if offsets[i] < offsets[j] {
+                            ((i, a), (j, b))
+                        } else {
+                            ((j, b), (i, a))
+                        };
+                        let pair = scalar_pair(dl, a, b);
+                        let pair_offsets = match pair.fields {
+                            FieldsShape::Arbitrary { ref offsets, .. } => offsets,
+                            _ => unreachable!(),
+                        };
+                        if offsets[i] == pair_offsets[0]
+                            && offsets[j] == pair_offsets[1]
+                            && align == pair.align
+                            && size == pair.size
+                        {
+                            // We can use `ScalarPair` only when it matches our
+                            // already computed layout (including `#[repr(C)]`).
+                            abi = pair.abi;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            _ => {}
+        }
+    }
+
+    if fields.iter().any(|f| f.abi.is_uninhabited()) {
+        abi = Abi::Uninhabited;
+    }
+
+    Ok(Layout {
+        variants: Variants::Single,
+        fields: FieldsShape::Arbitrary { offsets, memory_index },
+        abi,
+        largest_niche,
+        align,
+        size,
+    })
+}
+
+fn layout_of_union(
+    db: &dyn HirDatabase,
+    id: UnionId,
+    subst: &Substitution,
+) -> Result<Layout, LayoutError> {
+    let dl = &*db.current_target_data_layout();
+
+    let union_data = db.union_data(id);
+
+    let repr = union_data.repr.unwrap_or_default();
+    let fields = union_data.variant_data.fields();
+
+    if repr.pack.is_some() && repr.align.is_some() {
+        user_error!("union cannot be packed and aligned");
+    }
+
+    let mut align = if repr.pack.is_some() { dl.i8_align } else { dl.aggregate_align };
+    if let Some(repr_align) = repr.align {
+        align = align.max(AbiAndPrefAlign::new(repr_align));
+    }
+
+    let optimize = !repr.inhibit_union_abi_opt();
+    let mut size = Size::ZERO;
+    let mut abi = Abi::Aggregate { sized: true };
+    for (fd, _) in fields.iter() {
+        let field_ty = field_ty(db, id.into(), fd, subst);
+        let field = layout_of_ty(db, &field_ty)?;
+        if field.is_unsized() {
+            user_error!("unsized union field");
+        }
+        // If all non-ZST fields have the same ABI, forward this ABI
+        if optimize && !field.is_zst() {
+            // Discard valid range information and allow undef
+            let field_abi = match field.abi {
+                Abi::Scalar(x) => Abi::Scalar(x.to_union()),
+                Abi::ScalarPair(x, y) => Abi::ScalarPair(x.to_union(), y.to_union()),
+                Abi::Vector { element: x, count } => Abi::Vector { element: x.to_union(), count },
+                Abi::Uninhabited | Abi::Aggregate { .. } => Abi::Aggregate { sized: true },
+            };
+
+            if size == Size::ZERO {
+                // first non ZST: initialize 'abi'
+                abi = field_abi;
+            } else if abi != field_abi {
+                // different fields have different ABI: reset to Aggregate
+                abi = Abi::Aggregate { sized: true };
+            }
+        }
+
+        size = cmp::max(size, field.size);
+    }
+
+    if let Some(pack) = repr.pack {
+        align = align.min(AbiAndPrefAlign::new(pack));
+    }
+
+    Ok(Layout {
+        variants: Variants::Single,
+        fields: FieldsShape::Union(
+            NonZeroUsize::new(fields.len())
+                .ok_or(LayoutError::UserError("union with zero fields".to_string()))?,
+        ),
+        abi,
+        largest_niche: None,
+        align,
+        size: size.align_to(align.abi),
+    })
+}
+
+// Invert a bijective mapping, i.e. `invert(map)[y] = x` if `map[x] = y`.
+// This is used to go between `memory_index` (source field order to memory order)
+// and `inverse_memory_index` (memory order to source field order).
+// See also `FieldsShape::Arbitrary::memory_index` for more details.
+// FIXME(eddyb) build a better abstraction for permutations, if possible.
+fn invert_mapping(map: &[u32]) -> Vec<u32> {
+    let mut inverse = vec![0; map.len()];
+    for i in 0..map.len() {
+        inverse[map[i] as usize] = i as u32;
+    }
+    inverse
+}
+
+fn scalar_pair(dl: &TargetDataLayout, a: Scalar, b: Scalar) -> Layout {
+    let b_align = b.align(dl);
+    let align = a.align(dl).max(b_align).max(dl.aggregate_align);
+    let b_offset = a.size(dl).align_to(b_align.abi);
+    let size = b_offset.checked_add(b.size(dl), dl).unwrap().align_to(align.abi);
+
+    // HACK(nox): We iter on `b` and then `a` because `max_by_key`
+    // returns the last maximum.
+    let largest_niche = Niche::from_scalar(dl, b_offset, b)
+        .into_iter()
+        .chain(Niche::from_scalar(dl, Size::ZERO, a))
+        .max_by_key(|niche| niche.available(dl));
+
+    Layout {
+        variants: Variants::Single,
+        fields: FieldsShape::Arbitrary {
+            offsets: vec![Size::ZERO, b_offset],
+            memory_index: vec![0, 1],
+        },
+        abi: Abi::ScalarPair(a, b),
+        largest_niche,
+        align,
+        size,
+    }
+}

crates/hir-ty/src/layout/target.rs

@@ -0,0 +1,44 @@
+//! Target dependent parameters needed for layouts
+
+use std::sync::Arc;
+
+use hir_def::layout::TargetDataLayout;
+
+use crate::db::HirDatabase;
+
+use super::{AbiAndPrefAlign, AddressSpace, Align, Endian, Integer, Size};
+
+pub fn current_target_data_layout_query(db: &dyn HirDatabase) -> Arc<TargetDataLayout> {
+    let crate_graph = db.crate_graph();
+    let cfg_options = &crate_graph[crate_graph.iter().next().unwrap()].cfg_options;
+    let endian = match cfg_options.get_cfg_values("target_endian").next() {
+        Some(x) if x.as_str() == "big" => Endian::Big,
+        _ => Endian::Little,
+    };
+    let pointer_size =
+        Size::from_bytes(match cfg_options.get_cfg_values("target_pointer_width").next() {
+            Some(x) => match x.as_str() {
+                "16" => 2,
+                "32" => 4,
+                _ => 8,
+            },
+            _ => 8,
+        });
+    Arc::new(TargetDataLayout {
+        endian,
+        i1_align: AbiAndPrefAlign::new(Align::from_bytes(1).unwrap()),
+        i8_align: AbiAndPrefAlign::new(Align::from_bytes(1).unwrap()),
+        i16_align: AbiAndPrefAlign::new(Align::from_bytes(2).unwrap()),
+        i32_align: AbiAndPrefAlign::new(Align::from_bytes(4).unwrap()),
+        i64_align: AbiAndPrefAlign::new(Align::from_bytes(8).unwrap()),
+        i128_align: AbiAndPrefAlign::new(Align::from_bytes(8).unwrap()),
+        f32_align: AbiAndPrefAlign::new(Align::from_bytes(4).unwrap()),
+        f64_align: AbiAndPrefAlign::new(Align::from_bytes(8).unwrap()),
+        pointer_size,
+        pointer_align: AbiAndPrefAlign::new(Align::from_bytes(8).unwrap()),
+        aggregate_align: AbiAndPrefAlign::new(Align::from_bytes(1).unwrap()),
+        vector_align: vec![],
+        instruction_address_space: AddressSpace(0),
+        c_enum_min_size: Integer::I32,
+    })
+}

crates/hir-ty/src/layout/tests.rs

@@ -0,0 +1,167 @@
+use base_db::fixture::WithFixture;
+use chalk_ir::{AdtId, TyKind};
+use hir_def::{
+    db::DefDatabase,
+    layout::{Layout, LayoutError},
+};
+
+use crate::{test_db::TestDB, Interner, Substitution};
+
+use super::layout_of_ty;
+
+fn eval_goal(ra_fixture: &str) -> Result<Layout, LayoutError> {
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    let module_id = db.module_for_file(file_id);
+    let def_map = module_id.def_map(&db);
+    let scope = &def_map[module_id.local_id].scope;
+    let adt_id = scope
+        .declarations()
+        .into_iter()
+        .find_map(|x| match x {
+            hir_def::ModuleDefId::AdtId(x) => {
+                let name = match x {
+                    hir_def::AdtId::StructId(x) => db.struct_data(x).name.to_string(),
+                    hir_def::AdtId::UnionId(x) => db.union_data(x).name.to_string(),
+                    hir_def::AdtId::EnumId(x) => db.enum_data(x).name.to_string(),
+                };
+                if name == "Goal" {
+                    Some(x)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        })
+        .unwrap();
+    let goal_ty = TyKind::Adt(AdtId(adt_id), Substitution::empty(Interner)).intern(Interner);
+    layout_of_ty(&db, &goal_ty)
+}
+
+fn check_size_and_align(ra_fixture: &str, size: u64, align: u64) {
+    let l = eval_goal(ra_fixture).unwrap();
+    assert_eq!(l.size.bytes(), size);
+    assert_eq!(l.align.abi.bytes(), align);
+}
+
+fn check_fail(ra_fixture: &str, e: LayoutError) {
+    let r = eval_goal(ra_fixture);
+    assert_eq!(r, Err(e));
+}
+
+macro_rules! size_and_align {
+    ($($t:tt)*) => {
+        {
+            #[allow(dead_code)]
+            $($t)*
+            check_size_and_align(
+                stringify!($($t)*),
+                ::std::mem::size_of::<Goal>() as u64,
+                ::std::mem::align_of::<Goal>() as u64,
+            );
+        }
+    };
+}
+
+#[test]
+fn hello_world() {
+    size_and_align! {
+        struct Goal(i32);
+    }
+    //check_size_and_align(r#"struct Goal(i32)"#, 4, 4);
+}
+
+#[test]
+fn field_order_optimization() {
+    size_and_align! {
+        struct Goal(u8, i32, u8);
+    }
+    size_and_align! {
+        #[repr(C)]
+        struct Goal(u8, i32, u8);
+    }
+}
+
+#[test]
+fn recursive() {
+    size_and_align! {
+        struct Goal {
+            left: &'static Goal,
+            right: &'static Goal,
+        }
+    }
+    size_and_align! {
+        struct BoxLike<T: ?Sized>(*mut T);
+        struct Goal(BoxLike<Goal>);
+    }
+    check_fail(
+        r#"struct Goal(Goal);"#,
+        LayoutError::UserError("infinite sized recursive type".to_string()),
+    );
+    check_fail(
+        r#"
+        struct Foo<T>(Foo<T>);
+        struct Goal(Foo<i32>);
+        "#,
+        LayoutError::UserError("infinite sized recursive type".to_string()),
+    );
+}
+
+#[test]
+fn generic() {
+    size_and_align! {
+        struct Pair<A, B>(A, B);
+        struct Goal(Pair<Pair<i32, u8>, i64>);
+    }
+    size_and_align! {
+        struct X<const N: usize> {
+            field1: [i32; N],
+            field2: [u8; N],
+        }
+        struct Goal(X<1000>);
+    }
+}
+
+#[test]
+fn enums() {
+    size_and_align! {
+        enum Goal {
+            Quit,
+            Move { x: i32, y: i32 },
+            ChangeColor(i32, i32, i32),
+        }
+    }
+}
+
+#[test]
+fn primitives() {
+    size_and_align! {
+        struct Goal(i32, i128, isize, usize, f32, f64, bool, char);
+    }
+}
+
+#[test]
+fn tuple() {
+    size_and_align! {
+        struct Goal((), (i32, u64, bool));
+    }
+}
+
+#[test]
+fn niche_optimization() {
+    check_size_and_align(
+        r#"
+    //- minicore: option
+    struct Goal(Option<&i32>);
+    "#,
+        8,
+        8,
+    );
+    check_size_and_align(
+        r#"
+    //- minicore: option
+    struct Goal(Option<Option<bool>>);
+    "#,
+        1,
+        1,
+    );
+}

crates/hir-ty/src/lib.rs

@@ -27,6 +27,8 @@ pub mod display;
 pub mod method_resolution;
 pub mod primitive;
 pub mod traits;
+pub mod layout;
+pub mod lang_items;
 
 #[cfg(test)]
 mod tests;

crates/hir/src/lib.rs

@@ -39,12 +39,13 @@ use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, CrateOrigin, Edition, FileId, ProcMacroKind};
 use either::Either;
 use hir_def::{
-    adt::{ReprData, VariantData},
+    adt::VariantData,
     body::{BodyDiagnostic, SyntheticSyntax},
     expr::{BindingAnnotation, LabelId, Pat, PatId},
     generics::{TypeOrConstParamData, TypeParamProvenance},
     item_tree::ItemTreeNode,
     lang_item::LangItemTarget,
+    layout::{Layout, LayoutError, ReprOptions},
     nameres::{self, diagnostics::DefDiagnostic},
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
@@ -59,6 +60,7 @@ use hir_ty::{
     all_super_traits, autoderef,
     consteval::{unknown_const_as_generic, ComputedExpr, ConstEvalError, ConstExt},
     diagnostics::BodyValidationDiagnostic,
+    layout::layout_of_ty,
     method_resolution::{self, TyFingerprint},
     primitive::UintTy,
     traits::FnTrait,
@@ -844,6 +846,10 @@ impl Field {
         self.parent.variant_data(db).fields()[self.id].name.clone()
     }
 
+    pub fn index(&self) -> usize {
+        u32::from(self.id.into_raw()) as usize
+    }
+
     /// Returns the type as in the signature of the struct (i.e., with
     /// placeholder types for type parameters). Only use this in the context of
     /// the field definition.
@@ -859,6 +865,10 @@ impl Field {
         Type::new(db, var_id, ty)
     }
 
+    pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
+        layout_of_ty(db, &self.ty(db).ty)
+    }
+
     pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
         self.parent
     }
@@ -900,7 +910,7 @@ impl Struct {
         Type::from_def(db, self.id)
     }
 
-    pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprData> {
+    pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprOptions> {
         db.struct_data(self.id).repr.clone()
     }
 
@@ -1076,6 +1086,13 @@ impl Adt {
         })
     }
 
+    pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
+        if db.generic_params(self.into()).iter().count() != 0 {
+            return Err(LayoutError::HasPlaceholder);
+        }
+        db.layout_of_adt(self.into(), Substitution::empty(Interner))
+    }
+
     /// Turns this ADT into a type. Any type parameters of the ADT will be
     /// turned into unknown types, which is good for e.g. finding the most
     /// general set of completions, but will not look very nice when printed.
@@ -3031,7 +3048,7 @@ impl Type {
 
         let adt = adt_id.into();
         match adt {
-            Adt::Struct(s) => matches!(s.repr(db), Some(ReprData { packed: true, .. })),
+            Adt::Struct(s) => s.repr(db).unwrap_or_default().pack.is_some(),
             _ => false,
         }
     }

crates/ide/src/hover/render.rs

@@ -2,7 +2,10 @@
 use std::fmt::Display;
 
 use either::Either;
-use hir::{AsAssocItem, AttributeTemplate, HasAttrs, HasSource, HirDisplay, Semantics, TypeInfo};
+use hir::{
+    db::HirDatabase, Adt, AsAssocItem, AttributeTemplate, HasAttrs, HasSource, HirDisplay,
+    Semantics, TypeInfo,
+};
 use ide_db::{
     base_db::SourceDatabase,
     defs::Definition,
@@ -388,10 +391,30 @@ pub(super) fn definition(
     let mod_path = definition_mod_path(db, &def);
     let (label, docs) = match def {
         Definition::Macro(it) => label_and_docs(db, it),
-        Definition::Field(it) => label_and_docs(db, it),
+        Definition::Field(it) => label_and_layout_info_and_docs(db, it, |&it| {
+            let var_def = it.parent_def(db);
+            let id = it.index();
+            let layout = it.layout(db).ok()?;
+            let offset = match var_def {
+                hir::VariantDef::Struct(s) => {
+                    let layout = Adt::from(s).layout(db).ok()?;
+                    layout.fields.offset(id, &db.current_target_data_layout())
+                }
+                _ => return None,
+            };
+            Some(format!(
+                "size = {}, align = {}, offset = {}",
+                layout.size.bytes(),
+                layout.align.abi.bytes(),
+                offset.bytes()
+            ))
+        }),
         Definition::Module(it) => label_and_docs(db, it),
         Definition::Function(it) => label_and_docs(db, it),
-        Definition::Adt(it) => label_and_docs(db, it),
+        Definition::Adt(it) => label_and_layout_info_and_docs(db, it, |&it| {
+            let layout = it.layout(db).ok()?;
+            Some(format!("size = {}, align = {}", layout.size.bytes(), layout.align.abi.bytes()))
+        }),
         Definition::Variant(it) => label_value_and_docs(db, it, |&it| {
             if !it.parent_enum(db).is_data_carrying(db) {
                 match it.eval(db) {
@@ -489,6 +512,25 @@ where
     (label, docs)
 }
 
+fn label_and_layout_info_and_docs<D, E, V>(
+    db: &RootDatabase,
+    def: D,
+    value_extractor: E,
+) -> (String, Option<hir::Documentation>)
+where
+    D: HasAttrs + HirDisplay,
+    E: Fn(&D) -> Option<V>,
+    V: Display,
+{
+    let label = if let Some(value) = value_extractor(&def) {
+        format!("{} // {}", def.display(db), value)
+    } else {
+        def.display(db).to_string()
+    };
+    let docs = def.attrs(db).docs();
+    (label, docs)
+}
+
 fn label_value_and_docs<D, E, V>(
     db: &RootDatabase,
     def: D,

crates/ide/src/hover/tests.rs

@@ -522,6 +522,27 @@ fn main() { }
     );
 }
 
+#[test]
+fn hover_field_offset() {
+    // Hovering over the field when instantiating
+    check(
+        r#"
+struct Foo { fiel$0d_a: u8, field_b: i32, field_c: i16 }
+"#,
+        expect![[r#"
+            *field_a*
+
+            ```rust
+            test::Foo
+            ```
+
+            ```rust
+            field_a: u8 // size = 1, align = 1, offset = 6
+            ```
+        "#]],
+    );
+}
+
 #[test]
 fn hover_shows_struct_field_info() {
     // Hovering over the field when instantiating
@@ -541,7 +562,7 @@ fn main() {
             ```
 
             ```rust
-                field_a: u32
+            field_a: u32 // size = 4, align = 4, offset = 0
             ```
         "#]],
     );
@@ -563,7 +584,7 @@ fn main() {
             ```
 
             ```rust
-                field_a: u32
+            field_a: u32 // size = 4, align = 4, offset = 0
             ```
         "#]],
     );
@@ -1508,7 +1529,7 @@ struct Bar;
 
 fn foo() { let bar = Ba$0r; }
 "#,
-        expect![[r##"
+        expect![[r#"
             *Bar*
 
             ```rust
@@ -1516,7 +1537,7 @@ fn foo() { let bar = Ba$0r; }
             ```
 
             ```rust
-                struct Bar
+            struct Bar // size = 0, align = 1
             ```
 
             ---
@@ -1531,7 +1552,7 @@ fn foo() { let bar = Ba$0r; }
 
             assert_eq!(6, my_crate::add_one(5));
             ```
-            "##]],
+        "#]],
     );
 }
 
@@ -1552,7 +1573,7 @@ fn foo() { let bar = Ba$0r; }
             ```
 
             ```rust
-                struct Bar
+            struct Bar // size = 0, align = 1
             ```
 
             ---
@@ -1581,7 +1602,7 @@ fn foo() { let bar = Ba$0r; }
             ```
 
             ```rust
-                struct Bar
+            struct Bar // size = 0, align = 1
             ```
 
             ---
@@ -1609,7 +1630,7 @@ pub struct B$0ar
             ```
 
             ```rust
-                pub struct Bar
+            pub struct Bar // size = 0, align = 1
             ```
 
             ---
@@ -1636,7 +1657,7 @@ pub struct B$0ar
             ```
 
             ```rust
-                pub struct Bar
+            pub struct Bar // size = 0, align = 1
             ```
 
             ---
@@ -2960,7 +2981,7 @@ fn main() {
             ```
 
             ```rust
-            f: i32
+            f: i32 // size = 4, align = 4, offset = 0
             ```
         "#]],
     );
@@ -4210,7 +4231,7 @@ pub fn gimme() -> theitem::TheItem {
             ```
 
             ```rust
-                pub struct TheItem
+            pub struct TheItem // size = 0, align = 1
             ```
 
             ---
@@ -4358,7 +4379,7 @@ mod string {
             ```
 
             ```rust
-                struct String
+            struct String // size = 0, align = 1
             ```
 
             ---
@@ -5025,7 +5046,7 @@ foo_macro!(
             ```
 
             ```rust
-            pub struct Foo
+            pub struct Foo // size = 0, align = 1
             ```
 
             ---
@@ -5040,7 +5061,7 @@ fn hover_intra_in_attr() {
     check(
         r#"
 #[doc = "Doc comment for [`Foo$0`]"]
-pub struct Foo;
+pub struct Foo(i32);
 "#,
         expect![[r#"
             *[`Foo`]*
@@ -5050,7 +5071,7 @@ pub struct Foo;
             ```
 
             ```rust
-            pub struct Foo
+            pub struct Foo // size = 4, align = 4
             ```
 
             ---

lib/la-arena/src/map.rs

@@ -86,6 +86,14 @@ impl<T, V> ArenaMap<Idx<T>, V> {
         self.v.iter().enumerate().filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_ref()?)))
     }
 
+    /// Returns an iterator over the arena indexes and values in the map.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (Idx<T>, &mut V)> {
+        self.v
+            .iter_mut()
+            .enumerate()
+            .filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_mut()?)))
+    }
+
     /// Gets the given key's corresponding entry in the map for in-place manipulation.
     pub fn entry(&mut self, idx: Idx<T>) -> Entry<'_, Idx<T>, V> {
         let idx = Self::to_idx(idx);