mirror of
https://github.com/rust-lang/rust-analyzer
synced 2024-09-21 15:02:03 +00:00
Compute data layout of types
This commit is contained in:
hkalbasi
parent
957b4bb216
commit
86b5b609f1
16 changed files with 2822 additions and 157 deletions
|
|
@ -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;
|
||||
if let Some(TokenTree::Subtree(_)) = tts.peek() {
|
||||
let pack = if let Some(TokenTree::Subtree(tt)) = 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" => {
|
||||
if let ReprKind::BuiltinInt { is_c, .. } = &mut data.kind {
|
||||
*is_c = true;
|
||||
} else {
|
||||
data.kind = ReprKind::C;
|
||||
}
|
||||
}
|
||||
"transparent" => data.kind = ReprKind::Transparent,
|
||||
"C" => ReprFlags::IS_C,
|
||||
"transparent" => ReprFlags::IS_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),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
1173
crates/hir-def/src/layout.rs
Normal file
1173
crates/hir-def/src/layout.rs
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -419,6 +419,7 @@ pub mod known {
|
|||
shr,
|
||||
sub_assign,
|
||||
sub,
|
||||
unsafe_cell,
|
||||
va_list
|
||||
);
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId,
|
||||
db::DefDatabase,
|
||||
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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
VariantId,
|
||||
adt::VariantData, body::Body, expr::PatId, AdtId, EnumVariantId, LocalFieldId, 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)
|
||||
|
|
|
|||
20
crates/hir-ty/src/lang_items.rs
Normal file
20
crates/hir-ty/src/lang_items.rs
Normal file
|
|
@ -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
|
||||
}
|
||||
271
crates/hir-ty/src/layout.rs
Normal file
271
crates/hir-ty/src/layout.rs
Normal file
|
|
@ -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;
|
||||
900
crates/hir-ty/src/layout/adt.rs
Normal file
900
crates/hir-ty/src/layout/adt.rs
Normal file
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
44
crates/hir-ty/src/layout/target.rs
Normal file
44
crates/hir-ty/src/layout/target.rs
Normal file
|
|
@ -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,
|
||||
})
|
||||
}
|
||||
167
crates/hir-ty/src/layout/tests.rs
Normal file
167
crates/hir-ty/src/layout/tests.rs
Normal file
|
|
@ -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,
|
||||
);
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -534,16 +555,16 @@ fn main() {
|
|||
}
|
||||
"#,
|
||||
expect![[r#"
|
||||
*field_a*
|
||||
*field_a*
|
||||
|
||||
```rust
|
||||
test::Foo
|
||||
```
|
||||
```rust
|
||||
test::Foo
|
||||
```
|
||||
|
||||
```rust
|
||||
field_a: u32
|
||||
```
|
||||
"#]],
|
||||
```rust
|
||||
field_a: u32 // size = 4, align = 4, offset = 0
|
||||
```
|
||||
"#]],
|
||||
);
|
||||
|
||||
// Hovering over the field in the definition
|
||||
|
|
@ -556,16 +577,16 @@ fn main() {
|
|||
}
|
||||
"#,
|
||||
expect![[r#"
|
||||
*field_a*
|
||||
*field_a*
|
||||
|
||||
```rust
|
||||
test::Foo
|
||||
```
|
||||
```rust
|
||||
test::Foo
|
||||
```
|
||||
|
||||
```rust
|
||||
field_a: u32
|
||||
```
|
||||
"#]],
|
||||
```rust
|
||||
field_a: u32 // size = 4, align = 4, offset = 0
|
||||
```
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1508,30 +1529,30 @@ struct Bar;
|
|||
|
||||
fn foo() { let bar = Ba$0r; }
|
||||
"#,
|
||||
expect![[r##"
|
||||
*Bar*
|
||||
expect![[r#"
|
||||
*Bar*
|
||||
|
||||
```rust
|
||||
test
|
||||
```
|
||||
```rust
|
||||
test
|
||||
```
|
||||
|
||||
```rust
|
||||
struct Bar
|
||||
```
|
||||
```rust
|
||||
struct Bar // size = 0, align = 1
|
||||
```
|
||||
|
||||
---
|
||||
---
|
||||
|
||||
This is an example
|
||||
multiline doc
|
||||
This is an example
|
||||
multiline doc
|
||||
|
||||
# Example
|
||||
# Example
|
||||
|
||||
```
|
||||
let five = 5;
|
||||
```
|
||||
let five = 5;
|
||||
|
||||
assert_eq!(6, my_crate::add_one(5));
|
||||
```
|
||||
"##]],
|
||||
assert_eq!(6, my_crate::add_one(5));
|
||||
```
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1545,20 +1566,20 @@ struct Bar;
|
|||
fn foo() { let bar = Ba$0r; }
|
||||
"#,
|
||||
expect![[r#"
|
||||
*Bar*
|
||||
*Bar*
|
||||
|
||||
```rust
|
||||
test
|
||||
```
|
||||
```rust
|
||||
test
|
||||
```
|
||||
|
||||
```rust
|
||||
struct Bar
|
||||
```
|
||||
```rust
|
||||
struct Bar // size = 0, align = 1
|
||||
```
|
||||
|
||||
---
|
||||
---
|
||||
|
||||
bar docs
|
||||
"#]],
|
||||
bar docs
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1574,22 +1595,22 @@ struct Bar;
|
|||
fn foo() { let bar = Ba$0r; }
|
||||
"#,
|
||||
expect![[r#"
|
||||
*Bar*
|
||||
*Bar*
|
||||
|
||||
```rust
|
||||
test
|
||||
```
|
||||
```rust
|
||||
test
|
||||
```
|
||||
|
||||
```rust
|
||||
struct Bar
|
||||
```
|
||||
```rust
|
||||
struct Bar // size = 0, align = 1
|
||||
```
|
||||
|
||||
---
|
||||
---
|
||||
|
||||
bar docs 0
|
||||
bar docs 1
|
||||
bar docs 2
|
||||
"#]],
|
||||
bar docs 0
|
||||
bar docs 1
|
||||
bar docs 2
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1602,20 +1623,20 @@ pub struct Foo;
|
|||
pub struct B$0ar
|
||||
"#,
|
||||
expect
|
||||
"#]],
|
||||
[external](https://www.google.com)
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1629,20 +1650,20 @@ pub struct Foo;
|
|||
pub struct B$0ar
|
||||
"#,
|
||||
expect
|
||||
"#]],
|
||||
[baz](Baz)
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -2960,7 +2981,7 @@ fn main() {
|
|||
```
|
||||
|
||||
```rust
|
||||
f: i32
|
||||
f: i32 // size = 4, align = 4, offset = 0
|
||||
```
|
||||
"#]],
|
||||
);
|
||||
|
|
@ -4203,20 +4224,20 @@ pub fn gimme() -> theitem::TheItem {
|
|||
}
|
||||
"#,
|
||||
expect![[r#"
|
||||
*[`TheItem`]*
|
||||
*[`TheItem`]*
|
||||
|
||||
```rust
|
||||
test::theitem
|
||||
```
|
||||
```rust
|
||||
test::theitem
|
||||
```
|
||||
|
||||
```rust
|
||||
pub struct TheItem
|
||||
```
|
||||
```rust
|
||||
pub struct TheItem // size = 0, align = 1
|
||||
```
|
||||
|
||||
---
|
||||
---
|
||||
|
||||
This is the item. Cool!
|
||||
"#]],
|
||||
This is the item. Cool!
|
||||
"#]],
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -4351,20 +4372,20 @@ mod string {
|
|||
}
|
||||
"#,
|
||||
expect![[r#"
|
||||
*String*
|
||||
*String*
|
||||
|
||||
```rust
|
||||
main
|
||||
```
|
||||
```rust
|
||||
main
|
||||
```
|
||||
|
||||
```rust
|
||||
struct String
|
||||
```
|
||||
```rust
|
||||
struct String // size = 0, align = 1
|
||||
```
|
||||
|
||||
---
|
||||
---
|
||||
|
||||
Custom `String` type.
|
||||
"#]],
|
||||
Custom `String` type.
|
||||
"#]],
|
||||
)
|
||||
}
|
||||
|
||||
|
|
@ -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
|
||||
```
|
||||
|
||||
---
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
Loading…
Reference in a new issue