Split enum variants out of enum_data query

Author: Veykril

crates/hir-def/src/data/adt.rs

@@ -56,12 +56,16 @@ bitflags! {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EnumData {
     pub name: Name,
-    pub variants: Box<[(EnumVariantId, 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,
@@ -203,28 +207,16 @@ impl StructData {
     }
 }
 
-impl EnumData {
-    pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
+impl EnumVariants {
+    pub(crate) fn enum_variants_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumVariants> {
         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 rustc_has_incoherent_inherent_impls = item_tree
-            .attrs(db, loc.container.krate, ModItem::from(loc.id.value).into())
-            .by_key(&sym::rustc_has_incoherent_inherent_impls)
-            .exists();
-
-        let enum_ = &item_tree[loc.id.value];
 
-        Arc::new(EnumData {
-            name: enum_.name.clone(),
+        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(),
-            repr,
-            visibility: item_tree[enum_.visibility].clone(),
-            rustc_has_incoherent_inherent_impls,
         })
     }
 
@@ -233,13 +225,6 @@ impl EnumData {
         Some(id)
     }
 
-    pub fn variant_body_type(&self) -> IntegerType {
-        match self.repr {
-            Some(ReprOptions { int: Some(builtin), .. }) => builtin,
-            _ => IntegerType::Pointer(true),
-        }
-    }
-
     // [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, _)| {
@@ -262,6 +247,35 @@ impl EnumData {
     }
 }
 
+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 rustc_has_incoherent_inherent_impls = item_tree
+            .attrs(db, loc.container.krate, ModItem::from(loc.id.value).into())
+            .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(

crates/hir-def/src/db.rs

@@ -11,7 +11,7 @@ use triomphe::Arc;
 use crate::{
     attr::{Attrs, AttrsWithOwner},
     data::{
-        adt::{EnumData, EnumVariantData, StructData, VariantData},
+        adt::{EnumData, EnumVariantData, EnumVariants, StructData, VariantData},
         ConstData, ExternCrateDeclData, FunctionData, ImplData, Macro2Data, MacroRulesData,
         ProcMacroData, StaticData, TraitAliasData, TraitData, TypeAliasData,
     },
@@ -167,6 +167,9 @@ pub trait DefDatabase:
     #[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>;

crates/hir-ty/src/chalk_db.rs

@@ -801,7 +801,7 @@ pub(crate) fn adt_datum_query(
         }
         hir_def::AdtId::EnumId(id) => {
             let variants = db
-                .enum_data(id)
+                .enum_variants(id)
                 .variants
                 .iter()
                 .map(|&(variant_id, _)| variant_id_to_fields(variant_id.into()))

crates/hir-ty/src/consteval.rs

@@ -309,7 +309,7 @@ pub(crate) fn const_eval_discriminant_variant(
         let value = match prev_idx {
             Some(prev_idx) => {
                 1 + db.const_eval_discriminant(
-                    db.enum_data(loc.parent).variants[prev_idx as usize].0,
+                    db.enum_variants(loc.parent).variants[prev_idx as usize].0,
                 )?
             }
             _ => 0,

crates/hir-ty/src/diagnostics/decl_check.rs

@@ -394,7 +394,7 @@ impl<'a> DeclValidator<'a> {
 
     /// Check incorrect names for enum variants.
     fn validate_enum_variants(&mut self, enum_id: EnumId) {
-        let data = self.db.enum_data(enum_id);
+        let data = self.db.enum_variants(enum_id);
 
         for (variant_id, _) in data.variants.iter() {
             self.validate_enum_variant_fields(*variant_id);

crates/hir-ty/src/diagnostics/expr.rs

@@ -642,7 +642,7 @@ fn missing_match_arms<'p>(
     }
 
     let non_empty_enum = match scrut_ty.as_adt() {
-        Some((AdtId::EnumId(e), _)) => !cx.db.enum_data(e).variants.is_empty(),
+        Some((AdtId::EnumId(e), _)) => !cx.db.enum_variants(e).variants.is_empty(),
         _ => false,
     };
     let display_target = DisplayTarget::from_crate(cx.db, krate);

crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs

@@ -49,7 +49,7 @@ impl EnumVariantContiguousIndex {
     }
 
     fn to_enum_variant_id(self, db: &dyn HirDatabase, eid: EnumId) -> EnumVariantId {
-        db.enum_data(eid).variants[self.0].0
+        db.enum_variants(eid).variants[self.0].0
     }
 }
 
@@ -449,7 +449,7 @@ impl PatCx for MatchCheckCtx<'_> {
             TyKind::Scalar(Scalar::Int(..) | Scalar::Uint(..)) => unhandled(),
             TyKind::Array(..) | TyKind::Slice(..) => unhandled(),
             &TyKind::Adt(AdtId(adt @ hir_def::AdtId::EnumId(enum_id)), ref subst) => {
-                let enum_data = cx.db.enum_data(enum_id);
+                let enum_data = cx.db.enum_variants(enum_id);
                 let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive(adt);
 
                 if enum_data.variants.is_empty() && !is_declared_nonexhaustive {

crates/hir-ty/src/drop.rs

@@ -72,7 +72,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
                 // Unions cannot have fields with destructors.
                 AdtId::UnionId(_) => DropGlue::None,
                 AdtId::EnumId(id) => db
-                    .enum_data(id)
+                    .enum_variants(id)
                     .variants
                     .iter()
                     .map(|&(variant, _)| {

crates/hir-ty/src/infer.rs

@@ -1587,7 +1587,7 @@ impl<'a> InferenceContext<'a> {
                     // If we can resolve to an enum variant, it takes priority over associated type
                     // of the same name.
                     if let Some((AdtId::EnumId(id), _)) = ty.as_adt() {
-                        let enum_data = self.db.enum_data(id);
+                        let enum_data = self.db.enum_variants(id);
                         if let Some(variant) = enum_data.variant(current_segment.name) {
                             return if remaining_segments.len() == 1 {
                                 (ty, Some(variant.into()))
@@ -1701,7 +1701,7 @@ impl<'a> InferenceContext<'a> {
                 let segment = path.segments().last().unwrap();
                 // this could be an enum variant or associated type
                 if let Some((AdtId::EnumId(enum_id), _)) = ty.as_adt() {
-                    let enum_data = self.db.enum_data(enum_id);
+                    let enum_data = self.db.enum_variants(enum_id);
                     if let Some(variant) = enum_data.variant(segment) {
                         return (ty, Some(variant.into()));
                     }

crates/hir-ty/src/infer/cast.rs

@@ -43,7 +43,7 @@ impl CastTy {
                 let (AdtId::EnumId(id), _) = t.as_adt()? else {
                     return None;
                 };
-                let enum_data = table.db.enum_data(id);
+                let enum_data = table.db.enum_variants(id);
                 if enum_data.is_payload_free(table.db.upcast()) {
                     Some(Self::Int(Int::CEnum))
                 } else {