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

13 files changed, 498 insertions, 59 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index a29c4d41e..d04f54e15 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -54,8 +54,8 @@ impl StructData {
         id: StructOrUnionId,
     ) -> Arc<StructData> {
         let src = id.source(db);
-        let name = src.ast.name().map(|n| n.as_name());
-        let variant_data = VariantData::new(src.ast.kind());
+        let name = src.value.name().map(|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 })
     }
@@ -64,9 +64,9 @@ impl StructData {
 impl EnumData {
     pub(crate) fn enum_data_query(db: &impl DefDatabase2, e: EnumId) -> Arc<EnumData> {
         let src = e.source(db);
-        let name = src.ast.name().map(|n| n.as_name());
+        let name = src.value.name().map(|n| n.as_name());
         let variants = src
-            .ast
+            .value
             .variant_list()
             .into_iter()
             .flat_map(|it| it.variants())
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 85dc4feb0..dfb79a30a 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -17,7 +17,7 @@ use crate::{
     expr::{Expr, ExprId, Pat, PatId},
     nameres::CrateDefMap,
     path::Path,
-    AstItemDef, DefWithBodyId, ModuleId,
+    AstItemDef, DefWithBodyId, HasModule, HasSource, Lookup, ModuleId,
 };
 
 pub struct Expander {
@@ -73,8 +73,8 @@ impl Expander {
         std::mem::forget(mark);
     }
 
-    fn to_source<T>(&self, ast: T) -> Source<T> {
-        Source { file_id: self.current_file_id, ast }
+    fn to_source<T>(&self, value: T) -> Source<T> {
+        Source { file_id: self.current_file_id, value }
     }
 
     fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
@@ -149,17 +149,19 @@ impl Body {
 
         let (file_id, module, body) = match def {
             DefWithBodyId::FunctionId(f) => {
+                let f = f.lookup(db);
                 let src = f.source(db);
-                params = src.ast.param_list();
-                (src.file_id, f.module(db), src.ast.body().map(ast::Expr::from))
+                params = src.value.param_list();
+                (src.file_id, f.module(db), src.value.body().map(ast::Expr::from))
             }
             DefWithBodyId::ConstId(c) => {
+                let c = c.lookup(db);
                 let src = c.source(db);
-                (src.file_id, c.module(db), src.ast.body())
+                (src.file_id, c.module(db), src.value.body())
             }
             DefWithBodyId::StaticId(s) => {
                 let src = s.source(db);
-                (src.file_id, s.module(db), src.ast.body())
+                (src.file_id, s.module(db), src.value.body())
             }
         };
         let expander = Expander::new(db, file_id, module);
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index 10cb87d37..aeb71ff22 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -210,8 +210,9 @@ mod tests {
         let scopes = db.expr_scopes(function.into());
         let (_body, source_map) = db.body_with_source_map(function.into());
 
-        let expr_id =
-            source_map.node_expr(Source { file_id: file_id.into(), ast: &marker.into() }).unwrap();
+        let expr_id = source_map
+            .node_expr(Source { file_id: file_id.into(), value: &marker.into() })
+            .unwrap();
         let scope = scopes.scope_for(expr_id);
 
         let actual = scopes
@@ -317,14 +318,14 @@ mod tests {
         let expr_scope = {
             let expr_ast = name_ref.syntax().ancestors().find_map(ast::Expr::cast).unwrap();
             let expr_id =
-                source_map.node_expr(Source { file_id: file_id.into(), ast: &expr_ast }).unwrap();
+                source_map.node_expr(Source { file_id: file_id.into(), value: &expr_ast }).unwrap();
             scopes.scope_for(expr_id).unwrap()
         };
 
         let resolved = scopes.resolve_name_in_scope(expr_scope, &name_ref.as_name()).unwrap();
         let pat_src = source_map.pat_syntax(resolved.pat()).unwrap();
 
-        let local_name = pat_src.ast.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
+        let local_name = pat_src.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
         assert_eq!(local_name.range(), expected_name.syntax().text_range());
     }
 
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 348aca07f..844f8bbe8 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -8,30 +8,32 @@ use ra_syntax::ast;
 use crate::{
     adt::{EnumData, StructData},
     body::{scope::ExprScopes, Body, BodySourceMap},
-    imp::ImplData,
+    generics::GenericParams,
+    impls::ImplData,
     nameres::{
         raw::{ImportSourceMap, RawItems},
         CrateDefMap,
     },
-    DefWithBodyId, EnumId, ImplId, ItemLoc, StructOrUnionId,
+    traits::TraitData,
+    DefWithBodyId, EnumId, GenericDefId, ImplId, ItemLoc, StructOrUnionId, TraitId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
 pub trait InternDatabase: SourceDatabase {
     #[salsa::interned]
-    fn intern_function(&self, loc: ItemLoc<ast::FnDef>) -> 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]
     fn intern_enum(&self, loc: ItemLoc<ast::EnumDef>) -> crate::EnumId;
     #[salsa::interned]
-    fn intern_const(&self, loc: ItemLoc<ast::ConstDef>) -> crate::ConstId;
+    fn intern_const(&self, loc: crate::ConstLoc) -> crate::ConstId;
     #[salsa::interned]
     fn intern_static(&self, loc: ItemLoc<ast::StaticDef>) -> crate::StaticId;
     #[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;
 }
@@ -59,6 +61,9 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
     #[salsa::invoke(ImplData::impl_data_query)]
     fn impl_data(&self, e: ImplId) -> Arc<ImplData>;
 
+    #[salsa::invoke(TraitData::trait_data_query)]
+    fn trait_data(&self, e: TraitId) -> Arc<TraitData>;
+
     #[salsa::invoke(Body::body_with_source_map_query)]
     fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
 
@@ -67,4 +72,7 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
 
     #[salsa::invoke(ExprScopes::expr_scopes_query)]
     fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
+
+    #[salsa::invoke(GenericParams::generic_params_query)]
+    fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
 }
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index 9843009a5..eda9b2269 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -20,7 +20,7 @@ impl Diagnostic for UnresolvedModule {
         "unresolved module".to_string()
     }
     fn source(&self) -> Source<SyntaxNodePtr> {
-        Source { file_id: self.file, ast: self.decl.into() }
+        Source { file_id: self.file, value: self.decl.into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
new file mode 100644
index 000000000..9e2e4c3cc
--- /dev/null
+++ b/crates/ra_hir_def/src/generics.rs
@@ -0,0 +1,185 @@
+//! Many kinds of items or constructs can have generic parameters: functions,
+//! structs, impls, traits, etc. This module provides a common HIR for these
+//! generic parameters. See also the `Generics` type and the `generics_of` query
+//! in rustc.
+use std::sync::Arc;
+
+use hir_expand::name::{self, AsName, Name};
+use ra_syntax::ast::{self, NameOwner, TypeBoundsOwner, TypeParamsOwner};
+
+use crate::{
+    db::DefDatabase2,
+    type_ref::{TypeBound, TypeRef},
+    AdtId, AstItemDef, ContainerId, GenericDefId, HasSource, Lookup,
+};
+
+/// Data about a generic parameter (to a function, struct, impl, ...).
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct GenericParam {
+    // FIXME: give generic params proper IDs
+    pub idx: u32,
+    pub name: Name,
+    pub default: Option<TypeRef>,
+}
+
+/// Data about the generic parameters of a function, struct, impl, etc.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct GenericParams {
+    pub parent_params: Option<Arc<GenericParams>>,
+    pub params: Vec<GenericParam>,
+    pub where_predicates: Vec<WherePredicate>,
+}
+
+/// A single predicate from a where clause, i.e. `where Type: Trait`. Combined
+/// where clauses like `where T: Foo + Bar` are turned into multiple of these.
+/// It might still result in multiple actual predicates though, because of
+/// associated type bindings like `Iterator<Item = u32>`.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct WherePredicate {
+    pub type_ref: TypeRef,
+    pub bound: TypeBound,
+}
+
+impl GenericParams {
+    pub(crate) fn generic_params_query(
+        db: &impl DefDatabase2,
+        def: GenericDefId,
+    ) -> Arc<GenericParams> {
+        let parent_generics = parent_generic_def(db, def).map(|it| db.generic_params(it));
+        Arc::new(GenericParams::new(db, def.into(), parent_generics))
+    }
+
+    fn new(
+        db: &impl DefDatabase2,
+        def: GenericDefId,
+        parent_params: Option<Arc<GenericParams>>,
+    ) -> GenericParams {
+        let mut generics =
+            GenericParams { params: Vec::new(), parent_params, where_predicates: Vec::new() };
+        let start = generics.parent_params.as_ref().map(|p| p.params.len()).unwrap_or(0) as u32;
+        // 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::EnumId(it)) => generics.fill(&it.source(db).value, start),
+            GenericDefId::TraitId(it) => {
+                // traits get the Self type as an implicit first type parameter
+                generics.params.push(GenericParam {
+                    idx: start,
+                    name: name::SELF_TYPE,
+                    default: None,
+                });
+                generics.fill(&it.source(db).value, start + 1);
+                // add super traits as bounds on Self
+                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
+                let self_param = TypeRef::Path(name::SELF_TYPE.into());
+                generics.fill_bounds(&it.source(db).value, self_param);
+            }
+            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.
+            GenericDefId::ImplId(it) => generics.fill(&it.source(db).value, start),
+            GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => {}
+        }
+
+        generics
+    }
+
+    fn fill(&mut self, node: &impl TypeParamsOwner, start: u32) {
+        if let Some(params) = node.type_param_list() {
+            self.fill_params(params, start)
+        }
+        if let Some(where_clause) = node.where_clause() {
+            self.fill_where_predicates(where_clause);
+        }
+    }
+
+    fn fill_bounds(&mut self, node: &impl ast::TypeBoundsOwner, type_ref: TypeRef) {
+        for bound in
+            node.type_bound_list().iter().flat_map(|type_bound_list| type_bound_list.bounds())
+        {
+            self.add_where_predicate_from_bound(bound, type_ref.clone());
+        }
+    }
+
+    fn fill_params(&mut self, params: ast::TypeParamList, start: u32) {
+        for (idx, type_param) in params.type_params().enumerate() {
+            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
+            // FIXME: Use `Path::from_src`
+            let default = type_param.default_type().map(TypeRef::from_ast);
+            let param = GenericParam { idx: idx as u32 + start, name: name.clone(), default };
+            self.params.push(param);
+
+            let type_ref = TypeRef::Path(name.into());
+            self.fill_bounds(&type_param, type_ref);
+        }
+    }
+
+    fn fill_where_predicates(&mut self, where_clause: ast::WhereClause) {
+        for pred in where_clause.predicates() {
+            let type_ref = match pred.type_ref() {
+                Some(type_ref) => type_ref,
+                None => continue,
+            };
+            let type_ref = TypeRef::from_ast(type_ref);
+            for bound in pred.type_bound_list().iter().flat_map(|l| l.bounds()) {
+                self.add_where_predicate_from_bound(bound, type_ref.clone());
+            }
+        }
+    }
+
+    fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) {
+        if bound.has_question_mark() {
+            // FIXME: remove this bound
+            return;
+        }
+        let bound = TypeBound::from_ast(bound);
+        self.where_predicates.push(WherePredicate { type_ref, bound });
+    }
+
+    pub fn find_by_name(&self, name: &Name) -> Option<&GenericParam> {
+        self.params.iter().find(|p| &p.name == name)
+    }
+
+    pub fn count_parent_params(&self) -> usize {
+        self.parent_params.as_ref().map(|p| p.count_params_including_parent()).unwrap_or(0)
+    }
+
+    pub fn count_params_including_parent(&self) -> usize {
+        let parent_count = self.count_parent_params();
+        parent_count + self.params.len()
+    }
+
+    fn for_each_param<'a>(&'a self, f: &mut impl FnMut(&'a GenericParam)) {
+        if let Some(parent) = &self.parent_params {
+            parent.for_each_param(f);
+        }
+        self.params.iter().for_each(f);
+    }
+
+    pub fn params_including_parent(&self) -> Vec<&GenericParam> {
+        let mut vec = Vec::with_capacity(self.count_params_including_parent());
+        self.for_each_param(&mut |p| vec.push(p));
+        vec
+    }
+}
+
+fn parent_generic_def(db: &impl DefDatabase2, def: GenericDefId) -> Option<GenericDefId> {
+    let container = match def {
+        GenericDefId::FunctionId(it) => it.lookup(db).container,
+        GenericDefId::TypeAliasId(it) => it.lookup(db).container,
+        GenericDefId::ConstId(it) => it.lookup(db).container,
+        GenericDefId::EnumVariantId(it) => return Some(it.parent.into()),
+        GenericDefId::AdtId(_) | GenericDefId::TraitId(_) | GenericDefId::ImplId(_) => return None,
+    };
+
+    match container {
+        ContainerId::ImplId(it) => Some(it.into()),
+        ContainerId::TraitId(it) => Some(it.into()),
+        ContainerId::ModuleId(_) => None,
+    }
+}
diff --git a/crates/ra_hir_def/src/imp.rs b/crates/ra_hir_def/src/impls.rs
index 717991c40..750a869f2 100644
--- a/crates/ra_hir_def/src/imp.rs
+++ b/crates/ra_hir_def/src/impls.rs
@@ -5,11 +5,12 @@
 
 use std::sync::Arc;
 
+use hir_expand::AstId;
 use ra_syntax::ast;
 
 use crate::{
-    db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstId, FunctionId, ImplId,
-    LocationCtx, TypeAliasId,
+    db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstLoc, ContainerId,
+    FunctionLoc, ImplId, Intern, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -25,23 +26,37 @@ impl ImplData {
         let src = id.source(db);
         let items = db.ast_id_map(src.file_id);
 
-        let target_trait = src.ast.target_trait().map(TypeRef::from_ast);
-        let target_type = TypeRef::from_ast_opt(src.ast.target_type());
-        let negative = src.ast.is_negative();
+        let target_trait = src.value.target_trait().map(TypeRef::from_ast);
+        let target_type = TypeRef::from_ast_opt(src.value.target_type());
+        let negative = src.value.is_negative();
 
-        let items = if let Some(item_list) = src.ast.item_list() {
-            let ctx = LocationCtx::new(db, id.module(db), src.file_id);
+        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) => {
-                        FunctionId::from_ast_id(ctx, items.ast_id(&it)).into()
+                        let def = FunctionLoc {
+                            container: ContainerId::ImplId(id),
+                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
+                        }
+                        .intern(db);
+                        def.into()
                     }
                     ast::ImplItem::ConstDef(it) => {
-                        ConstId::from_ast_id(ctx, items.ast_id(&it)).into()
+                        let def = ConstLoc {
+                            container: ContainerId::ImplId(id),
+                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
+                        }
+                        .intern(db);
+                        def.into()
                     }
                     ast::ImplItem::TypeAliasDef(it) => {
-                        TypeAliasId::from_ast_id(ctx, items.ast_id(&it)).into()
+                        let def = TypeAliasLoc {
+                            container: ContainerId::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 a240a10b8..0af41de87 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -13,10 +13,12 @@ pub mod path;
 pub mod type_ref;
 pub mod builtin_type;
 pub mod adt;
-pub mod imp;
+pub mod impls;
 pub mod diagnostics;
 pub mod expr;
 pub mod body;
+pub mod generics;
+pub mod traits;
 
 #[cfg(test)]
 mod test_db;
@@ -80,7 +82,7 @@ impl ModuleSource {
 
     pub fn from_child_node(db: &impl db::DefDatabase2, child: Source<&SyntaxNode>) -> ModuleSource {
         if let Some(m) =
-            child.ast.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
+            child.value.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
         {
             ModuleSource::Module(m)
         } else {
@@ -184,8 +186,8 @@ pub trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
     }
     fn source(self, db: &(impl AstDatabase + InternDatabase)) -> Source<N> {
         let loc = self.lookup_intern(db);
-        let ast = loc.ast_id.to_node(db);
-        Source { file_id: loc.ast_id.file_id(), ast }
+        let value = loc.ast_id.to_node(db);
+        Source { file_id: loc.ast_id.file_id(), value }
     }
     fn module(self, db: &impl InternDatabase) -> ModuleId {
         let loc = self.lookup_intern(db);
@@ -197,12 +199,23 @@ pub trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
 pub struct FunctionId(salsa::InternId);
 impl_intern_key!(FunctionId);
 
-impl AstItemDef<ast::FnDef> for FunctionId {
-    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::FnDef>) -> Self {
-        db.intern_function(loc)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FunctionLoc {
+    pub container: ContainerId,
+    pub ast_id: AstId<ast::FnDef>,
+}
+
+impl Intern for FunctionLoc {
+    type ID = FunctionId;
+    fn intern(self, db: &impl db::DefDatabase2) -> FunctionId {
+        db.intern_function(self)
     }
-    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::FnDef> {
-        db.lookup_intern_function(self)
+}
+
+impl Lookup for FunctionId {
+    type Data = FunctionLoc;
+    fn lookup(&self, db: &impl db::DefDatabase2) -> FunctionLoc {
+        db.lookup_intern_function(*self)
     }
 }
 
@@ -276,12 +289,23 @@ impl_arena_id!(LocalStructFieldId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ConstId(salsa::InternId);
 impl_intern_key!(ConstId);
-impl AstItemDef<ast::ConstDef> for ConstId {
-    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::ConstDef>) -> Self {
-        db.intern_const(loc)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ConstLoc {
+    pub container: ContainerId,
+    pub ast_id: AstId<ast::ConstDef>,
+}
+
+impl Intern for ConstLoc {
+    type ID = ConstId;
+    fn intern(self, db: &impl db::DefDatabase2) -> ConstId {
+        db.intern_const(self)
     }
-    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::ConstDef> {
-        db.lookup_intern_const(self)
+}
+
+impl Lookup for ConstId {
+    type Data = ConstLoc;
+    fn lookup(&self, db: &impl db::DefDatabase2) -> ConstLoc {
+        db.lookup_intern_const(*self)
     }
 }
 
@@ -312,12 +336,24 @@ 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: ContainerId,
+    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)
     }
 }
 
@@ -352,6 +388,13 @@ macro_rules! impl_froms {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ContainerId {
+    ModuleId(ModuleId),
+    ImplId(ImplId),
+    TraitId(TraitId),
+}
+
 /// A Data Type
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AdtId {
@@ -408,3 +451,102 @@ pub enum AssocItemId {
 // require not implementing From, and instead having some checked way of
 // casting them, and somehow making the constructors private, which would be annoying.
 impl_froms!(AssocItemId: FunctionId, ConstId, TypeAliasId);
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum GenericDefId {
+    FunctionId(FunctionId),
+    AdtId(AdtId),
+    TraitId(TraitId),
+    TypeAliasId(TypeAliasId),
+    ImplId(ImplId),
+    // enum variants cannot have generics themselves, but their parent enums
+    // can, and this makes some code easier to write
+    EnumVariantId(EnumVariantId),
+    // consts can have type parameters from their parents (i.e. associated consts of traits)
+    ConstId(ConstId),
+}
+impl_froms!(
+    GenericDefId: FunctionId,
+    AdtId(StructId, EnumId, UnionId),
+    TraitId,
+    TypeAliasId,
+    ImplId,
+    EnumVariantId,
+    ConstId
+);
+
+trait Intern {
+    type ID;
+    fn intern(self, db: &impl db::DefDatabase2) -> Self::ID;
+}
+
+pub trait Lookup {
+    type Data;
+    fn lookup(&self, db: &impl db::DefDatabase2) -> Self::Data;
+}
+
+pub trait HasModule {
+    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId;
+}
+
+impl HasModule for FunctionLoc {
+    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+        match self.container {
+            ContainerId::ModuleId(it) => it,
+            ContainerId::ImplId(it) => it.module(db),
+            ContainerId::TraitId(it) => it.module(db),
+        }
+    }
+}
+
+impl HasModule for TypeAliasLoc {
+    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+        match self.container {
+            ContainerId::ModuleId(it) => it,
+            ContainerId::ImplId(it) => it.module(db),
+            ContainerId::TraitId(it) => it.module(db),
+        }
+    }
+}
+
+impl HasModule for ConstLoc {
+    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+        match self.container {
+            ContainerId::ModuleId(it) => it,
+            ContainerId::ImplId(it) => it.module(db),
+            ContainerId::TraitId(it) => it.module(db),
+        }
+    }
+}
+
+pub trait HasSource {
+    type Value;
+    fn source(&self, db: &impl db::DefDatabase2) -> Source<Self::Value>;
+}
+
+impl HasSource for FunctionLoc {
+    type Value = ast::FnDef;
+
+    fn source(&self, db: &impl db::DefDatabase2) -> Source<ast::FnDef> {
+        let node = self.ast_id.to_node(db);
+        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)
+    }
+}
+
+impl HasSource for ConstLoc {
+    type Value = ast::ConstDef;
+
+    fn source(&self, db: &impl db::DefDatabase2) -> Source<ast::ConstDef> {
+        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.rs b/crates/ra_hir_def/src/nameres.rs
index e5b073a0f..c01e020ef 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -165,6 +165,14 @@ impl ModuleScope {
         self.items.iter().chain(BUILTIN_SCOPE.iter())
     }
 
+    pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ {
+        self.entries()
+            .filter_map(|(_name, res)| if res.import.is_none() { Some(res.def) } else { None })
+            .flat_map(|per_ns| {
+                per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter())
+            })
+    }
+
     /// Iterate over all module scoped macros
     pub fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
         self.items
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 8f426b097..aae3dcadf 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -19,9 +19,9 @@ use crate::{
         per_ns::PerNs, raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
     },
     path::{Path, PathKind},
-    AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId, ImplId,
-    LocationCtx, ModuleDefId, ModuleId, StaticId, StructId, StructOrUnionId, TraitId, TypeAliasId,
-    UnionId,
+    AdtId, AstId, AstItemDef, ConstLoc, ContainerId, CrateModuleId, EnumId, EnumVariantId,
+    FunctionLoc, ImplId, Intern, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
+    StructOrUnionId, TraitId, TypeAliasLoc, UnionId,
 };
 
 pub(super) fn collect_defs(db: &impl DefDatabase2, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -673,8 +673,13 @@ where
         let name = def.name.clone();
         let def: PerNs = match def.kind {
             raw::DefKind::Function(ast_id) => {
-                let f = FunctionId::from_ast_id(ctx, ast_id);
-                PerNs::values(f.into())
+                let def = FunctionLoc {
+                    container: ContainerId::ModuleId(module),
+                    ast_id: AstId::new(self.file_id, ast_id),
+                }
+                .intern(self.def_collector.db);
+
+                PerNs::values(def.into())
             }
             raw::DefKind::Struct(ast_id) => {
                 let id = StructOrUnionId::from_ast_id(ctx, ast_id).into();
@@ -687,13 +692,27 @@ where
                 PerNs::both(u, u)
             }
             raw::DefKind::Enum(ast_id) => PerNs::types(EnumId::from_ast_id(ctx, ast_id).into()),
-            raw::DefKind::Const(ast_id) => PerNs::values(ConstId::from_ast_id(ctx, ast_id).into()),
+            raw::DefKind::Const(ast_id) => {
+                let def = ConstLoc {
+                    container: ContainerId::ModuleId(module),
+                    ast_id: AstId::new(self.file_id, ast_id),
+                }
+                .intern(self.def_collector.db);
+
+                PerNs::values(def.into())
+            }
             raw::DefKind::Static(ast_id) => {
                 PerNs::values(StaticId::from_ast_id(ctx, ast_id).into())
             }
             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: ContainerId::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/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index a0a2c7273..7c68fd638 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -327,7 +327,7 @@ impl RawItemsCollector {
 
         let mut buf = Vec::new();
         Path::expand_use_item(
-            Source { ast: use_item, file_id: self.file_id },
+            Source { value: use_item, file_id: self.file_id },
             &self.hygiene,
             |path, use_tree, is_glob, alias| {
                 let import_data = ImportData {
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 04039376f..626ebffdc 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -71,7 +71,7 @@ impl Path {
         hygiene: &Hygiene,
         mut cb: impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
     ) {
-        if let Some(tree) = item_src.ast.use_tree() {
+        if let Some(tree) = item_src.value.use_tree() {
             expand_use_tree(None, tree, hygiene, &mut cb);
         }
     }
diff --git a/crates/ra_hir_def/src/traits.rs b/crates/ra_hir_def/src/traits.rs
new file mode 100644
index 000000000..877d73d66
--- /dev/null
+++ b/crates/ra_hir_def/src/traits.rs
@@ -0,0 +1,59 @@
+//! HIR for trait definitions.
+
+use std::sync::Arc;
+
+use hir_expand::{
+    name::{AsName, Name},
+    AstId,
+};
+
+use ra_syntax::ast::{self, NameOwner};
+
+use crate::{
+    db::DefDatabase2, AssocItemId, AstItemDef, ConstLoc, ContainerId, FunctionLoc, Intern, TraitId,
+    TypeAliasLoc,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TraitData {
+    pub name: Option<Name>,
+    pub items: Vec<AssocItemId>,
+    pub auto: bool,
+}
+
+impl TraitData {
+    pub(crate) fn trait_data_query(db: &impl DefDatabase2, tr: TraitId) -> Arc<TraitData> {
+        let src = tr.source(db);
+        let name = src.value.name().map(|n| n.as_name());
+        let auto = src.value.is_auto();
+        let ast_id_map = db.ast_id_map(src.file_id);
+        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)),
+                    }
+                    .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)),
+                    }
+                    .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)),
+                    }
+                    .intern(db)
+                    .into(),
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        Arc::new(TraitData { name, items, auto })
+    }
+}