1 files changed, 32 insertions, 11 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index c9f30923e..3666529b0 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -12,25 +12,25 @@ use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
 
 use crate::{
     db::DefDatabase, trace::Trace, type_ref::TypeRef, AstItemDef, EnumId, HasChildSource,
-    LocalEnumVariantId, LocalStructFieldId, StructOrUnionId, VariantId,
+    LocalEnumVariantId, LocalStructFieldId, StructId, UnionId, VariantId,
 };
 
 /// Note that we use `StructData` for unions as well!
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StructData {
-    pub name: Option<Name>,
+    pub name: Name,
     pub variant_data: Arc<VariantData>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EnumData {
-    pub name: Option<Name>,
+    pub name: Name,
     pub variants: Arena<LocalEnumVariantId, EnumVariantData>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EnumVariantData {
-    pub name: Option<Name>,
+    pub name: Name,
     pub variant_data: Arc<VariantData>,
 }
 
@@ -49,26 +49,38 @@ pub struct StructFieldData {
 }
 
 impl StructData {
-    pub(crate) fn struct_data_query(db: &impl DefDatabase, id: StructOrUnionId) -> Arc<StructData> {
+    pub(crate) fn struct_data_query(db: &impl DefDatabase, id: StructId) -> Arc<StructData> {
         let src = id.source(db);
-        let name = src.value.name().map(|n| n.as_name());
+        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
         let variant_data = VariantData::new(src.value.kind());
         let variant_data = Arc::new(variant_data);
         Arc::new(StructData { name, variant_data })
     }
+    pub(crate) fn union_data_query(db: &impl DefDatabase, id: UnionId) -> Arc<StructData> {
+        let src = id.source(db);
+        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
+        let variant_data = VariantData::new(
+            src.value
+                .record_field_def_list()
+                .map(ast::StructKind::Record)
+                .unwrap_or(ast::StructKind::Unit),
+        );
+        let variant_data = Arc::new(variant_data);
+        Arc::new(StructData { name, variant_data })
+    }
 }
 
 impl EnumData {
     pub(crate) fn enum_data_query(db: &impl DefDatabase, e: EnumId) -> Arc<EnumData> {
         let src = e.source(db);
-        let name = src.value.name().map(|n| n.as_name());
+        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
         let mut trace = Trace::new_for_arena();
         lower_enum(&mut trace, &src.value);
         Arc::new(EnumData { name, variants: trace.into_arena() })
     }
 
-    pub(crate) fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
-        let (id, _) = self.variants.iter().find(|(_id, data)| data.name.as_ref() == Some(name))?;
+    pub fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
+        let (id, _) = self.variants.iter().find(|(_id, data)| &data.name == name)?;
         Some(id)
     }
 }
@@ -92,7 +104,7 @@ fn lower_enum(
         trace.alloc(
             || var.clone(),
             || EnumVariantData {
-                name: var.name().map(|it| it.as_name()),
+                name: var.name().map_or_else(Name::missing, |it| it.as_name()),
                 variant_data: Arc::new(VariantData::new(var.kind())),
             },
         );
@@ -117,6 +129,10 @@ impl VariantData {
         }
     }
 
+    pub fn field(&self, name: &Name) -> Option<LocalStructFieldId> {
+        self.fields().iter().find_map(|(id, data)| if &data.name == name { Some(id) } else { None })
+    }
+
     pub fn is_unit(&self) -> bool {
         match self {
             VariantData::Unit => true,
@@ -137,7 +153,12 @@ impl HasChildSource for VariantId {
                 let src = it.parent.child_source(db);
                 src.map(|map| map[it.local_id].kind())
             }
-            VariantId::StructId(it) => it.0.source(db).map(|it| it.kind()),
+            VariantId::StructId(it) => it.source(db).map(|it| it.kind()),
+            VariantId::UnionId(it) => it.source(db).map(|it| {
+                it.record_field_def_list()
+                    .map(ast::StructKind::Record)
+                    .unwrap_or(ast::StructKind::Unit)
+            }),
         };
         let mut trace = Trace::new_for_map();
         lower_struct(&mut trace, &src.value);