19 files changed, 441 insertions, 316 deletions

diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 5437133b8..88c13566c 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -17,6 +17,7 @@ use crate::{
     impl_block::ImplBlock,
     resolve::Resolver,
     diagnostics::DiagnosticSink,
+    traits::{TraitItem, TraitData},
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -649,6 +650,18 @@ impl Trait {
     pub fn generic_params(&self, db: &impl DefDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
+
+    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
+        self.trait_data(db).name().clone()
+    }
+
+    pub fn items(self, db: &impl DefDatabase) -> Vec<TraitItem> {
+        self.trait_data(db).items().to_vec()
+    }
+
+    pub(crate) fn trait_data(self, db: &impl DefDatabase) -> Arc<TraitData> {
+        db.trait_data(self)
+    }
 }
 
 impl Docs for Trait {
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 14237060c..790e2b80f 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -76,7 +76,7 @@ impl Module {
         import: ImportId,
     ) -> TreeArc<ast::PathSegment> {
         let (file_id, source) = self.definition_source(db);
-        let (_, source_map) = db.raw_items_with_source_map(file_id.original_file(db));
+        let (_, source_map) = db.raw_items_with_source_map(file_id);
         source_map.get(&source, import)
     }
 
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index d3908f8ac..3296b9b31 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use ra_syntax::{SyntaxNode, TreeArc, SourceFile};
-use ra_db::{SourceDatabase, salsa, FileId};
+use ra_db::{SourceDatabase, salsa};
 
 use crate::{
-    HirFileId, SourceFileItems, SourceItemId, Crate, Module, HirInterner,
+    HirFileId, MacroDefId, SourceFileItems, SourceItemId, Crate, Module, HirInterner,
     Function, FnSignature, ExprScopes, TypeAlias,
     Struct, Enum, StructField,
     Const, ConstSignature, Static,
@@ -14,10 +14,14 @@ use crate::{
     impl_block::{ModuleImplBlocks, ImplSourceMap},
     generics::{GenericParams, GenericDef},
     type_ref::TypeRef,
+    traits::TraitData, Trait, ty::TraitRef
 };
 
 #[salsa::query_group(DefDatabaseStorage)]
 pub trait DefDatabase: SourceDatabase + AsRef<HirInterner> {
+    #[salsa::invoke(crate::ids::macro_def_query)]
+    fn macro_def(&self, macro_id: MacroDefId) -> Option<Arc<mbe::MacroRules>>;
+
     #[salsa::invoke(HirFileId::hir_parse)]
     fn hir_parse(&self, file_id: HirFileId) -> TreeArc<SourceFile>;
 
@@ -27,17 +31,23 @@ pub trait DefDatabase: SourceDatabase + AsRef<HirInterner> {
     #[salsa::invoke(crate::adt::EnumData::enum_data_query)]
     fn enum_data(&self, e: Enum) -> Arc<EnumData>;
 
-    #[salsa::invoke(crate::ids::SourceFileItems::file_items_query)]
+    #[salsa::invoke(crate::traits::TraitData::trait_data_query)]
+    fn trait_data(&self, t: Trait) -> Arc<TraitData>;
+
+    #[salsa::invoke(crate::source_id::SourceFileItems::file_items_query)]
     fn file_items(&self, file_id: HirFileId) -> Arc<SourceFileItems>;
 
-    #[salsa::invoke(crate::ids::SourceFileItems::file_item_query)]
+    #[salsa::invoke(crate::source_id::SourceFileItems::file_item_query)]
     fn file_item(&self, source_item_id: SourceItemId) -> TreeArc<SyntaxNode>;
 
     #[salsa::invoke(RawItems::raw_items_query)]
-    fn raw_items(&self, file_id: FileId) -> Arc<RawItems>;
+    fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
 
     #[salsa::invoke(RawItems::raw_items_with_source_map_query)]
-    fn raw_items_with_source_map(&self, file_id: FileId) -> (Arc<RawItems>, Arc<ImportSourceMap>);
+    fn raw_items_with_source_map(
+        &self,
+        file_id: HirFileId,
+    ) -> (Arc<RawItems>, Arc<ImportSourceMap>);
 
     #[salsa::invoke(CrateDefMap::crate_def_map_query)]
     fn crate_def_map(&self, krate: Crate) -> Arc<CrateDefMap>;
@@ -98,6 +108,9 @@ pub trait HirDatabase: DefDatabase {
 
     #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
     fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
+
+    #[salsa::invoke(crate::ty::method_resolution::implements)]
+    fn implements(&self, trait_ref: TraitRef) -> bool;
 }
 
 #[test]
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 18401f865..e73dd5d21 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -5,12 +5,12 @@ use std::{
 };
 
 use ra_db::{LocationInterner, FileId};
-use ra_syntax::{TreeArc, SyntaxNode, SourceFile, AstNode, SyntaxNodePtr, ast};
-use ra_arena::{Arena, RawId, ArenaId, impl_arena_id};
+use ra_syntax::{TreeArc, SourceFile, AstNode, ast};
+use ra_arena::{RawId, ArenaId, impl_arena_id};
+use mbe::MacroRules;
 
 use crate::{
-    Module,
-    DefDatabase,
+    Module, DefDatabase, SourceItemId, SourceFileItemId,
 };
 
 #[derive(Debug, Default)]
@@ -100,10 +100,7 @@ fn parse_macro(db: &impl DefDatabase, macro_call_id: MacroCallId) -> Option<Tree
     let macro_call = ast::MacroCall::cast(&syntax).unwrap();
     let (macro_arg, _) = macro_call.token_tree().and_then(mbe::ast_to_token_tree)?;
 
-    let def_map = db.crate_def_map(loc.module.krate);
-    let (krate, macro_id) = def_map.resolve_macro(macro_call_id)?;
-    let def_map = db.crate_def_map(krate);
-    let macro_rules = &def_map[macro_id];
+    let macro_rules = db.macro_def(loc.def)?;
     let tt = macro_rules.expand(&macro_arg).ok()?;
     Some(mbe::token_tree_to_ast_item_list(&tt))
 }
@@ -126,6 +123,22 @@ impl From<MacroCallId> for HirFileId {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MacroDefId {
+    MacroByExample { source_item_id: SourceItemId },
+}
+
+pub(crate) fn macro_def_query(db: &impl DefDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
+    let syntax_node = match id {
+        MacroDefId::MacroByExample { source_item_id } => db.file_item(source_item_id),
+    };
+    let macro_call = ast::MacroCall::cast(&syntax_node).unwrap();
+    let arg = macro_call.token_tree()?;
+    let (tt, _) = mbe::ast_to_token_tree(arg)?;
+    let rules = MacroRules::parse(&tt).ok()?;
+    Some(Arc::new(rules))
+}
+
 /// `MacroCallId` identifies a particular macro invocation, like
 /// `println!("Hello, {}", world)`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -134,7 +147,7 @@ impl_arena_id!(MacroCallId);
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroCallLoc {
-    pub(crate) module: Module,
+    pub(crate) def: MacroDefId,
     pub(crate) source_item_id: SourceItemId,
 }
 
@@ -290,110 +303,3 @@ impl AstItemDef<ast::TypeAliasDef> for TypeId {
         &interner.types
     }
 }
-
-/// Identifier of item within a specific file. This is stable over reparses, so
-/// it's OK to use it as a salsa key/value.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct SourceFileItemId(RawId);
-impl_arena_id!(SourceFileItemId);
-
-impl SourceFileItemId {
-    pub(crate) fn with_file_id(self, file_id: HirFileId) -> SourceItemId {
-        SourceItemId { file_id, item_id: self }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct SourceItemId {
-    pub(crate) file_id: HirFileId,
-    pub(crate) item_id: SourceFileItemId,
-}
-
-/// Maps items' `SyntaxNode`s to `SourceFileItemId`s and back.
-#[derive(Debug, PartialEq, Eq)]
-pub struct SourceFileItems {
-    file_id: HirFileId,
-    arena: Arena<SourceFileItemId, SyntaxNodePtr>,
-}
-
-impl SourceFileItems {
-    pub(crate) fn file_items_query(
-        db: &impl DefDatabase,
-        file_id: HirFileId,
-    ) -> Arc<SourceFileItems> {
-        let source_file = db.hir_parse(file_id);
-        Arc::new(SourceFileItems::from_source_file(&source_file, file_id))
-    }
-
-    pub(crate) fn file_item_query(
-        db: &impl DefDatabase,
-        source_item_id: SourceItemId,
-    ) -> TreeArc<SyntaxNode> {
-        let source_file = db.hir_parse(source_item_id.file_id);
-        db.file_items(source_item_id.file_id)[source_item_id.item_id]
-            .to_node(&source_file)
-            .to_owned()
-    }
-
-    pub(crate) fn from_source_file(
-        source_file: &SourceFile,
-        file_id: HirFileId,
-    ) -> SourceFileItems {
-        let mut res = SourceFileItems { file_id, arena: Arena::default() };
-        // By walking the tree in bread-first order we make sure that parents
-        // get lower ids then children. That is, adding a new child does not
-        // change parent's id. This means that, say, adding a new function to a
-        // trait does not change ids of top-level items, which helps caching.
-        bfs(source_file.syntax(), |it| {
-            if let Some(module_item) = ast::ModuleItem::cast(it) {
-                res.alloc(module_item.syntax());
-            } else if let Some(macro_call) = ast::MacroCall::cast(it) {
-                res.alloc(macro_call.syntax());
-            }
-        });
-        res
-    }
-
-    fn alloc(&mut self, item: &SyntaxNode) -> SourceFileItemId {
-        self.arena.alloc(SyntaxNodePtr::new(item))
-    }
-    pub(crate) fn id_of(&self, file_id: HirFileId, item: &SyntaxNode) -> SourceFileItemId {
-        assert_eq!(
-            self.file_id, file_id,
-            "SourceFileItems: wrong file, expected {:?}, got {:?}",
-            self.file_id, file_id
-        );
-        self.id_of_unchecked(item)
-    }
-    pub(crate) fn id_of_unchecked(&self, item: &SyntaxNode) -> SourceFileItemId {
-        let ptr = SyntaxNodePtr::new(item);
-        if let Some((id, _)) = self.arena.iter().find(|(_id, i)| **i == ptr) {
-            return id;
-        }
-        panic!(
-            "Can't find {:?} in SourceFileItems:\n{:?}",
-            item,
-            self.arena.iter().map(|(_id, i)| i).collect::<Vec<_>>(),
-        );
-    }
-}
-
-impl std::ops::Index<SourceFileItemId> for SourceFileItems {
-    type Output = SyntaxNodePtr;
-    fn index(&self, idx: SourceFileItemId) -> &SyntaxNodePtr {
-        &self.arena[idx]
-    }
-}
-
-/// Walks the subtree in bfs order, calling `f` for each node.
-fn bfs(node: &SyntaxNode, mut f: impl FnMut(&SyntaxNode)) {
-    let mut curr_layer = vec![node];
-    let mut next_layer = vec![];
-    while !curr_layer.is_empty() {
-        curr_layer.drain(..).for_each(|node| {
-            next_layer.extend(node.children());
-            f(node);
-        });
-        std::mem::swap(&mut curr_layer, &mut next_layer);
-    }
-}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index ce54d7608..ac2585de0 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -23,10 +23,12 @@ pub mod mock;
 mod path;
 pub mod source_binder;
 
+mod source_id;
 mod ids;
 mod name;
 mod nameres;
 mod adt;
+mod traits;
 mod type_alias;
 mod type_ref;
 mod ty;
@@ -46,13 +48,14 @@ mod marks;
 use crate::{
     db::{HirDatabase, DefDatabase},
     name::{AsName, KnownName},
-    ids::{SourceItemId, SourceFileItems},
+    source_id::SourceFileItemId,
 };
 
 pub use self::{
     path::{Path, PathKind},
     name::Name,
-    ids::{HirFileId, MacroCallId, MacroCallLoc, HirInterner},
+    source_id::{SourceFileItems, SourceItemId},
+    ids::{HirFileId, MacroDefId, MacroCallId, MacroCallLoc, HirInterner},
     nameres::{PerNs, Namespace},
     ty::{Ty, ApplicationTy, TypeCtor, Substs, display::HirDisplay},
     impl_block::{ImplBlock, ImplItem},
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 56ed872d5..e962bbd31 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -61,9 +61,9 @@ use ra_db::{FileId, Edition};
 use test_utils::tested_by;
 
 use crate::{
-    ModuleDef, Name, Crate, Module,
-    DefDatabase, Path, PathKind, HirFileId,
-    ids::{SourceItemId, SourceFileItemId, MacroCallId},
+    ModuleDef, Name, Crate, Module, SourceItemId,
+    DefDatabase, Path, PathKind, HirFileId, Trait,
+    ids::MacroDefId,
     diagnostics::DiagnosticSink,
     nameres::diagnostics::DefDiagnostic,
 };
@@ -84,9 +84,7 @@ pub struct CrateDefMap {
     extern_prelude: FxHashMap<Name, ModuleDef>,
     root: CrateModuleId,
     modules: Arena<CrateModuleId, ModuleData>,
-    macros: Arena<CrateMacroId, mbe::MacroRules>,
-    public_macros: FxHashMap<Name, CrateMacroId>,
-    macro_resolutions: FxHashMap<MacroCallId, (Crate, CrateMacroId)>,
+    public_macros: FxHashMap<Name, MacroDefId>,
     diagnostics: Vec<DefDiagnostic>,
 }
 
@@ -97,18 +95,6 @@ impl std::ops::Index<CrateModuleId> for CrateDefMap {
     }
 }
 
-impl std::ops::Index<CrateMacroId> for CrateDefMap {
-    type Output = mbe::MacroRules;
-    fn index(&self, id: CrateMacroId) -> &mbe::MacroRules {
-        &self.macros[id]
-    }
-}
-
-/// An ID of a macro, **local** to a specific crate
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub(crate) struct CrateMacroId(RawId);
-impl_arena_id!(CrateMacroId);
-
 /// An ID of a module, **local** to a specific crate
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) struct CrateModuleId(RawId);
@@ -139,6 +125,12 @@ impl ModuleScope {
     pub fn get(&self, name: &Name) -> Option<&Resolution> {
         self.items.get(name)
     }
+    pub fn traits<'a>(&'a self) -> impl Iterator<Item = Trait> + 'a {
+        self.items.values().filter_map(|r| match r.def.take_types() {
+            Some(ModuleDef::Trait(t)) => Some(t),
+            _ => None,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
@@ -196,9 +188,7 @@ impl CrateDefMap {
                 prelude: None,
                 root,
                 modules,
-                macros: Arena::default(),
                 public_macros: FxHashMap::default(),
-                macro_resolutions: FxHashMap::default(),
                 diagnostics: Vec::new(),
             }
         };
@@ -232,19 +222,11 @@ impl CrateDefMap {
         self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
     }
 
-    pub(crate) fn resolve_macro(
-        &self,
-        macro_call_id: MacroCallId,
-    ) -> Option<(Crate, CrateMacroId)> {
-        self.macro_resolutions.get(&macro_call_id).map(|&it| it)
-    }
-
     pub(crate) fn find_module_by_source(
         &self,
         file_id: HirFileId,
-        decl_id: Option<SourceFileItemId>,
+        decl_id: Option<SourceItemId>,
     ) -> Option<CrateModuleId> {
-        let decl_id = decl_id.map(|it| it.with_file_id(file_id));
         let (module_id, _module_data) = self.modules.iter().find(|(_module_id, module_data)| {
             if decl_id.is_some() {
                 module_data.declaration == decl_id
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index 8830b4624..4fb298155 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -6,15 +6,15 @@ use ra_db::FileId;
 
 use crate::{
     Function, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
-    DefDatabase, HirFileId, Name, Path, Crate,
+    DefDatabase, HirFileId, Name, Path, SourceItemId,
     KnownName,
     nameres::{
         Resolution, PerNs, ModuleDef, ReachedFixedPoint, ResolveMode,
-        CrateDefMap, CrateModuleId, ModuleData, CrateMacroId,
+        CrateDefMap, CrateModuleId, ModuleData,
         diagnostics::DefDiagnostic,
         raw,
     },
-    ids::{AstItemDef, LocationCtx, MacroCallLoc, SourceItemId, MacroCallId},
+    ids::{AstItemDef, LocationCtx, MacroCallLoc, MacroCallId, MacroDefId},
 };
 
 pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -51,8 +51,8 @@ struct DefCollector<DB> {
     def_map: CrateDefMap,
     glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
     unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
-    unexpanded_macros: Vec<(CrateModuleId, MacroCallId, Path, tt::Subtree)>,
-    global_macro_scope: FxHashMap<Name, CrateMacroId>,
+    unexpanded_macros: Vec<(CrateModuleId, SourceItemId, Path)>,
+    global_macro_scope: FxHashMap<Name, MacroDefId>,
 }
 
 impl<'a, DB> DefCollector<&'a DB>
@@ -62,7 +62,7 @@ where
     fn collect(&mut self) {
         let crate_graph = self.db.crate_graph();
         let file_id = crate_graph.crate_root(self.def_map.krate.crate_id());
-        let raw_items = self.db.raw_items(file_id);
+        let raw_items = self.db.raw_items(file_id.into());
         let module_id = self.def_map.root;
         self.def_map.modules[module_id].definition = Some(file_id);
         ModCollector {
@@ -93,14 +93,11 @@ where
         }
     }
 
-    fn define_macro(&mut self, name: Name, tt: &tt::Subtree, export: bool) {
-        if let Ok(rules) = mbe::MacroRules::parse(tt) {
-            let macro_id = self.def_map.macros.alloc(rules);
-            if export {
-                self.def_map.public_macros.insert(name.clone(), macro_id);
-            }
-            self.global_macro_scope.insert(name, macro_id);
+    fn define_macro(&mut self, name: Name, macro_id: MacroDefId, export: bool) {
+        if export {
+            self.def_map.public_macros.insert(name.clone(), macro_id);
         }
+        self.global_macro_scope.insert(name, macro_id);
     }
 
     fn resolve_imports(&mut self) -> ReachedFixedPoint {
@@ -296,7 +293,7 @@ where
         let mut macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new());
         let mut resolved = Vec::new();
         let mut res = ReachedFixedPoint::Yes;
-        macros.retain(|(module_id, call_id, path, tt)| {
+        macros.retain(|(module_id, source_item_id, path)| {
             if path.segments.len() != 2 {
                 return true;
             }
@@ -312,47 +309,24 @@ where
             res = ReachedFixedPoint::No;
             let def_map = self.db.crate_def_map(krate);
             if let Some(macro_id) = def_map.public_macros.get(&path.segments[1].name).cloned() {
-                resolved.push((*module_id, *call_id, (krate, macro_id), tt.clone()));
+                let call_id =
+                    MacroCallLoc { def: macro_id, source_item_id: *source_item_id }.id(self.db);
+                resolved.push((*module_id, call_id));
             }
             false
         });
 
-        for (module_id, macro_call_id, macro_def_id, arg) in resolved {
-            self.collect_macro_expansion(module_id, macro_call_id, macro_def_id, arg);
+        for (module_id, macro_call_id) in resolved {
+            self.collect_macro_expansion(module_id, macro_call_id);
         }
         res
     }
 
-    fn collect_macro_expansion(
-        &mut self,
-        module_id: CrateModuleId,
-        macro_call_id: MacroCallId,
-        macro_def_id: (Crate, CrateMacroId),
-        macro_arg: tt::Subtree,
-    ) {
-        let (macro_krate, macro_id) = macro_def_id;
-        let dm;
-        let rules = if macro_krate == self.def_map.krate {
-            &self.def_map[macro_id]
-        } else {
-            dm = self.db.crate_def_map(macro_krate);
-            &dm[macro_id]
-        };
-        if let Ok(expansion) = rules.expand(&macro_arg) {
-            self.def_map.macro_resolutions.insert(macro_call_id, macro_def_id);
-            // XXX: this **does not** go through a database, because we can't
-            // identify macro_call without adding the whole state of name resolution
-            // as a parameter to the query.
-            //
-            // So, we run the queries "manually" and we must ensure that
-            // `db.hir_parse(macro_call_id)` returns the same source_file.
-            let file_id: HirFileId = macro_call_id.into();
-            let source_file = mbe::token_tree_to_ast_item_list(&expansion);
-
-            let raw_items = raw::RawItems::from_source_file(&source_file, file_id);
-            ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items }
-                .collect(raw_items.items())
-        }
+    fn collect_macro_expansion(&mut self, module_id: CrateModuleId, macro_call_id: MacroCallId) {
+        let file_id: HirFileId = macro_call_id.into();
+        let raw_items = self.db.raw_items(file_id);
+        ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items }
+            .collect(raw_items.items())
     }
 
     fn finish(self) -> CrateDefMap {
@@ -412,7 +386,7 @@ where
                     Ok(file_id) => {
                         let module_id =
                             self.push_child_module(name.clone(), source_item_id, Some(file_id));
-                        let raw_items = self.def_collector.db.raw_items(file_id);
+                        let raw_items = self.def_collector.db.raw_items(file_id.into());
                         ModCollector {
                             def_collector: &mut *self.def_collector,
                             module_id,
@@ -484,38 +458,33 @@ where
         // Case 1: macro rules, define a macro in crate-global mutable scope
         if is_macro_rules(&mac.path) {
             if let Some(name) = &mac.name {
-                self.def_collector.define_macro(name.clone(), &mac.arg, mac.export)
+                let macro_id = MacroDefId::MacroByExample {
+                    source_item_id: mac.source_item_id.with_file_id(self.file_id),
+                };
+                self.def_collector.define_macro(name.clone(), macro_id, mac.export)
             }
             return;
         }
 
         let source_item_id = SourceItemId { file_id: self.file_id, item_id: mac.source_item_id };
-        let macro_call_id = MacroCallLoc {
-            module: Module { krate: self.def_collector.def_map.krate, module_id: self.module_id },
-            source_item_id,
-        }
-        .id(self.def_collector.db);
 
         // Case 2: try to expand macro_rules from this crate, triggering
         // recursive item collection.
         if let Some(&macro_id) =
             mac.path.as_ident().and_then(|name| self.def_collector.global_macro_scope.get(name))
         {
-            self.def_collector.collect_macro_expansion(
-                self.module_id,
-                macro_call_id,
-                (self.def_collector.def_map.krate, macro_id),
-                mac.arg.clone(),
-            );
+            let macro_call_id =
+                MacroCallLoc { def: macro_id, source_item_id }.id(self.def_collector.db);
+
+            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id);
             return;
         }
 
         // Case 3: path to a macro from another crate, expand during name resolution
         self.def_collector.unexpanded_macros.push((
             self.module_id,
-            macro_call_id,
+            source_item_id,
             mac.path.clone(),
-            mac.arg.clone(),
         ))
     }
 }
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index f8ba398ec..f32004601 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -4,7 +4,6 @@ use std::{
 };
 
 use test_utils::tested_by;
-use ra_db::FileId;
 use ra_arena::{Arena, impl_arena_id, RawId, map::ArenaMap};
 use ra_syntax::{
     AstNode, SourceFile, AstPtr, TreeArc,
@@ -13,9 +12,13 @@ use ra_syntax::{
 
 use crate::{
     DefDatabase, Name, AsName, Path, HirFileId, ModuleSource,
-    ids::{SourceFileItemId, SourceFileItems},
+    SourceFileItemId, SourceFileItems,
 };
 
+/// `RawItems` is a set of top-level items in a file (except for impls).
+///
+/// It is the input to name resolution algorithm. `RawItems` are not invalidated
+/// on most edits.
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct RawItems {
     modules: Arena<Module, ModuleData>,
@@ -32,11 +35,11 @@ pub struct ImportSourceMap {
 }
 
 impl ImportSourceMap {
-    pub(crate) fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
+    fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
         self.map.insert(import, AstPtr::new(segment))
     }
 
-    pub fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
+    pub(crate) fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
         let file = match source {
             ModuleSource::SourceFile(file) => &*file,
             ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
@@ -47,40 +50,27 @@ impl ImportSourceMap {
 }
 
 impl RawItems {
-    pub(crate) fn raw_items_query(db: &impl DefDatabase, file_id: FileId) -> Arc<RawItems> {
+    pub(crate) fn raw_items_query(db: &impl DefDatabase, file_id: HirFileId) -> Arc<RawItems> {
         db.raw_items_with_source_map(file_id).0
     }
 
     pub(crate) fn raw_items_with_source_map_query(
         db: &impl DefDatabase,
-        file_id: FileId,
+        file_id: HirFileId,
     ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
         let mut collector = RawItemsCollector {
             raw_items: RawItems::default(),
             source_file_items: db.file_items(file_id.into()),
             source_map: ImportSourceMap::default(),
         };
-        let source_file = db.parse(file_id);
+        let source_file = db.hir_parse(file_id);
         collector.process_module(None, &*source_file);
         (Arc::new(collector.raw_items), Arc::new(collector.source_map))
     }
 
-    pub(crate) fn items(&self) -> &[RawItem] {
+    pub(super) fn items(&self) -> &[RawItem] {
         &self.items
     }
-
-    // We can't use queries during name resolution for fear of cycles, so this
-    // is a query-less variant of the above function.
-    pub(crate) fn from_source_file(source_file: &SourceFile, file_id: HirFileId) -> RawItems {
-        let source_file_items = SourceFileItems::from_source_file(source_file, file_id);
-        let mut collector = RawItemsCollector {
-            raw_items: RawItems::default(),
-            source_file_items: Arc::new(source_file_items),
-            source_map: ImportSourceMap::default(),
-        };
-        collector.process_module(None, &*source_file);
-        collector.raw_items
-    }
 }
 
 impl Index<Module> for RawItems {
@@ -112,7 +102,7 @@ impl Index<Macro> for RawItems {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(crate) enum RawItem {
+pub(super) enum RawItem {
     Module(Module),
     Import(ImportId),
     Def(Def),
@@ -120,11 +110,11 @@ pub(crate) enum RawItem {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct Module(RawId);
+pub(super) struct Module(RawId);
 impl_arena_id!(Module);
 
 #[derive(Debug, PartialEq, Eq)]
-pub(crate) enum ModuleData {
+pub(super) enum ModuleData {
     Declaration { name: Name, source_item_id: SourceFileItemId },
     Definition { name: Name, source_item_id: SourceFileItemId, items: Vec<RawItem> },
 }
@@ -135,26 +125,26 @@ impl_arena_id!(ImportId);
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportData {
-    pub(crate) path: Path,
-    pub(crate) alias: Option<Name>,
-    pub(crate) is_glob: bool,
-    pub(crate) is_prelude: bool,
-    pub(crate) is_extern_crate: bool,
+    pub(super) path: Path,
+    pub(super) alias: Option<Name>,
+    pub(super) is_glob: bool,
+    pub(super) is_prelude: bool,
+    pub(super) is_extern_crate: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct Def(RawId);
+pub(super) struct Def(RawId);
 impl_arena_id!(Def);
 
 #[derive(Debug, PartialEq, Eq)]
-pub(crate) struct DefData {
-    pub(crate) source_item_id: SourceFileItemId,
-    pub(crate) name: Name,
-    pub(crate) kind: DefKind,
+pub(super) struct DefData {
+    pub(super) source_item_id: SourceFileItemId,
+    pub(super) name: Name,
+    pub(super) kind: DefKind,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(crate) enum DefKind {
+pub(super) enum DefKind {
     Function,
     Struct,
     Enum,
@@ -165,16 +155,15 @@ pub(crate) enum DefKind {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct Macro(RawId);
+pub(super) struct Macro(RawId);
 impl_arena_id!(Macro);
 
 #[derive(Debug, PartialEq, Eq)]
-pub(crate) struct MacroData {
-    pub(crate) source_item_id: SourceFileItemId,
-    pub(crate) path: Path,
-    pub(crate) name: Option<Name>,
-    pub(crate) arg: tt::Subtree,
-    pub(crate) export: bool,
+pub(super) struct MacroData {
+    pub(super) source_item_id: SourceFileItemId,
+    pub(super) path: Path,
+    pub(super) name: Option<Name>,
+    pub(super) export: bool,
 }
 
 struct RawItemsCollector {
@@ -291,18 +280,15 @@ impl RawItemsCollector {
     }
 
     fn add_macro(&mut self, current_module: Option<Module>, m: &ast::MacroCall) {
-        let (path, arg) = match (
-            m.path().and_then(Path::from_ast),
-            m.token_tree().and_then(mbe::ast_to_token_tree),
-        ) {
-            (Some(path), Some((token_tree, _token_map))) => (path, token_tree),
+        let path = match m.path().and_then(Path::from_ast) {
+            Some(it) => it,
             _ => return,
         };
 
         let name = m.name().map(|it| it.as_name());
         let source_item_id = self.source_file_items.id_of_unchecked(m.syntax());
         let export = m.has_atom_attr("macro_export");
-        let m = self.raw_items.macros.alloc(MacroData { source_item_id, path, arg, name, export });
+        let m = self.raw_items.macros.alloc(MacroData { source_item_id, path, name, export });
         self.push_item(current_module, RawItem::Macro(m));
     }
 
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
index 698781923..a059634e2 100644
--- a/crates/ra_hir/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -90,34 +90,27 @@ fn adding_inner_items_should_not_invalidate_def_map() {
     );
 }
 
-// It would be awesome to make this work, but it's unclear how
 #[test]
-#[ignore]
-fn typing_inside_a_function_inside_a_macro_should_not_invalidate_def_map() {
+fn typing_inside_a_macro_should_not_invalidate_def_map() {
     check_def_map_is_not_recomputed(
         "
         //- /lib.rs
+        macro_rules! m {
+            ($ident:ident) => {
+                struct Foo;
+            }
+        }
         mod foo;
 
-        use crate::foo::bar::Baz;
-
         //- /foo/mod.rs
         pub mod bar;
 
         //- /foo/bar.rs
         <|>
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 1 + 1 }
-            }
-        }
+        m!(X);
         ",
         "
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 92 }
-            }
-        }
+        m!(Y);
         ",
     );
 }
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index f28154517..2609585b1 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -11,7 +11,7 @@ use crate::{
     generics::GenericParams,
     expr::{scope::{ExprScopes, ScopeId}, PatId, Body},
     impl_block::ImplBlock,
-    path::Path,
+    path::Path, Trait
 };
 
 #[derive(Debug, Clone, Default)]
@@ -175,6 +175,21 @@ impl Resolver {
         names
     }
 
+    pub(crate) fn traits_in_scope<'a>(&'a self) -> impl Iterator<Item = Trait> + 'a {
+        // FIXME prelude
+        self.scopes
+            .iter()
+            .rev()
+            .flat_map(|scope| {
+                match scope {
+                    Scope::ModuleScope(m) => Some(m.crate_def_map[m.module_id].scope.traits()),
+                    _ => None,
+                }
+                .into_iter()
+            })
+            .flatten()
+    }
+
     fn module(&self) -> Option<(&CrateDefMap, CrateModuleId)> {
         self.scopes.iter().rev().find_map(|scope| match scope {
             Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)),
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 3645b73b4..db9e3a22e 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -13,9 +13,9 @@ use ra_syntax::{
 };
 
 use crate::{
-    HirDatabase, Function, Struct, Enum,
+    HirDatabase, Function, Struct, Enum, SourceItemId,
     AsName, Module, HirFileId, Crate, Trait, Resolver,
-    ids::{LocationCtx, SourceFileItemId},
+    ids::LocationCtx,
     expr
 };
 
@@ -55,7 +55,7 @@ fn module_from_inline(
     assert!(!module.has_semi());
     let file_id = file_id.into();
     let file_items = db.file_items(file_id);
-    let item_id = file_items.id_of(file_id, module.syntax());
+    let item_id = file_items.id_of(file_id, module.syntax()).with_file_id(file_id);
     module_from_source(db, file_id, Some(item_id))
 }
 
@@ -75,7 +75,7 @@ pub fn module_from_child_node(
 fn module_from_source(
     db: &impl HirDatabase,
     file_id: HirFileId,
-    decl_id: Option<SourceFileItemId>,
+    decl_id: Option<SourceItemId>,
 ) -> Option<Module> {
     let source_root_id = db.file_source_root(file_id.as_original_file());
     db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs
new file mode 100644
index 000000000..62707ba6a
--- /dev/null
+++ b/crates/ra_hir/src/source_id.rs
@@ -0,0 +1,113 @@
+use std::sync::Arc;
+
+use ra_arena::{Arena, RawId, impl_arena_id};
+use ra_syntax::{SyntaxNodePtr, TreeArc, SyntaxNode, SourceFile, AstNode, ast};
+
+use crate::{HirFileId, DefDatabase};
+
+/// Identifier of item within a specific file. This is stable over reparses, so
+/// it's OK to use it as a salsa key/value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct SourceFileItemId(RawId);
+impl_arena_id!(SourceFileItemId);
+
+impl SourceFileItemId {
+    pub(crate) fn with_file_id(self, file_id: HirFileId) -> SourceItemId {
+        SourceItemId { file_id, item_id: self }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SourceItemId {
+    pub(crate) file_id: HirFileId,
+    pub(crate) item_id: SourceFileItemId,
+}
+
+/// Maps items' `SyntaxNode`s to `SourceFileItemId`s and back.
+#[derive(Debug, PartialEq, Eq)]
+pub struct SourceFileItems {
+    file_id: HirFileId,
+    arena: Arena<SourceFileItemId, SyntaxNodePtr>,
+}
+
+impl SourceFileItems {
+    pub(crate) fn file_items_query(
+        db: &impl DefDatabase,
+        file_id: HirFileId,
+    ) -> Arc<SourceFileItems> {
+        let source_file = db.hir_parse(file_id);
+        Arc::new(SourceFileItems::from_source_file(&source_file, file_id))
+    }
+
+    pub(crate) fn file_item_query(
+        db: &impl DefDatabase,
+        source_item_id: SourceItemId,
+    ) -> TreeArc<SyntaxNode> {
+        let source_file = db.hir_parse(source_item_id.file_id);
+        db.file_items(source_item_id.file_id)[source_item_id.item_id]
+            .to_node(&source_file)
+            .to_owned()
+    }
+
+    pub(crate) fn from_source_file(
+        source_file: &SourceFile,
+        file_id: HirFileId,
+    ) -> SourceFileItems {
+        let mut res = SourceFileItems { file_id, arena: Arena::default() };
+        // By walking the tree in bread-first order we make sure that parents
+        // get lower ids then children. That is, adding a new child does not
+        // change parent's id. This means that, say, adding a new function to a
+        // trait does not change ids of top-level items, which helps caching.
+        bfs(source_file.syntax(), |it| {
+            if let Some(module_item) = ast::ModuleItem::cast(it) {
+                res.alloc(module_item.syntax());
+            } else if let Some(macro_call) = ast::MacroCall::cast(it) {
+                res.alloc(macro_call.syntax());
+            }
+        });
+        res
+    }
+
+    fn alloc(&mut self, item: &SyntaxNode) -> SourceFileItemId {
+        self.arena.alloc(SyntaxNodePtr::new(item))
+    }
+    pub(crate) fn id_of(&self, file_id: HirFileId, item: &SyntaxNode) -> SourceFileItemId {
+        assert_eq!(
+            self.file_id, file_id,
+            "SourceFileItems: wrong file, expected {:?}, got {:?}",
+            self.file_id, file_id
+        );
+        self.id_of_unchecked(item)
+    }
+    pub(crate) fn id_of_unchecked(&self, item: &SyntaxNode) -> SourceFileItemId {
+        let ptr = SyntaxNodePtr::new(item);
+        if let Some((id, _)) = self.arena.iter().find(|(_id, i)| **i == ptr) {
+            return id;
+        }
+        panic!(
+            "Can't find {:?} in SourceFileItems:\n{:?}",
+            item,
+            self.arena.iter().map(|(_id, i)| i).collect::<Vec<_>>(),
+        );
+    }
+}
+
+impl std::ops::Index<SourceFileItemId> for SourceFileItems {
+    type Output = SyntaxNodePtr;
+    fn index(&self, idx: SourceFileItemId) -> &SyntaxNodePtr {
+        &self.arena[idx]
+    }
+}
+
+/// Walks the subtree in bfs order, calling `f` for each node.
+fn bfs(node: &SyntaxNode, mut f: impl FnMut(&SyntaxNode)) {
+    let mut curr_layer = vec![node];
+    let mut next_layer = vec![];
+    while !curr_layer.is_empty() {
+        curr_layer.drain(..).for_each(|node| {
+            next_layer.extend(node.children());
+            f(node);
+        });
+        std::mem::swap(&mut curr_layer, &mut next_layer);
+    }
+}
diff --git a/crates/ra_hir/src/traits.rs b/crates/ra_hir/src/traits.rs
new file mode 100644
index 000000000..725bdd5cb
--- /dev/null
+++ b/crates/ra_hir/src/traits.rs
@@ -0,0 +1,52 @@
+//! HIR for trait definitions.
+
+use std::sync::Arc;
+
+use ra_syntax::ast::{self, NameOwner};
+
+use crate::{Function, Const, TypeAlias, Name, DefDatabase, Trait, ids::LocationCtx, name::AsName};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TraitData {
+    name: Option<Name>,
+    items: Vec<TraitItem>,
+}
+
+impl TraitData {
+    pub(crate) fn trait_data_query(db: &impl DefDatabase, tr: Trait) -> Arc<TraitData> {
+        let (file_id, node) = tr.source(db);
+        let name = node.name().map(|n| n.as_name());
+        let module = tr.module(db);
+        let ctx = LocationCtx::new(db, module, file_id);
+        let items = if let Some(item_list) = node.item_list() {
+            item_list
+                .impl_items()
+                .map(|item_node| match item_node.kind() {
+                    ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(it) }.into(),
+                    ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(it) }.into(),
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        Arc::new(TraitData { name, items })
+    }
+
+    pub(crate) fn name(&self) -> &Option<Name> {
+        &self.name
+    }
+
+    pub(crate) fn items(&self) -> &[TraitItem] {
+        &self.items
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TraitItem {
+    Function(Function),
+    Const(Const),
+    TypeAlias(TypeAlias),
+    // Existential
+}
+impl_froms!(TraitItem: Function, Const, TypeAlias);
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 7d25ade47..d42c61e9d 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -14,7 +14,7 @@ pub(crate) mod display;
 use std::sync::Arc;
 use std::{fmt, mem};
 
-use crate::{Name, AdtDef, type_ref::Mutability, db::HirDatabase};
+use crate::{Name, AdtDef, type_ref::Mutability, db::HirDatabase, Trait};
 
 pub(crate) use lower::{TypableDef, CallableDef, type_for_def, type_for_field, callable_item_sig};
 pub(crate) use infer::{infer, InferenceResult, InferTy};
@@ -91,7 +91,7 @@ pub enum TypeCtor {
 /// A nominal type with (maybe 0) type parameters. This might be a primitive
 /// type like `bool`, a struct, tuple, function pointer, reference or
 /// several other things.
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct ApplicationTy {
     pub ctor: TypeCtor,
     pub parameters: Substs,
@@ -103,7 +103,7 @@ pub struct ApplicationTy {
 /// the same thing (but in a different way).
 ///
 /// This should be cheap to clone.
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Ty {
     /// A nominal type with (maybe 0) type parameters. This might be a primitive
     /// type like `bool`, a struct, tuple, function pointer, reference or
@@ -132,7 +132,7 @@ pub enum Ty {
 }
 
 /// A list of substitutions for generic parameters.
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Substs(Arc<[Ty]>);
 
 impl Substs {
@@ -169,6 +169,21 @@ impl Substs {
     }
 }
 
+/// A trait with type parameters. This includes the `Self`, so this represents a concrete type implementing the trait.
+/// Name to be bikeshedded: TraitBound? TraitImplements?
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct TraitRef {
+    /// FIXME name?
+    trait_: Trait,
+    substs: Substs,
+}
+
+impl TraitRef {
+    pub fn self_ty(&self) -> &Ty {
+        &self.substs.0[0]
+    }
+}
+
 /// A function signature as seen by type inference: Several parameter types and
 /// one return type.
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 5fd602a9e..573115321 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -821,7 +821,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             Expr::MethodCall { receiver, args, method_name, generic_args } => {
                 let receiver_ty = self.infer_expr(*receiver, &Expectation::none());
-                let resolved = receiver_ty.clone().lookup_method(self.db, method_name);
+                let resolved =
+                    receiver_ty.clone().lookup_method(self.db, method_name, &self.resolver);
                 let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
                     Some((ty, func)) => {
                         self.write_method_resolution(tgt_expr, func);
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index b1684acf9..3ac8dc46b 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -8,12 +8,12 @@ use rustc_hash::FxHashMap;
 
 use crate::{
     HirDatabase, Module, Crate, Name, Function, Trait,
-    ids::TraitId,
     impl_block::{ImplId, ImplBlock, ImplItem},
     ty::{Ty, TypeCtor},
-    nameres::CrateModuleId,
+    nameres::CrateModuleId, resolve::Resolver, traits::TraitItem
 
 };
+use super::{ TraitRef, Substs};
 
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -38,7 +38,7 @@ pub struct CrateImplBlocks {
     /// To make sense of the CrateModuleIds, we need the source root.
     krate: Crate,
     impls: FxHashMap<TyFingerprint, Vec<(CrateModuleId, ImplId)>>,
-    impls_by_trait: FxHashMap<TraitId, Vec<(CrateModuleId, ImplId)>>,
+    impls_by_trait: FxHashMap<Trait, Vec<(CrateModuleId, ImplId)>>,
 }
 
 impl CrateImplBlocks {
@@ -56,8 +56,7 @@ impl CrateImplBlocks {
         &'a self,
         tr: &Trait,
     ) -> impl Iterator<Item = ImplBlock> + 'a {
-        let id = tr.id;
-        self.impls_by_trait.get(&id).into_iter().flat_map(|i| i.iter()).map(
+        self.impls_by_trait.get(&tr).into_iter().flat_map(|i| i.iter()).map(
             move |(module_id, impl_id)| {
                 let module = Module { krate: self.krate, module_id: *module_id };
                 ImplBlock::from_id(module, *impl_id)
@@ -73,18 +72,18 @@ impl CrateImplBlocks {
 
             let target_ty = impl_block.target_ty(db);
 
-            if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
-                self.impls
-                    .entry(target_ty_fp)
-                    .or_insert_with(Vec::new)
-                    .push((module.module_id, impl_id));
-            }
-
             if let Some(tr) = impl_block.target_trait(db) {
                 self.impls_by_trait
-                    .entry(tr.id)
+                    .entry(tr)
                     .or_insert_with(Vec::new)
                     .push((module.module_id, impl_id));
+            } else {
+                if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
+                    self.impls
+                        .entry(target_ty_fp)
+                        .or_insert_with(Vec::new)
+                        .push((module.module_id, impl_id));
+                }
             }
         }
 
@@ -109,6 +108,20 @@ impl CrateImplBlocks {
     }
 }
 
+/// Rudimentary check whether an impl exists for a given type and trait; this
+/// will actually be done by chalk.
+pub(crate) fn implements(db: &impl HirDatabase, trait_ref: TraitRef) -> bool {
+    // FIXME use all trait impls in the whole crate graph
+    let krate = trait_ref.trait_.module(db).krate(db);
+    let krate = match krate {
+        Some(krate) => krate,
+        None => return false,
+    };
+    let crate_impl_blocks = db.impls_in_crate(krate);
+    let mut impl_blocks = crate_impl_blocks.lookup_impl_blocks_for_trait(&trait_ref.trait_);
+    impl_blocks.any(|impl_block| &impl_block.target_ty(db) == trait_ref.self_ty())
+}
+
 fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
     match ty {
         Ty::Apply(a_ty) => match a_ty.ctor {
@@ -120,20 +133,64 @@ fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
 }
 
 impl Ty {
-    // FIXME: cache this as a query?
-    // - if so, what signature? (TyFingerprint, Name)?
-    // - or maybe cache all names and def_ids of methods per fingerprint?
     /// Look up the method with the given name, returning the actual autoderefed
     /// receiver type (but without autoref applied yet).
-    pub fn lookup_method(self, db: &impl HirDatabase, name: &Name) -> Option<(Ty, Function)> {
-        self.iterate_methods(db, |ty, f| {
+    pub fn lookup_method(
+        self,
+        db: &impl HirDatabase,
+        name: &Name,
+        resolver: &Resolver,
+    ) -> Option<(Ty, Function)> {
+        // FIXME: trait methods should be used before autoderefs
+        let inherent_method = self.clone().iterate_methods(db, |ty, f| {
             let sig = f.signature(db);
             if sig.name() == name && sig.has_self_param() {
                 Some((ty.clone(), f))
             } else {
                 None
             }
-        })
+        });
+        inherent_method.or_else(|| self.lookup_trait_method(db, name, resolver))
+    }
+
+    fn lookup_trait_method(
+        self,
+        db: &impl HirDatabase,
+        name: &Name,
+        resolver: &Resolver,
+    ) -> Option<(Ty, Function)> {
+        let mut candidates = Vec::new();
+        for t in resolver.traits_in_scope() {
+            let data = t.trait_data(db);
+            for item in data.items() {
+                match item {
+                    &TraitItem::Function(m) => {
+                        let sig = m.signature(db);
+                        if sig.name() == name && sig.has_self_param() {
+                            candidates.push((t, m));
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+        // FIXME:
+        //  - we might not actually be able to determine fully that the type
+        //    implements the trait here; it's enough if we (well, Chalk) determine
+        //    that it's possible.
+        //  - when the trait method is picked, we need to register an
+        //    'obligation' somewhere so that we later check that it's really
+        //    implemented
+        //  - both points go for additional requirements from where clauses as
+        //    well (in fact, the 'implements' condition could just be considered a
+        //    'where Self: Trait' clause)
+        candidates.retain(|(t, _m)| {
+            let trait_ref = TraitRef { trait_: *t, substs: Substs::single(self.clone()) };
+            db.implements(trait_ref)
+        });
+        // FIXME if there's multiple candidates here, that's an ambiguity error
+        let (_chosen_trait, chosen_method) = candidates.first()?;
+        Some((self.clone(), *chosen_method))
     }
 
     // This would be nicer if it just returned an iterator, but that runs into
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 3aedba243..655f3c522 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1272,8 +1272,8 @@ fn test() {
 [241; 252) 'Struct::FOO': u32
 [262; 263) 'y': u32
 [266; 275) 'Enum::BAR': u32
-[285; 286) 'z': u32
-[289; 302) 'TraitTest::ID': u32"###
+[285; 286) 'z': {unknown}
+[289; 302) 'TraitTest::ID': {unknown}"###
     );
 }
 
@@ -1918,9 +1918,9 @@ fn test() {
 [110; 114) 'self': &{unknown}
 [170; 228) '{     ...i128 }': ()
 [176; 178) 'S1': S1
-[176; 187) 'S1.method()': {unknown}
+[176; 187) 'S1.method()': u32
 [203; 205) 'S2': S2
-[203; 214) 'S2.method()': {unknown}"###
+[203; 214) 'S2.method()': i128"###
     );
 }
 
@@ -1964,10 +1964,10 @@ mod bar_test {
 [169; 173) 'self': &{unknown}
 [300; 337) '{     ...     }': ()
 [310; 311) 'S': S
-[310; 320) 'S.method()': {unknown}
+[310; 320) 'S.method()': u32
 [416; 454) '{     ...     }': ()
 [426; 427) 'S': S
-[426; 436) 'S.method()': {unknown}"###
+[426; 436) 'S.method()': i128"###
     );
 }
 
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 54b72f8c5..47a37e4d1 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -4061,7 +4061,11 @@ impl ast::NameOwner for TraitDef {}
 impl ast::AttrsOwner for TraitDef {}
 impl ast::DocCommentsOwner for TraitDef {}
 impl ast::TypeParamsOwner for TraitDef {}
-impl TraitDef {}
+impl TraitDef {
+    pub fn item_list(&self) -> Option<&ItemList> {
+        super::child_opt(self)
+    }
+}
 
 // TrueKw
 #[derive(Debug, PartialEq, Eq, Hash)]
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 4f8e19bd0..ad6d74162 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -292,7 +292,10 @@ Grammar(
         ], options: [["variant_list", "EnumVariantList"]] ),
         "EnumVariantList": ( collections: [["variants", "EnumVariant"]] ),
         "EnumVariant": ( traits: ["NameOwner", "DocCommentsOwner", "AttrsOwner"], options: ["Expr"] ),
-        "TraitDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner"] ),
+        "TraitDef": (
+            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner"],
+            options: ["ItemList"]
+        ),
         "Module": (
             traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner" ],
             options: [ "ItemList" ]