language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-27 18:26:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Salsa idiomize VariantFields query

Browse source
This commit is contained in:
Lukas Wirth 2025-06-26 12:55:55 +02:00
parent 332434aecd
commit 889d84a1be
33 changed files with 201 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/hir/src/diagnostics.rs
View file

@ -490,7 +490,7 @@ impl<'db> AnyDiagnostic<'db> {
) -> Option<AnyDiagnostic<'db>> {
match diagnostic {
BodyValidationDiagnostic::RecordMissingFields { record, variant, missed_fields } => {
let variant_data = variant.variant_data(db);
let variant_data = variant.fields(db);
let missed_fields = missed_fields
.into_iter()
.map(|idx| variant_data.fields()[idx].name.clone())

2
crates/hir/src/display.rs
View file

@ -404,7 +404,7 @@ impl HirDisplay for TupleField {
impl HirDisplay for Variant {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?;
let data = f.db.variant_fields(self.id.into());
let data = self.id.fields(f.db);
match data.shape {
FieldsShape::Unit => {}
FieldsShape::Tuple => {

39
crates/hir/src/lib.rs
View file

@ -668,25 +668,25 @@ impl Module {
Adt::Struct(s) => {
let source_map = db.struct_signature_with_source_map(s.id).1;
expr_store_diagnostics(db, acc, &source_map);
let source_map = db.variant_fields_with_source_map(s.id.into()).1;
expr_store_diagnostics(db, acc, &source_map);
let source_map = &s.id.fields_with_source_map(db).1;
expr_store_diagnostics(db, acc, source_map);
push_ty_diagnostics(
db,
acc,
db.field_types_with_diagnostics(s.id.into()).1,
&source_map,
source_map,
);
}
Adt::Union(u) => {
let source_map = db.union_signature_with_source_map(u.id).1;
expr_store_diagnostics(db, acc, &source_map);
let source_map = db.variant_fields_with_source_map(u.id.into()).1;
expr_store_diagnostics(db, acc, &source_map);
let source_map = &u.id.fields_with_source_map(db).1;
expr_store_diagnostics(db, acc, source_map);
push_ty_diagnostics(
db,
acc,
db.field_types_with_diagnostics(u.id.into()).1,
&source_map,
source_map,
);
}
Adt::Enum(e) => {
@ -711,14 +711,14 @@ impl Module {
}
}
for &(v, _, _) in &variants.variants {
let source_map = db.variant_fields_with_source_map(v.into()).1;
let source_map = &v.fields_with_source_map(db).1;
push_ty_diagnostics(
db,
acc,
db.field_types_with_diagnostics(v.into()).1,
&source_map,
source_map,
);
expr_store_diagnostics(db, acc, &source_map);
expr_store_diagnostics(db, acc, source_map);
}
}
}
@ -1311,7 +1311,7 @@ impl AstNode for FieldSource {
impl Field {
pub fn name(&self, db: &dyn HirDatabase) -> Name {
db.variant_fields(self.parent.into()).fields()[self.id].name.clone()
VariantId::from(self.parent).fields(db).fields()[self.id].name.clone()
}
pub fn index(&self) -> usize {
@ -1380,7 +1380,7 @@ impl Field {
impl HasVisibility for Field {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let variant_data = db.variant_fields(self.parent.into());
let variant_data = VariantId::from(self.parent).fields(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
@ -1403,7 +1403,8 @@ impl Struct {
}
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
db.variant_fields(self.id.into())
self.id
.fields(db)
.fields()
.iter()
.map(|(id, _)| Field { parent: self.into(), id })
@ -1434,8 +1435,8 @@ impl Struct {
}
}
fn variant_fields(self, db: &dyn HirDatabase) -> Arc<VariantFields> {
db.variant_fields(self.id.into())
fn variant_fields(self, db: &dyn HirDatabase) -> &VariantFields {
self.id.fields(db)
}
pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {
@ -1478,7 +1479,7 @@ impl Union {
}
pub fn kind(self, db: &dyn HirDatabase) -> StructKind {
match db.variant_fields(self.id.into()).shape {
match self.id.fields(db).shape {
hir_def::item_tree::FieldsShape::Record => StructKind::Record,
hir_def::item_tree::FieldsShape::Tuple => StructKind::Tuple,
hir_def::item_tree::FieldsShape::Unit => StructKind::Unit,
@ -1486,7 +1487,8 @@ impl Union {
}
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
db.variant_fields(self.id.into())
self.id
.fields(db)
.fields()
.iter()
.map(|(id, _)| Field { parent: self.into(), id })
@ -1626,7 +1628,8 @@ impl Variant {
}
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
db.variant_fields(self.id.into())
self.id
.fields(db)
.fields()
.iter()
.map(|(id, _)| Field { parent: self.into(), id })
@ -1634,7 +1637,7 @@ impl Variant {
}
pub fn kind(self, db: &dyn HirDatabase) -> StructKind {
match db.variant_fields(self.id.into()).shape {
match self.id.fields(db).shape {
hir_def::item_tree::FieldsShape::Record => StructKind::Record,
hir_def::item_tree::FieldsShape::Tuple => StructKind::Tuple,
hir_def::item_tree::FieldsShape::Unit => StructKind::Unit,

2
crates/hir/src/semantics/child_by_source.rs
View file

@ -191,7 +191,7 @@ impl ChildBySource for VariantId {
Either::Right(source) => res[keys::RECORD_FIELD].insert(AstPtr::new(&source), id),
}
}
let (_, sm) = db.variant_fields_with_source_map(*self);
let (_, sm) = self.fields_with_source_map(db);
sm.expansions().for_each(|(ast, &exp_id)| res[keys::MACRO_CALL].insert(ast.value, exp_id));
}
}

12
crates/hir/src/source_analyzer.rs
View file

@ -156,14 +156,14 @@ impl<'db> SourceAnalyzer<'db> {
InFile { file_id, .. }: InFile<&SyntaxNode>,
_offset: Option<TextSize>,
) -> SourceAnalyzer<'db> {
let (fields, source_map) = db.variant_fields_with_source_map(def);
let (fields, source_map) = def.fields_with_source_map(db);
let resolver = def.resolver(db);
SourceAnalyzer {
resolver,
body_or_sig: Some(BodyOrSig::VariantFields {
def,
store: fields.store.clone(),
source_map,
source_map: source_map.clone(),
}),
file_id,
}
@ -713,7 +713,7 @@ impl<'db> SourceAnalyzer<'db> {
};
let (adt, subst) = self.infer()?.type_of_expr_or_pat(expr_id)?.as_adt()?;
let variant = self.infer()?.variant_resolution_for_expr_or_pat(expr_id)?;
let variant_data = variant.variant_data(db);
let variant_data = variant.fields(db);
let field = FieldId { parent: variant, local_id: variant_data.field(&local_name)? };
let field_ty =
db.field_types(variant).get(field.local_id)?.clone().substitute(Interner, subst);
@ -734,7 +734,7 @@ impl<'db> SourceAnalyzer<'db> {
let record_pat = ast::RecordPat::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
let pat_id = self.pat_id(&record_pat.into())?;
let variant = self.infer()?.variant_resolution_for_pat(pat_id.as_pat()?)?;
let variant_data = variant.variant_data(db);
let variant_data = variant.fields(db);
let field = FieldId { parent: variant, local_id: variant_data.field(&field_name)? };
let (adt, subst) = self.infer()?.type_of_pat.get(pat_id.as_pat()?)?.as_adt()?;
let field_ty =
@ -803,8 +803,8 @@ impl<'db> SourceAnalyzer<'db> {
};
container = Either::Right(db.normalize_projection(projection, trait_env.clone()));
}
let handle_variants = |variant, subst: &Substitution, container: &mut _| {
let fields = db.variant_fields(variant);
let handle_variants = |variant: VariantId, subst: &Substitution, container: &mut _| {
let fields = variant.fields(db);
let field = fields.field(&field_name.as_name())?;
let field_types = db.field_types(variant);
*container = Either::Right(field_types[field].clone().substitute(Interner, subst));