Split `variant_data` into its own query

26 files changed, 189 insertions, 211 deletions

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/attr.rs b/src/tools/rust-analyzer/crates/hir-def/src/attr.rs
index 030d064584c..2775e1398c2 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/attr.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/attr.rs
@@ -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);
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/data/adt.rs b/src/tools/rust-analyzer/crates/hir-def/src/data/adt.rs
index c8429d8b689..9db66d6e91c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/data/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/data/adt.rs
@@ -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)]
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index bc9fc8e0793..108968fe52e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -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>;
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index c346cec242e..b9b00108dcd 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -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()))
                         }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
index 9acf98e62cd..d42104faa2e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
@@ -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>;
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
index b0546d4f33f..05b99ae31f4 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
@@ -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,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
index d113a500ef7..e666b1ea6bc 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
@@ -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, ",");
                     }
                 });
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index fbbeb4beb99..5f8cd0fde04 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -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 {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index 72723499fc9..0ed26ca853e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -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),
         }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/src.rs b/src/tools/rust-analyzer/crates/hir-def/src/src.rs
index 43d31aa503c..347c4803be1 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/src.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/src.rs
@@ -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,
                 )
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
index ac4d1babd62..acaca24f54f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
@@ -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);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
index 0b21ae7ade3..5106056d409 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
@@ -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);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index be590b6101d..7bce23f398a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -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()),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index 6c0e0b02737..8b43d0188a9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -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)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 6c50f056c18..9ae6e0a1744 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -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();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index d0936185957..d0cbce70a2f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -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,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index a9332a5a963..e55fc0a9b83 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -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);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 167dcec3bb3..2f7ad2b99d2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -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,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index 40a1d4e6707..9f453162e30 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -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())
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 33e852aaee4..12f3a1138fc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -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 => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 25aa2606558..45b43855681 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -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());
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim/simd.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim/simd.rs
index e229a4ab317..829ed9efa2b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim/simd.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim/simd.rs
@@ -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");
                             };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 57d4baa137c..102048b3f4d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -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| {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
index 783f92b2043..1c6dc4fecd8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/pattern_matching.rs
@@ -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,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f78b7a5c435..9f91f155ea7 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -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> {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/apply_change.rs b/src/tools/rust-analyzer/crates/ide-db/src/apply_change.rs
index 6b08ada34b6..4e058bb0106 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/apply_change.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/apply_change.rs
@@ -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