//! Item signature IR definitions

use bitflags::bitflags;

use cfg::{CfgExpr, CfgOptions};

use intern::{Symbol, sym};

use la_arena::{Arena, Idx};

use rustc_abi::{IntegerType, ReprOptions};

use syntax::{

};

use thin_vec::ThinVec;

use triomphe::Arc;

use crate::{

db::DefDatabase,

expr_store::{

ExpressionStore, ExpressionStoreSourceMap,

},

},

hir::{ExprId, PatId, generics::GenericParams},

lang_item::LangItem,

src::HasSource,

type_ref::{TraitRef, TypeBound, TypeRefId},

};

#[derive(Debug, PartialEq, Eq)]

pub struct StructSignature {

pub name: Name,

impl StructSignature {

pub fn query(db: &dyn DefDatabase, id: StructId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let mut flags = StructFlags::empty();

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

}

}

let repr = attrs.repr();

let (store, generic_params, source_map) = lower_generic_params(

db,

loc.container,

id.into(),

file_id,

);

(

Arc::new(StructSignature {

generic_params,

store,

flags,

repr,

}),

Arc::new(source_map),

}

}

#[derive(Debug, PartialEq, Eq)]

pub struct UnionSignature {

pub name: Name,

impl UnionSignature {

pub fn query(db: &dyn DefDatabase, id: UnionId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let mut flags = StructFlags::empty();

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

flags |= StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;

let repr = attrs.repr();

let (store, generic_params, source_map) = lower_generic_params(

db,

loc.container,

id.into(),

file_id,

);

(

Arc::new(UnionSignature {

store,

flags,

repr,

}),

Arc::new(source_map),

)

impl EnumSignature {

pub fn query(db: &dyn DefDatabase, id: EnumId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let mut flags = EnumFlags::empty();

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

flags |= EnumFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS;

let repr = attrs.repr();

let (store, generic_params, source_map) = lower_generic_params(

db,

loc.container,

id.into(),

file_id,

);

(

store,

flags,

repr,

}),

Arc::new(source_map),

)

impl ConstSignature {

pub fn query(db: &dyn DefDatabase, id: ConstId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let module = loc.container.module(db);

let mut flags = ConstFlags::empty();

if attrs.by_key(sym::rustc_allow_incoherent_impl).exists() {

flags |= ConstFlags::RUSTC_ALLOW_INCOHERENT_IMPL;

}

let (store, source_map, type_ref) =

(

Arc::new(ConstSignature {

store: Arc::new(store),

type_ref,

flags,

}),

Arc::new(source_map),

)

impl StaticSignature {

pub fn query(db: &dyn DefDatabase, id: StaticId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let module = loc.container.module(db);

let mut flags = StaticFlags::empty();

if attrs.by_key(sym::rustc_allow_incoherent_impl).exists() {

flags |= StaticFlags::RUSTC_ALLOW_INCOHERENT_IMPL;

}

let (store, source_map, type_ref) =

(

Arc::new(StaticSignature {

store: Arc::new(store),

type_ref,

flags,

}),

Arc::new(source_map),

)

impl TraitSignature {

pub fn query(db: &dyn DefDatabase, id: TraitId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let mut flags = TraitFlags::empty();

let source = loc.source(db);

if source.value.auto_token().is_some() {

flags.insert(TraitFlags::AUTO);

flags |= TraitFlags::SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH;

}

let (store, source_map, generic_params) = lower_trait(db, loc.container, source, id);

(

Arc::new(source_map),

)

}

id: TraitAliasId,

) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let source = loc.source(db);

let (store, source_map, generic_params) = lower_trait_alias(db, loc.container, source, id);

(

Arc::new(source_map),

)

}

) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let module = loc.container.module(db);

let mut flags = FnFlags::empty();

if attrs.by_key(sym::rustc_allow_incoherent_impl).exists() {

flags.insert(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPL);

}

flags.insert(FnFlags::HAS_BODY);

}

let abi = source.value.abi().map(|abi| {

abi.abi_string().map_or_else(|| sym::C, |it| Symbol::intern(it.text_without_quotes()))

});

abi,

flags,

legacy_const_generics_indices,

}),

Arc::new(source_map),

)

id: TypeAliasId,

) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

let loc = id.lookup(db);

let mut flags = TypeAliasFlags::empty();

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

flags.insert(TypeAliasFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPL);

}

flags.insert(TypeAliasFlags::IS_EXTERN);

}

let source = loc.source(db);

let (store, source_map, generic_params, bounds, ty) =

lower_type_alias(db, loc.container.module(db), source, id);

generic_params,

flags,

bounds,

ty,

}),

Arc::new(source_map),

pub store: Arc<ExpressionStore>,

pub shape: FieldsShape,

}

impl VariantFields {

pub(crate) fn query(

db: &dyn DefDatabase,

id: VariantId,

) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {

VariantId::EnumVariantId(id) => {

let loc = id.lookup(db);

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

}

VariantId::StructId(id) => {

let loc = id.lookup(db);

}

VariantId::UnionId(id) => {

let loc = id.lookup(db);

}

};

}

pub fn len(&self) -> usize {

self.fields.len()

}

}

}

db: &dyn DefDatabase,

module: ModuleId,

let cfg_options = module.krate.cfg_options(db);

let mut col = ExprCollector::new(db, module, fields.file_id);

}

#[derive(Debug, PartialEq, Eq)]

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

pub struct EnumVariants {

}

impl EnumVariants {

db: &dyn DefDatabase,

e: EnumId,

let loc = e.lookup(db);

let mut diagnostics = ThinVec::new();

let cfg_options = loc.container.krate.cfg_options(db);

let mut index = 0;

.filter_map(|variant| {

}

}

})

.collect();

}

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

}

// [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 {

// The condition check order is slightly modified from rustc

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

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

return false;

}

if !matches!(variant.shape, FieldsShape::Unit) {

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

// A variant with explicit discriminant

return false;

}

}

})

}

}