82 files changed, 5829 insertions, 1552 deletions
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 50be8d9bc..0d2109e4e 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 format-buf = "1.0.0"
 join_to_string = "0.1.3"
 rustc-hash = "1.0"
-itertools = "0.8.0"
+either = "1.5"
 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 28152f724..43f0d664b 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,5 +1,6 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-use hir::{db::HirDatabase, InFile, SourceAnalyzer};
+use either::Either;
+use hir::{db::HirDatabase, InFile, SourceAnalyzer, SourceBinder};
 use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_syntax::{
@@ -9,12 +10,12 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
-use crate::{AssistAction, AssistId, AssistLabel};
+use crate::{AssistAction, AssistId, AssistLabel, ResolvedAssist};
 #[derive(Clone, Debug)]
 pub(crate) enum Assist {
    Unresolved { label: AssistLabel },
-    Resolved { label: AssistLabel, action: AssistAction },
+    Resolved { assist: ResolvedAssist },
 }
 /// `AssistCtx` allows to apply an assist or check if it could be applied.
@@ -81,16 +82,45 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
        self,
        id: AssistId,
        label: impl Into<String>,
-        f: impl FnOnce(&mut AssistBuilder),
+        f: impl FnOnce(&mut ActionBuilder),
    ) -> Option<Assist> {
        let label = AssistLabel { label: label.into(), id };
+        assert!(label.label.chars().nth(0).unwrap().is_uppercase());
        let assist = if self.should_compute_edit {
            let action = {
-                let mut edit = AssistBuilder::default();
+                let mut edit = ActionBuilder::default();
                f(&mut edit);
                edit.build()
            };
-            Assist::Resolved { label, action }
+            Assist::Resolved { assist: ResolvedAssist { label, action_data: Either::Left(action) } }
+        } else {
+            Assist::Unresolved { label }
+        };
+        Some(assist)
+    }
+    #[allow(dead_code)] // will be used for auto import assist with multiple actions
+    pub(crate) fn add_assist_group(
+        self,
+        id: AssistId,
+        label: impl Into<String>,
+        f: impl FnOnce() -> Vec<ActionBuilder>,
+    ) -> Option<Assist> {
+        let label = AssistLabel { label: label.into(), id };
+        let assist = if self.should_compute_edit {
+            let actions = f();
+            assert!(!actions.is_empty(), "Assist cannot have no");
+            Assist::Resolved {
+                assist: ResolvedAssist {
+                    label,
+                    action_data: Either::Right(
+                        actions.into_iter().map(ActionBuilder::build).collect(),
+                    ),
+                },
+            }
        } else {
            Assist::Unresolved { label }
        };
@@ -112,12 +142,16 @@ 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_binder(&self) -> SourceBinder<'a, DB> {
+        SourceBinder::new(self.db)
+    }
    pub(crate) fn source_analyzer(
        &self,
        node: &SyntaxNode,
        offset: Option<TextUnit>,
    ) -> SourceAnalyzer {
-        SourceAnalyzer::new(self.db, InFile::new(self.frange.file_id.into(), node), offset)
+        let src = InFile::new(self.frange.file_id.into(), node);
+        self.source_binder().analyze(src, offset)
    }
    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
@@ -126,13 +160,20 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
 }
 #[derive(Default)]
-pub(crate) struct AssistBuilder {
+pub(crate) struct ActionBuilder {
    edit: TextEditBuilder,
    cursor_position: Option<TextUnit>,
    target: Option<TextRange>,
+    label: Option<String>,
 }
-impl AssistBuilder {
+impl ActionBuilder {
+    #[allow(dead_code)]
+    /// Adds a custom label to the action, if it needs to be different from the assist label
+    pub(crate) fn label(&mut self, label: impl Into<String>) {
+        self.label = Some(label.into())
+    }
    /// Replaces specified `range` of text with a given string.
    pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
        self.edit.replace(range, replace_with.into())
@@ -191,6 +232,7 @@ impl AssistBuilder {
            edit: self.edit.finish(),
            cursor_position: self.cursor_position,
            target: self.target,
+            label: self.label,
        }
    }
 }
diff --git a/crates/ra_assists/src/assists/add_custom_impl.rs b/crates/ra_assists/src/assists/add_custom_impl.rs
index 9b8955710..f91034967 100644
--- a/crates/ra_assists/src/assists/add_custom_impl.rs
+++ b/crates/ra_assists/src/assists/add_custom_impl.rs
@@ -49,7 +49,10 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
    let annotated_name = annotated.syntax().text().to_string();
    let start_offset = annotated.syntax().parent()?.text_range().end();
-    ctx.add_assist(AssistId("add_custom_impl"), "add custom impl", |edit| {
+    let label =
+        format!("Add custom impl '{}' for '{}'", trait_token.text().as_str(), annotated_name);
+    ctx.add_assist(AssistId("add_custom_impl"), label, |edit| {
        edit.target(attr.syntax().text_range());
        let new_attr_input = input
diff --git a/crates/ra_assists/src/assists/add_derive.rs b/crates/ra_assists/src/assists/add_derive.rs
index 764b17bd8..6d9af3905 100644
--- a/crates/ra_assists/src/assists/add_derive.rs
+++ b/crates/ra_assists/src/assists/add_derive.rs
@@ -28,7 +28,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_derive(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
    let node_start = derive_insertion_offset(&nominal)?;
-    ctx.add_assist(AssistId("add_derive"), "add `#[derive]`", |edit| {
+    ctx.add_assist(AssistId("add_derive"), "Add `#[derive]`", |edit| {
        let derive_attr = nominal
            .attrs()
            .filter_map(|x| x.as_simple_call())
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index 2c602a79e..f9f826b88 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -47,10 +47,14 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
        return None;
    }
-    ctx.add_assist(AssistId("add_explicit_type"), "add explicit type", |edit| {
+    ctx.add_assist(
-        edit.target(pat_range);
+        AssistId("add_explicit_type"),
-        edit.insert(name_range.end(), format!(": {}", ty.display(db)));
+        format!("Insert explicit type '{}'", ty.display(db)),
-    })
+        |edit| {
+            edit.target(pat_range);
+            edit.insert(name_range.end(), format!(": {}", ty.display(db)));
+        },
+    )
 }
 #[cfg(test)]
diff --git a/crates/ra_assists/src/assists/add_impl.rs b/crates/ra_assists/src/assists/add_impl.rs
index 7da0cfd0d..4b326c837 100644
--- a/crates/ra_assists/src/assists/add_impl.rs
+++ b/crates/ra_assists/src/assists/add_impl.rs
@@ -30,7 +30,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
    let name = nominal.name()?;
-    ctx.add_assist(AssistId("add_impl"), "add impl", |edit| {
+    ctx.add_assist(AssistId("add_impl"), format!("Implement {}", name.text().as_str()), |edit| {
        edit.target(nominal.syntax().text_range());
        let type_params = nominal.type_param_list();
        let start_offset = nominal.syntax().text_range().end();
diff --git a/crates/ra_assists/src/assists/add_import.rs b/crates/ra_assists/src/assists/add_import.rs
index b8752cbad..bf6cfe865 100644
--- a/crates/ra_assists/src/assists/add_import.rs
+++ b/crates/ra_assists/src/assists/add_import.rs
@@ -72,7 +72,7 @@ pub(crate) fn add_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        }
    };
-    ctx.add_assist(AssistId("add_import"), format!("import {}", fmt_segments(&segments)), |edit| {
+    ctx.add_assist(AssistId("add_import"), format!("Import {}", fmt_segments(&segments)), |edit| {
        apply_auto_import(&position, &path, &segments, edit.text_edit_builder());
    })
 }
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 bf1136193..5bb937bde 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/assists/add_missing_impl_members.rs
@@ -48,7 +48,7 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Opti
        ctx,
        AddMissingImplMembersMode::NoDefaultMethods,
        "add_impl_missing_members",
-        "add missing impl members",
+        "Implement missing members",
    )
 }
@@ -89,7 +89,7 @@ pub(crate) fn add_missing_default_members(ctx: AssistCtx<impl HirDatabase>) -> O
        ctx,
        AddMissingImplMembersMode::DefaultMethodsOnly,
        "add_impl_default_members",
-        "add impl default members",
+        "Implement default members",
    )
 }
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index b2f946fac..8db63f762 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::{db::HirDatabase, FromSource, InFile};
+use hir::{db::HirDatabase, InFile};
 use join_to_string::join;
 use ra_syntax::{
    ast::{
@@ -43,7 +43,7 @@ pub(crate) fn add_new(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    // Return early if we've found an existing new fn
    let impl_block = find_struct_impl(&ctx, &strukt)?;
-    ctx.add_assist(AssistId("add_new"), "add new fn", |edit| {
+    ctx.add_assist(AssistId("add_new"), "Add default constructor", |edit| {
        edit.target(strukt.syntax().text_range());
        let mut buf = String::with_capacity(512);
@@ -136,15 +136,16 @@ fn find_struct_impl(
    let module = strukt.syntax().ancestors().find(|node| {
        ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
    })?;
+    let mut sb = ctx.source_binder();
    let struct_ty = {
        let src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        hir::Struct::from_source(db, src)?.ty(db)
+        sb.to_def(src)?.ty(db)
    };
    let block = module.descendants().filter_map(ast::ImplBlock::cast).find_map(|impl_blk| {
        let src = InFile { file_id: ctx.frange.file_id.into(), value: impl_blk.clone() };
-        let blk = hir::ImplBlock::from_source(db, src)?;
+        let blk = sb.to_def(src)?;
        let same_ty = blk.target_ty(db) == struct_ty;
        let not_trait_impl = blk.target_trait(db).is_none();
diff --git a/crates/ra_assists/src/assists/apply_demorgan.rs b/crates/ra_assists/src/assists/apply_demorgan.rs
index 7c57c0560..666dce4e6 100644
--- a/crates/ra_assists/src/assists/apply_demorgan.rs
+++ b/crates/ra_assists/src/assists/apply_demorgan.rs
@@ -39,7 +39,7 @@ pub(crate) fn apply_demorgan(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
    let not_lhs = invert_boolean_expression(&lhs)?;
    let not_rhs = invert_boolean_expression(&rhs)?;
-    ctx.add_assist(AssistId("apply_demorgan"), "apply demorgan's law", |edit| {
+    ctx.add_assist(AssistId("apply_demorgan"), "Apply De Morgan's law", |edit| {
        edit.target(op_range);
        edit.replace(op_range, opposite_op);
        edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
diff --git a/crates/ra_assists/src/assists/change_visibility.rs b/crates/ra_assists/src/assists/change_visibility.rs
index 132c9dc1d..fd766bb46 100644
--- a/crates/ra_assists/src/assists/change_visibility.rs
+++ b/crates/ra_assists/src/assists/change_visibility.rs
@@ -57,7 +57,7 @@ fn add_vis(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        (vis_offset(field.syntax()), ident.text_range())
    };
-    ctx.add_assist(AssistId("change_visibility"), "make pub(crate)", |edit| {
+    ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub(crate)", |edit| {
        edit.target(target);
        edit.insert(offset, "pub(crate) ");
        edit.set_cursor(offset);
@@ -77,14 +77,18 @@ fn vis_offset(node: &SyntaxNode) -> TextUnit {
 fn change_vis(ctx: AssistCtx<impl HirDatabase>, vis: ast::Visibility) -> Option<Assist> {
    if vis.syntax().text() == "pub" {
-        return ctx.add_assist(AssistId("change_visibility"), "change to pub(crate)", |edit| {
+        return ctx.add_assist(
-            edit.target(vis.syntax().text_range());
+            AssistId("change_visibility"),
-            edit.replace(vis.syntax().text_range(), "pub(crate)");
+            "Change Visibility to pub(crate)",
-            edit.set_cursor(vis.syntax().text_range().start())
+            |edit| {
-        });
+                edit.target(vis.syntax().text_range());
+                edit.replace(vis.syntax().text_range(), "pub(crate)");
+                edit.set_cursor(vis.syntax().text_range().start())
+            },
+        );
    }
    if vis.syntax().text() == "pub(crate)" {
-        return ctx.add_assist(AssistId("change_visibility"), "change to pub", |edit| {
+        return ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub", |edit| {
            edit.target(vis.syntax().text_range());
            edit.replace(vis.syntax().text_range(), "pub");
            edit.set_cursor(vis.syntax().text_range().start());
diff --git a/crates/ra_assists/src/assists/early_return.rs b/crates/ra_assists/src/assists/early_return.rs
index 023917aca..487ee9eef 100644
--- a/crates/ra_assists/src/assists/early_return.rs
+++ b/crates/ra_assists/src/assists/early_return.rs
@@ -95,7 +95,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx<impl HirDatabase>) -> Opt
    then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
    let cursor_position = ctx.frange.range.start();
-    ctx.add_assist(AssistId("convert_to_guarded_return"), "convert to guarded return", |edit| {
+    ctx.add_assist(AssistId("convert_to_guarded_return"), "Convert to guarded return", |edit| {
        let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
        let new_block = match if_let_pat {
            None => {
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 99d80998c..01758d23a 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -57,7 +57,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
    let db = ctx.db;
-    ctx.add_assist(AssistId("fill_match_arms"), "fill match arms", |edit| {
+    ctx.add_assist(AssistId("fill_match_arms"), "Fill match arms", |edit| {
        let indent_level = IndentLevel::from_node(match_arm_list.syntax());
        let new_arm_list = {
diff --git a/crates/ra_assists/src/assists/flip_binexpr.rs b/crates/ra_assists/src/assists/flip_binexpr.rs
index 2d91b2a7e..2074087cd 100644
--- a/crates/ra_assists/src/assists/flip_binexpr.rs
+++ b/crates/ra_assists/src/assists/flip_binexpr.rs
@@ -34,7 +34,7 @@ pub(crate) fn flip_binexpr(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("flip_binexpr"), "flip binary expression", |edit| {
+    ctx.add_assist(AssistId("flip_binexpr"), "Flip binary expression", |edit| {
        edit.target(op_range);
        if let FlipAction::FlipAndReplaceOp(new_op) = action {
            edit.replace(op_range, new_op);
diff --git a/crates/ra_assists/src/assists/flip_comma.rs b/crates/ra_assists/src/assists/flip_comma.rs
index 9be1c1dc6..dd0c405ed 100644
--- a/crates/ra_assists/src/assists/flip_comma.rs
+++ b/crates/ra_assists/src/assists/flip_comma.rs
@@ -29,7 +29,7 @@ pub(crate) fn flip_comma(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("flip_comma"), "flip comma", |edit| {
+    ctx.add_assist(AssistId("flip_comma"), "Flip comma", |edit| {
        edit.target(comma.text_range());
        edit.replace(prev.text_range(), next.to_string());
        edit.replace(next.text_range(), prev.to_string());
diff --git a/crates/ra_assists/src/assists/flip_trait_bound.rs b/crates/ra_assists/src/assists/flip_trait_bound.rs
index 6017b39dd..50b3fa492 100644
--- a/crates/ra_assists/src/assists/flip_trait_bound.rs
+++ b/crates/ra_assists/src/assists/flip_trait_bound.rs
@@ -33,7 +33,7 @@ pub(crate) fn flip_trait_bound(ctx: AssistCtx<impl HirDatabase>) -> Option<Assis
        non_trivia_sibling(plus.clone().into(), Direction::Next)?,
    );
-    ctx.add_assist(AssistId("flip_trait_bound"), "flip trait bound", |edit| {
+    ctx.add_assist(AssistId("flip_trait_bound"), "Flip trait bounds", |edit| {
        edit.target(plus.text_range());
        edit.replace(before.text_range(), after.to_string());
        edit.replace(after.text_range(), before.to_string());
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index 18a34502c..45e0f983f 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    TextRange,
 };
-use crate::assist_ctx::AssistBuilder;
+use crate::assist_ctx::ActionBuilder;
 use crate::{Assist, AssistCtx, AssistId};
 // Assist: inline_local_variable
@@ -93,8 +93,8 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
    ctx.add_assist(
        AssistId("inline_local_variable"),
-        "inline local variable",
+        "Inline variable",
-        move |edit: &mut AssistBuilder| {
+        move |edit: &mut ActionBuilder| {
            edit.delete(delete_range);
            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
                if should_wrap {
diff --git a/crates/ra_assists/src/assists/introduce_variable.rs b/crates/ra_assists/src/assists/introduce_variable.rs
index 0623d4475..19e211e0f 100644
--- a/crates/ra_assists/src/assists/introduce_variable.rs
+++ b/crates/ra_assists/src/assists/introduce_variable.rs
@@ -43,7 +43,7 @@ pub(crate) fn introduce_variable(ctx: AssistCtx<impl HirDatabase>) -> Option<Ass
    if indent.kind() != WHITESPACE {
        return None;
    }
-    ctx.add_assist(AssistId("introduce_variable"), "introduce variable", move |edit| {
+    ctx.add_assist(AssistId("introduce_variable"), "Extract into variable", move |edit| {
        let mut buf = String::new();
        let cursor_offset = if wrap_in_block {
diff --git a/crates/ra_assists/src/assists/invert_if.rs b/crates/ra_assists/src/assists/invert_if.rs
index bababa3e2..16352c040 100644
--- a/crates/ra_assists/src/assists/invert_if.rs
+++ b/crates/ra_assists/src/assists/invert_if.rs
@@ -41,7 +41,7 @@ pub(crate) fn invert_if(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        let else_node = else_block.syntax();
        let else_range = else_node.text_range();
        let then_range = then_node.text_range();
-        return ctx.add_assist(AssistId("invert_if"), "invert if branches", |edit| {
+        return ctx.add_assist(AssistId("invert_if"), "Invert if", |edit| {
            edit.target(if_range);
            edit.replace(cond_range, flip_cond.syntax().text());
            edit.replace(else_range, then_node.text());
diff --git a/crates/ra_assists/src/assists/merge_match_arms.rs b/crates/ra_assists/src/assists/merge_match_arms.rs
index e9f2cae91..aca391155 100644
--- a/crates/ra_assists/src/assists/merge_match_arms.rs
+++ b/crates/ra_assists/src/assists/merge_match_arms.rs
@@ -52,7 +52,7 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assis
    let cursor_to_end = current_arm.syntax().text_range().end() - ctx.frange.range.start();
-    ctx.add_assist(AssistId("merge_match_arms"), "merge match arms", |edit| {
+    ctx.add_assist(AssistId("merge_match_arms"), "Merge match arms", |edit| {
        fn contains_placeholder(a: &MatchArm) -> bool {
            a.pats().any(|x| match x {
                ra_syntax::ast::Pat::PlaceholderPat(..) => true,
diff --git a/crates/ra_assists/src/assists/move_bounds.rs b/crates/ra_assists/src/assists/move_bounds.rs
index 3145d7625..355adddc3 100644
--- a/crates/ra_assists/src/assists/move_bounds.rs
+++ b/crates/ra_assists/src/assists/move_bounds.rs
@@ -46,7 +46,7 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx<impl HirDatabase>) -> O
        _ => return None,
    };
-    ctx.add_assist(AssistId("move_bounds_to_where_clause"), "move_bounds_to_where_clause", |edit| {
+    ctx.add_assist(AssistId("move_bounds_to_where_clause"), "Move to where clause", |edit| {
        let new_params = type_param_list
            .type_params()
            .filter(|it| it.type_bound_list().is_some())
diff --git a/crates/ra_assists/src/assists/move_guard.rs b/crates/ra_assists/src/assists/move_guard.rs
index b49ec6172..41a31e677 100644
--- a/crates/ra_assists/src/assists/move_guard.rs
+++ b/crates/ra_assists/src/assists/move_guard.rs
@@ -41,7 +41,7 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx<impl HirDatabase>) -> Option
    let arm_expr = match_arm.expr()?;
    let buf = format!("if {} {{ {} }}", guard_conditions.syntax().text(), arm_expr.syntax().text());
-    ctx.add_assist(AssistId("move_guard_to_arm_body"), "move guard to arm body", |edit| {
+    ctx.add_assist(AssistId("move_guard_to_arm_body"), "Move guard to arm body", |edit| {
        edit.target(guard.syntax().text_range());
        let offseting_amount = match space_before_guard.and_then(|it| it.into_token()) {
            Some(tok) => {
@@ -111,7 +111,7 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx<impl HirDatabase>) ->
    ctx.add_assist(
        AssistId("move_arm_cond_to_match_guard"),
-        "move condition to match guard",
+        "Move condition to match guard",
        |edit| {
            edit.target(if_expr.syntax().text_range());
            let then_only_expr = then_block.block().and_then(|it| it.statements().next()).is_none();
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/assists/raw_string.rs
index 93912a470..e79c51673 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/assists/raw_string.rs
@@ -25,7 +25,7 @@ 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).and_then(ast::String::cast)?;
    let value = token.value()?;
-    ctx.add_assist(AssistId("make_raw_string"), "make raw string", |edit| {
+    ctx.add_assist(AssistId("make_raw_string"), "Rewrite as raw string", |edit| {
        edit.target(token.syntax().text_range());
        let max_hash_streak = count_hashes(&value);
        let mut hashes = String::with_capacity(max_hash_streak + 1);
@@ -54,7 +54,7 @@ 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).and_then(ast::RawString::cast)?;
    let value = token.value()?;
-    ctx.add_assist(AssistId("make_usual_string"), "make usual string", |edit| {
+    ctx.add_assist(AssistId("make_usual_string"), "Rewrite as regular string", |edit| {
        edit.target(token.syntax().text_range());
        // parse inside string to escape `"`
        let escaped = value.escape_default().to_string();
@@ -79,7 +79,7 @@ pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
 // ```
 pub(crate) fn add_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let token = ctx.find_token_at_offset(RAW_STRING)?;
-    ctx.add_assist(AssistId("add_hash"), "add hash to raw string", |edit| {
+    ctx.add_assist(AssistId("add_hash"), "Add # to raw string", |edit| {
        edit.target(token.text_range());
        edit.insert(token.text_range().start() + TextUnit::of_char('r'), "#");
        edit.insert(token.text_range().end(), "#");
@@ -108,7 +108,7 @@ pub(crate) fn remove_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        // no hash to remove
        return None;
    }
-    ctx.add_assist(AssistId("remove_hash"), "remove hash from raw string", |edit| {
+    ctx.add_assist(AssistId("remove_hash"), "Remove hash from raw string", |edit| {
        edit.target(token.text_range());
        let result = &text[2..text.len() - 1];
        let result = if result.starts_with('\"') {
diff --git a/crates/ra_assists/src/assists/remove_dbg.rs b/crates/ra_assists/src/assists/remove_dbg.rs
index aedf8747f..cf211ab84 100644
--- a/crates/ra_assists/src/assists/remove_dbg.rs
+++ b/crates/ra_assists/src/assists/remove_dbg.rs
@@ -58,7 +58,7 @@ pub(crate) fn remove_dbg(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        text.slice(without_parens).to_string()
    };
-    ctx.add_assist(AssistId("remove_dbg"), "remove dbg!()", |edit| {
+    ctx.add_assist(AssistId("remove_dbg"), "Remove dbg!()", |edit| {
        edit.target(macro_call.syntax().text_range());
        edit.replace(macro_range, macro_content);
        edit.set_cursor(cursor_pos);
diff --git a/crates/ra_assists/src/assists/replace_if_let_with_match.rs b/crates/ra_assists/src/assists/replace_if_let_with_match.rs
index 3272801ff..c9b62e5ff 100644
--- a/crates/ra_assists/src/assists/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/assists/replace_if_let_with_match.rs
@@ -42,7 +42,7 @@ pub(crate) fn replace_if_let_with_match(ctx: AssistCtx<impl HirDatabase>) -> Opt
        ast::ElseBranch::IfExpr(_) => return None,
    };
-    ctx.add_assist(AssistId("replace_if_let_with_match"), "replace with match", |edit| {
+    ctx.add_assist(AssistId("replace_if_let_with_match"), "Replace with match", |edit| {
        let match_expr = build_match_expr(expr, pat, then_block, else_block);
        edit.target(if_expr.syntax().text_range());
        edit.replace_node_and_indent(if_expr.syntax(), match_expr);
diff --git a/crates/ra_assists/src/assists/split_import.rs b/crates/ra_assists/src/assists/split_import.rs
index 5f8d6b0be..6038c4858 100644
--- a/crates/ra_assists/src/assists/split_import.rs
+++ b/crates/ra_assists/src/assists/split_import.rs
@@ -32,7 +32,7 @@ pub(crate) fn split_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
        None => top_path.syntax().text_range().end(),
    };
-    ctx.add_assist(AssistId("split_import"), "split import", |edit| {
+    ctx.add_assist(AssistId("split_import"), "Split import", |edit| {
        edit.target(colon_colon.text_range());
        edit.insert(l_curly, "{");
        edit.insert(r_curly, "}");
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index eac2903d1..56b7588ef 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -2,7 +2,7 @@
 use rustc_hash::FxHashMap;
 use hir::{db::HirDatabase, InFile, PathResolution};
-use ra_syntax::ast::{self, make, AstNode};
+use ra_syntax::ast::{self, AstNode};
 pub trait AstTransform<'a> {
    fn get_substitution(
@@ -134,11 +134,18 @@ impl<'a, DB: HirDatabase> QualifyPaths<'a, DB> {
        match resolution {
            PathResolution::Def(def) => {
                let found_path = from.find_use_path(self.db, def)?;
-                let args = p
+                let mut path = path_to_ast(found_path);
+                let type_args = p
                    .segment()
                    .and_then(|s| s.type_arg_list())
                    .map(|arg_list| apply(self, node.with_value(arg_list)));
-                Some(make::path_with_type_arg_list(path_to_ast(found_path), args).syntax().clone())
+                if let Some(type_args) = type_args {
+                    let last_segment = path.segment().unwrap();
+                    path = path.with_segment(last_segment.with_type_args(type_args))
+                }
+                Some(path.syntax().clone())
            }
            PathResolution::Local(_)
            | PathResolution::TypeParam(_)
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
index a8f8446cb..5dc1ee233 100644
--- a/crates/ra_assists/src/doc_tests.rs
+++ b/crates/ra_assists/src/doc_tests.rs
@@ -15,21 +15,21 @@ fn check(assist_id: &str, before: &str, after: &str) {
    let (db, file_id) = TestDB::with_single_file(&before);
    let frange = FileRange { file_id, range: selection.into() };
-    let (_assist_id, action) = crate::assists(&db, frange)
+    let assist = crate::assists(&db, frange)
        .into_iter()
-        .find(|(id, _)| id.id.0 == assist_id)
+        .find(|assist| assist.label.id.0 == assist_id)
        .unwrap_or_else(|| {
            panic!(
                "\n\nAssist is not applicable: {}\nAvailable assists: {}",
                assist_id,
                crate::assists(&db, frange)
                    .into_iter()
-                    .map(|(id, _)| id.id.0)
+                    .map(|assist| assist.label.id.0)
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        });
-    let actual = action.edit.apply(&before);
+    let actual = assist.get_first_action().edit.apply(&before);
    assert_eq_text!(after, &actual);
 }
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 712ff6f6a..d45b58966 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -13,6 +13,7 @@ mod doc_tests;
 mod test_db;
 pub mod ast_transform;
+use either::Either;
 use hir::db::HirDatabase;
 use ra_db::FileRange;
 use ra_syntax::{TextRange, TextUnit};
@@ -35,11 +36,27 @@ pub struct AssistLabel {
 #[derive(Debug, Clone)]
 pub struct AssistAction {
+    pub label: Option<String>,
    pub edit: TextEdit,
    pub cursor_position: Option<TextUnit>,
    pub target: Option<TextRange>,
 }
+#[derive(Debug, Clone)]
+pub struct ResolvedAssist {
+    pub label: AssistLabel,
+    pub action_data: Either<AssistAction, Vec<AssistAction>>,
+}
+impl ResolvedAssist {
+    pub fn get_first_action(&self) -> AssistAction {
+        match &self.action_data {
+            Either::Left(action) => action.clone(),
+            Either::Right(actions) => actions[0].clone(),
+        }
+    }
+}
 /// Return all the assists applicable at the given position.
 ///
 /// Assists are returned in the "unresolved" state, that is only labels are
@@ -64,7 +81,7 @@ where
 ///
 /// Assists are returned in the "resolved" state, that is with edit fully
 /// computed.
-pub fn assists<H>(db: &H, range: FileRange) -> Vec<(AssistLabel, AssistAction)>
+pub fn assists<H>(db: &H, range: FileRange) -> Vec<ResolvedAssist>
 where
    H: HirDatabase + 'static,
 {
@@ -75,11 +92,11 @@ where
            .iter()
            .filter_map(|f| f(ctx.clone()))
            .map(|a| match a {
-                Assist::Resolved { label, action } => (label, action),
+                Assist::Resolved { assist } => assist,
                Assist::Unresolved { .. } => unreachable!(),
            })
            .collect::<Vec<_>>();
-        a.sort_by(|a, b| match (a.1.target, b.1.target) {
+        a.sort_by(|a, b| match (a.get_first_action().target, b.get_first_action().target) {
            (Some(a), Some(b)) => a.len().cmp(&b.len()),
            (Some(_), None) => Ordering::Less,
            (None, Some(_)) => Ordering::Greater,
@@ -174,7 +191,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let actual = action.edit.apply(&before);
@@ -201,7 +218,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let mut actual = action.edit.apply(&before);
@@ -224,7 +241,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let range = action.target.expect("expected target on action");
@@ -243,7 +260,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let range = action.target.expect("expected target on action");
@@ -292,8 +309,11 @@ mod tests {
        let assists = super::assists(&db, frange);
        let mut assists = assists.iter();
-        assert_eq!(assists.next().expect("expected assist").0.label, "make pub(crate)");
+        assert_eq!(
-        assert_eq!(assists.next().expect("expected assist").0.label, "add `#[derive]`");
+            assists.next().expect("expected assist").label.label,
+            "Change visibility to pub(crate)"
+        );
+        assert_eq!(assists.next().expect("expected assist").label.label, "Add `#[derive]`");
    }
    #[test]
@@ -312,7 +332,7 @@ mod tests {
        let assists = super::assists(&db, frange);
        let mut assists = assists.iter();
-        assert_eq!(assists.next().expect("expected assist").0.label, "introduce variable");
+        assert_eq!(assists.next().expect("expected assist").label.label, "Extract into variable");
-        assert_eq!(assists.next().expect("expected assist").0.label, "replace with match");
+        assert_eq!(assists.next().expect("expected assist").label.label, "Replace with match");
    }
 }
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
index 2e411d23b..9ead48abf 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 crossbeam-channel = "0.4"
-lsp-types = { version = "0.68.0", features = ["proposed"] }
+lsp-types = { version = "0.69.0", features = ["proposed"] }
 log = "0.4.3"
 cargo_metadata = "0.9.1"
 jod-thread = "0.1.0"
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
index 20fa5a924..7f4c9280c 100644
--- a/crates/ra_cargo_watch/src/lib.rs
+++ b/crates/ra_cargo_watch/src/lib.rs
@@ -38,7 +38,7 @@ pub struct CheckOptions {
 #[derive(Debug)]
 pub struct CheckWatcher {
    pub task_recv: Receiver<CheckTask>,
-    pub shared: Arc<RwLock<CheckWatcherSharedState>>,
+    pub state: Arc<RwLock<CheckState>>,
    cmd_send: Option<Sender<CheckCommand>>,
    handle: Option<JoinHandle<()>>,
 }
@@ -46,22 +46,21 @@ pub struct CheckWatcher {
 impl CheckWatcher {
    pub fn new(options: &CheckOptions, workspace_root: PathBuf) -> CheckWatcher {
        let options = options.clone();
-        let shared = Arc::new(RwLock::new(CheckWatcherSharedState::new()));
+        let state = Arc::new(RwLock::new(CheckState::new()));
        let (task_send, task_recv) = unbounded::<CheckTask>();
        let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
-        let shared_ = shared.clone();
        let handle = std::thread::spawn(move || {
-            let mut check = CheckWatcherState::new(options, workspace_root, shared_);
+            let mut check = CheckWatcherThread::new(options, workspace_root);
            check.run(&task_send, &cmd_recv);
        });
-        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle), shared }
+        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle), state }
    }
    /// Returns a CheckWatcher that doesn't actually do anything
    pub fn dummy() -> CheckWatcher {
-        let shared = Arc::new(RwLock::new(CheckWatcherSharedState::new()));
+        let state = Arc::new(RwLock::new(CheckState::new()));
-        CheckWatcher { task_recv: never(), cmd_send: None, handle: None, shared }
+        CheckWatcher { task_recv: never(), cmd_send: None, handle: None, state }
    }
    /// Schedule a re-start of the cargo check worker.
@@ -89,14 +88,14 @@ impl std::ops::Drop for CheckWatcher {
 }
 #[derive(Debug)]
-pub struct CheckWatcherSharedState {
+pub struct CheckState {
    diagnostic_collection: HashMap<Url, Vec<Diagnostic>>,
    suggested_fix_collection: HashMap<Url, Vec<SuggestedFix>>,
 }
-impl CheckWatcherSharedState {
+impl CheckState {
-    fn new() -> CheckWatcherSharedState {
+    fn new() -> CheckState {
-        CheckWatcherSharedState {
+        CheckState {
            diagnostic_collection: HashMap::new(),
            suggested_fix_collection: HashMap::new(),
        }
@@ -104,15 +103,11 @@ impl CheckWatcherSharedState {
    /// Clear the cached diagnostics, and schedule updating diagnostics by the
    /// server, to clear stale results.
-    pub fn clear(&mut self, task_send: &Sender<CheckTask>) {
+    pub fn clear(&mut self) -> Vec<Url> {
        let cleared_files: Vec<Url> = self.diagnostic_collection.keys().cloned().collect();
        self.diagnostic_collection.clear();
        self.suggested_fix_collection.clear();
+        cleared_files
-        for uri in cleared_files {
-            task_send.send(CheckTask::Update(uri.clone())).unwrap();
-        }
    }
    pub fn diagnostics_for(&self, uri: &Url) -> Option<&[Diagnostic]> {
@@ -123,6 +118,13 @@ impl CheckWatcherSharedState {
        self.suggested_fix_collection.get(uri).map(|d| d.as_slice())
    }
+    pub fn add_diagnostic_with_fixes(&mut self, file_uri: Url, diagnostic: DiagnosticWithFixes) {
+        for fix in diagnostic.suggested_fixes {
+            self.add_suggested_fix_for_diagnostic(fix, &diagnostic.diagnostic);
+        }
+        self.add_diagnostic(file_uri, diagnostic.diagnostic);
+    }
    fn add_diagnostic(&mut self, file_uri: Url, diagnostic: Diagnostic) {
        let diagnostics = self.diagnostic_collection.entry(file_uri).or_default();
@@ -158,8 +160,11 @@ impl CheckWatcherSharedState {
 #[derive(Debug)]
 pub enum CheckTask {
-    /// Request a update of the given files diagnostics
+    /// Request a clearing of all cached diagnostics from the check watcher
-    Update(Url),
+    ClearDiagnostics,
+    /// Request adding a diagnostic with fixes included to a file
+    AddDiagnostic(Url, DiagnosticWithFixes),
    /// Request check progress notification to client
    Status(WorkDoneProgress),
@@ -170,26 +175,20 @@ pub enum CheckCommand {
    Update,
 }
-struct CheckWatcherState {
+struct CheckWatcherThread {
    options: CheckOptions,
    workspace_root: PathBuf,
    watcher: WatchThread,
    last_update_req: Option<Instant>,
-    shared: Arc<RwLock<CheckWatcherSharedState>>,
 }
-impl CheckWatcherState {
+impl CheckWatcherThread {
-    fn new(
+    fn new(options: CheckOptions, workspace_root: PathBuf) -> CheckWatcherThread {
-        options: CheckOptions,
+        CheckWatcherThread {
-        workspace_root: PathBuf,
-        shared: Arc<RwLock<CheckWatcherSharedState>>,
-    ) -> CheckWatcherState {
-        CheckWatcherState {
            options,
            workspace_root,
            watcher: WatchThread::dummy(),
            last_update_req: None,
-            shared,
        }
    }
@@ -215,7 +214,7 @@ impl CheckWatcherState {
            if self.should_recheck() {
                self.last_update_req.take();
-                self.shared.write().clear(task_send);
+                task_send.send(CheckTask::ClearDiagnostics).unwrap();
                // By replacing the watcher, we drop the previous one which
                // causes it to shut down automatically.
@@ -240,7 +239,7 @@ impl CheckWatcherState {
        }
    }
-    fn handle_message(&mut self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
+    fn handle_message(&self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
        match msg {
            CheckEvent::Begin => {
                task_send
@@ -279,18 +278,9 @@ impl CheckWatcherState {
                    };
                let MappedRustDiagnostic { location, diagnostic, suggested_fixes } = map_result;
-                let file_uri = location.uri.clone();
-                if !suggested_fixes.is_empty() {
+                let diagnostic = DiagnosticWithFixes { diagnostic, suggested_fixes };
-                    for suggested_fix in suggested_fixes {
+                task_send.send(CheckTask::AddDiagnostic(location.uri, diagnostic)).unwrap();
-                        self.shared
-                            .write()
-                            .add_suggested_fix_for_diagnostic(suggested_fix, &diagnostic);
-                    }
-                }
-                self.shared.write().add_diagnostic(file_uri, diagnostic);
-                task_send.send(CheckTask::Update(location.uri)).unwrap();
            }
            CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
@@ -299,6 +289,12 @@ impl CheckWatcherState {
    }
 }
+#[derive(Debug)]
+pub struct DiagnosticWithFixes {
+    diagnostic: Diagnostic,
+    suggested_fixes: Vec<SuggestedFix>,
+}
 /// WatchThread exists to wrap around the communication needed to be able to
 /// run `cargo check` without blocking. Currently the Rust standard library
 /// doesn't provide a way to read sub-process output without blocking, so we
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index a177cebca..500b34c17 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -7,7 +7,6 @@ use hir_def::{
    builtin_type::BuiltinType,
    docs::Documentation,
    expr::{BindingAnnotation, Pat, PatId},
-    nameres::ModuleSource,
    per_ns::PerNs,
    resolver::HasResolver,
    type_ref::{Mutability, TypeRef},
@@ -21,8 +20,8 @@ use hir_expand::{
    MacroDefId,
 };
 use hir_ty::{
-    autoderef, display::HirFormatter, expr::ExprValidator, ApplicationTy, Canonical, InEnvironment,
+    autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
-    TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
+    Canonical, InEnvironment, TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
@@ -120,7 +119,8 @@ impl_froms!(
    BuiltinType
 );
-pub use hir_def::{attr::Attrs, visibility::Visibility};
+pub use hir_def::{attr::Attrs, visibility::Visibility, AssocItemId};
+use rustc_hash::FxHashSet;
 impl Module {
    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
@@ -192,13 +192,14 @@ impl Module {
    pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
        let _p = profile("Module::diagnostics");
-        db.crate_def_map(self.id.krate).add_diagnostics(db, self.id.local_id, sink);
+        let crate_def_map = db.crate_def_map(self.id.krate);
+        crate_def_map.add_diagnostics(db, self.id.local_id, sink);
        for decl in self.declarations(db) {
            match decl {
                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
                crate::ModuleDef::Module(m) => {
                    // Only add diagnostics from inline modules
-                    if let ModuleSource::Module(_) = m.definition_source(db).value {
+                    if crate_def_map[m.id.local_id].origin.is_inline() {
                        m.diagnostics(db, sink)
                    }
                }
@@ -878,6 +879,28 @@ impl Type {
        }
    }
+    /// Checks that particular type `ty` implements `std::future::Future`.
+    /// This function is used in `.await` syntax completion.
+    pub fn impls_future(&self, db: &impl HirDatabase) -> bool {
+        let krate = self.krate;
+        let std_future_trait =
+            db.lang_item(krate, "future_trait".into()).and_then(|it| it.as_trait());
+        let std_future_trait = match std_future_trait {
+            Some(it) => it,
+            None => return false,
+        };
+        let canonical_ty = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        method_resolution::implements_trait(
+            &canonical_ty,
+            db,
+            self.ty.environment.clone(),
+            krate,
+            std_future_trait,
+        )
+    }
    // FIXME: this method is broken, as it doesn't take closures into account.
    pub fn as_callable(&self) -> Option<CallableDef> {
        Some(self.ty.value.as_callable()?.0)
@@ -986,6 +1009,65 @@ impl Type {
        None
    }
+    pub fn iterate_method_candidates<T>(
+        &self,
+        db: &impl HirDatabase,
+        krate: Crate,
+        traits_in_scope: &FxHashSet<TraitId>,
+        name: Option<&Name>,
+        mut callback: impl FnMut(&Ty, Function) -> Option<T>,
+    ) -> Option<T> {
+        // There should be no inference vars in types passed here
+        // FIXME check that?
+        // FIXME replace Unknown by bound vars here
+        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let env = self.ty.environment.clone();
+        let krate = krate.id;
+        method_resolution::iterate_method_candidates(
+            &canonical,
+            db,
+            env,
+            krate,
+            traits_in_scope,
+            name,
+            method_resolution::LookupMode::MethodCall,
+            |ty, it| match it {
+                AssocItemId::FunctionId(f) => callback(ty, f.into()),
+                _ => None,
+            },
+        )
+    }
+    pub fn iterate_path_candidates<T>(
+        &self,
+        db: &impl HirDatabase,
+        krate: Crate,
+        traits_in_scope: &FxHashSet<TraitId>,
+        name: Option<&Name>,
+        mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
+    ) -> Option<T> {
+        // There should be no inference vars in types passed here
+        // FIXME check that?
+        // FIXME replace Unknown by bound vars here
+        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let env = self.ty.environment.clone();
+        let krate = krate.id;
+        method_resolution::iterate_method_candidates(
+            &canonical,
+            db,
+            env,
+            krate,
+            traits_in_scope,
+            name,
+            method_resolution::LookupMode::Path,
+            |ty, it| callback(ty, it.into()),
+        )
+    }
    pub fn as_adt(&self) -> Option<Adt> {
        let (adt, _subst) = self.ty.value.as_adt()?;
        Some(adt.into())
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
deleted file mode 100644
index 6314be8d4..000000000
--- a/crates/ra_hir/src/from_source.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-//! Finds a corresponding hir data structure for a syntax node in a specific
-//! file.
-use hir_def::{
-    child_by_source::ChildBySource, dyn_map::DynMap, keys, keys::Key, nameres::ModuleSource,
-    ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId,
-    StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
-};
-use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
-use ra_db::FileId;
-use ra_prof::profile;
-use ra_syntax::{
-    ast::{self, AstNode, NameOwner},
-    match_ast, SyntaxNode,
-};
-use crate::{
-    db::{DefDatabase, HirDatabase},
-    Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, ImplBlock, InFile, Local,
-    MacroDef, Module, Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union,
-};
-pub trait FromSource: Sized {
-    type Ast;
-    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self>;
-}
-pub trait FromSourceByContainer: Sized {
-    type Ast: AstNode + 'static;
-    type Id: Copy + 'static;
-    const KEY: Key<Self::Ast, Self::Id>;
-}
-impl<T: FromSourceByContainer> FromSource for T
-where
-    T: From<<T as FromSourceByContainer>::Id>,
-{
-    type Ast = <T as FromSourceByContainer>::Ast;
-    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
-        analyze_container(db, src.as_ref().map(|it| it.syntax()))[T::KEY]
-            .get(&src)
-            .copied()
-            .map(Self::from)
-    }
-}
-macro_rules! from_source_by_container_impls {
-    ($(($hir:ident, $id:ident, $ast:path, $key:path)),* ,) => {$(
-        impl FromSourceByContainer for $hir {
-            type Ast = $ast;
-            type Id = $id;
-            const KEY: Key<Self::Ast, Self::Id> = $key;
-        }
-    )*}
-}
-from_source_by_container_impls![
-    (Struct, StructId, ast::StructDef, keys::STRUCT),
-    (Union, UnionId, ast::UnionDef, keys::UNION),
-    (Enum, EnumId, ast::EnumDef, keys::ENUM),
-    (Trait, TraitId, ast::TraitDef, keys::TRAIT),
-    (Function, FunctionId, ast::FnDef, keys::FUNCTION),
-    (Static, StaticId, ast::StaticDef, keys::STATIC),
-    (Const, ConstId, ast::ConstDef, keys::CONST),
-    (TypeAlias, TypeAliasId, ast::TypeAliasDef, keys::TYPE_ALIAS),
-    (ImplBlock, ImplId, ast::ImplBlock, keys::IMPL),
-];
-impl FromSource for MacroDef {
-    type Ast = ast::MacroCall;
-    fn from_source(db: &impl DefDatabase, src: InFile<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, InFile::new(src.file_id, module_src))?;
-        let krate = Some(module.krate().id);
-        let ast_id = Some(AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.value)));
-        let id: MacroDefId = MacroDefId { krate, ast_id, kind };
-        Some(MacroDef { id })
-    }
-}
-impl FromSource for EnumVariant {
-    type Ast = ast::EnumVariant;
-    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
-        let parent_enum = src.value.parent_enum();
-        let src_enum = InFile { file_id: src.file_id, value: parent_enum };
-        let parent_enum = Enum::from_source(db, src_enum)?;
-        parent_enum.id.child_by_source(db)[keys::ENUM_VARIANT]
-            .get(&src)
-            .copied()
-            .map(EnumVariant::from)
-    }
-}
-impl FromSource for StructField {
-    type Ast = FieldSource;
-    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
-        let src = src.as_ref();
-        // FIXME this is buggy
-        let variant_id: VariantId = match src.value {
-            FieldSource::Named(field) => {
-                let value = field.syntax().ancestors().find_map(ast::StructDef::cast)?;
-                let src = InFile { file_id: src.file_id, value };
-                let def = Struct::from_source(db, src)?;
-                def.id.into()
-            }
-            FieldSource::Pos(field) => {
-                let value = field.syntax().ancestors().find_map(ast::EnumVariant::cast)?;
-                let src = InFile { file_id: src.file_id, value };
-                let def = EnumVariant::from_source(db, src)?;
-                EnumVariantId::from(def).into()
-            }
-        };
-        let dyn_map = variant_id.child_by_source(db);
-        match src.value {
-            FieldSource::Pos(it) => dyn_map[keys::TUPLE_FIELD].get(&src.with_value(it.clone())),
-            FieldSource::Named(it) => dyn_map[keys::RECORD_FIELD].get(&src.with_value(it.clone())),
-        }
-        .copied()
-        .map(StructField::from)
-    }
-}
-impl Local {
-    pub fn from_source(db: &impl HirDatabase, src: InFile<ast::BindPat>) -> Option<Self> {
-        let file_id = src.file_id;
-        let parent: DefWithBody = src.value.syntax().ancestors().find_map(|it| {
-            let res = match_ast! {
-                match it {
-                    ast::ConstDef(value) => { Const::from_source(db, InFile { value, file_id})?.into() },
-                    ast::StaticDef(value) => { Static::from_source(db, InFile { value, file_id})?.into() },
-                    ast::FnDef(value) => { Function::from_source(db, InFile { value, file_id})?.into() },
-                    _ => return None,
-                }
-            };
-            Some(res)
-        })?;
-        let (_body, source_map) = db.body_with_source_map(parent.into());
-        let src = src.map(ast::Pat::from);
-        let pat_id = source_map.node_pat(src.as_ref())?;
-        Some(Local { parent, pat_id })
-    }
-}
-impl TypeParam {
-    pub fn from_source(db: &impl HirDatabase, src: InFile<ast::TypeParam>) -> Option<Self> {
-        let file_id = src.file_id;
-        let parent: GenericDefId = src.value.syntax().ancestors().find_map(|it| {
-            let res = match_ast! {
-                match it {
-                    ast::FnDef(value) => { Function::from_source(db, InFile { value, file_id})?.id.into() },
-                    ast::StructDef(value) => { Struct::from_source(db, InFile { value, file_id})?.id.into() },
-                    ast::EnumDef(value) => { Enum::from_source(db, InFile { value, file_id})?.id.into() },
-                    ast::TraitDef(value) => { Trait::from_source(db, InFile { value, file_id})?.id.into() },
-                    ast::TypeAliasDef(value) => { TypeAlias::from_source(db, InFile { value, file_id})?.id.into() },
-                    ast::ImplBlock(value) => { ImplBlock::from_source(db, InFile { value, file_id})?.id.into() },
-                    _ => return None,
-                }
-            };
-            Some(res)
-        })?;
-        let &id = parent.child_by_source(db)[keys::TYPE_PARAM].get(&src)?;
-        Some(TypeParam { id })
-    }
-}
-impl Module {
-    pub fn from_declaration(db: &impl DefDatabase, src: InFile<ast::Module>) -> Option<Self> {
-        let _p = profile("Module::from_declaration");
-        let parent_declaration = src.value.syntax().ancestors().skip(1).find_map(ast::Module::cast);
-        let parent_module = match parent_declaration {
-            Some(parent_declaration) => {
-                let src_parent = InFile { file_id: src.file_id, value: parent_declaration };
-                Module::from_declaration(db, src_parent)
-            }
-            None => {
-                let source_file = db.parse(src.file_id.original_file(db)).tree();
-                let src_parent =
-                    InFile { file_id: src.file_id, value: ModuleSource::SourceFile(source_file) };
-                Module::from_definition(db, src_parent)
-            }
-        }?;
-        let child_name = src.value.name()?.as_name();
-        let def_map = db.crate_def_map(parent_module.id.krate);
-        let child_id = def_map[parent_module.id.local_id].children.get(&child_name)?;
-        Some(parent_module.with_module_id(*child_id))
-    }
-    pub fn from_definition(db: &impl DefDatabase, src: InFile<ModuleSource>) -> Option<Self> {
-        let _p = profile("Module::from_definition");
-        match src.value {
-            ModuleSource::Module(ref module) => {
-                assert!(!module.has_semi());
-                return Module::from_declaration(
-                    db,
-                    InFile { file_id: src.file_id, value: module.clone() },
-                );
-            }
-            ModuleSource::SourceFile(_) => (),
-        };
-        let original_file = src.file_id.original_file(db);
-        Module::from_file(db, original_file)
-    }
-    fn from_file(db: &impl DefDatabase, file: FileId) -> Option<Self> {
-        let _p = profile("Module::from_file");
-        let (krate, local_id) = db.relevant_crates(file).iter().find_map(|&crate_id| {
-            let crate_def_map = db.crate_def_map(crate_id);
-            let local_id = crate_def_map.modules_for_file(file).next()?;
-            Some((crate_id, local_id))
-        })?;
-        Some(Module { id: ModuleId { krate, local_id } })
-    }
-}
-fn analyze_container(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> DynMap {
-    let _p = profile("analyze_container");
-    return child_by_source(db, src).unwrap_or_default();
-    fn child_by_source(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> Option<DynMap> {
-        for container in src.value.ancestors().skip(1) {
-            let res = match_ast! {
-                match container {
-                    ast::TraitDef(it) => {
-                        let def = Trait::from_source(db, src.with_value(it))?;
-                        def.id.child_by_source(db)
-                    },
-                    ast::ImplBlock(it) => {
-                        let def = ImplBlock::from_source(db, src.with_value(it))?;
-                        def.id.child_by_source(db)
-                    },
-                    ast::FnDef(it) => {
-                        let def = Function::from_source(db, src.with_value(it))?;
-                        DefWithBodyId::from(def.id)
-                            .child_by_source(db)
-                    },
-                    ast::StaticDef(it) => {
-                        let def = Static::from_source(db, src.with_value(it))?;
-                        DefWithBodyId::from(def.id)
-                            .child_by_source(db)
-                    },
-                    ast::ConstDef(it) => {
-                        let def = Const::from_source(db, src.with_value(it))?;
-                        DefWithBodyId::from(def.id)
-                            .child_by_source(db)
-                    },
-                    _ => { continue },
-                }
-            };
-            return Some(res);
-        }
-        let module_source = ModuleSource::from_child_node(db, src);
-        let c = Module::from_definition(db, src.with_value(module_source))?;
-        Some(c.id.child_by_source(db))
-    }
-}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 3d13978d4..e1c7b7a20 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -8,7 +8,7 @@
 #![recursion_limit = "512"]
 macro_rules! impl_froms {
-    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
+    ($e:ident: $($v:ident $(($($sv:ident),*))?),*$(,)?) => {
        $(
            impl From<$v> for $e {
                fn from(it: $v) -> $e {
@@ -27,6 +27,7 @@ macro_rules! impl_froms {
 }
 pub mod db;
+pub mod source_analyzer;
 pub mod source_binder;
 pub mod diagnostics;
@@ -35,7 +36,6 @@ mod from_id;
 mod code_model;
 mod has_source;
-mod from_source;
 pub use crate::{
    code_model::{
@@ -44,9 +44,9 @@ pub use crate::{
        MacroDef, Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias,
        TypeParam, Union, VariantDef,
    },
-    from_source::FromSource,
    has_source::HasSource,
-    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
+    source_analyzer::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
+    source_binder::SourceBinder,
 };
 pub use hir_def::{
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
new file mode 100644
index 000000000..4f8fc9602
--- /dev/null
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -0,0 +1,450 @@
+//! Lookup hir elements using positions in the source code. This is a lossy
+//! transformation: in general, a single source might correspond to several
+//! modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on
+//! modules.
+//!
+//! So, this modules should not be used during hir construction, it exists
+//! purely for "IDE needs".
+use std::sync::Arc;
+use either::Either;
+use hir_def::{
+    body::{
+        scope::{ExprScopes, ScopeId},
+        BodySourceMap,
+    },
+    expr::{ExprId, PatId},
+    resolver::{self, resolver_for_scope, Resolver, TypeNs, ValueNs},
+    DefWithBodyId, TraitId,
+};
+use hir_expand::{
+    hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
+};
+use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
+use ra_syntax::{
+    ast::{self, AstNode},
+    AstPtr, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
+};
+use rustc_hash::FxHashSet;
+use crate::{
+    db::HirDatabase, Adt, Const, DefWithBody, EnumVariant, Function, Local, MacroDef, Name, Path,
+    ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+};
+/// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
+/// original source files. It should not be used inside the HIR itself.
+#[derive(Debug)]
+pub struct SourceAnalyzer {
+    file_id: HirFileId,
+    resolver: Resolver,
+    body_owner: Option<DefWithBody>,
+    body_source_map: Option<Arc<BodySourceMap>>,
+    infer: Option<Arc<InferenceResult>>,
+    scopes: Option<Arc<ExprScopes>>,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PathResolution {
+    /// An item
+    Def(crate::ModuleDef),
+    /// A local binding (only value namespace)
+    Local(Local),
+    /// A generic parameter
+    TypeParam(TypeParam),
+    SelfType(crate::ImplBlock),
+    Macro(MacroDef),
+    AssocItem(crate::AssocItem),
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScopeEntryWithSyntax {
+    pub(crate) name: Name,
+    pub(crate) ptr: Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>,
+}
+impl ScopeEntryWithSyntax {
+    pub fn name(&self) -> &Name {
+        &self.name
+    }
+    pub fn ptr(&self) -> Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>> {
+        self.ptr
+    }
+}
+#[derive(Debug)]
+pub struct ReferenceDescriptor {
+    pub range: TextRange,
+    pub name: String,
+}
+#[derive(Debug)]
+pub struct Expansion {
+    macro_call_id: MacroCallId,
+}
+impl Expansion {
+    pub fn map_token_down(
+        &self,
+        db: &impl HirDatabase,
+        token: InFile<&SyntaxToken>,
+    ) -> Option<InFile<SyntaxToken>> {
+        let exp_info = self.file_id().expansion_info(db)?;
+        exp_info.map_token_down(token)
+    }
+    pub fn file_id(&self) -> HirFileId {
+        self.macro_call_id.as_file()
+    }
+}
+impl SourceAnalyzer {
+    pub fn new(
+        db: &impl HirDatabase,
+        node: InFile<&SyntaxNode>,
+        offset: Option<TextUnit>,
+    ) -> SourceAnalyzer {
+        crate::source_binder::SourceBinder::new(db).analyze(node, offset)
+    }
+    pub(crate) fn new_for_body(
+        db: &impl HirDatabase,
+        def: DefWithBodyId,
+        node: InFile<&SyntaxNode>,
+        offset: Option<TextUnit>,
+    ) -> SourceAnalyzer {
+        let (_body, source_map) = db.body_with_source_map(def);
+        let scopes = db.expr_scopes(def);
+        let scope = match offset {
+            None => scope_for(&scopes, &source_map, node),
+            Some(offset) => scope_for_offset(&scopes, &source_map, node.with_value(offset)),
+        };
+        let resolver = resolver_for_scope(db, def, scope);
+        SourceAnalyzer {
+            resolver,
+            body_owner: Some(def.into()),
+            body_source_map: Some(source_map),
+            infer: Some(db.infer(def)),
+            scopes: Some(scopes),
+            file_id: node.file_id,
+        }
+    }
+    pub(crate) fn new_for_resolver(
+        resolver: Resolver,
+        node: InFile<&SyntaxNode>,
+    ) -> SourceAnalyzer {
+        SourceAnalyzer {
+            resolver,
+            body_owner: None,
+            body_source_map: None,
+            infer: None,
+            scopes: None,
+            file_id: node.file_id,
+        }
+    }
+    pub fn module(&self) -> Option<crate::code_model::Module> {
+        Some(crate::code_model::Module { id: self.resolver.module()? })
+    }
+    fn expr_id(&self, expr: &ast::Expr) -> Option<ExprId> {
+        let src = InFile { file_id: self.file_id, value: expr };
+        self.body_source_map.as_ref()?.node_expr(src)
+    }
+    fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
+        let src = InFile { file_id: self.file_id, value: pat };
+        self.body_source_map.as_ref()?.node_pat(src)
+    }
+    fn expand_expr(
+        &self,
+        db: &impl HirDatabase,
+        expr: InFile<&ast::Expr>,
+    ) -> Option<InFile<ast::Expr>> {
+        let macro_call = ast::MacroCall::cast(expr.value.syntax().clone())?;
+        let macro_file =
+            self.body_source_map.as_ref()?.node_macro_file(expr.with_value(&macro_call))?;
+        let expanded = db.parse_or_expand(macro_file)?;
+        let kind = expanded.kind();
+        let expr = InFile::new(macro_file, ast::Expr::cast(expanded)?);
+        if ast::MacroCall::can_cast(kind) {
+            self.expand_expr(db, expr.as_ref())
+        } else {
+            Some(expr)
+        }
+    }
+    pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
+        let expr_id = if let Some(expr) = self.expand_expr(db, InFile::new(self.file_id, expr)) {
+            self.body_source_map.as_ref()?.node_expr(expr.as_ref())?
+        } else {
+            self.expr_id(expr)?
+        };
+        let ty = self.infer.as_ref()?[expr_id].clone();
+        let environment = TraitEnvironment::lower(db, &self.resolver);
+        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
+    }
+    pub fn type_of_pat(&self, db: &impl HirDatabase, pat: &ast::Pat) -> Option<Type> {
+        let pat_id = self.pat_id(pat)?;
+        let ty = self.infer.as_ref()?[pat_id].clone();
+        let environment = TraitEnvironment::lower(db, &self.resolver);
+        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
+    }
+    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+        let expr_id = self.expr_id(&call.clone().into())?;
+        self.infer.as_ref()?.method_resolution(expr_id).map(Function::from)
+    }
+    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<crate::StructField> {
+        let expr_id = self.expr_id(&field.clone().into())?;
+        self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
+    }
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<crate::StructField> {
+        let expr_id = match field.expr() {
+            Some(it) => self.expr_id(&it)?,
+            None => {
+                let src = InFile { file_id: self.file_id, value: field };
+                self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?
+            }
+        };
+        self.infer.as_ref()?.record_field_resolution(expr_id).map(|it| it.into())
+    }
+    pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {
+        let expr_id = self.expr_id(&record_lit.clone().into())?;
+        self.infer.as_ref()?.variant_resolution_for_expr(expr_id).map(|it| it.into())
+    }
+    pub fn resolve_record_pattern(&self, record_pat: &ast::RecordPat) -> Option<crate::VariantDef> {
+        let pat_id = self.pat_id(&record_pat.clone().into())?;
+        self.infer.as_ref()?.variant_resolution_for_pat(pat_id).map(|it| it.into())
+    }
+    pub fn resolve_macro_call(
+        &self,
+        db: &impl HirDatabase,
+        macro_call: InFile<&ast::MacroCall>,
+    ) -> Option<MacroDef> {
+        let hygiene = Hygiene::new(db, macro_call.file_id);
+        let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &hygiene))?;
+        self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into())
+    }
+    pub fn resolve_hir_path(
+        &self,
+        db: &impl HirDatabase,
+        path: &crate::Path,
+    ) -> Option<PathResolution> {
+        let types =
+            self.resolver.resolve_path_in_type_ns_fully(db, path.mod_path()).map(|ty| match ty {
+                TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
+                TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
+                TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
+                    PathResolution::Def(Adt::from(it).into())
+                }
+                TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
+                TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
+                TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
+            });
+        let values =
+            self.resolver.resolve_path_in_value_ns_fully(db, path.mod_path()).and_then(|val| {
+                let res = match val {
+                    ValueNs::LocalBinding(pat_id) => {
+                        let var = Local { parent: self.body_owner?, pat_id };
+                        PathResolution::Local(var)
+                    }
+                    ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
+                    ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
+                    ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
+                    ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
+                    ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                };
+                Some(res)
+            });
+        let items = self
+            .resolver
+            .resolve_module_path_in_items(db, path.mod_path())
+            .take_types()
+            .map(|it| PathResolution::Def(it.into()));
+        types.or(values).or(items).or_else(|| {
+            self.resolver
+                .resolve_path_as_macro(db, path.mod_path())
+                .map(|def| PathResolution::Macro(def.into()))
+        })
+    }
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option<PathResolution> {
+        if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
+            let expr_id = self.expr_id(&path_expr.into())?;
+            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
+                return Some(PathResolution::AssocItem(assoc.into()));
+            }
+        }
+        if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
+            let pat_id = self.pat_id(&path_pat.into())?;
+            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) {
+                return Some(PathResolution::AssocItem(assoc.into()));
+            }
+        }
+        // This must be a normal source file rather than macro file.
+        let hir_path = crate::Path::from_ast(path.clone())?;
+        self.resolve_hir_path(db, &hir_path)
+    }
+    fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
+        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, InFile::new(self.file_id, name_ref.syntax()))?;
+        let entry = scopes.resolve_name_in_scope(scope, &name)?;
+        Some(ScopeEntryWithSyntax {
+            name: entry.name().clone(),
+            ptr: source_map.pat_syntax(entry.pat())?.value,
+        })
+    }
+    pub fn process_all_names(&self, db: &impl HirDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
+        self.resolver.process_all_names(db, &mut |name, def| {
+            let def = match def {
+                resolver::ScopeDef::PerNs(it) => it.into(),
+                resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
+                resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
+                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
+                resolver::ScopeDef::Local(pat_id) => {
+                    let parent = self.resolver.body_owner().unwrap().into();
+                    ScopeDef::Local(Local { parent, pat_id })
+                }
+            };
+            f(name, def)
+        })
+    }
+    // FIXME: we only use this in `inline_local_variable` assist, ideally, we
+    // should switch to general reference search infra there.
+    pub fn find_all_refs(&self, pat: &ast::BindPat) -> Vec<ReferenceDescriptor> {
+        let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
+        let ptr = Either::Left(AstPtr::new(&ast::Pat::from(pat.clone())));
+        fn_def
+            .syntax()
+            .descendants()
+            .filter_map(ast::NameRef::cast)
+            .filter(|name_ref| match self.resolve_local_name(&name_ref) {
+                None => false,
+                Some(entry) => entry.ptr() == ptr,
+            })
+            .map(|name_ref| ReferenceDescriptor {
+                name: name_ref.text().to_string(),
+                range: name_ref.syntax().text_range(),
+            })
+            .collect()
+    }
+    /// Note: `FxHashSet<TraitId>` should be treated as an opaque type, passed into `Type
+    pub fn traits_in_scope(&self, db: &impl HirDatabase) -> FxHashSet<TraitId> {
+        self.resolver.traits_in_scope(db)
+    }
+    pub fn expand(
+        &self,
+        db: &impl HirDatabase,
+        macro_call: InFile<&ast::MacroCall>,
+    ) -> Option<Expansion> {
+        let def = self.resolve_macro_call(db, macro_call)?.id;
+        let ast_id = AstId::new(
+            macro_call.file_id,
+            db.ast_id_map(macro_call.file_id).ast_id(macro_call.value),
+        );
+        Some(Expansion { macro_call_id: def.as_call_id(db, MacroCallKind::FnLike(ast_id)) })
+    }
+}
+fn scope_for(
+    scopes: &ExprScopes,
+    source_map: &BodySourceMap,
+    node: InFile<&SyntaxNode>,
+) -> Option<ScopeId> {
+    node.value
+        .ancestors()
+        .filter_map(ast::Expr::cast)
+        .filter_map(|it| source_map.node_expr(InFile::new(node.file_id, &it)))
+        .find_map(|it| scopes.scope_for(it))
+}
+fn scope_for_offset(
+    scopes: &ExprScopes,
+    source_map: &BodySourceMap,
+    offset: InFile<TextUnit>,
+) -> Option<ScopeId> {
+    scopes
+        .scope_by_expr()
+        .iter()
+        .filter_map(|(id, scope)| {
+            let source = source_map.expr_syntax(*id)?;
+            // FIXME: correctly handle macro expansion
+            if source.file_id != offset.file_id {
+                return None;
+            }
+            let syntax_node_ptr =
+                source.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
+            Some((syntax_node_ptr, scope))
+        })
+        // find containing scope
+        .min_by_key(|(ptr, _scope)| {
+            (
+                !(ptr.range().start() <= offset.value && offset.value <= ptr.range().end()),
+                ptr.range().len(),
+            )
+        })
+        .map(|(ptr, scope)| {
+            adjust(scopes, source_map, ptr, offset.file_id, offset.value).unwrap_or(*scope)
+        })
+}
+// XXX: during completion, cursor might be outside of any particular
+// expression. Try to figure out the correct scope...
+fn adjust(
+    scopes: &ExprScopes,
+    source_map: &BodySourceMap,
+    ptr: SyntaxNodePtr,
+    file_id: HirFileId,
+    offset: TextUnit,
+) -> Option<ScopeId> {
+    let r = ptr.range();
+    let child_scopes = scopes
+        .scope_by_expr()
+        .iter()
+        .filter_map(|(id, scope)| {
+            let source = source_map.expr_syntax(*id)?;
+            // FIXME: correctly handle macro expansion
+            if source.file_id != file_id {
+                return None;
+            }
+            let syntax_node_ptr =
+                source.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
+            Some((syntax_node_ptr, scope))
+        })
+        .map(|(ptr, scope)| (ptr.range(), scope))
+        .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
+    child_scopes
+        .max_by(|(r1, _), (r2, _)| {
+            if r2.is_subrange(&r1) {
+                std::cmp::Ordering::Greater
+            } else if r1.is_subrange(&r2) {
+                std::cmp::Ordering::Less
+            } else {
+                r1.start().cmp(&r2.start())
+            }
+        })
+        .map(|(_ptr, scope)| *scope)
+}
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index a2a9d968c..f3150f578 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -1,569 +1,357 @@
-//! Lookup hir elements using positions in the source code. This is a lossy
+//! `SourceBinder` is the main entry point for getting info about source code.
-//! transformation: in general, a single source might correspond to several
+//! It's main task is to map source syntax trees to hir-level IDs.
-//! modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on
-//! modules.
-//!
-//! So, this modules should not be used during hir construction, it exists
-//! purely for "IDE needs".
-use std::sync::Arc;
-use either::Either;
 use hir_def::{
-    body::{
+    child_by_source::ChildBySource,
-        scope::{ExprScopes, ScopeId},
+    dyn_map::DynMap,
-        BodySourceMap,
+    keys::{self, Key},
-    },
+    resolver::{HasResolver, Resolver},
-    expr::{ExprId, PatId},
+    ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId,
-    nameres::ModuleSource,
+    StaticId, StructFieldId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
-    path::path,
-    resolver::{self, resolver_for_scope, HasResolver, Resolver, TypeNs, ValueNs},
-    AssocItemId, DefWithBodyId,
-};
-use hir_expand::{
-    hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
-};
-use hir_ty::{
-    method_resolution::{self, implements_trait},
-    Canonical, InEnvironment, InferenceResult, TraitEnvironment, Ty,
 };
+use hir_expand::{name::AsName, AstId, InFile, MacroDefId, MacroDefKind};
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, AstNode},
+    ast::{self, NameOwner},
-    match_ast, AstPtr,
+    match_ast, AstNode, SyntaxNode, TextUnit,
-    SyntaxKind::*,
-    SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
 };
+use rustc_hash::FxHashMap;
-use crate::{
+use crate::{db::HirDatabase, Local, Module, SourceAnalyzer, TypeParam};
-    db::HirDatabase, Adt, AssocItem, Const, DefWithBody, Enum, EnumVariant, FromSource, Function,
+use ra_db::FileId;
-    ImplBlock, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias,
-    TypeParam,
-};
-fn try_get_resolver_for_node(db: &impl HirDatabase, node: InFile<&SyntaxNode>) -> Option<Resolver> {
-    match_ast! {
-        match (node.value) {
-            ast::Module(it) => {
-                let src = node.with_value(it);
-                Some(crate::Module::from_declaration(db, src)?.id.resolver(db))
-            },
-             ast::SourceFile(it) => {
-                let src = node.with_value(ModuleSource::SourceFile(it));
-                Some(crate::Module::from_definition(db, src)?.id.resolver(db))
-            },
-            ast::StructDef(it) => {
-                let src = node.with_value(it);
-                Some(Struct::from_source(db, src)?.id.resolver(db))
-            },
-            ast::EnumDef(it) => {
-                let src = node.with_value(it);
-                Some(Enum::from_source(db, src)?.id.resolver(db))
-            },
-            ast::ImplBlock(it) => {
-                let src = node.with_value(it);
-                Some(ImplBlock::from_source(db, src)?.id.resolver(db))
-            },
-            ast::TraitDef(it) => {
-                let src = node.with_value(it);
-                Some(Trait::from_source(db, src)?.id.resolver(db))
-            },
-            _ => match node.value.kind() {
-                FN_DEF | CONST_DEF | STATIC_DEF => {
-                    let def = def_with_body_from_child_node(db, node)?;
-                    let def = DefWithBodyId::from(def);
-                    Some(def.resolver(db))
-                }
-                // FIXME add missing cases
-                _ => None
-            }
-        }
-    }
-}
-fn def_with_body_from_child_node(
-    db: &impl HirDatabase,
-    child: InFile<&SyntaxNode>,
-) -> Option<DefWithBody> {
-    let _p = profile("def_with_body_from_child_node");
-    child.cloned().ancestors_with_macros(db).find_map(|node| {
-        let n = &node.value;
-        match_ast! {
-            match n {
-                ast::FnDef(def)  => { return Function::from_source(db, node.with_value(def)).map(DefWithBody::from); },
-                ast::ConstDef(def) => { return Const::from_source(db, node.with_value(def)).map(DefWithBody::from); },
-                ast::StaticDef(def) => { return Static::from_source(db, node.with_value(def)).map(DefWithBody::from); },
-                _ => { None },
-            }
-        }
-    })
-}
-/// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
-/// original source files. It should not be used inside the HIR itself.
-#[derive(Debug)]
-pub struct SourceAnalyzer {
-    file_id: HirFileId,
-    resolver: Resolver,
-    body_owner: Option<DefWithBody>,
-    body_source_map: Option<Arc<BodySourceMap>>,
-    infer: Option<Arc<InferenceResult>>,
-    scopes: Option<Arc<ExprScopes>>,
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PathResolution {
-    /// An item
-    Def(crate::ModuleDef),
-    /// A local binding (only value namespace)
-    Local(Local),
-    /// A generic parameter
-    TypeParam(TypeParam),
-    SelfType(crate::ImplBlock),
-    Macro(MacroDef),
-    AssocItem(crate::AssocItem),
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ScopeEntryWithSyntax {
-    pub(crate) name: Name,
-    pub(crate) ptr: Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>,
-}
-impl ScopeEntryWithSyntax {
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-    pub fn ptr(&self) -> Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>> {
-        self.ptr
-    }
-}
-#[derive(Debug)]
-pub struct ReferenceDescriptor {
-    pub range: TextRange,
-    pub name: String,
-}
-#[derive(Debug)]
+pub struct SourceBinder<'a, DB> {
-pub struct Expansion {
+    pub db: &'a DB,
-    macro_call_id: MacroCallId,
+    child_by_source_cache: FxHashMap<ChildContainer, DynMap>,
 }
-impl Expansion {
+impl<DB: HirDatabase> SourceBinder<'_, DB> {
-    pub fn map_token_down(
+    pub fn new(db: &DB) -> SourceBinder<DB> {
-        &self,
+        SourceBinder { db, child_by_source_cache: FxHashMap::default() }
-        db: &impl HirDatabase,
-        token: InFile<&SyntaxToken>,
-    ) -> Option<InFile<SyntaxToken>> {
-        let exp_info = self.file_id().expansion_info(db)?;
-        exp_info.map_token_down(token)
-    }
-    pub fn file_id(&self) -> HirFileId {
-        self.macro_call_id.as_file()
    }
-}
-impl SourceAnalyzer {
+    pub fn analyze(
-    pub fn new(
+        &mut self,
-        db: &impl HirDatabase,
+        src: InFile<&SyntaxNode>,
-        node: InFile<&SyntaxNode>,
        offset: Option<TextUnit>,
    ) -> SourceAnalyzer {
-        let _p = profile("SourceAnalyzer::new");
+        let _p = profile("SourceBinder::analyzer");
-        let def_with_body = def_with_body_from_child_node(db, node);
+        let container = match self.find_container(src) {
-        if let Some(def) = def_with_body {
+            Some(it) => it,
-            let (_body, source_map) = db.body_with_source_map(def.into());
+            None => return SourceAnalyzer::new_for_resolver(Resolver::default(), src),
-            let scopes = db.expr_scopes(def.into());
+        };
-            let scope = match offset {
-                None => scope_for(&scopes, &source_map, node),
+        let resolver = match container {
-                Some(offset) => scope_for_offset(&scopes, &source_map, node.with_value(offset)),
+            ChildContainer::DefWithBodyId(def) => {
-            };
+                return SourceAnalyzer::new_for_body(self.db, def, src, offset)
-            let resolver = resolver_for_scope(db, def.into(), scope);
-            SourceAnalyzer {
-                resolver,
-                body_owner: Some(def),
-                body_source_map: Some(source_map),
-                infer: Some(db.infer(def.into())),
-                scopes: Some(scopes),
-                file_id: node.file_id,
-            }
-        } else {
-            SourceAnalyzer {
-                resolver: node
-                    .value
-                    .ancestors()
-                    .find_map(|it| try_get_resolver_for_node(db, node.with_value(&it)))
-                    .unwrap_or_default(),
-                body_owner: None,
-                body_source_map: None,
-                infer: None,
-                scopes: None,
-                file_id: node.file_id,
            }
-        }
+            ChildContainer::TraitId(it) => it.resolver(self.db),
+            ChildContainer::ImplId(it) => it.resolver(self.db),
+            ChildContainer::ModuleId(it) => it.resolver(self.db),
+            ChildContainer::EnumId(it) => it.resolver(self.db),
+            ChildContainer::VariantId(it) => it.resolver(self.db),
+            ChildContainer::GenericDefId(it) => it.resolver(self.db),
+        };
+        SourceAnalyzer::new_for_resolver(resolver, src)
    }
-    pub fn module(&self) -> Option<crate::code_model::Module> {
+    pub fn to_def<T: ToDef>(&mut self, src: InFile<T>) -> Option<T::Def> {
-        Some(crate::code_model::Module { id: self.resolver.module()? })
+        T::to_def(self, src)
    }
-    fn expr_id(&self, expr: &ast::Expr) -> Option<ExprId> {
+    pub fn to_module_def(&mut self, file: FileId) -> Option<Module> {
-        let src = InFile { file_id: self.file_id, value: expr };
+        let _p = profile("SourceBinder::to_module_def");
-        self.body_source_map.as_ref()?.node_expr(src)
+        let (krate, local_id) = self.db.relevant_crates(file).iter().find_map(|&crate_id| {
+            let crate_def_map = self.db.crate_def_map(crate_id);
+            let local_id = crate_def_map.modules_for_file(file).next()?;
+            Some((crate_id, local_id))
+        })?;
+        Some(Module { id: ModuleId { krate, local_id } })
    }
-    fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
+    fn to_id<T: ToId>(&mut self, src: InFile<T>) -> Option<T::ID> {
-        let src = InFile { file_id: self.file_id, value: pat };
+        T::to_id(self, src)
-        self.body_source_map.as_ref()?.node_pat(src)
    }
-    fn expand_expr(
+    fn find_container(&mut self, src: InFile<&SyntaxNode>) -> Option<ChildContainer> {
-        &self,
+        for container in src.cloned().ancestors_with_macros(self.db).skip(1) {
-        db: &impl HirDatabase,
+            let res: ChildContainer = match_ast! {
-        expr: InFile<&ast::Expr>,
+                match (container.value) {
-    ) -> Option<InFile<ast::Expr>> {
+                    ast::TraitDef(it) => {
-        let macro_call = ast::MacroCall::cast(expr.value.syntax().clone())?;
+                        let def: TraitId = self.to_id(container.with_value(it))?;
-        let macro_file =
+                        def.into()
-            self.body_source_map.as_ref()?.node_macro_file(expr.with_value(&macro_call))?;
+                    },
-        let expanded = db.parse_or_expand(macro_file)?;
+                    ast::ImplBlock(it) => {
-        let kind = expanded.kind();
+                        let def: ImplId = self.to_id(container.with_value(it))?;
-        let expr = InFile::new(macro_file, ast::Expr::cast(expanded)?);
+                        def.into()
+                    },
-        if ast::MacroCall::can_cast(kind) {
+                    ast::FnDef(it) => {
-            self.expand_expr(db, expr.as_ref())
+                        let def: FunctionId = self.to_id(container.with_value(it))?;
-        } else {
+                        DefWithBodyId::from(def).into()
-            Some(expr)
+                    },
+                    ast::StaticDef(it) => {
+                        let def: StaticId = self.to_id(container.with_value(it))?;
+                        DefWithBodyId::from(def).into()
+                    },
+                    ast::ConstDef(it) => {
+                        let def: ConstId = self.to_id(container.with_value(it))?;
+                        DefWithBodyId::from(def).into()
+                    },
+                    ast::EnumDef(it) => {
+                        let def: EnumId = self.to_id(container.with_value(it))?;
+                        def.into()
+                    },
+                    ast::StructDef(it) => {
+                        let def: StructId = self.to_id(container.with_value(it))?;
+                        VariantId::from(def).into()
+                    },
+                    ast::UnionDef(it) => {
+                        let def: UnionId = self.to_id(container.with_value(it))?;
+                        VariantId::from(def).into()
+                    },
+                    ast::Module(it) => {
+                        let def: ModuleId = self.to_id(container.with_value(it))?;
+                        def.into()
+                    },
+                    _ => { continue },
+                }
+            };
+            return Some(res);
        }
-    }
-    pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
+        let c = self.to_module_def(src.file_id.original_file(self.db))?;
-        let expr_id = if let Some(expr) = self.expand_expr(db, InFile::new(self.file_id, expr)) {
+        Some(c.id.into())
-            self.body_source_map.as_ref()?.node_expr(expr.as_ref())?
-        } else {
-            self.expr_id(expr)?
-        };
-        let ty = self.infer.as_ref()?[expr_id].clone();
-        let environment = TraitEnvironment::lower(db, &self.resolver);
-        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
-    }
-    pub fn type_of_pat(&self, db: &impl HirDatabase, pat: &ast::Pat) -> Option<Type> {
-        let pat_id = self.pat_id(pat)?;
-        let ty = self.infer.as_ref()?[pat_id].clone();
-        let environment = TraitEnvironment::lower(db, &self.resolver);
-        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
    }
-    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+    fn child_by_source(&mut self, container: ChildContainer) -> &DynMap {
-        let expr_id = self.expr_id(&call.clone().into())?;
+        let db = self.db;
-        self.infer.as_ref()?.method_resolution(expr_id).map(Function::from)
+        self.child_by_source_cache.entry(container).or_insert_with(|| match container {
+            ChildContainer::DefWithBodyId(it) => it.child_by_source(db),
+            ChildContainer::ModuleId(it) => it.child_by_source(db),
+            ChildContainer::TraitId(it) => it.child_by_source(db),
+            ChildContainer::ImplId(it) => it.child_by_source(db),
+            ChildContainer::EnumId(it) => it.child_by_source(db),
+            ChildContainer::VariantId(it) => it.child_by_source(db),
+            ChildContainer::GenericDefId(it) => it.child_by_source(db),
+        })
    }
+}
-    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<crate::StructField> {
+pub trait ToId: Sized {
-        let expr_id = self.expr_id(&field.clone().into())?;
+    type ID: Sized + Copy + 'static;
-        self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
+    fn to_id<DB: HirDatabase>(sb: &mut SourceBinder<'_, DB>, src: InFile<Self>)
-    }
+        -> Option<Self::ID>;
+}
-    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<crate::StructField> {
+pub trait ToDef: Sized + AstNode + 'static {
-        let expr_id = match field.expr() {
+    type Def;
-            Some(it) => self.expr_id(&it)?,
+    fn to_def<DB: HirDatabase>(
-            None => {
+        sb: &mut SourceBinder<'_, DB>,
-                let src = InFile { file_id: self.file_id, value: field };
+        src: InFile<Self>,
-                self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?
+    ) -> Option<Self::Def>;
-            }
+}
-        };
-        self.infer.as_ref()?.record_field_resolution(expr_id).map(|it| it.into())
-    }
-    pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {
+macro_rules! to_def_impls {
-        let expr_id = self.expr_id(&record_lit.clone().into())?;
+    ($(($def:path, $ast:path)),* ,) => {$(
-        self.infer.as_ref()?.variant_resolution_for_expr(expr_id).map(|it| it.into())
+        impl ToDef for $ast {
-    }
+            type Def = $def;
+            fn to_def<DB: HirDatabase>(sb: &mut SourceBinder<'_, DB>, src: InFile<Self>)
+                -> Option<Self::Def>
+            { sb.to_id(src).map(Into::into) }
+        }
+    )*}
+}
-    pub fn resolve_record_pattern(&self, record_pat: &ast::RecordPat) -> Option<crate::VariantDef> {
+to_def_impls![
-        let pat_id = self.pat_id(&record_pat.clone().into())?;
+    (crate::Module, ast::Module),
-        self.infer.as_ref()?.variant_resolution_for_pat(pat_id).map(|it| it.into())
+    (crate::Struct, ast::StructDef),
-    }
+    (crate::Enum, ast::EnumDef),
+    (crate::Union, ast::UnionDef),
+    (crate::Trait, ast::TraitDef),
+    (crate::ImplBlock, ast::ImplBlock),
+    (crate::TypeAlias, ast::TypeAliasDef),
+    (crate::Const, ast::ConstDef),
+    (crate::Static, ast::StaticDef),
+    (crate::Function, ast::FnDef),
+    (crate::StructField, ast::RecordFieldDef),
+    (crate::EnumVariant, ast::EnumVariant),
+    (crate::MacroDef, ast::MacroCall), // this one is dubious, not all calls are macros
+];
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum ChildContainer {
+    DefWithBodyId(DefWithBodyId),
+    ModuleId(ModuleId),
+    TraitId(TraitId),
+    ImplId(ImplId),
+    EnumId(EnumId),
+    VariantId(VariantId),
+    /// XXX: this might be the same def as, for example an `EnumId`. However,
+    /// here the children generic parameters, and not, eg enum variants.
+    GenericDefId(GenericDefId),
+}
+impl_froms! {
+    ChildContainer:
+    DefWithBodyId,
+    ModuleId,
+    TraitId,
+    ImplId,
+    EnumId,
+    VariantId,
+    GenericDefId
+}
-    pub fn resolve_macro_call(
+pub trait ToIdByKey: Sized + AstNode + 'static {
-        &self,
+    type ID: Sized + Copy + 'static;
-        db: &impl HirDatabase,
+    const KEY: Key<Self, Self::ID>;
-        macro_call: InFile<&ast::MacroCall>,
+}
-    ) -> Option<MacroDef> {
-        let hygiene = Hygiene::new(db, macro_call.file_id);
-        let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &hygiene))?;
-        self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into())
-    }
-    pub fn resolve_hir_path(
+impl<T: ToIdByKey> ToId for T {
-        &self,
+    type ID = <T as ToIdByKey>::ID;
-        db: &impl HirDatabase,
+    fn to_id<DB: HirDatabase>(
-        path: &crate::Path,
+        sb: &mut SourceBinder<'_, DB>,
-    ) -> Option<PathResolution> {
+        src: InFile<Self>,
-        let types =
+    ) -> Option<Self::ID> {
-            self.resolver.resolve_path_in_type_ns_fully(db, path.mod_path()).map(|ty| match ty {
+        let container = sb.find_container(src.as_ref().map(|it| it.syntax()))?;
-                TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
+        let db = sb.db;
-                TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
+        let dyn_map =
-                TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
+            &*sb.child_by_source_cache.entry(container).or_insert_with(|| match container {
-                    PathResolution::Def(Adt::from(it).into())
+                ChildContainer::DefWithBodyId(it) => it.child_by_source(db),
-                }
+                ChildContainer::ModuleId(it) => it.child_by_source(db),
-                TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                ChildContainer::TraitId(it) => it.child_by_source(db),
-                TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
+                ChildContainer::ImplId(it) => it.child_by_source(db),
-                TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
+                ChildContainer::EnumId(it) => it.child_by_source(db),
-                TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
+                ChildContainer::VariantId(it) => it.child_by_source(db),
-            });
+                ChildContainer::GenericDefId(it) => it.child_by_source(db),
-        let values =
-            self.resolver.resolve_path_in_value_ns_fully(db, path.mod_path()).and_then(|val| {
-                let res = match val {
-                    ValueNs::LocalBinding(pat_id) => {
-                        let var = Local { parent: self.body_owner?, pat_id };
-                        PathResolution::Local(var)
-                    }
-                    ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
-                    ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
-                    ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
-                    ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
-                    ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
-                };
-                Some(res)
            });
+        dyn_map[T::KEY].get(&src).copied()
-        let items = self
-            .resolver
-            .resolve_module_path_in_items(db, path.mod_path())
-            .take_types()
-            .map(|it| PathResolution::Def(it.into()));
-        types.or(values).or(items).or_else(|| {
-            self.resolver
-                .resolve_path_as_macro(db, path.mod_path())
-                .map(|def| PathResolution::Macro(def.into()))
-        })
    }
+}
-    pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option<PathResolution> {
+macro_rules! to_id_key_impls {
-        if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
+    ($(($id:ident, $ast:path, $key:path)),* ,) => {$(
-            let expr_id = self.expr_id(&path_expr.into())?;
+        impl ToIdByKey for $ast {
-            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
+            type ID = $id;
-                return Some(PathResolution::AssocItem(assoc.into()));
+            const KEY: Key<Self, Self::ID> = $key;
-            }
        }
-        if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
+    )*}
-            let pat_id = self.pat_id(&path_pat.into())?;
+}
-            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) {
-                return Some(PathResolution::AssocItem(assoc.into()));
-            }
-        }
-        // This must be a normal source file rather than macro file.
-        let hir_path = crate::Path::from_ast(path.clone())?;
-        self.resolve_hir_path(db, &hir_path)
-    }
-    fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
+to_id_key_impls![
-        let name = name_ref.as_name();
+    (StructId, ast::StructDef, keys::STRUCT),
-        let source_map = self.body_source_map.as_ref()?;
+    (UnionId, ast::UnionDef, keys::UNION),
-        let scopes = self.scopes.as_ref()?;
+    (EnumId, ast::EnumDef, keys::ENUM),
-        let scope = scope_for(scopes, source_map, InFile::new(self.file_id, name_ref.syntax()))?;
+    (TraitId, ast::TraitDef, keys::TRAIT),
-        let entry = scopes.resolve_name_in_scope(scope, &name)?;
+    (FunctionId, ast::FnDef, keys::FUNCTION),
-        Some(ScopeEntryWithSyntax {
+    (StaticId, ast::StaticDef, keys::STATIC),
-            name: entry.name().clone(),
+    (ConstId, ast::ConstDef, keys::CONST),
-            ptr: source_map.pat_syntax(entry.pat())?.value,
+    (TypeAliasId, ast::TypeAliasDef, keys::TYPE_ALIAS),
-        })
+    (ImplId, ast::ImplBlock, keys::IMPL),
+    (StructFieldId, ast::RecordFieldDef, keys::RECORD_FIELD),
+    (EnumVariantId, ast::EnumVariant, keys::ENUM_VARIANT),
+];
+// FIXME: use DynMap as well?
+impl ToId for ast::MacroCall {
+    type ID = MacroDefId;
+    fn to_id<DB: HirDatabase>(
+        sb: &mut SourceBinder<'_, DB>,
+        src: InFile<Self>,
+    ) -> Option<Self::ID> {
+        let kind = MacroDefKind::Declarative;
+        let krate = sb.to_module_def(src.file_id.original_file(sb.db))?.id.krate;
+        let ast_id =
+            Some(AstId::new(src.file_id, sb.db.ast_id_map(src.file_id).ast_id(&src.value)));
+        Some(MacroDefId { krate: Some(krate), ast_id, kind })
    }
+}
-    pub fn process_all_names(&self, db: &impl HirDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
+impl ToDef for ast::BindPat {
-        self.resolver.process_all_names(db, &mut |name, def| {
+    type Def = Local;
-            let def = match def {
-                resolver::ScopeDef::PerNs(it) => it.into(),
+    fn to_def<DB: HirDatabase>(sb: &mut SourceBinder<'_, DB>, src: InFile<Self>) -> Option<Local> {
-                resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
+        let file_id = src.file_id;
-                resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
+        let parent: DefWithBodyId = src.value.syntax().ancestors().find_map(|it| {
-                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
+            let res = match_ast! {
-                resolver::ScopeDef::Local(pat_id) => {
+                match it {
-                    let parent = self.resolver.body_owner().unwrap().into();
+                    ast::ConstDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
-                    ScopeDef::Local(Local { parent, pat_id })
+                    ast::StaticDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::FnDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    _ => return None,
                }
            };
-            f(name, def)
+            Some(res)
-        })
+        })?;
-    }
+        let (_body, source_map) = sb.db.body_with_source_map(parent);
+        let src = src.map(ast::Pat::from);
-    // FIXME: we only use this in `inline_local_variable` assist, ideally, we
+        let pat_id = source_map.node_pat(src.as_ref())?;
-    // should switch to general reference search infra there.
+        Some(Local { parent: parent.into(), pat_id })
-    pub fn find_all_refs(&self, pat: &ast::BindPat) -> Vec<ReferenceDescriptor> {
-        let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
-        let ptr = Either::Left(AstPtr::new(&ast::Pat::from(pat.clone())));
-        fn_def
-            .syntax()
-            .descendants()
-            .filter_map(ast::NameRef::cast)
-            .filter(|name_ref| match self.resolve_local_name(&name_ref) {
-                None => false,
-                Some(entry) => entry.ptr() == ptr,
-            })
-            .map(|name_ref| ReferenceDescriptor {
-                name: name_ref.text().to_string(),
-                range: name_ref.syntax().text_range(),
-            })
-            .collect()
-    }
-    pub fn iterate_method_candidates<T>(
-        &self,
-        db: &impl HirDatabase,
-        ty: &Type,
-        name: Option<&Name>,
-        mut callback: impl FnMut(&Ty, Function) -> Option<T>,
-    ) -> Option<T> {
-        // There should be no inference vars in types passed here
-        // FIXME check that?
-        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
-        method_resolution::iterate_method_candidates(
-            &canonical,
-            db,
-            &self.resolver,
-            name,
-            method_resolution::LookupMode::MethodCall,
-            |ty, it| match it {
-                AssocItemId::FunctionId(f) => callback(ty, f.into()),
-                _ => None,
-            },
-        )
-    }
-    pub fn iterate_path_candidates<T>(
-        &self,
-        db: &impl HirDatabase,
-        ty: &Type,
-        name: Option<&Name>,
-        mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
-    ) -> Option<T> {
-        // There should be no inference vars in types passed here
-        // FIXME check that?
-        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
-        method_resolution::iterate_method_candidates(
-            &canonical,
-            db,
-            &self.resolver,
-            name,
-            method_resolution::LookupMode::Path,
-            |ty, it| callback(ty, it.into()),
-        )
-    }
-    /// Checks that particular type `ty` implements `std::future::Future`.
-    /// This function is used in `.await` syntax completion.
-    pub fn impls_future(&self, db: &impl HirDatabase, ty: Type) -> bool {
-        let std_future_path = path![std::future::Future];
-        let std_future_trait = match self.resolver.resolve_known_trait(db, &std_future_path) {
-            Some(it) => it.into(),
-            _ => return false,
-        };
-        let krate = match self.resolver.krate() {
-            Some(krate) => krate,
-            _ => return false,
-        };
-        let canonical_ty = Canonical { value: ty.ty.value, num_vars: 0 };
-        implements_trait(&canonical_ty, db, &self.resolver, krate.into(), std_future_trait)
-    }
-    pub fn expand(
-        &self,
-        db: &impl HirDatabase,
-        macro_call: InFile<&ast::MacroCall>,
-    ) -> Option<Expansion> {
-        let def = self.resolve_macro_call(db, macro_call)?.id;
-        let ast_id = AstId::new(
-            macro_call.file_id,
-            db.ast_id_map(macro_call.file_id).ast_id(macro_call.value),
-        );
-        Some(Expansion { macro_call_id: def.as_call_id(db, MacroCallKind::FnLike(ast_id)) })
    }
 }
-fn scope_for(
+impl ToDef for ast::TypeParam {
-    scopes: &ExprScopes,
+    type Def = TypeParam;
-    source_map: &BodySourceMap,
-    node: InFile<&SyntaxNode>,
+    fn to_def<DB: HirDatabase>(
-) -> Option<ScopeId> {
+        sb: &mut SourceBinder<'_, DB>,
-    node.value
+        src: InFile<ast::TypeParam>,
-        .ancestors()
+    ) -> Option<TypeParam> {
-        .filter_map(ast::Expr::cast)
+        let mut sb = SourceBinder::new(sb.db);
-        .filter_map(|it| source_map.node_expr(InFile::new(node.file_id, &it)))
+        let file_id = src.file_id;
-        .find_map(|it| scopes.scope_for(it))
+        let parent: GenericDefId = src.value.syntax().ancestors().find_map(|it| {
+            let res = match_ast! {
+                match it {
+                    ast::FnDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::StructDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::EnumDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::TraitDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::TypeAliasDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::ImplBlock(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    _ => return None,
+                }
+            };
+            Some(res)
+        })?;
+        let &id = sb.child_by_source(parent.into())[keys::TYPE_PARAM].get(&src)?;
+        Some(TypeParam { id })
+    }
 }
-fn scope_for_offset(
+impl ToId for ast::Module {
-    scopes: &ExprScopes,
+    type ID = ModuleId;
-    source_map: &BodySourceMap,
-    offset: InFile<TextUnit>,
+    fn to_id<DB: HirDatabase>(
-) -> Option<ScopeId> {
+        sb: &mut SourceBinder<'_, DB>,
-    scopes
+        src: InFile<ast::Module>,
-        .scope_by_expr()
+    ) -> Option<ModuleId> {
-        .iter()
+        {
-        .filter_map(|(id, scope)| {
+            let _p = profile("ast::Module::to_def");
-            let source = source_map.expr_syntax(*id)?;
+            let parent_declaration = src
-            // FIXME: correctly handle macro expansion
+                .as_ref()
-            if source.file_id != offset.file_id {
+                .map(|it| it.syntax())
-                return None;
+                .cloned()
-            }
+                .ancestors_with_macros(sb.db)
-            let syntax_node_ptr =
+                .skip(1)
-                source.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
+                .find_map(|it| {
-            Some((syntax_node_ptr, scope))
+                    let m = ast::Module::cast(it.value.clone())?;
-        })
+                    Some(it.with_value(m))
-        // find containing scope
+                });
-        .min_by_key(|(ptr, _scope)| {
-            (
+            let parent_module = match parent_declaration {
-                !(ptr.range().start() <= offset.value && offset.value <= ptr.range().end()),
+                Some(parent_declaration) => sb.to_id(parent_declaration)?,
-                ptr.range().len(),
+                None => {
-            )
+                    let file_id = src.file_id.original_file(sb.db);
-        })
+                    sb.to_module_def(file_id)?.id
-        .map(|(ptr, scope)| {
+                }
-            adjust(scopes, source_map, ptr, offset.file_id, offset.value).unwrap_or(*scope)
+            };
-        })
-}
-// XXX: during completion, cursor might be outside of any particular
+            let child_name = src.value.name()?.as_name();
-// expression. Try to figure out the correct scope...
+            let def_map = sb.db.crate_def_map(parent_module.krate);
-fn adjust(
+            let child_id = *def_map[parent_module.local_id].children.get(&child_name)?;
-    scopes: &ExprScopes,
+            Some(ModuleId { krate: parent_module.krate, local_id: child_id })
-    source_map: &BodySourceMap,
+        }
-    ptr: SyntaxNodePtr,
+    }
-    file_id: HirFileId,
-    offset: TextUnit,
-) -> Option<ScopeId> {
-    let r = ptr.range();
-    let child_scopes = scopes
-        .scope_by_expr()
-        .iter()
-        .filter_map(|(id, scope)| {
-            let source = source_map.expr_syntax(*id)?;
-            // FIXME: correctly handle macro expansion
-            if source.file_id != file_id {
-                return None;
-            }
-            let syntax_node_ptr =
-                source.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
-            Some((syntax_node_ptr, scope))
-        })
-        .map(|(ptr, scope)| (ptr.range(), scope))
-        .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
-    child_scopes
-        .max_by(|(r1, _), (r2, _)| {
-            if r2.is_subrange(&r1) {
-                std::cmp::Ordering::Greater
-            } else if r1.is_subrange(&r2) {
-                std::cmp::Ordering::Less
-            } else {
-                r1.start().cmp(&r2.start())
-            }
-        })
-        .map(|(_ptr, scope)| *scope)
 }
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index f7dc8acb7..8cc2fb160 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -35,7 +35,7 @@ fn find_path_inner(
    let def_map = db.crate_def_map(from.krate);
    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
    if let Some((name, _)) = from_scope.name_of(item) {
-        return Some(ModPath::from_simple_segments(PathKind::Plain, vec![name.clone()]));
+        return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
    }
    // - if the item is the crate root, return `crate`
@@ -45,12 +45,12 @@ fn find_path_inner(
            local_id: def_map.root,
        }))
    {
-        return Some(ModPath::from_simple_segments(PathKind::Crate, Vec::new()));
+        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
    }
    // - if the item is the module we're in, use `self`
    if item == ItemInNs::Types(from.into()) {
-        return Some(ModPath::from_simple_segments(PathKind::Super(0), Vec::new()));
+        return Some(ModPath::from_segments(PathKind::Super(0), Vec::new()));
    }
    // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
@@ -61,14 +61,14 @@ fn find_path_inner(
                local_id: parent_id,
            }))
        {
-            return Some(ModPath::from_simple_segments(PathKind::Super(1), Vec::new()));
+            return Some(ModPath::from_segments(PathKind::Super(1), Vec::new()));
        }
    }
    // - if the item is the crate root of a dependency crate, return the name from the extern prelude
    for (name, def_id) in &def_map.extern_prelude {
        if item == ItemInNs::Types(*def_id) {
-            return Some(ModPath::from_simple_segments(PathKind::Plain, vec![name.clone()]));
+            return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
        }
    }
@@ -79,7 +79,7 @@ fn find_path_inner(
            &prelude_def_map.modules[prelude_module.local_id].scope;
        if let Some((name, vis)) = prelude_scope.name_of(item) {
            if vis.is_visible_from(db, from) {
-                return Some(ModPath::from_simple_segments(PathKind::Plain, vec![name.clone()]));
+                return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
            }
        }
    }
diff --git a/crates/ra_hir_def/src/keys.rs b/crates/ra_hir_def/src/keys.rs
index d844f7a62..5913f12b1 100644
--- a/crates/ra_hir_def/src/keys.rs
+++ b/crates/ra_hir_def/src/keys.rs
@@ -2,7 +2,7 @@
 use std::marker::PhantomData;
-use hir_expand::InFile;
+use hir_expand::{InFile, MacroDefId};
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
@@ -29,6 +29,8 @@ pub const TUPLE_FIELD: Key<ast::TupleFieldDef, StructFieldId> = Key::new();
 pub const RECORD_FIELD: Key<ast::RecordFieldDef, StructFieldId> = Key::new();
 pub const TYPE_PARAM: Key<ast::TypeParam, TypeParamId> = Key::new();
+pub const MACRO: Key<ast::MacroCall, MacroDefId> = Key::new();
 /// XXX: AST Nodes and SyntaxNodes have identity equality semantics: nodes are
 /// equal if they point to exactly the same object.
 ///
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index ebc12e891..feb3a300d 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -332,7 +332,7 @@ pub enum VariantId {
    StructId(StructId),
    UnionId(UnionId),
 }
-impl_froms!(VariantId: EnumVariantId, StructId);
+impl_froms!(VariantId: EnumVariantId, StructId, UnionId);
 trait Intern {
    type ID;
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 4d210eab1..27c12e46c 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -59,12 +59,9 @@ use std::sync::Arc;
 use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile};
 use ra_arena::Arena;
-use ra_db::{CrateId, Edition, FileId, FilePosition};
+use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
-use ra_syntax::{
+use ra_syntax::ast;
-    ast::{self, AstNode},
-    SyntaxNode,
-};
 use rustc_hash::FxHashMap;
 use crate::{
@@ -145,6 +142,13 @@ impl ModuleOrigin {
        }
    }
+    pub fn is_inline(&self) -> bool {
+        match self {
+            ModuleOrigin::Inline { .. } => true,
+            ModuleOrigin::CrateRoot { .. } | ModuleOrigin::File { .. } => false,
+        }
+    }
    /// Returns a node which defines this module.
    /// That is, a file or a `mod foo {}` with items.
    fn definition_source(&self, db: &impl DefDatabase) -> InFile<ModuleSource> {
@@ -248,35 +252,6 @@ pub enum ModuleSource {
    Module(ast::Module),
 }
-impl ModuleSource {
-    // FIXME: this methods do not belong here
-    pub fn from_position(db: &impl DefDatabase, position: FilePosition) -> ModuleSource {
-        let parse = db.parse(position.file_id);
-        match &ra_syntax::algo::find_node_at_offset::<ast::Module>(
-            parse.tree().syntax(),
-            position.offset,
-        ) {
-            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
-            _ => {
-                let source_file = parse.tree();
-                ModuleSource::SourceFile(source_file)
-            }
-        }
-    }
-    pub fn from_child_node(db: &impl DefDatabase, child: InFile<&SyntaxNode>) -> ModuleSource {
-        if let Some(m) =
-            child.value.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)
-        }
-    }
-}
 mod diagnostics {
    use hir_expand::diagnostics::DiagnosticSink;
    use ra_db::RelativePathBuf;
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 9f93a5424..ab290e2c9 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -39,10 +39,7 @@ impl ModPath {
        lower::lower_path(path, hygiene).map(|it| it.mod_path)
    }
-    pub fn from_simple_segments(
+    pub fn from_segments(kind: PathKind, segments: impl IntoIterator<Item = Name>) -> ModPath {
-        kind: PathKind,
-        segments: impl IntoIterator<Item = Name>,
-    ) -> ModPath {
        let segments = segments.into_iter().collect::<Vec<_>>();
        ModPath { kind, segments }
    }
@@ -240,7 +237,7 @@ impl From<Name> for Path {
    fn from(name: Name) -> Path {
        Path {
            type_anchor: None,
-            mod_path: ModPath::from_simple_segments(PathKind::Plain, iter::once(name)),
+            mod_path: ModPath::from_segments(PathKind::Plain, iter::once(name)),
            generic_args: vec![None],
        }
    }
@@ -248,7 +245,7 @@ impl From<Name> for Path {
 impl From<Name> for ModPath {
    fn from(name: Name) -> ModPath {
-        ModPath::from_simple_segments(PathKind::Plain, iter::once(name))
+        ModPath::from_segments(PathKind::Plain, iter::once(name))
    }