Merge branch 'master' of https://github.com/rust-analyzer/rust-analyzer into feature/themes

16 files changed, 180 insertions, 111 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);
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 53456fc08..fffb22201 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -35,7 +35,7 @@ impl Attrs {
         match def {
             AttrDefId::ModuleId(module) => {
                 let def_map = db.crate_def_map(module.krate);
-                let src = match def_map[module.module_id].declaration_source(db) {
+                let src = match def_map[module.local_id].declaration_source(db) {
                     Some(it) => it,
                     None => return Attrs::default(),
                 };
@@ -54,9 +54,9 @@ impl Attrs {
                 Attrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
             }
             AttrDefId::AdtId(it) => match it {
-                AdtId::StructId(it) => attrs_from_ast(it.0.lookup_intern(db).ast_id, db),
+                AdtId::StructId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
                 AdtId::EnumId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
-                AdtId::UnionId(it) => attrs_from_ast(it.0.lookup_intern(db).ast_id, db),
+                AdtId::UnionId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
             },
             AttrDefId::TraitId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
             AttrDefId::MacroDefId(it) => attrs_from_ast(it.ast_id, db),
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index d77ccb272..a57a0176d 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -6,8 +6,7 @@ pub mod scope;
 use std::{ops::Index, sync::Arc};
 
 use hir_expand::{
-    either::Either, hygiene::Hygiene, AstId, HirFileId, MacroCallLoc, MacroDefId, MacroFileKind,
-    Source,
+    either::Either, hygiene::Hygiene, AstId, HirFileId, MacroDefId, MacroFileKind, Source,
 };
 use ra_arena::{map::ArenaMap, Arena};
 use ra_syntax::{ast, AstNode, AstPtr};
@@ -47,7 +46,7 @@ impl Expander {
 
         if let Some(path) = macro_call.path().and_then(|path| self.parse_path(path)) {
             if let Some(def) = self.resolve_path_as_macro(db, &path) {
-                let call_id = db.intern_macro(MacroCallLoc { def, ast_id });
+                let call_id = def.as_call_id(db, ast_id);
                 let file_id = call_id.as_file(MacroFileKind::Expr);
                 if let Some(node) = db.parse_or_expand(file_id) {
                     if let Some(expr) = ast::Expr::cast(node) {
@@ -83,7 +82,7 @@ impl Expander {
     }
 
     fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
-        self.crate_def_map.resolve_path(db, self.module.module_id, path).0.take_macros()
+        self.crate_def_map.resolve_path(db, self.module.local_id, path).0.take_macros()
     }
 }
 
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 68bea34df..fee10b237 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -86,39 +86,53 @@ impl TypeAliasData {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TraitData {
-    pub name: Option<Name>,
-    pub items: Vec<AssocItemId>,
+    pub name: Name,
+    pub items: Vec<(Name, AssocItemId)>,
     pub auto: bool,
 }
 
 impl TraitData {
     pub(crate) fn trait_data_query(db: &impl DefDatabase, tr: TraitId) -> Arc<TraitData> {
         let src = tr.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 auto = src.value.is_auto();
         let ast_id_map = db.ast_id_map(src.file_id);
+
+        let container = ContainerId::TraitId(tr);
         let items = if let Some(item_list) = src.value.item_list() {
             item_list
                 .impl_items()
                 .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => FunctionLoc {
-                        container: ContainerId::TraitId(tr),
-                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    ast::ImplItem::FnDef(it) => {
+                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                        let def = FunctionLoc {
+                            container,
+                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                        }
+                        .intern(db)
+                        .into();
+                        (name, def)
                     }
-                    .intern(db)
-                    .into(),
-                    ast::ImplItem::ConstDef(it) => ConstLoc {
-                        container: ContainerId::TraitId(tr),
-                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    ast::ImplItem::ConstDef(it) => {
+                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                        let def = ConstLoc {
+                            container,
+                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                        }
+                        .intern(db)
+                        .into();
+                        (name, def)
                     }
-                    .intern(db)
-                    .into(),
-                    ast::ImplItem::TypeAliasDef(it) => TypeAliasLoc {
-                        container: ContainerId::TraitId(tr),
-                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    ast::ImplItem::TypeAliasDef(it) => {
+                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                        let def = TypeAliasLoc {
+                            container,
+                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                        }
+                        .intern(db)
+                        .into();
+                        (name, def)
                     }
-                    .intern(db)
-                    .into(),
                 })
                 .collect()
         } else {
@@ -128,11 +142,18 @@ impl TraitData {
     }
 
     pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
-        self.items.iter().filter_map(|item| match item {
+        self.items.iter().filter_map(|(_name, item)| match item {
             AssocItemId::TypeAliasId(t) => Some(*t),
             _ => None,
         })
     }
+
+    pub fn associated_type_by_name(&self, name: &Name) -> Option<TypeAliasId> {
+        self.items.iter().find_map(|(item_name, item)| match item {
+            AssocItemId::TypeAliasId(t) if item_name == name => Some(*t),
+            _ => None,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -193,6 +214,7 @@ impl ImplData {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConstData {
+    /// const _: () = ();
     pub name: Option<Name>,
     pub type_ref: TypeRef,
 }
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 32adb11bd..ef5611ffc 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -18,8 +18,8 @@ use crate::{
         CrateDefMap,
     },
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, FunctionId, FunctionLoc, GenericDefId,
-    ImplId, ItemLoc, ModuleId, StaticId, StaticLoc, StructOrUnionId, TraitId, TypeAliasId,
-    TypeAliasLoc,
+    ImplId, ItemLoc, ModuleId, StaticId, StaticLoc, StructId, TraitId, TypeAliasId, TypeAliasLoc,
+    UnionId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
@@ -27,7 +27,9 @@ pub trait InternDatabase: SourceDatabase {
     #[salsa::interned]
     fn intern_function(&self, loc: FunctionLoc) -> FunctionId;
     #[salsa::interned]
-    fn intern_struct_or_union(&self, loc: ItemLoc<ast::StructDef>) -> StructOrUnionId;
+    fn intern_struct(&self, loc: ItemLoc<ast::StructDef>) -> StructId;
+    #[salsa::interned]
+    fn intern_union(&self, loc: ItemLoc<ast::UnionDef>) -> UnionId;
     #[salsa::interned]
     fn intern_enum(&self, loc: ItemLoc<ast::EnumDef>) -> EnumId;
     #[salsa::interned]
@@ -57,7 +59,9 @@ pub trait DefDatabase: InternDatabase + AstDatabase {
     fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
 
     #[salsa::invoke(StructData::struct_data_query)]
-    fn struct_data(&self, id: StructOrUnionId) -> Arc<StructData>;
+    fn struct_data(&self, id: StructId) -> Arc<StructData>;
+    #[salsa::invoke(StructData::union_data_query)]
+    fn union_data(&self, id: UnionId) -> Arc<StructData>;
 
     #[salsa::invoke(EnumData::enum_data_query)]
     fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
diff --git a/crates/ra_hir_def/src/docs.rs b/crates/ra_hir_def/src/docs.rs
index 90a8627bc..34ed9b7a5 100644
--- a/crates/ra_hir_def/src/docs.rs
+++ b/crates/ra_hir_def/src/docs.rs
@@ -36,7 +36,7 @@ impl Documentation {
         match def {
             AttrDefId::ModuleId(module) => {
                 let def_map = db.crate_def_map(module.krate);
-                let src = def_map[module.module_id].declaration_source(db)?;
+                let src = def_map[module.local_id].declaration_source(db)?;
                 docs_from_ast(&src.value)
             }
             AttrDefId::StructFieldId(it) => {
@@ -47,9 +47,9 @@ impl Documentation {
                 }
             }
             AttrDefId::AdtId(it) => match it {
-                AdtId::StructId(it) => docs_from_ast(&it.0.source(db).value),
+                AdtId::StructId(it) => docs_from_ast(&it.source(db).value),
                 AdtId::EnumId(it) => docs_from_ast(&it.source(db).value),
-                AdtId::UnionId(it) => docs_from_ast(&it.0.source(db).value),
+                AdtId::UnionId(it) => docs_from_ast(&it.source(db).value),
             },
             AttrDefId::EnumVariantId(it) => {
                 let src = it.parent.child_source(db);
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index 015fe772e..3f94e40e4 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -60,10 +60,8 @@ impl GenericParams {
         // FIXME: add `: Sized` bound for everything except for `Self` in traits
         match def {
             GenericDefId::FunctionId(it) => generics.fill(&it.lookup(db).source(db).value, start),
-            GenericDefId::AdtId(AdtId::StructId(it)) => {
-                generics.fill(&it.0.source(db).value, start)
-            }
-            GenericDefId::AdtId(AdtId::UnionId(it)) => generics.fill(&it.0.source(db).value, start),
+            GenericDefId::AdtId(AdtId::StructId(it)) => generics.fill(&it.source(db).value, start),
+            GenericDefId::AdtId(AdtId::UnionId(it)) => generics.fill(&it.source(db).value, start),
             GenericDefId::AdtId(AdtId::EnumId(it)) => generics.fill(&it.source(db).value, start),
             GenericDefId::TraitId(it) => {
                 // traits get the Self type as an implicit first type parameter
diff --git a/crates/ra_hir_def/src/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
index f15c23db9..f4fdbdcfc 100644
--- a/crates/ra_hir_def/src/lang_item.rs
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -41,7 +41,7 @@ impl LangItems {
         crate_def_map
             .modules
             .iter()
-            .filter_map(|(module_id, _)| db.module_lang_items(ModuleId { krate, module_id }))
+            .filter_map(|(local_id, _)| db.module_lang_items(ModuleId { krate, local_id }))
             .for_each(|it| lang_items.items.extend(it.items.iter().map(|(k, v)| (k.clone(), *v))));
 
         Arc::new(lang_items)
@@ -80,7 +80,7 @@ impl LangItems {
     fn collect_lang_items(&mut self, db: &impl DefDatabase, module: ModuleId) {
         // Look for impl targets
         let def_map = db.crate_def_map(module.krate);
-        let module_data = &def_map[module.module_id];
+        let module_data = &def_map[module.local_id];
         for &impl_block in module_data.impls.iter() {
             self.collect_lang_item(db, impl_block, LangItemTarget::ImplBlockId)
         }
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 8e8c2d749..bc5530896 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -27,7 +27,7 @@ pub mod body;
 pub mod resolver;
 
 mod trace;
-mod nameres;
+pub mod nameres;
 
 #[cfg(test)]
 mod test_db;
@@ -50,7 +50,7 @@ impl_arena_id!(LocalImportId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
     pub krate: CrateId,
-    pub module_id: LocalModuleId,
+    pub local_id: LocalModuleId,
 }
 
 /// An ID of a module, **local** to a specific crate
@@ -141,30 +141,26 @@ impl Lookup for FunctionId {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct StructOrUnionId(salsa::InternId);
-impl_intern_key!(StructOrUnionId);
-impl AstItemDef<ast::StructDef> for StructOrUnionId {
+pub struct StructId(salsa::InternId);
+impl_intern_key!(StructId);
+impl AstItemDef<ast::StructDef> for StructId {
     fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::StructDef>) -> Self {
-        db.intern_struct_or_union(loc)
+        db.intern_struct(loc)
     }
     fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::StructDef> {
-        db.lookup_intern_struct_or_union(self)
+        db.lookup_intern_struct(self)
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct StructId(pub StructOrUnionId);
-impl From<StructId> for StructOrUnionId {
-    fn from(id: StructId) -> StructOrUnionId {
-        id.0
+pub struct UnionId(salsa::InternId);
+impl_intern_key!(UnionId);
+impl AstItemDef<ast::UnionDef> for UnionId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::UnionDef>) -> Self {
+        db.intern_union(loc)
     }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct UnionId(pub StructOrUnionId);
-impl From<UnionId> for StructOrUnionId {
-    fn from(id: UnionId) -> StructOrUnionId {
-        id.0
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::UnionDef> {
+        db.lookup_intern_union(self)
     }
 }
 
@@ -402,6 +398,16 @@ impl_froms!(
     ConstId
 );
 
+impl From<AssocItemId> for GenericDefId {
+    fn from(item: AssocItemId) -> Self {
+        match item {
+            AssocItemId::FunctionId(f) => f.into(),
+            AssocItemId::ConstId(c) => c.into(),
+            AssocItemId::TypeAliasId(t) => t.into(),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AttrDefId {
     ModuleId(ModuleId),
@@ -435,6 +441,7 @@ impl_froms!(
 pub enum VariantId {
     EnumVariantId(EnumVariantId),
     StructId(StructId),
+    UnionId(UnionId),
 }
 impl_froms!(VariantId: EnumVariantId, StructId);
 
@@ -485,13 +492,23 @@ impl HasModule for ConstLoc {
 impl HasModule for AdtId {
     fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
         match self {
-            AdtId::StructId(it) => it.0.module(db),
-            AdtId::UnionId(it) => it.0.module(db),
+            AdtId::StructId(it) => it.module(db),
+            AdtId::UnionId(it) => it.module(db),
             AdtId::EnumId(it) => it.module(db),
         }
     }
 }
 
+impl HasModule for DefWithBodyId {
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
+        match self {
+            DefWithBodyId::FunctionId(it) => it.lookup(db).module(db),
+            DefWithBodyId::StaticId(it) => it.lookup(db).module(db),
+            DefWithBodyId::ConstId(it) => it.lookup(db).module(db),
+        }
+    }
+}
+
 impl HasModule for StaticLoc {
     fn module(&self, _db: &impl db::DefDatabase) -> ModuleId {
         self.container
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 41becf8df..fd8245113 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -6,7 +6,7 @@
 use hir_expand::{
     builtin_macro::find_builtin_macro,
     name::{self, AsName, Name},
-    HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind, MacroFileKind,
+    HirFileId, MacroCallId, MacroDefId, MacroDefKind, MacroFileKind,
 };
 use ra_cfg::CfgOptions;
 use ra_db::{CrateId, FileId};
@@ -25,7 +25,7 @@ use crate::{
     per_ns::PerNs,
     AdtId, AstId, AstItemDef, ConstLoc, ContainerId, EnumId, EnumVariantId, FunctionLoc, ImplId,
     Intern, LocalImportId, LocalModuleId, LocationCtx, ModuleDefId, ModuleId, StaticLoc, StructId,
-    StructOrUnionId, TraitId, TypeAliasLoc, UnionId,
+    TraitId, TypeAliasLoc, UnionId,
 };
 
 pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -37,7 +37,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
         log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
         def_map.extern_prelude.insert(
             dep.as_name(),
-            ModuleId { krate: dep.crate_id, module_id: dep_def_map.root }.into(),
+            ModuleId { krate: dep.crate_id, local_id: dep_def_map.root }.into(),
         );
 
         // look for the prelude
@@ -323,7 +323,7 @@ where
                         tested_by!(glob_across_crates);
                         // glob import from other crate => we can just import everything once
                         let item_map = self.db.crate_def_map(m.krate);
-                        let scope = &item_map[m.module_id].scope;
+                        let scope = &item_map[m.local_id].scope;
 
                         // Module scoped macros is included
                         let items = scope
@@ -337,7 +337,7 @@ where
                         // glob import from same crate => we do an initial
                         // import, and then need to propagate any further
                         // additions
-                        let scope = &self.def_map[m.module_id].scope;
+                        let scope = &self.def_map[m.local_id].scope;
 
                         // Module scoped macros is included
                         let items = scope
@@ -349,7 +349,7 @@ where
                         self.update(module_id, Some(import_id), &items);
                         // record the glob import in case we add further items
                         self.glob_imports
-                            .entry(m.module_id)
+                            .entry(m.local_id)
                             .or_default()
                             .push((module_id, import_id));
                     }
@@ -362,7 +362,7 @@ where
                         .variants
                         .iter()
                         .filter_map(|(local_id, variant_data)| {
-                            let name = variant_data.name.clone()?;
+                            let name = variant_data.name.clone();
                             let variant = EnumVariantId { parent: e, local_id };
                             let res = Resolution {
                                 def: PerNs::both(variant.into(), variant.into()),
@@ -480,7 +480,7 @@ where
             );
 
             if let Some(def) = resolved_res.resolved_def.take_macros() {
-                let call_id = self.db.intern_macro(MacroCallLoc { def, ast_id: *ast_id });
+                let call_id = def.as_call_id(self.db, *ast_id);
                 resolved.push((*module_id, call_id, def));
                 res = ReachedFixedPoint::No;
                 return false;
@@ -590,7 +590,7 @@ where
                     raw::RawItemKind::Impl(imp) => {
                         let module = ModuleId {
                             krate: self.def_collector.def_map.krate,
-                            module_id: self.module_id,
+                            local_id: self.module_id,
                         };
                         let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
                         let imp_id = ImplId::from_ast_id(ctx, self.raw_items[imp].ast_id);
@@ -673,7 +673,7 @@ where
         modules[self.module_id].children.insert(name.clone(), res);
         let resolution = Resolution {
             def: PerNs::types(
-                ModuleId { krate: self.def_collector.def_map.krate, module_id: res }.into(),
+                ModuleId { krate: self.def_collector.def_map.krate, local_id: res }.into(),
             ),
             import: None,
         };
@@ -682,8 +682,7 @@ where
     }
 
     fn define_def(&mut self, def: &raw::DefData) {
-        let module =
-            ModuleId { krate: self.def_collector.def_map.krate, module_id: self.module_id };
+        let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
         let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
 
         let name = def.name.clone();
@@ -698,14 +697,12 @@ where
                 PerNs::values(def.into())
             }
             raw::DefKind::Struct(ast_id) => {
-                let id = StructOrUnionId::from_ast_id(ctx, ast_id).into();
-                let s = StructId(id).into();
-                PerNs::both(s, s)
+                let id = StructId::from_ast_id(ctx, ast_id).into();
+                PerNs::both(id, id)
             }
             raw::DefKind::Union(ast_id) => {
-                let id = StructOrUnionId::from_ast_id(ctx, ast_id).into();
-                let u = UnionId(id).into();
-                PerNs::both(u, u)
+                let id = UnionId::from_ast_id(ctx, ast_id).into();
+                PerNs::both(id, id)
             }
             raw::DefKind::Enum(ast_id) => PerNs::types(EnumId::from_ast_id(ctx, ast_id).into()),
             raw::DefKind::Const(ast_id) => {
@@ -775,8 +772,7 @@ where
         if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
             self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
         }) {
-            let macro_call_id =
-                self.def_collector.db.intern_macro(MacroCallLoc { def: macro_def, ast_id });
+            let macro_call_id = macro_def.as_call_id(self.def_collector.db, ast_id);
 
             self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, macro_def);
             return;
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 9455f22bb..b72c55bd1 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -74,19 +74,19 @@ impl CrateDefMap {
             PathKind::DollarCrate(krate) => {
                 if krate == self.krate {
                     tested_by!(macro_dollar_crate_self);
-                    PerNs::types(ModuleId { krate: self.krate, module_id: self.root }.into())
+                    PerNs::types(ModuleId { krate: self.krate, local_id: self.root }.into())
                 } else {
                     let def_map = db.crate_def_map(krate);
-                    let module = ModuleId { krate, module_id: def_map.root };
+                    let module = ModuleId { krate, local_id: def_map.root };
                     tested_by!(macro_dollar_crate_other);
                     PerNs::types(module.into())
                 }
             }
             PathKind::Crate => {
-                PerNs::types(ModuleId { krate: self.krate, module_id: self.root }.into())
+                PerNs::types(ModuleId { krate: self.krate, local_id: self.root }.into())
             }
             PathKind::Self_ => {
-                PerNs::types(ModuleId { krate: self.krate, module_id: original_module }.into())
+                PerNs::types(ModuleId { krate: self.krate, local_id: original_module }.into())
             }
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
@@ -113,7 +113,7 @@ impl CrateDefMap {
             }
             PathKind::Super => {
                 if let Some(p) = self.modules[original_module].parent {
-                    PerNs::types(ModuleId { krate: self.krate, module_id: p }.into())
+                    PerNs::types(ModuleId { krate: self.krate, local_id: p }.into())
                 } else {
                     log::debug!("super path in root module");
                     return ResolvePathResult::empty(ReachedFixedPoint::Yes);
@@ -160,7 +160,7 @@ impl CrateDefMap {
                             Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ };
                         log::debug!("resolving {:?} in other crate", path);
                         let defp_map = db.crate_def_map(module.krate);
-                        let (def, s) = defp_map.resolve_path(db, module.module_id, &path);
+                        let (def, s) = defp_map.resolve_path(db, module.local_id, &path);
                         return ResolvePathResult::with(
                             def,
                             ReachedFixedPoint::Yes,
@@ -169,7 +169,7 @@ impl CrateDefMap {
                     }
 
                     // Since it is a qualified path here, it should not contains legacy macros
-                    match self[module.module_id].scope.get(&segment.name) {
+                    match self[module.local_id].scope.get(&segment.name) {
                         Some(res) => res.def,
                         _ => {
                             log::debug!("path segment {:?} not found", segment.name);
@@ -254,7 +254,7 @@ impl CrateDefMap {
                 keep = db.crate_def_map(prelude.krate);
                 &keep
             };
-            def_map[prelude.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
+            def_map[prelude.local_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
         } else {
             PerNs::none()
         }
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 401af031c..6eb106094 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -176,7 +176,7 @@ pub(super) struct DefData {
 pub(super) enum DefKind {
     Function(FileAstId<ast::FnDef>),
     Struct(FileAstId<ast::StructDef>),
-    Union(FileAstId<ast::StructDef>),
+    Union(FileAstId<ast::UnionDef>),
     Enum(FileAstId<ast::EnumDef>),
     Const(FileAstId<ast::ConstDef>),
     Static(FileAstId<ast::StaticDef>),
@@ -246,11 +246,12 @@ impl RawItemsCollector {
             ast::ModuleItem::StructDef(it) => {
                 let id = self.source_ast_id_map.ast_id(&it);
                 let name = it.name();
-                if it.is_union() {
-                    (DefKind::Union(id), name)
-                } else {
-                    (DefKind::Struct(id), name)
-                }
+                (DefKind::Struct(id), name)
+            }
+            ast::ModuleItem::UnionDef(it) => {
+                let id = self.source_ast_id_map.ast_id(&it);
+                let name = it.name();
+                (DefKind::Union(id), name)
             }
             ast::ModuleItem::EnumDef(it) => {
                 (DefKind::Enum(self.source_ast_id_map.ast_id(&it)), it.name())
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index f502f1cb3..87fcd617c 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -82,6 +82,12 @@ fn crate_def_map_smoke_test() {
 
         //- /foo/bar.rs
         pub struct Baz;
+
+        union U {
+            to_be: bool,
+            not_to_be: u8,
+        }
+
         enum E { V }
         ",
     );
@@ -99,6 +105,7 @@ fn crate_def_map_smoke_test() {
         ⋮crate::foo::bar
         ⋮Baz: t v
         ⋮E: t
+        ⋮U: t v
     "###)
 }
 
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 0e606fd0e..6810a26db 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -97,7 +97,7 @@ impl Path {
 
     /// Converts an `ast::Path` to `Path`. Works with use trees.
     /// It correctly handles `$crate` based path from macro call.
-    pub(crate) fn from_src(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
+    pub fn from_src(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
         let mut kind = PathKind::Plain;
         let mut segments = Vec::new();
         loop {
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 95b3c926d..0847f6dcf 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -61,6 +61,8 @@ pub enum TypeNs {
     GenericParam(u32),
     AdtId(AdtId),
     AdtSelfType(AdtId),
+    // Yup, enum variants are added to the types ns, but any usage of variant as
+    // type is an error.
     EnumVariantId(EnumVariantId),
     TypeAliasId(TypeAliasId),
     BuiltinType(BuiltinType),
@@ -323,7 +325,7 @@ impl Resolver {
             if let Scope::ModuleScope(m) = scope {
                 if let Some(prelude) = m.crate_def_map.prelude {
                     let prelude_def_map = db.crate_def_map(prelude.krate);
-                    traits.extend(prelude_def_map[prelude.module_id].scope.traits());
+                    traits.extend(prelude_def_map[prelude.local_id].scope.traits());
                 }
                 traits.extend(m.crate_def_map[m.module_id].scope.traits());
             }
@@ -400,7 +402,7 @@ impl Scope {
                 });
                 if let Some(prelude) = m.crate_def_map.prelude {
                     let prelude_def_map = db.crate_def_map(prelude.krate);
-                    prelude_def_map[prelude.module_id].scope.entries().for_each(|(name, res)| {
+                    prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, res)| {
                         f(name.clone(), ScopeDef::PerNs(res.def));
                     });
                 }
@@ -482,7 +484,7 @@ impl Resolver {
     }
 }
 
-pub trait HasResolver {
+pub trait HasResolver: Copy {
     /// Builds a resolver for type references inside this def.
     fn resolver(self, db: &impl DefDatabase) -> Resolver;
 }
@@ -490,7 +492,7 @@ pub trait HasResolver {
 impl HasResolver for ModuleId {
     fn resolver(self, db: &impl DefDatabase) -> Resolver {
         let def_map = db.crate_def_map(self.krate);
-        Resolver::default().push_module_scope(def_map, self.module_id)
+        Resolver::default().push_module_scope(def_map, self.local_id)
     }
 }
 
@@ -500,7 +502,7 @@ impl HasResolver for TraitId {
     }
 }
 
-impl<T: Into<AdtId>> HasResolver for T {
+impl<T: Into<AdtId> + Copy> HasResolver for T {
     fn resolver(self, db: &impl DefDatabase) -> Resolver {
         let def = self.into();
         def.module(db)
diff --git a/crates/ra_hir_def/src/test_db.rs b/crates/ra_hir_def/src/test_db.rs
index 439e8a412..54e3a84bd 100644
--- a/crates/ra_hir_def/src/test_db.rs
+++ b/crates/ra_hir_def/src/test_db.rs
@@ -24,7 +24,9 @@ impl salsa::Database for TestDB {
     fn salsa_runtime(&self) -> &salsa::Runtime<Self> {
         &self.runtime
     }
-
+    fn salsa_runtime_mut(&mut self) -> &mut salsa::Runtime<Self> {
+        &mut self.runtime
+    }
     fn salsa_event(&self, event: impl Fn() -> salsa::Event<TestDB>) {
         let mut events = self.events.lock().unwrap();
         if let Some(events) = &mut *events {