103 files changed, 2595 insertions, 1931 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8ab47106d..974d18584 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -8,6 +8,16 @@ on:
      - trying
 jobs:
+  rust-audit:
+    name: Audit Rust vulnerabilities
+    runs-on: ubuntu-latest
+    steps:
+        - name: Checkout repository
+          uses: actions/checkout@v1
+        - run: cargo install cargo-audit
+        - run: cargo audit
  rust:
    name: Rust
    runs-on: ${{ matrix.os }}
@@ -79,7 +89,7 @@ jobs:
        if: matrix.os == 'windows-latest'
        run: Remove-Item ./target/debug/xtask.exe
-  type-script:
+  typescript:
    name: TypeScript
    runs-on: ubuntu-latest
    env:
@@ -96,7 +106,12 @@ jobs:
      - run: npm ci
        working-directory: ./editors/code
+      - run: npm audit
+        working-directory: ./editors/code
      - run: npm run fmt
        working-directory: ./editors/code
      - run: npm run package --scripts-prepend-node-path
        working-directory: ./editors/code
diff --git a/Cargo.lock b/Cargo.lock
index 0b4d5ebe6..49fddef4b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -129,7 +129,7 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 [[package]]
 name = "chalk-derive"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git?rev=af48f302a1f571b3ca418f7c5aa639a144a34f75#af48f302a1f571b3ca418f7c5aa639a144a34f75"
+source = "git+https://github.com/rust-lang/chalk.git?rev=2939913fb7bb94ac2a6721087dc086be11410702#2939913fb7bb94ac2a6721087dc086be11410702"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -139,7 +139,7 @@ dependencies = [
 [[package]]
 name = "chalk-engine"
 version = "0.9.0"
-source = "git+https://github.com/rust-lang/chalk.git?rev=af48f302a1f571b3ca418f7c5aa639a144a34f75#af48f302a1f571b3ca418f7c5aa639a144a34f75"
+source = "git+https://github.com/rust-lang/chalk.git?rev=2939913fb7bb94ac2a6721087dc086be11410702#2939913fb7bb94ac2a6721087dc086be11410702"
 dependencies = [
 "chalk-macros",
 "rustc-hash",
@@ -148,7 +148,7 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git?rev=af48f302a1f571b3ca418f7c5aa639a144a34f75#af48f302a1f571b3ca418f7c5aa639a144a34f75"
+source = "git+https://github.com/rust-lang/chalk.git?rev=2939913fb7bb94ac2a6721087dc086be11410702#2939913fb7bb94ac2a6721087dc086be11410702"
 dependencies = [
 "chalk-derive",
 "chalk-engine",
@@ -159,7 +159,7 @@ dependencies = [
 [[package]]
 name = "chalk-macros"
 version = "0.1.1"
-source = "git+https://github.com/rust-lang/chalk.git?rev=af48f302a1f571b3ca418f7c5aa639a144a34f75#af48f302a1f571b3ca418f7c5aa639a144a34f75"
+source = "git+https://github.com/rust-lang/chalk.git?rev=2939913fb7bb94ac2a6721087dc086be11410702#2939913fb7bb94ac2a6721087dc086be11410702"
 dependencies = [
 "lazy_static",
 ]
@@ -167,7 +167,7 @@ dependencies = [
 [[package]]
 name = "chalk-rust-ir"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git?rev=af48f302a1f571b3ca418f7c5aa639a144a34f75#af48f302a1f571b3ca418f7c5aa639a144a34f75"
+source = "git+https://github.com/rust-lang/chalk.git?rev=2939913fb7bb94ac2a6721087dc086be11410702#2939913fb7bb94ac2a6721087dc086be11410702"
 dependencies = [
 "chalk-derive",
 "chalk-engine",
@@ -178,7 +178,7 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git?rev=af48f302a1f571b3ca418f7c5aa639a144a34f75#af48f302a1f571b3ca418f7c5aa639a144a34f75"
+source = "git+https://github.com/rust-lang/chalk.git?rev=2939913fb7bb94ac2a6721087dc086be11410702#2939913fb7bb94ac2a6721087dc086be11410702"
 dependencies = [
 "chalk-derive",
 "chalk-engine",
@@ -461,9 +461,9 @@ dependencies = [
 [[package]]
 name = "hermit-abi"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2c55f143919fbc0bc77e427fe2d74cf23786d7c1875666f2fde3ac3c659bb67"
+checksum = "1010591b26bbfe835e9faeabeb11866061cc7dcebffd56ad7d0942d0e61aefd8"
 dependencies = [
 "libc",
 ]
@@ -662,9 +662,9 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.70.2"
+version = "0.71.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6743fb3902ab3dfa6ce030daeac6ff492e20bb0fee840739d16f6bfb0efaf91c"
+checksum = "efa6b75633b0c3412ee36fc416e6d9c1e4ff576b536217f4ac3f34ac83d9e564"
 dependencies = [
 "base64",
 "bitflags",
@@ -821,9 +821,9 @@ dependencies = [
 [[package]]
 name = "paste"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "423a519e1c6e828f1e73b720f9d9ed2fa643dce8a7737fb43235ce0b41eeaa49"
+checksum = "63e1afe738d71b1ebab5f1207c055054015427dbfc7bbe9ee1266894156ec046"
 dependencies = [
 "paste-impl",
 "proc-macro-hack",
@@ -831,9 +831,9 @@ dependencies = [
 [[package]]
 name = "paste-impl"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4214c9e912ef61bf42b81ba9a47e8aad1b2ffaf739ab162bf96d1e011f54e6c5"
+checksum = "6d4dc4a7f6f743211c5aab239640a65091535d97d43d92a52bca435a640892bb"
 dependencies = [
 "proc-macro-hack",
 "proc-macro2",
@@ -882,9 +882,9 @@ dependencies = [
 [[package]]
 name = "proc-macro2"
-version = "1.0.8"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acb317c6ff86a4e579dfa00fc5e6cca91ecbb4e7eb2df0468805b674eb88548"
+checksum = "6c09721c6781493a2a492a96b5a5bf19b65917fe6728884e7c44dd0c60ca3435"
 dependencies = [
 "unicode-xid",
 ]
@@ -906,7 +906,6 @@ version = "0.1.0"
 name = "ra_assists"
 version = "0.1.0"
 dependencies = [
- "either",
 "format-buf",
 "join_to_string",
 "ra_db",
@@ -927,10 +926,8 @@ dependencies = [
 "cargo_metadata",
 "crossbeam-channel",
 "insta",
- "jod-thread",
 "log",
 "lsp-types",
- "parking_lot",
 "serde_json",
 ]
@@ -988,7 +985,6 @@ dependencies = [
 "drop_bomb",
 "either",
 "insta",
- "itertools",
 "log",
 "once_cell",
 "ra_arena",
@@ -1046,7 +1042,6 @@ version = "0.1.0"
 dependencies = [
 "either",
 "format-buf",
- "fst",
 "indexmap",
 "insta",
 "itertools",
@@ -1063,29 +1058,17 @@ dependencies = [
 "ra_syntax",
 "ra_text_edit",
 "rand",
- "rayon",
 "rustc-hash",
- "superslice",
 "test_utils",
- "unicase",
 ]
 [[package]]
 name = "ra_ide_db"
 version = "0.1.0"
 dependencies = [
- "either",
- "format-buf",
 "fst",
- "indexmap",
- "insta",
- "itertools",
- "join_to_string",
 "log",
- "once_cell",
- "ra_cfg",
 "ra_db",
- "ra_fmt",
 "ra_hir",
 "ra_prof",
 "ra_syntax",
@@ -1093,8 +1076,6 @@ dependencies = [
 "rayon",
 "rustc-hash",
 "superslice",
- "test_utils",
- "unicase",
 ]
 [[package]]
@@ -1122,7 +1103,6 @@ name = "ra_prof"
 version = "0.1.0"
 dependencies = [
 "backtrace",
- "itertools",
 "jemalloc-ctl",
 "jemallocator",
 "once_cell",
@@ -1165,7 +1145,6 @@ dependencies = [
 name = "ra_text_edit"
 version = "0.1.0"
 dependencies = [
- "test_utils",
 "text_unit",
 ]
@@ -1308,9 +1287,9 @@ dependencies = [
 [[package]]
 name = "rowan"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d03d4eff7a4e8dcc362e4c06bb2b1b33af4bcd64336c7f40a31a05850336b6c"
+checksum = "1ea7cadf87a9d8432e85cb4eb86bd2e765ace60c24ef86e79084dcae5d1c5a19"
 dependencies = [
 "rustc-hash",
 "smol_str",
@@ -1324,7 +1303,6 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "crossbeam-channel",
- "either",
 "env_logger",
 "globset",
 "itertools",
@@ -1534,9 +1512,9 @@ checksum = "ab16ced94dbd8a46c82fd81e3ed9a8727dac2977ea869d217bcc4ea1f122e81f"
 [[package]]
 name = "syn"
-version = "1.0.15"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a0294dc449adc58bb6592fff1a23d3e5e6e235afc6a0ffca2657d19e7bbffe5"
+checksum = "123bd9499cfb380418d509322d7a6d52e5315f064fe4b3ad18a53d6b92c07859"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1577,9 +1555,9 @@ dependencies = [
 [[package]]
 name = "text_unit"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08bbcb7a3adbda0eb23431206b653bdad3d8dea311e72d36bf2215e27a42579"
+checksum = "20431e104bfecc1a40872578dbc390e10290a0e9c35fffe3ce6f73c15a9dbfc2"
 [[package]]
 name = "thin-dst"
@@ -1606,15 +1584,6 @@ dependencies = [
 ]
 [[package]]
-name = "unicase"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
-dependencies = [
- "version_check",
-]
-[[package]]
 name = "unicode-bidi"
 version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1657,12 +1626,6 @@ dependencies = [
 ]
 [[package]]
-name = "version_check"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "078775d0255232fb988e6fccf26ddc9d1ac274299aaedcedce21c6f72cc533ce"
-[[package]]
 name = "walkdir"
 version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 12a933645..d314dc8e6 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -11,7 +11,6 @@ doctest = false
 format-buf = "1.0.0"
 join_to_string = "0.1.3"
 rustc-hash = "1.1.0"
-either = "1.5.3"
 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 5aab5fb8b..c25d2e323 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,6 +1,6 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-use hir::{InFile, SourceAnalyzer, SourceBinder};
+use hir::Semantics;
-use ra_db::{FileRange, SourceDatabase};
+use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
@@ -74,29 +74,23 @@ pub(crate) type AssistHandler = fn(AssistCtx) -> Option<Assist>;
 /// Note, however, that we don't actually use such two-phase logic at the
 /// moment, because the LSP API is pretty awkward in this place, and it's much
 /// easier to just compute the edit eagerly :-)
-#[derive(Debug)]
+#[derive(Clone)]
 pub(crate) struct AssistCtx<'a> {
+    pub(crate) sema: &'a Semantics<'a, RootDatabase>,
    pub(crate) db: &'a RootDatabase,
    pub(crate) frange: FileRange,
    source_file: SourceFile,
    should_compute_edit: bool,
 }
-impl Clone for AssistCtx<'_> {
-    fn clone(&self) -> Self {
-        AssistCtx {
-            db: self.db,
-            frange: self.frange,
-            source_file: self.source_file.clone(),
-            should_compute_edit: self.should_compute_edit,
-        }
-    }
-}
 impl<'a> AssistCtx<'a> {
-    pub fn new(db: &RootDatabase, frange: FileRange, should_compute_edit: bool) -> AssistCtx {
+    pub fn new(
-        let parse = db.parse(frange.file_id);
+        sema: &'a Semantics<'a, RootDatabase>,
-        AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit }
+        frange: FileRange,
+        should_compute_edit: bool,
+    ) -> AssistCtx<'a> {
+        let source_file = sema.parse(frange.file_id);
+        AssistCtx { sema, db: sema.db, frange, source_file, should_compute_edit }
    }
    pub(crate) fn add_assist(
@@ -138,18 +132,6 @@ impl<'a> AssistCtx<'a> {
    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, RootDatabase> {
-        SourceBinder::new(self.db)
-    }
-    pub(crate) fn source_analyzer(
-        &self,
-        node: &SyntaxNode,
-        offset: Option<TextUnit>,
-    ) -> SourceAnalyzer {
-        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 {
        find_covering_element(self.source_file.syntax(), range)
    }
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 56b7588ef..7846e9798 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -1,14 +1,12 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
 use rustc_hash::FxHashMap;
-use hir::{db::HirDatabase, InFile, PathResolution};
+use hir::{PathResolution, SemanticsScope};
+use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, AstNode};
 pub trait AstTransform<'a> {
-    fn get_substitution(
+    fn get_substitution(&self, node: &ra_syntax::SyntaxNode) -> Option<ra_syntax::SyntaxNode>;
-        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode>;
    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a>;
    fn or<T: AstTransform<'a> + 'a>(self, other: T) -> Box<dyn AstTransform<'a> + 'a>
@@ -22,10 +20,7 @@ pub trait AstTransform<'a> {
 struct NullTransformer;
 impl<'a> AstTransform<'a> for NullTransformer {
-    fn get_substitution(
+    fn get_substitution(&self, _node: &ra_syntax::SyntaxNode) -> Option<ra_syntax::SyntaxNode> {
-        &self,
-        _node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode> {
        None
    }
    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
@@ -33,18 +28,20 @@ impl<'a> AstTransform<'a> for NullTransformer {
    }
 }
-pub struct SubstituteTypeParams<'a, DB: HirDatabase> {
+pub struct SubstituteTypeParams<'a> {
-    db: &'a DB,
+    source_scope: &'a SemanticsScope<'a, RootDatabase>,
    substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
    previous: Box<dyn AstTransform<'a> + 'a>,
 }
-impl<'a, DB: HirDatabase> SubstituteTypeParams<'a, DB> {
+impl<'a> SubstituteTypeParams<'a> {
    pub fn for_trait_impl(
-        db: &'a DB,
+        source_scope: &'a SemanticsScope<'a, RootDatabase>,
+        db: &'a RootDatabase,
+        // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
        trait_: hir::Trait,
        impl_block: ast::ImplBlock,
-    ) -> SubstituteTypeParams<'a, DB> {
+    ) -> SubstituteTypeParams<'a> {
        let substs = get_syntactic_substs(impl_block).unwrap_or_default();
        let generic_def: hir::GenericDef = trait_.into();
        let substs_by_param: FxHashMap<_, _> = generic_def
@@ -55,7 +52,7 @@ impl<'a, DB: HirDatabase> SubstituteTypeParams<'a, DB> {
            .zip(substs.into_iter())
            .collect();
        return SubstituteTypeParams {
-            db,
+            source_scope,
            substs: substs_by_param,
            previous: Box::new(NullTransformer),
        };
@@ -79,15 +76,15 @@ impl<'a, DB: HirDatabase> SubstituteTypeParams<'a, DB> {
    }
    fn get_substitution_inner(
        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
+        node: &ra_syntax::SyntaxNode,
    ) -> Option<ra_syntax::SyntaxNode> {
-        let type_ref = ast::TypeRef::cast(node.value.clone())?;
+        let type_ref = ast::TypeRef::cast(node.clone())?;
        let path = match &type_ref {
            ast::TypeRef::PathType(path_type) => path_type.path()?,
            _ => return None,
        };
-        let analyzer = hir::SourceAnalyzer::new(self.db, node, None);
+        let path = hir::Path::from_ast(path)?;
-        let resolution = analyzer.resolve_path(self.db, &path)?;
+        let resolution = self.source_scope.resolve_hir_path(&path)?;
        match resolution {
            hir::PathResolution::TypeParam(tp) => Some(self.substs.get(&tp)?.syntax().clone()),
            _ => None,
@@ -95,11 +92,8 @@ impl<'a, DB: HirDatabase> SubstituteTypeParams<'a, DB> {
    }
 }
-impl<'a, DB: HirDatabase> AstTransform<'a> for SubstituteTypeParams<'a, DB> {
+impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
-    fn get_substitution(
+    fn get_substitution(&self, node: &ra_syntax::SyntaxNode) -> Option<ra_syntax::SyntaxNode> {
-        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode> {
        self.get_substitution_inner(node).or_else(|| self.previous.get_substitution(node))
    }
    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
@@ -107,30 +101,35 @@ impl<'a, DB: HirDatabase> AstTransform<'a> for SubstituteTypeParams<'a, DB> {
    }
 }
-pub struct QualifyPaths<'a, DB: HirDatabase> {
+pub struct QualifyPaths<'a> {
-    db: &'a DB,
+    target_scope: &'a SemanticsScope<'a, RootDatabase>,
-    from: Option<hir::Module>,
+    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    db: &'a RootDatabase,
    previous: Box<dyn AstTransform<'a> + 'a>,
 }
-impl<'a, DB: HirDatabase> QualifyPaths<'a, DB> {
+impl<'a> QualifyPaths<'a> {
-    pub fn new(db: &'a DB, from: Option<hir::Module>) -> Self {
+    pub fn new(
-        Self { db, from, previous: Box::new(NullTransformer) }
+        target_scope: &'a SemanticsScope<'a, RootDatabase>,
+        source_scope: &'a SemanticsScope<'a, RootDatabase>,
+        db: &'a RootDatabase,
+    ) -> Self {
+        Self { target_scope, source_scope, db, previous: Box::new(NullTransformer) }
    }
    fn get_substitution_inner(
        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
+        node: &ra_syntax::SyntaxNode,
    ) -> Option<ra_syntax::SyntaxNode> {
        // FIXME handle value ns?
-        let from = self.from?;
+        let from = self.target_scope.module()?;
-        let p = ast::Path::cast(node.value.clone())?;
+        let p = ast::Path::cast(node.clone())?;
        if p.segment().and_then(|s| s.param_list()).is_some() {
            // don't try to qualify `Fn(Foo) -> Bar` paths, they are in prelude anyway
            return None;
        }
-        let analyzer = hir::SourceAnalyzer::new(self.db, node, None);
+        let hir_path = hir::Path::from_ast(p.clone());
-        let resolution = analyzer.resolve_path(self.db, &p)?;
+        let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
        match resolution {
            PathResolution::Def(def) => {
                let found_path = from.find_use_path(self.db, def)?;
@@ -139,7 +138,7 @@ impl<'a, DB: HirDatabase> QualifyPaths<'a, DB> {
                let type_args = p
                    .segment()
                    .and_then(|s| s.type_arg_list())
-                    .map(|arg_list| apply(self, node.with_value(arg_list)));
+                    .map(|arg_list| apply(self, arg_list));
                if let Some(type_args) = type_args {
                    let last_segment = path.segment().unwrap();
                    path = path.with_segment(last_segment.with_type_args(type_args))
@@ -156,11 +155,11 @@ impl<'a, DB: HirDatabase> QualifyPaths<'a, DB> {
    }
 }
-pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: InFile<N>) -> N {
+pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
-    let syntax = node.value.syntax();
+    let syntax = node.syntax();
    let result = ra_syntax::algo::replace_descendants(syntax, &|element| match element {
        ra_syntax::SyntaxElement::Node(n) => {
-            let replacement = transformer.get_substitution(node.with_value(&n))?;
+            let replacement = transformer.get_substitution(&n)?;
            Some(replacement.into())
        }
        _ => None,
@@ -168,11 +167,8 @@ pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: InFile<N>
    N::cast(result).unwrap()
 }
-impl<'a, DB: HirDatabase> AstTransform<'a> for QualifyPaths<'a, DB> {
+impl<'a> AstTransform<'a> for QualifyPaths<'a> {
-    fn get_substitution(
+    fn get_substitution(&self, node: &ra_syntax::SyntaxNode) -> Option<ra_syntax::SyntaxNode> {
-        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode> {
        self.get_substitution_inner(node).or_else(|| self.previous.get_substitution(node))
    }
    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 2cb9d2f48..a63ef48b1 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -51,14 +51,13 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
        }
    }
    // Infer type
-    let db = ctx.db;
+    let ty = ctx.sema.type_of_expr(&expr)?;
-    let analyzer = ctx.source_analyzer(stmt.syntax(), None);
-    let ty = analyzer.type_of(db, &expr)?;
    // Assist not applicable if the type is unknown
    if ty.contains_unknown() {
        return None;
    }
+    let db = ctx.db;
    ctx.add_assist(
        AssistId("add_explicit_type"),
        format!("Insert explicit type '{}'", ty.display(db)),
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index ab21388c8..4005014bd 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -1,4 +1,4 @@
-use hir::{HasSource, InFile};
+use hir::HasSource;
 use ra_syntax::{
    ast::{self, edit, make, AstNode, NameOwner},
    SmolStr,
@@ -104,9 +104,7 @@ fn add_missing_impl_members_inner(
    let impl_node = ctx.find_node_at_offset::<ast::ImplBlock>()?;
    let impl_item_list = impl_node.item_list()?;
-    let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
+    let trait_ = resolve_target_trait(&ctx.sema, &impl_node)?;
-    let trait_ = resolve_target_trait(ctx.db, &analyzer, &impl_node)?;
    let def_name = |item: &ast::ImplItem| -> Option<SmolStr> {
        match item {
@@ -117,7 +115,7 @@ fn add_missing_impl_members_inner(
        .map(|it| it.text().clone())
    };
-    let missing_items = get_missing_impl_items(ctx.db, &analyzer, &impl_node)
+    let missing_items = get_missing_impl_items(&ctx.sema, &impl_node)
        .iter()
        .map(|i| match i {
            hir::AssocItem::Function(i) => ast::ImplItem::FnDef(i.source(ctx.db).value),
@@ -138,23 +136,17 @@ fn add_missing_impl_members_inner(
        return None;
    }
-    let db = ctx.db;
+    let sema = ctx.sema;
-    let file_id = ctx.frange.file_id;
-    let trait_file_id = trait_.source(db).file_id;
    ctx.add_assist(AssistId(assist_id), label, |edit| {
        let n_existing_items = impl_item_list.impl_items().count();
-        let module = hir::SourceAnalyzer::new(
+        let source_scope = sema.scope_for_def(trait_);
-            db,
+        let target_scope = sema.scope(impl_item_list.syntax());
-            hir::InFile::new(file_id.into(), impl_node.syntax()),
+        let ast_transform = QualifyPaths::new(&target_scope, &source_scope, sema.db)
-            None,
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, sema.db, trait_, impl_node));
-        )
-        .module();
-        let ast_transform = QualifyPaths::new(db, module)
-            .or(SubstituteTypeParams::for_trait_impl(db, trait_, impl_node));
        let items = missing_items
            .into_iter()
-            .map(|it| ast_transform::apply(&*ast_transform, InFile::new(trait_file_id, it)))
+            .map(|it| ast_transform::apply(&*ast_transform, it))
            .map(|it| match it {
                ast::ImplItem::FnDef(def) => ast::ImplItem::FnDef(add_body(def)),
                _ => it,
@@ -181,9 +173,10 @@ fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
 #[cfg(test)]
 mod tests {
-    use super::*;
    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use super::*;
    #[test]
    fn test_add_missing_impl_members() {
        check_assist(
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index dd070e8ec..166e907fb 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::{Adt, InFile};
+use hir::Adt;
 use join_to_string::join;
 use ra_syntax::{
    ast::{
@@ -133,16 +133,11 @@ fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<a
    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_def = {
+    let struct_def = ctx.sema.to_def(strukt)?;
-        let src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        sb.to_def(src)?
-    };
    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 = ctx.sema.to_def(&impl_blk)?;
-        let blk = sb.to_def(src)?;
        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
        // (we currently use the wrong type parameter)
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index c4aea2a06..edf0cf6d0 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -3,8 +3,8 @@ use crate::{
    insert_use_statement, AssistId,
 };
 use hir::{
-    db::HirDatabase, AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution,
+    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
-    SourceAnalyzer, Trait, Type,
+    Type,
 };
 use ra_ide_db::{imports_locator::ImportsLocator, RootDatabase};
 use ra_prof::profile;
@@ -78,14 +78,9 @@ impl AutoImportAssets {
    fn for_method_call(method_call: ast::MethodCallExpr, ctx: &AssistCtx) -> Option<Self> {
        let syntax_under_caret = method_call.syntax().to_owned();
-        let source_analyzer = ctx.source_analyzer(&syntax_under_caret, None);
+        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
-        let module_with_name_to_import = source_analyzer.module()?;
        Some(Self {
-            import_candidate: ImportCandidate::for_method_call(
+            import_candidate: ImportCandidate::for_method_call(&ctx.sema, &method_call)?,
-                &method_call,
-                &source_analyzer,
-                ctx.db,
-            )?,
            module_with_name_to_import,
            syntax_under_caret,
        })
@@ -97,14 +92,9 @@ impl AutoImportAssets {
            return None;
        }
-        let source_analyzer = ctx.source_analyzer(&syntax_under_caret, None);
+        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
-        let module_with_name_to_import = source_analyzer.module()?;
        Some(Self {
-            import_candidate: ImportCandidate::for_regular_path(
+            import_candidate: ImportCandidate::for_regular_path(&ctx.sema, &path_under_caret)?,
-                &path_under_caret,
-                &source_analyzer,
-                ctx.db,
-            )?,
            module_with_name_to_import,
            syntax_under_caret,
        })
@@ -229,25 +219,23 @@ enum ImportCandidate {
 impl ImportCandidate {
    fn for_method_call(
+        sema: &Semantics<RootDatabase>,
        method_call: &ast::MethodCallExpr,
-        source_analyzer: &SourceAnalyzer,
-        db: &impl HirDatabase,
    ) -> Option<Self> {
-        if source_analyzer.resolve_method_call(method_call).is_some() {
+        if sema.resolve_method_call(method_call).is_some() {
            return None;
        }
        Some(Self::TraitMethod(
-            source_analyzer.type_of(db, &method_call.expr()?)?,
+            sema.type_of_expr(&method_call.expr()?)?,
            method_call.name_ref()?.syntax().to_string(),
        ))
    }
    fn for_regular_path(
+        sema: &Semantics<RootDatabase>,
        path_under_caret: &ast::Path,
-        source_analyzer: &SourceAnalyzer,
-        db: &impl HirDatabase,
    ) -> Option<Self> {
-        if source_analyzer.resolve_path(db, path_under_caret).is_some() {
+        if sema.resolve_path(path_under_caret).is_some() {
            return None;
        }
@@ -256,17 +244,15 @@ impl ImportCandidate {
            let qualifier_start = qualifier.syntax().descendants().find_map(ast::NameRef::cast)?;
            let qualifier_start_path =
                qualifier_start.syntax().ancestors().find_map(ast::Path::cast)?;
-            if let Some(qualifier_start_resolution) =
+            if let Some(qualifier_start_resolution) = sema.resolve_path(&qualifier_start_path) {
-                source_analyzer.resolve_path(db, &qualifier_start_path)
-            {
                let qualifier_resolution = if qualifier_start_path == qualifier {
                    qualifier_start_resolution
                } else {
-                    source_analyzer.resolve_path(db, &qualifier)?
+                    sema.resolve_path(&qualifier)?
                };
                if let PathResolution::Def(ModuleDef::Adt(assoc_item_path)) = qualifier_resolution {
                    Some(ImportCandidate::TraitAssocItem(
-                        assoc_item_path.ty(db),
+                        assoc_item_path.ty(sema.db),
                        segment.syntax().to_string(),
                    ))
                } else {
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index ae2437ed3..e5d8c639d 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -2,10 +2,11 @@
 use std::iter;
-use hir::{db::HirDatabase, Adt, HasSource};
+use hir::{db::HirDatabase, Adt, HasSource, Semantics};
 use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
 use crate::{Assist, AssistCtx, AssistId};
+use ra_ide_db::RootDatabase;
 // Assist: fill_match_arms
 //
@@ -46,10 +47,9 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
    };
    let expr = match_expr.expr()?;
-    let (enum_def, module) = {
+    let enum_def = resolve_enum_def(&ctx.sema, &expr)?;
-        let analyzer = ctx.source_analyzer(expr.syntax(), None);
+    let module = ctx.sema.scope(expr.syntax()).module()?;
-        (resolve_enum_def(ctx.db, &analyzer, &expr)?, analyzer.module()?)
-    };
    let variants = enum_def.variants(ctx.db);
    if variants.is_empty() {
        return None;
@@ -81,18 +81,11 @@ fn is_trivial(arm: &ast::MatchArm) -> bool {
    }
 }
-fn resolve_enum_def(
+fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
-    db: &impl HirDatabase,
+    sema.type_of_expr(&expr)?.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
-    analyzer: &hir::SourceAnalyzer,
-    expr: &ast::Expr,
-) -> Option<hir::Enum> {
-    let expr_ty = analyzer.type_of(db, &expr)?;
-    let result = expr_ty.autoderef(db).find_map(|ty| match ty.as_adt() {
        Some(Adt::Enum(e)) => Some(e),
        _ => None,
-    });
+    })
-    result
 }
 fn build_pat(
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index 91b588243..53a72309b 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -44,8 +44,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
    } else {
        let_stmt.syntax().text_range()
    };
-    let analyzer = ctx.source_analyzer(bind_pat.syntax(), None);
+    let refs = ctx.sema.find_all_refs(&bind_pat);
-    let refs = analyzer.find_all_refs(&bind_pat);
    if refs.is_empty() {
        return None;
    };
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index 7312ce687..b453c51fb 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -136,15 +136,13 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
 mod tests {
    use test_utils::covers;
-    use crate::helpers::{
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
-        check_assist_range, check_assist_range_not_applicable, check_assist_range_target,
-    };
    use super::*;
    #[test]
    fn test_introduce_var_simple() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() {
@@ -161,16 +159,13 @@ fn foo() {
    #[test]
    fn introduce_var_in_comment_is_not_applicable() {
        covers!(introduce_var_in_comment_is_not_applicable);
-        check_assist_range_not_applicable(
+        check_assist_not_applicable(introduce_variable, "fn main() { 1 + /* <|>comment<|> */ 1; }");
-            introduce_variable,
-            "fn main() { 1 + /* <|>comment<|> */ 1; }",
-        );
    }
    #[test]
    fn test_introduce_var_expr_stmt() {
        covers!(test_introduce_var_expr_stmt);
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() {
@@ -181,7 +176,7 @@ fn foo() {
    let <|>var_name = 1 + 1;
 }",
        );
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() {
@@ -198,7 +193,7 @@ fn foo() {
    #[test]
    fn test_introduce_var_part_of_expr_stmt() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() {
@@ -215,7 +210,7 @@ fn foo() {
    #[test]
    fn test_introduce_var_last_expr() {
        covers!(test_introduce_var_last_expr);
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() {
@@ -227,7 +222,7 @@ fn foo() {
    bar(var_name)
 }",
        );
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() {
@@ -243,7 +238,7 @@ fn foo() {
    #[test]
    fn test_introduce_var_in_match_arm_no_block() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -268,7 +263,7 @@ fn main() {
    #[test]
    fn test_introduce_var_in_match_arm_with_block() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -300,7 +295,7 @@ fn main() {
    #[test]
    fn test_introduce_var_in_closure_no_block() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -317,7 +312,7 @@ fn main() {
    #[test]
    fn test_introduce_var_in_closure_with_block() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -334,7 +329,7 @@ fn main() {
    #[test]
    fn test_introduce_var_path_simple() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -352,7 +347,7 @@ fn main() {
    #[test]
    fn test_introduce_var_path_method() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -370,7 +365,7 @@ fn main() {
    #[test]
    fn test_introduce_var_return() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() -> u32 {
@@ -388,7 +383,7 @@ fn foo() -> u32 {
    #[test]
    fn test_introduce_var_does_not_add_extra_whitespace() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() -> u32 {
@@ -407,7 +402,7 @@ fn foo() -> u32 {
 ",
        );
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() -> u32 {
@@ -424,7 +419,7 @@ fn foo() -> u32 {
 ",
        );
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn foo() -> u32 {
@@ -452,7 +447,7 @@ fn foo() -> u32 {
    #[test]
    fn test_introduce_var_break() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -474,7 +469,7 @@ fn main() {
    #[test]
    fn test_introduce_var_for_cast() {
-        check_assist_range(
+        check_assist(
            introduce_variable,
            "
 fn main() {
@@ -492,27 +487,20 @@ fn main() {
    #[test]
    fn test_introduce_var_for_return_not_applicable() {
-        check_assist_range_not_applicable(introduce_variable, "fn foo() { <|>return<|>; } ");
+        check_assist_not_applicable(introduce_variable, "fn foo() { <|>return<|>; } ");
    }
    #[test]
    fn test_introduce_var_for_break_not_applicable() {
-        check_assist_range_not_applicable(
+        check_assist_not_applicable(introduce_variable, "fn main() { loop { <|>break<|>; }; }");
-            introduce_variable,
-            "fn main() { loop { <|>break<|>; }; }",
-        );
    }
    // FIXME: This is not quite correct, but good enough(tm) for the sorting heuristic
    #[test]
    fn introduce_var_target() {
-        check_assist_range_target(
+        check_assist_target(introduce_variable, "fn foo() -> u32 { <|>return 2 + 2<|>; }", "2 + 2");
-            introduce_variable,
-            "fn foo() -> u32 { <|>return 2 + 2<|>; }",
-            "2 + 2",
-        );
-        check_assist_range_target(
+        check_assist_target(
            introduce_variable,
            "
 fn main() {
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index d7998b0d1..c28a9b92b 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -19,6 +19,7 @@ use ra_text_edit::TextEdit;
 pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
 pub use crate::handlers::replace_qualified_name_with_use::insert_use_statement;
+use hir::Semantics;
 /// Unique identifier of the assist, should not be shown to the user
 /// directly.
@@ -63,7 +64,8 @@ pub struct ResolvedAssist {
 /// Assists are returned in the "unresolved" state, that is only labels are
 /// returned, without actual edits.
 pub fn unresolved_assists(db: &RootDatabase, range: FileRange) -> Vec<AssistLabel> {
-    let ctx = AssistCtx::new(db, range, false);
+    let sema = Semantics::new(db);
+    let ctx = AssistCtx::new(&sema, range, false);
    handlers::all()
        .iter()
        .filter_map(|f| f(ctx.clone()))
@@ -77,7 +79,8 @@ pub fn unresolved_assists(db: &RootDatabase, range: FileRange) -> Vec<AssistLabe
 /// Assists are returned in the "resolved" state, that is with edit fully
 /// computed.
 pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssist> {
-    let ctx = AssistCtx::new(db, range, true);
+    let sema = Semantics::new(db);
+    let ctx = AssistCtx::new(&sema, range, true);
    let mut a = handlers::all()
        .iter()
        .filter_map(|f| f(ctx.clone()))
@@ -162,9 +165,10 @@ mod helpers {
    use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
    use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
    use ra_syntax::TextRange;
-    use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
+    use test_utils::{add_cursor, assert_eq_text, extract_range_or_offset, RangeOrOffset};
    use crate::{AssistCtx, AssistHandler};
+    use hir::Semantics;
    pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
        let (mut db, file_id) = RootDatabase::with_single_file(text);
@@ -176,81 +180,66 @@ mod helpers {
    }
    pub(crate) fn check_assist(assist: AssistHandler, before: &str, after: &str) {
-        let (before_cursor_pos, before) = extract_offset(before);
+        check(assist, before, ExpectedResult::After(after));
-        let (db, file_id) = with_single_file(&before);
-        let frange =
-            FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
-        let assist =
-            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = assist.0[0].action.clone().unwrap();
-        let actual = action.edit.apply(&before);
-        let actual_cursor_pos = match action.cursor_position {
-            None => action
-                .edit
-                .apply_to_offset(before_cursor_pos)
-                .expect("cursor position is affected by the edit"),
-            Some(off) => off,
-        };
-        let actual = add_cursor(&actual, actual_cursor_pos);
-        assert_eq_text!(after, &actual);
-    }
-    pub(crate) fn check_assist_range(assist: AssistHandler, before: &str, after: &str) {
-        let (range, before) = extract_range(before);
-        let (db, file_id) = with_single_file(&before);
-        let frange = FileRange { file_id, range };
-        let assist =
-            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = assist.0[0].action.clone().unwrap();
-        let mut actual = action.edit.apply(&before);
-        if let Some(pos) = action.cursor_position {
-            actual = add_cursor(&actual, pos);
-        }
-        assert_eq_text!(after, &actual);
    }
+    // FIXME: instead of having a separate function here, maybe use
+    // `extract_ranges` and mark the target as `<target> </target>` in the
+    // fixuture?
    pub(crate) fn check_assist_target(assist: AssistHandler, before: &str, target: &str) {
-        let (before_cursor_pos, before) = extract_offset(before);
+        check(assist, before, ExpectedResult::Target(target));
-        let (db, file_id) = with_single_file(&before);
-        let frange =
-            FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
-        let assist =
-            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = assist.0[0].action.clone().unwrap();
-        let range = action.target.expect("expected target on action");
-        assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
    }
-    pub(crate) fn check_assist_range_target(assist: AssistHandler, before: &str, target: &str) {
+    pub(crate) fn check_assist_not_applicable(assist: AssistHandler, before: &str) {
-        let (range, before) = extract_range(before);
+        check(assist, before, ExpectedResult::NotApplicable);
-        let (db, file_id) = with_single_file(&before);
-        let frange = FileRange { file_id, range };
-        let assist =
-            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = assist.0[0].action.clone().unwrap();
-        let range = action.target.expect("expected target on action");
-        assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
    }
-    pub(crate) fn check_assist_not_applicable(assist: AssistHandler, before: &str) {
+    enum ExpectedResult<'a> {
-        let (before_cursor_pos, before) = extract_offset(before);
+        NotApplicable,
-        let (db, file_id) = with_single_file(&before);
+        After(&'a str),
-        let frange =
+        Target(&'a str),
-            FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
-        let assist = assist(AssistCtx::new(&db, frange, true));
-        assert!(assist.is_none());
    }
-    pub(crate) fn check_assist_range_not_applicable(assist: AssistHandler, before: &str) {
+    fn check(assist: AssistHandler, before: &str, expected: ExpectedResult) {
-        let (range, before) = extract_range(before);
+        let (range_or_offset, before) = extract_range_or_offset(before);
+        let range: TextRange = range_or_offset.into();
        let (db, file_id) = with_single_file(&before);
        let frange = FileRange { file_id, range };
-        let assist = assist(AssistCtx::new(&db, frange, true));
+        let sema = Semantics::new(&db);
-        assert!(assist.is_none());
+        let assist_ctx = AssistCtx::new(&sema, frange, true);
+        match (assist(assist_ctx), expected) {
+            (Some(assist), ExpectedResult::After(after)) => {
+                let action = assist.0[0].action.clone().unwrap();
+                let mut actual = action.edit.apply(&before);
+                match action.cursor_position {
+                    None => {
+                        if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
+                            let off = action
+                                .edit
+                                .apply_to_offset(before_cursor_pos)
+                                .expect("cursor position is affected by the edit");
+                            actual = add_cursor(&actual, off)
+                        }
+                    }
+                    Some(off) => actual = add_cursor(&actual, off),
+                };
+                assert_eq_text!(after, &actual);
+            }
+            (Some(assist), ExpectedResult::Target(target)) => {
+                let action = assist.0[0].action.clone().unwrap();
+                let range = action.target.expect("expected target on action");
+                assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
+            }
+            (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
+            (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
+                panic!("code action is not applicable")
+            }
+            (None, ExpectedResult::NotApplicable) => (),
+        };
    }
 }
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 6ff44c95c..92d3ed471 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -1,16 +1,15 @@
 //! Assorted functions shared by several assists.
+use hir::Semantics;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
    ast::{self, make, NameOwner},
    AstNode, T,
 };
-use hir::db::HirDatabase;
 use rustc_hash::FxHashSet;
 pub fn get_missing_impl_items(
-    db: &impl HirDatabase,
+    sema: &Semantics<RootDatabase>,
-    analyzer: &hir::SourceAnalyzer,
    impl_block: &ast::ImplBlock,
 ) -> Vec<hir::AssocItem> {
    // Names must be unique between constants and functions. However, type aliases
@@ -42,15 +41,17 @@ pub fn get_missing_impl_items(
        }
    }
-    resolve_target_trait(db, analyzer, impl_block).map_or(vec![], |target_trait| {
+    resolve_target_trait(sema, impl_block).map_or(vec![], |target_trait| {
        target_trait
-            .items(db)
+            .items(sema.db)
            .iter()
            .filter(|i| match i {
-                hir::AssocItem::Function(f) => !impl_fns_consts.contains(&f.name(db).to_string()),
+                hir::AssocItem::Function(f) => {
-                hir::AssocItem::TypeAlias(t) => !impl_type.contains(&t.name(db).to_string()),
+                    !impl_fns_consts.contains(&f.name(sema.db).to_string())
+                }
+                hir::AssocItem::TypeAlias(t) => !impl_type.contains(&t.name(sema.db).to_string()),
                hir::AssocItem::Const(c) => c
-                    .name(db)
+                    .name(sema.db)
                    .map(|n| !impl_fns_consts.contains(&n.to_string()))
                    .unwrap_or_default(),
            })
@@ -60,8 +61,7 @@ pub fn get_missing_impl_items(
 }
 pub(crate) fn resolve_target_trait(
-    db: &impl HirDatabase,
+    sema: &Semantics<RootDatabase>,
-    analyzer: &hir::SourceAnalyzer,
    impl_block: &ast::ImplBlock,
 ) -> Option<hir::Trait> {
    let ast_path = impl_block
@@ -70,7 +70,7 @@ pub(crate) fn resolve_target_trait(
        .and_then(ast::PathType::cast)?
        .path()?;
-    match analyzer.resolve_path(db, &ast_path) {
+    match sema.resolve_path(&ast_path) {
        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => Some(def),
        _ => None,
    }
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
index b09650d98..1fdbffea1 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -6,13 +6,10 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 crossbeam-channel = "0.4.0"
-lsp-types = { version = "0.70.1", features = ["proposed"] }
+lsp-types = { version = "0.71.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.9.1"
-jod-thread = "0.1.0"
-parking_lot = "0.10.0"
 serde_json = "1.0.48"
 [dev-dependencies]
 insta = "0.13.1"
-serde_json = "1.0.48"
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs
index 4bca27b5c..db27f9b83 100644
--- a/crates/ra_fmt/src/lib.rs
+++ b/crates/ra_fmt/src/lib.rs
@@ -43,15 +43,35 @@ pub fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
 pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
    let block = block.block()?;
-    let expr = block.expr()?;
+    let has_anything_else = |thing: &SyntaxNode| -> bool {
-    let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
+        let mut non_trivial_children =
-        WHITESPACE | T!['{'] | T!['}'] => false,
+            block.syntax().children_with_tokens().filter(|it| match it.kind() {
-        _ => it != expr.syntax(),
+                WHITESPACE | T!['{'] | T!['}'] => false,
-    });
+                _ => it.as_node() != Some(thing),
-    if non_trivial_children.count() > 0 {
+            });
-        return None;
+        non_trivial_children.next().is_some()
+    };
+    if let Some(expr) = block.expr() {
+        if has_anything_else(expr.syntax()) {
+            return None;
+        }
+        return Some(expr);
+    } else {
+        // Unwrap `{ continue; }`
+        let (stmt,) = block.statements().next_tuple()?;
+        if has_anything_else(stmt.syntax()) {
+            return None;
+        }
+        if let ast::Stmt::ExprStmt(expr_stmt) = stmt {
+            let expr = expr_stmt.expr()?;
+            match expr.syntax().kind() {
+                CONTINUE_EXPR | BREAK_EXPR | RETURN_EXPR => return Some(expr),
+                _ => (),
+            }
+        }
    }
-    Some(expr)
+    None
 }
 pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index c16c17072..3aa7c4870 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -40,6 +40,7 @@ from_id![
    (hir_def::ConstId, crate::Const),
    (hir_def::FunctionId, crate::Function),
    (hir_def::ImplId, crate::ImplBlock),
+    (hir_def::TypeParamId, crate::TypeParam),
    (hir_expand::MacroDefId, crate::MacroDef)
 ];
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 7a9745ebe..4a85e7e36 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -26,6 +26,7 @@ macro_rules! impl_froms {
    }
 }
+mod semantics;
 pub mod db;
 pub mod source_analyzer;
 pub mod source_binder;
@@ -45,8 +46,8 @@ pub use crate::{
        StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
    },
    has_source::HasSource,
-    source_analyzer::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
+    semantics::{original_range, Semantics, SemanticsScope},
-    source_binder::SourceBinder,
+    source_analyzer::PathResolution,
 };
 pub use hir_def::{
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
new file mode 100644
index 000000000..c3d8ee1ae
--- /dev/null
+++ b/crates/ra_hir/src/semantics.rs
@@ -0,0 +1,412 @@
+//! See `Semantics`.
+use std::{cell::RefCell, fmt, iter::successors};
+use hir_def::{
+    resolver::{self, HasResolver, Resolver},
+    DefWithBodyId, TraitId,
+};
+use ra_db::{FileId, FileRange};
+use ra_syntax::{
+    algo::{find_covering_element, skip_trivia_token},
+    ast, match_ast, AstNode, Direction, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxToken,
+    TextRange, TextUnit,
+};
+use rustc_hash::{FxHashMap, FxHashSet};
+use crate::{
+    db::HirDatabase,
+    source_analyzer::{resolve_hir_path, ReferenceDescriptor, SourceAnalyzer},
+    source_binder::{ChildContainer, SourceBinder},
+    Function, HirFileId, InFile, Local, MacroDef, Module, Name, Origin, Path, PathResolution,
+    ScopeDef, StructField, Trait, Type, TypeParam, VariantDef,
+};
+use ra_prof::profile;
+/// Primary API to get semantic information, like types, from syntax trees.
+pub struct Semantics<'db, DB> {
+    pub db: &'db DB,
+    pub(crate) sb: RefCell<SourceBinder>,
+    cache: RefCell<FxHashMap<SyntaxNode, HirFileId>>,
+}
+impl<DB> fmt::Debug for Semantics<'_, DB> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Semantics {{ ... }}")
+    }
+}
+impl<'db, DB: HirDatabase> Semantics<'db, DB> {
+    pub fn new(db: &DB) -> Semantics<DB> {
+        let sb = RefCell::new(SourceBinder::new());
+        Semantics { db, sb, cache: RefCell::default() }
+    }
+    pub fn parse(&self, file_id: FileId) -> ast::SourceFile {
+        let tree = self.db.parse(file_id).tree();
+        self.cache(tree.syntax().clone(), file_id.into());
+        tree
+    }
+    pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
+        let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
+        let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
+        let file_id = sa.expand(self.db, macro_call)?;
+        let node = self.db.parse_or_expand(file_id)?;
+        self.cache(node.clone(), file_id);
+        Some(node)
+    }
+    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
+        let parent = token.parent();
+        let parent = self.find_file(parent);
+        let sa = self.analyze2(parent.as_ref(), None);
+        let token = successors(Some(parent.with_value(token)), |token| {
+            let macro_call = token.value.ancestors().find_map(ast::MacroCall::cast)?;
+            let tt = macro_call.token_tree()?;
+            if !token.value.text_range().is_subrange(&tt.syntax().text_range()) {
+                return None;
+            }
+            let file_id = sa.expand(self.db, token.with_value(&macro_call))?;
+            let token = file_id.expansion_info(self.db)?.map_token_down(token.as_ref())?;
+            self.cache(find_root(&token.value.parent()), token.file_id);
+            Some(token)
+        })
+        .last()
+        .unwrap();
+        token.value
+    }
+    pub fn original_range(&self, node: &SyntaxNode) -> FileRange {
+        let node = self.find_file(node.clone());
+        original_range(self.db, node.as_ref())
+    }
+    pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
+        let node = self.find_file(node);
+        node.ancestors_with_macros(self.db).map(|it| it.value)
+    }
+    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
+        self.analyze(expr.syntax()).type_of(self.db, &expr)
+    }
+    pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
+        self.analyze(pat.syntax()).type_of_pat(self.db, &pat)
+    }
+    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+        self.analyze(call.syntax()).resolve_method_call(call)
+    }
+    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<StructField> {
+        self.analyze(field.syntax()).resolve_field(field)
+    }
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<StructField> {
+        self.analyze(field.syntax()).resolve_record_field(field)
+    }
+    pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<VariantDef> {
+        self.analyze(record_lit.syntax()).resolve_record_literal(record_lit)
+    }
+    pub fn resolve_record_pattern(&self, record_pat: &ast::RecordPat) -> Option<VariantDef> {
+        self.analyze(record_pat.syntax()).resolve_record_pattern(record_pat)
+    }
+    pub fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
+        let sa = self.analyze(macro_call.syntax());
+        let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
+        sa.resolve_macro_call(self.db, macro_call)
+    }
+    pub fn resolve_path(&self, path: &ast::Path) -> Option<PathResolution> {
+        self.analyze(path.syntax()).resolve_path(self.db, path)
+    }
+    // FIXME: use this instead?
+    // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
+    pub fn to_def<T: ToDef + Clone>(&self, src: &T) -> Option<T::Def> {
+        T::to_def(self, src)
+    }
+    pub fn to_module_def(&self, file: FileId) -> Option<Module> {
+        let mut sb = self.sb.borrow_mut();
+        sb.to_module_def(self.db, file)
+    }
+    pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db, DB> {
+        let node = self.find_file(node.clone());
+        let resolver = self.analyze2(node.as_ref(), None).resolver;
+        SemanticsScope { db: self.db, resolver }
+    }
+    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextUnit) -> SemanticsScope<'db, DB> {
+        let node = self.find_file(node.clone());
+        let resolver = self.analyze2(node.as_ref(), Some(offset)).resolver;
+        SemanticsScope { db: self.db, resolver }
+    }
+    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db, DB> {
+        let resolver = def.id.resolver(self.db);
+        SemanticsScope { db: self.db, resolver }
+    }
+    // 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> {
+        self.analyze(pat.syntax()).find_all_refs(pat)
+    }
+    fn analyze(&self, node: &SyntaxNode) -> SourceAnalyzer {
+        let src = self.find_file(node.clone());
+        self.analyze2(src.as_ref(), None)
+    }
+    fn analyze2(&self, src: InFile<&SyntaxNode>, offset: Option<TextUnit>) -> SourceAnalyzer {
+        let _p = profile("Semantics::analyze2");
+        let container = match self.sb.borrow_mut().find_container(self.db, src) {
+            Some(it) => it,
+            None => return SourceAnalyzer::new_for_resolver(Resolver::default(), src),
+        };
+        let resolver = match container {
+            ChildContainer::DefWithBodyId(def) => {
+                return SourceAnalyzer::new_for_body(self.db, def, src, offset)
+            }
+            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)
+    }
+    fn cache(&self, root_node: SyntaxNode, file_id: HirFileId) {
+        assert!(root_node.parent().is_none());
+        let mut cache = self.cache.borrow_mut();
+        let prev = cache.insert(root_node, file_id);
+        assert!(prev == None || prev == Some(file_id))
+    }
+    pub fn assert_contains_node(&self, node: &SyntaxNode) {
+        self.find_file(node.clone());
+    }
+    fn lookup(&self, root_node: &SyntaxNode) -> Option<HirFileId> {
+        let cache = self.cache.borrow();
+        cache.get(root_node).copied()
+    }
+    fn find_file(&self, node: SyntaxNode) -> InFile<SyntaxNode> {
+        let root_node = find_root(&node);
+        let file_id = self.lookup(&root_node).unwrap_or_else(|| {
+            panic!(
+                "\n\nFailed to lookup {:?} in this Semantics.\n\
+                 Make sure to use only query nodes, derived from this instance of Semantics.\n\
+                 root node:   {:?}\n\
+                 known nodes: {}\n\n",
+                node,
+                root_node,
+                self.cache
+                    .borrow()
+                    .keys()
+                    .map(|it| format!("{:?}", it))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        });
+        InFile::new(file_id, node)
+    }
+}
+pub trait ToDef: Sized + AstNode + 'static {
+    type Def;
+    fn to_def<DB: HirDatabase>(sema: &Semantics<DB>, src: &Self) -> Option<Self::Def>;
+}
+macro_rules! to_def_impls {
+    ($(($def:path, $ast:path)),* ,) => {$(
+        impl ToDef for $ast {
+            type Def = $def;
+            fn to_def<DB: HirDatabase>(sema: &Semantics<DB>, src: &Self)
+                -> Option<Self::Def>
+            {
+                let src = sema.find_file(src.syntax().clone()).with_value(src);
+                sema.sb.borrow_mut().to_id(sema.db, src.cloned()).map(Into::into)
+            }
+        }
+    )*}
+}
+to_def_impls![
+    (crate::Module, ast::Module),
+    (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::TypeParam, ast::TypeParam),
+    (crate::MacroDef, ast::MacroCall), // this one is dubious, not all calls are macros
+];
+impl ToDef for ast::BindPat {
+    type Def = Local;
+    fn to_def<DB: HirDatabase>(sema: &Semantics<DB>, src: &Self) -> Option<Local> {
+        let src = sema.find_file(src.syntax().clone()).with_value(src);
+        let file_id = src.file_id;
+        let mut sb = sema.sb.borrow_mut();
+        let db = sema.db;
+        let parent: DefWithBodyId = src.value.syntax().ancestors().find_map(|it| {
+            let res = match_ast! {
+                match it {
+                    ast::ConstDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
+                    ast::StaticDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
+                    ast::FnDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
+                    _ => return None,
+                }
+            };
+            Some(res)
+        })?;
+        let (_body, source_map) = db.body_with_source_map(parent);
+        let src = src.cloned().map(ast::Pat::from);
+        let pat_id = source_map.node_pat(src.as_ref())?;
+        Some(Local { parent: parent.into(), pat_id })
+    }
+}
+fn find_root(node: &SyntaxNode) -> SyntaxNode {
+    node.ancestors().last().unwrap()
+}
+pub struct SemanticsScope<'a, DB> {
+    pub db: &'a DB,
+    resolver: Resolver,
+}
+impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
+    pub fn module(&self) -> Option<Module> {
+        Some(Module { id: self.resolver.module()? })
+    }
+    /// Note: `FxHashSet<TraitId>` should be treated as an opaque type, passed into `Type
+    // FIXME: rename to visible_traits to not repeat scope?
+    pub fn traits_in_scope(&self) -> FxHashSet<TraitId> {
+        let resolver = &self.resolver;
+        resolver.traits_in_scope(self.db)
+    }
+    pub fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef)) {
+        let resolver = &self.resolver;
+        resolver.process_all_names(self.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 = resolver.body_owner().unwrap().into();
+                    ScopeDef::Local(Local { parent, pat_id })
+                }
+            };
+            f(name, def)
+        })
+    }
+    pub fn resolve_hir_path(&self, path: &Path) -> Option<PathResolution> {
+        resolve_hir_path(self.db, &self.resolver, path)
+    }
+}
+// FIXME: Change `HasSource` trait to work with `Semantics` and remove this?
+pub fn original_range(db: &impl HirDatabase, node: InFile<&SyntaxNode>) -> FileRange {
+    let mut elem: InFile<SyntaxElement> = node.map(|n| n.clone().into());
+    while let Some((range, Origin::Call)) = original_range_and_origin(db, elem.as_ref()) {
+        let original_file = range.file_id.original_file(db);
+        if range.file_id == original_file.into() {
+            return FileRange { file_id: original_file, range: range.value };
+        }
+        if range.file_id != elem.file_id {
+            if let Some(root) = db.parse_or_expand(range.file_id) {
+                elem = range.with_value(find_covering_element(&root, range.value));
+                continue;
+            }
+        }
+        log::error!("Fail to mapping up more for {:?}", range);
+        return FileRange { file_id: range.file_id.original_file(db), range: range.value };
+    }
+    // Fall back to whole macro call
+    if let Some(expansion) = node.file_id.expansion_info(db) {
+        if let Some(call_node) = expansion.call_node() {
+            return FileRange {
+                file_id: call_node.file_id.original_file(db),
+                range: call_node.value.text_range(),
+            };
+        }
+    }
+    FileRange { file_id: node.file_id.original_file(db), range: node.value.text_range() }
+}
+fn original_range_and_origin(
+    db: &impl HirDatabase,
+    elem: InFile<&SyntaxElement>,
+) -> Option<(InFile<TextRange>, Origin)> {
+    let expansion = elem.file_id.expansion_info(db)?;
+    let node = match elem.as_ref().value {
+        NodeOrToken::Node(it) => elem.with_value(it),
+        NodeOrToken::Token(it) => {
+            let (tt, origin) = expansion.map_token_up(elem.with_value(it))?;
+            return Some((tt.map(|it| it.text_range()), origin));
+        }
+    };
+    // the input node has only one token ?
+    let single = skip_trivia_token(node.value.first_token()?, Direction::Next)?
+        == skip_trivia_token(node.value.last_token()?, Direction::Prev)?;
+    Some(node.value.descendants().find_map(|it| {
+        let first = skip_trivia_token(it.first_token()?, Direction::Next)?;
+        let last = skip_trivia_token(it.last_token()?, Direction::Prev)?;
+        if !single && first == last {
+            return None;
+        }
+        // Try to map first and last tokens of node, and, if success, return the union range of mapped tokens
+        let (first, first_origin) = expansion.map_token_up(node.with_value(&first))?;
+        let (last, last_origin) = expansion.map_token_up(node.with_value(&last))?;
+        if first.file_id != last.file_id || first_origin != last_origin {
+            return None;
+        }
+        Some((
+            first.with_value(first.value.text_range().extend_to(&last.value.text_range())),
+            first_origin,
+        ))
+    })?)
+}
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index efa3f8a79..b655e2c32 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -14,29 +14,27 @@ use hir_def::{
        BodySourceMap,
    },
    expr::{ExprId, PatId},
-    resolver::{self, resolver_for_scope, Resolver, TypeNs, ValueNs},
+    resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
-    AsMacroCall, DefWithBodyId, TraitId,
+    AsMacroCall, DefWithBodyId,
 };
-use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile, MacroCallId};
+use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
 use ra_syntax::{
    ast::{self, AstNode},
-    AstPtr, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
+    AstPtr, SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
 };
-use rustc_hash::FxHashSet;
 use crate::{
-    db::HirDatabase, Adt, Const, DefWithBody, EnumVariant, Function, Local, MacroDef, Name, Path,
+    db::HirDatabase, Adt, Const, EnumVariant, Function, Local, MacroDef, Path, Static, Struct,
-    ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+    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 {
+pub(crate) struct SourceAnalyzer {
    file_id: HirFileId,
-    resolver: Resolver,
+    pub(crate) resolver: Resolver,
-    body_owner: Option<DefWithBody>,
    body_source_map: Option<Arc<BodySourceMap>>,
    infer: Option<Arc<InferenceResult>>,
    scopes: Option<Arc<ExprScopes>>,
@@ -55,57 +53,13 @@ pub enum PathResolution {
    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,
@@ -121,7 +75,6 @@ impl SourceAnalyzer {
        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),
@@ -135,7 +88,6 @@ impl SourceAnalyzer {
    ) -> SourceAnalyzer {
        SourceAnalyzer {
            resolver,
-            body_owner: None,
            body_source_map: None,
            infer: None,
            scopes: None,
@@ -143,10 +95,6 @@ impl SourceAnalyzer {
        }
    }
-    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)
@@ -180,7 +128,7 @@ impl SourceAnalyzer {
        TraitEnvironment::lower(db, &self.resolver)
    }
-    pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
+    pub(crate) 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 {
@@ -192,24 +140,27 @@ impl SourceAnalyzer {
        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> {
+    pub(crate) 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 = self.trait_env(db);
        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
    }
-    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+    pub(crate) 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> {
+    pub(crate) 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> {
+    pub(crate) fn resolve_record_field(
+        &self,
+        field: &ast::RecordField,
+    ) -> Option<crate::StructField> {
        let expr_id = match field.expr() {
            Some(it) => self.expr_id(&it)?,
            None => {
@@ -220,17 +171,23 @@ impl SourceAnalyzer {
        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> {
+    pub(crate) 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> {
+    pub(crate) 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(
+    pub(crate) fn resolve_macro_call(
        &self,
        db: &impl HirDatabase,
        macro_call: InFile<&ast::MacroCall>,
@@ -240,52 +197,11 @@ impl SourceAnalyzer {
        self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into())
    }
-    pub fn resolve_hir_path(
+    pub(crate) fn resolve_path(
        &self,
        db: &impl HirDatabase,
-        path: &crate::Path,
+        path: &ast::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) {
@@ -300,40 +216,24 @@ impl SourceAnalyzer {
        }
        // 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)
+        resolve_hir_path(db, &self.resolver, &hir_path)
    }
-    fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
+    fn resolve_local_name(
+        &self,
+        name_ref: &ast::NameRef,
+    ) -> Option<Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>> {
        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 {
+        Some(source_map.pat_syntax(entry.pat())?.value)
-            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> {
+    pub(crate) 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
@@ -342,7 +242,7 @@ impl SourceAnalyzer {
            .filter_map(ast::NameRef::cast)
            .filter(|name_ref| match self.resolve_local_name(&name_ref) {
                None => false,
-                Some(entry) => entry.ptr() == ptr,
+                Some(d_ptr) => d_ptr == ptr,
            })
            .map(|name_ref| ReferenceDescriptor {
                name: name_ref.text().to_string(),
@@ -351,19 +251,14 @@ impl SourceAnalyzer {
            .collect()
    }
-    /// Note: `FxHashSet<TraitId>` should be treated as an opaque type, passed into `Type
+    pub(crate) fn expand(
-    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> {
+    ) -> Option<HirFileId> {
        let macro_call_id =
            macro_call.as_call_id(db, |path| self.resolver.resolve_path_as_macro(db, &path))?;
-        Some(Expansion { macro_call_id })
+        Some(macro_call_id.as_file())
    }
 }
@@ -409,6 +304,47 @@ fn scope_for_offset(
        })
 }
+pub(crate) fn resolve_hir_path(
+    db: &impl HirDatabase,
+    resolver: &Resolver,
+    path: &crate::Path,
+) -> Option<PathResolution> {
+    let types = 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 body_owner = resolver.body_owner();
+    let values = 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: body_owner?.into(), 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 = 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(|| {
+        resolver
+            .resolve_path_as_macro(db, path.mod_path())
+            .map(|def| PathResolution::Macro(def.into()))
+    })
+}
 // XXX: during completion, cursor might be outside of any particular
 // expression. Try to figure out the correct scope...
 fn adjust(
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index f3150f578..4353e25ac 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -5,112 +5,89 @@ use hir_def::{
    child_by_source::ChildBySource,
    dyn_map::DynMap,
    keys::{self, Key},
-    resolver::{HasResolver, Resolver},
    ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId,
-    StaticId, StructFieldId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
+    StaticId, StructFieldId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId,
 };
 use hir_expand::{name::AsName, AstId, InFile, MacroDefId, MacroDefKind};
+use ra_db::FileId;
 use ra_prof::profile;
 use ra_syntax::{
    ast::{self, NameOwner},
-    match_ast, AstNode, SyntaxNode, TextUnit,
+    match_ast, AstNode, SyntaxNode,
 };
 use rustc_hash::FxHashMap;
-use crate::{db::HirDatabase, Local, Module, SourceAnalyzer, TypeParam};
+use crate::{db::HirDatabase, Module};
-use ra_db::FileId;
-pub struct SourceBinder<'a, DB> {
+pub(crate) struct SourceBinder {
-    pub db: &'a DB,
    child_by_source_cache: FxHashMap<ChildContainer, DynMap>,
 }
-impl<DB: HirDatabase> SourceBinder<'_, DB> {
+impl SourceBinder {
-    pub fn new(db: &DB) -> SourceBinder<DB> {
+    pub(crate) fn new() -> SourceBinder {
-        SourceBinder { db, child_by_source_cache: FxHashMap::default() }
+        SourceBinder { child_by_source_cache: FxHashMap::default() }
-    }
-    pub fn analyze(
-        &mut self,
-        src: InFile<&SyntaxNode>,
-        offset: Option<TextUnit>,
-    ) -> SourceAnalyzer {
-        let _p = profile("SourceBinder::analyzer");
-        let container = match self.find_container(src) {
-            Some(it) => it,
-            None => return SourceAnalyzer::new_for_resolver(Resolver::default(), src),
-        };
-        let resolver = match container {
-            ChildContainer::DefWithBodyId(def) => {
-                return SourceAnalyzer::new_for_body(self.db, def, src, offset)
-            }
-            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 to_def<T: ToDef>(&mut self, src: InFile<T>) -> Option<T::Def> {
-        T::to_def(self, src)
    }
-    pub fn to_module_def(&mut self, file: FileId) -> Option<Module> {
+    pub(crate) fn to_module_def(&mut self, db: &impl HirDatabase, file: FileId) -> Option<Module> {
        let _p = profile("SourceBinder::to_module_def");
-        let (krate, local_id) = self.db.relevant_crates(file).iter().find_map(|&crate_id| {
+        let (krate, local_id) = db.relevant_crates(file).iter().find_map(|&crate_id| {
-            let crate_def_map = self.db.crate_def_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 to_id<T: ToId>(&mut self, src: InFile<T>) -> Option<T::ID> {
+    pub(crate) fn to_id<T: ToId>(
-        T::to_id(self, src)
+        &mut self,
+        db: &impl HirDatabase,
+        src: InFile<T>,
+    ) -> Option<T::ID> {
+        T::to_id(db, self, src)
    }
-    fn find_container(&mut self, src: InFile<&SyntaxNode>) -> Option<ChildContainer> {
+    pub(crate) fn find_container(
-        for container in src.cloned().ancestors_with_macros(self.db).skip(1) {
+        &mut self,
+        db: &impl HirDatabase,
+        src: InFile<&SyntaxNode>,
+    ) -> Option<ChildContainer> {
+        for container in src.cloned().ancestors_with_macros(db).skip(1) {
            let res: ChildContainer = match_ast! {
                match (container.value) {
                    ast::TraitDef(it) => {
-                        let def: TraitId = self.to_id(container.with_value(it))?;
+                        let def: TraitId = self.to_id(db, container.with_value(it))?;
                        def.into()
                    },
                    ast::ImplBlock(it) => {
-                        let def: ImplId = self.to_id(container.with_value(it))?;
+                        let def: ImplId = self.to_id(db, container.with_value(it))?;
                        def.into()
                    },
                    ast::FnDef(it) => {
-                        let def: FunctionId = self.to_id(container.with_value(it))?;
+                        let def: FunctionId = self.to_id(db, container.with_value(it))?;
                        DefWithBodyId::from(def).into()
                    },
                    ast::StaticDef(it) => {
-                        let def: StaticId = self.to_id(container.with_value(it))?;
+                        let def: StaticId = self.to_id(db, container.with_value(it))?;
                        DefWithBodyId::from(def).into()
                    },
                    ast::ConstDef(it) => {
-                        let def: ConstId = self.to_id(container.with_value(it))?;
+                        let def: ConstId = self.to_id(db, container.with_value(it))?;
                        DefWithBodyId::from(def).into()
                    },
                    ast::EnumDef(it) => {
-                        let def: EnumId = self.to_id(container.with_value(it))?;
+                        let def: EnumId = self.to_id(db, container.with_value(it))?;
                        def.into()
                    },
                    ast::StructDef(it) => {
-                        let def: StructId = self.to_id(container.with_value(it))?;
+                        let def: StructId = self.to_id(db, container.with_value(it))?;
                        VariantId::from(def).into()
                    },
                    ast::UnionDef(it) => {
-                        let def: UnionId = self.to_id(container.with_value(it))?;
+                        let def: UnionId = self.to_id(db, container.with_value(it))?;
                        VariantId::from(def).into()
                    },
                    ast::Module(it) => {
-                        let def: ModuleId = self.to_id(container.with_value(it))?;
+                        let def: ModuleId = self.to_id(db, container.with_value(it))?;
                        def.into()
                    },
                    _ => { continue },
@@ -119,12 +96,11 @@ impl<DB: HirDatabase> SourceBinder<'_, DB> {
            return Some(res);
        }
-        let c = self.to_module_def(src.file_id.original_file(self.db))?;
+        let c = self.to_module_def(db, src.file_id.original_file(db))?;
        Some(c.id.into())
    }
-    fn child_by_source(&mut self, container: ChildContainer) -> &DynMap {
+    fn child_by_source(&mut self, db: &impl HirDatabase, container: ChildContainer) -> &DynMap {
-        let db = self.db;
        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),
@@ -137,49 +113,17 @@ impl<DB: HirDatabase> SourceBinder<'_, DB> {
    }
 }
-pub trait ToId: Sized {
+pub(crate) trait ToId: Sized {
    type ID: Sized + Copy + 'static;
-    fn to_id<DB: HirDatabase>(sb: &mut SourceBinder<'_, DB>, src: InFile<Self>)
+    fn to_id<DB: HirDatabase>(
-        -> Option<Self::ID>;
+        db: &DB,
-}
+        sb: &mut SourceBinder,
-pub trait ToDef: Sized + AstNode + 'static {
-    type Def;
-    fn to_def<DB: HirDatabase>(
-        sb: &mut SourceBinder<'_, DB>,
        src: InFile<Self>,
-    ) -> Option<Self::Def>;
+    ) -> Option<Self::ID>;
-}
-macro_rules! to_def_impls {
-    ($(($def:path, $ast:path)),* ,) => {$(
-        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) }
-        }
-    )*}
 }
-to_def_impls![
-    (crate::Module, ast::Module),
-    (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 {
+pub(crate) enum ChildContainer {
    DefWithBodyId(DefWithBodyId),
    ModuleId(ModuleId),
    TraitId(TraitId),
@@ -201,7 +145,7 @@ impl_froms! {
    GenericDefId
 }
-pub trait ToIdByKey: Sized + AstNode + 'static {
+pub(crate) trait ToIdByKey: Sized + AstNode + 'static {
    type ID: Sized + Copy + 'static;
    const KEY: Key<Self, Self::ID>;
 }
@@ -209,11 +153,11 @@ pub trait ToIdByKey: Sized + AstNode + 'static {
 impl<T: ToIdByKey> ToId for T {
    type ID = <T as ToIdByKey>::ID;
    fn to_id<DB: HirDatabase>(
-        sb: &mut SourceBinder<'_, DB>,
+        db: &DB,
+        sb: &mut SourceBinder,
        src: InFile<Self>,
    ) -> Option<Self::ID> {
-        let container = sb.find_container(src.as_ref().map(|it| it.syntax()))?;
+        let container = sb.find_container(db, src.as_ref().map(|it| it.syntax()))?;
-        let db = sb.db;
        let dyn_map =
            &*sb.child_by_source_cache.entry(container).or_insert_with(|| match container {
                ChildContainer::DefWithBodyId(it) => it.child_by_source(db),
@@ -255,68 +199,44 @@ to_id_key_impls![
 impl ToId for ast::MacroCall {
    type ID = MacroDefId;
    fn to_id<DB: HirDatabase>(
-        sb: &mut SourceBinder<'_, DB>,
+        db: &DB,
+        sb: &mut SourceBinder,
        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 krate = sb.to_module_def(db, src.file_id.original_file(db))?.id.krate;
-        let ast_id =
+        let ast_id = Some(AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.value)));
-            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 })
    }
 }
-impl ToDef for ast::BindPat {
+impl ToId for ast::TypeParam {
-    type Def = Local;
+    type ID = TypeParamId;
-    fn to_def<DB: HirDatabase>(sb: &mut SourceBinder<'_, DB>, src: InFile<Self>) -> Option<Local> {
-        let file_id = src.file_id;
-        let parent: DefWithBodyId = src.value.syntax().ancestors().find_map(|it| {
-            let res = match_ast! {
-                match it {
-                    ast::ConstDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
-                    ast::StaticDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
-                    ast::FnDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
-                    _ => return None,
-                }
-            };
-            Some(res)
-        })?;
-        let (_body, source_map) = sb.db.body_with_source_map(parent);
-        let src = src.map(ast::Pat::from);
-        let pat_id = source_map.node_pat(src.as_ref())?;
-        Some(Local { parent: parent.into(), pat_id })
-    }
-}
-impl ToDef for ast::TypeParam {
-    type Def = TypeParam;
-    fn to_def<DB: HirDatabase>(
+    fn to_id<DB: HirDatabase>(
-        sb: &mut SourceBinder<'_, DB>,
+        db: &DB,
-        src: InFile<ast::TypeParam>,
+        sb: &mut SourceBinder,
-    ) -> Option<TypeParam> {
+        src: InFile<Self>,
-        let mut sb = SourceBinder::new(sb.db);
+    ) -> Option<Self::ID> {
        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) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::FnDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
-                    ast::StructDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::StructDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
-                    ast::EnumDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::EnumDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
-                    ast::TraitDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::TraitDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
-                    ast::TypeAliasDef(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::TypeAliasDef(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
-                    ast::ImplBlock(value) => { sb.to_id(InFile { value, file_id})?.into() },
+                    ast::ImplBlock(value) => { sb.to_id(db, InFile { value, file_id})?.into() },
                    _ => return None,
                }
            };
            Some(res)
        })?;
-        let &id = sb.child_by_source(parent.into())[keys::TYPE_PARAM].get(&src)?;
+        sb.child_by_source(db, parent.into())[keys::TYPE_PARAM].get(&src).copied()
-        Some(TypeParam { id })
    }
 }
@@ -324,7 +244,8 @@ impl ToId for ast::Module {
    type ID = ModuleId;
    fn to_id<DB: HirDatabase>(
-        sb: &mut SourceBinder<'_, DB>,
+        db: &DB,
+        sb: &mut SourceBinder,
        src: InFile<ast::Module>,
    ) -> Option<ModuleId> {
        {
@@ -333,7 +254,7 @@ impl ToId for ast::Module {
                .as_ref()
                .map(|it| it.syntax())
                .cloned()
-                .ancestors_with_macros(sb.db)
+                .ancestors_with_macros(db)
                .skip(1)
                .find_map(|it| {
                    let m = ast::Module::cast(it.value.clone())?;
@@ -341,15 +262,15 @@ impl ToId for ast::Module {
                });
            let parent_module = match parent_declaration {
-                Some(parent_declaration) => sb.to_id(parent_declaration)?,
+                Some(parent_declaration) => sb.to_id(db, parent_declaration)?,
                None => {
-                    let file_id = src.file_id.original_file(sb.db);
+                    let file_id = src.file_id.original_file(db);
-                    sb.to_module_def(file_id)?.id
+                    sb.to_module_def(db, file_id)?.id
                }
            };
            let child_name = src.value.name()?.as_name();
-            let def_map = sb.db.crate_def_map(parent_module.krate);
+            let def_map = db.crate_def_map(parent_module.krate);
            let child_id = *def_map[parent_module.local_id].children.get(&child_name)?;
            Some(ModuleId { krate: parent_module.krate, local_id: child_id })
        }
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index 5053d0688..fa25cc4fb 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -14,7 +14,6 @@ rustc-hash = "1.1.0"
 either = "1.5.3"
 anymap = "0.12.1"
 drop_bomb = "0.1.4"
-itertools = "0.8.2"
 ra_arena = { path = "../ra_arena" }
 ra_db = { path = "../ra_db" }
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 49cafc539..99e2fe1bf 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -21,9 +21,9 @@ ra_prof = { path = "../ra_prof" }
 ra_syntax = { path = "../ra_syntax" }
 test_utils = { path = "../test_utils" }
-chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
+chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
-chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
+chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
 lalrpop-intern = "0.15.1"
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 2317fcac3..17aef9490 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -14,7 +14,7 @@ use crate::db::HirDatabase;
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
-use self::chalk::{from_chalk, ToChalk, TypeFamily};
+use self::chalk::{from_chalk, Interner, ToChalk};
 pub(crate) mod chalk;
 mod builtin;
@@ -22,7 +22,7 @@ mod builtin;
 #[derive(Debug, Clone)]
 pub struct TraitSolver {
    krate: CrateId,
-    inner: Arc<Mutex<chalk_solve::Solver<TypeFamily>>>,
+    inner: Arc<Mutex<chalk_solve::Solver<Interner>>>,
 }
 /// We need eq for salsa
@@ -38,8 +38,8 @@ impl TraitSolver {
    fn solve(
        &self,
        db: &impl HirDatabase,
-        goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<TypeFamily>>>,
+        goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>,
-    ) -> Option<chalk_solve::Solution<TypeFamily>> {
+    ) -> Option<chalk_solve::Solution<Interner>> {
        let context = ChalkContext { db, krate: self.krate };
        log::debug!("solve goal: {:?}", goal);
        let mut solver = match self.inner.lock() {
@@ -110,7 +110,7 @@ pub(crate) fn trait_solver_query(
    TraitSolver { krate, inner: Arc::new(Mutex::new(create_chalk_solver())) }
 }
-fn create_chalk_solver() -> chalk_solve::Solver<TypeFamily> {
+fn create_chalk_solver() -> chalk_solve::Solver<Interner> {
    let solver_choice =
        chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE, expected_answers: None };
    solver_choice.into_solver()
@@ -242,9 +242,9 @@ pub(crate) fn trait_solve_query(
 fn solution_from_chalk(
    db: &impl HirDatabase,
-    solution: chalk_solve::Solution<TypeFamily>,
+    solution: chalk_solve::Solution<Interner>,
 ) -> Solution {
-    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<TypeFamily>>| {
+    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
        let value = subst
            .value
            .into_iter()
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index e1e430aeb..5b6c1a62e 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -3,7 +3,7 @@ use std::{fmt, sync::Arc};
 use log::debug;
-use chalk_ir::{cast::Cast, GoalData, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
+use chalk_ir::{cast::Cast, Goal, GoalData, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
 use hir_def::{AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId};
 use ra_db::{
@@ -18,13 +18,14 @@ use crate::{
 };
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct TypeFamily {}
+pub struct Interner {}
-impl chalk_ir::family::TypeFamily for TypeFamily {
+impl chalk_ir::interner::Interner for Interner {
    type InternedType = Box<chalk_ir::TyData<Self>>;
    type InternedLifetime = chalk_ir::LifetimeData<Self>;
    type InternedParameter = chalk_ir::ParameterData<Self>;
    type InternedGoal = Arc<GoalData<Self>>;
+    type InternedGoals = Vec<Goal<Self>>;
    type InternedSubstitution = Vec<Parameter<Self>>;
    type DefId = InternId;
@@ -85,10 +86,18 @@ impl chalk_ir::family::TypeFamily for TypeFamily {
        Arc::new(goal)
    }
+    fn intern_goals(data: impl IntoIterator<Item = Goal<Self>>) -> Self::InternedGoals {
+        data.into_iter().collect()
+    }
    fn goal_data(goal: &Arc<GoalData<Self>>) -> &GoalData<Self> {
        goal
    }
+    fn goals_data(goals: &Vec<Goal<Interner>>) -> &[Goal<Interner>] {
+        goals
+    }
    fn intern_substitution<E>(
        data: impl IntoIterator<Item = Result<Parameter<Self>, E>>,
    ) -> Result<Vec<Parameter<Self>>, E> {
@@ -100,20 +109,20 @@ impl chalk_ir::family::TypeFamily for TypeFamily {
    }
 }
-impl chalk_ir::family::HasTypeFamily for TypeFamily {
+impl chalk_ir::interner::HasInterner for Interner {
-    type TypeFamily = Self;
+    type Interner = Self;
 }
-pub type AssocTypeId = chalk_ir::AssocTypeId<TypeFamily>;
+pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
-pub type AssociatedTyDatum = chalk_rust_ir::AssociatedTyDatum<TypeFamily>;