6 files changed, 74 insertions, 19 deletions

diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index e4ffdebe9..d6d32fb8c 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -14,13 +14,13 @@ use crate::{
         CrateDefMap,
     },
     traits::{TraitData, TraitItemsIndex},
-    DefWithBodyId, EnumId, FunctionLoc, ImplId, ItemLoc, ModuleId, StructOrUnionId, TraitId,
+    DefWithBodyId, EnumId, ImplId, ItemLoc, ModuleId, StructOrUnionId, TraitId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
 pub trait InternDatabase: SourceDatabase {
     #[salsa::interned]
-    fn intern_function(&self, loc: FunctionLoc) -> crate::FunctionId;
+    fn intern_function(&self, loc: crate::FunctionLoc) -> crate::FunctionId;
     #[salsa::interned]
     fn intern_struct_or_union(&self, loc: ItemLoc<ast::StructDef>) -> crate::StructOrUnionId;
     #[salsa::interned]
@@ -32,7 +32,7 @@ pub trait InternDatabase: SourceDatabase {
     #[salsa::interned]
     fn intern_trait(&self, loc: ItemLoc<ast::TraitDef>) -> crate::TraitId;
     #[salsa::interned]
-    fn intern_type_alias(&self, loc: ItemLoc<ast::TypeAliasDef>) -> crate::TypeAliasId;
+    fn intern_type_alias(&self, loc: crate::TypeAliasLoc) -> crate::TypeAliasId;
     #[salsa::interned]
     fn intern_impl(&self, loc: ItemLoc<ast::ImplBlock>) -> crate::ImplId;
 }
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index 11dd2a948..17a5d5f43 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -72,7 +72,7 @@ impl GenericParams {
                 let self_param = TypeRef::Path(name::SELF_TYPE.into());
                 generics.fill_bounds(&it.source(db).value, self_param);
             }
-            GenericDefId::TypeAliasId(it) => generics.fill(&it.source(db).value, start),
+            GenericDefId::TypeAliasId(it) => generics.fill(&it.lookup(db).source(db).value, start),
             // Note that we don't add `Self` here: in `impl`s, `Self` is not a
             // type-parameter, but rather is a type-alias for impl's target
             // type, so this is handled by the resolver.
diff --git a/crates/ra_hir_def/src/impls.rs b/crates/ra_hir_def/src/impls.rs
index 9be38c5e1..703e4d503 100644
--- a/crates/ra_hir_def/src/impls.rs
+++ b/crates/ra_hir_def/src/impls.rs
@@ -10,7 +10,7 @@ use ra_syntax::ast;
 
 use crate::{
     db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstId, FunctionContainerId,
-    FunctionLoc, ImplId, Intern, LocationCtx, TypeAliasId,
+    FunctionLoc, ImplId, Intern, LocationCtx, TypeAliasContainerId, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -36,18 +36,23 @@ impl ImplData {
                 .impl_items()
                 .map(|item_node| match item_node {
                     ast::ImplItem::FnDef(it) => {
-                        let func_id = FunctionLoc {
+                        let def = FunctionLoc {
                             container: FunctionContainerId::ImplId(id),
                             ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                         }
                         .intern(db);
-                        func_id.into()
+                        def.into()
                     }
                     ast::ImplItem::ConstDef(it) => {
                         ConstId::from_ast_id(ctx, items.ast_id(&it)).into()
                     }
                     ast::ImplItem::TypeAliasDef(it) => {
-                        TypeAliasId::from_ast_id(ctx, items.ast_id(&it)).into()
+                        let def = TypeAliasLoc {
+                            container: TypeAliasContainerId::ImplId(id),
+                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
+                        }
+                        .intern(db);
+                        def.into()
                     }
                 })
                 .collect()
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index b9a13776f..6052370b4 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -332,16 +332,35 @@ impl AstItemDef<ast::TraitDef> for TraitId {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TypeAliasId(salsa::InternId);
 impl_intern_key!(TypeAliasId);
-impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
-    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::TypeAliasDef>) -> Self {
-        db.intern_type_alias(loc)
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TypeAliasLoc {
+    pub container: TypeAliasContainerId,
+    pub ast_id: AstId<ast::TypeAliasDef>,
+}
+
+impl Intern for TypeAliasLoc {
+    type ID = TypeAliasId;
+    fn intern(self, db: &impl db::DefDatabase2) -> TypeAliasId {
+        db.intern_type_alias(self)
     }
-    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::TypeAliasDef> {
-        db.lookup_intern_type_alias(self)
+}
+
+impl Lookup for TypeAliasId {
+    type Data = TypeAliasLoc;
+    fn lookup(&self, db: &impl db::DefDatabase2) -> TypeAliasLoc {
+        db.lookup_intern_type_alias(*self)
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TypeAliasContainerId {
+    ModuleId(ModuleId),
+    ImplId(ImplId),
+    TraitId(TraitId),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ImplId(salsa::InternId);
 impl_intern_key!(ImplId);
 impl AstItemDef<ast::ImplBlock> for ImplId {
@@ -476,6 +495,16 @@ impl HasModule for FunctionLoc {
     }
 }
 
+impl HasModule for TypeAliasLoc {
+    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+        match self.container {
+            TypeAliasContainerId::ModuleId(it) => it,
+            TypeAliasContainerId::ImplId(it) => it.module(db),
+            TypeAliasContainerId::TraitId(it) => it.module(db),
+        }
+    }
+}
+
 pub trait HasSource {
     type Value;
     fn source(&self, db: &impl db::DefDatabase2) -> Source<Self::Value>;
@@ -489,3 +518,12 @@ impl HasSource for FunctionLoc {
         Source::new(self.ast_id.file_id(), node)
     }
 }
+
+impl HasSource for TypeAliasLoc {
+    type Value = ast::TypeAliasDef;
+
+    fn source(&self, db: &impl db::DefDatabase2) -> Source<ast::TypeAliasDef> {
+        let node = self.ast_id.to_node(db);
+        Source::new(self.ast_id.file_id(), node)
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index d2ed94a87..060185b61 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -21,7 +21,7 @@ use crate::{
     path::{Path, PathKind},
     AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionContainerId,
     FunctionLoc, ImplId, Intern, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
-    StructOrUnionId, TraitId, TypeAliasId, UnionId,
+    StructOrUnionId, TraitId, TypeAliasContainerId, TypeAliasLoc, UnionId,
 };
 
 pub(super) fn collect_defs(db: &impl DefDatabase2, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -673,13 +673,13 @@ where
         let name = def.name.clone();
         let def: PerNs = match def.kind {
             raw::DefKind::Function(ast_id) => {
-                let f = FunctionLoc {
+                let def = FunctionLoc {
                     container: FunctionContainerId::ModuleId(module),
                     ast_id: AstId::new(self.file_id, ast_id),
                 }
                 .intern(self.def_collector.db);
 
-                PerNs::values(f.into())
+                PerNs::values(def.into())
             }
             raw::DefKind::Struct(ast_id) => {
                 let id = StructOrUnionId::from_ast_id(ctx, ast_id).into();
@@ -698,7 +698,13 @@ where
             }
             raw::DefKind::Trait(ast_id) => PerNs::types(TraitId::from_ast_id(ctx, ast_id).into()),
             raw::DefKind::TypeAlias(ast_id) => {
-                PerNs::types(TypeAliasId::from_ast_id(ctx, ast_id).into())
+                let def = TypeAliasLoc {
+                    container: TypeAliasContainerId::ModuleId(module),
+                    ast_id: AstId::new(self.file_id, ast_id),
+                }
+                .intern(self.def_collector.db);
+
+                PerNs::types(def.into())
             }
         };
         let resolution = Resolution { def, import: None };
diff --git a/crates/ra_hir_def/src/traits.rs b/crates/ra_hir_def/src/traits.rs
index 6e36bc0d0..228524a57 100644
--- a/crates/ra_hir_def/src/traits.rs
+++ b/crates/ra_hir_def/src/traits.rs
@@ -12,7 +12,7 @@ use rustc_hash::FxHashMap;
 
 use crate::{
     db::DefDatabase2, AssocItemId, AstItemDef, ConstId, FunctionContainerId, FunctionLoc, Intern,
-    LocationCtx, ModuleDefId, ModuleId, TraitId, TypeAliasId,
+    LocationCtx, ModuleDefId, ModuleId, TraitId, TypeAliasContainerId, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -41,7 +41,12 @@ impl TraitData {
                     .intern(db)
                     .into(),
                     ast::ImplItem::ConstDef(it) => ConstId::from_ast(ctx, &it).into(),
-                    ast::ImplItem::TypeAliasDef(it) => TypeAliasId::from_ast(ctx, &it).into(),
+                    ast::ImplItem::TypeAliasDef(it) => TypeAliasLoc {
+                        container: TypeAliasContainerId::TraitId(tr),
+                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    }
+                    .intern(db)
+                    .into(),
                 })
                 .collect()
         } else {
@@ -65,6 +70,7 @@ impl TraitItemsIndex {
                 for item in db.trait_data(tr).items.iter() {
                     match item {
                         AssocItemId::FunctionId(_) => (),
+                        AssocItemId::TypeAliasId(_) => (),
                         _ => {
                             let prev = index.traits_by_def.insert(*item, tr);
                             assert!(prev.is_none());