itsscb/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-28 11:20:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Split variant_data into its own query

Browse Source
This commit is contained in:
Lukas Wirth 2025-02-27 11:22:29 +01:00
parent 8e8d997304
commit 2ea09b2e47
26 changed files with 189 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/hir-def/src/attr.rs
View File

@ -84,7 +84,7 @@ impl Attrs {
let krate = loc.parent.lookup(db).container.krate;
item_tree = loc.id.item_tree(db);
let variant = &item_tree[loc.id.value];
(FieldParent::Variant(loc.id.value), &variant.fields, krate)
(FieldParent::EnumVariant(loc.id.value), &variant.fields, krate)
}
VariantId::StructId(it) => {
let loc = it.lookup(db);

215
crates/hir-def/src/data/adt.rs
View File

@ -27,7 +27,6 @@ use crate::{
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StructData {
pub name: Name,
pub variant_data: Arc<VariantData>,
pub repr: Option<ReprOptions>,
pub visibility: RawVisibility,
pub flags: StructFlags,
@ -69,7 +68,6 @@ pub struct EnumVariants {
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EnumVariantData {
pub name: Name,
pub variant_data: Arc<VariantData>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
@ -79,6 +77,94 @@ pub enum VariantData {
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 {
@ -99,13 +185,6 @@ fn repr_from_value(
impl StructData {
#[inline]
pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
db.struct_data_with_diagnostics(id).0
}
pub(crate) fn struct_data_with_diagnostics_query(
db: &dyn DefDatabase,
id: StructId,
) -> (Arc<StructData>, DefDiagnostics) {
let loc = id.lookup(db);
let krate = loc.container.krate;
let item_tree = loc.id.item_tree(db);
@ -130,44 +209,16 @@ impl StructData {
}
let strukt = &item_tree[loc.id.value];
let (fields, diagnostics) = 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,
);
let types_map = strukt.types_map.clone();
(
Arc::new(StructData {
name: strukt.name.clone(),
variant_data: Arc::new(match strukt.shape {
FieldsShape::Record => VariantData::Record { fields, types_map },
FieldsShape::Tuple => VariantData::Tuple { fields, types_map },
FieldsShape::Unit => VariantData::Unit,
}),
repr,
visibility: item_tree[strukt.visibility].clone(),
flags,
}),
DefDiagnostics::new(diagnostics),
)
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> {
db.union_data_with_diagnostics(id).0
}
pub(crate) fn union_data_with_diagnostics_query(
db: &dyn DefDatabase,
id: UnionId,
) -> (Arc<StructData>, DefDiagnostics) {
let loc = id.lookup(db);
let krate = loc.container.krate;
let item_tree = loc.id.item_tree(db);
@ -182,28 +233,13 @@ impl StructData {
}
let union = &item_tree[loc.id.value];
let (fields, diagnostics) = 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,
);
let types_map = union.types_map.clone();
(
Arc::new(StructData {
name: union.name.clone(),
variant_data: Arc::new(VariantData::Record { fields, types_map }),
repr,
visibility: item_tree[union.visibility].clone(),
flags,
}),
DefDiagnostics::new(diagnostics),
)
Arc::new(StructData {
name: union.name.clone(),
repr,
visibility: item_tree[union.visibility].clone(),
flags,
})
}
}
@ -227,16 +263,16 @@ impl EnumVariants {
// [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, _)| {
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.enum_variant_data(*v).variant_data;
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());
let body = db.body(v.into());
// A variant with explicit discriminant
if body.exprs[body.body_expr] != Expr::Missing {
return false;
@ -282,43 +318,11 @@ impl EnumVariantData {
db: &dyn DefDatabase,
e: EnumVariantId,
) -> Arc<EnumVariantData> {
db.enum_variant_data_with_diagnostics(e).0
}
pub(crate) fn enum_variant_data_with_diagnostics_query(
db: &dyn DefDatabase,
e: EnumVariantId,
) -> (Arc<EnumVariantData>, DefDiagnostics) {
let loc = e.lookup(db);
let container = loc.parent.lookup(db).container;
let krate = container.krate;
let item_tree = loc.id.item_tree(db);
let variant = &item_tree[loc.id.value];
let (fields, diagnostics) = lower_fields(
db,
krate,
container.local_id,
loc.id.tree_id(),
&item_tree,
krate.cfg_options(db),
FieldParent::Variant(loc.id.value),
&variant.fields,
Some(item_tree[loc.parent.lookup(db).id.value].visibility),
);
let types_map = variant.types_map.clone();
(
Arc::new(EnumVariantData {
name: variant.name.clone(),
variant_data: Arc::new(match variant.shape {
FieldsShape::Record => VariantData::Record { fields, types_map },
FieldsShape::Tuple => VariantData::Tuple { fields, types_map },
FieldsShape::Unit => VariantData::Unit,
}),
}),
DefDiagnostics::new(diagnostics),
)
Arc::new(EnumVariantData { name: variant.name.clone() })
}
}
@ -352,15 +356,6 @@ impl VariantData {
VariantData::Unit => StructKind::Unit,
}
}
#[allow(clippy::self_named_constructors)]
pub(crate) fn variant_data(db: &dyn DefDatabase, id: VariantId) -> Arc<VariantData> {
match id {
VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),
VariantId::EnumVariantId(it) => db.enum_variant_data(it).variant_data.clone(),
VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),
}
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]

24
crates/hir-def/src/db.rs
View File

@ -151,39 +151,27 @@ pub trait DefDatabase:
// region:data
#[salsa::transparent]
#[salsa::invoke_actual(VariantData::variant_data_query)]
fn variant_data(&self, id: VariantId) -> Arc<VariantData>;
#[salsa::invoke_actual(VariantData::variant_data_with_diagnostics_query)]
fn variant_data_with_diagnostics(&self, id: VariantId) -> (Arc<VariantData>, DefDiagnostics);
#[salsa::invoke_actual(StructData::struct_data_query)]
fn struct_data(&self, id: StructId) -> Arc<StructData>;
#[salsa::invoke_actual(StructData::struct_data_with_diagnostics_query)]
fn struct_data_with_diagnostics(&self, id: StructId) -> (Arc<StructData>, DefDiagnostics);
#[salsa::transparent]
#[salsa::invoke_actual(StructData::union_data_query)]
fn union_data(&self, id: UnionId) -> Arc<StructData>;
#[salsa::invoke_actual(StructData::union_data_with_diagnostics_query)]
fn union_data_with_diagnostics(&self, id: UnionId) -> (Arc<StructData>, DefDiagnostics);
#[salsa::invoke_actual(EnumData::enum_data_query)]
fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
#[salsa::invoke_actual(EnumVariants::enum_variants_query)]
fn enum_variants(&self, e: EnumId) -> Arc<EnumVariants>;
#[salsa::transparent]
#[salsa::invoke_actual(EnumVariantData::enum_variant_data_query)]
fn enum_variant_data(&self, id: EnumVariantId) -> Arc<EnumVariantData>;
#[salsa::invoke_actual(EnumVariantData::enum_variant_data_with_diagnostics_query)]
fn enum_variant_data_with_diagnostics(
&self,
id: EnumVariantId,
) -> (Arc<EnumVariantData>, DefDiagnostics);
#[salsa::transparent]
#[salsa::invoke_actual(VariantData::variant_data)]
fn variant_data(&self, id: VariantId) -> Arc<VariantData>;
#[salsa::invoke_actual(ImplData::impl_data_query)]
fn impl_data(&self, e: ImplId) -> Arc<ImplData>;

2
crates/hir-def/src/expr_store/lower.rs
View File

@ -1631,7 +1631,7 @@ impl ExprCollector<'_> {
(None, Pat::Path(name.into()))
}
Some(ModuleDefId::AdtId(AdtId::StructId(s)))
if self.db.struct_data(s).variant_data.kind() != StructKind::Record =>
if self.db.variant_data(s.into()).kind() != StructKind::Record =>
{
(None, Pat::Path(name.into()))
}

2
crates/hir-def/src/item_tree.rs
View File

@ -506,7 +506,7 @@ impl AttrOwner {
pub enum FieldParent {
Struct(FileItemTreeId<Struct>),
Union(FileItemTreeId<Union>),
Variant(FileItemTreeId<Variant>),
EnumVariant(FileItemTreeId<Variant>),
}
pub type ItemTreeParamId = Idx<Param>;

2
crates/hir-def/src/item_tree/lower.rs
View File

@ -428,7 +428,7 @@ impl<'a> Ctx<'a> {
for (idx, attr) in attrs {
self.add_attrs(
AttrOwner::Field(
FieldParent::Variant(FileItemTreeId(id)),
FieldParent::EnumVariant(FileItemTreeId(id)),
Idx::from_raw(RawIdx::from_u32(idx as u32)),
),
attr,

7
crates/hir-def/src/item_tree/pretty.rs
View File

@ -382,7 +382,12 @@ impl Printer<'_> {
this.print_ast_id(ast_id.erase());
this.print_attrs_of(variant, "\n");
w!(this, "{}", name.display(self.db.upcast(), edition));
this.print_fields(FieldParent::Variant(variant), *kind, fields, types_map);
this.print_fields(
FieldParent::EnumVariant(variant),
*kind,
fields,
types_map,
);
wln!(this, ",");
}
});

6
crates/hir-def/src/lib.rs
View File

@ -1104,11 +1104,7 @@ impl_from!(EnumVariantId, StructId, UnionId for VariantId);
impl VariantId {
pub fn variant_data(self, db: &dyn DefDatabase) -> Arc<VariantData> {
match self {
VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),
VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),
VariantId::EnumVariantId(it) => db.enum_variant_data(it).variant_data.clone(),
}
db.variant_data(self)
}
pub fn file_id(self, db: &dyn DefDatabase) -> HirFileId {

9
crates/hir-def/src/resolver.rs
View File

@ -276,11 +276,16 @@ impl Resolver {
db: &dyn DefDatabase,
visibility: &RawVisibility,
) -> Option<Visibility> {
let within_impl = self.scopes().any(|scope| matches!(scope, Scope::ImplDefScope(_)));
match visibility {
RawVisibility::Module(_, _) => {
let (item_map, item_local_map, module) = self.item_scope();
item_map.resolve_visibility(item_local_map, db, module, visibility, within_impl)
item_map.resolve_visibility(
item_local_map,
db,
module,
visibility,
self.scopes().any(|scope| matches!(scope, Scope::ImplDefScope(_))),
)
}
RawVisibility::Public => Some(Visibility::Public),
}

2
crates/hir-def/src/src.rs
View File

@ -131,7 +131,7 @@ impl HasChildSource<LocalFieldId> for VariantId {
item_tree = lookup.id.item_tree(db);
(
lookup.source(db).map(|it| it.kind()),
FieldParent::Variant(lookup.id.value),
FieldParent::EnumVariant(lookup.id.value),
lookup.parent.lookup(db).container,
)
}

2
crates/hir-ty/src/chalk_db.rs
View File

@ -137,7 +137,7 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
_ => self_ty_fp.as_ref().map(std::slice::from_ref).unwrap_or(&[]),
_ => self_ty_fp.as_slice(),
};
let id_to_chalk = |id: hir_def::ImplId| id.to_chalk(self.db);

8
crates/hir-ty/src/diagnostics/decl_check.rs
View File

@ -307,8 +307,8 @@ impl<'a> DeclValidator<'a> {
/// Check incorrect names for struct fields.
fn validate_struct_fields(&mut self, struct_id: StructId) {
let data = self.db.struct_data(struct_id);
let VariantData::Record { fields, .. } = data.variant_data.as_ref() else {
let data = self.db.variant_data(struct_id.into());
let VariantData::Record { fields, .. } = data.as_ref() else {
return;
};
let edition = self.edition(struct_id);
@ -467,8 +467,8 @@ impl<'a> DeclValidator<'a> {
/// Check incorrect names for fields of enum variant.
fn validate_enum_variant_fields(&mut self, variant_id: EnumVariantId) {
let variant_data = self.db.enum_variant_data(variant_id);
let VariantData::Record { fields, .. } = variant_data.variant_data.as_ref() else {
let variant_data = self.db.variant_data(variant_id.into());
let VariantData::Record { fields, .. } = variant_data.as_ref() else {
return;
};
let edition = self.edition(variant_id);

4
crates/hir-ty/src/display.rs
View File

@ -846,7 +846,7 @@ fn render_const_scalar(
write!(f, "{}", data.name.display(f.db.upcast(), f.edition()))?;
let field_types = f.db.field_types(s.into());
render_variant_after_name(
&data.variant_data,
&f.db.variant_data(s.into()),
f,
&field_types,
f.db.trait_environment(adt.0.into()),
@ -872,7 +872,7 @@ fn render_const_scalar(
write!(f, "{}", data.name.display(f.db.upcast(), f.edition()))?;
let field_types = f.db.field_types(var_id.into());
render_variant_after_name(
&data.variant_data,
&f.db.variant_data(var_id.into()),
f,
&field_types,
f.db.trait_environment(adt.0.into()),

4
crates/hir-ty/src/infer/cast.rs
View File

@ -389,8 +389,8 @@ fn pointer_kind(ty: &Ty, table: &mut InferenceTable<'_>) -> Result<Option<Pointe
return Err(());
};
let struct_data = table.db.struct_data(id);
if let Some((last_field, _)) = struct_data.variant_data.fields().iter().last() {
let struct_data = table.db.variant_data(id.into());
if let Some((last_field, _)) = struct_data.fields().iter().last() {
let last_field_ty =
table.db.field_types(id.into())[last_field].clone().substitute(Interner, subst);
pointer_kind(&last_field_ty, table)

4
crates/hir-ty/src/infer/closure.rs
View File

@ -1159,7 +1159,7 @@ impl InferenceContext<'_> {
self.consume_place(place)
}
VariantId::StructId(s) => {
let vd = &*self.db.struct_data(s).variant_data;
let vd = &*self.db.variant_data(s.into());
for field_pat in args.iter() {
let arg = field_pat.pat;
let Some(local_id) = vd.field(&field_pat.name) else {
@ -1211,7 +1211,7 @@ impl InferenceContext<'_> {
self.consume_place(place)
}
VariantId::StructId(s) => {
let vd = &*self.db.struct_data(s).variant_data;
let vd = &*self.db.variant_data(s.into());
let (al, ar) =
args.split_at(ellipsis.map_or(args.len(), |it| it as usize));
let fields = vd.fields().iter();

12
crates/hir-ty/src/infer/expr.rs
View File

@ -1681,14 +1681,14 @@ impl InferenceContext<'_> {
})
});
}
TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
let local_id = self.db.struct_data(*s).variant_data.field(name)?;
let field = FieldId { parent: (*s).into(), local_id };
&TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), ref parameters) => {
let local_id = self.db.variant_data(s.into()).field(name)?;
let field = FieldId { parent: s.into(), local_id };
(field, parameters.clone())
}
TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => {
let local_id = self.db.union_data(*u).variant_data.field(name)?;
let field = FieldId { parent: (*u).into(), local_id };
&TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), ref parameters) => {
let local_id = self.db.variant_data(u.into()).field(name)?;
let field = FieldId { parent: u.into(), local_id };
(field, parameters.clone())
}
_ => return None,

5
crates/hir-ty/src/infer/unify.rs
View File

@ -928,9 +928,8 @@ impl<'a> InferenceTable<'a> {
// Must use a loop here and not recursion because otherwise users will conduct completely
// artificial examples of structs that have themselves as the tail field and complain r-a crashes.
while let Some((AdtId::StructId(id), subst)) = ty.as_adt() {
let struct_data = self.db.struct_data(id);
if let Some((last_field, _)) = struct_data.variant_data.fields().iter().next_back()
{
let struct_data = self.db.variant_data(id.into());
if let Some((last_field, _)) = struct_data.fields().iter().next_back() {
let last_field_ty = self.db.field_types(id.into())[last_field]
.clone()
.substitute(Interner, subst);

8
crates/hir-ty/src/layout.rs
View File

@ -377,12 +377,12 @@ pub(crate) fn layout_of_ty_recover(
fn struct_tail_erasing_lifetimes(db: &dyn HirDatabase, pointee: Ty) -> Ty {
match pointee.kind(Interner) {
TyKind::Adt(AdtId(hir_def::AdtId::StructId(i)), subst) => {
let data = db.struct_data(*i);
let mut it = data.variant_data.fields().iter().rev();
&TyKind::Adt(AdtId(hir_def::AdtId::StructId(i)), ref subst) => {
let data = db.variant_data(i.into());
let mut it = data.fields().iter().rev();
match it.next() {
Some((f, _)) => {
let last_field_ty = field_ty(db, (*i).into(), f, subst);
let last_field_ty = field_ty(db, i.into(), f, subst);
struct_tail_erasing_lifetimes(db, last_field_ty)
}
None => pointee,

6
crates/hir-ty/src/layout/adt.rs
View File

@ -44,13 +44,13 @@ pub fn layout_of_adt_query(
AdtId::StructId(s) => {
let data = db.struct_data(s);
let mut r = SmallVec::<[_; 1]>::new();
r.push(handle_variant(s.into(), &data.variant_data)?);
r.push(handle_variant(s.into(), &db.variant_data(s.into()))?);
(r, data.repr.unwrap_or_default())
}
AdtId::UnionId(id) => {
let data = db.union_data(id);
let mut r = SmallVec::new();
r.push(handle_variant(id.into(), &data.variant_data)?);
r.push(handle_variant(id.into(), &db.variant_data(id.into()))?);
(r, data.repr.unwrap_or_default())
}
AdtId::EnumId(e) => {
@ -58,7 +58,7 @@ pub fn layout_of_adt_query(
let r = variants
.variants
.iter()
.map(|&(v, _)| handle_variant(v.into(), &db.enum_variant_data(v).variant_data))
.map(|&(v, _)| handle_variant(v.into(), &db.variant_data(v.into())))
.collect::<Result<SmallVec<_>, _>>()?;
(r, db.enum_data(e).repr.unwrap_or_default())
}

26
crates/hir-ty/src/lower.rs
View File

@ -1491,16 +1491,12 @@ fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> {
}
fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig {
let struct_data = db.struct_data(def);
let fields = struct_data.variant_data.fields();
let struct_data = db.variant_data(def.into());
let fields = struct_data.fields();
let resolver = def.resolver(db.upcast());
let mut ctx = TyLoweringContext::new(
db,
&resolver,
struct_data.variant_data.types_map(),
AdtId::from(def).into(),
)
.with_type_param_mode(ParamLoweringMode::Variable);
let mut ctx =
TyLoweringContext::new(db, &resolver, struct_data.types_map(), AdtId::from(def).into())
.with_type_param_mode(ParamLoweringMode::Variable);
let params = fields.iter().map(|(_, field)| ctx.lower_ty(field.type_ref));
let (ret, binders) = type_for_adt(db, def.into()).into_value_and_skipped_binders();
Binders::new(
@ -1511,8 +1507,8 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS
/// Build the type of a tuple struct constructor.
fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Option<Binders<Ty>> {
let struct_data = db.struct_data(def);
match struct_data.variant_data.kind() {
let struct_data = db.variant_data(def.into());
match struct_data.kind() {
StructKind::Record => None,
StructKind::Unit => Some(type_for_adt(db, def.into())),
StructKind::Tuple => {
@ -1528,13 +1524,13 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Option<Bi
}
fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {
let var_data = db.enum_variant_data(def);
let fields = var_data.variant_data.fields();
let var_data = db.variant_data(def.into());
let fields = var_data.fields();
let resolver = def.resolver(db.upcast());
let mut ctx = TyLoweringContext::new(
db,
&resolver,
var_data.variant_data.types_map(),
var_data.types_map(),
DefWithBodyId::VariantId(def).into(),
)
.with_type_param_mode(ParamLoweringMode::Variable);
@ -1553,7 +1549,7 @@ fn type_for_enum_variant_constructor(
def: EnumVariantId,
) -> Option<Binders<Ty>> {
let e = def.lookup(db.upcast()).parent;
match db.enum_variant_data(def).variant_data.kind() {
match db.variant_data(def.into()).kind() {
StructKind::Record => None,
StructKind::Unit => Some(type_for_adt(db, e.into())),
StructKind::Tuple => {

10
crates/hir-ty/src/mir/eval.rs
View File

@ -1761,7 +1761,7 @@ impl Evaluator<'_> {
AdtId::EnumId(_) => not_supported!("unsizing enums"),
};
let Some((last_field, _)) =
self.db.struct_data(id).variant_data.fields().iter().next_back()
self.db.variant_data(id.into()).fields().iter().next_back()
else {
not_supported!("unsizing struct without field");
};
@ -2243,10 +2243,10 @@ impl Evaluator<'_> {
}
chalk_ir::TyKind::Adt(adt, subst) => match adt.0 {
AdtId::StructId(s) => {
let data = this.db.struct_data(s);
let data = this.db.variant_data(s.into());
let layout = this.layout(ty)?;
let field_types = this.db.field_types(s.into());
for (f, _) in data.variant_data.fields().iter() {
for (f, _) in data.fields().iter() {
let offset = layout
.fields
.offset(u32::from(f.into_raw()) as usize)
@ -2272,7 +2272,7 @@ impl Evaluator<'_> {
bytes,
e,
) {
let data = &this.db.enum_variant_data(v).variant_data;
let data = &this.db.variant_data(v.into());
let field_types = this.db.field_types(v.into());
for (f, _) in data.fields().iter() {
let offset =
@ -2851,7 +2851,7 @@ impl Evaluator<'_> {
return Ok(());
}
let layout = self.layout_adt(id.0, subst.clone())?;
match data.variant_data.as_ref() {
match self.db.variant_data(s.into()).as_ref() {
VariantData::Record { fields, .. }
| VariantData::Tuple { fields, .. } => {
let field_types = self.db.field_types(s.into());

4
crates/hir-ty/src/mir/eval/shim/simd.rs
View File

@ -31,8 +31,8 @@ impl Evaluator<'_> {
Some(len) => len,
_ => {
if let AdtId::StructId(id) = id.0 {
let struct_data = self.db.struct_data(id);
let fields = struct_data.variant_data.fields();
let struct_data = self.db.variant_data(id.into());
let fields = struct_data.fields();
let Some((first_field, _)) = fields.iter().next() else {
not_supported!("simd type with no field");
};

5
crates/hir-ty/src/mir/lower.rs
View File

@ -499,7 +499,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
Ok(Some(current))
}
ValueNs::EnumVariantId(variant_id) => {
let variant_data = &self.db.enum_variant_data(variant_id).variant_data;
let variant_data = &self.db.variant_data(variant_id.into());
if variant_data.kind() == StructKind::Unit {
let ty = self.infer.type_of_expr[expr_id].clone();
current = self.lower_enum_variant(
@ -1165,8 +1165,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
Rvalue::Aggregate(
AggregateKind::Adt(st.into(), subst.clone()),
self.db
.struct_data(st)
.variant_data
.variant_data(st.into())
.fields()
.iter()
.map(|it| {

4
crates/hir-ty/src/mir/lower/pattern_matching.rs
View File

@ -597,7 +597,7 @@ impl MirLowerCtx<'_> {
}
self.pattern_matching_variant_fields(
shape,
&self.db.enum_variant_data(v).variant_data,
&self.db.variant_data(v.into()),
variant,
current,
current_else,
@ -607,7 +607,7 @@ impl MirLowerCtx<'_> {
}
VariantId::StructId(s) => self.pattern_matching_variant_fields(
shape,
&self.db.struct_data(s).variant_data,
&self.db.variant_data(s.into()),
variant,
current,
current_else,

23
crates/hir/src/lib.rs
View File

@ -661,8 +661,7 @@ impl Module {
db.field_types_with_diagnostics(s.id.into()).1,
tree_source_maps.strukt(tree_id.value).item(),
);
for diag in db.struct_data_with_diagnostics(s.id).1.iter() {
for diag in db.variant_data_with_diagnostics(s.id.into()).1.iter() {
emit_def_diagnostic(db, acc, diag, edition);
}
}
@ -675,8 +674,7 @@ impl Module {
db.field_types_with_diagnostics(u.id.into()).1,
tree_source_maps.union(tree_id.value).item(),
);
for diag in db.union_data_with_diagnostics(u.id).1.iter() {
for diag in db.variant_data_with_diagnostics(u.id.into()).1.iter() {
emit_def_diagnostic(db, acc, diag, edition);
}
}
@ -692,7 +690,7 @@ impl Module {
tree_source_maps.variant(tree_id.value),
);
acc.extend(ModuleDef::Variant(v).diagnostics(db, style_lints));
for diag in db.enum_variant_data_with_diagnostics(v.id).1.iter() {
for diag in db.variant_data_with_diagnostics(v.id.into()).1.iter() {
emit_def_diagnostic(db, acc, diag, edition);
}
}
@ -1059,7 +1057,7 @@ fn emit_def_diagnostic_(
AttrOwner::Variant(it) => {
ast_id_map.get(item_tree[it].ast_id).syntax_node_ptr()
}
AttrOwner::Field(FieldParent::Variant(parent), idx) => process_field_list(
AttrOwner::Field(FieldParent::EnumVariant(parent), idx) => process_field_list(
ast_id_map
.get(item_tree[parent].ast_id)
.to_node(&db.parse_or_expand(tree.file_id()))
@ -1392,6 +1390,7 @@ impl HasVisibility for Field {
let variant_data = self.parent.variant_data(db);
let visibility = &variant_data.fields()[self.id].visibility;
let parent_id: hir_def::VariantId = self.parent.into();
// FIXME: RawVisibility::Public doesn't need to construct a resolver
visibility.resolve(db.upcast(), &parent_id.resolver(db.upcast()))
}
}
@ -1411,8 +1410,7 @@ impl Struct {
}
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
db.struct_data(self.id)
.variant_data
db.variant_data(self.id.into())
.fields()
.iter()
.map(|(id, _)| Field { parent: self.into(), id })
@ -1440,7 +1438,7 @@ impl Struct {
}
fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
db.struct_data(self.id).variant_data.clone()
db.variant_data(self.id.into()).clone()
}
pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {
@ -1481,8 +1479,7 @@ impl Union {
}
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
db.union_data(self.id)
.variant_data
db.variant_data(self.id.into())
.fields()
.iter()
.map(|(id, _)| Field { parent: self.into(), id })
@ -1490,7 +1487,7 @@ impl Union {
}
fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
db.union_data(self.id).variant_data.clone()
db.variant_data(self.id.into()).clone()
}
pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {
@ -1633,7 +1630,7 @@ impl Variant {
}
pub(crate) fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
db.enum_variant_data(self.id).variant_data.clone()
db.variant_data(self.id.into()).clone()
}
pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

4
crates/ide-db/src/apply_change.rs
View File

@ -149,7 +149,6 @@ impl RootDatabase {
// hir::db::CrateNotableTraitsQuery
// hir::db::CrateSupportsNoStdQuery
// hir::db::EnumDataQuery
// hir::db::EnumVariantDataWithDiagnosticsQuery
// hir::db::ExpandProcAttrMacrosQuery
// hir::db::ExprScopesQuery
// hir::db::ExternCrateDeclDataQuery
@ -191,11 +190,10 @@ impl RootDatabase {
// hir::db::NotableTraitsInDepsQuery
// hir::db::ProcMacroDataQuery
// hir::db::StaticDataQuery
// hir::db::StructDataWithDiagnosticsQuery
// hir::db::TraitAliasDataQuery
// hir::db::TraitItemsWithDiagnosticsQuery
// hir::db::TypeAliasDataQuery
// hir::db::UnionDataWithDiagnosticsQuery
// hir::db::VariantDataWithDiagnosticsQuery
// // InternDatabase
// hir::db::InternFunctionQuery