-//! Defines hir-level representation of structs, enums and unions

-

-use base_db::Crate;

-use bitflags::bitflags;

-use cfg::CfgOptions;

-

-use hir_expand::name::Name;

-use intern::sym;

-use la_arena::Arena;

-use rustc_abi::{IntegerType, ReprOptions};

-use triomphe::Arc;

-

-use crate::{

- EnumId, EnumVariantId, LocalFieldId, LocalModuleId, Lookup, StructId, UnionId, VariantId,

- db::DefDatabase,

- hir::Expr,

- item_tree::{

- AttrOwner, Field, FieldParent, FieldsShape, ItemTree, ModItem, RawVisibilityId, TreeId,

- },

- lang_item::LangItem,

- nameres::diagnostics::{DefDiagnostic, DefDiagnostics},

- type_ref::{TypeRefId, TypesMap},

- visibility::RawVisibility,

-};

-

-/// Note that we use `StructData` for unions as well!

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub struct StructData {

- pub name: Name,

- pub repr: Option<ReprOptions>,

- pub visibility: RawVisibility,

- pub flags: StructFlags,

-}

-

-bitflags! {

- #[derive(Debug, Copy, Clone, PartialEq, Eq)]

- pub struct StructFlags: u8 {

- const NO_FLAGS = 0;

- /// Indicates whether the struct is `PhantomData`.

- const IS_PHANTOM_DATA = 1 << 2;

- /// Indicates whether the struct has a `#[fundamental]` attribute.

- const IS_FUNDAMENTAL = 1 << 3;

- // FIXME: should this be a flag?

- /// Indicates whether the struct has a `#[rustc_has_incoherent_inherent_impls]` attribute.

- const IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPL = 1 << 4;

- /// Indicates whether this struct is `Box`.

- const IS_BOX = 1 << 5;

- /// Indicates whether this struct is `ManuallyDrop`.

- const IS_MANUALLY_DROP = 1 << 6;

- /// Indicates whether this struct is `UnsafeCell`.

- const IS_UNSAFE_CELL = 1 << 7;

- }

-}

-

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub struct EnumData {

- pub name: Name,

- pub repr: Option<ReprOptions>,

- pub visibility: RawVisibility,

- pub rustc_has_incoherent_inherent_impls: bool,

-}

-

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub struct EnumVariants {

- pub variants: Box<[(EnumVariantId, Name)]>,

-}

-

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub struct EnumVariantData {

- pub name: Name,

-}

-

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub enum VariantData {

- Record { fields: Arena<FieldData>, types_map: Arc<TypesMap> },

- Tuple { fields: Arena<FieldData>, types_map: Arc<TypesMap> },

- Unit,

-}

-

-impl VariantData {

- #[inline]

- pub(crate) fn variant_data_query(db: &dyn DefDatabase, id: VariantId) -> Arc<VariantData> {

- db.variant_data_with_diagnostics(id).0

- }

-

- pub(crate) fn variant_data_with_diagnostics_query(

- db: &dyn DefDatabase,

- id: VariantId,

- ) -> (Arc<VariantData>, DefDiagnostics) {

- let (shape, types_map, (fields, diagnostics)) = match id {

- VariantId::EnumVariantId(id) => {

- let loc = id.lookup(db);

- let item_tree = loc.id.item_tree(db);

- let parent = loc.parent.lookup(db);

- let krate = parent.container.krate;

- let variant = &item_tree[loc.id.value];

- (

- variant.shape,

- variant.types_map.clone(),

- lower_fields(

- db,

- krate,

- parent.container.local_id,

- loc.id.tree_id(),

- &item_tree,

- krate.cfg_options(db),

- FieldParent::EnumVariant(loc.id.value),

- &variant.fields,

- Some(item_tree[parent.id.value].visibility),

- ),

- )

- }

- VariantId::StructId(id) => {

- let loc = id.lookup(db);

- let item_tree = loc.id.item_tree(db);

- let krate = loc.container.krate;

- let strukt = &item_tree[loc.id.value];

- (

- strukt.shape,

- strukt.types_map.clone(),

- lower_fields(

- db,

- krate,

- loc.container.local_id,

- loc.id.tree_id(),

- &item_tree,

- krate.cfg_options(db),

- FieldParent::Struct(loc.id.value),

- &strukt.fields,

- None,

- ),

- )

- }

- VariantId::UnionId(id) => {

- let loc = id.lookup(db);

- let item_tree = loc.id.item_tree(db);

- let krate = loc.container.krate;

- let union = &item_tree[loc.id.value];

- (

- FieldsShape::Record,

- union.types_map.clone(),

- lower_fields(

- db,

- krate,

- loc.container.local_id,

- loc.id.tree_id(),

- &item_tree,

- krate.cfg_options(db),

- FieldParent::Union(loc.id.value),

- &union.fields,

- None,

- ),

- )

- }

- };

-

- (

- Arc::new(match shape {

- FieldsShape::Record => VariantData::Record { fields, types_map },

- FieldsShape::Tuple => VariantData::Tuple { fields, types_map },

- FieldsShape::Unit => VariantData::Unit,

- }),

- DefDiagnostics::new(diagnostics),

- )

- }

-}

-

-/// A single field of an enum variant or struct

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub struct FieldData {

- pub name: Name,

- pub type_ref: TypeRefId,

- pub visibility: RawVisibility,

- pub is_unsafe: bool,

-}

-

-fn repr_from_value(

- db: &dyn DefDatabase,

- krate: Crate,

- item_tree: &ItemTree,

- of: AttrOwner,

-) -> Option<ReprOptions> {

- item_tree.attrs(db, krate, of).repr()

-}

-

-impl StructData {

- #[inline]

- pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {

- let loc = id.lookup(db);

- let krate = loc.container.krate;

- let item_tree = loc.id.item_tree(db);

- let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());

- let attrs = item_tree.attrs(db, krate, ModItem::from(loc.id.value).into());

-

- let mut flags = StructFlags::NO_FLAGS;

- if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {

- flags |= StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPL;

- }

- if attrs.by_key(&sym::fundamental).exists() {

- flags |= StructFlags::IS_FUNDAMENTAL;

- }

- if let Some(lang) = attrs.lang_item() {

- match lang {

- LangItem::PhantomData => flags |= StructFlags::IS_PHANTOM_DATA,

- LangItem::OwnedBox => flags |= StructFlags::IS_BOX,

- LangItem::ManuallyDrop => flags |= StructFlags::IS_MANUALLY_DROP,

- LangItem::UnsafeCell => flags |= StructFlags::IS_UNSAFE_CELL,

- _ => (),

- }

- }

-

- let strukt = &item_tree[loc.id.value];

- Arc::new(StructData {

- name: strukt.name.clone(),

- repr,

- visibility: item_tree[strukt.visibility].clone(),

- flags,

- })

- }

-

- #[inline]

- pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {

- let loc = id.lookup(db);

- let krate = loc.container.krate;

- let item_tree = loc.id.item_tree(db);

- let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());

- let attrs = item_tree.attrs(db, krate, ModItem::from(loc.id.value).into());

- let mut flags = StructFlags::NO_FLAGS;

-

- if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {

- flags |= StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPL;

- }

- if attrs.by_key(&sym::fundamental).exists() {

- flags |= StructFlags::IS_FUNDAMENTAL;

- }

-

- let union = &item_tree[loc.id.value];

-

- Arc::new(StructData {

- name: union.name.clone(),

- repr,

- visibility: item_tree[union.visibility].clone(),

- flags,

- })

- }

-}

-

-impl EnumVariants {

- pub(crate) fn enum_variants_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumVariants> {

- let loc = e.lookup(db);

- let item_tree = loc.id.item_tree(db);

-

- Arc::new(EnumVariants {

- variants: loc.container.def_map(db).enum_definitions[&e]

- .iter()

- .map(|&id| (id, item_tree[id.lookup(db).id.value].name.clone()))

- .collect(),

- })

- }

-

- pub fn variant(&self, name: &Name) -> Option<EnumVariantId> {

- let &(id, _) = self.variants.iter().find(|(_id, n)| n == name)?;

- Some(id)

- }

-

- // [Adopted from rustc](https://github.com/rust-lang/rust/blob/bd53aa3bf7a24a70d763182303bd75e5fc51a9af/compiler/rustc_middle/src/ty/adt.rs#L446-L448)

- pub fn is_payload_free(&self, db: &dyn DefDatabase) -> bool {

- self.variants.iter().all(|&(v, _)| {

- // The condition check order is slightly modified from rustc

- // to improve performance by early returning with relatively fast checks

- let variant = &db.variant_data(v.into());

- if !variant.fields().is_empty() {

- return false;

- }

- // The outer if condition is whether this variant has const ctor or not

- if !matches!(variant.kind(), StructKind::Unit) {

- let body = db.body(v.into());

- // A variant with explicit discriminant

- if body.exprs[body.body_expr] != Expr::Missing {

- return false;

- }

- }

- true

- })

- }

-}

-

-impl EnumData {

- pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {

- let loc = e.lookup(db);

- let krate = loc.container.krate;

- let item_tree = loc.id.item_tree(db);

- let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());

- let attrs = item_tree.attrs(db, loc.container.krate, ModItem::from(loc.id.value).into());

-

- let rustc_has_incoherent_inherent_impls =

- attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists();

-

- let enum_ = &item_tree[loc.id.value];

-

- Arc::new(EnumData {

- name: enum_.name.clone(),

- repr,

- visibility: item_tree[enum_.visibility].clone(),

- rustc_has_incoherent_inherent_impls,

- })

- }

-

- pub fn variant_body_type(&self) -> IntegerType {

- match self.repr {

- Some(ReprOptions { int: Some(builtin), .. }) => builtin,

- _ => IntegerType::Pointer(true),

- }

- }

-}

-

-impl EnumVariantData {

- #[inline]

- pub(crate) fn enum_variant_data_query(

- db: &dyn DefDatabase,

- e: EnumVariantId,

- ) -> Arc<EnumVariantData> {

- let loc = e.lookup(db);

- let item_tree = loc.id.item_tree(db);

- let variant = &item_tree[loc.id.value];

-

- Arc::new(EnumVariantData { name: variant.name.clone() })

- }

-}

-

-impl VariantData {

- pub fn fields(&self) -> &Arena<FieldData> {

- const EMPTY: &Arena<FieldData> = &Arena::new();

- match self {

- VariantData::Record { fields, .. } | VariantData::Tuple { fields, .. } => fields,

- _ => EMPTY,

- }

- }

-

- pub fn types_map(&self) -> &TypesMap {

- match self {

- VariantData::Record { types_map, .. } | VariantData::Tuple { types_map, .. } => {

- types_map

- }

- VariantData::Unit => TypesMap::EMPTY,

- }

- }

-

- // FIXME: Linear lookup

- pub fn field(&self, name: &Name) -> Option<LocalFieldId> {

- self.fields().iter().find_map(|(id, data)| if &data.name == name { Some(id) } else { None })

- }

-

- pub fn kind(&self) -> StructKind {

- match self {

- VariantData::Record { .. } => StructKind::Record,

- VariantData::Tuple { .. } => StructKind::Tuple,

- VariantData::Unit => StructKind::Unit,

- }

- }

-}

-

-#[derive(Debug, Copy, Clone, PartialEq, Eq)]

-pub enum StructKind {

- Tuple,

- Record,

- Unit,

-}

-

-fn lower_fields(

- db: &dyn DefDatabase,

- krate: Crate,

- container: LocalModuleId,

- tree_id: TreeId,

- item_tree: &ItemTree,

- cfg_options: &CfgOptions,

- parent: FieldParent,

- fields: &[Field],

- override_visibility: Option<RawVisibilityId>,

-) -> (Arena<FieldData>, Vec<DefDiagnostic>) {

- let mut diagnostics = Vec::new();

- let mut arena = Arena::new();

- for (idx, field) in fields.iter().enumerate() {

- let attr_owner = AttrOwner::make_field_indexed(parent, idx);

- let attrs = item_tree.attrs(db, krate, attr_owner);

- if attrs.is_cfg_enabled(cfg_options) {

- arena.alloc(lower_field(item_tree, field, override_visibility));

- } else {

- diagnostics.push(DefDiagnostic::unconfigured_code(

- container,

- tree_id,

- attr_owner,

- attrs.cfg().unwrap(),

- cfg_options.clone(),

- ))

- }

- }

- (arena, diagnostics)

-}

-

-fn lower_field(

- item_tree: &ItemTree,

- field: &Field,

- override_visibility: Option<RawVisibilityId>,

-) -> FieldData {

- FieldData {

- name: field.name.clone(),

- type_ref: field.type_ref,

- visibility: item_tree[override_visibility.unwrap_or(field.visibility)].clone(),

- is_unsafe: field.is_unsafe,

- }

-}