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>;
+pub type AssociatedTyDatum = chalk_rust_ir::AssociatedTyDatum<Interner>;
-pub type TraitId = chalk_ir::TraitId<TypeFamily>;
+pub type TraitId = chalk_ir::TraitId<Interner>;
-pub type TraitDatum = chalk_rust_ir::TraitDatum<TypeFamily>;
+pub type TraitDatum = chalk_rust_ir::TraitDatum<Interner>;
-pub type StructId = chalk_ir::StructId<TypeFamily>;
+pub type StructId = chalk_ir::StructId<Interner>;
-pub type StructDatum = chalk_rust_ir::StructDatum<TypeFamily>;
+pub type StructDatum = chalk_rust_ir::StructDatum<Interner>;
-pub type ImplId = chalk_ir::ImplId<TypeFamily>;
+pub type ImplId = chalk_ir::ImplId<Interner>;
-pub type ImplDatum = chalk_rust_ir::ImplDatum<TypeFamily>;
+pub type ImplDatum = chalk_rust_ir::ImplDatum<Interner>;
 pub type AssociatedTyValueId = chalk_rust_ir::AssociatedTyValueId;
-pub type AssociatedTyValue = chalk_rust_ir::AssociatedTyValue<TypeFamily>;
+pub type AssociatedTyValue = chalk_rust_ir::AssociatedTyValue<Interner>;
 pub(super) trait ToChalk {
    type Chalk;
@@ -129,8 +138,8 @@ where
 }
 impl ToChalk for Ty {
-    type Chalk = chalk_ir::Ty<TypeFamily>;
+    type Chalk = chalk_ir::Ty<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Ty<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Ty<Interner> {
        match self {
            Ty::Apply(apply_ty) => {
                let name = apply_ty.ctor.to_chalk(db);
@@ -148,7 +157,7 @@ impl ToChalk for Ty {
                    ui: UniverseIndex::ROOT,
                    idx: interned_id.as_intern_id().as_usize(),
                }
-                .to_ty::<TypeFamily>()
+                .to_ty::<Interner>()
            }
            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
@@ -169,7 +178,7 @@ impl ToChalk for Ty {
            }
        }
    }
-    fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<TypeFamily>) -> Self {
+    fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
        match chalk.data().clone() {
            chalk_ir::TyData::Apply(apply_ty) => match apply_ty.name {
                TypeName::Error => Ty::Unknown,
@@ -205,13 +214,13 @@ impl ToChalk for Ty {
 }
 impl ToChalk for Substs {
-    type Chalk = chalk_ir::Substitution<TypeFamily>;
+    type Chalk = chalk_ir::Substitution<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Substitution<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Substitution<Interner> {
        chalk_ir::Substitution::from(self.iter().map(|ty| ty.clone().to_chalk(db)))
    }
-    fn from_chalk(db: &impl HirDatabase, parameters: chalk_ir::Substitution<TypeFamily>) -> Substs {
+    fn from_chalk(db: &impl HirDatabase, parameters: chalk_ir::Substitution<Interner>) -> Substs {
        let tys = parameters
            .into_iter()
            .map(|p| match p.ty() {
@@ -224,15 +233,15 @@ impl ToChalk for Substs {
 }
 impl ToChalk for TraitRef {
-    type Chalk = chalk_ir::TraitRef<TypeFamily>;
+    type Chalk = chalk_ir::TraitRef<Interner>;
-    fn to_chalk(self: TraitRef, db: &impl HirDatabase) -> chalk_ir::TraitRef<TypeFamily> {
+    fn to_chalk(self: TraitRef, db: &impl HirDatabase) -> chalk_ir::TraitRef<Interner> {
        let trait_id = self.trait_.to_chalk(db);
        let substitution = self.substs.to_chalk(db);
        chalk_ir::TraitRef { trait_id, substitution }
    }
-    fn from_chalk(db: &impl HirDatabase, trait_ref: chalk_ir::TraitRef<TypeFamily>) -> Self {
+    fn from_chalk(db: &impl HirDatabase, trait_ref: chalk_ir::TraitRef<Interner>) -> Self {
        let trait_ = from_chalk(db, trait_ref.trait_id);
        let substs = from_chalk(db, trait_ref.substitution);
        TraitRef { trait_, substs }
@@ -252,9 +261,9 @@ impl ToChalk for hir_def::TraitId {
 }
 impl ToChalk for TypeCtor {
-    type Chalk = TypeName<TypeFamily>;
+    type Chalk = TypeName<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> TypeName<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> TypeName<Interner> {
        match self {
            TypeCtor::AssociatedType(type_alias) => {
                let type_id = type_alias.to_chalk(db);
@@ -268,7 +277,7 @@ impl ToChalk for TypeCtor {
        }
    }
-    fn from_chalk(db: &impl HirDatabase, type_name: TypeName<TypeFamily>) -> TypeCtor {
+    fn from_chalk(db: &impl HirDatabase, type_name: TypeName<Interner>) -> TypeCtor {
        match type_name {
            TypeName::Struct(struct_id) => db.lookup_intern_type_ctor(struct_id.into()),
            TypeName::AssociatedType(type_id) => TypeCtor::AssociatedType(from_chalk(db, type_id)),
@@ -317,9 +326,9 @@ impl ToChalk for AssocTyValue {
 }
 impl ToChalk for GenericPredicate {
-    type Chalk = chalk_ir::QuantifiedWhereClause<TypeFamily>;
+    type Chalk = chalk_ir::QuantifiedWhereClause<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::QuantifiedWhereClause<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::QuantifiedWhereClause<Interner> {
        match self {
            GenericPredicate::Implemented(trait_ref) => {
                make_binders(chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db)), 0)
@@ -337,7 +346,7 @@ impl ToChalk for GenericPredicate {
    fn from_chalk(
        db: &impl HirDatabase,
-        where_clause: chalk_ir::QuantifiedWhereClause<TypeFamily>,
+        where_clause: chalk_ir::QuantifiedWhereClause<Interner>,
    ) -> GenericPredicate {
        match where_clause.value {
            chalk_ir::WhereClause::Implemented(tr) => {
@@ -353,9 +362,9 @@ impl ToChalk for GenericPredicate {
 }
 impl ToChalk for ProjectionTy {
-    type Chalk = chalk_ir::AliasTy<TypeFamily>;
+    type Chalk = chalk_ir::AliasTy<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::AliasTy<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::AliasTy<Interner> {
        chalk_ir::AliasTy {
            associated_ty_id: self.associated_ty.to_chalk(db),
            substitution: self.parameters.to_chalk(db),
@@ -364,7 +373,7 @@ impl ToChalk for ProjectionTy {
    fn from_chalk(
        db: &impl HirDatabase,
-        projection_ty: chalk_ir::AliasTy<TypeFamily>,
+        projection_ty: chalk_ir::AliasTy<Interner>,
    ) -> ProjectionTy {
        ProjectionTy {
            associated_ty: from_chalk(db, projection_ty.associated_ty_id),
@@ -374,28 +383,28 @@ impl ToChalk for ProjectionTy {
 }
 impl ToChalk for super::ProjectionPredicate {
-    type Chalk = chalk_ir::Normalize<TypeFamily>;
+    type Chalk = chalk_ir::Normalize<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Normalize<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Normalize<Interner> {
        chalk_ir::Normalize { alias: self.projection_ty.to_chalk(db), ty: self.ty.to_chalk(db) }
    }
-    fn from_chalk(_db: &impl HirDatabase, _normalize: chalk_ir::Normalize<TypeFamily>) -> Self {
+    fn from_chalk(_db: &impl HirDatabase, _normalize: chalk_ir::Normalize<Interner>) -> Self {
        unimplemented!()
    }
 }
 impl ToChalk for Obligation {
-    type Chalk = chalk_ir::DomainGoal<TypeFamily>;
+    type Chalk = chalk_ir::DomainGoal<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::DomainGoal<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::DomainGoal<Interner> {
        match self {
            Obligation::Trait(tr) => tr.to_chalk(db).cast(),
            Obligation::Projection(pr) => pr.to_chalk(db).cast(),
        }
    }
-    fn from_chalk(_db: &impl HirDatabase, _goal: chalk_ir::DomainGoal<TypeFamily>) -> Self {
+    fn from_chalk(_db: &impl HirDatabase, _goal: chalk_ir::DomainGoal<Interner>) -> Self {
        unimplemented!()
    }
 }
@@ -418,16 +427,16 @@ where
 }
 impl ToChalk for Arc<super::TraitEnvironment> {
-    type Chalk = chalk_ir::Environment<TypeFamily>;
+    type Chalk = chalk_ir::Environment<Interner>;
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Environment<TypeFamily> {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Environment<Interner> {
        let mut clauses = Vec::new();
        for pred in &self.predicates {
            if pred.is_error() {
                // for env, we just ignore errors
                continue;
            }
-            let program_clause: chalk_ir::ProgramClause<TypeFamily> =
+            let program_clause: chalk_ir::ProgramClause<Interner> =
                pred.clone().to_chalk(db).cast();
            clauses.push(program_clause.into_from_env_clause());
        }
@@ -436,7 +445,7 @@ impl ToChalk for Arc<super::TraitEnvironment> {
    fn from_chalk(
        _db: &impl HirDatabase,
-        _env: chalk_ir::Environment<TypeFamily>,
+        _env: chalk_ir::Environment<Interner>,
    ) -> Arc<super::TraitEnvironment> {
        unimplemented!()
    }
@@ -444,7 +453,7 @@ impl ToChalk for Arc<super::TraitEnvironment> {
 impl<T: ToChalk> ToChalk for super::InEnvironment<T>
 where
-    T::Chalk: chalk_ir::family::HasTypeFamily<TypeFamily = TypeFamily>,
+    T::Chalk: chalk_ir::interner::HasInterner<Interner = Interner>,
 {
    type Chalk = chalk_ir::InEnvironment<T::Chalk>;
@@ -522,7 +531,7 @@ fn convert_where_clauses(
    db: &impl HirDatabase,
    def: GenericDefId,
    substs: &Substs,
-) -> Vec<chalk_ir::QuantifiedWhereClause<TypeFamily>> {
+) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
    let generic_predicates = db.generic_predicates(def);
    let mut result = Vec::with_capacity(generic_predicates.len());
    for pred in generic_predicates.iter() {
@@ -535,7 +544,7 @@ fn convert_where_clauses(
    result
 }
-impl<'a, DB> chalk_solve::RustIrDatabase<TypeFamily> for ChalkContext<'a, DB>
+impl<'a, DB> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a, DB>
 where
    DB: HirDatabase,
 {
@@ -554,7 +563,7 @@ where
    fn impls_for_trait(
        &self,
        trait_id: TraitId,
-        parameters: &[Parameter<TypeFamily>],
+        parameters: &[Parameter<Interner>],
    ) -> Vec<ImplId> {
        debug!("impls_for_trait {:?}", trait_id);
        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
@@ -589,14 +598,14 @@ where
    fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
        self.db.associated_ty_value(self.krate, id)
    }
-    fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<TypeFamily>> {
+    fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<Interner>> {
        vec![]
    }
    fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> {
        // We don't do coherence checking (yet)
        unimplemented!()
    }
-    fn as_struct_id(&self, id: &TypeName<TypeFamily>) -> Option<StructId> {
+    fn as_struct_id(&self, id: &TypeName<Interner>) -> Option<StructId> {
        match id {
            TypeName::Struct(struct_id) => Some(*struct_id),
            _ => None,
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 3407d2598..7625fc8c8 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -17,11 +17,7 @@ indexmap = "1.3.2"
 itertools = "0.8.2"
 join_to_string = "0.1.3"
 log = "0.4.8"
-rayon = "1.3.0"
-fst = { version = "0.3.5", default-features = false }
 rustc-hash = "1.1.0"
-unicase = "2.6.0"
-superslice = "1.0.0"
 rand = { version = "0.7.3", features = ["small_rng"] }
 once_cell = "1.3.1"
diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index f984f40ad..b00b6d431 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -2,18 +2,13 @@
 use indexmap::IndexMap;
-use hir::db::AstDatabase;
+use hir::Semantics;
 use ra_ide_db::RootDatabase;
-use ra_syntax::{
+use ra_syntax::{ast, match_ast, AstNode, TextRange};
-    ast::{self, DocCommentsOwner},
-    match_ast, AstNode, TextRange,
-};
 use crate::{
-    call_info::FnCallNode,
+    call_info::FnCallNode, display::ToNav, goto_definition, references, FilePosition,
-    display::{ShortLabel, ToNav},
+    NavigationTarget, RangeInfo,
-    expand::descend_into_macros,
-    goto_definition, references, FilePosition, NavigationTarget, RangeInfo,
 };
 #[derive(Debug, Clone)]
@@ -43,6 +38,7 @@ pub(crate) fn call_hierarchy(
 }
 pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
+    let sema = Semantics::new(db);
    // 1. Find all refs
    // 2. Loop through refs and determine unique fndef. This will become our `from: CallHierarchyItem,` in the reply.
    // 3. Add ranges relative to the start of the fndef.
@@ -52,24 +48,21 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
    for reference in refs.info.references() {
        let file_id = reference.file_range.file_id;
-        let file = db.parse_or_expand(file_id.into())?;
+        let file = sema.parse(file_id);
+        let file = file.syntax();
        let token = file.token_at_offset(reference.file_range.range.start()).next()?;
-        let token = descend_into_macros(db, file_id, token);
+        let token = sema.descend_into_macros(token);
-        let syntax = token.value.parent();
+        let syntax = token.parent();
        // This target is the containing function
        if let Some(nav) = syntax.ancestors().find_map(|node| {
            match_ast! {
                match node {
                    ast::FnDef(it) => {
-                        Some(NavigationTarget::from_named(
+                        let def = sema.to_def(&it)?;
-                            db,
+                        Some(def.to_nav(sema.db))
-                            token.with_value(&it),
-                            it.doc_comment_text(),
-                            it.short_label(),
-                        ))
                    },
-                    _ => { None },
+                    _ => None,
                }
            }
        }) {
@@ -82,11 +75,13 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
 }
 pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
+    let sema = Semantics::new(db);
    let file_id = position.file_id;
-    let file = db.parse_or_expand(file_id.into())?;
+    let file = sema.parse(file_id);
+    let file = file.syntax();
    let token = file.token_at_offset(position.offset).next()?;
-    let token = descend_into_macros(db, file_id, token);
+    let token = sema.descend_into_macros(token);
-    let syntax = token.value.parent();
+    let syntax = token.parent();
    let mut calls = CallLocations::default();
@@ -95,14 +90,11 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
        .filter_map(|node| FnCallNode::with_node_exact(&node))
        .filter_map(|call_node| {
            let name_ref = call_node.name_ref()?;
-            let name_ref = token.with_value(name_ref.syntax());
-            let analyzer = hir::SourceAnalyzer::new(db, name_ref, None);
            if let Some(func_target) = match &call_node {
                FnCallNode::CallExpr(expr) => {
                    //FIXME: Type::as_callable is broken
-                    let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+                    let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
                    match callable_def {
                        hir::CallableDef::FunctionId(it) => {
                            let fn_def: hir::Function = it.into();
@@ -113,15 +105,15 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
                    }
                }
                FnCallNode::MethodCallExpr(expr) => {
-                    let function = analyzer.resolve_method_call(&expr)?;
+                    let function = sema.resolve_method_call(&expr)?;
                    Some(function.to_nav(db))
                }
-                FnCallNode::MacroCallExpr(expr) => {
+                FnCallNode::MacroCallExpr(macro_call) => {
-                    let macro_def = analyzer.resolve_macro_call(db, name_ref.with_value(&expr))?;
+                    let macro_def = sema.resolve_macro_call(&macro_call)?;
                    Some(macro_def.to_nav(db))
                }
            } {
-                Some((func_target, name_ref.value.text_range()))
+                Some((func_target, name_ref.syntax().text_range()))
            } else {
                None
            }
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 7c6322cb4..9a1fc0d35 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -1,5 +1,5 @@
 //! FIXME: write short doc here
-use hir::db::AstDatabase;
+use hir::Semantics;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    ast::{self, ArgListOwner},
@@ -7,24 +7,23 @@ use ra_syntax::{
 };
 use test_utils::tested_by;
-use crate::{expand::descend_into_macros, CallInfo, FilePosition, FunctionSignature};
+use crate::{CallInfo, FilePosition, FunctionSignature};
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
-    let file = db.parse_or_expand(position.file_id.into())?;
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id);
+    let file = file.syntax();
    let token = file.token_at_offset(position.offset).next()?;
-    let token = descend_into_macros(db, position.file_id, token);
+    let token = sema.descend_into_macros(token);
    // Find the calling expression and it's NameRef
-    let calling_node = FnCallNode::with_node(&token.value.parent())?;
+    let calling_node = FnCallNode::with_node(&token.parent())?;
-    let name_ref = calling_node.name_ref()?;
-    let name_ref = token.with_value(name_ref.syntax());
-    let analyzer = hir::SourceAnalyzer::new(db, name_ref, None);
    let (mut call_info, has_self) = match &calling_node {
-        FnCallNode::CallExpr(expr) => {
+        FnCallNode::CallExpr(call) => {
            //FIXME: Type::as_callable is broken
-            let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+            let callable_def = sema.type_of_expr(&call.expr()?)?.as_callable()?;
            match callable_def {
                hir::CallableDef::FunctionId(it) => {
                    let fn_def = it.into();
@@ -36,12 +35,12 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
                }
            }
        }
-        FnCallNode::MethodCallExpr(expr) => {
+        FnCallNode::MethodCallExpr(method_call) => {
-            let function = analyzer.resolve_method_call(&expr)?;
+            let function = sema.resolve_method_call(&method_call)?;
            (CallInfo::with_fn(db, function), function.has_self_param(db))
        }
-        FnCallNode::MacroCallExpr(expr) => {
+        FnCallNode::MacroCallExpr(macro_call) => {
-            let macro_def = analyzer.resolve_macro_call(db, name_ref.with_value(&expr))?;
+            let macro_def = sema.resolve_macro_call(&macro_call)?;
            (CallInfo::with_macro(db, macro_def)?, false)
        }
    };
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index 4bdc6ba23..c378c2c62 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -17,7 +17,6 @@ mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
-use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 #[cfg(test)]
@@ -57,8 +56,7 @@ pub use crate::completion::completion_item::{
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
 pub(crate) fn completions(db: &RootDatabase, position: FilePosition) -> Option<Completions> {
-    let original_parse = db.parse(position.file_id);
+    let ctx = CompletionContext::new(db, position)?;
-    let ctx = CompletionContext::new(db, &original_parse, position)?;
    let mut acc = Completions::default();
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 2ca78c927..a6e0158b2 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -16,7 +16,7 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
        _ => return,
    };
-    let receiver_ty = match ctx.analyzer.type_of(ctx.db, &dot_receiver) {
+    let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
        Some(ty) => ty,
        _ => return,
    };
@@ -55,7 +55,7 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
    if let Some(krate) = ctx.module.map(|it| it.krate()) {
        let mut seen_methods = FxHashSet::default();
-        let traits_in_scope = ctx.analyzer.traits_in_scope(ctx.db);
+        let traits_in_scope = ctx.scope().traits_in_scope();
        receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
            if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
                acc.add_function(ctx, func);
diff --git a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
index faadd1e3f..1866d9e6c 100644
--- a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
@@ -5,7 +5,7 @@ use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
    // Show only macros in top level.
    if ctx.is_new_item {
-        ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
+        ctx.scope().process_all_names(&mut |name, res| {
            if let hir::ScopeDef::MacroDef(mac) = res {
                acc.add_macro(ctx, Some(name.to_string()), mac);
            }
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
index 2d7f09a6c..c626e90cc 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -11,7 +11,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
        Some(path) => path.clone(),
        _ => return,
    };
-    let def = match ctx.analyzer.resolve_hir_path(ctx.db, &path) {
+    let def = match ctx.scope().resolve_hir_path(&path) {
        Some(PathResolution::Def(def)) => def,
        _ => return,
    };
@@ -49,7 +49,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
            // FIXME: complete T::AssocType
            let krate = ctx.module.map(|m| m.krate());
            if let Some(krate) = krate {
-                let traits_in_scope = ctx.analyzer.traits_in_scope(ctx.db);
+                let traits_in_scope = ctx.scope().traits_in_scope();
                ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                    match item {
                        hir::AssocItem::Function(func) => {
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index fd03b1c40..c2c6ca002 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -9,7 +9,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    }
    // FIXME: ideally, we should look at the type we are matching against and
    // suggest variants + auto-imports
-    ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
+    ctx.scope().process_all_names(&mut |name, res| {
        let def = match &res {
            hir::ScopeDef::ModuleDef(def) => def,
            _ => return,
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 5470dc291..8a74f993a 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -29,7 +29,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
        dot_receiver.syntax().text().to_string()
    };
-    let receiver_ty = match ctx.analyzer.type_of(ctx.db, &dot_receiver) {
+    let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
        Some(it) => it,
        None => return,
    };
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
index 577c394d2..f98353d76 100644
--- a/crates/ra_ide/src/completion/complete_record_literal.rs
+++ b/crates/ra_ide/src/completion/complete_record_literal.rs
@@ -5,10 +5,7 @@ use crate::completion::{CompletionContext, Completions};
 /// Complete fields in fields literals.
 pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionContext) {
    let (ty, variant) = match ctx.record_lit_syntax.as_ref().and_then(|it| {
-        Some((
+        Some((ctx.sema.type_of_expr(&it.clone().into())?, ctx.sema.resolve_record_literal(it)?))
-            ctx.analyzer.type_of(ctx.db, &it.clone().into())?,
-            ctx.analyzer.resolve_record_literal(it)?,
-        ))
    }) {
        Some(it) => it,
        _ => return,
diff --git a/crates/ra_ide/src/completion/complete_record_pattern.rs b/crates/ra_ide/src/completion/complete_record_pattern.rs
index a56c7e3a1..9bdeae49f 100644
--- a/crates/ra_ide/src/completion/complete_record_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_record_pattern.rs
@@ -4,10 +4,7 @@ use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_record_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    let (ty, variant) = match ctx.record_lit_pat.as_ref().and_then(|it| {
-        Some((
+        Some((ctx.sema.type_of_pat(&it.clone().into())?, ctx.sema.resolve_record_pattern(it)?))
-            ctx.analyzer.type_of_pat(ctx.db, &it.clone().into())?,
-            ctx.analyzer.resolve_record_pattern(it)?,
-        ))
    }) {
        Some(it) => it,
        _ => return,
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index e2ee86dd1..aad016d4a 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -7,9 +7,7 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
        return;
    }
-    ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
+    ctx.scope().process_all_names(&mut |name, res| acc.add_resolution(ctx, name.to_string(), &res));
-        acc.add_resolution(ctx, name.to_string(), &res)
-    });
 }
 #[cfg(test)]
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 83628e35c..9a27c164b 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -64,11 +64,12 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
    if let (Some(trigger), Some(impl_block)) = (trigger, impl_block) {
        match trigger.kind() {
            SyntaxKind::FN_DEF => {
-                for missing_fn in get_missing_impl_items(ctx.db, &ctx.analyzer, &impl_block)
+                for missing_fn in
-                    .iter()
+                    get_missing_impl_items(&ctx.sema, &impl_block).iter().filter_map(|item| {
-                    .filter_map(|item| match item {
+                        match item {
-                        hir::AssocItem::Function(fn_item) => Some(fn_item),
+                            hir::AssocItem::Function(fn_item) => Some(fn_item),
-                        _ => None,
+                            _ => None,
+                        }
                    })
                {
                    add_function_impl(&trigger, acc, ctx, &missing_fn);
@@ -76,11 +77,12 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
            }
            SyntaxKind::TYPE_ALIAS_DEF => {
-                for missing_fn in get_missing_impl_items(ctx.db, &ctx.analyzer, &impl_block)
+                for missing_fn in
-                    .iter()
+                    get_missing_impl_items(&ctx.sema, &impl_block).iter().filter_map(|item| {
-                    .filter_map(|item| match item {
+                        match item {
-                        hir::AssocItem::TypeAlias(type_item) => Some(type_item),
+                            hir::AssocItem::TypeAlias(type_item) => Some(type_item),
-                        _ => None,
+                            _ => None,
+                        }
                    })
                {
                    add_type_alias_impl(&trigger, acc, ctx, &missing_fn);
@@ -88,11 +90,12 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
            }
            SyntaxKind::CONST_DEF => {
-                for missing_fn in get_missing_impl_items(ctx.db, &ctx.analyzer, &impl_block)
+                for missing_fn in
-                    .iter()
+                    get_missing_impl_items(&ctx.sema, &impl_block).iter().filter_map(|item| {
-                    .filter_map(|item| match item {
+                        match item {
-                        hir::AssocItem::Const(const_item) => Some(const_item),
+                            hir::AssocItem::Const(const_item) => Some(const_item),
-                        _ => None,
+                            _ => None,
+                        }
                    })
                {
                    add_const_impl(&trigger, acc, ctx, &missing_fn);
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 8678a3234..81321a897 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -1,9 +1,11 @@
 //! FIXME: write short doc here
+use hir::{Semantics, SemanticsScope};
+use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_covering_element, find_node_at_offset},
-    ast, AstNode, Parse, SourceFile,
+    ast, AstNode, SourceFile,
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, TextRange, TextUnit,
 };
@@ -15,8 +17,8 @@ use crate::FilePosition;
 /// exactly is the cursor, syntax-wise.
 #[derive(Debug)]
 pub(crate) struct CompletionContext<'a> {
+    pub(super) sema: Semantics<'a, RootDatabase>,
    pub(super) db: &'a RootDatabase,
-    pub(super) analyzer: hir::SourceAnalyzer,
    pub(super) offset: TextUnit,
    pub(super) token: SyntaxToken,
    pub(super) module: Option<hir::Module>,
@@ -51,20 +53,26 @@ pub(crate) struct CompletionContext<'a> {
 impl<'a> CompletionContext<'a> {
    pub(super) fn new(
        db: &'a RootDatabase,
-        original_parse: &'a Parse<ast::SourceFile>,
        position: FilePosition,
    ) -> Option<CompletionContext<'a>> {
-        let mut sb = hir::SourceBinder::new(db);
+        let sema = Semantics::new(db);
-        let module = sb.to_module_def(position.file_id);
-        let token =
+        let original_file = sema.parse(position.file_id);
-            original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
-        let analyzer = sb.analyze(
+        // Insert a fake ident to get a valid parse tree. We will use this file
-            hir::InFile::new(position.file_id.into(), &token.parent()),
+        // to determine context, though the original_file will be used for
-            Some(position.offset),
+        // actual completion.
-        );
+        let file_with_fake_ident = {
+            let parse = db.parse(position.file_id);
+            let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
+            parse.reparse(&edit).tree()
+        };
+        let module = sema.to_module_def(position.file_id);
+        let token = original_file.syntax().token_at_offset(position.offset).left_biased()?;
        let mut ctx = CompletionContext {
+            sema,
            db,
-            analyzer,
            token,
            offset: position.offset,
            module,
@@ -87,7 +95,7 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
        };
-        ctx.fill(&original_parse, position.offset);
+        ctx.fill(&original_file, file_with_fake_ident, position.offset);
        Some(ctx)
    }
@@ -100,29 +108,33 @@ impl<'a> CompletionContext<'a> {
        }
    }
-    fn fill(&mut self, original_parse: &'a Parse<ast::SourceFile>, offset: TextUnit) {
+    pub(crate) fn scope(&self) -> SemanticsScope<'_, RootDatabase> {
-        // Insert a fake ident to get a valid parse tree. We will use this file
+        self.sema.scope_at_offset(&self.token.parent(), self.offset)
-        // to determine context, though the original_file will be used for
+    }
-        // actual completion.
-        let file = {
-            let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string());
-            original_parse.reparse(&edit).tree()
-        };
+    fn fill(
+        &mut self,
+        original_file: &ast::SourceFile,
+        file_with_fake_ident: ast::SourceFile,
+        offset: TextUnit,
+    ) {
        // First, let's try to complete a reference to some declaration.
-        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), offset) {
+        if let Some(name_ref) =
+            find_node_at_offset::<ast::NameRef>(file_with_fake_ident.syntax(), offset)
+        {
            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
            // See RFC#1685.
            if is_node::<ast::Param>(name_ref.syntax()) {
                self.is_param = true;
                return;
            }
-            self.classify_name_ref(original_parse.tree(), name_ref);
+            self.classify_name_ref(original_file, name_ref);
        }
        // Otherwise, see if this is a declaration. We can use heuristics to
        // suggest declaration names, see `CompletionKind::Magic`.
-        if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), offset) {
+        if let Some(name) = find_node_at_offset::<ast::Name>(file_with_fake_ident.syntax(), offset)
+        {
            if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
                let parent = bind_pat.syntax().parent();
                if parent.clone().and_then(ast::MatchArm::cast).is_some()
@@ -136,13 +148,12 @@ impl<'a> CompletionContext<'a> {
                return;
            }
            if name.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() {
-                self.record_lit_pat =
+                self.record_lit_pat = find_node_at_offset(original_file.syntax(), self.offset);
-                    find_node_at_offset(original_parse.tree().syntax(), self.offset);
            }
        }
    }
-    fn classify_name_ref(&mut self, original_file: SourceFile, name_ref: ast::NameRef) {
+    fn classify_name_ref(&mut self, original_file: &SourceFile, name_ref: ast::NameRef) {
        self.name_ref_syntax =
            find_node_at_offset(original_file.syntax(), name_ref.syntax().text_range().start());
        let name_range = name_ref.syntax().text_range();
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 9cf86b26d..a52f7fdd9 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -2,7 +2,10 @@
 use std::cell::RefCell;
-use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
+use hir::{
+    diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink},
+    Semantics,
+};
 use itertools::Itertools;
 use ra_db::{RelativePath, SourceDatabase, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
@@ -24,7 +27,7 @@ pub enum Severity {
 pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic> {
    let _p = profile("diagnostics");
-    let mut sb = hir::SourceBinder::new(db);
+    let sema = Semantics::new(db);
    let parse = db.parse(file_id);
    let mut res = Vec::new();
@@ -110,7 +113,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
            fix: Some(fix),
        })
    });
-    if let Some(m) = sb.to_module_def(file_id) {
+    if let Some(m) = sema.to_module_def(file_id) {
        m.diagnostics(db, &mut sink);
    };
    drop(sink);
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index b42cb477e..5afb23764 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 use either::Either;
-use hir::{AssocItem, FieldSource, HasSource, InFile, ModuleSource};
+use hir::{original_range, AssocItem, FieldSource, HasSource, InFile, ModuleSource};
 use ra_db::{FileId, SourceDatabase};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
@@ -11,7 +11,11 @@ use ra_syntax::{
    TextRange,
 };
-use crate::{expand::original_range, references::NameDefinition, FileSymbol};
+use crate::{
+    // expand::original_range,
+    references::NameDefinition,
+    FileSymbol,
+};
 use super::short_label::ShortLabel;
@@ -125,7 +129,7 @@ impl NavigationTarget {
    }
    /// Allows `NavigationTarget` to be created from a `NameOwner`
-    pub(crate) fn from_named(
+    fn from_named(
        db: &RootDatabase,
        node: InFile<&dyn ast::NameOwner>,
        docs: Option<String>,
diff --git a/crates/ra_ide/src/expand.rs b/crates/ra_ide/src/expand.rs
deleted file mode 100644
index 9f3aaa3a3..000000000
--- a/crates/ra_ide/src/expand.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-//! Utilities to work with files, produced by macros.
-use std::iter::successors;
-use hir::{InFile, Origin};
-use ra_db::FileId;
-use ra_ide_db::RootDatabase;
-use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxToken, TextRange};
-use crate::FileRange;
-pub(crate) fn original_range(db: &RootDatabase, node: InFile<&SyntaxNode>) -> FileRange {
-    if let Some((range, Origin::Call)) = original_range_and_origin(db, node) {
-        return range;
-    }
-    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: &RootDatabase,
-    node: InFile<&SyntaxNode>,
-) -> Option<(FileRange, Origin)> {
-    let expansion = node.file_id.expansion_info(db)?;
-    // the input node has only one token ?
-    let single = node.value.first_token()? == node.value.last_token()?;
-    // FIXME: We should handle recurside macro expansions
-    let (range, origin) = node.value.descendants().find_map(|it| {
-        let first = it.first_token()?;
-        let last = it.last_token()?;
-        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;
-        }
-        // FIXME: Add union method in TextRange
-        Some((
-            first.with_value(union_range(first.value.text_range(), last.value.text_range())),
-            first_origin,
-        ))
-    })?;
-    return Some((
-        FileRange { file_id: range.file_id.original_file(db), range: range.value },
-        origin,
-    ));
-    fn union_range(a: TextRange, b: TextRange) -> TextRange {
-        let start = a.start().min(b.start());
-        let end = a.end().max(b.end());
-        TextRange::from_to(start, end)
-    }
-}
-pub(crate) fn descend_into_macros(
-    db: &RootDatabase,
-    file_id: FileId,
-    token: SyntaxToken,
-) -> InFile<SyntaxToken> {
-    let src = InFile::new(file_id.into(), token);
-    let source_analyzer =
-        hir::SourceAnalyzer::new(db, src.with_value(src.value.parent()).as_ref(), None);
-    descend_into_macros_with_analyzer(db, &source_analyzer, src)
-}
-pub(crate) fn descend_into_macros_with_analyzer(
-    db: &RootDatabase,
-    source_analyzer: &hir::SourceAnalyzer,
-    src: InFile<SyntaxToken>,
-) -> InFile<SyntaxToken> {
-    successors(Some(src), |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 exp = source_analyzer.expand(db, token.with_value(&macro_call))?;
-        exp.map_token_down(db, token.as_ref())
-    })
-    .last()
-    .unwrap()
-}
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index af2783bef..f2814e684 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -1,7 +1,6 @@
 //! This modules implements "expand macro" functionality in the IDE
-use hir::db::AstDatabase;
+use hir::Semantics;
-use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_node_at_offset, replace_descendants},
@@ -17,13 +16,12 @@ pub struct ExpandedMacro {
 }
 pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<ExpandedMacro> {
-    let parse = db.parse(position.file_id);
+    let sema = Semantics::new(db);
-    let file = parse.tree();
+    let file = sema.parse(position.file_id);
    let name_ref = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset)?;
    let mac = name_ref.syntax().ancestors().find_map(ast::MacroCall::cast)?;
-    let source = hir::InFile::new(position.file_id.into(), mac.syntax());
+    let expanded = expand_macro_recur(&sema, &mac)?;
-    let expanded = expand_macro_recur(db, source, source.with_value(&mac))?;
    // FIXME:
    // macro expansion may lose all white space information
@@ -33,21 +31,16 @@ pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<
 }
 fn expand_macro_recur(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
-    source: hir::InFile<&SyntaxNode>,
+    macro_call: &ast::MacroCall,
-    macro_call: hir::InFile<&ast::MacroCall>,
 ) -> Option<SyntaxNode> {
-    let analyzer = hir::SourceAnalyzer::new(db, source, None);
+    let mut expanded = sema.expand(macro_call)?;
-    let expansion = analyzer.expand(db, macro_call)?;
-    let macro_file_id = expansion.file_id();
-    let mut expanded: SyntaxNode = db.parse_or_expand(macro_file_id)?;
    let children = expanded.descendants().filter_map(ast::MacroCall::cast);
    let mut replaces: FxHashMap<SyntaxElement, SyntaxElement> = FxHashMap::default();
    for child in children.into_iter() {
-        let node = hir::InFile::new(macro_file_id, &child);
+        if let Some(new_node) = expand_macro_recur(sema, &child) {
-        if let Some(new_node) = expand_macro_recur(db, source, node) {
            // Replace the whole node if it is root
            // `replace_descendants` will not replace the parent node
            // but `SyntaxNode::descendants include itself
@@ -120,10 +113,12 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::mock_analysis::analysis_and_position;
    use insta::assert_snapshot;
+    use crate::mock_analysis::analysis_and_position;
+    use super::*;
    fn check_expand_macro(fixture: &str) -> ExpandedMacro {
        let (analysis, pos) = analysis_and_position(fixture);
        analysis.expand_macro(pos).unwrap().unwrap()
diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs
index 4757d8e22..f5a063351 100644
--- a/crates/ra_ide/src/extend_selection.rs
+++ b/crates/ra_ide/src/extend_selection.rs
@@ -2,26 +2,26 @@
 use std::iter::successors;
-use hir::db::AstDatabase;
+use hir::Semantics;
-use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
-    algo::find_covering_element,
+    algo::{self, find_covering_element, skip_trivia_token},
    ast::{self, AstNode, AstToken},
-    Direction, NodeOrToken, SyntaxElement,
+    Direction, NodeOrToken,
    SyntaxKind::{self, *},
    SyntaxNode, SyntaxToken, TextRange, TextUnit, TokenAtOffset, T,
 };
-use crate::{expand::descend_into_macros, FileId, FileRange};
+use crate::FileRange;
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
-    let src = db.parse(frange.file_id).tree();
+    let sema = Semantics::new(db);
-    try_extend_selection(db, src.syntax(), frange).unwrap_or(frange.range)
+    let src = sema.parse(frange.file_id);
+    try_extend_selection(&sema, src.syntax(), frange).unwrap_or(frange.range)
 }
 fn try_extend_selection(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    root: &SyntaxNode,
    frange: FileRange,
 ) -> Option<TextRange> {
@@ -86,7 +86,7 @@ fn try_extend_selection(
    // if we are in single token_tree, we maybe live in macro or attr
    if node.kind() == TOKEN_TREE {
        if let Some(macro_call) = node.ancestors().find_map(ast::MacroCall::cast) {
-            if let Some(range) = extend_tokens_from_range(db, frange.file_id, macro_call, range) {
+            if let Some(range) = extend_tokens_from_range(sema, macro_call, range) {
                return Some(range);
            }
        }
@@ -96,7 +96,7 @@ fn try_extend_selection(
        return Some(node.text_range());
    }
-    let node = shallowest_node(&node.into()).unwrap();
+    let node = shallowest_node(&node.into());
    if node.parent().map(|n| list_kinds.contains(&n.kind())) == Some(true) {
        if let Some(range) = extend_list_item(&node) {
@@ -108,8 +108,7 @@ fn try_extend_selection(
 }
 fn extend_tokens_from_range(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
-    file_id: FileId,
    macro_call: ast::MacroCall,
    original_range: TextRange,
 ) -> Option<TextRange> {
@@ -119,54 +118,50 @@ fn extend_tokens_from_range(
        NodeOrToken::Token(it) => (it.clone(), it),
    };
-    let mut first_token = skip_whitespace(first_token, Direction::Next)?;
+    let mut first_token = skip_trivia_token(first_token, Direction::Next)?;
-    let mut last_token = skip_whitespace(last_token, Direction::Prev)?;
+    let mut last_token = skip_trivia_token(last_token, Direction::Prev)?;
    while !first_token.text_range().is_subrange(&original_range) {
-        first_token = skip_whitespace(first_token.next_token()?, Direction::Next)?;
+        first_token = skip_trivia_token(first_token.next_token()?, Direction::Next)?;
    }
    while !last_token.text_range().is_subrange(&original_range) {
-        last_token = skip_whitespace(last_token.prev_token()?, Direction::Prev)?;
+        last_token = skip_trivia_token(last_token.prev_token()?, Direction::Prev)?;
    }
    // compute original mapped token range
-    let expanded = {
+    let extended = {
-        let first_node = descend_into_macros(db, file_id, first_token.clone());
+        let fst_expanded = sema.descend_into_macros(first_token.clone());
-        let first_node = first_node.map(|it| it.text_range());
+        let lst_expanded = sema.descend_into_macros(last_token.clone());
+        let mut lca = algo::least_common_ancestor(&fst_expanded.parent(), &lst_expanded.parent())?;
-        let last_node = descend_into_macros(db, file_id, last_token.clone());
+        lca = shallowest_node(&lca);
-        if last_node.file_id == file_id.into() || first_node.file_id != last_node.file_id {
+        if lca.first_token() == Some(fst_expanded) && lca.last_token() == Some(lst_expanded) {
-            return None;
+            lca = lca.parent()?;
        }
-        first_node.map(|it| union_range(it, last_node.value.text_range()))
+        lca
    };
    // Compute parent node range
-    let src = db.parse_or_expand(expanded.file_id)?;
+    let validate = |token: &SyntaxToken| {
-    let parent = shallowest_node(&find_covering_element(&src, expanded.value))?.parent()?;
+        let expanded = sema.descend_into_macros(token.clone());
+        algo::least_common_ancestor(&extended, &expanded.parent()).as_ref() == Some(&extended)
-    let validate = |token: SyntaxToken| {
-        let node = descend_into_macros(db, file_id, token.clone());
-        if node.file_id == expanded.file_id
-            && node.value.text_range().is_subrange(&parent.text_range())
-        {
-            Some(token)
-        } else {
-            None
-        }
    };
    // Find the first and last text range under expanded parent
    let first = successors(Some(first_token), |token| {
-        validate(skip_whitespace(token.prev_token()?, Direction::Prev)?)
+        let token = token.prev_token()?;
+        skip_trivia_token(token, Direction::Prev)
    })
+    .take_while(validate)
    .last()?;
    let last = successors(Some(last_token), |token| {
-        validate(skip_whitespace(token.next_token()?, Direction::Next)?)
+        let token = token.next_token()?;
+        skip_trivia_token(token, Direction::Next)
    })
+    .take_while(validate)
    .last()?;
-    let range = union_range(first.text_range(), last.text_range());
+    let range = first.text_range().extend_to(&last.text_range());
    if original_range.is_subrange(&range) && original_range != range {
        Some(range)
    } else {
@@ -174,25 +169,9 @@ fn extend_tokens_from_range(
    }
 }
-fn skip_whitespace(mut token: SyntaxToken, direction: Direction) -> Option<SyntaxToken> {
-    while token.kind() == WHITESPACE {
-        token = match direction {
-            Direction::Next => token.next_token()?,
-            Direction::Prev => token.prev_token()?,
-        }
-    }
-    Some(token)
-}
-fn union_range(range: TextRange, r: TextRange) -> TextRange {
-    let start = range.start().min(r.start());
-    let end = range.end().max(r.end());
-    TextRange::from_to(start, end)
-}
 /// Find the shallowest node with same range, which allows us to traverse siblings.
-fn shallowest_node(node: &SyntaxElement) -> Option<SyntaxNode> {
+fn shallowest_node(node: &SyntaxNode) -> SyntaxNode {
-    node.ancestors().take_while(|n| n.text_range() == node.text_range()).last()
+    node.ancestors().take_while(|n| n.text_range() == node.text_range()).last().unwrap()
 }
 fn extend_single_word_in_comment_or_string(
@@ -334,10 +313,12 @@ fn adj_comments(comment: &ast::Comment, dir: Direction) -> ast::Comment {
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::mock_analysis::single_file;
    use test_utils::extract_offset;
+    use crate::mock_analysis::single_file;
+    use super::*;
    fn do_check(before: &str, afters: &[&str]) {
        let (cursor, before) = extract_offset(before);
        let (analysis, file_id) = single_file(&before);
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index feff1ec3f..6053c1bb6 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
-use hir::{db::AstDatabase, InFile, SourceBinder};
+use hir::Semantics;
-use ra_ide_db::{symbol_index, RootDatabase};
+use ra_ide_db::{defs::classify_name, symbol_index, RootDatabase};
 use ra_syntax::{
    ast::{self},
    match_ast, AstNode,
@@ -11,8 +11,7 @@ use ra_syntax::{
 use crate::{
    display::{ToNav, TryToNav},
-    expand::descend_into_macros,
+    references::classify_name_ref,
-    references::{classify_name, classify_name_ref},
    FilePosition, NavigationTarget, RangeInfo,
 };
@@ -20,18 +19,18 @@ pub(crate) fn goto_definition(
    db: &RootDatabase,
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let file = db.parse_or_expand(position.file_id.into())?;
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id).syntax().clone();
    let original_token = pick_best(file.token_at_offset(position.offset))?;
-    let token = descend_into_macros(db, position.file_id, original_token.clone());
+    let token = sema.descend_into_macros(original_token.clone());
-    let mut sb = SourceBinder::new(db);
    let nav_targets = match_ast! {
-        match (token.value.parent()) {
+        match (token.parent()) {
            ast::NameRef(name_ref) => {
-                reference_definition(&mut sb, token.with_value(&name_ref)).to_vec()
+                reference_definition(&sema, &name_ref).to_vec()
            },
            ast::Name(name) => {
-                name_definition(&mut sb, token.with_value(&name))?
+                name_definition(&sema, &name)?
            },
            _ => return None,
        }
@@ -68,33 +67,33 @@ impl ReferenceResult {
 }
 pub(crate) fn reference_definition(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    name_ref: InFile<&ast::NameRef>,
+    name_ref: &ast::NameRef,
 ) -> ReferenceResult {
    use self::ReferenceResult::*;
-    let name_kind = classify_name_ref(sb, name_ref);
+    let name_kind = classify_name_ref(sema, name_ref);
    if let Some(def) = name_kind {
-        return match def.try_to_nav(sb.db) {
+        return match def.try_to_nav(sema.db) {
            Some(nav) => ReferenceResult::Exact(nav),
            None => ReferenceResult::Approximate(Vec::new()),
        };
    }
    // Fallback index based approach:
-    let navs = symbol_index::index_resolve(sb.db, name_ref.value)
+    let navs = symbol_index::index_resolve(sema.db, name_ref)
        .into_iter()
-        .map(|s| s.to_nav(sb.db))
+        .map(|s| s.to_nav(sema.db))
        .collect();
    Approximate(navs)
 }
 fn name_definition(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    name: InFile<&ast::Name>,
+    name: &ast::Name,
 ) -> Option<Vec<NavigationTarget>> {
-    let def = classify_name(sb, name)?;
+    let def = classify_name(sema, name)?;
-    let nav = def.try_to_nav(sb.db)?;
+    let nav = def.try_to_nav(sema.db)?;
    Some(vec![nav])
 }
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index 69940fc36..869a4708b 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -1,31 +1,31 @@
 //! FIXME: write short doc here
-use hir::db::AstDatabase;
 use ra_ide_db::RootDatabase;
-use ra_syntax::{ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
+use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
-use crate::{
+use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
-    display::ToNav, expand::descend_into_macros, FilePosition, NavigationTarget, RangeInfo,
-};
 pub(crate) fn goto_type_definition(
    db: &RootDatabase,
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let file = db.parse_or_expand(position.file_id.into())?;
+    let sema = hir::Semantics::new(db);
-    let token = pick_best(file.token_at_offset(position.offset))?;
-    let token = descend_into_macros(db, position.file_id, token);
+    let file: ast::SourceFile = sema.parse(position.file_id);
+    let token: SyntaxToken = pick_best(file.syntax().token_at_offset(position.offset))?;
-    let node = token
+    let token: SyntaxToken = sema.descend_into_macros(token);
-        .value
-        .ancestors()
+    let (ty, node) = sema.ancestors_with_macros(token.parent()).find_map(|node| {
-        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
+        let ty = match_ast! {
+            match node {
-    let analyzer = hir::SourceAnalyzer::new(db, token.with_value(&node), None);
+                ast::Expr(expr) => { sema.type_of_expr(&expr)? },
+                ast::Pat(pat) => { sema.type_of_pat(&pat)? },
+                _ => { return None },
+            }
+        };
-    let ty: hir::Type = ast::Expr::cast(node.clone())
+        Some((ty, node))
-        .and_then(|e| analyzer.type_of(db, &e))
+    })?;
-        .or_else(|| ast::Pat::cast(node.clone()).and_then(|p| analyzer.type_of_pat(db, &p)))?;
    let adt_def = ty.autoderef(db).find_map(|ty| ty.as_adt())?;
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 1c6ca36df..177038e20 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,8 +1,10 @@
 //! FIXME: write short doc here
-use hir::{db::AstDatabase, Adt, HasSource, HirDisplay, SourceBinder};
+use hir::{Adt, HasSource, HirDisplay, Semantics};
-use ra_db::SourceDatabase;
+use ra_ide_db::{
-use ra_ide_db::{defs::NameDefinition, RootDatabase};
+    defs::{classify_name, NameDefinition},
+    RootDatabase,
+};
 use ra_syntax::{
    algo::find_covering_element,
    ast::{self, DocCommentsOwner},
@@ -13,8 +15,7 @@ use ra_syntax::{
 use crate::{
    display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
-    expand::{descend_into_macros, original_range},
+    references::classify_name_ref,
-    references::{classify_name, classify_name_ref},
    FilePosition, FileRange, RangeInfo,
 };
@@ -143,25 +144,25 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: NameDefinition) -> Option<S
 }
 pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
-    let file = db.parse_or_expand(position.file_id.into())?;
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id).syntax().clone();
    let token = pick_best(file.token_at_offset(position.offset))?;
-    let token = descend_into_macros(db, position.file_id, token);
+    let token = sema.descend_into_macros(token);
    let mut res = HoverResult::new();
-    let mut sb = SourceBinder::new(db);
    if let Some((node, name_kind)) = match_ast! {
-        match (token.value.parent()) {
+        match (token.parent()) {
            ast::NameRef(name_ref) => {
-                classify_name_ref(&mut sb, token.with_value(&name_ref)).map(|d| (name_ref.syntax().clone(), d))
+                classify_name_ref(&sema, &name_ref).map(|d| (name_ref.syntax().clone(), d))
            },
            ast::Name(name) => {
-                classify_name(&mut sb, token.with_value(&name)).map(|d| (name.syntax().clone(), d))
+                classify_name(&sema, &name).map(|d| (name.syntax().clone(), d))
            },
            _ => None,
        }
    } {
-        let range = original_range(db, token.with_value(&node)).range;
+        let range = sema.original_range(&node).range;
        res.extend(hover_text_from_name_kind(db, name_kind));
        if !res.is_empty() {
@@ -170,11 +171,14 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
    }
    let node = token
-        .value
        .ancestors()
        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
-    let frange = original_range(db, token.with_value(&node));
+    // FIXME: Currently `hover::typeof` do not work inside
+    // macro expansion such that if the hover range is pointing to
+    // a string literal, the following type_of will return None.
+    // See also `test_hover_through_literal_string_in_macro`
+    let frange = sema.original_range(&node);
    res.extend(type_of(db, frange).map(rust_code_markup));
    if res.is_empty() {
        return None;
@@ -197,19 +201,17 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
 }
 pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
-    let parse = db.parse(frange.file_id);
+    let sema = Semantics::new(db);
-    let leaf_node = find_covering_element(parse.tree().syntax(), frange.range);
+    let source_file = sema.parse(frange.file_id);
+    let leaf_node = find_covering_element(source_file.syntax(), frange.range);
    // if we picked identifier, expand to pattern/expression
    let node = leaf_node
        .ancestors()
        .take_while(|it| it.text_range() == leaf_node.text_range())
        .find(|it| ast::Expr::cast(it.clone()).is_some() || ast::Pat::cast(it.clone()).is_some())?;
-    let analyzer =
+    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| sema.type_of_expr(&e)) {
-        hir::SourceAnalyzer::new(db, hir::InFile::new(frange.file_id.into(), &node), None);
-    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
-    {
        ty
-    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| analyzer.type_of_pat(db, &p)) {
+    } else if let Some(ty) = ast::Pat::cast(node).and_then(|p| sema.type_of_pat(&p)) {
        ty
    } else {
        return None;
@@ -219,11 +221,12 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
 #[cfg(test)]
 mod tests {
+    use ra_db::FileLoader;
+    use ra_syntax::TextRange;
    use crate::mock_analysis::{
        analysis_and_position, single_file_with_position, single_file_with_range,
    };
-    use ra_db::FileLoader;
-    use ra_syntax::TextRange;
    fn trim_markup(s: &str) -> &str {
        s.trim_start_matches("```rust\n").trim_end_matches("\n```")
@@ -251,6 +254,11 @@ mod tests {
        content[hover.range].to_string()
    }
+    fn check_hover_no_result(fixture: &str) {
+        let (analysis, position) = analysis_and_position(fixture);
+        assert!(analysis.hover(position).unwrap().is_none());
+    }
    #[test]
    fn hover_shows_type_of_an_expression() {
        let (analysis, position) = single_file_with_position(
@@ -755,6 +763,45 @@ fn func(foo: i32) { if true { <|>foo; }; }
    }
    #[test]
+    fn test_hover_through_expr_in_macro_recursive() {
+        let hover_on = check_hover_result(
+            "
+            //- /lib.rs
+            macro_rules! id_deep {
+                ($($tt:tt)*) => { $($tt)* }
+            }
+            macro_rules! id {
+                ($($tt:tt)*) => { id_deep!($($tt)*) }
+            }
+            fn foo(bar:u32) {
+                let a = id!(ba<|>r);
+            }
+            ",
+            &["u32"],
+        );
+        assert_eq!(hover_on, "bar")
+    }
+    #[test]
+    fn test_hover_through_literal_string_in_macro() {
+        // FIXME: Currently `hover::type_of` do not work inside
+        // macro expansion
+        check_hover_no_result(
+            r#"
+            //- /lib.rs
+            macro_rules! arr {
+                ($($tt:tt)*) => { [$($tt)*)] }
+            }
+            fn foo() {
+                let mastered_for_itunes = "";
+                let _ = arr!("Tr<|>acks", &mastered_for_itunes);
+            }
+            "#,
+        );
+    }
+    #[test]
    fn test_hover_non_ascii_space_doc() {
        check_hover_result(
            "
diff --git a/crates/ra_ide/src/impls.rs b/crates/ra_ide/src/impls.rs
index 64a2dadc8..bf82b2a16 100644
--- a/crates/ra_ide/src/impls.rs
+++ b/crates/ra_ide/src/impls.rs
@@ -1,7 +1,6 @@
 //! FIXME: write short doc here
-use hir::{Crate, ImplBlock, SourceBinder};
+use hir::{Crate, ImplBlock, Semantics};
-use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
@@ -11,21 +10,21 @@ pub(crate) fn goto_implementation(
    db: &RootDatabase,
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let parse = db.parse(position.file_id);
+    let sema = Semantics::new(db);
-    let syntax = parse.tree().syntax().clone();
+    let source_file = sema.parse(position.file_id);
-    let mut sb = SourceBinder::new(db);
+    let syntax = source_file.syntax().clone();
-    let krate = sb.to_module_def(position.file_id)?.krate();
+    let krate = sema.to_module_def(position.file_id)?.krate();
    if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(&syntax, position.offset) {
        return Some(RangeInfo::new(
            nominal_def.syntax().text_range(),
-            impls_for_def(&mut sb, position, &nominal_def, krate)?,
+            impls_for_def(&sema, &nominal_def, krate)?,
        ));
    } else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(&syntax, position.offset) {
        return Some(RangeInfo::new(
            trait_def.syntax().text_range(),
-            impls_for_trait(&mut sb, position, &trait_def, krate)?,
+            impls_for_trait(&sema, &trait_def, krate)?,
        ));
    }
@@ -33,49 +32,37 @@ pub(crate) fn goto_implementation(
 }
 fn impls_for_def(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
    node: &ast::NominalDef,
    krate: Crate,
 ) -> Option<Vec<NavigationTarget>> {
    let ty = match node {
-        ast::NominalDef::StructDef(def) => {
+        ast::NominalDef::StructDef(def) => sema.to_def(def)?.ty(sema.db),
-            let src = hir::InFile { file_id: position.file_id.into(), value: def.clone() };
+        ast::NominalDef::EnumDef(def) => sema.to_def(def)?.ty(sema.db),
-            sb.to_def(src)?.ty(sb.db)
+        ast::NominalDef::UnionDef(def) => sema.to_def(def)?.ty(sema.db),
-        }
-        ast::NominalDef::EnumDef(def) => {
-            let src = hir::InFile { file_id: position.file_id.into(), value: def.clone() };
-            sb.to_def(src)?.ty(sb.db)
-        }
-        ast::NominalDef::UnionDef(def) => {
-            let src = hir::InFile { file_id: position.file_id.into(), value: def.clone() };
-            sb.to_def(src)?.ty(sb.db)
-        }
    };
-    let impls = ImplBlock::all_in_crate(sb.db, krate);
+    let impls = ImplBlock::all_in_crate(sema.db, krate);
    Some(
        impls
            .into_iter()
-            .filter(|impl_block| ty.is_equal_for_find_impls(&impl_block.target_ty(sb.db)))
+            .filter(|impl_block| ty.is_equal_for_find_impls(&impl_block.target_ty(sema.db)))
-            .map(|imp| imp.to_nav(sb.db))
+            .map(|imp| imp.to_nav(sema.db))
            .collect(),
    )
 }
 fn impls_for_trait(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
    node: &ast::TraitDef,
    krate: Crate,
 ) -> Option<Vec<NavigationTarget>> {
-    let src = hir::InFile { file_id: position.file_id.into(), value: node.clone() };
+    let tr = sema.to_def(node)?;
-    let tr = sb.to_def(src)?;
-    let impls = ImplBlock::for_trait(sb.db, krate, tr);
+    let impls = ImplBlock::for_trait(sema.db, krate, tr);
-    Some(impls.into_iter().map(|imp| imp.to_nav(sb.db)).collect())
+    Some(impls.into_iter().map(|imp| imp.to_nav(sema.db)).collect())
 }
 #[cfg(test)]
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index a484dfdeb..35e3f782d 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,12 +1,11 @@
 //! FIXME: write short doc here
-use hir::{HirDisplay, SourceAnalyzer, SourceBinder};
+use hir::{Adt, HirDisplay, Semantics, Type};
-use once_cell::unsync::Lazy;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
    ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, SmolStr, SourceFile, SyntaxNode, TextRange,
+    match_ast, SmolStr, SyntaxNode, TextRange,
 };
 use crate::{FileId, FunctionSignature};
@@ -27,42 +26,38 @@ pub struct InlayHint {
 pub(crate) fn inlay_hints(
    db: &RootDatabase,
    file_id: FileId,
-    file: &SourceFile,
    max_inlay_hint_length: Option<usize>,
 ) -> Vec<InlayHint> {
-    let mut sb = SourceBinder::new(db);
+    let sema = Semantics::new(db);
+    let file = sema.parse(file_id);
    let mut res = Vec::new();
    for node in file.syntax().descendants() {
-        get_inlay_hints(&mut res, &mut sb, file_id, &node, max_inlay_hint_length);
+        get_inlay_hints(&mut res, &sema, &node, max_inlay_hint_length);
    }
    res
 }
 fn get_inlay_hints(
    acc: &mut Vec<InlayHint>,
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    file_id: FileId,
    node: &SyntaxNode,
    max_inlay_hint_length: Option<usize>,
 ) -> Option<()> {
    let _p = profile("get_inlay_hints");
-    let db = sb.db;
+    let db = sema.db;
-    let analyzer = Lazy::new(move || sb.analyze(hir::InFile::new(file_id.into(), node), None));
    match_ast! {
        match node {
            ast::CallExpr(it) => {
-                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+                get_param_name_hints(acc, sema, ast::Expr::from(it));
            },
            ast::MethodCallExpr(it) => {
-                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+                get_param_name_hints(acc, sema, ast::Expr::from(it));
            },
            ast::BindPat(it) => {
-                if should_not_display_type_hint(&it) {
+                let pat = ast::Pat::from(it.clone());
-                    return None;
+                let ty = sema.type_of_pat(&pat)?;
-                }
-                let pat = ast::Pat::from(it);
+                if should_not_display_type_hint(db, &it, &ty) {
-                let ty = analyzer.type_of_pat(db, &pat)?;
-                if ty.is_unknown() {
                    return None;
                }
@@ -80,7 +75,24 @@ fn get_inlay_hints(
    Some(())
 }
-fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
+fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
+    if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
+        let pat_text = bind_pat.syntax().to_string();
+        enum_data
+            .variants(db)
+            .into_iter()
+            .map(|variant| variant.name(db).to_string())
+            .any(|enum_name| enum_name == pat_text)
+    } else {
+        false
+    }
+}
+fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
+    if pat_ty.is_unknown() {
+        return true;
+    }
    for node in bind_pat.syntax().ancestors() {
        match_ast! {
            match node {
@@ -90,6 +102,17 @@ fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
                ast::Param(it) => {
                    return it.ascribed_type().is_some()
                },
+                ast::MatchArm(_it) => {
+                    return pat_is_enum_variant(db, bind_pat, pat_ty);
+                },
+                ast::IfExpr(it) => {
+                    return it.condition().and_then(|condition| condition.pat()).is_some()
+                        && pat_is_enum_variant(db, bind_pat, pat_ty);
+                },
+                ast::WhileExpr(it) => {
+                    return it.condition().and_then(|condition| condition.pat()).is_some()
+                        && pat_is_enum_variant(db, bind_pat, pat_ty);
+                },
                _ => (),
            }
        }
@@ -99,8 +122,7 @@ fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
 fn get_param_name_hints(
    acc: &mut Vec<InlayHint>,
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
-    analyzer: &SourceAnalyzer,
    expr: ast::Expr,
 ) -> Option<()> {
    let args = match &expr {
@@ -112,20 +134,19 @@ fn get_param_name_hints(
    // we need args len to determine whether to skip or not the &self parameter
    .collect::<Vec<_>>();
-    let fn_signature = get_fn_signature(db, analyzer, &expr)?;
+    let fn_signature = get_fn_signature(sema, &expr)?;
    let n_params_to_skip =
        if fn_signature.has_self_param && fn_signature.parameter_names.len() > args.len() {
            1
        } else {
            0
        };
-    let parameters = fn_signature.parameter_names.iter().skip(n_params_to_skip);
+    let hints = fn_signature
+        .parameter_names
-    let hints = parameters
+        .iter()
+        .skip(n_params_to_skip)
        .zip(args)
-        .filter(|(param, arg)| {
+        .filter(|(param, arg)| should_show_param_hint(&fn_signature, param, &arg))
-            should_show_param_hint(&fn_signature, param, &arg.syntax().to_string())
-        })
        .map(|(param_name, arg)| InlayHint {
            range: arg.syntax().text_range(),
            kind: InlayKind::ParameterHint,
@@ -139,8 +160,9 @@ fn get_param_name_hints(
 fn should_show_param_hint(
    fn_signature: &FunctionSignature,
    param_name: &str,
-    argument_string: &str,
+    argument: &ast::Expr,
 ) -> bool {
+    let argument_string = argument.syntax().to_string();
    if param_name.is_empty() || argument_string.ends_with(param_name) {
        return false;
    }
@@ -158,28 +180,26 @@ fn should_show_param_hint(
    true
 }
-fn get_fn_signature(
+fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<FunctionSignature> {
-    db: &RootDatabase,
-    analyzer: &SourceAnalyzer,
-    expr: &ast::Expr,
-) -> Option<FunctionSignature> {
    match expr {
        ast::Expr::CallExpr(expr) => {
            // FIXME: Type::as_callable is broken for closures
-            let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+            let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
            match callable_def {
                hir::CallableDef::FunctionId(it) => {
-                    Some(FunctionSignature::from_hir(db, it.into()))
+                    Some(FunctionSignature::from_hir(sema.db, it.into()))
+                }
+                hir::CallableDef::StructId(it) => {
+                    FunctionSignature::from_struct(sema.db, it.into())
                }
-                hir::CallableDef::StructId(it) => FunctionSignature::from_struct(db, it.into()),
                hir::CallableDef::EnumVariantId(it) => {
-                    FunctionSignature::from_enum_variant(db, it.into())
+                    FunctionSignature::from_enum_variant(sema.db, it.into())
                }
            }
        }
        ast::Expr::MethodCallExpr(expr) => {
-            let fn_def = analyzer.resolve_method_call(&expr)?;
+            let fn_def = sema.resolve_method_call(&expr)?;
-            Some(FunctionSignature::from_hir(db, fn_def))
+            Some(FunctionSignature::from_hir(sema.db, fn_def))
        }
        _ => None,
    }
@@ -440,75 +460,77 @@ struct Test {
    b: u8,
 }
+use CustomOption::*;
 fn main() {
-    let test = CustomOption::Some(Test { a: CustomOption::Some(3), b: 1 });
+    let test = Some(Test { a: Some(3), b: 1 });
-    if let CustomOption::None = &test {};
+    if let None = &test {};
    if let test = &test {};
-    if let CustomOption::Some(test) = &test {};
+    if let Some(test) = &test {};
-    if let CustomOption::Some(Test { a, b }) = &test {};
+    if let Some(Test { a, b }) = &test {};
-    if let CustomOption::Some(Test { a: x, b: y }) = &test {};
+    if let Some(Test { a: x, b: y }) = &test {};
-    if let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
+    if let Some(Test { a: Some(x), b: y }) = &test {};
-    if let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
+    if let Some(Test { a: None, b: y }) = &test {};
-    if let CustomOption::Some(Test { b: y, .. }) = &test {};
+    if let Some(Test { b: y, .. }) = &test {};
-    if test == CustomOption::None {}
+    if test == None {}
 }"#,
        );
        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
        [
            InlayHint {
-                range: [166; 170),
+                range: [188; 192),
                kind: TypeHint,
                label: "CustomOption<Test>",
            },
            InlayHint {
-                range: [287; 291),
+                range: [267; 271),
                kind: TypeHint,
                label: "&CustomOption<Test>",
            },
            InlayHint {
-                range: [334; 338),
+                range: [300; 304),
                kind: TypeHint,
                label: "&Test",
            },
            InlayHint {
-                range: [389; 390),
+                range: [341; 342),
                kind: TypeHint,
                label: "&CustomOption<u32>",
            },
            InlayHint {
-                range: [392; 393),
+                range: [344; 345),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [449; 450),
+                range: [387; 388),
                kind: TypeHint,
                label: "&CustomOption<u32>",
            },
            InlayHint {
-                range: [455; 456),
+                range: [393; 394),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [531; 532),
+                range: [441; 442),
                kind: TypeHint,
                label: "&u32",
            },
            InlayHint {
-                range: [538; 539),
+                range: [448; 449),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [618; 619),
+                range: [500; 501),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [675; 676),
+                range: [543; 544),
                kind: TypeHint,
                label: "&u8",
            },
@@ -533,75 +555,77 @@ struct Test {
    b: u8,
 }
+use CustomOption::*;
 fn main() {
-    let test = CustomOption::Some(Test { a: CustomOption::Some(3), b: 1 });
+    let test = Some(Test { a: Some(3), b: 1 });
-    while let CustomOption::None = &test {};
+    while let None = &test {};
    while let test = &test {};
-    while let CustomOption::Some(test) = &test {};
+    while let Some(test) = &test {};
-    while let CustomOption::Some(Test { a, b }) = &test {};
+    while let Some(Test { a, b }) = &test {};
-    while let CustomOption::Some(Test { a: x, b: y }) = &test {};
+    while let Some(Test { a: x, b: y }) = &test {};
-    while let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
+    while let Some(Test { a: Some(x), b: y }) = &test {};
-    while let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
+    while let Some(Test { a: None, b: y }) = &test {};
-    while let CustomOption::Some(Test { b: y, .. }) = &test {};
+    while let Some(Test { b: y, .. }) = &test {};
-    while test == CustomOption::None {}
+    while test == None {}
 }"#,
        );
        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
        [
            InlayHint {
-                range: [166; 170),
+                range: [188; 192),
                kind: TypeHint,
                label: "CustomOption<Test>",
            },
            InlayHint {
-                range: [293; 297),
+                range: [273; 277),
                kind: TypeHint,
                label: "&CustomOption<Test>",
            },
            InlayHint {
-                range: [343; 347),
+                range: [309; 313),
                kind: TypeHint,
                label: "&Test",
            },
            InlayHint {
-                range: [401; 402),
+                range: [353; 354),
                kind: TypeHint,
                label: "&CustomOption<u32>",
            },
            InlayHint {
-                range: [404; 405),
+                range: [356; 357),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [464; 465),
+                range: [402; 403),
                kind: TypeHint,
                label: "&CustomOption<u32>",
            },
            InlayHint {
-                range: [470; 471),
+                range: [408; 409),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [549; 550),
+                range: [459; 460),
                kind: TypeHint,
                label: "&u32",
            },
            InlayHint {
-                range: [556; 557),
+                range: [466; 467),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [639; 640),
+                range: [521; 522),
                kind: TypeHint,
                label: "&u8",
            },
            InlayHint {
-                range: [699; 700),
+                range: [567; 568),
                kind: TypeHint,
                label: "&u8",
            },
@@ -626,16 +650,18 @@ struct Test {
    b: u8,
 }
+use CustomOption::*;
 fn main() {
-    match CustomOption::Some(Test { a: CustomOption::Some(3), b: 1 }) {
+    match Some(Test { a: Some(3), b: 1 }) {
-        CustomOption::None => (),
+        None => (),
        test => (),
-        CustomOption::Some(test) => (),
+        Some(test) => (),
-        CustomOption::Some(Test { a, b }) => (),
+        Some(Test { a, b }) => (),
-        CustomOption::Some(Test { a: x, b: y }) => (),
+        Some(Test { a: x, b: y }) => (),
-        CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) => (),
+        Some(Test { a: Some(x), b: y }) => (),
-        CustomOption::Some(Test { a: CustomOption::None, b: y }) => (),
+        Some(Test { a: None, b: y }) => (),
-        CustomOption::Some(Test { b: y, .. }) => (),
+        Some(Test { b: y, .. }) => (),
        _ => {}
    }
 }"#,
@@ -644,52 +670,52 @@ fn main() {
        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
        [
            InlayHint {
-                range: [272; 276),
+                range: [252; 256),
                kind: TypeHint,
                label: "CustomOption<Test>",
            },
            InlayHint {
-                range: [311; 315),
+                range: [277; 281),
                kind: TypeHint,
                label: "Test",
            },
            InlayHint {
-                range: [358; 359),
+                range: [310; 311),
                kind: TypeHint,
                label: "CustomOption<u32>",
            },
            InlayHint {
-                range: [361; 362),
+                range: [313; 314),
                kind: TypeHint,
                label: "u8",
            },
            InlayHint {
-                range: [410; 411),
+                range: [348; 349),
                kind: TypeHint,
                label: "CustomOption<u32>",
            },
            InlayHint {
-                range: [416; 417),
+                range: [354; 355),
                kind: TypeHint,
                label: "u8",
            },
            InlayHint {
-                range: [484; 485),
+                range: [394; 395),
                kind: TypeHint,
                label: "u32",
            },
            InlayHint {
-                range: [491; 492),
+                range: [401; 402),
                kind: TypeHint,
                label: "u8",
            },
            InlayHint {
-                range: [563; 564),
+                range: [445; 446),
                kind: TypeHint,
                label: "u8",
            },
            InlayHint {
-                range: [612; 613),
+                range: [480; 481),
                kind: TypeHint,
                label: "u8",
            },
@@ -743,6 +769,7 @@ enum CustomOption<T> {
    None,
    Some(T),
 }
+use CustomOption::*;
 struct FileId {}
 struct SmolStr {}
@@ -791,11 +818,11 @@ fn main() {
    Test::from_syntax(
        FileId {},
        "impl".into(),
-        CustomOption::None,
+        None,
        TextRange {},
        SyntaxKind {},
-        CustomOption::None,
+        None,
-        CustomOption::None,
+        None,
    );
 }"#,
        );
@@ -803,77 +830,77 @@ fn main() {
        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
        [
            InlayHint {
-                range: [777; 788),
+                range: [798; 809),
                kind: TypeHint,
                label: "i32",
            },
            InlayHint {
-                range: [821; 822),
+                range: [842; 843),
                kind: ParameterHint,
                label: "foo",
            },
            InlayHint {
-                range: [824; 825),
+                range: [845; 846),
                kind: ParameterHint,
                label: "bar",
            },
            InlayHint {
-                range: [827; 834),
+                range: [848; 855),
                kind: ParameterHint,
                label: "msg",
            },
            InlayHint {
-                range: [839; 850),
+                range: [860; 871),
                kind: ParameterHint,
                label: "last",
            },
            InlayHint {
-                range: [893; 896),
+                range: [914; 917),
                kind: ParameterHint,
                label: "param",
            },
            InlayHint {
-                range: [916; 918),
+                range: [937; 939),
                kind: ParameterHint,
                label: "&self",
            },
            InlayHint {
-                range: [920; 924),
+                range: [941; 945),
                kind: ParameterHint,
                label: "param",
            },
            InlayHint {
-                range: [959; 968),
+                range: [980; 989),
                kind: ParameterHint,
                label: "file_id",
            },
            InlayHint {
-                range: [978; 991),
+                range: [999; 1012),
                kind: ParameterHint,
                label: "name",
            },
            InlayHint {
-                range: [1001; 1019),
+                range: [1022; 1026),
                kind: ParameterHint,
                label: "focus_range",
            },
            InlayHint {
-                range: [1029; 1041),
+                range: [1036; 1048),
                kind: ParameterHint,
                label: "full_range",
            },
            InlayHint {
-                range: [1051; 1064),
+                range: [1058; 1071),
                kind: ParameterHint,
                label: "kind",
            },
            InlayHint {
-                range: [1074; 1092),
+                range: [1081; 1085),
                kind: ParameterHint,
                label: "docs",
            },
            InlayHint {
-                range: [1102; 1120),
+                range: [1095; 1099),
                kind: ParameterHint,
                label: "description",
            },
diff --git a/crates/ra_ide/src/join_lines.rs b/crates/ra_ide/src/join_lines.rs
index 01fb32b3d..7d70dab9c 100644
--- a/crates/ra_ide/src/join_lines.rs
+++ b/crates/ra_ide/src/join_lines.rs
@@ -228,6 +228,31 @@ fn foo() {
    }
    #[test]
+    fn test_join_lines_diverging_block() {
+        let before = r"
+            fn foo() {
+                loop {
+                    match x {
+                        92 => <|>{
+                            continue;
+                        }
+                    }
+                }
+            }
+        ";
+        let after = r"
+            fn foo() {
+                loop {
+                    match x {
+                        92 => <|>continue,
+                    }
+                }
+            }
+        ";
+        check_join_lines(before, after);
+    }
+    #[test]
    fn join_lines_adds_comma_for_block_in_match_arm() {
        check_join_lines(
            r"
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index f86f98be7..d509de14e 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -35,7 +35,6 @@ mod typing;
 mod matching_brace;
 mod display;
 mod inlay_hints;
-mod expand;
 mod expand_macro;
 mod ssr;
@@ -75,7 +74,9 @@ pub use crate::{
    runnables::{Runnable, RunnableKind, TestId},
    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    ssr::SsrError,
-    syntax_highlighting::HighlightedRange,
+    syntax_highlighting::{
+        Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
+    },
 };
 pub use hir::Documentation;
@@ -319,9 +320,7 @@ impl Analysis {
        file_id: FileId,
        max_inlay_hint_length: Option<usize>,
    ) -> Cancelable<Vec<InlayHint>> {
-        self.with_db(|db| {
+        self.with_db(|db| inlay_hints::inlay_hints(db, file_id, max_inlay_hint_length))
-            inlay_hints::inlay_hints(db, file_id, &db.parse(file_id).tree(), max_inlay_hint_length)
-        })
    }
    /// Returns the set of folding ranges.
@@ -425,9 +424,14 @@ impl Analysis {
        self.with_db(|db| runnables::runnables(db, file_id))
    }
-    /// Computes syntax highlighting for the given file.
+    /// Computes syntax highlighting for the given file
    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, file_id))
+        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None))
+    }
+    /// Computes syntax highlighting for the given file range.
+    pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
+        self.with_db(|db| syntax_highlighting::highlight(db, frange.file_id, Some(frange.range)))
    }
    /// Computes syntax highlighting for the given file.
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
index bcb67e373..7b8b727b4 100644
--- a/crates/ra_ide/src/marks.rs
+++ b/crates/ra_ide/src/marks.rs
@@ -11,4 +11,5 @@ test_utils::marks!(
    call_info_bad_offset
    dont_complete_current_use
    test_resolve_parent_module_on_module_decl
+    search_filters_by_range
 );
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index af14d6ab3..2c4bdb039 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
-use ra_db::{CrateId, FileId, FilePosition, SourceDatabase};
+use hir::Semantics;
+use ra_db::{CrateId, FileId, FilePosition};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::find_node_at_offset,
@@ -13,10 +14,10 @@ use crate::NavigationTarget;
 /// This returns `Vec` because a module may be included from several places. We
 /// don't handle this case yet though, so the Vec has length at most one.
 pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
-    let mut sb = hir::SourceBinder::new(db);
+    let sema = Semantics::new(db);
-    let parse = db.parse(position.file_id);
+    let source_file = sema.parse(position.file_id);
-    let mut module = find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset);
+    let mut module = find_node_at_offset::<ast::Module>(source_file.syntax(), position.offset);
    // If cursor is literally on `mod foo`, go to the grandpa.
    if let Some(m) = &module {
@@ -30,8 +31,8 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
    }
    let module = match module {
-        Some(module) => sb.to_def(hir::InFile::new(position.file_id.into(), module)),
+        Some(module) => sema.to_def(&module),
-        None => sb.to_module_def(position.file_id),
+        None => sema.to_module_def(position.file_id),
    };
    let module = match module {
        None => return Vec::new(),
@@ -43,8 +44,8 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
 /// Returns `Vec` for the same reason as `parent_module`
 pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
-    let mut sb = hir::SourceBinder::new(db);
+    let sema = Semantics::new(db);
-    let module = match sb.to_module_def(file_id) {
+    let module = match sema.to_module_def(file_id) {
        Some(it) => it,
        None => return Vec::new(),
    };
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index aadc2dbcb..baa8a4d29 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -13,25 +13,22 @@ mod classify;
 mod rename;
 mod search_scope;
-use crate::expand::descend_into_macros_with_analyzer;
+use hir::Semantics;
-use hir::{InFile, SourceBinder};
 use once_cell::unsync::Lazy;
-use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_db::SourceDatabaseExt;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
    algo::find_node_at_offset,
    ast::{self, NameOwner},
-    match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, TextUnit, TokenAtOffset,
+    match_ast, AstNode, SyntaxKind, SyntaxNode, TextRange, TextUnit, TokenAtOffset,
 };
+use test_utils::tested_by;
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
-pub(crate) use self::{
+pub(crate) use self::{classify::classify_name_ref, rename::rename};
-    classify::{classify_name, classify_name_ref},
+pub(crate) use ra_ide_db::defs::{classify_name, NameDefinition};
-    rename::rename,
-};
-pub(crate) use ra_ide_db::defs::NameDefinition;
 pub use self::search_scope::SearchScope;
@@ -114,8 +111,8 @@ pub(crate) fn find_all_refs(
    position: FilePosition,
    search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
-    let parse = db.parse(position.file_id);
+    let sema = Semantics::new(db);
-    let syntax = parse.tree().syntax().clone();
+    let syntax = sema.parse(position.file_id).syntax().clone();
    let (opt_name, search_kind) =
        if let Some(name) = get_struct_def_name_for_struc_litetal_search(&syntax, position) {
@@ -124,7 +121,7 @@ pub(crate) fn find_all_refs(
            (find_node_at_offset::<ast::Name>(&syntax, position.offset), ReferenceKind::Other)
        };
-    let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position, opt_name)?;
+    let RangeInfo { range, info: (name, def) } = find_name(&sema, &syntax, position, opt_name)?;
    let declaration = def.try_to_nav(db)?;
    let search_scope = {
@@ -152,19 +149,18 @@ pub(crate) fn find_all_refs(
 }
 fn find_name(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    syntax: &SyntaxNode,
    position: FilePosition,
    opt_name: Option<ast::Name>,
 ) -> Option<RangeInfo<(String, NameDefinition)>> {
-    let mut sb = SourceBinder::new(db);
    if let Some(name) = opt_name {
-        let def = classify_name(&mut sb, InFile::new(position.file_id.into(), &name))?;
+        let def = classify_name(sema, &name)?;
        let range = name.syntax().text_range();
        return Some(RangeInfo::new(range, (name.text().to_string(), def)));
    }
    let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
-    let def = classify_name_ref(&mut sb, InFile::new(position.file_id.into(), &name_ref))?;
+    let def = classify_name_ref(sema, &name_ref)?;
    let range = name_ref.syntax().text_range();
    Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
 }
@@ -182,64 +178,53 @@ fn process_definition(
    for (file_id, search_range) in scope {
        let text = db.file_text(file_id);
+        let search_range =
+            search_range.unwrap_or(TextRange::offset_len(0.into(), TextUnit::of_str(&text)));
-        let parse = Lazy::new(|| SourceFile::parse(&text));
+        let sema = Semantics::new(db);
-        let mut sb = Lazy::new(|| SourceBinder::new(db));
+        let tree = Lazy::new(|| sema.parse(file_id).syntax().clone());
-        let mut analyzer = None;
        for (idx, _) in text.match_indices(pat) {
            let offset = TextUnit::from_usize(idx);
+            if !search_range.contains_inclusive(offset) {
+                tested_by!(search_filters_by_range);
+                continue;
+            }
-            let (name_ref, range) = if let Some(name_ref) =
+            let name_ref =
-                find_node_at_offset::<ast::NameRef>(parse.tree().syntax(), offset)
+                if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&tree, offset) {
-            {
+                    name_ref
-                let range = name_ref.syntax().text_range();
-                (InFile::new(file_id.into(), name_ref), range)
-            } else {
-                // Handle macro token cases
-                let t = match parse.tree().syntax().token_at_offset(offset) {
-                    TokenAtOffset::None => continue,
-                    TokenAtOffset::Single(t) => t,
-                    TokenAtOffset::Between(_, t) => t,
-                };
-                let range = t.text_range();
-                let analyzer = analyzer.get_or_insert_with(|| {
-                    sb.analyze(InFile::new(file_id.into(), parse.tree().syntax()), None)
-                });
-                let expanded = descend_into_macros_with_analyzer(
-                    db,
-                    &analyzer,
-                    InFile::new(file_id.into(), t),
-                );
-                if let Some(token) = ast::NameRef::cast(expanded.value.parent()) {
-                    (expanded.with_value(token), range)
                } else {
-                    continue;
+                    // Handle macro token cases
-                }
+                    let token = match tree.token_at_offset(offset) {
-            };
+                        TokenAtOffset::None => continue,
+                        TokenAtOffset::Single(t) => t,
+                        TokenAtOffset::Between(_, t) => t,
+                    };
+                    let expanded = sema.descend_into_macros(token);
+                    match ast::NameRef::cast(expanded.parent()) {
+                        Some(name_ref) => name_ref,
+                        _ => continue,
+                    }
+                };
-            if let Some(search_range) = search_range {
-                if !range.is_subrange(&search_range) {
-                    continue;
-                }
-            }
            // FIXME: reuse sb
            // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
-            if let Some(d) = classify_name_ref(&mut sb, name_ref.as_ref()) {
+            if let Some(d) = classify_name_ref(&sema, &name_ref) {
                if d == def {
-                    let kind = if is_record_lit_name_ref(&name_ref.value)
+                    let kind =
-                        || is_call_expr_name_ref(&name_ref.value)
+                        if is_record_lit_name_ref(&name_ref) || is_call_expr_name_ref(&name_ref) {
-                    {
+                            ReferenceKind::StructLiteral
-                        ReferenceKind::StructLiteral
+                        } else {
-                    } else {
+                            ReferenceKind::Other
-                        ReferenceKind::Other
+                        };
-                    };
+                    let file_range = sema.original_range(name_ref.syntax());
                    refs.push(Reference {
-                        file_range: FileRange { file_id, range },
+                        file_range,
                        kind,
-                        access: reference_access(&d, &name_ref.value),
+                        access: reference_access(&d, &name_ref),
                    });
                }
            }
@@ -348,6 +333,8 @@ fn is_call_expr_name_ref(name_ref: &ast::NameRef) -> bool {
 #[cfg(test)]
 mod tests {
+    use test_utils::covers;
    use crate::{
        mock_analysis::{analysis_and_position, single_file_with_position, MockAnalysis},
        Declaration, Reference, ReferenceSearchResult, SearchScope,
@@ -456,6 +443,27 @@ mod tests {
    }
    #[test]
+    fn search_filters_by_range() {
+        covers!(search_filters_by_range);
+        let code = r#"
+            fn foo() {
+                let spam<|> = 92;
+                spam + spam
+            }
+            fn bar() {
+                let spam = 92;
+                spam + spam
+            }
+        "#;
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "spam BIND_PAT FileId(1) [44; 48) Other Write",
+            &["FileId(1) [71; 75) Other Read", "FileId(1) [78; 82) Other Read"],
+        );
+    }
+    #[test]
    fn test_find_all_refs_for_param_inside() {
        let code = r#"
    fn foo(i : u32) -> u32 {
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 478e18871..91b21429a 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,34 +1,32 @@
 //! Functions that are used to classify an element from its definition or reference.
-use hir::{InFile, PathResolution, SourceBinder};
+use hir::{PathResolution, Semantics};
+use ra_ide_db::defs::NameDefinition;
+use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
-use super::NameDefinition;
+pub use ra_ide_db::defs::{from_module_def, from_struct_field};
-use ra_ide_db::RootDatabase;
-pub use ra_ide_db::defs::{classify_name, from_module_def, from_struct_field};
 pub(crate) fn classify_name_ref(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    name_ref: InFile<&ast::NameRef>,
+    name_ref: &ast::NameRef,
 ) -> Option<NameDefinition> {
    let _p = profile("classify_name_ref");
-    let parent = name_ref.value.syntax().parent()?;
+    let parent = name_ref.syntax().parent()?;
-    let analyzer = sb.analyze(name_ref.map(|it| it.syntax()), None);
    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
        tested_by!(goto_def_for_methods);
-        if let Some(func) = analyzer.resolve_method_call(&method_call) {
+        if let Some(func) = sema.resolve_method_call(&method_call) {
            return Some(from_module_def(func.into()));
        }
    }
    if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
        tested_by!(goto_def_for_fields);
-        if let Some(field) = analyzer.resolve_field(&field_expr) {
+        if let Some(field) = sema.resolve_field(&field_expr) {
            return Some(from_struct_field(field));
        }
    }
@@ -36,22 +34,20 @@ pub(crate) fn classify_name_ref(
    if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
        tested_by!(goto_def_for_record_fields);
        tested_by!(goto_def_for_field_init_shorthand);
-        if let Some(field_def) = analyzer.resolve_record_field(&record_field) {
+        if let Some(field_def) = sema.resolve_record_field(&record_field) {
            return Some(from_struct_field(field_def));
        }
    }
    if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
        tested_by!(goto_def_for_macros);
-        if let Some(macro_def) =
+        if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
-            analyzer.resolve_macro_call(sb.db, name_ref.with_value(&macro_call))
-        {
            return Some(NameDefinition::Macro(macro_def));
        }
    }
-    let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
+    let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
-    let resolved = analyzer.resolve_path(sb.db, &path)?;
+    let resolved = sema.resolve_path(&path)?;
    let res = match resolved {
        PathResolution::Def(def) => from_module_def(def),
        PathResolution::AssocItem(item) => {
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index bdb90020b..5b4bcf434 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
-use hir::ModuleSource;
+use hir::{ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabase, SourceDatabaseExt};
+use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
@@ -24,15 +24,16 @@ pub(crate) fn rename(
        _ => return None,
    }
-    let parse = db.parse(position.file_id);
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
    if let Some((ast_name, ast_module)) =
-        find_name_and_module_at_offset(parse.tree().syntax(), position)
+        find_name_and_module_at_offset(source_file.syntax(), position)
    {
        let range = ast_name.syntax().text_range();
-        rename_mod(db, &ast_name, &ast_module, position, new_name)
+        rename_mod(&sema, &ast_name, &ast_module, position, new_name)
            .map(|info| RangeInfo::new(range, info))
    } else {
-        rename_reference(db, position, new_name)
+        rename_reference(sema.db, position, new_name)
    }
 }
@@ -54,7 +55,7 @@ fn source_edit_from_file_id_range(
 }
 fn rename_mod(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    ast_name: &ast::Name,
    ast_module: &ast::Module,
    position: FilePosition,
@@ -62,13 +63,12 @@ fn rename_mod(
 ) -> Option<SourceChange> {
    let mut source_file_edits = Vec::new();
    let mut file_system_edits = Vec::new();
-    let module_src = hir::InFile { file_id: position.file_id.into(), value: ast_module.clone() };
+    if let Some(module) = sema.to_def(ast_module) {
-    if let Some(module) = hir::SourceBinder::new(db).to_def(module_src) {
+        let src = module.definition_source(sema.db);
-        let src = module.definition_source(db);
+        let file_id = src.file_id.original_file(sema.db);
-        let file_id = src.file_id.original_file(db);
        match src.value {
            ModuleSource::SourceFile(..) => {
-                let mod_path: RelativePathBuf = db.file_relative_path(file_id);
+                let mod_path: RelativePathBuf = sema.db.file_relative_path(file_id);
                // mod is defined in path/to/dir/mod.rs
                let dst_path = if mod_path.file_stem() == Some("mod") {
                    mod_path
@@ -82,7 +82,7 @@ fn rename_mod(
                if let Some(path) = dst_path {
                    let move_file = FileSystemEdit::MoveFile {
                        src: file_id,
-                        dst_source_root: db.file_source_root(position.file_id),
+                        dst_source_root: sema.db.file_source_root(position.file_id),
                        dst_path: path,
                    };
                    file_system_edits.push(move_file);
@@ -98,7 +98,7 @@ fn rename_mod(
    };
    source_file_edits.push(edit);
-    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(db, position, None) {
+    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(sema.db, position, None) {
        let ref_edits = refs.references.into_iter().map(|reference| {
            source_edit_from_file_id_range(
                reference.file_range.file_id,
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index be2a67d0a..74877e90f 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -1,8 +1,7 @@
 //! FIXME: write short doc here
-use hir::{InFile, SourceBinder};
+use hir::Semantics;
 use itertools::Itertools;
-use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    ast::{self, AstNode, AttrsOwner, ModuleItemOwner, NameOwner},
@@ -42,46 +41,33 @@ pub enum RunnableKind {
 }
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
-    let parse = db.parse(file_id);
+    let sema = Semantics::new(db);
-    let mut sb = SourceBinder::new(db);
+    let source_file = sema.parse(file_id);
-    parse.tree().syntax().descendants().filter_map(|i| runnable(db, &mut sb, file_id, i)).collect()
+    source_file.syntax().descendants().filter_map(|i| runnable(&sema, i)).collect()
 }
-fn runnable(
+fn runnable(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
-    db: &RootDatabase,
-    source_binder: &mut SourceBinder<RootDatabase>,
-    file_id: FileId,
-    item: SyntaxNode,
-) -> Option<Runnable> {
    match_ast! {
        match item {
-            ast::FnDef(it) => { runnable_fn(db, source_binder, file_id, it) },
+            ast::FnDef(it) => { runnable_fn(sema, it) },
-            ast::Module(it) => { runnable_mod(db, source_binder, file_id, it) },
+            ast::Module(it) => { runnable_mod(sema, it) },
-            _ => { None },
+            _ => None,
        }
    }
 }
-fn runnable_fn(
+fn runnable_fn(sema: &Semantics<RootDatabase>, fn_def: ast::FnDef) -> Option<Runnable> {
-    db: &RootDatabase,
-    source_binder: &mut SourceBinder<RootDatabase>,
-    file_id: FileId,
-    fn_def: ast::FnDef,
-) -> Option<Runnable> {
    let name_string = fn_def.name()?.text().to_string();
    let kind = if name_string == "main" {
        RunnableKind::Bin
    } else {
-        let test_id = if let Some(module) = source_binder
+        let test_id = if let Some(module) = sema.to_def(&fn_def).map(|def| def.module(sema.db)) {
-            .to_def(InFile::new(file_id.into(), fn_def.clone()))
-            .map(|def| def.module(db))
-        {
            let path = module
-                .path_to_root(db)
+                .path_to_root(sema.db)
                .into_iter()
                .rev()
-                .filter_map(|it| it.name(db))
+                .filter_map(|it| it.name(sema.db))
                .map(|name| name.to_string())
                .chain(std::iter::once(name_string))
                .join("::");
@@ -115,12 +101,7 @@ fn has_test_related_attribute(fn_def: &ast::FnDef) -> bool {
        .any(|attribute_text| attribute_text.contains("test"))
 }
-fn runnable_mod(
+fn runnable_mod(sema: &Semantics<RootDatabase>, module: ast::Module) -> Option<Runnable> {
-    db: &RootDatabase,
-    source_binder: &mut SourceBinder<RootDatabase>,
-    file_id: FileId,
-    module: ast::Module,
-) -> Option<Runnable> {
    let has_test_function = module
        .item_list()?
        .items()
@@ -133,9 +114,10 @@ fn runnable_mod(
        return None;
    }
    let range = module.syntax().text_range();
-    let module = source_binder.to_def(InFile::new(file_id.into(), module))?;
+    let module = sema.to_def(&module)?;
-    let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
+    let path =
+        module.path_to_root(sema.db).into_iter().rev().filter_map(|it| it.name(sema.db)).join("::");
    Some(Runnable { range, kind: RunnableKind::TestMod { path } })
 }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index a02dbaf2f..51851763e 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -10,29 +10,29 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
 .type               { color: #7CB8BB; }
-.type\.builtin     { color: #8CD0D3; }
+.type.builtin       { color: #8CD0D3; }
-.type\.param       { color: #20999D; }
+.type.param         { color: #20999D; }
 .attribute          { color: #94BFF3; }
 .literal            { color: #BFEBBF; }
-.literal\.numeric  { color: #6A8759; }
+.literal.numeric    { color: #6A8759; }
 .macro              { color: #94BFF3; }
 .module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
-.variable\.mut     { color: #DCDCCC; text-decoration: underline; }
+.variable.mut       { color: #DCDCCC; text-decoration: underline; }
 .keyword            { color: #F0DFAF; }
-.keyword\.unsafe   { color: #DFAF8F; }
+.keyword.unsafe     { color: #DFAF8F; }
-.keyword\.control  { color: #F0DFAF; font-weight: bold; }
+.keyword.control    { color: #F0DFAF; font-weight: bold; }
 </style>
 <pre><code><span class="attribute">#</span><span class="attribute">[</span><span class="attribute">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span>
 <span class="keyword">struct</span> <span class="type">Foo</span> {
-    <span class="keyword">pub</span> <span class="field">x</span>: <span class="type.builtin">i32</span>,
+    <span class="keyword">pub</span> <span class="field">x</span>: <span class="type builtin">i32</span>,
-    <span class="keyword">pub</span> <span class="field">y</span>: <span class="type.builtin">i32</span>,
+    <span class="keyword">pub</span> <span class="field">y</span>: <span class="type builtin">i32</span>,
 }
-<span class="keyword">fn</span> <span class="function">foo</span>&lt;<span class="type.param">T</span>&gt;() -&gt; <span class="type.param">T</span> {
+<span class="keyword">fn</span> <span class="function">foo</span>&lt;<span class="type param">T</span>&gt;() -&gt; <span class="type param">T</span> {
    <span class="macro">unimplemented</span><span class="macro">!</span>();
-    <span class="function">foo</span>::&lt;<span class="type.builtin">i32</span>&gt;();
+    <span class="function">foo</span>::&lt;<span class="type builtin">i32</span>&gt;();
 }
 <span class="macro">macro_rules</span><span class="macro">!</span> def_fn {
@@ -40,33 +40,33 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 }
 <span class="macro">def_fn</span><span class="macro">!</span>{
-    <span class="keyword">fn</span> <span class="function">bar</span>() -&gt; <span class="type.builtin">u32</span> {
+    <span class="keyword">fn</span> <span class="function">bar</span>() -&gt; <span class="type builtin">u32</span> {
-        <span class="literal.numeric">100</span>
+        <span class="literal numeric">100</span>
    }
 }
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function">main</span>() {
-    <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal.numeric">92</span>);
+    <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal numeric">92</span>);
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">vec</span> = Vec::new();
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable mutable">vec</span> = Vec::new();
-    <span class="keyword.control">if</span> <span class="keyword">true</span> {
+    <span class="keyword control">if</span> <span class="keyword">true</span> {
-        <span class="keyword">let</span> <span class="variable">x</span> = <span class="literal.numeric">92</span>;
+        <span class="keyword">let</span> <span class="variable">x</span> = <span class="literal numeric">92</span>;
-        <span class="variable.mut">vec</span>.push(<span class="type">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="literal.numeric">1</span> });
+        <span class="variable mutable">vec</span>.push(<span class="type">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="literal numeric">1</span> });
    }
-    <span class="keyword.unsafe">unsafe</span> { <span class="variable.mut">vec</span>.set_len(<span class="literal.numeric">0</span>); }
+    <span class="keyword unsafe">unsafe</span> { <span class="variable mutable">vec</span>.set_len(<span class="literal numeric">0</span>); }
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">x</span> = <span class="literal.numeric">42</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable mutable">x</span> = <span class="literal numeric">42</span>;
-    <span class="keyword">let</span> <span class="variable.mut">y</span> = &<span class="keyword">mut</span> <span class="variable.mut">x</span>;
+    <span class="keyword">let</span> <span class="variable mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
-    <span class="keyword">let</span> <span class="variable">z</span> = &<span class="variable.mut">y</span>;
+    <span class="keyword">let</span> <span class="variable">z</span> = &<span class="variable mutable">y</span>;
-    <span class="variable.mut">y</span>;
+    <span class="variable mutable">y</span>;
 }
-<span class="keyword">enum</span> <span class="type">E</span>&lt;<span class="type.param">X</span>&gt; {
+<span class="keyword">enum</span> <span class="type">E</span>&lt;<span class="type param">X</span>&gt; {
-    <span class="constant">V</span>(<span class="type.param">X</span>)
+    <span class="constant">V</span>(<span class="type param">X</span>)
 }
-<span class="keyword">impl</span>&lt;<span class="type.param">X</span>&gt; <span class="type">E</span>&lt;<span class="type.param">X</span>&gt; {
+<span class="keyword">impl</span>&lt;<span class="type param">X</span>&gt; <span class="type">E</span>&lt;<span class="type param">X</span>&gt; {
-    <span class="keyword">fn</span> <span class="function">new</span>&lt;<span class="type.param">T</span>&gt;() -&gt; <span class="type">E</span>&lt;<span class="type.param">T</span>&gt; {}
+    <span class="keyword">fn</span> <span class="function">new</span>&lt;<span class="type param">T</span>&gt;() -&gt; <span class="type">E</span>&lt;<span class="type param">T</span>&gt; {}
 }</code></pre>
 \ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 95f038f00..1f869867f 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -10,29 +10,29 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
 .type               { color: #7CB8BB; }
-.type\.builtin     { color: #8CD0D3; }
+.type.builtin       { color: #8CD0D3; }
-.type\.param       { color: #20999D; }
+.type.param         { color: #20999D; }
 .attribute          { color: #94BFF3; }
 .literal            { color: #BFEBBF; }
-.literal\.numeric  { color: #6A8759; }
+.literal.numeric    { color: #6A8759; }
 .macro              { color: #94BFF3; }
 .module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
-.variable\.mut     { color: #DCDCCC; text-decoration: underline; }
+.variable.mut       { color: #DCDCCC; text-decoration: underline; }
 .keyword            { color: #F0DFAF; }
-.keyword\.unsafe   { color: #DFAF8F; }
+.keyword.unsafe     { color: #DFAF8F; }
-.keyword\.control  { color: #F0DFAF; font-weight: bold; }
+.keyword.control    { color: #F0DFAF; font-weight: bold; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function">main</span>() {
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string">"hello"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="4303609361109701698" style="color: hsl(242,75%,88%);">x</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="2705725358298919760" style="color: hsl(17,51%,74%);">x</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.to_string();
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="13865792086344377029" style="color: hsl(340,64%,86%);">y</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="3365759661443752373" style="color: hsl(127,76%,66%);">y</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.to_string();
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span> = <span class="string">"other color please!"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span> = <span class="string">"other color please!"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="12461245066629867975" style="color: hsl(132,91%,68%);">y</span> = <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="6717528807933952652" style="color: hsl(85,49%,84%);">y</span> = <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span>.to_string();
 }
 <span class="keyword">fn</span> <span class="function">bar</span>() {
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable mutable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string">"hello"</span>;
 }</code></pre>
 \ No newline at end of file
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index d873f153e..5f11b091c 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -1,54 +1,30 @@
 //! FIXME: write short doc here
-use hir::{HirFileId, InFile, Name, SourceAnalyzer, SourceBinder};
+mod tags;
-use ra_db::SourceDatabase;
+mod html;
-use ra_ide_db::{defs::NameDefinition, RootDatabase};
+use hir::{Name, Semantics};
+use ra_ide_db::{
+    defs::{classify_name, NameDefinition},
+    RootDatabase,
+};
 use ra_prof::profile;
 use ra_syntax::{
-    ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxToken, TextRange,
+    ast, AstNode, Direction, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxToken,
-    WalkEvent, T,
+    TextRange, WalkEvent, T,
 };
 use rustc_hash::FxHashMap;
-use crate::{
+use crate::{references::classify_name_ref, FileId};
-    expand::descend_into_macros_with_analyzer,
-    references::{classify_name, classify_name_ref},
-    FileId,
-};
-pub mod tags {
+pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
-    pub(crate) const FIELD: &str = "field";
-    pub(crate) const FUNCTION: &str = "function";
+pub(crate) use html::highlight_as_html;
-    pub(crate) const MODULE: &str = "module";
-    pub(crate) const CONSTANT: &str = "constant";
-    pub(crate) const MACRO: &str = "macro";
-    pub(crate) const VARIABLE: &str = "variable";
-    pub(crate) const VARIABLE_MUT: &str = "variable.mut";
-    pub(crate) const TYPE: &str = "type";
-    pub(crate) const TYPE_BUILTIN: &str = "type.builtin";
-    pub(crate) const TYPE_SELF: &str = "type.self";
-    pub(crate) const TYPE_PARAM: &str = "type.param";
-    pub(crate) const TYPE_LIFETIME: &str = "type.lifetime";
-    pub(crate) const LITERAL_BYTE: &str = "literal.byte";
-    pub(crate) const LITERAL_NUMERIC: &str = "literal.numeric";
-    pub(crate) const LITERAL_CHAR: &str = "literal.char";
-    pub(crate) const LITERAL_COMMENT: &str = "comment";
-    pub(crate) const LITERAL_STRING: &str = "string";
-    pub(crate) const LITERAL_ATTRIBUTE: &str = "attribute";
-    pub(crate) const KEYWORD: &str = "keyword";
-    pub(crate) const KEYWORD_UNSAFE: &str = "keyword.unsafe";
-    pub(crate) const KEYWORD_CONTROL: &str = "keyword.control";
-}
 #[derive(Debug)]
 pub struct HighlightedRange {
    pub range: TextRange,
-    pub tag: &'static str,
+    pub highlight: Highlight,
    pub binding_hash: Option<u64>,
 }
@@ -67,54 +43,82 @@ fn is_control_keyword(kind: SyntaxKind) -> bool {
    }
 }
-pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
+pub(crate) fn highlight(
+    db: &RootDatabase,
+    file_id: FileId,
+    range: Option<TextRange>,
+) -> Vec<HighlightedRange> {
    let _p = profile("highlight");
-    let parse = db.parse(file_id);
+    let sema = Semantics::new(db);
-    let root = parse.tree().syntax().clone();
+    let root = sema.parse(file_id).syntax().clone();
-    let mut sb = SourceBinder::new(db);
    let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
    let mut res = Vec::new();
-    let analyzer = sb.analyze(InFile::new(file_id.into(), &root), None);
    let mut in_macro_call = None;
+    // Determine the root based on the given range.
+    let (root, highlight_range) = if let Some(range) = range {
+        let root = match root.covering_element(range) {
+            NodeOrToken::Node(node) => node,
+            NodeOrToken::Token(token) => token.parent(),
+        };
+        (root, range)
+    } else {
+        (root.clone(), root.text_range())
+    };
    for event in root.preorder_with_tokens() {
        match event {
-            WalkEvent::Enter(node) => match node.kind() {
+            WalkEvent::Enter(node) => {
-                MACRO_CALL => {
+                if node.text_range().intersection(&highlight_range).is_none() {
-                    in_macro_call = Some(node.clone());
+                    continue;
-                    if let Some(range) = highlight_macro(InFile::new(file_id.into(), node)) {
-                        res.push(HighlightedRange { range, tag: tags::MACRO, binding_hash: None });
-                    }
                }
-                _ if in_macro_call.is_some() => {
-                    if let Some(token) = node.as_token() {
+                match node.kind() {
-                        if let Some((tag, binding_hash)) = highlight_token_tree(
+                    MACRO_CALL => {
-                            &mut sb,
+                        in_macro_call = Some(node.clone());
-                            &analyzer,
+                        if let Some(range) = highlight_macro(node) {
-                            &mut bindings_shadow_count,
+                            res.push(HighlightedRange {
-                            InFile::new(file_id.into(), token.clone()),
+                                range,
-                        ) {
+                                highlight: HighlightTag::Macro.into(),
+                                binding_hash: None,
+                            });
+                        }
+                    }
+                    _ if in_macro_call.is_some() => {
+                        if let Some(token) = node.as_token() {
+                            if let Some((highlight, binding_hash)) = highlight_token_tree(
+                                &sema,
+                                &mut bindings_shadow_count,
+                                token.clone(),
+                            ) {
+                                res.push(HighlightedRange {
+                                    range: node.text_range(),
+                                    highlight,
+                                    binding_hash,
+                                });
+                            }
+                        }
+                    }
+                    _ => {
+                        if let Some((highlight, binding_hash)) =
+                            highlight_node(&sema, &mut bindings_shadow_count, node.clone())
+                        {
                            res.push(HighlightedRange {
                                range: node.text_range(),
-                                tag,
+                                highlight,
                                binding_hash,
                            });
                        }
                    }
                }
-                _ => {
+            }
-                    if let Some((tag, binding_hash)) = highlight_node(
-                        &mut sb,
-                        &mut bindings_shadow_count,
-                        InFile::new(file_id.into(), node.clone()),
-                    ) {
-                        res.push(HighlightedRange { range: node.text_range(), tag, binding_hash });
-                    }
-                }
-            },
            WalkEvent::Leave(node) => {
+                if node.text_range().intersection(&highlight_range).is_none() {
+                    continue;
+                }
                if let Some(m) = in_macro_call.as_ref() {
                    if *m == node {
                        in_macro_call = None;
@@ -127,8 +131,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
    res
 }
-fn highlight_macro(node: InFile<SyntaxElement>) -> Option<TextRange> {
+fn highlight_macro(node: SyntaxElement) -> Option<TextRange> {
-    let macro_call = ast::MacroCall::cast(node.value.as_node()?.clone())?;
+    let macro_call = ast::MacroCall::cast(node.as_node()?.clone())?;
    let path = macro_call.path()?;
    let name_ref = path.segment()?.name_ref()?;
@@ -145,56 +149,56 @@ fn highlight_macro(node: InFile<SyntaxElement>) -> Option<TextRange> {
 }
 fn highlight_token_tree(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
-    analyzer: &SourceAnalyzer,
    bindings_shadow_count: &mut FxHashMap<Name, u32>,
-    token: InFile<SyntaxToken>,
+    token: SyntaxToken,
-) -> Option<(&'static str, Option<u64>)> {
+) -> Option<(Highlight, Option<u64>)> {
-    if token.value.parent().kind() != TOKEN_TREE {
+    if token.parent().kind() != TOKEN_TREE {
        return None;
    }
-    let token = descend_into_macros_with_analyzer(sb.db, analyzer, token);
+    let token = sema.descend_into_macros(token.clone());
    let expanded = {
-        let parent = token.value.parent();
+        let parent = token.parent();
        // We only care Name and Name_ref
-        match (token.value.kind(), parent.kind()) {
+        match (token.kind(), parent.kind()) {
-            (IDENT, NAME) | (IDENT, NAME_REF) => token.with_value(parent.into()),
+            (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
-            _ => token.map(|it| it.into()),
+            _ => token.into(),
        }
    };
-    highlight_node(sb, bindings_shadow_count, expanded)
+    highlight_node(sema, bindings_shadow_count, expanded)
 }
 fn highlight_node(
-    sb: &mut SourceBinder<RootDatabase>,
+    sema: &Semantics<RootDatabase>,
    bindings_shadow_count: &mut FxHashMap<Name, u32>,
-    node: InFile<SyntaxElement>,
+    node: SyntaxElement,
-) -> Option<(&'static str, Option<u64>)> {
+) -> Option<(Highlight, Option<u64>)> {
-    let db = sb.db;
+    let db = sema.db;
    let mut binding_hash = None;
-    let tag = match node.value.kind() {
+    let highlight: Highlight = match node.kind() {
        FN_DEF => {
            bindings_shadow_count.clear();
            return None;
        }
-        COMMENT => tags::LITERAL_COMMENT,
+        COMMENT => HighlightTag::Comment.into(),
-        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
+        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::LiteralString.into(),
-        ATTR => tags::LITERAL_ATTRIBUTE,
+        ATTR => HighlightTag::Attribute.into(),
        // Special-case field init shorthand
-        NAME_REF if node.value.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
+        NAME_REF if node.parent().and_then(ast::RecordField::cast).is_some() => {
-        NAME_REF if node.value.ancestors().any(|it| it.kind() == ATTR) => return None,
+            HighlightTag::Field.into()
+        }
+        NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => return None,
        NAME_REF => {
-            let name_ref = node.value.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
+            let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-            let name_kind = classify_name_ref(sb, node.with_value(&name_ref));
+            let name_kind = classify_name_ref(sema, &name_ref);
            match name_kind {
                Some(name_kind) => {
                    if let NameDefinition::Local(local) = &name_kind {
                        if let Some(name) = local.name(db) {
                            let shadow_count =
                                bindings_shadow_count.entry(name.clone()).or_default();
-                            binding_hash =
+                            binding_hash = Some(calc_binding_hash(&name, *shadow_count))
-                                Some(calc_binding_hash(node.file_id, &name, *shadow_count))
                        }
                    };
@@ -204,41 +208,45 @@ fn highlight_node(
            }
        }
        NAME => {
-            let name = node.value.as_node().cloned().and_then(ast::Name::cast).unwrap();
+            let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap();
-            let name_kind = classify_name(sb, node.with_value(&name));
+            let name_kind = classify_name(sema, &name);
            if let Some(NameDefinition::Local(local)) = &name_kind {
                if let Some(name) = local.name(db) {
                    let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
                    *shadow_count += 1;
-                    binding_hash = Some(calc_binding_hash(node.file_id, &name, *shadow_count))
+                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
                }
            };
            match name_kind {
                Some(name_kind) => highlight_name(db, name_kind),
-                None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
+                None => name.syntax().parent().map_or(HighlightTag::Function.into(), |x| {
-                    STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
+                    match x.kind() {
-                    TYPE_PARAM => tags::TYPE_PARAM,
+                        STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => {
-                    RECORD_FIELD_DEF => tags::FIELD,
+                            HighlightTag::Type.into()
-                    _ => tags::FUNCTION,
+                        }
+                        TYPE_PARAM => HighlightTag::TypeParam.into(),
+                        RECORD_FIELD_DEF => HighlightTag::Field.into(),
+                        _ => HighlightTag::Function.into(),
+                    }
                }),
            }
        }
-        INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
+        INT_NUMBER | FLOAT_NUMBER => HighlightTag::LiteralNumeric.into(),
-        BYTE => tags::LITERAL_BYTE,
+        BYTE => HighlightTag::LiteralByte.into(),
-        CHAR => tags::LITERAL_CHAR,
+        CHAR => HighlightTag::LiteralChar.into(),
-        LIFETIME => tags::TYPE_LIFETIME,
+        LIFETIME => HighlightTag::TypeLifetime.into(),
-        T![unsafe] => tags::KEYWORD_UNSAFE,
+        T![unsafe] => HighlightTag::Keyword | HighlightModifier::Unsafe,
-        k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
+        k if is_control_keyword(k) => HighlightTag::Keyword | HighlightModifier::Control,
-        k if k.is_keyword() => tags::KEYWORD,
+        k if k.is_keyword() => HighlightTag::Keyword.into(),
        _ => return None,
    };
-    return Some((tag, binding_hash));
+    return Some((highlight, binding_hash));
-    fn calc_binding_hash(file_id: HirFileId, name: &Name, shadow_count: u32) -> u64 {
+    fn calc_binding_hash(name: &Name, shadow_count: u32) -> u64 {
        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
@@ -247,134 +255,48 @@ fn highlight_node(
            hasher.finish()
        }
-        hash((file_id, name, shadow_count))
+        hash((name, shadow_count))
    }
 }
-pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
+fn highlight_name(db: &RootDatabase, def: NameDefinition) -> Highlight {
-    let parse = db.parse(file_id);
-    fn rainbowify(seed: u64) -> String {
-        use rand::prelude::*;
-        let mut rng = SmallRng::seed_from_u64(seed);
-        format!(
-            "hsl({h},{s}%,{l}%)",
-            h = rng.gen_range::<u16, _, _>(0, 361),
-            s = rng.gen_range::<u16, _, _>(42, 99),
-            l = rng.gen_range::<u16, _, _>(40, 91),
-        )
-    }
-    let mut ranges = highlight(db, file_id);
-    ranges.sort_by_key(|it| it.range.start());
-    // quick non-optimal heuristic to intersect token ranges and highlighted ranges
-    let mut frontier = 0;
-    let mut could_intersect: Vec<&HighlightedRange> = Vec::new();
-    let mut buf = String::new();
-    buf.push_str(&STYLE);
-    buf.push_str("<pre><code>");
-    let tokens = parse.tree().syntax().descendants_with_tokens().filter_map(|it| it.into_token());
-    for token in tokens {
-        could_intersect.retain(|it| token.text_range().start() <= it.range.end());
-        while let Some(r) = ranges.get(frontier) {
-            if r.range.start() <= token.text_range().end() {
-                could_intersect.push(r);
-                frontier += 1;
-            } else {
-                break;
-            }
-        }
-        let text = html_escape(&token.text());
-        let ranges = could_intersect
-            .iter()
-            .filter(|it| token.text_range().is_subrange(&it.range))
-            .collect::<Vec<_>>();
-        if ranges.is_empty() {
-            buf.push_str(&text);
-        } else {
-            let classes = ranges.iter().map(|x| x.tag).collect::<Vec<_>>().join(" ");
-            let binding_hash = ranges.first().and_then(|x| x.binding_hash);
-            let color = match (rainbow, binding_hash) {
-                (true, Some(hash)) => format!(
-                    " data-binding-hash=\"{}\" style=\"color: {};\"",
-                    hash,
-                    rainbowify(hash)
-                ),
-                _ => "".into(),
-            };
-            buf.push_str(&format!("<span class=\"{}\"{}>{}</span>", classes, color, text));
-        }
-    }
-    buf.push_str("</code></pre>");
-    buf
-}
-fn highlight_name(db: &RootDatabase, def: NameDefinition) -> &'static str {
    match def {
-        NameDefinition::Macro(_) => tags::MACRO,
+        NameDefinition::Macro(_) => HighlightTag::Macro,
-        NameDefinition::StructField(_) => tags::FIELD,
+        NameDefinition::StructField(_) => HighlightTag::Field,
-        NameDefinition::ModuleDef(hir::ModuleDef::Module(_)) => tags::MODULE,
+        NameDefinition::ModuleDef(hir::ModuleDef::Module(_)) => HighlightTag::Module,
-        NameDefinition::ModuleDef(hir::ModuleDef::Function(_)) => tags::FUNCTION,
+        NameDefinition::ModuleDef(hir::ModuleDef::Function(_)) => HighlightTag::Function,
-        NameDefinition::ModuleDef(hir::ModuleDef::Adt(_)) => tags::TYPE,
+        NameDefinition::ModuleDef(hir::ModuleDef::Adt(_)) => HighlightTag::Type,
-        NameDefinition::ModuleDef(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
+        NameDefinition::ModuleDef(hir::ModuleDef::EnumVariant(_)) => HighlightTag::Constant,
-        NameDefinition::ModuleDef(hir::ModuleDef::Const(_)) => tags::CONSTANT,
+        NameDefinition::ModuleDef(hir::ModuleDef::Const(_)) => HighlightTag::Constant,
-        NameDefinition::ModuleDef(hir::ModuleDef::Static(_)) => tags::CONSTANT,
+        NameDefinition::ModuleDef(hir::ModuleDef::Static(_)) => HighlightTag::Constant,
-        NameDefinition::ModuleDef(hir::ModuleDef::Trait(_)) => tags::TYPE,
+        NameDefinition::ModuleDef(hir::ModuleDef::Trait(_)) => HighlightTag::Type,
-        NameDefinition::ModuleDef(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
+        NameDefinition::ModuleDef(hir::ModuleDef::TypeAlias(_)) => HighlightTag::Type,
-        NameDefinition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
+        NameDefinition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
-        NameDefinition::SelfType(_) => tags::TYPE_SELF,
+            return HighlightTag::Type | HighlightModifier::Builtin
-        NameDefinition::TypeParam(_) => tags::TYPE_PARAM,
+        }
+        NameDefinition::SelfType(_) => HighlightTag::TypeSelf,
+        NameDefinition::TypeParam(_) => HighlightTag::TypeParam,
        NameDefinition::Local(local) => {
+            let mut h = Highlight::new(HighlightTag::Variable);
            if local.is_mut(db) || local.ty(db).is_mutable_reference() {
-                tags::VARIABLE_MUT
+                h |= HighlightModifier::Mutable;
-            } else {
-                tags::VARIABLE
            }
+            return h;
        }
    }
+    .into()
 }
-//FIXME: like, real html escaping
-fn html_escape(text: &str) -> String {
-    text.replace("<", "&lt;").replace(">", "&gt;")
-}
-const STYLE: &str = "
-<style>
-body                { margin: 0; }
-pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
-.comment            { color: #7F9F7F; }
-.string             { color: #CC9393; }
-.field              { color: #94BFF3; }
-.function           { color: #93E0E3; }
-.parameter          { color: #94BFF3; }
-.text               { color: #DCDCCC; }
-.type               { color: #7CB8BB; }
-.type\\.builtin     { color: #8CD0D3; }
-.type\\.param       { color: #20999D; }
-.attribute          { color: #94BFF3; }
-.literal            { color: #BFEBBF; }
-.literal\\.numeric  { color: #6A8759; }
-.macro              { color: #94BFF3; }
-.module             { color: #AFD8AF; }
-.variable           { color: #DCDCCC; }
-.variable\\.mut     { color: #DCDCCC; text-decoration: underline; }
-.keyword            { color: #F0DFAF; }
-.keyword\\.unsafe   { color: #DFAF8F; }
-.keyword\\.control  { color: #F0DFAF; font-weight: bold; }
-</style>
-";
 #[cfg(test)]
 mod tests {
    use std::fs;
    use test_utils::{assert_eq_text, project_dir, read_text};
-    use crate::mock_analysis::{single_file, MockAnalysis};
+    use crate::{
+        mock_analysis::{single_file, MockAnalysis},
+        FileRange, TextRange,
+    };
    #[test]
    fn test_highlighting() {
@@ -475,4 +397,26 @@ fn bar() {
        let _ = host.analysis().highlight(file_id).unwrap();
        // eprintln!("elapsed: {:?}", t.elapsed());
    }
+    #[test]
+    fn test_ranges() {
+        let (analysis, file_id) = single_file(
+            r#"
+            #[derive(Clone, Debug)]
+            struct Foo {
+                pub x: i32,
+                pub y: i32,
+            }"#,
+        );
+        // The "x"
+        let highlights = &analysis
+            .highlight_range(FileRange {
+                file_id,
+                range: TextRange::offset_len(82.into(), 1.into()),
+            })
+            .unwrap();
+        assert_eq!(&highlights[0].highlight.to_string(), "field");
+    }
 }
diff --git a/crates/ra_ide/src/syntax_highlighting/html.rs b/crates/ra_ide/src/syntax_highlighting/html.rs
new file mode 100644
index 000000000..210d9a57b
--- /dev/null
+++ b/crates/ra_ide/src/syntax_highlighting/html.rs
@@ -0,0 +1,104 @@
+//! Renders a bit of code as HTML.
+use ra_db::SourceDatabase;
+use ra_syntax::AstNode;
+use crate::{FileId, HighlightedRange, RootDatabase};
+use super::highlight;
+pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
+    let parse = db.parse(file_id);
+    fn rainbowify(seed: u64) -> String {
+        use rand::prelude::*;
+        let mut rng = SmallRng::seed_from_u64(seed);
+        format!(
+            "hsl({h},{s}%,{l}%)",
+            h = rng.gen_range::<u16, _, _>(0, 361),
+            s = rng.gen_range::<u16, _, _>(42, 99),
+            l = rng.gen_range::<u16, _, _>(40, 91),
+        )
+    }
+    let mut ranges = highlight(db, file_id, None);
+    ranges.sort_by_key(|it| it.range.start());
+    // quick non-optimal heuristic to intersect token ranges and highlighted ranges
+    let mut frontier = 0;
+    let mut could_intersect: Vec<&HighlightedRange> = Vec::new();
+    let mut buf = String::new();
+    buf.push_str(&STYLE);
+    buf.push_str("<pre><code>");
+    let tokens = parse.tree().syntax().descendants_with_tokens().filter_map(|it| it.into_token());
+    for token in tokens {
+        could_intersect.retain(|it| token.text_range().start() <= it.range.end());
+        while let Some(r) = ranges.get(frontier) {
+            if r.range.start() <= token.text_range().end() {
+                could_intersect.push(r);
+                frontier += 1;
+            } else {
+                break;
+            }
+        }
+        let text = html_escape(&token.text());
+        let ranges = could_intersect
+            .iter()
+            .filter(|it| token.text_range().is_subrange(&it.range))
+            .collect::<Vec<_>>();
+        if ranges.is_empty() {
+            buf.push_str(&text);
+        } else {
+            let classes = ranges
+                .iter()
+                .map(|it| it.highlight.to_string().replace('.', " "))
+                .collect::<Vec<_>>()
+                .join(" ");
+            let binding_hash = ranges.first().and_then(|x| x.binding_hash);
+            let color = match (rainbow, binding_hash) {
+                (true, Some(hash)) => format!(
+                    " data-binding-hash=\"{}\" style=\"color: {};\"",
+                    hash,
+                    rainbowify(hash)
+                ),
+                _ => "".into(),
+            };
+            buf.push_str(&format!("<span class=\"{}\"{}>{}</span>", classes, color, text));
+        }
+    }
+    buf.push_str("</code></pre>");
+    buf
+}
+//FIXME: like, real html escaping
+fn html_escape(text: &str) -> String {
+    text.replace("<", "&lt;").replace(">", "&gt;")
+}
+const STYLE: &str = "
+<style>
+body                { margin: 0; }
+pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
+.comment            { color: #7F9F7F; }
+.string             { color: #CC9393; }
+.field              { color: #94BFF3; }
+.function           { color: #93E0E3; }
+.parameter          { color: #94BFF3; }
+.text               { color: #DCDCCC; }
+.type               { color: #7CB8BB; }
+.type.builtin       { color: #8CD0D3; }
+.type.param         { color: #20999D; }
+.attribute          { color: #94BFF3; }
+.literal            { color: #BFEBBF; }
+.literal.numeric    { color: #6A8759; }
+.macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
+.variable           { color: #DCDCCC; }
+.variable.mut       { color: #DCDCCC; text-decoration: underline; }
+.keyword            { color: #F0DFAF; }
+.keyword.unsafe     { color: #DFAF8F; }
+.keyword.control    { color: #F0DFAF; font-weight: bold; }
+</style>
+";
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
new file mode 100644
index 000000000..383c74c98
--- /dev/null
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -0,0 +1,163 @@
+//! Defines token tags we use for syntax highlighting.
+//! A tag is not unlike a CSS class.
+use std::{fmt, ops};
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Highlight {
+    pub tag: HighlightTag,
+    pub modifiers: HighlightModifiers,
+}
+#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct HighlightModifiers(u32);
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum HighlightTag {
+    Field,
+    Function,
+    Module,
+    Constant,
+    Macro,
+    Variable,
+    Type,
+    TypeSelf,
+    TypeParam,
+    TypeLifetime,
+    LiteralByte,
+    LiteralNumeric,
+    LiteralChar,
+    Comment,
+    LiteralString,
+    Attribute,
+    Keyword,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[repr(u8)]
+pub enum HighlightModifier {
+    Mutable = 0,
+    Unsafe,
+    /// Used with keywords like `if` and `break`.
+    Control,
+    Builtin,
+}
+impl HighlightTag {
+    fn as_str(self) -> &'static str {
+        match self {
+            HighlightTag::Field => "field",
+            HighlightTag::Function => "function",
+            HighlightTag::Module => "module",
+            HighlightTag::Constant => "constant",
+            HighlightTag::Macro => "macro",
+            HighlightTag::Variable => "variable",
+            HighlightTag::Type => "type",
+            HighlightTag::TypeSelf => "type.self",
+            HighlightTag::TypeParam => "type.param",
+            HighlightTag::TypeLifetime => "type.lifetime",
+            HighlightTag::LiteralByte => "literal.byte",
+            HighlightTag::LiteralNumeric => "literal.numeric",
+            HighlightTag::LiteralChar => "literal.char",
+            HighlightTag::Comment => "comment",
+            HighlightTag::LiteralString => "string",
+            HighlightTag::Attribute => "attribute",
+            HighlightTag::Keyword => "keyword",
+        }
+    }
+}
+impl fmt::Display for HighlightTag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+impl HighlightModifier {
+    const ALL: &'static [HighlightModifier] = &[
+        HighlightModifier::Mutable,
+        HighlightModifier::Unsafe,
+        HighlightModifier::Control,
+        HighlightModifier::Builtin,
+    ];
+    fn as_str(self) -> &'static str {
+        match self {
+            HighlightModifier::Mutable => "mutable",
+            HighlightModifier::Unsafe => "unsafe",
+            HighlightModifier::Control => "control",
+            HighlightModifier::Builtin => "builtin",
+        }
+    }
+    fn mask(self) -> u32 {
+        1 << (self as u32)
+    }
+}
+impl fmt::Display for HighlightModifier {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+impl fmt::Display for Highlight {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.tag)?;
+        for modifier in self.modifiers.iter() {
+            write!(f, ".{}", modifier)?
+        }
+        Ok(())
+    }
+}
+impl From<HighlightTag> for Highlight {
+    fn from(tag: HighlightTag) -> Highlight {
+        Highlight::new(tag)
+    }
+}
+impl Highlight {
+    pub(crate) fn new(tag: HighlightTag) -> Highlight {
+        Highlight { tag, modifiers: HighlightModifiers::default() }
+    }
+}
+impl ops::BitOr<HighlightModifier> for HighlightTag {
+    type Output = Highlight;
+    fn bitor(self, rhs: HighlightModifier) -> Highlight {
+        Highlight::new(self) | rhs
+    }
+}
+impl ops::BitOrAssign<HighlightModifier> for HighlightModifiers {
+    fn bitor_assign(&mut self, rhs: HighlightModifier) {
+        self.0 |= rhs.mask();
+    }
+}
+impl ops::BitOrAssign<HighlightModifier> for Highlight {
+    fn bitor_assign(&mut self, rhs: HighlightModifier) {
+        self.modifiers |= rhs;
+    }
+}
+impl ops::BitOr<HighlightModifier> for Highlight {
+    type Output = Highlight;
+    fn bitor(mut self, rhs: HighlightModifier) -> Highlight {
+        self |= rhs;
+        self
+    }
+}
+impl HighlightModifiers {
+    pub fn iter(self) -> impl Iterator<Item = HighlightModifier> {
+        HighlightModifier::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
+    }
+}
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index ee409e34e..7b285d280 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -11,30 +11,17 @@ doctest = false
 wasm = []
 [dependencies]
-either = "1.5.3"
-format-buf = "1.0.0"
-indexmap = "1.3.2"
-itertools = "0.8.2"
-join_to_string = "0.1.3"
 log = "0.4.8"
 rayon = "1.3.0"
 fst = { version = "0.3.5", default-features = false }
 rustc-hash = "1.1.0"
-unicase = "2.6.0"
 superslice = "1.0.0"
-once_cell = "1.3.1"
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
 ra_db = { path = "../ra_db" }
-ra_cfg = { path = "../ra_cfg" }
-ra_fmt = { path = "../ra_fmt" }
 ra_prof = { path = "../ra_prof" }
-test_utils = { path = "../test_utils" }
 # ra_ide should depend only on the top-level `hir` package. if you need
 # something from some `hir_xxx` subpackage, reexport the API via `hir`.
 hir = { path = "../ra_hir", package = "ra_hir" }
-[dev-dependencies]
-insta = "0.13.1"
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 04c214624..e10e72f71 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,8 +6,8 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 use hir::{
-    Adt, FieldSource, HasSource, ImplBlock, InFile, Local, MacroDef, Module, ModuleDef,
+    Adt, FieldSource, HasSource, ImplBlock, Local, MacroDef, Module, ModuleDef, Semantics,
-    SourceBinder, StructField, TypeParam,
+    StructField, TypeParam,
 };
 use ra_prof::profile;
 use ra_syntax::{
@@ -68,78 +68,62 @@ impl NameDefinition {
    }
 }
-pub fn classify_name(
+pub fn classify_name(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<NameDefinition> {
-    sb: &mut SourceBinder<RootDatabase>,
-    name: InFile<&ast::Name>,
-) -> Option<NameDefinition> {
    let _p = profile("classify_name");
-    let parent = name.value.syntax().parent()?;
+    let parent = name.syntax().parent()?;
    match_ast! {
        match parent {
            ast::BindPat(it) => {
-                let src = name.with_value(it);
+                let local = sema.to_def(&it)?;
-                let local = sb.to_def(src)?;
                Some(NameDefinition::Local(local))
            },
            ast::RecordFieldDef(it) => {
-                let src = name.with_value(it);
+                let field: hir::StructField = sema.to_def(&it)?;
-                let field: hir::StructField = sb.to_def(src)?;
                Some(from_struct_field(field))
            },
            ast::Module(it) => {
-                let def = sb.to_def(name.with_value(it))?;
+                let def = sema.to_def(&it)?;
                Some(from_module_def(def.into()))
            },
            ast::StructDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::Struct = sema.to_def(&it)?;
-                let def: hir::Struct = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::EnumDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::Enum = sema.to_def(&it)?;
-                let def: hir::Enum = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::TraitDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::Trait = sema.to_def(&it)?;
-                let def: hir::Trait = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::StaticDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::Static = sema.to_def(&it)?;
-                let def: hir::Static = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::EnumVariant(it) => {
-                let src = name.with_value(it);
+                let def: hir::EnumVariant = sema.to_def(&it)?;
-                let def: hir::EnumVariant = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::FnDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::Function = sema.to_def(&it)?;
-                let def: hir::Function = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::ConstDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::Const = sema.to_def(&it)?;
-                let def: hir::Const = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::TypeAliasDef(it) => {
-                let src = name.with_value(it);
+                let def: hir::TypeAlias = sema.to_def(&it)?;
-                let def: hir::TypeAlias = sb.to_def(src)?;
                Some(from_module_def(def.into()))
            },
            ast::MacroCall(it) => {
-                let src = name.with_value(it);
+                let def = sema.to_def(&it)?;
-                let def = sb.to_def(src.clone())?;
                Some(NameDefinition::Macro(def))
            },
            ast::TypeParam(it) => {
-                let src = name.with_value(it);
+                let def = sema.to_def(&it)?;
-                let def = sb.to_def(src)?;
                Some(NameDefinition::TypeParam(def))
            },
            _ => None,
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index b8dd358a9..e590d2a5c 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the ra_assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
-use hir::{db::HirDatabase, ModuleDef, SourceBinder};
+use hir::{ModuleDef, Semantics};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
@@ -12,17 +12,17 @@ use crate::{
 };
 pub struct ImportsLocator<'a> {
-    source_binder: SourceBinder<'a, RootDatabase>,
+    sema: Semantics<'a, RootDatabase>,
 }
 impl<'a> ImportsLocator<'a> {
    pub fn new(db: &'a RootDatabase) -> Self {
-        Self { source_binder: SourceBinder::new(db) }
+        Self { sema: Semantics::new(db) }
    }
    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<ModuleDef> {
        let _p = profile("search_for_imports");
-        let db = self.source_binder.db;
+        let db = self.sema.db;
        let project_results = {
            let mut query = Query::new(name_to_import.to_string());
@@ -41,7 +41,7 @@ impl<'a> ImportsLocator<'a> {
        project_results
            .into_iter()
            .chain(lib_results.into_iter())
-            .filter_map(|import_candidate| self.get_name_definition(db, &import_candidate))
+            .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
            .filter_map(|name_definition_to_import| match name_definition_to_import {
                NameDefinition::ModuleDef(module_def) => Some(module_def),
                _ => None,
@@ -49,22 +49,16 @@ impl<'a> ImportsLocator<'a> {
            .collect()
    }
-    fn get_name_definition(
+    fn get_name_definition(&mut self, import_candidate: &FileSymbol) -> Option<NameDefinition> {
-        &mut self,
-        db: &impl HirDatabase,
-        import_candidate: &FileSymbol,
-    ) -> Option<NameDefinition> {
        let _p = profile("get_name_definition");
-        let file_id = import_candidate.file_id.into();
+        let file_id = import_candidate.file_id;
-        let candidate_node = import_candidate.ptr.to_node(&db.parse_or_expand(file_id)?);
+        let candidate_node = import_candidate.ptr.to_node(self.sema.parse(file_id).syntax());
        let candidate_name_node = if candidate_node.kind() != NAME {
            candidate_node.children().find(|it| it.kind() == NAME)?
        } else {
            candidate_node
        };
-        classify_name(
+        classify_name(&self.sema, &ast::Name::cast(candidate_name_node)?)
-            &mut self.source_binder,
-            hir::InFile { file_id, value: &ast::Name::cast(candidate_name_node)? },
-        )
    }
 }
diff --git a/crates/ra_prof/Cargo.toml b/crates/ra_prof/Cargo.toml
index 823745795..d15b08992 100644
--- a/crates/ra_prof/Cargo.toml
+++ b/crates/ra_prof/Cargo.toml
@@ -10,7 +10,6 @@ doctest = false
 [dependencies]
 once_cell = "1.3.1"
-itertools = "0.8.2"
 backtrace = { version = "0.3.44", optional = true }
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 7891628dc..8efc6b368 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 itertools = "0.8.2"
-rowan = "0.9.0"
+rowan = "0.9.1"
 rustc_lexer = "0.1.0"
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index 21fca99a6..ebf59288a 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -4,10 +4,11 @@ use std::ops::RangeInclusive;
 use itertools::Itertools;
 use ra_text_edit::TextEditBuilder;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
-    AstNode, Direction, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
+    AstNode, Direction, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken,
+    TextRange, TextUnit,
 };
 /// Returns ancestors of the node at the offset, sorted by length. This should
@@ -37,6 +38,17 @@ pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextUnit) ->
    ancestors_at_offset(syntax, offset).find_map(N::cast)
 }
+/// Skip to next non `trivia` token
+pub fn skip_trivia_token(mut token: SyntaxToken, direction: Direction) -> Option<SyntaxToken> {
+    while token.kind().is_trivia() {
+        token = match direction {
+            Direction::Next => token.next_token()?,
+            Direction::Prev => token.prev_token()?,
+        }
+    }
+    Some(token)
+}
 /// Finds the first sibling in the given direction which is not `trivia`
 pub fn non_trivia_sibling(element: SyntaxElement, direction: Direction) -> Option<SyntaxElement> {
    return match element {
@@ -56,6 +68,11 @@ pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxEleme
    root.covering_element(range)
 }
+pub fn least_common_ancestor(u: &SyntaxNode, v: &SyntaxNode) -> Option<SyntaxNode> {
+    let u_ancestors = u.ancestors().collect::<FxHashSet<SyntaxNode>>();
+    v.ancestors().find(|it| u_ancestors.contains(it))
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum InsertPosition<T> {
    First,
diff --git a/crates/ra_text_edit/Cargo.toml b/crates/ra_text_edit/Cargo.toml
index a32149299..cae28389d 100644
--- a/crates/ra_text_edit/Cargo.toml
+++ b/crates/ra_text_edit/Cargo.toml
@@ -9,7 +9,5 @@ publish = false
 doctest = false
 [dependencies]
-text_unit = "0.1.9"
+text_unit = "0.1.10"
-[dev-dependencies]
-test_utils = { path = "../test_utils" }
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index c5d6e3831..d00545121 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -15,13 +15,12 @@ path = "./src/bin/main.rs"
 [dependencies]
 anyhow = "1.0.26"
 crossbeam-channel = "0.4.0"
-either = "1.5.3"
 env_logger = { version = "0.7.1", default-features = false }
 globset = "0.4.4"
 itertools = "0.8.2"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.70.1", features = ["proposed"] }
+lsp-types = { version = "0.71.0", features = ["proposed"] }
 parking_lot = "0.10.0"
 pico-args = "0.3.1"
 rand = { version = "0.7.3", features = ["small_rng"] }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index c9fd645f1..759bceb32 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -1,12 +1,15 @@
 //! Advertizes the capabilities of the LSP Server.
+use crate::semantic_tokens;
 use lsp_types::{
    CallHierarchyServerCapability, CodeActionProviderCapability, CodeLensOptions,
    CompletionOptions, DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability,
    ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
-    SelectionRangeProviderCapability, ServerCapabilities, SignatureHelpOptions,
+    SelectionRangeProviderCapability, SemanticTokensDocumentProvider, SemanticTokensLegend,
-    TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
+    SemanticTokensOptions, ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability,
-    TypeDefinitionProviderCapability, WorkDoneProgressOptions,
+    TextDocumentSyncKind, TextDocumentSyncOptions, TypeDefinitionProviderCapability,
+    WorkDoneProgressOptions,
 };
 pub fn server_capabilities() -> ServerCapabilities {
@@ -57,7 +60,19 @@ pub fn server_capabilities() -> ServerCapabilities {
        execute_command_provider: None,
        workspace: None,
        call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
-        semantic_tokens_provider: None,
+        semantic_tokens_provider: Some(
+            SemanticTokensOptions {
+                legend: SemanticTokensLegend {
+                    token_types: semantic_tokens::SUPPORTED_TYPES.iter().cloned().collect(),
+                    token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.iter().cloned().collect(),
+                },
+                document_provider: Some(SemanticTokensDocumentProvider::Bool(true)),
+                range_provider: Some(true),
+                work_done_progress_options: Default::default(),
+            }
+            .into(),
+        ),
        experimental: Default::default(),
    }
 }
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs
index 90ef74056..b012f5dd5 100644
--- a/crates/rust-analyzer/src/conv.rs
+++ b/crates/rust-analyzer/src/conv.rs
@@ -4,19 +4,27 @@
 use lsp_types::{
    self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
    Location, LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp,
-    SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem,
+    SemanticTokenModifier, SemanticTokenType, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
-    TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit,
+    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier,
+    WorkspaceEdit,
 };
 use ra_ide::{
    translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
-    FileRange, FileSystemEdit, Fold, FoldKind, InsertTextFormat, LineCol, LineIndex,
+    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag,
-    NavigationTarget, RangeInfo, ReferenceAccess, Severity, SourceChange, SourceFileEdit,
+    InsertTextFormat, LineCol, LineIndex, NavigationTarget, RangeInfo, ReferenceAccess, Severity,
+    SourceChange, SourceFileEdit,
 };
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 use ra_vfs::LineEndings;
-use crate::{req, world::WorldSnapshot, Result};
+use crate::{
+    req,
+    semantic_tokens::{self, ModifierSet, BUILTIN, CONSTANT, CONTROL, MUTABLE, UNSAFE},
+    world::WorldSnapshot,
+    Result,
+};
+use semantic_tokens::ATTRIBUTE;
 pub trait Conv {
    type Output;
@@ -302,6 +310,55 @@ impl ConvWith<&FoldConvCtx<'_>> for Fold {
    }
 }
+impl Conv for Highlight {
+    type Output = (u32, u32);
+    fn conv(self) -> Self::Output {
+        let mut mods = ModifierSet::default();
+        let type_ = match self.tag {
+            HighlightTag::Field => SemanticTokenType::MEMBER,
+            HighlightTag::Function => SemanticTokenType::FUNCTION,
+            HighlightTag::Module => SemanticTokenType::NAMESPACE,
+            HighlightTag::Constant => {
+                mods |= SemanticTokenModifier::STATIC;
+                mods |= SemanticTokenModifier::READONLY;
+                CONSTANT
+            }
+            HighlightTag::Macro => SemanticTokenType::MACRO,
+            HighlightTag::Variable => SemanticTokenType::VARIABLE,
+            HighlightTag::Type => SemanticTokenType::TYPE,
+            HighlightTag::TypeSelf => {
+                mods |= SemanticTokenModifier::REFERENCE;
+                SemanticTokenType::TYPE
+            }
+            HighlightTag::TypeParam => SemanticTokenType::TYPE_PARAMETER,
+            HighlightTag::TypeLifetime => {
+                mods |= SemanticTokenModifier::REFERENCE;
+                SemanticTokenType::LABEL
+            }
+            HighlightTag::LiteralByte => SemanticTokenType::NUMBER,
+            HighlightTag::LiteralNumeric => SemanticTokenType::NUMBER,
+            HighlightTag::LiteralChar => SemanticTokenType::NUMBER,
+            HighlightTag::Comment => SemanticTokenType::COMMENT,
+            HighlightTag::LiteralString => SemanticTokenType::STRING,
+            HighlightTag::Attribute => ATTRIBUTE,
+            HighlightTag::Keyword => SemanticTokenType::KEYWORD,
+        };
+        for modifier in self.modifiers.iter() {
+            let modifier = match modifier {
+                HighlightModifier::Mutable => MUTABLE,
+                HighlightModifier::Unsafe => UNSAFE,
+                HighlightModifier::Control => CONTROL,
+                HighlightModifier::Builtin => BUILTIN,
+            };
+            mods |= modifier;
+        }
+        (semantic_tokens::type_index(type_), mods.0)
+    }
+}
 impl<T: ConvWith<CTX>, CTX> ConvWith<CTX> for Option<T> {
    type Output = Option<T::Output>;
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 0dae30e46..a0f968823 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -36,6 +36,7 @@ pub mod req;
 mod config;
 mod world;
 mod diagnostics;
+mod semantic_tokens;
 use serde::de::DeserializeOwned;
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 98306986b..2b25f5443 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -527,6 +527,8 @@ fn on_request(
        .on::<req::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
        .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)?
        .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)?
+        .on::<req::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
+        .on::<req::SemanticTokensRangeRequest>(handlers::handle_semantic_tokens_range)?
        .on::<req::Ssr>(handlers::handle_ssr)?
        .finish();
    Ok(())
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index bb7bab372..9ed53169c 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -16,8 +16,9 @@ use lsp_types::{
    CodeAction, CodeActionOrCommand, CodeActionResponse, CodeLens, Command, CompletionItem,
    Diagnostic, DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
    FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind, Position,
-    PrepareRenameResponse, Range, RenameParams, SymbolInformation, TextDocumentIdentifier,
+    PrepareRenameResponse, Range, RenameParams, SemanticTokens, SemanticTokensParams,
-    TextEdit, WorkspaceEdit,
+    SemanticTokensRangeParams, SemanticTokensRangeResult, SemanticTokensResult, SymbolInformation,
+    TextDocumentIdentifier, TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
    AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
@@ -38,6 +39,7 @@ use crate::{
    diagnostics::DiagnosticTask,
    from_json,
    req::{self, Decoration, InlayHint, InlayHintsParams, InlayKind},
+    semantic_tokens::SemanticTokensBuilder,
    world::WorldSnapshot,
    LspError, Result,
 };
@@ -952,7 +954,7 @@ fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>>
        .into_iter()
        .map(|h| Decoration {
            range: h.range.conv_with(&line_index),
-            tag: h.tag,
+            tag: h.highlight.to_string(),
            binding_hash: h.binding_hash.map(|x| x.to_string()),
        })
        .collect();
@@ -1068,3 +1070,45 @@ pub fn handle_call_hierarchy_outgoing(
    Ok(Some(res))
 }
+pub fn handle_semantic_tokens(
+    world: WorldSnapshot,
+    params: SemanticTokensParams,
+) -> Result<Option<SemanticTokensResult>> {
+    let _p = profile("handle_semantic_tokens");
+    let file_id = params.text_document.try_conv_with(&world)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let mut builder = SemanticTokensBuilder::default();
+    for highlight_range in world.analysis().highlight(file_id)?.into_iter() {
+        let (token_type, token_modifiers) = highlight_range.highlight.conv();
+        builder.push(highlight_range.range.conv_with(&line_index), token_type, token_modifiers);
+    }
+    let tokens = SemanticTokens { data: builder.build(), ..Default::default() };
+    Ok(Some(tokens.into()))
+}
+pub fn handle_semantic_tokens_range(
+    world: WorldSnapshot,
+    params: SemanticTokensRangeParams,
+) -> Result<Option<SemanticTokensRangeResult>> {
+    let _p = profile("handle_semantic_tokens_range");
+    let frange = (&params.text_document, params.range).try_conv_with(&world)?;
+    let line_index = world.analysis().file_line_index(frange.file_id)?;
+    let mut builder = SemanticTokensBuilder::default();
+    for highlight_range in world.analysis().highlight_range(frange)?.into_iter() {
+        let (token_type, token_modifiers) = highlight_range.highlight.conv();
+        builder.push(highlight_range.range.conv_with(&line_index), token_type, token_modifiers);
+    }
+    let tokens = SemanticTokens { data: builder.build(), ..Default::default() };
+    Ok(Some(tokens.into()))
+}
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index 7ff7f60b3..fd6aef597 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -12,9 +12,10 @@ pub use lsp_types::{
    DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
    PartialResultParams, ProgressParams, ProgressParamsValue, ProgressToken,
    PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams, SelectionRange,
-    SelectionRangeParams, ServerCapabilities, ShowMessageParams, SignatureHelp, SymbolKind,
+    SelectionRangeParams, SemanticTokensParams, SemanticTokensRangeParams,
-    TextDocumentEdit, TextDocumentPositionParams, TextEdit, WorkDoneProgressParams, WorkspaceEdit,
+    SemanticTokensRangeResult, SemanticTokensResult, ServerCapabilities, ShowMessageParams,
-    WorkspaceSymbolParams,
+    SignatureHelp, SymbolKind, TextDocumentEdit, TextDocumentPositionParams, TextEdit,
+    WorkDoneProgressParams, WorkspaceEdit, WorkspaceSymbolParams,
 };
 pub enum AnalyzerStatus {}
@@ -111,7 +112,7 @@ pub struct PublishDecorationsParams {
 #[serde(rename_all = "camelCase")]
 pub struct Decoration {
    pub range: Range,
-    pub tag: &'static str,
+    pub tag: String,
    pub binding_hash: Option<String>,
 }
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
new file mode 100644
index 000000000..d8362409d
--- /dev/null
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -0,0 +1,114 @@
+//! Semantic Tokens helpers
+use std::ops;
+use lsp_types::{Range, SemanticToken, SemanticTokenModifier, SemanticTokenType};
+pub(crate) const ATTRIBUTE: SemanticTokenType = SemanticTokenType::new("attribute");
+pub(crate) const CONSTANT: SemanticTokenType = SemanticTokenType::new("constant");
+pub(crate) const MUTABLE: SemanticTokenModifier = SemanticTokenModifier::new("mutable");
+pub(crate) const UNSAFE: SemanticTokenModifier = SemanticTokenModifier::new("unsafe");
+pub(crate) const CONTROL: SemanticTokenModifier = SemanticTokenModifier::new("control");
+pub(crate) const BUILTIN: SemanticTokenModifier = SemanticTokenModifier::new("builtin");
+pub(crate) const SUPPORTED_TYPES: &[SemanticTokenType] = &[
+    SemanticTokenType::COMMENT,
+    SemanticTokenType::KEYWORD,
+    SemanticTokenType::STRING,
+    SemanticTokenType::NUMBER,
+    SemanticTokenType::REGEXP,
+    SemanticTokenType::OPERATOR,
+    SemanticTokenType::NAMESPACE,
+    SemanticTokenType::TYPE,
+    SemanticTokenType::STRUCT,
+    SemanticTokenType::CLASS,
+    SemanticTokenType::INTERFACE,
+    SemanticTokenType::ENUM,
+    SemanticTokenType::TYPE_PARAMETER,
+    SemanticTokenType::FUNCTION,
+    SemanticTokenType::MEMBER,
+    SemanticTokenType::PROPERTY,
+    SemanticTokenType::MACRO,
+    SemanticTokenType::VARIABLE,
+    SemanticTokenType::PARAMETER,
+    SemanticTokenType::LABEL,
+    ATTRIBUTE,
+    CONSTANT,
+];
+pub(crate) const SUPPORTED_MODIFIERS: &[SemanticTokenModifier] = &[
+    SemanticTokenModifier::DOCUMENTATION,
+    SemanticTokenModifier::DECLARATION,
+    SemanticTokenModifier::DEFINITION,
+    SemanticTokenModifier::REFERENCE,
+    SemanticTokenModifier::STATIC,
+    SemanticTokenModifier::ABSTRACT,
+    SemanticTokenModifier::DEPRECATED,
+    SemanticTokenModifier::ASYNC,
+    SemanticTokenModifier::VOLATILE,
+    SemanticTokenModifier::READONLY,
+    MUTABLE,
+    UNSAFE,
+    CONTROL,
+    BUILTIN,
+];
+#[derive(Default)]
+pub(crate) struct ModifierSet(pub(crate) u32);
+impl ops::BitOrAssign<SemanticTokenModifier> for ModifierSet {
+    fn bitor_assign(&mut self, rhs: SemanticTokenModifier) {
+        let idx = SUPPORTED_MODIFIERS.iter().position(|it| it == &rhs).unwrap();
+        self.0 |= 1 << idx;
+    }
+}
+/// Tokens are encoded relative to each other.
+///
+/// This is a direct port of https://github.com/microsoft/vscode-languageserver-node/blob/f425af9de46a0187adb78ec8a46b9b2ce80c5412/server/src/sematicTokens.proposed.ts#L45
+#[derive(Default)]
+pub(crate) struct SemanticTokensBuilder {
+    prev_line: u32,
+    prev_char: u32,
+    data: Vec<SemanticToken>,
+}
+impl SemanticTokensBuilder {
+    /// Push a new token onto the builder
+    pub fn push(&mut self, range: Range, token_index: u32, modifier_bitset: u32) {
+        let mut push_line = range.start.line as u32;
+        let mut push_char = range.start.character as u32;
+        if !self.data.is_empty() {
+            push_line -= self.prev_line;
+            if push_line == 0 {
+                push_char -= self.prev_char;
+            }
+        }
+        // A token cannot be multiline
+        let token_len = range.end.character - range.start.character;
+        let token = SemanticToken {
+            delta_line: push_line,
+            delta_start: push_char,
+            length: token_len as u32,
+            token_type: token_index,
+            token_modifiers_bitset: modifier_bitset,
+        };
+        self.data.push(token);
+        self.prev_line = range.start.line as u32;
+        self.prev_char = range.start.character as u32;
+    }
+    pub fn build(self) -> Vec<SemanticToken> {
+        self.data
+    }
+}
+pub fn type_index(type_: SemanticTokenType) -> u32 {
+    SUPPORTED_TYPES.iter().position(|it| *it == type_).unwrap() as u32
+}
diff --git a/crates/test_utils/Cargo.toml b/crates/test_utils/Cargo.toml
index 971592b73..6a7c6d6f9 100644
--- a/crates/test_utils/Cargo.toml
+++ b/crates/test_utils/Cargo.toml
@@ -9,5 +9,5 @@ doctest = false
 [dependencies]
 difference = "2.0.0"
-text_unit = "0.1.9"
+text_unit = "0.1.10"
 serde_json = "1.0.48"
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index e6e8d7110..69deddcb5 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -83,6 +83,7 @@ fn try_extract_range(text: &str) -> Option<(TextRange, String)> {
    Some((TextRange::from_to(start, end), text))
 }
+#[derive(Clone, Copy)]
 pub enum RangeOrOffset {
    Range(TextRange),
    Offset(TextUnit),
diff --git a/editors/code/.eslintrc.js b/editors/code/.eslintrc.js
index 16f18ab2c..c6bf410f4 100644
--- a/editors/code/.eslintrc.js
+++ b/editors/code/.eslintrc.js
@@ -32,6 +32,7 @@ module.exports = {
        "@typescript-eslint/semi": [
            "error",
            "always"
-        ]
+        ],
+        "@typescript-eslint/no-unnecessary-type-assertion": "error"
    }
 };
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 76ef2aae4..6901363fc 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -112,12 +112,6 @@
                "@types/node": "*"
            }
        },
-        "@types/throttle-debounce": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/@types/throttle-debounce/-/throttle-debounce-2.1.0.tgz",
-            "integrity": "sha512-5eQEtSCoESnh2FsiLTxE121IiE60hnMqcb435fShf4bpLRjEu1Eoekht23y6zXS9Ts3l+Szu3TARnTsA0GkOkQ==",
-            "dev": true
-        },
        "@types/vscode": {
            "version": "1.42.0",
            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.42.0.tgz",
@@ -1517,11 +1511,6 @@
            "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=",
            "dev": true
        },
-        "throttle-debounce": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/throttle-debounce/-/throttle-debounce-2.1.0.tgz",
-            "integrity": "sha512-AOvyNahXQuU7NN+VVvOOX+uW6FPaWdAOdRP5HfwYxAfCzXTFKRMoIMk+n+po318+ktcChx+F1Dd91G3YHeMKyg=="
-        },
        "through": {
            "version": "2.3.8",
            "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
@@ -1575,9 +1564,9 @@
            }
        },
        "typescript": {
-            "version": "3.7.5",
+            "version": "3.8.2",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.8.2.tgz",
-            "integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==",
+            "integrity": "sha512-EgOVgL/4xfVrCMbhYKUQTdF37SQn4Iw73H5BgCrF1Abdun7Kwy/QZsE/ssAy0y4LxBbvua3PIbFsbRczWWnDdQ==",
            "dev": true
        },
        "typescript-formatter": {
diff --git a/editors/code/package.json b/editors/code/package.json
index 9ef6c6983..ad1101603 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -18,6 +18,7 @@
    "engines": {
        "vscode": "^1.42.0"
    },
+    "enableProposedApi": true,
    "scripts": {
        "vscode:prepublish": "tsc && rollup -c",
        "package": "vsce package -o rust-analyzer.vsix",
@@ -27,7 +28,6 @@
    "dependencies": {
        "jsonc-parser": "^2.1.0",
        "node-fetch": "^2.6.0",
-        "throttle-debounce": "^2.1.0",
        "vscode-languageclient": "^6.1.1"
    },
    "devDependencies": {
@@ -35,14 +35,13 @@
        "@rollup/plugin-node-resolve": "^7.1.1",
        "@types/node": "^12.12.27",
        "@types/node-fetch": "^2.5.4",
-        "@types/throttle-debounce": "^2.1.0",
        "@types/vscode": "^1.42.0",
        "@typescript-eslint/eslint-plugin": "^2.20.0",
        "@typescript-eslint/parser": "^2.20.0",
        "eslint": "^6.8.0",
        "rollup": "^1.31.1",
        "tslib": "^1.10.0",
-        "typescript": "^3.7.5",
+        "typescript": "^3.8.2",
        "typescript-formatter": "^7.2.2",
        "vsce": "^1.73.0"
    },
@@ -169,6 +168,11 @@
            "type": "object",
            "title": "Rust Analyzer",
            "properties": {
+                "rust-analyzer.highlighting.semanticTokens": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "Use proposed semantic tokens API for syntax highlighting"
+                },
                "rust-analyzer.highlightingOn": {
                    "type": "boolean",
                    "default": false,
@@ -375,6 +379,48 @@
                    "highContrast": "#BEBEBE"
                }
            }
+        ],
+        "semanticTokenTypes": [
+            {
+                "id": "attribute"
+            },
+            {
+                "id": "constant"
+            }
+        ],
+        "semanticTokenModifiers": [
+            {
+                "id": "mutable"
+            },
+            {
+                "id": "unsafe"
+            },
+            {
+                "id": "control"
+            },
+            {
+                "id": "builtin"
+            }
+        ],
+        "semanticTokenStyleDefaults": [
+            {
+                "selector": "*.mutable",
+                "light": {
+                    "fontStyle": "underline"
+                },
+                "dark": {
+                    "fontStyle": "underline"
+                },
+                "highContrast": {
+                    "fontStyle": "underline"
+                }
+            },
+            {
+                "selector": "constant",
+                "scope": [
+                    "entity.name.constant"
+                ]
+            }
        ]
    }
 }
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index aaf2ef40e..44bd04c21 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -3,6 +3,7 @@ import * as vscode from 'vscode';
 import { Config } from './config';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
+import { SemanticTokensFeature } from 'vscode-languageclient/lib/semanticTokens.proposed';
 export async function createClient(config: Config, serverPath: string): Promise<lc.LanguageClient> {
    // '.' Is the fallback if no folder is open
@@ -26,7 +27,7 @@ export async function createClient(config: Config, serverPath: string): Promise<
    const clientOptions: lc.LanguageClientOptions = {
        documentSelector: [{ scheme: 'file', language: 'rust' }],
        initializationOptions: {
-            publishDecorations: true,
+            publishDecorations: !config.highlightingSemanticTokens,
            lruCapacity: config.lruCapacity,
            maxInlayHintLength: config.maxInlayHintLength,
            cargoWatchEnable: cargoWatchOpts.enable,
@@ -83,5 +84,10 @@ export async function createClient(config: Config, serverPath: string): Promise<
    // Here we want to just enable CallHierarchyFeature since it is available on stable.
    // Note that while the CallHierarchyFeature is stable the LSP protocol is not.
    res.registerFeature(new CallHierarchyFeature(res));
+    if (config.highlightingSemanticTokens) {
+        res.registerFeature(new SemanticTokensFeature(res));
+    }
    return res;
 }
diff --git a/editors/code/src/commands/analyzer_status.ts b/editors/code/src/commands/analyzer_status.ts
index 6631e8db7..1c6ea399b 100644
--- a/editors/code/src/commands/analyzer_status.ts
+++ b/editors/code/src/commands/analyzer_status.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
 // Shows status of rust-analyzer (for debugging)
@@ -50,10 +51,7 @@ class TextDocumentContentProvider
        const client = this.ctx.client;
        if (!editor || !client) return '';
-        return client.sendRequest<string>(
+        return client.sendRequest(ra.analyzerStatus, null);
-            'rust-analyzer/analyzerStatus',
-            null,
-        );
    }
    get onDidChange(): vscode.Event<vscode.Uri> {
diff --git a/editors/code/src/commands/expand_macro.ts b/editors/code/src/commands/expand_macro.ts
index edec9bbc1..23f2ef1d5 100644
--- a/editors/code/src/commands/expand_macro.ts
+++ b/editors/code/src/commands/expand_macro.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
@@ -26,12 +26,7 @@ export function expandMacro(ctx: Ctx): Cmd {
    };
 }
-interface ExpandedMacro {
+function codeFormat(expanded: ra.ExpandedMacro): string {
-    name: string;
-    expansion: string;
-}
-function codeFormat(expanded: ExpandedMacro): string {
    let result = `// Recursive expansion of ${expanded.name}! macro\n`;
    result += '// ' + '='.repeat(result.length - 3);
    result += '\n\n';
@@ -54,14 +49,11 @@ class TextDocumentContentProvider
        if (!editor || !client) return '';
        const position = editor.selection.active;
-        const request: lc.TextDocumentPositionParams = {
+        const expanded = await client.sendRequest(ra.expandMacro, {
            textDocument: { uri: editor.document.uri.toString() },
            position,
-        };
+        });
-        const expanded = await client.sendRequest<ExpandedMacro>(
-            'rust-analyzer/expandMacro',
-            request,
-        );
        if (expanded == null) return 'Not available';
diff --git a/editors/code/src/commands/index.ts b/editors/code/src/commands/index.ts
index 839245f48..bdb7fc3b0 100644
--- a/editors/code/src/commands/index.ts
+++ b/editors/code/src/commands/index.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
 import * as sourceChange from '../source_change';
@@ -16,9 +17,7 @@ export * from './ssr';
 export * from './server_version';
 export function collectGarbage(ctx: Ctx): Cmd {
-    return async () => {
+    return async () => ctx.client.sendRequest(ra.collectGarbage, null);
-        await ctx.client?.sendRequest<null>('rust-analyzer/collectGarbage', null);
-    };
 }
 export function showReferences(ctx: Ctx): Cmd {
@@ -36,13 +35,13 @@ export function showReferences(ctx: Ctx): Cmd {
 }
 export function applySourceChange(ctx: Ctx): Cmd {
-    return async (change: sourceChange.SourceChange) => {
+    return async (change: ra.SourceChange) => {
        await sourceChange.applySourceChange(ctx, change);
    };
 }
 export function selectAndApplySourceChange(ctx: Ctx): Cmd {
-    return async (changes: sourceChange.SourceChange[]) => {
+    return async (changes: ra.SourceChange[]) => {
        if (changes.length === 1) {
            await sourceChange.applySourceChange(ctx, changes[0]);
        } else if (changes.length > 0) {
diff --git a/editors/code/src/commands/join_lines.ts b/editors/code/src/commands/join_lines.ts
index 7b08c3255..de0614653 100644
--- a/editors/code/src/commands/join_lines.ts
+++ b/editors/code/src/commands/join_lines.ts
@@ -1,7 +1,7 @@
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
-import { applySourceChange, SourceChange } from '../source_change';
+import { applySourceChange } from '../source_change';
 export function joinLines(ctx: Ctx): Cmd {
    return async () => {
@@ -9,19 +9,10 @@ export function joinLines(ctx: Ctx): Cmd {
        const client = ctx.client;
        if (!editor || !client) return;
-        const request: JoinLinesParams = {
+        const change = await client.sendRequest(ra.joinLines, {
            range: client.code2ProtocolConverter.asRange(editor.selection),
            textDocument: { uri: editor.document.uri.toString() },
-        };
+        });
-        const change = await client.sendRequest<SourceChange>(
-            'rust-analyzer/joinLines',
-            request,
-        );
        await applySourceChange(ctx, change);
    };
 }
-interface JoinLinesParams {
-    textDocument: lc.TextDocumentIdentifier;
-    range: lc.Range;
-}
diff --git a/editors/code/src/commands/matching_brace.ts b/editors/code/src/commands/matching_brace.ts
index 7c58bb7e7..a60776e2d 100644
--- a/editors/code/src/commands/matching_brace.ts
+++ b/editors/code/src/commands/matching_brace.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
@@ -9,16 +9,12 @@ export function matchingBrace(ctx: Ctx): Cmd {
        const client = ctx.client;
        if (!editor || !client) return;
-        const request: FindMatchingBraceParams = {
+        const response = await client.sendRequest(ra.findMatchingBrace, {
            textDocument: { uri: editor.document.uri.toString() },
            offsets: editor.selections.map(s =>
                client.code2ProtocolConverter.asPosition(s.active),
            ),
-        };
+        });
-        const response = await client.sendRequest<lc.Position[]>(
-            'rust-analyzer/findMatchingBrace',
-            request,
-        );
        editor.selections = editor.selections.map((sel, idx) => {
            const active = client.protocol2CodeConverter.asPosition(
                response[idx],
@@ -29,8 +25,3 @@ export function matchingBrace(ctx: Ctx): Cmd {
        editor.revealRange(editor.selection);
    };
 }
-interface FindMatchingBraceParams {
-    textDocument: lc.TextDocumentIdentifier;
-    offsets: lc.Position[];
-}
diff --git a/editors/code/src/commands/on_enter.ts b/editors/code/src/commands/on_enter.ts
index 25eaebcbe..285849db7 100644
--- a/editors/code/src/commands/on_enter.ts
+++ b/editors/code/src/commands/on_enter.ts
@@ -1,7 +1,7 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
-import { applySourceChange, SourceChange } from '../source_change';
+import { applySourceChange } from '../source_change';
 import { Cmd, Ctx } from '../ctx';
 async function handleKeypress(ctx: Ctx) {
@@ -10,16 +10,15 @@ async function handleKeypress(ctx: Ctx) {
    if (!editor || !client) return false;
-    const request: lc.TextDocumentPositionParams = {
+    const change = await client.sendRequest(ra.onEnter, {
        textDocument: { uri: editor.document.uri.toString() },
        position: client.code2ProtocolConverter.asPosition(
            editor.selection.active,
        ),
-    };
+    }).catch(_error => {
-    const change = await client.sendRequest<undefined | SourceChange>(
+        // client.logFailedRequest(OnEnterRequest.type, error);
-        'rust-analyzer/onEnter',
+        return null;
-        request,
+    });
-    );
    if (!change) return false;
    await applySourceChange(ctx, change);
diff --git a/editors/code/src/commands/parent_module.ts b/editors/code/src/commands/parent_module.ts
index bf40b4021..8f78ddd71 100644
--- a/editors/code/src/commands/parent_module.ts
+++ b/editors/code/src/commands/parent_module.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
@@ -9,16 +9,12 @@ export function parentModule(ctx: Ctx): Cmd {
        const client = ctx.client;
        if (!editor || !client) return;
-        const request: lc.TextDocumentPositionParams = {
+        const response = await client.sendRequest(ra.parentModule, {
            textDocument: { uri: editor.document.uri.toString() },
            position: client.code2ProtocolConverter.asPosition(
                editor.selection.active,
            ),
-        };
+        });
-        const response = await client.sendRequest<lc.Location[]>(
-            'rust-analyzer/parentModule',
-            request,
-        );
        const loc = response[0];
        if (loc == null) return;
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index 7919997ce..06b513466 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
@@ -14,16 +15,13 @@ export function run(ctx: Ctx): Cmd {
        const textDocument: lc.TextDocumentIdentifier = {
            uri: editor.document.uri.toString(),
        };
-        const params: RunnablesParams = {
+        const runnables = await client.sendRequest(ra.runnables, {
            textDocument,
            position: client.code2ProtocolConverter.asPosition(
                editor.selection.active,
            ),
-        };
+        });
-        const runnables = await client.sendRequest<Runnable[]>(
-            'rust-analyzer/runnables',
-            params,
-        );
        const items: RunnableQuickPick[] = [];
        if (prevRunnable) {
            items.push(prevRunnable);
@@ -48,7 +46,7 @@ export function run(ctx: Ctx): Cmd {
 }
 export function runSingle(ctx: Ctx): Cmd {
-    return async (runnable: Runnable) => {
+    return async (runnable: ra.Runnable) => {
        const editor = ctx.activeRustEditor;
        if (!editor) return;
@@ -64,26 +62,13 @@ export function runSingle(ctx: Ctx): Cmd {
    };
 }
-interface RunnablesParams {
-    textDocument: lc.TextDocumentIdentifier;
-    position?: lc.Position;
-}
-interface Runnable {
-    label: string;
-    bin: string;
-    args: string[];
-    env: { [index: string]: string };
-    cwd?: string;
-}
 class RunnableQuickPick implements vscode.QuickPickItem {
    public label: string;
    public description?: string | undefined;
    public detail?: string | undefined;
    public picked?: boolean | undefined;
-    constructor(public runnable: Runnable) {
+    constructor(public runnable: ra.Runnable) {
        this.label = runnable.label;
    }
 }
@@ -96,7 +81,7 @@ interface CargoTaskDefinition extends vscode.TaskDefinition {
    env?: { [key: string]: string };
 }
-function createTask(spec: Runnable): vscode.Task {
+function createTask(spec: ra.Runnable): vscode.Task {
    const TASK_SOURCE = 'Rust';
    const definition: CargoTaskDefinition = {
        type: 'cargo',
diff --git a/editors/code/src/commands/ssr.ts b/editors/code/src/commands/ssr.ts
index 9b814612a..eee48c693 100644
--- a/editors/code/src/commands/ssr.ts
+++ b/editors/code/src/commands/ssr.ts
@@ -1,6 +1,8 @@
-import { Ctx, Cmd } from '../ctx';
-import { applySourceChange, SourceChange } from '../source_change';
 import * as vscode from 'vscode';
+import * as ra from "../rust-analyzer-api";
+import { Ctx, Cmd } from '../ctx';
+import { applySourceChange } from '../source_change';
 export function ssr(ctx: Ctx): Cmd {
    return async () => {
@@ -21,16 +23,8 @@ export function ssr(ctx: Ctx): Cmd {
        if (!request) return;
-        const ssrRequest: SsrRequest = { arg: request };
+        const change = await client.sendRequest(ra.ssr, { arg: request });
-        const change = await client.sendRequest<SourceChange>(
-            'rust-analyzer/ssr',
-            ssrRequest,
-        );
        await applySourceChange(ctx, change);
    };
 }
-interface SsrRequest {
-    arg: string;
-}
diff --git a/editors/code/src/commands/syntax_tree.ts b/editors/code/src/commands/syntax_tree.ts
index 2887c96c8..7218bfb90 100644
--- a/editors/code/src/commands/syntax_tree.ts
+++ b/editors/code/src/commands/syntax_tree.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
@@ -61,13 +61,8 @@ function afterLs(f: () => void) {
    setTimeout(f, 10);
 }
-interface SyntaxTreeParams {
-    textDocument: lc.TextDocumentIdentifier;
-    range?: lc.Range;
-}
-class TextDocumentContentProvider
+class TextDocumentContentProvider implements vscode.TextDocumentContentProvider {
-    implements vscode.TextDocumentContentProvider {
    uri = vscode.Uri.parse('rust-analyzer://syntaxtree');
    eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -79,23 +74,15 @@ class TextDocumentContentProvider
        const client = this.ctx.client;
        if (!editor || !client) return '';
-        let range: lc.Range | undefined;
        // When the range based query is enabled we take the range of the selection
-        if (uri.query === 'range=true') {
+        const range = uri.query === 'range=true' && !editor.selection.isEmpty
-            range = editor.selection.isEmpty
+            ? client.code2ProtocolConverter.asRange(editor.selection)
-                ? undefined
+            : null;
-                : client.code2ProtocolConverter.asRange(editor.selection);
-        }
-        const request: SyntaxTreeParams = {
+        return client.sendRequest(ra.syntaxTree, {
            textDocument: { uri: editor.document.uri.toString() },
            range,
-        };
+        });
-        return client.sendRequest<string>(
-            'rust-analyzer/syntaxTree',
-            request,
-        );
    }
    get onDidChange(): vscode.Event<vscode.Uri> {
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 47e8cd45d..bf915102c 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -22,6 +22,7 @@ export class Config {
    private static readonly requiresReloadOpts = [
        "cargoFeatures",
        "cargo-watch",
+        "highlighting.semanticTokens"
    ]
        .map(opt => `${Config.rootSection}.${opt}`);
@@ -143,6 +144,7 @@ export class Config {
    // We don't do runtime config validation here for simplicity. More on stackoverflow:
    // https://stackoverflow.com/questions/60135780/what-is-the-best-way-to-type-check-the-configuration-for-vscode-extension
+    get highlightingSemanticTokens() { return this.cfg.get("highlighting.semanticTokens") as boolean; }
    get highlightingOn() { return this.cfg.get("highlightingOn") as boolean; }
    get rainbowHighlightingOn() { return this.cfg.get("rainbowHighlightingOn") as boolean; }
    get lruCapacity() { return this.cfg.get("lruCapacity") as null | number; }
diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
index 77b4a1a68..3e0cbdc56 100644
--- a/editors/code/src/highlighting.ts
+++ b/editors/code/src/highlighting.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from './rust-analyzer-api';
 import { ColorTheme, TextMateRuleSettings } from './color_theme';
@@ -8,29 +8,25 @@ import { sendRequestWithRetry } from './util';
 export function activateHighlighting(ctx: Ctx) {
    const highlighter = new Highlighter(ctx);
-    const client = ctx.client;
-    if (client != null) {
-        client.onNotification(
-            'rust-analyzer/publishDecorations',
-            (params: PublishDecorationsParams) => {
-                if (!ctx.config.highlightingOn) return;
-                const targetEditor = vscode.window.visibleTextEditors.find(
-                    editor => {
-                        const unescapedUri = unescape(
-                            editor.document.uri.toString(),
-                        );
-                        // Unescaped URI looks like:
-                        // file:///c:/Workspace/ra-test/src/main.rs
-                        return unescapedUri === params.uri;
-                    },
-                );
-                if (!targetEditor) return;
-                highlighter.setHighlights(targetEditor, params.decorations);
+    ctx.client.onNotification(ra.publishDecorations, params => {
+        if (!ctx.config.highlightingOn) return;
+        const targetEditor = vscode.window.visibleTextEditors.find(
+            editor => {
+                const unescapedUri = unescape(
+                    editor.document.uri.toString(),
+                );
+                // Unescaped URI looks like:
+                // file:///c:/Workspace/ra-test/src/main.rs
+                return unescapedUri === params.uri;
            },
        );
-    }
+        if (!targetEditor) return;
+        highlighter.setHighlights(targetEditor, params.decorations);
+    });
    vscode.workspace.onDidChangeConfiguration(
        _ => highlighter.removeHighlights(),
@@ -45,13 +41,10 @@ export function activateHighlighting(ctx: Ctx) {
            const client = ctx.client;
            if (!client) return;
-            const params: lc.TextDocumentIdentifier = {
+            const decorations = await sendRequestWithRetry(
-                uri: editor.document.uri.toString(),
-            };
-            const decorations = await sendRequestWithRetry<Decoration[]>(
                client,
-                'rust-analyzer/decorationsRequest',
+                ra.decorationsRequest,
-                params,
+                { uri: editor.document.uri.toString() },
            );
            highlighter.setHighlights(editor, decorations);
        },
@@ -60,17 +53,6 @@ export function activateHighlighting(ctx: Ctx) {
    );
 }
-interface PublishDecorationsParams {
-    uri: string;
-    decorations: Decoration[];
-}
-interface Decoration {
-    range: lc.Range;
-    tag: string;
-    bindingHash?: string;
-}
 // Based on this HSL-based color generator: https://gist.github.com/bendc/76c48ce53299e6078a76
 function fancify(seed: string, shade: 'light' | 'dark') {
    const random = randomU32Numbers(hashString(seed));
@@ -108,7 +90,7 @@ class Highlighter {
        this.decorations = null;
    }
-    public setHighlights(editor: vscode.TextEditor, highlights: Decoration[]) {
+    public setHighlights(editor: vscode.TextEditor, highlights: ra.Decoration[]) {
        const client = this.ctx.client;
        if (!client) return;
        // Initialize decorations if necessary
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 5f9229efb..5951cf1b4 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from './rust-analyzer-api';
 import { Ctx } from './ctx';
 import { log, sendRequestWithRetry } from './util';
@@ -39,16 +39,6 @@ export function activateInlayHints(ctx: Ctx) {
    void hintsUpdater.setEnabled(ctx.config.displayInlayHints);
 }
-interface InlayHintsParams {
-    textDocument: lc.TextDocumentIdentifier;
-}
-interface InlayHint {
-    range: vscode.Range;
-    kind: "TypeHint" | "ParameterHint";
-    label: string;
-}
 const typeHintDecorationType = vscode.window.createTextEditorDecorationType({
    after: {
        color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
@@ -107,9 +97,9 @@ class HintsUpdater {
        if (newHints == null) return;
        const newTypeDecorations = newHints
-            .filter(hint => hint.kind === 'TypeHint')
+            .filter(hint => hint.kind === ra.InlayKind.TypeHint)
            .map(hint => ({
-                range: hint.range,
+                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
                renderOptions: {
                    after: {
                        contentText: `: ${hint.label}`,
@@ -119,9 +109,9 @@ class HintsUpdater {
        this.setTypeDecorations(editor, newTypeDecorations);
        const newParameterDecorations = newHints
-            .filter(hint => hint.kind === 'ParameterHint')
+            .filter(hint => hint.kind === ra.InlayKind.ParameterHint)
            .map(hint => ({
-                range: hint.range,
+                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
                renderOptions: {
                    before: {
                        contentText: `${hint.label}: `,
@@ -151,20 +141,15 @@ class HintsUpdater {
        );
    }
-    private async queryHints(documentUri: string): Promise<InlayHint[] | null> {
+    private async queryHints(documentUri: string): Promise<ra.InlayHint[] | null> {
        this.pending.get(documentUri)?.cancel();
        const tokenSource = new vscode.CancellationTokenSource();
        this.pending.set(documentUri, tokenSource);
-        const request: InlayHintsParams = { textDocument: { uri: documentUri } };
+        const request = { textDocument: { uri: documentUri } };
-        return sendRequestWithRetry<InlayHint[]>(
+        return sendRequestWithRetry(this.ctx.client, ra.inlayHints, request, tokenSource.token)
-            this.ctx.client,
-            'rust-analyzer/inlayHints',
-            request,
-            tokenSource.token
-        )
            .catch(_ => null)
            .finally(() => {
                if (!tokenSource.token.isCancellationRequested) {
diff --git a/editors/code/src/installation/download_artifact.ts b/editors/code/src/installation/download_artifact.ts
index 356723aba..8ed99bf0a 100644
--- a/editors/code/src/installation/download_artifact.ts
+++ b/editors/code/src/installation/download_artifact.ts
@@ -5,7 +5,6 @@ import { strict as assert } from "assert";
 import { ArtifactReleaseInfo } from "./interfaces";
 import { downloadFile } from "./download_file";
-import { throttle } from "throttle-debounce";
 /**
 * Downloads artifact from given `downloadUrl`.
@@ -38,19 +37,15 @@ export async function downloadArtifact(
        async (progress, _cancellationToken) => {
            let lastPrecentage = 0;
            const filePermissions = 0o755; // (rwx, r_x, r_x)
-            await downloadFile(downloadUrl, installationPath, filePermissions, throttle(
+            await downloadFile(downloadUrl, installationPath, filePermissions, (readBytes, totalBytes) => {
-                200,
+                const newPercentage = (readBytes / totalBytes) * 100;
-                /* noTrailing: */ true,
+                progress.report({
-                (readBytes, totalBytes) => {
+                    message: newPercentage.toFixed(0) + "%",
-                    const newPercentage = (readBytes / totalBytes) * 100;
+                    increment: newPercentage - lastPrecentage
-                    progress.report({
+                });
-                        message: newPercentage.toFixed(0) + "%",
-                        increment: newPercentage - lastPrecentage
-                    });
-                    lastPrecentage = newPercentage;
+                lastPrecentage = newPercentage;
-                })
+            });
-            );
        }
    );
 }
diff --git a/editors/code/src/installation/fetch_artifact_release_info.ts b/editors/code/src/installation/fetch_artifact_release_info.ts
index 1b6fc8d48..b1b5a3485 100644
--- a/editors/code/src/installation/fetch_artifact_release_info.ts
+++ b/editors/code/src/installation/fetch_artifact_release_info.ts
@@ -4,41 +4,61 @@ import { log } from "../util";
 const GITHUB_API_ENDPOINT_URL = "https://api.github.com";
 /**
- * Fetches the release with `releaseTag` (or just latest release when not specified)
+ * Fetches the release with `releaseTag` from GitHub `repo` and
- * from GitHub `repo` and returns metadata about `artifactFileName` shipped with
+ * returns metadata about `artifactFileName` shipped with
- * this release or `null` if no such artifact was published.
+ * this release.
+ *
+ * @throws Error upon network failure or if no such repository, release, or artifact exists.
 */
 export async function fetchArtifactReleaseInfo(
-    repo: GithubRepo, artifactFileName: string, releaseTag?: string
+    repo: GithubRepo,
-): Promise<null | ArtifactReleaseInfo> {
+    artifactFileName: string,
+    releaseTag: string
+): Promise<ArtifactReleaseInfo> {
    const repoOwner = encodeURIComponent(repo.owner);
    const repoName = encodeURIComponent(repo.name);
-    const apiEndpointPath = releaseTag
+    const apiEndpointPath = `/repos/${repoOwner}/${repoName}/releases/tags/${releaseTag}`;
-        ? `/repos/${repoOwner}/${repoName}/releases/tags/${releaseTag}`
-        : `/repos/${repoOwner}/${repoName}/releases/latest`;
    const requestUrl = GITHUB_API_ENDPOINT_URL + apiEndpointPath;
-    // We skip runtime type checks for simplicity (here we cast from `any` to `GithubRelease`)
    log.debug("Issuing request for released artifacts metadata to", requestUrl);
-    // FIXME: handle non-ok response
+    const response = await fetch(requestUrl, { headers: { Accept: "application/vnd.github.v3+json" } });
-    const response: GithubRelease = await fetch(requestUrl, {
-        headers: { Accept: "application/vnd.github.v3+json" }
-    })
-        .then(res => res.json());
-    const artifact = response.assets.find(artifact => artifact.name === artifactFileName);
+    if (!response.ok) {
+        log.error("Error fetching artifact release info", {
+            requestUrl,
+            releaseTag,
+            artifactFileName,
+            response: {
+                headers: response.headers,
+                status: response.status,
+                body: await response.text(),
+            }
+        });
+        throw new Error(
+            `Got response ${response.status} when trying to fetch ` +
+            `"${artifactFileName}" artifact release info for ${releaseTag} release`
+        );
+    }
-    if (!artifact) return null;
+    // We skip runtime type checks for simplicity (here we cast from `any` to `GithubRelease`)
+    const release: GithubRelease = await response.json();
+    const artifact = release.assets.find(artifact => artifact.name === artifactFileName);
+    if (!artifact) {
+        throw new Error(
+            `Artifact ${artifactFileName} was not found in ${release.name} release!`
+        );
+    }
    return {
-        releaseName: response.name,
+        releaseName: release.name,
        downloadUrl: artifact.browser_download_url
    };
diff --git a/editors/code/src/installation/server.ts b/editors/code/src/installation/server.ts
index 685abfdc6..cb5e56844 100644
--- a/editors/code/src/installation/server.ts
+++ b/editors/code/src/installation/server.ts
@@ -63,7 +63,7 @@ export async function ensureServerBinary(source: null | BinarySource): Promise<n
 async function downloadServer(source: BinarySource.GithubRelease): Promise<boolean> {
    try {
-        const releaseInfo = (await fetchArtifactReleaseInfo(source.repo, source.file, source.version))!;
+        const releaseInfo = await fetchArtifactReleaseInfo(source.repo, source.file, source.version);
        await downloadArtifact(releaseInfo, source.file, source.dir, "language server");
        await setServerVersion(source.storage, releaseInfo.releaseName);
@@ -88,9 +88,12 @@ async function downloadServer(source: BinarySource.GithubRelease): Promise<boole
        return false;
    }
-    if (!isBinaryAvailable(path.join(source.dir, source.file))) assert(false,
+    const binaryPath = path.join(source.dir, source.file);
+    assert(isBinaryAvailable(binaryPath),
        `Downloaded language server binary is not functional.` +
-        `Downloaded from: ${JSON.stringify(source, null, 4)}`
+        `Downloaded from GitHub repo ${source.repo.owner}/${source.repo.name} ` +
+        `to ${binaryPath}`
    );
    vscode.window.showInformationMessage(
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 7b3bb6302..ecf53cf77 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -12,6 +12,26 @@ import { log } from './util';
 let ctx: Ctx | undefined;
 export async function activate(context: vscode.ExtensionContext) {
+    // Register a "dumb" onEnter command for the case where server fails to
+    // start.
+    //
+    // FIXME: refactor command registration code such that commands are
+    // **always** registered, even if the server does not start. Use API like
+    // this perhaps?
+    //
+    // ```TypeScript
+    // registerCommand(
+    //    factory: (Ctx) => ((Ctx) => any),
+    //    fallback: () => any = () => vscode.window.showErrorMessage(
+    //        "rust-analyzer is not available"
+    //    ),
+    // )
+    const defaultOnEnter = vscode.commands.registerCommand(
+        'rust-analyzer.onEnter',
+        () => vscode.commands.executeCommand('default:type', { text: '\n' }),
+    );
+    context.subscriptions.push(defaultOnEnter);
    const config = new Config(context);
    const serverPath = await ensureServerBinary(config.serverSource);
@@ -54,7 +74,10 @@ export async function activate(context: vscode.ExtensionContext) {
    ctx.registerCommand('syntaxTree', commands.syntaxTree);
    ctx.registerCommand('expandMacro', commands.expandMacro);
    ctx.registerCommand('run', commands.run);
+    defaultOnEnter.dispose();
    ctx.registerCommand('onEnter', commands.onEnter);
    ctx.registerCommand('ssr', commands.ssr);
    ctx.registerCommand('serverVersion', commands.serverVersion);
@@ -66,7 +89,9 @@ export async function activate(context: vscode.ExtensionContext) {
    activateStatusDisplay(ctx);
-    activateHighlighting(ctx);
+    if (!ctx.config.highlightingSemanticTokens) {
+        activateHighlighting(ctx);
+    }
    activateInlayHints(ctx);
 }
diff --git a/editors/code/src/rust-analyzer-api.ts b/editors/code/src/rust-analyzer-api.ts
new file mode 100644
index 000000000..c5a010e94
--- /dev/null
+++ b/editors/code/src/rust-analyzer-api.ts
@@ -0,0 +1,117 @@
+/**
+ * This file mirrors `crates/rust-analyzer/src/req.rs` declarations.
+ */
+import * as lc from "vscode-languageclient";
+type Option<T> = null | T;
+type Vec<T> = T[];
+type FxHashMap<K extends PropertyKey, V> = Record<K, V>;
+function request<TParams, TResult>(method: string) {
+    return new lc.RequestType<TParams, TResult, unknown>(`rust-analyzer/${method}`);
+}
+function notification<TParam>(method: string) {
+    return new lc.NotificationType<TParam>(method);
+}
+export const analyzerStatus = request<null, string>("analyzerStatus");
+export const collectGarbage = request<null, null>("collectGarbage");
+export interface SyntaxTreeParams {
+    textDocument: lc.TextDocumentIdentifier;
+    range: Option<lc.Range>;
+}
+export const syntaxTree = request<SyntaxTreeParams, string>("syntaxTree");
+export interface ExpandMacroParams {
+    textDocument: lc.TextDocumentIdentifier;
+    position: Option<lc.Position>;
+}
+export interface ExpandedMacro {
+    name: string;
+    expansion: string;
+}
+export const expandMacro = request<ExpandMacroParams, Option<ExpandedMacro>>("expandMacro");
+export interface FindMatchingBraceParams {
+    textDocument: lc.TextDocumentIdentifier;
+    offsets: Vec<lc.Position>;
+}
+export const findMatchingBrace = request<FindMatchingBraceParams, Vec<lc.Position>>("findMatchingBrace");
+export interface PublishDecorationsParams {
+    uri: string;
+    decorations: Vec<Decoration>;
+}
+export interface Decoration {
+    range: lc.Range;
+    tag: string;
+    bindingHash: Option<string>;
+}
+export const decorationsRequest = request<lc.TextDocumentIdentifier, Vec<Decoration>>("decorationsRequest");
+export const parentModule = request<lc.TextDocumentPositionParams, Vec<lc.Location>>("parentModule");
+export interface JoinLinesParams {
+    textDocument: lc.TextDocumentIdentifier;
+    range: lc.Range;
+}
+export const joinLines = request<JoinLinesParams, SourceChange>("joinLines");
+export const onEnter = request<lc.TextDocumentPositionParams, Option<SourceChange>>("onEnter");
+export interface RunnablesParams {
+    textDocument: lc.TextDocumentIdentifier;
+    position: Option<lc.Position>;
+}
+export interface Runnable {
+    range: lc.Range;
+    label: string;
+    bin: string;
+    args: Vec<string>;
+    env: FxHashMap<string, string>;
+    cwd: Option<string>;
+}
+export const runnables = request<RunnablesParams, Vec<Runnable>>("runnables");
+export const enum InlayKind {
+    TypeHint = "TypeHint",
+    ParameterHint = "ParameterHint",
+}
+export interface InlayHint {
+    range: lc.Range;
+    kind: InlayKind;
+    label: string;
+}
+export interface InlayHintsParams {
+    textDocument: lc.TextDocumentIdentifier;
+}
+export const inlayHints = request<InlayHintsParams, Vec<InlayHint>>("inlayHints");
+export interface SsrParams {
+    arg: string;
+}
+export const ssr = request<SsrParams, SourceChange>("ssr");
+export const publishDecorations = notification<PublishDecorationsParams>("publishDecorations");
+export interface SourceChange {
+    label: string;
+    workspaceEdit: lc.WorkspaceEdit;
+    cursorPosition: Option<lc.TextDocumentPositionParams>;
+}
diff --git a/editors/code/src/source_change.ts b/editors/code/src/source_change.ts
index a336269ba..399a150c6 100644
--- a/editors/code/src/source_change.ts
+++ b/editors/code/src/source_change.ts
@@ -1,15 +1,10 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as ra from './rust-analyzer-api';
 import { Ctx } from './ctx';
-export interface SourceChange {
+export async function applySourceChange(ctx: Ctx, change: ra.SourceChange) {
-    label: string;
-    workspaceEdit: lc.WorkspaceEdit;
-    cursorPosition?: lc.TextDocumentPositionParams;
-}
-export async function applySourceChange(ctx: Ctx, change: SourceChange) {
    const client = ctx.client;
    if (!client) return;
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 2f18f85a3..68c2a94d0 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -20,21 +20,21 @@ export const log = {
    }
 };
-export async function sendRequestWithRetry<R>(
+export async function sendRequestWithRetry<TParam, TRet>(
    client: lc.LanguageClient,
-    method: string,
+    reqType: lc.RequestType<TParam, TRet, unknown>,
-    param: unknown,
+    param: TParam,
    token?: vscode.CancellationToken,
-): Promise<R> {
+): Promise<TRet> {
    for (const delay of [2, 4, 6, 8, 10, null]) {
        try {
            return await (token
-                ? client.sendRequest(method, param, token)
+                ? client.sendRequest(reqType, param, token)
-                : client.sendRequest(method, param)
+                : client.sendRequest(reqType, param)
            );
        } catch (error) {
            if (delay === null) {
-                log.error("LSP request timed out", { method, param, error });
+                log.error("LSP request timed out", { method: reqType.method, param, error });
                throw error;
            }
@@ -43,7 +43,7 @@ export async function sendRequestWithRetry<R>(
            }
            if (error.code !== lc.ErrorCodes.ContentModified) {
-                log.error("LSP request failed", { method, param, error });
+                log.error("LSP request failed", { method: reqType.method, param, error });
                throw error;
            }