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

author: Seivan Heidari <[email protected]> 2019-11-18 01:27:53 +0000
committer: Seivan Heidari <[email protected]> 2019-11-18 01:27:53 +0000
commit: 166636ba77adcf5bf2c4ef935e9aa75e20f25e10 (patch)
tree: 168be1ca55c73b016e20586c08417c608450c92c /crates
parent: cb26df950699586b314731fb70786e0db8eaa049 (diff)
parent: 28c2d74b2150102a8756a5357a5a965d7610bd15 (diff)
79 files changed, 1459 insertions, 869 deletions
diff --git a/crates/ra_arena/Cargo.toml b/crates/ra_arena/Cargo.toml
index 9328c1f50..d287dbb73 100644
--- a/crates/ra_arena/Cargo.toml
+++ b/crates/ra_arena/Cargo.toml
@@ -3,3 +3,6 @@ edition = "2018"
 name = "ra_arena"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index beebccbd9..434e6656c 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -4,11 +4,13 @@ name = "ra_assists"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 format-buf = "1.0.0"
 join_to_string = "0.1.3"
 itertools = "0.8.0"
-rustc_lexer = "0.1.0"
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 1908bdec9..0ea84d548 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,6 +1,5 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
+use hir::{db::HirDatabase, SourceAnalyzer};
-use hir::db::HirDatabase;
 use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_syntax::{
@@ -113,6 +112,13 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
    pub(crate) fn covering_element(&self) -> SyntaxElement {
        find_covering_element(self.source_file.syntax(), self.frange.range)
    }
+    pub(crate) fn source_analyzer(
+        &self,
+        node: &SyntaxNode,
+        offset: Option<TextUnit>,
+    ) -> SourceAnalyzer {
+        SourceAnalyzer::new(self.db, hir::Source::new(self.frange.file_id.into(), node), offset)
+    }
    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
        find_covering_element(self.source_file.syntax(), range)
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index ddda1a0f2..562a09685 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -40,7 +40,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
    }
    // Infer type
    let db = ctx.db;
-    let analyzer = hir::SourceAnalyzer::new(db, ctx.frange.file_id, stmt.syntax(), None);
+    let analyzer = ctx.source_analyzer(stmt.syntax(), None);
    let ty = analyzer.type_of(db, &expr)?;
    // Assist not applicable if the type is unknown
    if is_unknown(&ty) {
diff --git a/crates/ra_assists/src/assists/add_missing_impl_members.rs b/crates/ra_assists/src/assists/add_missing_impl_members.rs
index 41de23921..91af161ee 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/assists/add_missing_impl_members.rs
@@ -100,8 +100,7 @@ fn add_missing_impl_members_inner(
    let impl_item_list = impl_node.item_list()?;
    let trait_def = {
-        let file_id = ctx.frange.file_id;
+        let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
-        let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, impl_node.syntax(), None);
        resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
    };
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index a8839cfba..2038afdc6 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -158,9 +158,12 @@ fn find_struct_impl(
        let same_ty = blk.target_ty(db) == struct_ty;
        let not_trait_impl = blk.target_trait(db).is_none();
-        found_new_fn = has_new_fn(impl_blk);
+        if !(same_ty && not_trait_impl) {
+            return false;
+        }
-        same_ty && not_trait_impl
+        found_new_fn = has_new_fn(impl_blk);
+        true
    });
    if found_new_fn {
@@ -186,9 +189,10 @@ fn has_new_fn(imp: &ast::ImplBlock) -> bool {
 #[cfg(test)]
 mod tests {
-    use super::*;
    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use super::*;
    #[test]
    #[rustfmt::skip]
    fn test_add_new() {
@@ -345,7 +349,7 @@ struct Foo {<|>}
 impl Foo {
    fn new() -> Self {
        Self
-    }    
+    }
 }",
        );
@@ -357,7 +361,7 @@ struct Foo {<|>}
 impl Foo {
    fn New() -> Self {
        Self
-    }    
+    }
 }",
        );
    }
@@ -376,4 +380,59 @@ struct EvenMoreIrrelevant;
 struct Foo<'a, T: Foo<'a>> {}",
        );
    }
+    #[test]
+    fn test_unrelated_new() {
+        check_assist(
+            add_new,
+            r##"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+pub struct Source<T> {
+    pub file_id: HirFileId,<|>
+    pub ast: T,
+}
+impl<T> Source<T> {
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+}
+"##,
+            r##"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+pub struct Source<T> {
+    pub file_id: HirFileId,
+    pub ast: T,
+}
+impl<T> Source<T> {
+    pub fn new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }<|>
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+}
+"##,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 2b74f355c..b851c2082 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -47,8 +47,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
    let expr = match_expr.expr()?;
    let enum_def = {
-        let file_id = ctx.frange.file_id;
+        let analyzer = ctx.source_analyzer(expr.syntax(), None);
-        let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, expr.syntax(), None);
        resolve_enum_def(ctx.db, &analyzer, &expr)?
    };
    let variant_list = enum_def.variant_list()?;
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index a7fd9b6d2..18a34502c 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -45,7 +45,7 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
    } else {
        let_stmt.syntax().text_range()
    };
-    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, bind_pat.syntax(), None);
+    let analyzer = ctx.source_analyzer(bind_pat.syntax(), None);
    let refs = analyzer.find_all_refs(&bind_pat);
    let mut wrap_in_parens = vec![true; refs.len()];
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/assists/raw_string.rs
index 58f7157ae..93912a470 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/assists/raw_string.rs
@@ -1,9 +1,9 @@
 use hir::db::HirDatabase;
 use ra_syntax::{
+    ast, AstToken,
    SyntaxKind::{RAW_STRING, STRING},
-    TextRange, TextUnit,
+    TextUnit,
 };
-use rustc_lexer;
 use crate::{Assist, AssistCtx, AssistId};
@@ -23,32 +23,16 @@ use crate::{Assist, AssistCtx, AssistId};
 // }
 // ```
 pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let token = ctx.find_token_at_offset(STRING)?;
+    let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
-    let text = token.text().as_str();
+    let value = token.value()?;
-    let usual_string_range = find_usual_string_range(text)?;
-    let start_of_inside = usual_string_range.start().to_usize() + 1;
-    let end_of_inside = usual_string_range.end().to_usize();
-    let inside_str = &text[start_of_inside..end_of_inside];
-    let mut unescaped = String::with_capacity(inside_str.len());
-    let mut error = Ok(());
-    rustc_lexer::unescape::unescape_str(
-        inside_str,
-        &mut |_, unescaped_char| match unescaped_char {
-            Ok(c) => unescaped.push(c),
-            Err(_) => error = Err(()),
-        },
-    );
-    if error.is_err() {
-        return None;
-    }
    ctx.add_assist(AssistId("make_raw_string"), "make raw string", |edit| {
-        edit.target(token.text_range());
+        edit.target(token.syntax().text_range());
-        let max_hash_streak = count_hashes(&unescaped);
+        let max_hash_streak = count_hashes(&value);
        let mut hashes = String::with_capacity(max_hash_streak + 1);
        for _ in 0..hashes.capacity() {
            hashes.push('#');
        }
-        edit.replace(token.text_range(), format!("r{}\"{}\"{}", hashes, unescaped, hashes));
+        edit.replace(token.syntax().text_range(), format!("r{}\"{}\"{}", hashes, value, hashes));
    })
 }
@@ -68,17 +52,13 @@ pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 // }
 // ```
 pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let token = ctx.find_token_at_offset(RAW_STRING)?;
+    let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
-    let text = token.text().as_str();
+    let value = token.value()?;
-    let usual_string_range = find_usual_string_range(text)?;
    ctx.add_assist(AssistId("make_usual_string"), "make usual string", |edit| {
-        edit.target(token.text_range());
+        edit.target(token.syntax().text_range());
        // parse inside string to escape `"`
-        let start_of_inside = usual_string_range.start().to_usize() + 1;
+        let escaped = value.escape_default().to_string();
-        let end_of_inside = usual_string_range.end().to_usize();
+        edit.replace(token.syntax().text_range(), format!("\"{}\"", escaped));
-        let inside_str = &text[start_of_inside..end_of_inside];
-        let escaped = inside_str.escape_default().to_string();
-        edit.replace(token.text_range(), format!("\"{}\"", escaped));
    })
 }
@@ -132,6 +112,7 @@ pub(crate) fn remove_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        edit.target(token.text_range());
        let result = &text[2..text.len() - 1];
        let result = if result.starts_with('\"') {
+            // FIXME: this logic is wrong, not only the last has has to handled specially
            // no more hash, escape
            let internal_str = &result[1..result.len() - 1];
            format!("\"{}\"", internal_str.escape_default().to_string())
@@ -154,20 +135,6 @@ fn count_hashes(s: &str) -> usize {
    max_hash_streak
 }
-fn find_usual_string_range(s: &str) -> Option<TextRange> {
-    let left_quote = s.find('"')?;
-    let right_quote = s.rfind('"')?;
-    if left_quote == right_quote {
-        // `s` only contains one quote
-        None
-    } else {
-        Some(TextRange::from_to(
-            TextUnit::from(left_quote as u32),
-            TextUnit::from(right_quote as u32),
-        ))
-    }
-}
 #[cfg(test)]
 mod test {
    use super::*;
diff --git a/crates/ra_batch/Cargo.toml b/crates/ra_batch/Cargo.toml
index d08c5ceac..35626d77d 100644
--- a/crates/ra_batch/Cargo.toml
+++ b/crates/ra_batch/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_batch"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 log = "0.4.5"
 rustc-hash = "1.0"
diff --git a/crates/ra_cfg/Cargo.toml b/crates/ra_cfg/Cargo.toml
index b28affc3a..dd5ff88b0 100644
--- a/crates/ra_cfg/Cargo.toml
+++ b/crates/ra_cfg/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_cfg"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 rustc-hash = "1.0.1"
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 04aba3743..3429a3c49 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -169,12 +169,12 @@ pub fn run(
    println!(
        "Expressions of unknown type: {} ({}%)",
        num_exprs_unknown,
-        (num_exprs_unknown * 100 / num_exprs)
+        if num_exprs > 0 { (num_exprs_unknown * 100 / num_exprs) } else { 100 }
    );
    println!(
        "Expressions of partially unknown type: {} ({}%)",
        num_exprs_partially_unknown,
-        (num_exprs_partially_unknown * 100 / num_exprs)
+        if num_exprs > 0 { (num_exprs_partially_unknown * 100 / num_exprs) } else { 100 }
    );
    println!("Type mismatches: {}", num_type_mismatches);
    println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index bf1f7920c..4ec09b6d9 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_db"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 salsa = "0.13.0"
 relative-path = "1.0.0"
diff --git a/crates/ra_fmt/Cargo.toml b/crates/ra_fmt/Cargo.toml
index ba7b3ceac..9969d4746 100644
--- a/crates/ra_fmt/Cargo.toml
+++ b/crates/ra_fmt/Cargo.toml
@@ -5,6 +5,9 @@ version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+[lib]
+doctest = false
 [dependencies]
 itertools = "0.8.0"
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 324961328..42ddfecc9 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_hir"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 arrayvec = "0.5.1"
 log = "0.4.5"
@@ -23,9 +26,9 @@ hir_def = { path = "../ra_hir_def", package = "ra_hir_def" }
 test_utils = { path = "../test_utils" }
 ra_prof = { path = "../ra_prof" }
-chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "50f9f636123bd88d0cc1b958749981d6702e4d05" }
+chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "a88cad7f0a69e05ba8f40b74c58a1c229c1b2478" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "50f9f636123bd88d0cc1b958749981d6702e4d05" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "a88cad7f0a69e05ba8f40b74c58a1c229c1b2478" }
-chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "50f9f636123bd88d0cc1b958749981d6702e4d05" }
+chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "a88cad7f0a69e05ba8f40b74c58a1c229c1b2478" }
 lalrpop-intern = "0.15.1"
 [dev-dependencies]
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 078bd8609..731cc1fff 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -11,7 +11,7 @@ use hir_def::{
    body::scope::ExprScopes,
    builtin_type::BuiltinType,
    type_ref::{Mutability, TypeRef},
-    CrateModuleId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
+    CrateModuleId, ImplId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
@@ -29,7 +29,6 @@ use crate::{
        AstItemDef, ConstId, EnumId, FunctionId, MacroDefId, StaticId, StructId, TraitId,
        TypeAliasId,
    },
-    impl_block::ImplBlock,
    resolve::{Resolver, Scope, TypeNs},
    traits::TraitData,
    ty::{InferenceResult, Namespace, TraitRef},
@@ -243,12 +242,8 @@ impl Module {
    }
    pub fn impl_blocks(self, db: &impl DefDatabase) -> Vec<ImplBlock> {
-        let module_impl_blocks = db.impls_in_module(self);
+        let def_map = db.crate_def_map(self.id.krate);
-        module_impl_blocks
+        def_map[self.id.module_id].impls.iter().copied().map(ImplBlock::from).collect()
-            .impls
-            .iter()
-            .map(|(impl_id, _)| ImplBlock::from_id(self, impl_id))
-            .collect()
    }
    fn with_module_id(self, module_id: CrateModuleId) -> Module {
@@ -693,8 +688,7 @@ impl Function {
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
+        ImplBlock::containing(db, self.into())
-        ImplBlock::containing(module_impls, self.into())
    }
    /// The containing trait, if this is a trait method definition.
@@ -759,8 +753,7 @@ impl Const {
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
+        ImplBlock::containing(db, self.into())
-        ImplBlock::containing(module_impls, self.into())
    }
    pub fn parent_trait(self, db: &impl DefDatabase) -> Option<Trait> {
@@ -973,8 +966,7 @@ impl TypeAlias {
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
+        ImplBlock::containing(db, self.into())
-        ImplBlock::containing(module_impls, self.into())
    }
    /// The containing trait, if this is a trait method definition.
@@ -1137,3 +1129,8 @@ pub struct GenericParam {
    pub(crate) parent: GenericDef,
    pub(crate) idx: u32,
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImplBlock {
+    pub(crate) id: ImplId,
+}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index c60029c01..d75d71d66 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -10,22 +10,23 @@ use crate::{
    debug::HirDebugDatabase,
    generics::{GenericDef, GenericParams},
    ids,
-    impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
    lang_item::{LangItemTarget, LangItems},
    traits::TraitData,
    ty::{
-        method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate,
+        method_resolution::CrateImplBlocks,
-        InferenceResult, Namespace, Substs, Ty, TypableDef, TypeCtor,
+        traits::{AssocTyValue, Impl},
+        CallableDef, FnSig, GenericPredicate, InferenceResult, Namespace, Substs, Ty, TypableDef,
+        TypeCtor,
    },
    type_alias::TypeAliasData,
-    Const, ConstData, Crate, DefWithBody, FnData, Function, Module, Static, StructField, Trait,
+    Const, ConstData, Crate, DefWithBody, FnData, Function, ImplBlock, Module, Static, StructField,
-    TypeAlias,
+    Trait, TypeAlias,
 };
 pub use hir_def::db::{
    BodyQuery, BodyWithSourceMapQuery, CrateDefMapQuery, DefDatabase2, DefDatabase2Storage,
-    EnumDataQuery, ExprScopesQuery, InternDatabase, InternDatabaseStorage, RawItemsQuery,
+    EnumDataQuery, ExprScopesQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage,
-    RawItemsWithSourceMapQuery, StructDataQuery,
+    RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery,
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
@@ -42,15 +43,6 @@ pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
    #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)]
    fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex;
-    #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)]
-    fn impls_in_module_with_source_map(
-        &self,
-        module: Module,
-    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
-    #[salsa::invoke(ModuleImplBlocks::impls_in_module_query)]
-    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
    #[salsa::invoke(crate::generics::GenericParams::generic_params_query)]
    fn generic_params(&self, def: GenericDef) -> Arc<GenericParams>;
@@ -128,27 +120,43 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
    #[salsa::interned]
    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> ids::TypeCtorId;
    #[salsa::interned]
-    fn intern_impl(&self, impl_: Impl) -> ids::GlobalImplId;
+    fn intern_chalk_impl(&self, impl_: Impl) -> ids::GlobalImplId;
+    #[salsa::interned]
+    fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> ids::AssocTyValueId;
    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: chalk_ir::TypeId) -> Arc<chalk_rust_ir::AssociatedTyDatum>;
+    fn associated_ty_data(
+        &self,
+        id: chalk_ir::TypeId,
+    ) -> Arc<chalk_rust_ir::AssociatedTyDatum<chalk_ir::family::ChalkIr>>;
    #[salsa::invoke(crate::ty::traits::chalk::trait_datum_query)]
    fn trait_datum(
        &self,
        krate: Crate,
        trait_id: chalk_ir::TraitId,
-    ) -> Arc<chalk_rust_ir::TraitDatum>;
+    ) -> Arc<chalk_rust_ir::TraitDatum<chalk_ir::family::ChalkIr>>;
    #[salsa::invoke(crate::ty::traits::chalk::struct_datum_query)]
    fn struct_datum(
        &self,
        krate: Crate,
        struct_id: chalk_ir::StructId,
-    ) -> Arc<chalk_rust_ir::StructDatum>;
+    ) -> Arc<chalk_rust_ir::StructDatum<chalk_ir::family::ChalkIr>>;
    #[salsa::invoke(crate::ty::traits::chalk::impl_datum_query)]
-    fn impl_datum(&self, krate: Crate, impl_id: chalk_ir::ImplId) -> Arc<chalk_rust_ir::ImplDatum>;
+    fn impl_datum(
+        &self,
+        krate: Crate,
+        impl_id: chalk_ir::ImplId,
+    ) -> Arc<chalk_rust_ir::ImplDatum<chalk_ir::family::ChalkIr>>;
+    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_value_query)]
+    fn associated_ty_value(
+        &self,
+        krate: Crate,
+        id: chalk_rust_ir::AssociatedTyValueId,
+    ) -> Arc<chalk_rust_ir::AssociatedTyValue<chalk_ir::family::ChalkIr>>;
    #[salsa::invoke(crate::ty::traits::trait_solve_query)]
    fn trait_solve(
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index 9633ef586..f2203e995 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -3,9 +3,9 @@
 //! It's unclear if we need this long-term, but it's definitelly useful while we
 //! are splitting the hir.
-use hir_def::{AdtId, DefWithBodyId, EnumVariantId, ModuleDefId};
+use hir_def::{AdtId, AssocItemId, DefWithBodyId, EnumVariantId, ModuleDefId};
-use crate::{Adt, DefWithBody, EnumVariant, ModuleDef};
+use crate::{Adt, AssocItem, DefWithBody, EnumVariant, ModuleDef};
 macro_rules! from_id {
    ($(($id:path, $ty:path)),*) => {$(
@@ -27,6 +27,7 @@ from_id![
    (hir_def::StaticId, crate::Static),
    (hir_def::ConstId, crate::Const),
    (hir_def::FunctionId, crate::Function),
+    (hir_def::ImplId, crate::ImplBlock),
    (hir_expand::MacroDefId, crate::MacroDef)
 ];
@@ -71,3 +72,13 @@ impl From<DefWithBody> for DefWithBodyId {
        }
    }
 }
+impl From<AssocItemId> for AssocItem {
+    fn from(def: AssocItemId) -> Self {
+        match def {
+            AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
+            AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
+            AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 7e5523c54..1c26756c9 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 use hir_def::{ModuleId, StructId, StructOrUnionId, UnionId};
-use hir_expand::name::AsName;
+use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
 use ra_syntax::{
    ast::{self, AstNode, NameOwner},
    match_ast,
@@ -11,8 +11,8 @@ use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
    ids::{AstItemDef, LocationCtx},
    Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasBody, HasSource, ImplBlock,
-    Local, Module, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union,
+    Local, MacroDef, Module, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias,
-    VariantDef,
+    Union, VariantDef,
 };
 pub trait FromSource: Sized {
@@ -77,19 +77,28 @@ impl FromSource for TypeAlias {
        Some(TypeAlias { id })
    }
 }
-// FIXME: add impl FromSource for MacroDef
+impl FromSource for MacroDef {
+    type Ast = ast::MacroCall;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let kind = MacroDefKind::Declarative;
+        let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
+        let module = Module::from_definition(db, Source::new(src.file_id, module_src))?;
+        let krate = module.krate().crate_id();
+        let ast_id = AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.ast));
+        let id: MacroDefId = MacroDefId { krate, ast_id, kind };
+        Some(MacroDef { id })
+    }
+}
 impl FromSource for ImplBlock {
    type Ast = ast::ImplBlock;
    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
-        let module_src = crate::ModuleSource::from_child_node(
+        let id = from_source(db, src)?;
-            db,
+        Some(ImplBlock { id })
-            src.file_id.original_file(db),
-            &src.ast.syntax(),
-        );
-        let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
-        let impls = module.impl_blocks(db);
-        impls.into_iter().find(|b| b.source(db) == src)
    }
 }
@@ -202,9 +211,8 @@ where
    N: AstNode,
    DEF: AstItemDef<N>,
 {
-    let module_src =
+    let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
-        crate::ModuleSource::from_child_node(db, src.file_id.original_file(db), &src.ast.syntax());
+    let module = Module::from_definition(db, Source::new(src.file_id, module_src))?;
-    let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
    let ctx = LocationCtx::new(db, module.id, src.file_id);
    Some(DEF::from_ast(ctx, &src.ast))
 }
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index fe083c0c6..2b59365fb 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -37,3 +37,9 @@ impl_intern_key!(TypeCtorId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct GlobalImplId(salsa::InternId);
 impl_intern_key!(GlobalImplId);
+/// This exists just for Chalk, because it needs a unique ID for each associated
+/// type value in an impl (even synthetic ones).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AssocTyValueId(salsa::InternId);
+impl_intern_key!(AssocTyValueId);
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index b1a014074..0c2bb8fee 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -1,88 +1,38 @@
 //! FIXME: write short doc here
-use rustc_hash::FxHashMap;
+use hir_def::{type_ref::TypeRef, AstItemDef};
-use std::sync::Arc;
+use ra_syntax::ast::{self};
-use hir_def::{attr::Attr, type_ref::TypeRef};
-use hir_expand::hygiene::Hygiene;
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
-use ra_cfg::CfgOptions;
-use ra_syntax::{
-    ast::{self, AstNode},
-    AstPtr,
-};
 use crate::{
-    code_model::{Module, ModuleSource},
    db::{AstDatabase, DefDatabase, HirDatabase},
    generics::HasGenericParams,
-    ids::LocationCtx,
-    ids::MacroCallLoc,
    resolve::Resolver,
    ty::Ty,
-    AssocItem, AstId, Const, Function, HasSource, HirFileId, MacroFileKind, Path, Source, TraitRef,
+    AssocItem, Crate, HasSource, ImplBlock, Module, Source, TraitRef,
-    TypeAlias,
 };
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImplSourceMap {
-    map: ArenaMap<ImplId, Source<AstPtr<ast::ImplBlock>>>,
-}
-impl ImplSourceMap {
-    fn insert(&mut self, impl_id: ImplId, file_id: HirFileId, impl_block: &ast::ImplBlock) {
-        let source = Source { file_id, ast: AstPtr::new(impl_block) };
-        self.map.insert(impl_id, source)
-    }
-    pub fn get(&self, db: &impl AstDatabase, impl_id: ImplId) -> Source<ast::ImplBlock> {
-        let src = self.map[impl_id];
-        let root = src.file_syntax(db);
-        src.map(|ptr| ptr.to_node(&root))
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImplBlock {
-    module: Module,
-    impl_id: ImplId,
-}
 impl HasSource for ImplBlock {
    type Ast = ast::ImplBlock;
    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ImplBlock> {
-        let source_map = db.impls_in_module_with_source_map(self.module).1;
+        self.id.source(db)
-        source_map.get(db, self.impl_id)
    }
 }
 impl ImplBlock {
-    pub(crate) fn containing(
+    pub(crate) fn containing(db: &impl DefDatabase, item: AssocItem) -> Option<ImplBlock> {
-        module_impl_blocks: Arc<ModuleImplBlocks>,
+        let module = item.module(db);
-        item: AssocItem,
+        let crate_def_map = db.crate_def_map(module.id.krate);
-    ) -> Option<ImplBlock> {
+        crate_def_map[module.id.module_id].impls.iter().copied().map(ImplBlock::from).find(|it| {
-        let impl_id = *module_impl_blocks.impls_by_def.get(&item)?;
+            db.impl_data(it.id).items().iter().copied().map(AssocItem::from).any(|it| it == item)
-        Some(ImplBlock { module: module_impl_blocks.module, impl_id })
+        })
-    }
-    pub(crate) fn from_id(module: Module, impl_id: ImplId) -> ImplBlock {
-        ImplBlock { module, impl_id }
-    }
-    pub fn id(&self) -> ImplId {
-        self.impl_id
-    }
-    pub fn module(&self) -> Module {
-        self.module
    }
    pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.impls_in_module(self.module).impls[self.impl_id].target_trait().cloned()
+        db.impl_data(self.id).target_trait().cloned()
    }
    pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
-        db.impls_in_module(self.module).impls[self.impl_id].target_type().clone()
+        db.impl_data(self.id).target_type().clone()
    }
    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
@@ -95,15 +45,23 @@ impl ImplBlock {
    }
    pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        db.impls_in_module(self.module).impls[self.impl_id].items().to_vec()
+        db.impl_data(self.id).items().iter().map(|it| (*it).into()).collect()
    }
    pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
-        db.impls_in_module(self.module).impls[self.impl_id].negative
+        db.impl_data(self.id).is_negative()
+    }
+    pub fn module(&self, db: &impl DefDatabase) -> Module {
+        self.id.module(db).into()
+    }
+    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
+        Crate { crate_id: self.module(db).id.krate }
    }
    pub(crate) fn resolver(&self, db: &impl DefDatabase) -> Resolver {
-        let r = self.module().resolver(db);
+        let r = self.module(db).resolver(db);
        // add generic params, if present
        let p = self.generic_params(db);
        let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
@@ -111,175 +69,3 @@ impl ImplBlock {
        r
    }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ImplData {
-    target_trait: Option<TypeRef>,
-    target_type: TypeRef,
-    items: Vec<AssocItem>,
-    negative: bool,
-}
-impl ImplData {
-    pub(crate) fn from_ast(
-        db: &(impl DefDatabase + AstDatabase),
-        file_id: HirFileId,
-        module: Module,
-        node: &ast::ImplBlock,
-    ) -> Self {
-        let target_trait = node.target_trait().map(TypeRef::from_ast);
-        let target_type = TypeRef::from_ast_opt(node.target_type());
-        let ctx = LocationCtx::new(db, module.id, file_id);
-        let negative = node.is_negative();
-        let items = if let Some(item_list) = node.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItem::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItem::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
-        ImplData { target_trait, target_type, items, negative }
-    }
-    pub fn target_trait(&self) -> Option<&TypeRef> {
-        self.target_trait.as_ref()
-    }
-    pub fn target_type(&self) -> &TypeRef {
-        &self.target_type
-    }
-    pub fn items(&self) -> &[AssocItem] {
-        &self.items
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ImplId(pub RawId);
-impl_arena_id!(ImplId);
-/// The collection of impl blocks is a two-step process: first we collect the
-/// blocks per-module; then we build an index of all impl blocks in the crate.
-/// This way, we avoid having to do this process for the whole crate whenever
-/// a file is changed; as long as the impl blocks in the file don't change,
-/// we don't need to do the second step again.
-#[derive(Debug, PartialEq, Eq)]
-pub struct ModuleImplBlocks {
-    pub(crate) module: Module,
-    pub(crate) impls: Arena<ImplId, ImplData>,
-    impls_by_def: FxHashMap<AssocItem, ImplId>,
-}
-impl ModuleImplBlocks {
-    pub(crate) fn impls_in_module_with_source_map_query(
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
-        let mut source_map = ImplSourceMap::default();
-        let crate_graph = db.crate_graph();
-        let cfg_options = crate_graph.cfg_options(module.id.krate);
-        let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
-        (Arc::new(result), Arc::new(source_map))
-    }
-    pub(crate) fn impls_in_module_query(
-        db: &impl DefDatabase,
-        module: Module,
-    ) -> Arc<ModuleImplBlocks> {
-        db.impls_in_module_with_source_map(module).0
-    }
-    fn collect(
-        db: &(impl DefDatabase + AstDatabase),
-        cfg_options: &CfgOptions,
-        module: Module,
-        source_map: &mut ImplSourceMap,
-    ) -> Self {
-        let mut m = ModuleImplBlocks {
-            module,
-            impls: Arena::default(),
-            impls_by_def: FxHashMap::default(),
-        };
-        let src = m.module.definition_source(db);
-        match &src.ast {
-            ModuleSource::SourceFile(node) => {
-                m.collect_from_item_owner(db, cfg_options, source_map, node, src.file_id)
-            }
-            ModuleSource::Module(node) => {
-                let item_list = node.item_list().expect("inline module should have item list");
-                m.collect_from_item_owner(db, cfg_options, source_map, &item_list, src.file_id)
-            }
-        };
-        m
-    }
-    fn collect_from_item_owner(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        cfg_options: &CfgOptions,
-        source_map: &mut ImplSourceMap,
-        owner: &dyn ast::ModuleItemOwner,
-        file_id: HirFileId,
-    ) {
-        let hygiene = Hygiene::new(db, file_id);
-        for item in owner.items_with_macros() {
-            match item {
-                ast::ItemOrMacro::Item(ast::ModuleItem::ImplBlock(impl_block_ast)) => {
-                    let attrs = Attr::from_attrs_owner(&impl_block_ast, &hygiene);
-                    if attrs.map_or(false, |attrs| {
-                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
-                    }) {
-                        continue;
-                    }
-                    let impl_block = ImplData::from_ast(db, file_id, self.module, &impl_block_ast);
-                    let id = self.impls.alloc(impl_block);
-                    for &impl_item in &self.impls[id].items {
-                        self.impls_by_def.insert(impl_item, id);
-                    }
-                    source_map.insert(id, file_id, &impl_block_ast);
-                }
-                ast::ItemOrMacro::Item(_) => (),
-                ast::ItemOrMacro::Macro(macro_call) => {
-                    let attrs = Attr::from_attrs_owner(&macro_call, &hygiene);
-                    if attrs.map_or(false, |attrs| {
-                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
-                    }) {
-                        continue;
-                    }
-                    //FIXME: we should really cut down on the boilerplate required to process a macro
-                    let ast_id = AstId::new(file_id, db.ast_id_map(file_id).ast_id(&macro_call));
-                    if let Some(path) =
-                        macro_call.path().and_then(|path| Path::from_src(path, &hygiene))
-                    {
-                        if let Some(def) = self.module.resolver(db).resolve_path_as_macro(db, &path)
-                        {
-                            let call_id = db.intern_macro(MacroCallLoc { def: def.id, ast_id });
-                            let file_id = call_id.as_file(MacroFileKind::Items);
-                            if let Some(item_list) =
-                                db.parse_or_expand(file_id).and_then(ast::MacroItems::cast)
-                            {
-                                self.collect_from_item_owner(
-                                    db,
-                                    cfg_options,
-                                    source_map,
-                                    &item_list,
-                                    file_id,
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index e1780ed38..fa2ef8a17 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -25,7 +25,7 @@ impl LangItemTarget {
        Some(match self {
            LangItemTarget::Enum(e) => e.module(db).krate(),
            LangItemTarget::Function(f) => f.module(db).krate(),
-            LangItemTarget::ImplBlock(i) => i.module().krate(),
+            LangItemTarget::ImplBlock(i) => i.krate(db),
            LangItemTarget::Static(s) => s.module(db).krate(),
            LangItemTarget::Struct(s) => s.module(db).krate(),
            LangItemTarget::Trait(t) => t.module(db).krate(),
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 5ba847d35..da33c9591 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -54,12 +54,11 @@ mod test_db;
 #[cfg(test)]
 mod marks;
-use hir_expand::AstId;
+use crate::resolve::Resolver;
-use crate::{ids::MacroFileKind, resolve::Resolver};
 pub use crate::{
    adt::VariantDef,
+    code_model::ImplBlock,
    code_model::{
        attrs::{AttrDef, Attrs},
        docs::{DocDef, Docs, Documentation},
@@ -72,7 +71,6 @@ pub use crate::{
    from_source::FromSource,
    generics::GenericDef,
    ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
-    impl_block::ImplBlock,
    resolve::ScopeDef,
    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
    ty::{
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 2fb913108..79b92180a 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -15,9 +15,8 @@ use crate::{
    db::{DefDatabase, HirDatabase},
    expr::{ExprScopes, PatId, ScopeId},
    generics::GenericParams,
-    impl_block::ImplBlock,
+    Adt, Const, DefWithBody, Enum, EnumVariant, Function, ImplBlock, Local, MacroDef, ModuleDef,
-    Adt, Const, DefWithBody, Enum, EnumVariant, Function, Local, MacroDef, ModuleDef, PerNs,
+    PerNs, Static, Struct, Trait, TypeAlias,
-    Static, Struct, Trait, TypeAlias,
 };
 #[derive(Debug, Clone, Default)]
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 662d3f880..f0ed8e2b2 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -11,13 +11,12 @@ use hir_def::{
    expr::{ExprId, PatId},
    path::known,
 };
-use hir_expand::{name::AsName, Source};
+use hir_expand::{name::AsName, AstId, MacroCallId, MacroCallLoc, MacroFileKind, Source};
-use ra_db::FileId;
 use ra_syntax::{
    ast::{self, AstNode},
    match_ast, AstPtr,
    SyntaxKind::*,
-    SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
+    SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
 };
 use crate::{
@@ -30,52 +29,45 @@ use crate::{
    HirFileId, Local, MacroDef, Module, Name, Path, Resolver, Static, Struct, Ty,
 };
-fn try_get_resolver_for_node(
+fn try_get_resolver_for_node(db: &impl HirDatabase, node: Source<&SyntaxNode>) -> Option<Resolver> {
-    db: &impl HirDatabase,
-    file_id: FileId,
-    node: &SyntaxNode,
-) -> Option<Resolver> {
    match_ast! {
-        match node {
+        match (node.ast) {
            ast::Module(it) => {
-                let src = crate::Source { file_id: file_id.into(), ast: it };
+                let src = node.with_ast(it);
                Some(crate::Module::from_declaration(db, src)?.resolver(db))
            },
             ast::SourceFile(it) => {
-                let src =
+                let src = node.with_ast(crate::ModuleSource::SourceFile(it));
-                    crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(it) };
                Some(crate::Module::from_definition(db, src)?.resolver(db))
            },
            ast::StructDef(it) => {
-                let src = crate::Source { file_id: file_id.into(), ast: it };
+                let src = node.with_ast(it);
                Some(Struct::from_source(db, src)?.resolver(db))
            },
            ast::EnumDef(it) => {
-                let src = crate::Source { file_id: file_id.into(), ast: it };
+                let src = node.with_ast(it);
                Some(Enum::from_source(db, src)?.resolver(db))
            },
-            _ => {
+            _ => match node.ast.kind() {
-                if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
+                FN_DEF | CONST_DEF | STATIC_DEF => {
-                    Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
+                    Some(def_with_body_from_child_node(db, node)?.resolver(db))
-                } else {
-                    // FIXME add missing cases
-                    None
                }
-            },
+                // FIXME add missing cases
+                _ => None
+            }
        }
    }
 }
 fn def_with_body_from_child_node(
    db: &impl HirDatabase,
-    file_id: FileId,
+    child: Source<&SyntaxNode>,
-    node: &SyntaxNode,
 ) -> Option<DefWithBody> {
-    let src = crate::ModuleSource::from_child_node(db, file_id, node);
+    let module_source = crate::ModuleSource::from_child_node(db, child);
-    let module = Module::from_definition(db, crate::Source { file_id: file_id.into(), ast: src })?;
+    let module = Module::from_definition(db, Source::new(child.file_id, module_source))?;
-    let ctx = LocationCtx::new(db, module.id, file_id.into());
+    let ctx = LocationCtx::new(db, module.id, child.file_id);
-    node.ancestors().find_map(|node| {
+    child.ast.ancestors().find_map(|node| {
        match_ast! {
            match node {
                ast::FnDef(def)  => { Some(Function {id: ctx.to_def(&def) }.into()) },
@@ -91,8 +83,7 @@ fn def_with_body_from_child_node(
 /// original source files. It should not be used inside the HIR itself.
 #[derive(Debug)]
 pub struct SourceAnalyzer {
-    // FIXME: this doesn't handle macros at all
+    file_id: HirFileId,
-    file_id: FileId,
    resolver: Resolver,
    body_owner: Option<DefWithBody>,
    body_source_map: Option<Arc<BodySourceMap>>,
@@ -135,20 +126,38 @@ pub struct ReferenceDescriptor {
    pub name: String,
 }
+pub struct Expansion {
+    macro_call_id: MacroCallId,
+}
+impl Expansion {
+    pub fn map_token_down(
+        &self,
+        db: &impl HirDatabase,
+        token: Source<&SyntaxToken>,
+    ) -> Option<Source<SyntaxToken>> {
+        let exp_info = self.file_id().expansion_info(db)?;
+        exp_info.map_token_down(token)
+    }
+    fn file_id(&self) -> HirFileId {
+        self.macro_call_id.as_file(MacroFileKind::Items)
+    }
+}
 impl SourceAnalyzer {
    pub fn new(
        db: &impl HirDatabase,
-        file_id: FileId,
+        node: Source<&SyntaxNode>,
-        node: &SyntaxNode,
        offset: Option<TextUnit>,
    ) -> SourceAnalyzer {
-        let def_with_body = def_with_body_from_child_node(db, file_id, node);
+        let def_with_body = def_with_body_from_child_node(db, node);
        if let Some(def) = def_with_body {
            let source_map = def.body_source_map(db);
            let scopes = def.expr_scopes(db);
            let scope = match offset {
-                None => scope_for(&scopes, &source_map, file_id.into(), &node),
+                None => scope_for(&scopes, &source_map, node),
-                Some(offset) => scope_for_offset(&scopes, &source_map, file_id.into(), offset),
+                Some(offset) => scope_for_offset(&scopes, &source_map, node.with_ast(offset)),
            };
            let resolver = expr::resolver_for_scope(db, def, scope);
            SourceAnalyzer {
@@ -157,30 +166,31 @@ impl SourceAnalyzer {
                body_source_map: Some(source_map),
                infer: Some(def.infer(db)),
                scopes: Some(scopes),
-                file_id,
+                file_id: node.file_id,
            }
        } else {
            SourceAnalyzer {
                resolver: node
+                    .ast
                    .ancestors()
-                    .find_map(|node| try_get_resolver_for_node(db, file_id, &node))
+                    .find_map(|it| try_get_resolver_for_node(db, node.with_ast(&it)))
                    .unwrap_or_default(),
                body_owner: None,
                body_source_map: None,
                infer: None,
                scopes: None,
-                file_id,
+                file_id: node.file_id,
            }
        }
    }
    fn expr_id(&self, expr: &ast::Expr) -> Option<ExprId> {
-        let src = Source { file_id: self.file_id.into(), ast: expr };
+        let src = Source { file_id: self.file_id, ast: expr };
        self.body_source_map.as_ref()?.node_expr(src)
    }
    fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
-        let src = Source { file_id: self.file_id.into(), ast: pat };
+        let src = Source { file_id: self.file_id, ast: pat };
        self.body_source_map.as_ref()?.node_pat(src)
    }
@@ -288,7 +298,7 @@ impl SourceAnalyzer {
        let name = name_ref.as_name();
        let source_map = self.body_source_map.as_ref()?;
        let scopes = self.scopes.as_ref()?;
-        let scope = scope_for(scopes, source_map, self.file_id.into(), name_ref.syntax())?;
+        let scope = scope_for(scopes, source_map, Source::new(self.file_id, name_ref.syntax()))?;
        let entry = scopes.resolve_name_in_scope(scope, &name)?;
        Some(ScopeEntryWithSyntax {
            name: entry.name().clone(),
@@ -395,6 +405,13 @@ impl SourceAnalyzer {
        implements_trait(&canonical_ty, db, &self.resolver, krate, std_future_trait)
    }
+    pub fn expand(&self, db: &impl HirDatabase, macro_call: &ast::MacroCall) -> Option<Expansion> {
+        let def = self.resolve_macro_call(db, macro_call)?.id;
+        let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(macro_call));
+        let macro_call_loc = MacroCallLoc { def, ast_id };
+        Some(Expansion { macro_call_id: db.intern_macro(macro_call_loc) })
+    }
    #[cfg(test)]
    pub(crate) fn body_source_map(&self) -> Arc<BodySourceMap> {
        self.body_source_map.clone().unwrap()
@@ -409,20 +426,19 @@ impl SourceAnalyzer {
 fn scope_for(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
-    file_id: HirFileId,
+    node: Source<&SyntaxNode>,
-    node: &SyntaxNode,
 ) -> Option<ScopeId> {
-    node.ancestors()
+    node.ast
+        .ancestors()
        .filter_map(ast::Expr::cast)
-        .filter_map(|it| source_map.node_expr(Source { file_id, ast: &it }))
+        .filter_map(|it| source_map.node_expr(Source::new(node.file_id, &it)))
        .find_map(|it| scopes.scope_for(it))
 }
 fn scope_for_offset(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
-    file_id: HirFileId,
+    offset: Source<TextUnit>,
-    offset: TextUnit,
 ) -> Option<ScopeId> {
    scopes
        .scope_by_expr()
@@ -430,7 +446,7 @@ fn scope_for_offset(
        .filter_map(|(id, scope)| {
            let source = source_map.expr_syntax(*id)?;
            // FIXME: correctly handle macro expansion
-            if source.file_id != file_id {
+            if source.file_id != offset.file_id {
                return None;
            }
            let syntax_node_ptr =
@@ -439,9 +455,14 @@ fn scope_for_offset(
        })
        // find containing scope
        .min_by_key(|(ptr, _scope)| {
-            (!(ptr.range().start() <= offset && offset <= ptr.range().end()), ptr.range().len())
+            (
+                !(ptr.range().start() <= offset.ast && offset.ast <= ptr.range().end()),
+                ptr.range().len(),
+            )
+        })
+        .map(|(ptr, scope)| {
+            adjust(scopes, source_map, ptr, offset.file_id, offset.ast).unwrap_or(*scope)
        })
-        .map(|(ptr, scope)| adjust(scopes, source_map, ptr, file_id, offset).unwrap_or(*scope))
 }
 // XXX: during completion, cursor might be outside of any particular
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index ff6030ac4..b7f50b714 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -79,7 +79,7 @@ pub enum TypeCtor {
    ///
    /// For example the type of `bar` here:
    ///
-    /// ```rust
+    /// ```
    /// fn foo() -> i32 { 1 }
    /// let bar = foo; // bar: fn() -> i32 {foo}
    /// ```
@@ -89,7 +89,7 @@ pub enum TypeCtor {
    ///
    /// For example the type of `bar` here:
    ///
-    /// ```rust
+    /// ```
    /// fn foo() -> i32 { 1 }
    /// let bar: fn() -> i32 = foo;
    /// ```
@@ -224,8 +224,8 @@ impl TypeWalk for ProjectionTy {
        self.parameters.walk(f);
    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
-        self.parameters.walk_mut(f);
+        self.parameters.walk_mut_binders(f, binders);
    }
 }
@@ -291,6 +291,20 @@ pub enum Ty {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Substs(Arc<[Ty]>);
+impl TypeWalk for Substs {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
+        for t in self.0.iter() {
+            t.walk(f);
+        }
+    }
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
+        for t in make_mut_slice(&mut self.0) {
+            t.walk_mut_binders(f, binders);
+        }
+    }
+}
 impl Substs {
    pub fn empty() -> Substs {
        Substs(Arc::new([]))
@@ -304,18 +318,6 @@ impl Substs {
        Substs(self.0[..std::cmp::min(self.0.len(), n)].into())
    }
-    pub fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        for t in self.0.iter() {
-            t.walk(f);
-        }
-    }
-    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
-        for t in make_mut_slice(&mut self.0) {
-            t.walk_mut(f);
-        }
-    }
    pub fn as_single(&self) -> &Ty {
        if self.0.len() != 1 {
            panic!("expected substs of len 1, got {:?}", self);
@@ -440,8 +442,8 @@ impl TypeWalk for TraitRef {
        self.substs.walk(f);
    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
-        self.substs.walk_mut(f);
+        self.substs.walk_mut_binders(f, binders);
    }
 }
@@ -491,10 +493,12 @@ impl TypeWalk for GenericPredicate {
        }
    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
        match self {
-            GenericPredicate::Implemented(trait_ref) => trait_ref.walk_mut(f),
+            GenericPredicate::Implemented(trait_ref) => trait_ref.walk_mut_binders(f, binders),
-            GenericPredicate::Projection(projection_pred) => projection_pred.walk_mut(f),
+            GenericPredicate::Projection(projection_pred) => {
+                projection_pred.walk_mut_binders(f, binders)
+            }
            GenericPredicate::Error => {}
        }
    }
@@ -544,9 +548,9 @@ impl TypeWalk for FnSig {
        }
    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
        for t in make_mut_slice(&mut self.params_and_return) {
-            t.walk_mut(f);
+            t.walk_mut_binders(f, binders);
        }
    }
 }
@@ -671,7 +675,20 @@ impl Ty {
 /// types, similar to Chalk's `Fold` trait.
 pub trait TypeWalk {
    fn walk(&self, f: &mut impl FnMut(&Ty));
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty));
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        self.walk_mut_binders(&mut |ty, _binders| f(ty), 0);
+    }
+    /// Walk the type, counting entered binders.
+    ///
+    /// `Ty::Bound` variables use DeBruijn indexing, which means that 0 refers
+    /// to the innermost binder, 1 to the next, etc.. So when we want to
+    /// substitute a certain bound variable, we can't just walk the whole type
+    /// and blindly replace each instance of a certain index; when we 'enter'
+    /// things that introduce new bound variables, we have to keep track of
+    /// that. Currently, the only thing that introduces bound variables on our
+    /// side are `Ty::Dyn` and `Ty::Opaque`, which each introduce a bound
+    /// variable for the self type.
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize);
    fn fold(mut self, f: &mut impl FnMut(Ty) -> Ty) -> Self
    where
@@ -700,14 +717,22 @@ pub trait TypeWalk {
    }
    /// Substitutes `Ty::Bound` vars (as opposed to type parameters).
-    fn subst_bound_vars(self, substs: &Substs) -> Self
+    fn subst_bound_vars(mut self, substs: &Substs) -> Self
    where
        Self: Sized,
    {
-        self.fold(&mut |ty| match ty {
+        self.walk_mut_binders(
-            Ty::Bound(idx) => substs.get(idx as usize).cloned().unwrap_or_else(|| Ty::Bound(idx)),
+            &mut |ty, binders| match ty {
-            ty => ty,
+                &mut Ty::Bound(idx) => {
-        })
+                    if idx as usize >= binders && (idx as usize - binders) < substs.len() {
+                        *ty = substs.0[idx as usize - binders].clone();
+                    }
+                }
+                _ => {}
+            },
+            0,
+        );
+        self
    }
    /// Shifts up `Ty::Bound` vars by `n`.
@@ -748,22 +773,22 @@ impl TypeWalk for Ty {
        f(self);
    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
        match self {
            Ty::Apply(a_ty) => {
-                a_ty.parameters.walk_mut(f);
+                a_ty.parameters.walk_mut_binders(f, binders);
            }
            Ty::Projection(p_ty) => {
-                p_ty.parameters.walk_mut(f);
+                p_ty.parameters.walk_mut_binders(f, binders);
            }
            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
                for p in make_mut_slice(predicates) {
-                    p.walk_mut(f);
+                    p.walk_mut_binders(f, binders + 1);
                }
            }
            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
        }
-        f(self);
+        f(self, binders);
    }
 }
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index ca33cc7f8..64d9394cf 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -134,17 +134,19 @@ where
 }
 impl<T> Canonicalized<T> {
-    pub fn decanonicalize_ty(&self, ty: Ty) -> Ty {
+    pub fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty {
+        ty.walk_mut_binders(
-            Ty::Bound(idx) => {
+            &mut |ty, binders| match ty {
-                if (idx as usize) < self.free_vars.len() {
+                &mut Ty::Bound(idx) => {
-                    Ty::Infer(self.free_vars[idx as usize])
+                    if idx as usize >= binders && (idx as usize - binders) < self.free_vars.len() {
-                } else {
+                        *ty = Ty::Infer(self.free_vars[idx as usize - binders]);
-                    Ty::Bound(idx)
+                    }
                }
-            }
+                _ => {}
-            ty => ty,
+            },
-        })
+            0,
+        );
+        ty
    }
    pub fn apply_solution(
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index eb5ca6769..d20aeaacf 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -5,16 +5,14 @@
 use std::sync::Arc;
 use arrayvec::ArrayVec;
-use hir_def::CrateModuleId;
 use rustc_hash::FxHashMap;
 use crate::{
    db::HirDatabase,
-    impl_block::{ImplBlock, ImplId},
    resolve::Resolver,
    ty::primitive::{FloatBitness, Uncertain},
    ty::{Ty, TypeCtor},
-    AssocItem, Crate, Function, Module, Mutability, Name, Trait,
+    AssocItem, Crate, Function, ImplBlock, Module, Mutability, Name, Trait,
 };
 use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
@@ -39,65 +37,46 @@ impl TyFingerprint {
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplBlocks {
-    /// To make sense of the CrateModuleIds, we need the source root.
+    impls: FxHashMap<TyFingerprint, Vec<ImplBlock>>,
-    krate: Crate,
+    impls_by_trait: FxHashMap<Trait, Vec<ImplBlock>>,
-    impls: FxHashMap<TyFingerprint, Vec<(CrateModuleId, ImplId)>>,
-    impls_by_trait: FxHashMap<Trait, Vec<(CrateModuleId, ImplId)>>,
 }
 impl CrateImplBlocks {
-    pub fn lookup_impl_blocks<'a>(&'a self, ty: &Ty) -> impl Iterator<Item = ImplBlock> + 'a {
+    pub(crate) fn impls_in_crate_query(
+        db: &impl HirDatabase,
+        krate: Crate,
+    ) -> Arc<CrateImplBlocks> {
+        let mut crate_impl_blocks =
+            CrateImplBlocks { impls: FxHashMap::default(), impls_by_trait: FxHashMap::default() };
+        if let Some(module) = krate.root_module(db) {
+            crate_impl_blocks.collect_recursive(db, module);
+        }
+        Arc::new(crate_impl_blocks)
+    }
+    pub fn lookup_impl_blocks(&self, ty: &Ty) -> impl Iterator<Item = ImplBlock> + '_ {
        let fingerprint = TyFingerprint::for_impl(ty);
-        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flat_map(|i| i.iter()).map(
+        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied()
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
    }
-    pub fn lookup_impl_blocks_for_trait<'a>(
+    pub fn lookup_impl_blocks_for_trait(&self, tr: Trait) -> impl Iterator<Item = ImplBlock> + '_ {
-        &'a self,
+        self.impls_by_trait.get(&tr).into_iter().flatten().copied()
-        tr: Trait,
-    ) -> impl Iterator<Item = ImplBlock> + 'a {
-        self.impls_by_trait.get(&tr).into_iter().flat_map(|i| i.iter()).map(
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
    }
    pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplBlock> + 'a {
-        self.impls.values().chain(self.impls_by_trait.values()).flat_map(|i| i.iter()).map(
+        self.impls.values().chain(self.impls_by_trait.values()).flatten().copied()
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
    }
    fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) {
-        let module_impl_blocks = db.impls_in_module(module);
+        for impl_block in module.impl_blocks(db) {
-        for (impl_id, _) in module_impl_blocks.impls.iter() {
-            let impl_block = ImplBlock::from_id(module_impl_blocks.module, impl_id);
            let target_ty = impl_block.target_ty(db);
            if impl_block.target_trait(db).is_some() {
                if let Some(tr) = impl_block.target_trait_ref(db) {
-                    self.impls_by_trait
+                    self.impls_by_trait.entry(tr.trait_).or_default().push(impl_block);
-                        .entry(tr.trait_)
-                        .or_insert_with(Vec::new)
-                        .push((module.id.module_id, impl_id));
                }
            } else {
                if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
-                    self.impls
+                    self.impls.entry(target_ty_fp).or_default().push(impl_block);
-                        .entry(target_ty_fp)
-                        .or_insert_with(Vec::new)
-                        .push((module.id.module_id, impl_id));
                }
            }
        }
@@ -106,21 +85,6 @@ impl CrateImplBlocks {
            self.collect_recursive(db, child);
        }
    }
-    pub(crate) fn impls_in_crate_query(
-        db: &impl HirDatabase,
-        krate: Crate,
-    ) -> Arc<CrateImplBlocks> {
-        let mut crate_impl_blocks = CrateImplBlocks {
-            krate,
-            impls: FxHashMap::default(),
-            impls_by_trait: FxHashMap::default(),
-        };
-        if let Some(module) = krate.root_module(db) {
-            crate_impl_blocks.collect_recursive(db, module);
-        }
-        Arc::new(crate_impl_blocks)
-    }
 }
 fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayVec<[Crate; 2]>> {
@@ -264,14 +228,10 @@ fn iterate_trait_method_candidates<T>(
    'traits: for t in traits {
        let data = t.trait_data(db);
-        // FIXME this is a bit of a hack, since Chalk should say the same thing
-        // anyway, but currently Chalk doesn't implement `dyn/impl Trait` yet
-        let inherently_implemented = ty.value.inherent_trait() == Some(t);
        // we'll be lazy about checking whether the type implements the
        // trait, but if we find out it doesn't, we'll skip the rest of the
        // iteration
-        let mut known_implemented = inherently_implemented;
+        let mut known_implemented = false;
        for &item in data.items() {
            if !is_valid_candidate(db, name, mode, item) {
                continue;
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index fe9346c78..ca1693679 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1,3 +1,6 @@
+mod never_type;
+mod coercion;
 use std::fmt::Write;
 use std::sync::Arc;
@@ -11,7 +14,7 @@ use ra_syntax::{
 use test_utils::covers;
 use crate::{
-    expr::BodySourceMap, test_db::TestDB, ty::display::HirDisplay, ty::InferenceResult,
+    expr::BodySourceMap, test_db::TestDB, ty::display::HirDisplay, ty::InferenceResult, Source,
    SourceAnalyzer,
 };
@@ -19,9 +22,6 @@ use crate::{
 // against snapshots of the expected results using insta. Use cargo-insta to
 // update the snapshots.
-mod never_type;
-mod coercion;
 #[test]
 fn cfg_impl_block() {
    let (db, pos) = TestDB::with_position(
@@ -3983,11 +3983,11 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
    [180; 183) 'bar': fn bar() -> impl Trait<u64>
    [180; 185) 'bar()': impl Trait<u64>
    [191; 192) 'x': impl Trait<u64>
-    [191; 198) 'x.foo()': {unknown}
+    [191; 198) 'x.foo()': u64
    [204; 205) 'y': &impl Trait<u64>
-    [204; 211) 'y.foo()': {unknown}
+    [204; 211) 'y.foo()': u64
    [217; 218) 'z': impl Trait<u64>
-    [217; 224) 'z.foo()': {unknown}
+    [217; 224) 'z.foo()': u64
    [230; 231) 'x': impl Trait<u64>
    [230; 238) 'x.foo2()': i64
    [244; 245) 'y': &impl Trait<u64>
@@ -4033,11 +4033,11 @@ fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
    [177; 180) 'bar': fn bar() -> dyn Trait<u64>
    [177; 182) 'bar()': dyn Trait<u64>
    [188; 189) 'x': dyn Trait<u64>
-    [188; 195) 'x.foo()': {unknown}
+    [188; 195) 'x.foo()': u64
    [201; 202) 'y': &dyn Trait<u64>
-    [201; 208) 'y.foo()': {unknown}
+    [201; 208) 'y.foo()': u64
    [214; 215) 'z': dyn Trait<u64>
-    [214; 221) 'z.foo()': {unknown}
+    [214; 221) 'z.foo()': u64
    [227; 228) 'x': dyn Trait<u64>
    [227; 235) 'x.foo2()': i64
    [241; 242) 'y': &dyn Trait<u64>
@@ -4185,6 +4185,49 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
 }
 #[test]
+fn impl_trait_assoc_binding_projection_bug() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs crate:main deps:std
+pub trait Language {
+    type Kind;
+}
+pub enum RustLanguage {}
+impl Language for RustLanguage {
+    type Kind = SyntaxKind;
+}
+struct SyntaxNode<L> {}
+fn foo() -> impl Iterator<Item = SyntaxNode<RustLanguage>> {}
+trait Clone {
+    fn clone(&self) -> Self;
+}
+fn api_walkthrough() {
+    for node in foo() {
+        node.clone()<|>;
+    }
+}
+//- /std.rs crate:std
+#[prelude_import] use iter::*;
+mod iter {
+    trait IntoIterator {
+        type Item;
+    }
+    trait Iterator {
+        type Item;
+    }
+    impl<T: Iterator> IntoIterator for T {
+        type Item = <T as Iterator>::Item;
+    }
+}
+"#,
+    );
+    assert_eq!("{unknown}", type_at_pos(&db, pos));
+}
+#[test]
 fn projection_eq_within_chalk() {
    // std::env::set_var("CHALK_DEBUG", "1");
    assert_snapshot!(
@@ -4609,7 +4652,8 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
    let file = db.parse(pos.file_id).ok().unwrap();
    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
-    let analyzer = SourceAnalyzer::new(db, pos.file_id, expr.syntax(), Some(pos.offset));
+    let analyzer =
+        SourceAnalyzer::new(db, Source::new(pos.file_id.into(), expr.syntax()), Some(pos.offset));
    let ty = analyzer.type_of(db, &expr).unwrap();
    ty.display(db).to_string()
 }
@@ -4674,7 +4718,7 @@ fn infer(content: &str) -> String {
    for node in source_file.syntax().descendants() {
        if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
-            let analyzer = SourceAnalyzer::new(&db, file_id, &node, None);
+            let analyzer = SourceAnalyzer::new(&db, Source::new(file_id.into(), &node), None);
            infer_def(analyzer.inference_result(), analyzer.body_source_map());
        }
    }
@@ -4715,7 +4759,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        let file = db.parse(pos.file_id).ok().unwrap();
        let node = file.syntax().token_at_offset(pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            SourceAnalyzer::new(&db, pos.file_id, &node, None);
+            SourceAnalyzer::new(&db, Source::new(pos.file_id.into(), &node), None);
        });
        assert!(format!("{:?}", events).contains("infer"))
    }
@@ -4735,7 +4779,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        let file = db.parse(pos.file_id).ok().unwrap();
        let node = file.syntax().token_at_offset(pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            SourceAnalyzer::new(&db, pos.file_id, &node, None);
+            SourceAnalyzer::new(&db, Source::new(pos.file_id.into(), &node), None);
        });
        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
    }
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index 4f1eab150..45f725438 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -8,7 +8,7 @@ use ra_prof::profile;
 use rustc_hash::FxHashSet;
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
-use crate::{db::HirDatabase, expr::ExprId, Crate, DefWithBody, ImplBlock, Trait};
+use crate::{db::HirDatabase, expr::ExprId, Crate, DefWithBody, ImplBlock, Trait, TypeAlias};
 use self::chalk::{from_chalk, ToChalk};
@@ -17,7 +17,7 @@ pub(crate) mod chalk;
 #[derive(Debug, Clone)]
 pub struct TraitSolver {
    krate: Crate,
-    inner: Arc<Mutex<chalk_solve::Solver>>,
+    inner: Arc<Mutex<chalk_solve::Solver<ChalkIr>>>,
 }
 /// We need eq for salsa
@@ -34,7 +34,7 @@ impl TraitSolver {
        &self,
        db: &impl HirDatabase,
        goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<ChalkIr>>>,
-    ) -> Option<chalk_solve::Solution> {
+    ) -> Option<chalk_solve::Solution<ChalkIr>> {
        let context = ChalkContext { db, krate: self.krate };
        debug!("solve goal: {:?}", goal);
        let mut solver = match self.inner.lock() {
@@ -165,9 +165,9 @@ impl TypeWalk for ProjectionPredicate {
        self.ty.walk(f);
    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
-        self.projection_ty.walk_mut(f);
+        self.projection_ty.walk_mut_binders(f, binders);
-        self.ty.walk_mut(f);
+        self.ty.walk_mut_binders(f, binders);
    }
 }
@@ -188,6 +188,7 @@ pub(crate) fn trait_solve_query(
    }
    let canonical = goal.to_chalk(db).cast();
    // We currently don't deal with universes (I think / hope they're not yet
    // relevant for our use cases?)
    let u_canonical = chalk_ir::UCanonical { canonical, universes: 1 };
@@ -195,7 +196,10 @@ pub(crate) fn trait_solve_query(
    solution.map(|solution| solution_from_chalk(db, solution))
 }
-fn solution_from_chalk(db: &impl HirDatabase, solution: chalk_solve::Solution) -> Solution {
+fn solution_from_chalk(
+    db: &impl HirDatabase,
+    solution: chalk_solve::Solution<ChalkIr>,
+) -> Solution {
    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<ChalkIr>>| {
        let value = subst
            .value
@@ -300,3 +304,14 @@ pub enum Impl {
    /// Closure types implement the Fn traits synthetically.
    ClosureFnTraitImpl(ClosureFnTraitImplData),
 }
+/// An associated type value. Usually this comes from a `type` declaration
+/// inside an impl block, but for built-in impls we have to synthesize it.
+/// (We only need this because Chalk wants a unique ID for each of these.)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AssocTyValue {
+    /// A normal assoc type value from an impl block.
+    TypeAlias(TypeAlias),
+    /// The output type of the Fn trait implementation.
+    ClosureFnTraitImplOutput(ClosureFnTraitImplData),
+}
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 75351c17d..9bf93981a 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -7,22 +7,19 @@ use chalk_ir::{
    cast::Cast, family::ChalkIr, Identifier, ImplId, Parameter, PlaceholderIndex, TypeId,
    TypeKindId, TypeName, UniverseIndex,
 };
-use chalk_rust_ir::{AssociatedTyDatum, ImplDatum, StructDatum, TraitDatum};
+use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
 use hir_expand::name;
 use ra_db::salsa::{InternId, InternKey};
-use super::{Canonical, ChalkContext, Impl, Obligation};
+use super::{AssocTyValue, Canonical, ChalkContext, Impl, Obligation};
 use crate::{
    db::HirDatabase,
    generics::{GenericDef, HasGenericParams},
    ty::display::HirDisplay,
-    ty::{
+    ty::{ApplicationTy, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk},
-        ApplicationTy, GenericPredicate, Namespace, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    Crate, HasBody, ImplBlock, Trait, TypeAlias,
-        TypeWalk,
-    },
-    AssocItem, Crate, HasBody, ImplBlock, Trait, TypeAlias,
 };
 /// This represents a trait whose name we could not resolve.
@@ -59,29 +56,36 @@ impl ToChalk for Ty {
                    }
                };
                let parameters = apply_ty.parameters.to_chalk(db);
-                chalk_ir::ApplicationTy { name, parameters }.cast()
+                chalk_ir::ApplicationTy { name, parameters }.cast().intern()
            }
            Ty::Projection(proj_ty) => {
                let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
                let parameters = proj_ty.parameters.to_chalk(db);
-                chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast()
+                chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast().intern()
            }
            Ty::Param { idx, .. } => {
                PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }.to_ty::<ChalkIr>()
            }
-            Ty::Bound(idx) => chalk_ir::Ty::BoundVar(idx as usize),
+            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
-            // FIXME use Chalk's Dyn/Opaque once the bugs with that are fixed
+            Ty::Dyn(predicates) => {
-            Ty::Unknown | Ty::Dyn(_) | Ty::Opaque(_) => {
+                let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect();
+                chalk_ir::TyData::Dyn(make_binders(where_clauses, 1)).intern()
+            }
+            Ty::Opaque(predicates) => {
+                let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect();
+                chalk_ir::TyData::Opaque(make_binders(where_clauses, 1)).intern()
+            }
+            Ty::Unknown => {
                let parameters = Vec::new();
                let name = TypeName::Error;
-                chalk_ir::ApplicationTy { name, parameters }.cast()
+                chalk_ir::ApplicationTy { name, parameters }.cast().intern()
            }
        }
    }
    fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<ChalkIr>) -> Self {
-        match chalk {
+        match chalk.data().clone() {
-            chalk_ir::Ty::Apply(apply_ty) => {
+            chalk_ir::TyData::Apply(apply_ty) => {
                // FIXME this is kind of hacky due to the fact that
                // TypeName::Placeholder is a Ty::Param on our side
                match apply_ty.name {
@@ -104,21 +108,21 @@ impl ToChalk for Ty {
                    }
                }
            }
-            chalk_ir::Ty::Projection(proj) => {
+            chalk_ir::TyData::Projection(proj) => {
                let associated_ty = from_chalk(db, proj.associated_ty_id);
                let parameters = from_chalk(db, proj.parameters);
                Ty::Projection(ProjectionTy { associated_ty, parameters })
            }
-            chalk_ir::Ty::ForAll(_) => unimplemented!(),
+            chalk_ir::TyData::ForAll(_) => unimplemented!(),
-            chalk_ir::Ty::BoundVar(idx) => Ty::Bound(idx as u32),
+            chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32),
-            chalk_ir::Ty::InferenceVar(_iv) => Ty::Unknown,
+            chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
-            chalk_ir::Ty::Dyn(where_clauses) => {
+            chalk_ir::TyData::Dyn(where_clauses) => {
                assert_eq!(where_clauses.binders.len(), 1);
                let predicates =
                    where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect();
                Ty::Dyn(predicates)
            }
-            chalk_ir::Ty::Opaque(where_clauses) => {
+            chalk_ir::TyData::Opaque(where_clauses) => {
                assert_eq!(where_clauses.binders.len(), 1);
                let predicates =
                    where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect();
@@ -191,11 +195,11 @@ impl ToChalk for Impl {
    type Chalk = chalk_ir::ImplId;
    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ImplId {
-        db.intern_impl(self).into()
+        db.intern_chalk_impl(self).into()
    }
    fn from_chalk(db: &impl HirDatabase, impl_id: chalk_ir::ImplId) -> Impl {
-        db.lookup_intern_impl(impl_id.into())
+        db.lookup_intern_chalk_impl(impl_id.into())
    }
 }
@@ -211,6 +215,21 @@ impl ToChalk for TypeAlias {
    }
 }
+impl ToChalk for AssocTyValue {
+    type Chalk = chalk_rust_ir::AssociatedTyValueId;
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_rust_ir::AssociatedTyValueId {
+        db.intern_assoc_ty_value(self).into()
+    }
+    fn from_chalk(
+        db: &impl HirDatabase,
+        assoc_ty_value_id: chalk_rust_ir::AssociatedTyValueId,
+    ) -> AssocTyValue {
+        db.lookup_intern_assoc_ty_value(assoc_ty_value_id.into())
+    }
+}
 impl ToChalk for GenericPredicate {
    type Chalk = chalk_ir::QuantifiedWhereClause<ChalkIr>;
@@ -399,20 +418,20 @@ fn convert_where_clauses(
    result
 }
-impl<'a, DB> chalk_solve::RustIrDatabase for ChalkContext<'a, DB>
+impl<'a, DB> chalk_solve::RustIrDatabase<ChalkIr> for ChalkContext<'a, DB>
 where
    DB: HirDatabase,
 {
-    fn associated_ty_data(&self, id: TypeId) -> Arc<AssociatedTyDatum> {
+    fn associated_ty_data(&self, id: TypeId) -> Arc<AssociatedTyDatum<ChalkIr>> {
        self.db.associated_ty_data(id)
    }
-    fn trait_datum(&self, trait_id: chalk_ir::TraitId) -> Arc<TraitDatum> {
+    fn trait_datum(&self, trait_id: chalk_ir::TraitId) -> Arc<TraitDatum<ChalkIr>> {
        self.db.trait_datum(self.krate, trait_id)
    }
-    fn struct_datum(&self, struct_id: chalk_ir::StructId) -> Arc<StructDatum> {
+    fn struct_datum(&self, struct_id: chalk_ir::StructId) -> Arc<StructDatum<ChalkIr>> {
        self.db.struct_datum(self.krate, struct_id)
    }
-    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
+    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum<ChalkIr>> {
        self.db.impl_datum(self.krate, impl_id)
    }
    fn impls_for_trait(
@@ -462,13 +481,11 @@ where
    fn type_name(&self, _id: TypeKindId) -> Identifier {
        unimplemented!()
    }
-    fn split_projection<'p>(
+    fn associated_ty_value(
        &self,
-        projection: &'p chalk_ir::ProjectionTy<ChalkIr>,
+        id: chalk_rust_ir::AssociatedTyValueId,
-    ) -> (Arc<AssociatedTyDatum>, &'p [Parameter<ChalkIr>], &'p [Parameter<ChalkIr>]) {
+    ) -> Arc<AssociatedTyValue<ChalkIr>> {
-        debug!("split_projection {:?}", projection);
+        self.db.associated_ty_value(self.krate, id)
-        // we don't support GATs, so I think this should always be correct currently
-        (self.db.associated_ty_data(projection.associated_ty_id), &projection.parameters, &[])
    }
    fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<ChalkIr>> {
        vec![]
@@ -485,7 +502,7 @@ where
 pub(crate) fn associated_ty_data_query(
    db: &impl HirDatabase,
    id: TypeId,
-) -> Arc<AssociatedTyDatum> {
+) -> Arc<AssociatedTyDatum<ChalkIr>> {
    debug!("associated_ty_data {:?}", id);
    let type_alias: TypeAlias = from_chalk(db, id);
    let trait_ = match type_alias.container(db) {
@@ -493,19 +510,16 @@ pub(crate) fn associated_ty_data_query(
        _ => panic!("associated type not in trait"),
    };
    let generic_params = type_alias.generic_params(db);
-    let parameter_kinds = generic_params
+    let bound_data = chalk_rust_ir::AssociatedTyDatumBound {
-        .params_including_parent()
+        // FIXME add bounds and where clauses
-        .into_iter()
+        bounds: vec![],
-        .map(|p| chalk_ir::ParameterKind::Ty(lalrpop_intern::intern(&p.name.to_string())))
+        where_clauses: vec![],
-        .collect();
+    };
    let datum = AssociatedTyDatum {
        trait_id: trait_.to_chalk(db),
        id,
        name: lalrpop_intern::intern(&type_alias.name(db).to_string()),
-        parameter_kinds,
+        binders: make_binders(bound_data, generic_params.count_params_including_parent()),
-        // FIXME add bounds and where clauses
-        bounds: vec![],
-        where_clauses: vec![],
    };
    Arc::new(datum)
 }
@@ -514,17 +528,10 @@ pub(crate) fn trait_datum_query(
    db: &impl HirDatabase,
    krate: Crate,
    trait_id: chalk_ir::TraitId,
-) -> Arc<TraitDatum> {
+) -> Arc<TraitDatum<ChalkIr>> {
    debug!("trait_datum {:?}", trait_id);
    if trait_id == UNKNOWN_TRAIT {
-        let trait_datum_bound = chalk_rust_ir::TraitDatumBound {
+        let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses: Vec::new() };
-            trait_ref: chalk_ir::TraitRef {
-                trait_id: UNKNOWN_TRAIT,
-                parameters: vec![chalk_ir::Ty::BoundVar(0).cast()],
-            },
-            associated_ty_ids: Vec::new(),
-            where_clauses: Vec::new(),
-        };
        let flags = chalk_rust_ir::TraitFlags {
            auto: false,
@@ -532,18 +539,24 @@ pub(crate) fn trait_datum_query(
            upstream: true,
            fundamental: false,
            non_enumerable: true,
+            coinductive: false,
        };
-        return Arc::new(TraitDatum { binders: make_binders(trait_datum_bound, 1), flags });
+        return Arc::new(TraitDatum {
+            id: trait_id,
+            binders: make_binders(trait_datum_bound, 1),
+            flags,
+            associated_ty_ids: vec![],
+        });
    }
    let trait_: Trait = from_chalk(db, trait_id);
    debug!("trait {:?} = {:?}", trait_id, trait_.name(db));
    let generic_params = trait_.generic_params(db);
    let bound_vars = Substs::bound_vars(&generic_params);
-    let trait_ref = trait_.trait_ref(db).subst(&bound_vars).to_chalk(db);
    let flags = chalk_rust_ir::TraitFlags {
        auto: trait_.is_auto(db),
        upstream: trait_.module(db).krate() != krate,
        non_enumerable: true,
+        coinductive: false, // only relevant for Chalk testing
        // FIXME set these flags correctly
        marker: false,
        fundamental: false,
@@ -558,10 +571,13 @@ pub(crate) fn trait_datum_query(
        })
        .map(|type_alias| type_alias.to_chalk(db))
        .collect();
-    let trait_datum_bound =
+    let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses };
-        chalk_rust_ir::TraitDatumBound { trait_ref, where_clauses, associated_ty_ids };
+    let trait_datum = TraitDatum {
-    let trait_datum =
+        id: trait_id,
-        TraitDatum { binders: make_binders(trait_datum_bound, bound_vars.len()), flags };
+        binders: make_binders(trait_datum_bound, bound_vars.len()),
+        flags,
+        associated_ty_ids,
+    };
    Arc::new(trait_datum)
 }
@@ -569,7 +585,7 @@ pub(crate) fn struct_datum_query(
    db: &impl HirDatabase,
    krate: Crate,
    struct_id: chalk_ir::StructId,
-) -> Arc<StructDatum> {
+) -> Arc<StructDatum<ChalkIr>> {
    debug!("struct_datum {:?}", struct_id);
    let type_ctor: TypeCtor = from_chalk(db, struct_id);
    debug!("struct {:?} = {:?}", struct_id, type_ctor);
@@ -588,17 +604,12 @@ pub(crate) fn struct_datum_query(
        // FIXME set fundamental flag correctly
        fundamental: false,
    };
-    let self_ty = chalk_ir::ApplicationTy {
-        name: TypeName::TypeKindId(type_ctor.to_chalk(db).into()),
-        parameters: (0..num_params).map(|i| chalk_ir::Ty::BoundVar(i).cast()).collect(),
-    };
    let struct_datum_bound = chalk_rust_ir::StructDatumBound {
-        self_ty,
        fields: Vec::new(), // FIXME add fields (only relevant for auto traits)
        where_clauses,
-        flags,
    };
-    let struct_datum = StructDatum { binders: make_binders(struct_datum_bound, num_params) };
+    let struct_datum =
+        StructDatum { id: struct_id, binders: make_binders(struct_datum_bound, num_params), flags };
    Arc::new(struct_datum)
 }
@@ -606,16 +617,15 @@ pub(crate) fn impl_datum_query(
    db: &impl HirDatabase,
    krate: Crate,
    impl_id: ImplId,
-) -> Arc<ImplDatum> {
+) -> Arc<ImplDatum<ChalkIr>> {
    let _p = ra_prof::profile("impl_datum");
    debug!("impl_datum {:?}", impl_id);
    let impl_: Impl = from_chalk(db, impl_id);
    match impl_ {
        Impl::ImplBlock(impl_block) => impl_block_datum(db, krate, impl_id, impl_block),
-        Impl::ClosureFnTraitImpl(data) => {
+        Impl::ClosureFnTraitImpl(data) => closure_fn_trait_impl_datum(db, krate, data),
-            closure_fn_trait_impl_datum(db, krate, impl_id, data).unwrap_or_else(invalid_impl_datum)
-        }
    }
+    .unwrap_or_else(invalid_impl_datum)
 }
 fn impl_block_datum(
@@ -623,14 +633,12 @@ fn impl_block_datum(
    krate: Crate,
    impl_id: ImplId,
    impl_block: ImplBlock,
-) -> Arc<ImplDatum> {
+) -> Option<Arc<ImplDatum<ChalkIr>>> {
    let generic_params = impl_block.generic_params(db);
    let bound_vars = Substs::bound_vars(&generic_params);
-    let trait_ref = impl_block
+    let trait_ref = impl_block.target_trait_ref(db)?.subst(&bound_vars);
-        .target_trait_ref(db)
+    let trait_ = trait_ref.trait_;
-        .expect("FIXME handle unresolved impl block trait ref")
+    let impl_type = if impl_block.krate(db) == krate {
-        .subst(&bound_vars);
-    let impl_type = if impl_block.module().krate() == krate {
        chalk_rust_ir::ImplType::Local
    } else {
        chalk_rust_ir::ImplType::External
@@ -644,28 +652,7 @@ fn impl_block_datum(
        trait_ref.display(db),
        where_clauses
    );
-    let trait_ = trait_ref.trait_;
    let trait_ref = trait_ref.to_chalk(db);
-    let associated_ty_values = impl_block
-        .items(db)
-        .into_iter()
-        .filter_map(|item| match item {
-            AssocItem::TypeAlias(t) => Some(t),
-            _ => None,
-        })
-        .filter_map(|t| {
-            let assoc_ty = trait_.associated_type_by_name(db, &t.name(db))?;
-            let ty = db.type_for_def(t.into(), Namespace::Types).subst(&bound_vars);
-            Some(chalk_rust_ir::AssociatedTyValue {
-                impl_id,
-                associated_ty_id: assoc_ty.to_chalk(db),
-                value: chalk_ir::Binders {
-                    value: chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) },
-                    binders: vec![], // we don't support GATs yet
-                },
-            })
-        })
-        .collect();
    let polarity = if negative {
        chalk_rust_ir::Polarity::Negative
@@ -673,31 +660,41 @@ fn impl_block_datum(
        chalk_rust_ir::Polarity::Positive
    };
-    let impl_datum_bound =
+    let impl_datum_bound = chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses };
-        chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses, associated_ty_values };
+    let associated_ty_value_ids = impl_block
+        .items(db)
+        .into_iter()
+        .filter_map(|item| match item {
+            crate::AssocItem::TypeAlias(type_alias) => Some(type_alias),
+            _ => None,
+        })
+        .filter(|type_alias| {
+            // don't include associated types that don't exist in the trait
+            trait_.associated_type_by_name(db, &type_alias.name(db)).is_some()
+        })
+        .map(|type_alias| AssocTyValue::TypeAlias(type_alias).to_chalk(db))
+        .collect();
    debug!("impl_datum: {:?}", impl_datum_bound);
    let impl_datum = ImplDatum {
        binders: make_binders(impl_datum_bound, bound_vars.len()),
        impl_type,
        polarity,
+        associated_ty_value_ids,
    };
-    Arc::new(impl_datum)
+    Some(Arc::new(impl_datum))
 }
-fn invalid_impl_datum() -> Arc<ImplDatum> {
+fn invalid_impl_datum() -> Arc<ImplDatum<ChalkIr>> {
    let trait_ref = chalk_ir::TraitRef {
        trait_id: UNKNOWN_TRAIT,
-        parameters: vec![chalk_ir::Ty::BoundVar(0).cast()],
+        parameters: vec![chalk_ir::TyData::BoundVar(0).cast().intern().cast()],
-    };
-    let impl_datum_bound = chalk_rust_ir::ImplDatumBound {
-        trait_ref,
-        where_clauses: Vec::new(),
-        associated_ty_values: Vec::new(),
    };
+    let impl_datum_bound = chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses: Vec::new() };
    let impl_datum = ImplDatum {
        binders: make_binders(impl_datum_bound, 1),
        impl_type: chalk_rust_ir::ImplType::External,
        polarity: chalk_rust_ir::Polarity::Positive,
+        associated_ty_value_ids: Vec::new(),
    };
    Arc::new(impl_datum)
 }
@@ -705,15 +702,19 @@ fn invalid_impl_datum() -> Arc<ImplDatum> {
 fn closure_fn_trait_impl_datum(
    db: &impl HirDatabase,
    krate: Crate,
-    impl_id: ImplId,
    data: super::ClosureFnTraitImplData,
-) -> Option<Arc<ImplDatum>> {
+) -> Option<Arc<ImplDatum<ChalkIr>>> {
    // for some closure |X, Y| -> Z:
    // impl<T, U, V> Fn<(T, U)> for closure<fn(T, U) -> V> { Output = V }
-    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
    let trait_ = get_fn_trait(db, krate, data.fn_trait)?; // get corresponding fn trait
+    // validate FnOnce trait, since we need it in the assoc ty value definition
+    // and don't want to return a valid value only to find out later that FnOnce
+    // is broken
+    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
+    fn_once_trait.associated_type_by_name(db, &name::OUTPUT_TYPE)?;
    let num_args: u16 = match &data.def.body(db)[data.expr] {
        crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
        _ => {
@@ -726,7 +727,6 @@ fn closure_fn_trait_impl_datum(
        TypeCtor::Tuple { cardinality: num_args },
        Substs::builder(num_args as usize).fill_with_bound_vars(0).build(),
    );
-    let output_ty = Ty::Bound(num_args.into());
    let sig_ty = Ty::apply(
        TypeCtor::FnPtr { num_args },
        Substs::builder(num_args as usize + 1).fill_with_bound_vars(0).build(),
@@ -739,32 +739,99 @@ fn closure_fn_trait_impl_datum(
        substs: Substs::build_for_def(db, trait_).push(self_ty).push(arg_ty).build(),
    };
-    let output_ty_id = fn_once_trait.associated_type_by_name(db, &name::OUTPUT_TYPE)?;
+    let output_ty_id = AssocTyValue::ClosureFnTraitImplOutput(data.clone()).to_chalk(db);
-    let output_ty_value = chalk_rust_ir::AssociatedTyValue {
-        associated_ty_id: output_ty_id.to_chalk(db),
-        impl_id,
-        value: make_binders(
-            chalk_rust_ir::AssociatedTyValueBound { ty: output_ty.to_chalk(db) },
-            0,
-        ),
-    };
    let impl_type = chalk_rust_ir::ImplType::External;
    let impl_datum_bound = chalk_rust_ir::ImplDatumBound {
        trait_ref: trait_ref.to_chalk(db),
        where_clauses: Vec::new(),
-        associated_ty_values: vec![output_ty_value],
    };
    let impl_datum = ImplDatum {
        binders: make_binders(impl_datum_bound, num_args as usize + 1),
        impl_type,
        polarity: chalk_rust_ir::Polarity::Positive,
+        associated_ty_value_ids: vec![output_ty_id],
    };
    Some(Arc::new(impl_datum))
 }
+pub(crate) fn associated_ty_value_query(
+    db: &impl HirDatabase,
+    krate: Crate,
+    id: chalk_rust_ir::AssociatedTyValueId,
+) -> Arc<chalk_rust_ir::AssociatedTyValue<ChalkIr>> {
+    let data: AssocTyValue = from_chalk(db, id);
+    match data {
+        AssocTyValue::TypeAlias(type_alias) => {
+            type_alias_associated_ty_value(db, krate, type_alias)
+        }
+        AssocTyValue::ClosureFnTraitImplOutput(data) => {
+            closure_fn_trait_output_assoc_ty_value(db, krate, data)
+        }
+    }
+}
+fn type_alias_associated_ty_value(
+    db: &impl HirDatabase,
+    _krate: Crate,
+    type_alias: TypeAlias,
+) -> Arc<AssociatedTyValue<ChalkIr>> {
+    let impl_block = type_alias.impl_block(db).expect("assoc ty value should be in impl");
+    let impl_id = Impl::ImplBlock(impl_block).to_chalk(db);
+    let trait_ = impl_block
+        .target_trait_ref(db)
+        .expect("assoc ty value should not exist") // we don't return any assoc ty values if the impl'd trait can't be resolved
+        .trait_;
+    let assoc_ty = trait_
+        .associated_type_by_name(db, &type_alias.name(db))
+        .expect("assoc ty value should not exist"); // validated when building the impl data as well
+    let generic_params = impl_block.generic_params(db);
+    let bound_vars = Substs::bound_vars(&generic_params);
+    let ty = db.type_for_def(type_alias.into(), crate::ty::Namespace::Types).subst(&bound_vars);
+    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
+    let value = chalk_rust_ir::AssociatedTyValue {
+        impl_id,
+        associated_ty_id: assoc_ty.to_chalk(db),
+        value: make_binders(value_bound, bound_vars.len()),
+    };
+    Arc::new(value)
+}
+fn closure_fn_trait_output_assoc_ty_value(
+    db: &impl HirDatabase,
+    krate: Crate,
+    data: super::ClosureFnTraitImplData,
+) -> Arc<AssociatedTyValue<ChalkIr>> {
+    let impl_id = Impl::ClosureFnTraitImpl(data.clone()).to_chalk(db);
+    let num_args: u16 = match &data.def.body(db)[data.expr] {
+        crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
+        _ => {
+            log::warn!("closure for closure type {:?} not found", data);
+            0
+        }
+    };
+    let output_ty = Ty::Bound(num_args.into());
+    let fn_once_trait =
+        get_fn_trait(db, krate, super::FnTrait::FnOnce).expect("assoc ty value should not exist");
+    let output_ty_id = fn_once_trait
+        .associated_type_by_name(db, &name::OUTPUT_TYPE)
+        .expect("assoc ty value should not exist");
+    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: output_ty.to_chalk(db) };
+    let value = chalk_rust_ir::AssociatedTyValue {
+        associated_ty_id: output_ty_id.to_chalk(db),
+        impl_id,
+        value: make_binders(value_bound, num_args as usize + 1),
+    };
+    Arc::new(value)
+}
 fn get_fn_trait(db: &impl HirDatabase, krate: Crate, fn_trait: super::FnTrait) -> Option<Trait> {
    let target = db.lang_item(krate, fn_trait.lang_item_name().into())?;
    match target {
@@ -803,3 +870,15 @@ impl From<crate::ids::GlobalImplId> for chalk_ir::ImplId {
        chalk_ir::ImplId(id_to_chalk(impl_id))
    }
 }
+impl From<chalk_rust_ir::AssociatedTyValueId> for crate::ids::AssocTyValueId {
+    fn from(id: chalk_rust_ir::AssociatedTyValueId) -> Self {
+        id_from_chalk(id.0)
+    }
+}
+impl From<crate::ids::AssocTyValueId> for chalk_rust_ir::AssociatedTyValueId {
+    fn from(assoc_ty_value_id: crate::ids::AssocTyValueId) -> Self {
+        chalk_rust_ir::AssociatedTyValueId(id_to_chalk(assoc_ty_value_id))
+    }
+}
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index 21262be79..7e65f4c1d 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_hir_def"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 log = "0.4.5"
 once_cell = "1.0.1"
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 40b5920d9..348aca07f 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,
    nameres::{
        raw::{ImportSourceMap, RawItems},
        CrateDefMap,
    },
-    DefWithBodyId, EnumId, StructOrUnionId,
+    DefWithBodyId, EnumId, ImplId, ItemLoc, StructOrUnionId,
 };
 #[salsa::query_group(InternDatabaseStorage)]
 pub trait InternDatabase: SourceDatabase {
    #[salsa::interned]
-    fn intern_function(&self, loc: crate::ItemLoc<ast::FnDef>) -> crate::FunctionId;
+    fn intern_function(&self, loc: ItemLoc<ast::FnDef>) -> crate::FunctionId;
    #[salsa::interned]
-    fn intern_struct_or_union(&self, loc: crate::ItemLoc<ast::StructDef>)
+    fn intern_struct_or_union(&self, loc: ItemLoc<ast::StructDef>) -> crate::StructOrUnionId;
-        -> crate::StructOrUnionId;
    #[salsa::interned]
-    fn intern_enum(&self, loc: crate::ItemLoc<ast::EnumDef>) -> crate::EnumId;
+    fn intern_enum(&self, loc: ItemLoc<ast::EnumDef>) -> crate::EnumId;
    #[salsa::interned]
-    fn intern_const(&self, loc: crate::ItemLoc<ast::ConstDef>) -> crate::ConstId;
+    fn intern_const(&self, loc: ItemLoc<ast::ConstDef>) -> crate::ConstId;
    #[salsa::interned]
-    fn intern_static(&self, loc: crate::ItemLoc<ast::StaticDef>) -> crate::StaticId;
+    fn intern_static(&self, loc: ItemLoc<ast::StaticDef>) -> crate::StaticId;
    #[salsa::interned]
-    fn intern_trait(&self, loc: crate::ItemLoc<ast::TraitDef>) -> crate::TraitId;
+    fn intern_trait(&self, loc: ItemLoc<ast::TraitDef>) -> crate::TraitId;
    #[salsa::interned]
-    fn intern_type_alias(&self, loc: crate::ItemLoc<ast::TypeAliasDef>) -> crate::TypeAliasId;
+    fn intern_type_alias(&self, loc: ItemLoc<ast::TypeAliasDef>) -> crate::TypeAliasId;
+    #[salsa::interned]
+    fn intern_impl(&self, loc: ItemLoc<ast::ImplBlock>) -> crate::ImplId;
 }
 #[salsa::query_group(DefDatabase2Storage)]
@@ -54,6 +56,9 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
    #[salsa::invoke(EnumData::enum_data_query)]
    fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
+    #[salsa::invoke(ImplData::impl_data_query)]
+    fn impl_data(&self, e: ImplId) -> Arc<ImplData>;
    #[salsa::invoke(Body::body_with_source_map_query)]
    fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
diff --git a/crates/ra_hir_def/src/imp.rs b/crates/ra_hir_def/src/imp.rs
new file mode 100644
index 000000000..717991c40
--- /dev/null
+++ b/crates/ra_hir_def/src/imp.rs
@@ -0,0 +1,71 @@
+//! Defines hir-level representation of impls.
+//!
+//! The handling is similar, but is not quite the same as for other items,
+//! because `impl`s don't have names.
+use std::sync::Arc;
+use ra_syntax::ast;
+use crate::{
+    db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstId, FunctionId, ImplId,
+    LocationCtx, TypeAliasId,
+};
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplData {
+    target_trait: Option<TypeRef>,
+    target_type: TypeRef,
+    items: Vec<AssocItemId>,
+    negative: bool,
+}
+impl ImplData {
+    pub(crate) fn impl_data_query(db: &impl DefDatabase2, id: ImplId) -> Arc<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 items = if let Some(item_list) = src.ast.item_list() {
+            let ctx = LocationCtx::new(db, id.module(db), src.file_id);
+            item_list
+                .impl_items()
+                .map(|item_node| match item_node {
+                    ast::ImplItem::FnDef(it) => {
+                        FunctionId::from_ast_id(ctx, items.ast_id(&it)).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()
+                    }
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        let res = ImplData { target_trait, target_type, items, negative };
+        Arc::new(res)
+    }
+    pub fn target_trait(&self) -> Option<&TypeRef> {
+        self.target_trait.as_ref()
+    }
+    pub fn target_type(&self) -> &TypeRef {
+        &self.target_type
+    }
+    pub fn items(&self) -> &[AssocItemId] {
+        &self.items
+    }
+    pub fn is_negative(&self) -> bool {
+        self.negative
+    }
+}
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 3fab7965c..a240a10b8 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -13,6 +13,7 @@ pub mod path;
 pub mod type_ref;
 pub mod builtin_type;
 pub mod adt;
+pub mod imp;
 pub mod diagnostics;
 pub mod expr;
 pub mod body;
@@ -77,14 +78,13 @@ impl ModuleSource {
        }
    }
-    pub fn from_child_node(
+    pub fn from_child_node(db: &impl db::DefDatabase2, child: Source<&SyntaxNode>) -> ModuleSource {
-        db: &impl db::DefDatabase2,
+        if let Some(m) =
-        file_id: FileId,
+            child.ast.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
-        child: &SyntaxNode,
+        {
-    ) -> ModuleSource {
-        if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
            ModuleSource::Module(m)
        } else {
+            let file_id = child.file_id.original_file(db);
            let source_file = db.parse(file_id).tree();
            ModuleSource::SourceFile(source_file)
        }
@@ -321,6 +321,18 @@ impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
    }
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImplId(salsa::InternId);
+impl_intern_key!(ImplId);
+impl AstItemDef<ast::ImplBlock> for ImplId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::ImplBlock>) -> Self {
+        db.intern_impl(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::ImplBlock> {
+        db.lookup_intern_impl(self)
+    }
+}
 macro_rules! impl_froms {
    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
        $(
@@ -384,3 +396,15 @@ pub enum DefWithBodyId {
 }
 impl_froms!(DefWithBodyId: FunctionId, ConstId, StaticId);
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum AssocItemId {
+    FunctionId(FunctionId),
+    ConstId(ConstId),
+    TypeAliasId(TypeAliasId),
+}
+// FIXME: not every function, ... is actually an assoc item. maybe we should make
+// sure that you can only turn actual assoc items into AssocItemIds. This would
+// 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);
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 21d5f62e0..e5b073a0f 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -73,7 +73,7 @@ use crate::{
        diagnostics::DefDiagnostic, path_resolution::ResolveMode, per_ns::PerNs, raw::ImportId,
    },
    path::Path,
-    AstId, CrateModuleId, FunctionId, ModuleDefId, ModuleId, TraitId,
+    AstId, CrateModuleId, FunctionId, ImplId, ModuleDefId, ModuleId, TraitId,
 };
 /// Contains all top-level defs from a macro-expanded crate
@@ -122,16 +122,17 @@ pub struct ModuleData {
    ///
    /// Note that non-inline modules, by definition, live inside non-macro file.
    pub definition: Option<FileId>,
+    pub impls: Vec<ImplId>,
 }
-#[derive(Default, Debug, PartialEq, Eq, Clone)]
+#[derive(Default, Debug, PartialEq, Eq)]
 pub(crate) struct Declarations {
    fns: FxHashMap<FileAstId<ast::FnDef>, FunctionId>,
 }
-#[derive(Debug, Default, PartialEq, Eq, Clone)]
+#[derive(Debug, Default, PartialEq, Eq)]
 pub struct ModuleScope {
-    pub items: FxHashMap<Name, Resolution>,
+    items: FxHashMap<Name, Resolution>,
    /// Macros visable in current module in legacy textual scope
    ///
    /// For macros invoked by an unquatified identifier like `bar!()`, `legacy_macros` will be searched in first.
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 5c899aff3..8f426b097 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -19,7 +19,7 @@ use crate::{
        per_ns::PerNs, raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
    },
    path::{Path, PathKind},
-    AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId,
+    AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId, ImplId,
    LocationCtx, ModuleDefId, ModuleId, StaticId, StructId, StructOrUnionId, TraitId, TypeAliasId,
    UnionId,
 };
@@ -165,7 +165,7 @@ where
    /// crate::foo!();
    /// ```
    ///
-    /// Well, this code compiles, bacause the plain path `foo` in `use` is searched
+    /// Well, this code compiles, because the plain path `foo` in `use` is searched
    /// in the legacy textual scope only.
    /// ```rust
    /// macro_rules! foo { () => {} }
@@ -571,6 +571,15 @@ where
                        .push((self.module_id, import_id, self.raw_items[import_id].clone())),
                    raw::RawItemKind::Def(def) => self.define_def(&self.raw_items[def]),
                    raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+                    raw::RawItemKind::Impl(imp) => {
+                        let module = ModuleId {
+                            krate: self.def_collector.def_map.krate,
+                            module_id: self.module_id,
+                        };
+                        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
+                        let imp_id = ImplId::from_ast_id(ctx, self.raw_items[imp].ast_id);
+                        self.def_collector.def_map.modules[self.module_id].impls.push(imp_id)
+                    }
                }
            }
        }
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index f52002bc0..a0a2c7273 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -28,6 +28,7 @@ pub struct RawItems {
    imports: Arena<ImportId, ImportData>,
    defs: Arena<Def, DefData>,
    macros: Arena<Macro, MacroData>,
+    impls: Arena<Impl, ImplData>,
    /// items for top-level module
    items: Vec<RawItem>,
 }
@@ -121,6 +122,13 @@ impl Index<Macro> for RawItems {
    }
 }
+impl Index<Impl> for RawItems {
+    type Output = ImplData;
+    fn index(&self, idx: Impl) -> &ImplData {
+        &self.impls[idx]
+    }
+}
 // Avoid heap allocation on items without attributes.
 type Attrs = Option<Arc<[Attr]>>;
@@ -142,6 +150,7 @@ pub(super) enum RawItemKind {
    Import(ImportId),
    Def(Def),
    Macro(Macro),
+    Impl(Impl),
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -203,6 +212,15 @@ pub(super) struct MacroData {
    pub(super) builtin: bool,
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(super) struct Impl(RawId);
+impl_arena_id!(Impl);
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct ImplData {
+    pub(super) ast_id: FileAstId<ast::ImplBlock>,
+}
 struct RawItemsCollector {
    raw_items: RawItems,
    source_ast_id_map: Arc<AstIdMap>,
@@ -236,8 +254,8 @@ impl RawItemsCollector {
                self.add_extern_crate_item(current_module, extern_crate);
                return;
            }
-            ast::ModuleItem::ImplBlock(_) => {
+            ast::ModuleItem::ImplBlock(it) => {
-                // impls don't participate in name resolution
+                self.add_impl(current_module, it);
                return;
            }
            ast::ModuleItem::StructDef(it) => {
@@ -376,6 +394,13 @@ impl RawItemsCollector {
        self.push_item(current_module, attrs, RawItemKind::Macro(m));
    }
+    fn add_impl(&mut self, current_module: Option<Module>, imp: ast::ImplBlock) {
+        let attrs = self.parse_attrs(&imp);
+        let ast_id = self.source_ast_id_map.ast_id(&imp);
+        let imp = self.raw_items.impls.alloc(ImplData { ast_id });
+        self.push_item(current_module, attrs, RawItemKind::Impl(imp))
+    }
    fn push_import(
        &mut self,
        current_module: Option<Module>,
diff --git a/crates/ra_hir_expand/Cargo.toml b/crates/ra_hir_expand/Cargo.toml
index 8f29bf7d9..c60152a79 100644
--- a/crates/ra_hir_expand/Cargo.toml
+++ b/crates/ra_hir_expand/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_hir_expand"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 log = "0.4.5"
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 5eadee9c2..9de7c1ea8 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -32,10 +32,17 @@ impl TokenExpander {
        }
    }
-    pub fn shift(&self) -> u32 {
+    pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
        match self {
-            TokenExpander::MacroRules(it) => it.shift(),
+            TokenExpander::MacroRules(it) => it.map_id_down(id),
-            TokenExpander::Builtin(_) => 0,
+            TokenExpander::Builtin(..) => id,
+        }
+    }
+    pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
+        match self {
+            TokenExpander::MacroRules(it) => it.map_id_up(id),
+            TokenExpander::Builtin(..) => (id, mbe::Origin::Def),
        }
    }
 }
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 930789b0f..57e2e6cb1 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -18,8 +18,9 @@ use std::sync::Arc;
 use ra_db::{salsa, CrateId, FileId};
 use ra_syntax::{
+    algo,
    ast::{self, AstNode},
-    SyntaxNode, TextRange, TextUnit,
+    SyntaxNode, SyntaxToken, TextRange, TextUnit,
 };
 use crate::ast_id_map::FileAstId;
@@ -83,14 +84,21 @@ impl HirFileId {
                    loc.def.ast_id.to_node(db).token_tree()?.syntax().text_range().start();
                let macro_def = db.macro_def(loc.def)?;
-                let shift = macro_def.0.shift();
+                let (parse, exp_map) = db.parse_macro(macro_file)?;
-                let exp_map = db.parse_macro(macro_file)?.1;
+                let expanded = Source::new(self, parse.syntax_node());
                let macro_arg = db.macro_arg(macro_file.macro_call_id)?;
                let arg_start = (loc.ast_id.file_id, arg_start);
                let def_start = (loc.def.ast_id.file_id, def_start);
-                Some(ExpansionInfo { arg_start, def_start, macro_arg, macro_def, exp_map, shift })
+                Some(ExpansionInfo {
+                    expanded,
+                    arg_start,
+                    def_start,
+                    macro_arg,
+                    macro_def,
+                    exp_map,
+                })
            }
        }
    }
@@ -147,26 +155,42 @@ impl MacroCallId {
    }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 /// ExpansionInfo mainly describes how to map text range between src and expanded macro
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ExpansionInfo {
-    pub(crate) arg_start: (HirFileId, TextUnit),
+    expanded: Source<SyntaxNode>,
-    pub(crate) def_start: (HirFileId, TextUnit),
+    arg_start: (HirFileId, TextUnit),
-    pub(crate) shift: u32,
+    def_start: (HirFileId, TextUnit),
-    pub(crate) macro_def: Arc<(db::TokenExpander, mbe::TokenMap)>,
+    macro_def: Arc<(db::TokenExpander, mbe::TokenMap)>,
-    pub(crate) macro_arg: Arc<(tt::Subtree, mbe::TokenMap)>,
+    macro_arg: Arc<(tt::Subtree, mbe::TokenMap)>,
-    pub(crate) exp_map: Arc<mbe::RevTokenMap>,
+    exp_map: Arc<mbe::RevTokenMap>,
 }
 impl ExpansionInfo {
+    pub fn map_token_down(&self, token: Source<&SyntaxToken>) -> Option<Source<SyntaxToken>> {
+        assert_eq!(token.file_id, self.arg_start.0);
+        let range = token.ast.text_range().checked_sub(self.arg_start.1)?;
+        let token_id = self.macro_arg.1.token_by_range(range)?;
+        let token_id = self.macro_def.0.map_id_down(token_id);
+        let range = self.exp_map.range_by_token(token_id)?;
+        let token = algo::find_covering_element(&self.expanded.ast, range).into_token()?;
+        Some(self.expanded.with_ast(token))
+    }
+    // FIXME: a more correct signature would be
+    // `pub fn map_token_up(&self, token: Source<&SyntaxToken>) -> Option<Source<SyntaxToken>>`
    pub fn find_range(&self, from: TextRange) -> Option<(HirFileId, TextRange)> {
        let token_id = look_in_rev_map(&self.exp_map, from)?;
-        let (token_map, (file_id, start_offset), token_id) = if token_id.0 >= self.shift {
+        let (token_id, origin) = self.macro_def.0.map_id_up(token_id);
-            (&self.macro_arg.1, self.arg_start, tt::TokenId(token_id.0 - self.shift).into())
-        } else {
+        let (token_map, (file_id, start_offset)) = match origin {
-            (&self.macro_def.1, self.def_start, token_id)
+            mbe::Origin::Call => (&self.macro_arg.1, self.arg_start),
+            mbe::Origin::Def => (&self.macro_def.1, self.def_start),
        };
        let range = token_map.relative_range_of(token_id)?;
@@ -223,18 +247,30 @@ impl<N: AstNode> AstId<N> {
    }
 }
+/// FIXME: https://github.com/matklad/with ?
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct Source<T> {
    pub file_id: HirFileId,
+    // FIXME: this stores all kind of things, not only `ast`.
+    // There should be a better name...
    pub ast: T,
 }
 impl<T> Source<T> {
+    pub fn new(file_id: HirFileId, ast: T) -> Source<T> {
+        Source { file_id, ast }
+    }
+    // Similarly, naming here is stupid...
+    pub fn with_ast<U>(&self, ast: U) -> Source<U> {
+        Source::new(self.file_id, ast)
+    }
    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
-        Source { file_id: self.file_id, ast: f(self.ast) }
+        Source::new(self.file_id, f(self.ast))
    }
    pub fn as_ref(&self) -> Source<&T> {
-        Source { file_id: self.file_id, ast: &self.ast }
+        self.with_ast(&self.ast)
    }
    pub fn file_syntax(&self, db: &impl db::AstDatabase) -> SyntaxNode {
        db.parse_or_expand(self.file_id).expect("source created from invalid file")
diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml
index fa353b5dd..15346f388 100644
--- a/crates/ra_ide_api/Cargo.toml
+++ b/crates/ra_ide_api/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_ide_api"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [features]
 wasm = []
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 3572825b5..41ee81511 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -19,7 +19,11 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
    let calling_node = FnCallNode::with_node(&syntax, position.offset)?;
    let name_ref = calling_node.name_ref()?;
-    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
+    let analyzer = hir::SourceAnalyzer::new(
+        db,
+        hir::Source::new(position.file_id.into(), name_ref.syntax()),
+        None,
+    );
    let (mut call_info, has_self) = match &calling_node {
        FnCallNode::CallExpr(expr) => {
            //FIXME: apply subst
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 010b45141..5c9dec13e 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -271,7 +271,6 @@ impl RootDatabase {
        self.query(hir::db::AstIdMapQuery).sweep(sweep);
        self.query(hir::db::RawItemsWithSourceMapQuery).sweep(sweep);
-        self.query(hir::db::ImplsInModuleWithSourceMapQuery).sweep(sweep);
        self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep);
        self.query(hir::db::ExprScopesQuery).sweep(sweep);
@@ -314,8 +313,6 @@ impl RootDatabase {
            hir::db::RawItemsWithSourceMapQuery
            hir::db::RawItemsQuery
            hir::db::CrateDefMapQuery
-            hir::db::ImplsInModuleWithSourceMapQuery
-            hir::db::ImplsInModuleQuery
            hir::db::GenericParamsQuery
            hir::db::FnDataQuery
            hir::db::TypeAliasDataQuery
@@ -340,6 +337,7 @@ impl RootDatabase {
            hir::db::TraitDatumQuery
            hir::db::StructDatumQuery
            hir::db::ImplDatumQuery
+            hir::db::ImplDataQuery
            hir::db::TraitSolveQuery
        ];
        acc.sort_by_key(|it| std::cmp::Reverse(it.1));
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 64cbc0f98..0906a4e1b 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -58,8 +58,11 @@ impl<'a> CompletionContext<'a> {
        );
        let token =
            original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
-        let analyzer =
+        let analyzer = hir::SourceAnalyzer::new(
-            hir::SourceAnalyzer::new(db, position.file_id, &token.parent(), Some(position.offset));
+            db,
+            hir::Source::new(position.file_id.into(), &token.parent()),
+            Some(position.offset),
+        );
        let mut ctx = CompletionContext {
            db,
            analyzer,
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 6c8387f6c..b693a4c31 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -1,10 +1,11 @@
 //! FIXME: write short doc here
-use ra_db::{FileId, SourceDatabase};
+use std::iter::successors;
+use hir::{db::AstDatabase, Source};
 use ra_syntax::{
-    algo::find_node_at_offset,
    ast::{self, DocCommentsOwner},
-    match_ast, AstNode, SyntaxNode,
+    match_ast, AstNode, SyntaxNode, SyntaxToken,
 };
 use crate::{
@@ -18,17 +19,42 @@ pub(crate) fn goto_definition(
    db: &RootDatabase,
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let parse = db.parse(position.file_id);
+    let token = descend_into_macros(db, position)?;
-    let syntax = parse.tree().syntax().clone();
-    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&syntax, position.offset) {
+    let res = match_ast! {
-        let navs = reference_definition(db, position.file_id, &name_ref).to_vec();
+        match (token.ast.parent()) {
-        return Some(RangeInfo::new(name_ref.syntax().text_range(), navs.to_vec()));
+            ast::NameRef(name_ref) => {
-    }
+                let navs = reference_definition(db, token.with_ast(&name_ref)).to_vec();
-    if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
+                RangeInfo::new(name_ref.syntax().text_range(), navs.to_vec())
-        let navs = name_definition(db, position.file_id, &name)?;
+            },
-        return Some(RangeInfo::new(name.syntax().text_range(), navs));
+            ast::Name(name) => {
-    }
+                let navs = name_definition(db, token.with_ast(&name))?;
-    None
+                RangeInfo::new(name.syntax().text_range(), navs)
+            },
+            _ => return None,
+        }
+    };
+    Some(res)
+}
+fn descend_into_macros(db: &RootDatabase, position: FilePosition) -> Option<Source<SyntaxToken>> {
+    let file = db.parse_or_expand(position.file_id.into())?;
+    let token = file.token_at_offset(position.offset).filter(|it| !it.kind().is_trivia()).next()?;
+    successors(Some(Source::new(position.file_id.into(), token)), |token| {
+        let macro_call = token.ast.ancestors().find_map(ast::MacroCall::cast)?;
+        let tt = macro_call.token_tree()?;
+        if !token.ast.text_range().is_subrange(&tt.syntax().text_range()) {
+            return None;
+        }
+        let source_analyzer =
+            hir::SourceAnalyzer::new(db, token.with_ast(token.ast.parent()).as_ref(), None);
+        let exp = source_analyzer.expand(db, &macro_call)?;
+        exp.map_token_down(db, token.as_ref())
+    })
+    .last()
 }
 #[derive(Debug)]
@@ -49,12 +75,11 @@ impl ReferenceResult {
 pub(crate) fn reference_definition(
    db: &RootDatabase,
-    file_id: FileId,
+    name_ref: Source<&ast::NameRef>,
-    name_ref: &ast::NameRef,
 ) -> ReferenceResult {
    use self::ReferenceResult::*;
-    let name_kind = classify_name_ref(db, file_id, &name_ref).map(|d| d.kind);
+    let name_kind = classify_name_ref(db, name_ref).map(|d| d.kind);
    match name_kind {
        Some(Macro(mac)) => return Exact(mac.to_nav(db)),
        Some(Field(field)) => return Exact(field.to_nav(db)),
@@ -76,7 +101,7 @@ pub(crate) fn reference_definition(
    };
    // Fallback index based approach:
-    let navs = crate::symbol_index::index_resolve(db, name_ref)
+    let navs = crate::symbol_index::index_resolve(db, name_ref.ast)
        .into_iter()
        .map(|s| s.to_nav(db))
        .collect();
@@ -85,14 +110,13 @@ pub(crate) fn reference_definition(
 pub(crate) fn name_definition(
    db: &RootDatabase,
-    file_id: FileId,
+    name: Source<&ast::Name>,
-    name: &ast::Name,
 ) -> Option<Vec<NavigationTarget>> {
-    let parent = name.syntax().parent()?;
+    let parent = name.ast.syntax().parent()?;
    if let Some(module) = ast::Module::cast(parent.clone()) {
        if module.has_semi() {
-            let src = hir::Source { file_id: file_id.into(), ast: module };
+            let src = name.with_ast(module);
            if let Some(child_module) = hir::Module::from_declaration(db, src) {
                let nav = child_module.to_nav(db);
                return Some(vec![nav]);
@@ -100,20 +124,20 @@ pub(crate) fn name_definition(
        }
    }
-    if let Some(nav) = named_target(db, file_id, &parent) {
+    if let Some(nav) = named_target(db, name.with_ast(&parent)) {
        return Some(vec![nav]);
    }
    None
 }
-fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option<NavigationTarget> {
+fn named_target(db: &RootDatabase, node: Source<&SyntaxNode>) -> Option<NavigationTarget> {
    match_ast! {
-        match node {
+        match (node.ast) {
            ast::StructDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -122,7 +146,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::EnumDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -131,7 +155,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::EnumVariant(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -140,7 +164,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::FnDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -149,7 +173,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::TypeAliasDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -158,7 +182,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::ConstDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -167,7 +191,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::StaticDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -176,7 +200,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::TraitDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -185,7 +209,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::RecordFieldDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -194,7 +218,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::Module(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    it.short_label(),
@@ -203,7 +227,7 @@ fn named_target(db: &RootDatabase, file_id: FileId, node: &SyntaxNode) -> Option
            ast::MacroCall(it) => {
                Some(NavigationTarget::from_named(
                    db,
-                    file_id.into(),
+                    node.file_id,
                    &it,
                    it.doc_comment_text(),
                    None,
@@ -677,4 +701,23 @@ mod tests {
            "bar MODULE FileId(1) [0; 11) [4; 7)",
        );
    }
+    #[test]
+    fn goto_from_macro() {
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! id {
+                ($($tt:tt)*) => { $($tt)* }
+            }
+            fn foo() {}
+            id! {
+                fn bar() {
+                    fo<|>o();
+                }
+            }
+            ",
+            "foo FN_DEF FileId(1) [52; 63) [55; 58)",
+        );
+    }
 }
diff --git a/crates/ra_ide_api/src/goto_type_definition.rs b/crates/ra_ide_api/src/goto_type_definition.rs
index 71146591d..2327cb1e7 100644
--- a/crates/ra_ide_api/src/goto_type_definition.rs
+++ b/crates/ra_ide_api/src/goto_type_definition.rs
@@ -18,7 +18,8 @@ pub(crate) fn goto_type_definition(
            .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())
    })?;
-    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, &node, None);
+    let analyzer =
+        hir::SourceAnalyzer::new(db, hir::Source::new(position.file_id.into(), &node), None);
    let ty: hir::Ty = if let Some(ty) =
        ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index 07d511fb3..cc25f4c37 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use hir::{Adt, HasSource, HirDisplay};
+use hir::{Adt, HasSource, HirDisplay, Source};
 use ra_db::SourceDatabase;
 use ra_syntax::{
    algo::{ancestors_at_offset, find_covering_element, find_node_at_offset},
@@ -171,7 +171,8 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
        find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset)
    {
        let mut no_fallback = false;
-        if let Some(name_kind) = classify_name_ref(db, position.file_id, &name_ref).map(|d| d.kind)
+        if let Some(name_kind) =
+            classify_name_ref(db, Source::new(position.file_id.into(), &name_ref)).map(|d| d.kind)
        {
            res.extend(hover_text_from_name_kind(db, name_kind, &mut no_fallback))
        }
@@ -230,7 +231,8 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
        .ancestors()
        .take_while(|it| it.text_range() == leaf_node.text_range())
        .find(|it| ast::Expr::cast(it.clone()).is_some() || ast::Pat::cast(it.clone()).is_some())?;
-    let analyzer = hir::SourceAnalyzer::new(db, frange.file_id, &node, None);
+    let analyzer =
+        hir::SourceAnalyzer::new(db, hir::Source::new(frange.file_id.into(), &node), None);
    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
    {
        ty
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
index 2ff10b89a..0cd959848 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -32,6 +32,7 @@ fn get_inlay_hints(
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<Vec<InlayHint>> {
+    let analyzer = SourceAnalyzer::new(db, hir::Source::new(file_id.into(), node), None);
    match_ast! {
        match node {
            ast::LetStmt(it) => {
@@ -39,11 +40,9 @@ fn get_inlay_hints(
                    return None;
                }
                let pat = it.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, false))
            },
            ast::LambdaExpr(it) => {
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                it.param_list().map(|param_list| {
                    param_list
                        .params()
@@ -56,21 +55,17 @@ fn get_inlay_hints(
            },
            ast::ForExpr(it) => {
                let pat = it.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, false))
            },
            ast::IfExpr(it) => {
                let pat = it.condition()?.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, true))
            },
            ast::WhileExpr(it) => {
                let pat = it.condition()?.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, true))
            },
            ast::MatchArmList(it) => {
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(
                    it
                        .arms()
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 9cb9433e7..1af7e8a9f 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -14,6 +14,7 @@ mod name_definition;
 mod rename;
 mod search_scope;
+use hir::Source;
 use once_cell::unsync::Lazy;
 use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_prof::profile;
@@ -114,7 +115,7 @@ fn find_name<'a>(
        return Some(RangeInfo::new(range, (name.text().to_string(), def)));
    }
    let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
-    let def = classify_name_ref(db, position.file_id, &name_ref)?;
+    let def = classify_name_ref(db, Source::new(position.file_id.into(), &name_ref))?;
    let range = name_ref.syntax().text_range();
    Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
 }
@@ -146,7 +147,7 @@ fn process_definition(
                        continue;
                    }
                }
-                if let Some(d) = classify_name_ref(db, file_id, &name_ref) {
+                if let Some(d) = classify_name_ref(db, Source::new(file_id.into(), &name_ref)) {
                    if d == def {
                        refs.push(FileRange { file_id, range });
                    }
@@ -369,6 +370,21 @@ mod tests {
        assert_eq!(refs.len(), 2);
    }
+    #[test]
+    fn test_find_all_refs_macro_def() {
+        let code = r#"
+        #[macro_export]
+        macro_rules! m1<|> { () => (()) }
+        fn foo() {
+            m1();
+            m1();
+        }"#;
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 3);
+    }
    fn get_all_refs(text: &str) -> ReferenceSearchResult {
        let (analysis, position) = single_file_with_position(text);
        analysis.find_all_refs(position, None).unwrap().unwrap()
diff --git a/crates/ra_ide_api/src/references/classify.rs b/crates/ra_ide_api/src/references/classify.rs
index 217f9951e..5ca9da15e 100644
--- a/crates/ra_ide_api/src/references/classify.rs
+++ b/crates/ra_ide_api/src/references/classify.rs
@@ -21,7 +21,6 @@ pub(crate) fn classify_name(
    let parent = name.syntax().parent()?;
    let file_id = file_id.into();
-    // FIXME: add ast::MacroCall(it)
    match_ast! {
        match parent {
            ast::BindPat(it) => {
@@ -104,6 +103,19 @@ pub(crate) fn classify_name(
                    Some(from_module_def(db, def.into(), None))
                }
            },
+            ast::MacroCall(it) => {
+                let src = hir::Source { file_id, ast: it};
+                let def = hir::MacroDef::from_source(db, src.clone())?;
+                let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
+                let module = Module::from_definition(db, Source::new(file_id, module_src))?;
+                Some(NameDefinition {
+                    visibility: None,
+                    container: module,
+                    kind: NameKind::Macro(def),
+                })
+            },
            _ => None,
        }
    }
@@ -111,15 +123,12 @@ pub(crate) fn classify_name(
 pub(crate) fn classify_name_ref(
    db: &RootDatabase,
-    file_id: FileId,
+    name_ref: Source<&ast::NameRef>,
-    name_ref: &ast::NameRef,
 ) -> Option<NameDefinition> {
-    use PathResolution::*;
    let _p = profile("classify_name_ref");
-    let parent = name_ref.syntax().parent()?;
+    let parent = name_ref.ast.syntax().parent()?;
-    let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
+    let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None);
    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
        tested_by!(goto_definition_works_for_methods);
@@ -139,17 +148,16 @@ pub(crate) fn classify_name_ref(
        tested_by!(goto_definition_works_for_record_fields);
        if let Some(record_lit) = record_field.syntax().ancestors().find_map(ast::RecordLit::cast) {
            let variant_def = analyzer.resolve_record_literal(&record_lit)?;
-            let hir_path = Path::from_name_ref(name_ref);
+            let hir_path = Path::from_name_ref(name_ref.ast);
            let hir_name = hir_path.as_ident()?;
            let field = variant_def.field(db, hir_name)?;
            return Some(from_struct_field(db, field));
        }
    }
-    let ast = ModuleSource::from_child_node(db, file_id, &parent);
+    let ast = ModuleSource::from_child_node(db, name_ref.with_ast(&parent));
-    let file_id = file_id.into();
    // FIXME: find correct container and visibility for each case
-    let container = Module::from_definition(db, Source { file_id, ast })?;
+    let container = Module::from_definition(db, name_ref.with_ast(ast))?;
    let visibility = None;
    if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
@@ -160,29 +168,29 @@ pub(crate) fn classify_name_ref(
        }
    }
-    let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
+    let path = name_ref.ast.syntax().ancestors().find_map(ast::Path::cast)?;
    let resolved = analyzer.resolve_path(db, &path)?;
    match resolved {
-        Def(def) => Some(from_module_def(db, def, Some(container))),
+        PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))),
-        AssocItem(item) => Some(from_assoc_item(db, item)),
+        PathResolution::AssocItem(item) => Some(from_assoc_item(db, item)),
-        Local(local) => {
+        PathResolution::Local(local) => {
            let container = local.module(db);
            let kind = NameKind::Local(local);
            Some(NameDefinition { kind, container, visibility: None })
        }
-        GenericParam(par) => {
+        PathResolution::GenericParam(par) => {
            // FIXME: get generic param def
            let kind = NameKind::GenericParam(par);
            Some(NameDefinition { kind, container, visibility })
        }
-        Macro(def) => {
+        PathResolution::Macro(def) => {
            let kind = NameKind::Macro(def);
            Some(NameDefinition { kind, container, visibility })
        }
-        SelfType(impl_block) => {
+        PathResolution::SelfType(impl_block) => {
            let ty = impl_block.target_ty(db);
            let kind = NameKind::SelfType(ty);
-            let container = impl_block.module();
+            let container = impl_block.module(db);
            Some(NameDefinition { kind, container, visibility })
        }
    }
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 366ac8048..8039a5164 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -1,5 +1,6 @@
 //! FIXME: write short doc here
+use hir::Source;
 use itertools::Itertools;
 use ra_db::SourceDatabase;
 use ra_syntax::{
@@ -65,9 +66,8 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
        return None;
    }
    let range = module.syntax().text_range();
-    let src = hir::ModuleSource::from_child_node(db, file_id, &module.syntax());
+    let src = hir::ModuleSource::from_child_node(db, Source::new(file_id.into(), &module.syntax()));
-    let module =
+    let module = hir::Module::from_definition(db, Source::new(file_id.into(), src))?;
-        hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src })?;
    let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
    Some(Runnable { range, kind: RunnableKind::TestMod { path } })
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index d53a759ee..584657ca2 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -2,7 +2,7 @@
 use rustc_hash::{FxHashMap, FxHashSet};
-use hir::{Mutability, Name};
+use hir::{Mutability, Name, Source};
 use ra_db::SourceDatabase;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, TextRange, T};
@@ -80,7 +80,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                }
                let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-                let name_kind = classify_name_ref(db, file_id, &name_ref).map(|d| d.kind);
+                let name_kind =
+                    classify_name_ref(db, Source::new(file_id.into(), &name_ref)).map(|d| d.kind);
                if let Some(Local(local)) = &name_kind {
                    if let Some(name) = local.name(db) {
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index 743f6a60a..72dbe06dc 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_lsp_server"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 threadpool = "1.7.1"
 relative-path = "1.0.0"
diff --git a/crates/ra_mbe/Cargo.toml b/crates/ra_mbe/Cargo.toml
index b02e45ee3..a3fc01f63 100644
--- a/crates/ra_mbe/Cargo.toml
+++ b/crates/ra_mbe/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_mbe"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 ra_syntax = { path = "../ra_syntax" }
 ra_parser = { path = "../ra_parser" }
@@ -14,4 +17,3 @@ log = "0.4.5"
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 8a31d1c36..58ca95368 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -40,49 +40,75 @@ pub use crate::syntax_bridge::{
 /// and `$()*` have special meaning (see `Var` and `Repeat` data structures)
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct MacroRules {
-    pub(crate) rules: Vec<Rule>,
+    rules: Vec<Rule>,
    /// Highest id of the token we have in TokenMap
-    pub(crate) shift: u32,
+    shift: Shift,
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct Rule {
+struct Rule {
-    pub(crate) lhs: tt::Subtree,
+    lhs: tt::Subtree,
-    pub(crate) rhs: tt::Subtree,
+    rhs: tt::Subtree,
 }
-// Find the max token id inside a subtree
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-fn max_id(subtree: &tt::Subtree) -> Option<u32> {
+struct Shift(u32);
-    subtree
-        .token_trees
+impl Shift {
-        .iter()
+    fn new(tt: &tt::Subtree) -> Shift {
-        .filter_map(|tt| match tt {
+        // Note that TokenId is started from zero,
-            tt::TokenTree::Subtree(subtree) => max_id(subtree),
+        // We have to add 1 to prevent duplication.
-            tt::TokenTree::Leaf(tt::Leaf::Ident(ident))
+        let value = max_id(tt).map_or(0, |it| it + 1);
-                if ident.id != tt::TokenId::unspecified() =>
+        return Shift(value);
-            {
-                Some(ident.id.0)
+        // Find the max token id inside a subtree
+        fn max_id(subtree: &tt::Subtree) -> Option<u32> {
+            subtree
+                .token_trees
+                .iter()
+                .filter_map(|tt| match tt {
+                    tt::TokenTree::Subtree(subtree) => max_id(subtree),
+                    tt::TokenTree::Leaf(tt::Leaf::Ident(ident))
+                        if ident.id != tt::TokenId::unspecified() =>
+                    {
+                        Some(ident.id.0)
+                    }
+                    _ => None,
+                })
+                .max()
+        }
+    }
+    /// Shift given TokenTree token id
+    fn shift_all(self, tt: &mut tt::Subtree) {
+        for t in tt.token_trees.iter_mut() {
+            match t {
+                tt::TokenTree::Leaf(leaf) => match leaf {
+                    tt::Leaf::Ident(ident) => ident.id = self.shift(ident.id),
+                    _ => (),
+                },
+                tt::TokenTree::Subtree(tt) => self.shift_all(tt),
            }
-            _ => None,
+        }
-        })
+    }
-        .max()
-}
-/// Shift given TokenTree token id
+    fn shift(self, id: tt::TokenId) -> tt::TokenId {
-fn shift_subtree(tt: &mut tt::Subtree, shift: u32) {
+        if id == tt::TokenId::unspecified() {
-    for t in tt.token_trees.iter_mut() {
+            return id;
-        match t {
-            tt::TokenTree::Leaf(leaf) => match leaf {
-                tt::Leaf::Ident(ident) if ident.id != tt::TokenId::unspecified() => {
-                    ident.id.0 += shift;
-                }
-                _ => (),
-            },
-            tt::TokenTree::Subtree(tt) => shift_subtree(tt, shift),
        }
+        tt::TokenId(id.0 + self.0)
+    }
+    fn unshift(self, id: tt::TokenId) -> Option<tt::TokenId> {
+        id.0.checked_sub(self.0).map(tt::TokenId)
    }
 }
+pub enum Origin {
+    Def,
+    Call,
+}
 impl MacroRules {
    pub fn parse(tt: &tt::Subtree) -> Result<MacroRules, ParseError> {
        // Note: this parsing can be implemented using mbe machinery itself, by
@@ -105,21 +131,25 @@ impl MacroRules {
            validate(&rule.lhs)?;
        }
-        // Note that TokenId is started from zero,
+        Ok(MacroRules { rules, shift: Shift::new(tt) })
-        // We have to add 1 to prevent duplication.
-        let shift = max_id(tt).map_or(0, |it| it + 1);
-        Ok(MacroRules { rules, shift })
    }
    pub fn expand(&self, tt: &tt::Subtree) -> Result<tt::Subtree, ExpandError> {
        // apply shift
        let mut tt = tt.clone();
-        shift_subtree(&mut tt, self.shift);
+        self.shift.shift_all(&mut tt);
        mbe_expander::expand(self, &tt)
    }
-    pub fn shift(&self) -> u32 {
+    pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
-        self.shift
+        self.shift.shift(id)
+    }
+    pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, Origin) {
+        match self.shift.unshift(id) {
+            Some(id) => (id, Origin::Call),
+            None => (id, Origin::Def),
+        }
    }
 }
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index 3f57ce3b5..8398c9ac7 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -77,8 +77,14 @@ pub fn token_tree_to_syntax_node(
 }
 impl TokenMap {
-    pub fn relative_range_of(&self, tt: tt::TokenId) -> Option<TextRange> {
+    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
-        let idx = tt.0 as usize;
+        let (idx, _) =
+            self.tokens.iter().enumerate().find(|(_, range)| **range == relative_range)?;
+        Some(tt::TokenId(idx as u32))
+    }
+    pub fn relative_range_of(&self, token_id: tt::TokenId) -> Option<TextRange> {
+        let idx = token_id.0 as usize;
        self.tokens.get(idx).copied()
    }
@@ -90,6 +96,11 @@ impl TokenMap {
 }
 impl RevTokenMap {
+    pub fn range_by_token(&self, token_id: tt::TokenId) -> Option<TextRange> {
+        let &(r, _) = self.ranges.iter().find(|(_, tid)| *tid == token_id)?;
+        Some(r)
+    }
    fn add(&mut self, relative_range: TextRange, token_id: tt::TokenId) {
        self.ranges.push((relative_range, token_id.clone()))
    }
diff --git a/crates/ra_parser/Cargo.toml b/crates/ra_parser/Cargo.toml
index b110e2bc6..0da581fd5 100644
--- a/crates/ra_parser/Cargo.toml
+++ b/crates/ra_parser/Cargo.toml
@@ -5,5 +5,8 @@ version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+[lib]
+doctest = false
 [dependencies]
 drop_bomb = "0.1.4"
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 45f2e3de4..81d4f75f9 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -290,6 +290,22 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
        let m = lhs.precede(p);
        p.bump(op);
+        if is_range {
+            // test postfix_range
+            // fn foo() {
+            //     let x = 1..;
+            //     match 1.. { _ => () };
+            //     match a.b()..S { _ => () };
+            // }
+            let has_trailing_expression =
+                p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{']));
+            if !has_trailing_expression {
+                // no RHS
+                lhs = m.complete(p, RANGE_EXPR);
+                break;
+            }
+        }
        expr_bp(p, r, op_bp + 1);
        lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
    }
@@ -330,7 +346,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
                if p.at(op) {
                    m = p.start();
                    p.bump(op);
-                    if p.at_ts(EXPR_FIRST) {
+                    if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
                        expr_bp(p, r, 2);
                    }
                    return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
@@ -344,13 +360,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
            // }
            //
            let (lhs, blocklike) = atom::atom_expr(p, r)?;
-            return Some(postfix_expr(
+            return Some(postfix_expr(p, lhs, blocklike, !(r.prefer_stmt && blocklike.is_block())));
-                p,
-                lhs,
-                blocklike,
-                !(r.prefer_stmt && blocklike.is_block()),
-                r.forbid_structs,
-            ));
        }
    };
    // parse the interior of the unary expression
@@ -366,7 +376,6 @@ fn postfix_expr(
    // `while true {break}; ();`
    mut block_like: BlockLike,
    mut allow_calls: bool,
-    forbid_structs: bool,
 ) -> (CompletedMarker, BlockLike) {
    loop {
        lhs = match p.current() {
@@ -380,7 +389,7 @@ fn postfix_expr(
            // }
            T!['('] if allow_calls => call_expr(p, lhs),
            T!['['] if allow_calls => index_expr(p, lhs),
-            T![.] => match postfix_dot_expr(p, lhs, forbid_structs) {
+            T![.] => match postfix_dot_expr(p, lhs) {
                Ok(it) => it,
                Err(it) => {
                    lhs = it;
@@ -398,7 +407,6 @@ fn postfix_expr(
    fn postfix_dot_expr(
        p: &mut Parser,
        lhs: CompletedMarker,
-        forbid_structs: bool,
    ) -> Result<CompletedMarker, CompletedMarker> {
        assert!(p.at(T![.]));
        if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])) {
@@ -418,25 +426,8 @@ fn postfix_expr(
            return Ok(m.complete(p, AWAIT_EXPR));
        }
-        // test postfix_range
+        if p.at(T![..=]) || p.at(T![..]) {
-        // fn foo() {
+            return Err(lhs);
-        //     let x = 1..;
-        //     match 1.. { _ => () };
-        //     match a.b()..S { _ => () };
-        // }
-        for &(op, la) in &[(T![..=], 3), (T![..], 2)] {
-            if p.at(op) {
-                let next_token = p.nth(la);
-                let has_trailing_expression =
-                    !(forbid_structs && next_token == T!['{']) && EXPR_FIRST.contains(next_token);
-                return if has_trailing_expression {
-                    Err(lhs)
-                } else {
-                    let m = lhs.precede(p);
-                    p.bump(op);
-                    Ok(m.complete(p, RANGE_EXPR))
-                };
-            }
        }
        Ok(field_expr(p, lhs))
diff --git a/crates/ra_prof/Cargo.toml b/crates/ra_prof/Cargo.toml
index 751bcdeb8..382e6219a 100644
--- a/crates/ra_prof/Cargo.toml
+++ b/crates/ra_prof/Cargo.toml
@@ -5,6 +5,9 @@ version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+[lib]
+doctest = false
 [dependencies]
 once_cell = "1.0.1"
 itertools = "0.8.0"
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index b31c95903..69edc3c66 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_project_model"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 log = "0.4.5"
 rustc-hash = "1.0"
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 9c0e856e8..45a18a73f 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -7,6 +7,9 @@ license = "MIT OR Apache-2.0"
 description = "Comment and whitespace preserving parser for the Rust langauge"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
+[lib]
+doctest = false
 [dependencies]
 itertools = "0.8.0"
 rowan = "0.6.1"
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 1ec9881b9..277532a8c 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -16,7 +16,7 @@ use crate::{
 };
 pub use self::{
-    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp},
+    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp, RangeOp},
    extensions::{FieldKind, PathSegmentKind, SelfParamKind, StructKind, TypeBoundKind},
    generated::*,
    tokens::*,
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index 25dbd0bed..7c53aa934 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -189,6 +189,52 @@ impl ast::BinExpr {
    }
 }
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum RangeOp {
+    /// `..`
+    Exclusive,
+    /// `..=`
+    Inclusive,
+}
+impl ast::RangeExpr {
+    fn op_details(&self) -> Option<(usize, SyntaxToken, RangeOp)> {
+        self.syntax().children_with_tokens().enumerate().find_map(|(ix, child)| {
+            let token = child.into_token()?;
+            let bin_op = match token.kind() {
+                T![..] => RangeOp::Exclusive,
+                T![..=] => RangeOp::Inclusive,
+                _ => return None,
+            };
+            Some((ix, token, bin_op))
+        })
+    }
+    pub fn op_kind(&self) -> Option<RangeOp> {
+        self.op_details().map(|t| t.2)
+    }
+    pub fn op_token(&self) -> Option<SyntaxToken> {
+        self.op_details().map(|t| t.1)
+    }
+    pub fn start(&self) -> Option<ast::Expr> {
+        let op_ix = self.op_details()?.0;
+        self.syntax()
+            .children_with_tokens()
+            .take(op_ix)
+            .find_map(|it| ast::Expr::cast(it.into_node()?))
+    }
+    pub fn end(&self) -> Option<ast::Expr> {
+        let op_ix = self.op_details()?.0;
+        self.syntax()
+            .children_with_tokens()
+            .skip(op_ix + 1)
+            .find_map(|it| ast::Expr::cast(it.into_node()?))
+    }
+}
 impl ast::IndexExpr {
    pub fn base(&self) -> Option<ast::Expr> {
        children(self).nth(0)
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
index 87cca325d..ed8661faf 100644
--- a/crates/ra_syntax/src/ast/tokens.rs
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -2,8 +2,8 @@
 use crate::{
    ast::AstToken,
-    SyntaxKind::{COMMENT, WHITESPACE},
+    SyntaxKind::{COMMENT, RAW_STRING, STRING, WHITESPACE},
-    SyntaxToken,
+    SyntaxToken, TextRange, TextUnit,
 };
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -11,10 +11,9 @@ pub struct Comment(SyntaxToken);
 impl AstToken for Comment {
    fn cast(token: SyntaxToken) -> Option<Self> {
-        if token.kind() == COMMENT {
+        match token.kind() {
-            Some(Comment(token))
+            COMMENT => Some(Comment(token)),
-        } else {
+            _ => None,
-            None
        }
    }
    fn syntax(&self) -> &SyntaxToken {
@@ -94,10 +93,9 @@ pub struct Whitespace(SyntaxToken);
 impl AstToken for Whitespace {
    fn cast(token: SyntaxToken) -> Option<Self> {
-        if token.kind() == WHITESPACE {
+        match token.kind() {
-            Some(Whitespace(token))
+            WHITESPACE => Some(Whitespace(token)),
-        } else {
+            _ => None,
-            None
        }
    }
    fn syntax(&self) -> &SyntaxToken {
@@ -111,3 +109,80 @@ impl Whitespace {
        text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n'))
    }
 }
+pub struct String(SyntaxToken);
+impl AstToken for String {
+    fn cast(token: SyntaxToken) -> Option<Self> {
+        match token.kind() {
+            STRING => Some(String(token)),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxToken {
+        &self.0
+    }
+}
+impl String {
+    pub fn value(&self) -> Option<std::string::String> {
+        let text = self.text().as_str();
+        let usual_string_range = find_usual_string_range(text)?;
+        let start_of_inside = usual_string_range.start().to_usize() + 1;
+        let end_of_inside = usual_string_range.end().to_usize();
+        let inside_str = &text[start_of_inside..end_of_inside];
+        let mut buf = std::string::String::with_capacity(inside_str.len());
+        let mut has_error = false;
+        rustc_lexer::unescape::unescape_str(inside_str, &mut |_, unescaped_char| {
+            match unescaped_char {
+                Ok(c) => buf.push(c),
+                Err(_) => has_error = true,
+            }
+        });
+        if has_error {
+            return None;
+        }
+        Some(buf)
+    }
+}
+pub struct RawString(SyntaxToken);
+impl AstToken for RawString {
+    fn cast(token: SyntaxToken) -> Option<Self> {
+        match token.kind() {
+            RAW_STRING => Some(RawString(token)),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxToken {
+        &self.0
+    }
+}
+impl RawString {
+    pub fn value(&self) -> Option<std::string::String> {
+        let text = self.text().as_str();
+        let usual_string_range = find_usual_string_range(text)?;
+        let start_of_inside = usual_string_range.start().to_usize() + 1;
+        let end_of_inside = usual_string_range.end().to_usize();
+        let inside_str = &text[start_of_inside..end_of_inside];
+        Some(inside_str.to_string())
+    }
+}
+fn find_usual_string_range(s: &str) -> Option<TextRange> {
+    let left_quote = s.find('"')?;
+    let right_quote = s.rfind('"')?;
+    if left_quote == right_quote {
+        // `s` only contains one quote
+        None
+    } else {
+        Some(TextRange::from_to(
+            TextUnit::from(left_quote as u32),
+            TextUnit::from(right_quote as u32),
+        ))
+    }
+}
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 5dcb6a95a..9931fec84 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -176,9 +176,11 @@ impl SourceFile {
 /// ```
 #[macro_export]
 macro_rules! match_ast {
-    (match $node:ident {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {
        $( ast::$ast:ident($it:ident) => $res:block, )*
-        _ => $catch_all:expr,
+        _ => $catch_all:expr $(,)?
    }) => {{
        $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
        { $catch_all }
diff --git a/crates/ra_syntax/src/syntax_error.rs b/crates/ra_syntax/src/syntax_error.rs
index 1f60a7aab..6c171df8d 100644
--- a/crates/ra_syntax/src/syntax_error.rs
+++ b/crates/ra_syntax/src/syntax_error.rs
@@ -83,6 +83,7 @@ pub enum SyntaxErrorKind {
    InvalidMatchInnerAttr,
    InvalidTupleIndexFormat,
    VisibilityNotAllowed,
+    InclusiveRangeMissingEnd,
 }
 impl fmt::Display for SyntaxErrorKind {
@@ -103,6 +104,9 @@ impl fmt::Display for SyntaxErrorKind {
            VisibilityNotAllowed => {
                write!(f, "unnecessary visibility qualifier")
            }
+            InclusiveRangeMissingEnd => {
+                write!(f, "An inclusive range must have an end expression")
+            }
        }
    }
 }
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 2d596763e..222ac15f8 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -103,6 +103,7 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
                ast::FieldExpr(it) => { validate_numeric_name(it.name_ref(), &mut errors) },
                ast::RecordField(it) => { validate_numeric_name(it.name_ref(), &mut errors) },
                ast::Visibility(it) => { validate_visibility(it, &mut errors) },
+                ast::RangeExpr(it) => { validate_range_expr(it, &mut errors) },
                _ => (),
            }
        }
@@ -227,3 +228,12 @@ fn validate_visibility(vis: ast::Visibility, errors: &mut Vec<SyntaxError>) {
            .push(SyntaxError::new(SyntaxErrorKind::VisibilityNotAllowed, vis.syntax.text_range()))
    }
 }
+fn validate_range_expr(expr: ast::RangeExpr, errors: &mut Vec<SyntaxError>) {
+    if expr.op_kind() == Some(ast::RangeOp::Inclusive) && expr.end().is_none() {
+        errors.push(SyntaxError::new(
+            SyntaxErrorKind::InclusiveRangeMissingEnd,
+            expr.syntax().text_range(),
+        ));
+    }
+}
diff --git a/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.rs b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.rs
new file mode 100644
index 000000000..0b4ed7a2b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.rs
@@ -0,0 +1,4 @@
+fn main() {
+    0..=;
+    ..=;
+}
diff --git a/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.txt b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.txt
new file mode 100644
index 000000000..3810b9680
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.txt
@@ -0,0 +1,30 @@
+SOURCE_FILE@[0; 33)
+  FN_DEF@[0; 32)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 32)
+      BLOCK@[10; 32)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        EXPR_STMT@[16; 21)
+          RANGE_EXPR@[16; 20)
+            LITERAL@[16; 17)
+              INT_NUMBER@[16; 17) "0"
+            DOTDOTEQ@[17; 20) "..="
+          SEMI@[20; 21) ";"
+        WHITESPACE@[21; 26) "\n    "
+        EXPR_STMT@[26; 30)
+          RANGE_EXPR@[26; 29)
+            DOTDOTEQ@[26; 29) "..="
+          SEMI@[29; 30) ";"
+        WHITESPACE@[30; 31) "\n"
+        R_CURLY@[31; 32) "}"
+  WHITESPACE@[32; 33) "\n"
+error [16; 20): An inclusive range must have an end expression
+error [26; 29): An inclusive range must have an end expression
diff --git a/crates/ra_syntax/test_data/parser/ok/0060_as_range.rs b/crates/ra_syntax/test_data/parser/ok/0060_as_range.rs
new file mode 100644
index 000000000..f063ffadb
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0060_as_range.rs
@@ -0,0 +1,4 @@
+fn main() {
+    0 as usize ..;
+    1 + 2 as usize ..;
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0060_as_range.txt b/crates/ra_syntax/test_data/parser/ok/0060_as_range.txt
new file mode 100644
index 000000000..ad0c4a3fe
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0060_as_range.txt
@@ -0,0 +1,56 @@
+SOURCE_FILE@[0; 56)
+  FN_DEF@[0; 55)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 55)
+      BLOCK@[10; 55)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        EXPR_STMT@[16; 30)
+          RANGE_EXPR@[16; 29)
+            CAST_EXPR@[16; 26)
+              LITERAL@[16; 17)
+                INT_NUMBER@[16; 17) "0"
+              WHITESPACE@[17; 18) " "
+              AS_KW@[18; 20) "as"
+              WHITESPACE@[20; 21) " "
+              PATH_TYPE@[21; 26)
+                PATH@[21; 26)
+                  PATH_SEGMENT@[21; 26)
+                    NAME_REF@[21; 26)
+                      IDENT@[21; 26) "usize"
+            WHITESPACE@[26; 27) " "
+            DOTDOT@[27; 29) ".."
+          SEMI@[29; 30) ";"
+        WHITESPACE@[30; 35) "\n    "
+        EXPR_STMT@[35; 53)
+          RANGE_EXPR@[35; 52)
+            BIN_EXPR@[35; 49)
+              LITERAL@[35; 36)
+                INT_NUMBER@[35; 36) "1"
+              WHITESPACE@[36; 37) " "
+              PLUS@[37; 38) "+"
+              WHITESPACE@[38; 39) " "
+              CAST_EXPR@[39; 49)
+                LITERAL@[39; 40)
+                  INT_NUMBER@[39; 40) "2"
+                WHITESPACE@[40; 41) " "
+                AS_KW@[41; 43) "as"
+                WHITESPACE@[43; 44) " "
+                PATH_TYPE@[44; 49)
+                  PATH@[44; 49)
+                    PATH_SEGMENT@[44; 49)
+                      NAME_REF@[44; 49)
+                        IDENT@[44; 49) "usize"
+            WHITESPACE@[49; 50) " "
+            DOTDOT@[50; 52) ".."
+          SEMI@[52; 53) ";"
+        WHITESPACE@[53; 54) "\n"
+        R_CURLY@[54; 55) "}"
+  WHITESPACE@[55; 56) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.rs b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.rs
new file mode 100644
index 000000000..2c4ed11e1
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.rs
@@ -0,0 +1,4 @@
+fn main() {
+    match .. {
+    }
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.txt b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.txt
new file mode 100644
index 000000000..bdfac9b76
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.txt
@@ -0,0 +1,27 @@
+SOURCE_FILE@[0; 35)
+  FN_DEF@[0; 34)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 34)
+      BLOCK@[10; 34)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        MATCH_EXPR@[16; 32)
+          MATCH_KW@[16; 21) "match"
+          WHITESPACE@[21; 22) " "
+          RANGE_EXPR@[22; 24)
+            DOTDOT@[22; 24) ".."
+          WHITESPACE@[24; 25) " "
+          MATCH_ARM_LIST@[25; 32)
+            L_CURLY@[25; 26) "{"
+            WHITESPACE@[26; 31) "\n    "
+            R_CURLY@[31; 32) "}"
+        WHITESPACE@[32; 33) "\n"
+        R_CURLY@[33; 34) "}"
+  WHITESPACE@[34; 35) "\n"
diff --git a/crates/ra_text_edit/Cargo.toml b/crates/ra_text_edit/Cargo.toml
index b40026004..8573c521a 100644
--- a/crates/ra_text_edit/Cargo.toml
+++ b/crates/ra_text_edit/Cargo.toml
@@ -5,6 +5,9 @@ version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+[lib]
+doctest = false
 [dependencies]
 text_unit = "0.1.6"
diff --git a/crates/ra_tt/Cargo.toml b/crates/ra_tt/Cargo.toml
index 3fcc7f085..b8dceb92a 100644
--- a/crates/ra_tt/Cargo.toml
+++ b/crates/ra_tt/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_tt"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 # ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
 # to reduce number of compilations
diff --git a/crates/ra_vfs_glob/Cargo.toml b/crates/ra_vfs_glob/Cargo.toml
index 83749675f..094d6d6f4 100644
--- a/crates/ra_vfs_glob/Cargo.toml
+++ b/crates/ra_vfs_glob/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_vfs_glob"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 ra_vfs = "0.5.0"
 globset = "0.4.4"
diff --git a/crates/test_utils/Cargo.toml b/crates/test_utils/Cargo.toml
index 0be9c3665..a71366cc4 100644
--- a/crates/test_utils/Cargo.toml
+++ b/crates/test_utils/Cargo.toml
@@ -4,6 +4,9 @@ name = "test_utils"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+[lib]
+doctest = false
 [dependencies]
 difference = "2.0.0"
 text_unit = "0.1.2"
diff --git a/crates/test_utils/src/marks.rs b/crates/test_utils/src/marks.rs
index 1c268b49c..fe1813947 100644
--- a/crates/test_utils/src/marks.rs
+++ b/crates/test_utils/src/marks.rs
@@ -4,7 +4,7 @@
 //! See <https://matklad.github.io/2018/06/18/a-trick-for-test-maintenance.html>
 //! for details, but the TL;DR is that you write your test as
 //!
-//! ```rust,no_run
+//! ```
 //! #[test]
 //! fn test_foo() {
 //!     covers!(test_foo);
@@ -13,7 +13,7 @@
 //!
 //! and in the code under test you write
 //!
-//! ```rust,no_run
+//! ```
 //! # use test_utils::tested_by;
 //! # fn some_condition() -> bool { true }
 //! fn foo() {
author	Seivan Heidari <[email protected]>	2019-11-18 01:27:53 +0000
committer	Seivan Heidari <[email protected]>	2019-11-18 01:27:53 +0000
commit	166636ba77adcf5bf2c4ef935e9aa75e20f25e10 (patch)
tree	168be1ca55c73b016e20586c08417c608450c92c /crates
parent	cb26df950699586b314731fb70786e0db8eaa049 (diff)
parent	28c2d74b2150102a8756a5357a5a965d7610bd15 (diff)