109 files changed, 3408 insertions, 2533 deletions

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8ab47106d..3f41d32f7 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 run fmt
+
+      - run: npm audit
+        working-directory: ./editors/code
+
+      - run: npm run lint
         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 e5400f5eb..49fddef4b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -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",
@@ -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",
 ]
 
@@ -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 ra_db::{FileRange, SourceDatabase};
+use hir::Semantics;
+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 {
-        let parse = db.parse(frange.file_id);
-        AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit }
+    pub fn new(
+        sema: &'a Semantics<'a, RootDatabase>,
+        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 c6d15af5f..a74ac42d5 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -1,15 +1,12 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
 use rustc_hash::FxHashMap;
 
-use hir::{InFile, PathResolution};
+use hir::{PathResolution, SemanticsScope};
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, AstNode};
 
 pub trait AstTransform<'a> {
-    fn get_substitution(
-        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode>;
+    fn get_substitution(&self, node: &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>
@@ -23,10 +20,7 @@ pub trait AstTransform<'a> {
 struct NullTransformer;
 
 impl<'a> AstTransform<'a> for NullTransformer {
-    fn get_substitution(
-        &self,
-        _node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode> {
+    fn get_substitution(&self, _node: &ra_syntax::SyntaxNode) -> Option<ra_syntax::SyntaxNode> {
         None
     }
     fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
@@ -35,14 +29,16 @@ impl<'a> AstTransform<'a> for NullTransformer {
 }
 
 pub struct SubstituteTypeParams<'a> {
-    db: &'a RootDatabase,
+    source_scope: &'a SemanticsScope<'a, RootDatabase>,
     substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
 impl<'a> SubstituteTypeParams<'a> {
     pub fn for_trait_impl(
+        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> {
@@ -56,7 +52,7 @@ impl<'a> SubstituteTypeParams<'a> {
             .zip(substs.into_iter())
             .collect();
         return SubstituteTypeParams {
-            db,
+            source_scope,
             substs: substs_by_param,
             previous: Box::new(NullTransformer),
         };
@@ -80,15 +76,15 @@ impl<'a> SubstituteTypeParams<'a> {
     }
     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 resolution = analyzer.resolve_path(self.db, &path)?;
+        let path = hir::Path::from_ast(path)?;
+        let resolution = self.source_scope.resolve_hir_path(&path)?;
         match resolution {
             hir::PathResolution::TypeParam(tp) => Some(self.substs.get(&tp)?.syntax().clone()),
             _ => None,
@@ -97,10 +93,7 @@ impl<'a> SubstituteTypeParams<'a> {
 }
 
 impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
-    fn get_substitution(
-        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode> {
+    fn get_substitution(&self, node: &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> {
@@ -109,29 +102,34 @@ impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
 }
 
 pub struct QualifyPaths<'a> {
+    target_scope: &'a SemanticsScope<'a, RootDatabase>,
+    source_scope: &'a SemanticsScope<'a, RootDatabase>,
     db: &'a RootDatabase,
-    from: Option<hir::Module>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
 impl<'a> QualifyPaths<'a> {
-    pub fn new(db: &'a RootDatabase, from: Option<hir::Module>) -> Self {
-        Self { db, from, previous: Box::new(NullTransformer) }
+    pub fn new(
+        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 p = ast::Path::cast(node.value.clone())?;
+        let from = self.target_scope.module()?;
+        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 resolution = analyzer.resolve_path(self.db, &p)?;
+        let hir_path = hir::Path::from_ast(p.clone());
+        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)?;
@@ -140,7 +138,7 @@ impl<'a> QualifyPaths<'a> {
                 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))
@@ -157,11 +155,11 @@ impl<'a> QualifyPaths<'a> {
     }
 }
 
-pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: InFile<N>) -> N {
-    let syntax = node.value.syntax();
-    let result = ra_syntax::algo::replace_descendants(syntax, &|element| match element {
+pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
+    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,
@@ -170,10 +168,7 @@ pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: InFile<N>
 }
 
 impl<'a> AstTransform<'a> for QualifyPaths<'a> {
-    fn get_substitution(
-        &self,
-        node: InFile<&ra_syntax::SyntaxNode>,
-    ) -> Option<ra_syntax::SyntaxNode> {
+    fn get_substitution(&self, node: &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 analyzer = ctx.source_analyzer(stmt.syntax(), None);
-    let ty = analyzer.type_of(db, &expr)?;
+    let ty = ctx.sema.type_of_expr(&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.db, &analyzer, &impl_node)?;
+    let trait_ = resolve_target_trait(&ctx.sema, &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 file_id = ctx.frange.file_id;
-    let trait_file_id = trait_.source(db).file_id;
+    let sema = ctx.sema;
 
     ctx.add_assist(AssistId(assist_id), label, |edit| {
         let n_existing_items = impl_item_list.impl_items().count();
-        let module = hir::SourceAnalyzer::new(
-            db,
-            hir::InFile::new(file_id.into(), impl_node.syntax()),
-            None,
-        )
-        .module();
-        let ast_transform = QualifyPaths::new(db, module)
-            .or(SubstituteTypeParams::for_trait_impl(db, trait_, impl_node));
+        let source_scope = sema.scope_for_def(trait_);
+        let target_scope = sema.scope(impl_item_list.syntax());
+        let ast_transform = QualifyPaths::new(&target_scope, &source_scope, sema.db)
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, sema.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 src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        sb.to_def(src)?
-    };
+    let struct_def = ctx.sema.to_def(strukt)?;
 
     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 = sb.to_def(src)?;
+        let blk = ctx.sema.to_def(&impl_blk)?;
 
         // 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..c8bf181f9 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -1,10 +1,11 @@
 use crate::{
     assist_ctx::{Assist, AssistCtx},
-    insert_use_statement, AssistId,
+    utils::insert_use_statement,
+    AssistId,
 };
 use hir::{
-    db::HirDatabase, AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution,
-    SourceAnalyzer, Trait, Type,
+    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
+    Type,
 };
 use ra_ide_db::{imports_locator::ImportsLocator, RootDatabase};
 use ra_prof::profile;
@@ -52,7 +53,6 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
             edit.target(auto_import_assets.syntax_under_caret.text_range());
             insert_use_statement(
                 &auto_import_assets.syntax_under_caret,
-                &auto_import_assets.syntax_under_caret,
                 &import,
                 edit.text_edit_builder(),
             );
@@ -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 = source_analyzer.module()?;
+        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
         Some(Self {
-            import_candidate: ImportCandidate::for_method_call(
-                &method_call,
-                &source_analyzer,
-                ctx.db,
-            )?,
+            import_candidate: ImportCandidate::for_method_call(&ctx.sema, &method_call)?,
             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 = source_analyzer.module()?;
+        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
         Some(Self {
-            import_candidate: ImportCandidate::for_regular_path(
-                &path_under_caret,
-                &source_analyzer,
-                ctx.db,
-            )?,
+            import_candidate: ImportCandidate::for_regular_path(&ctx.sema, &path_under_caret)?,
             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) =
-                source_analyzer.resolve_path(db, &qualifier_start_path)
-            {
+            if let Some(qualifier_start_resolution) = sema.resolve_path(&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/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index f325b6f92..54e0a6c84 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -2,8 +2,8 @@ use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
     SyntaxKind::{
-        ATTR, COMMENT, ENUM_DEF, FN_DEF, IDENT, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
-        WHITESPACE,
+        ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, IDENT, MODULE, STRUCT_DEF, TRAIT_DEF,
+        VISIBILITY, WHITESPACE,
     },
     SyntaxNode, TextUnit, T,
 };
@@ -30,13 +30,13 @@ pub(crate) fn change_visibility(ctx: AssistCtx) -> Option<Assist> {
 
 fn add_vis(ctx: AssistCtx) -> Option<Assist> {
     let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
-        T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
+        T![const] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
         _ => false,
     });
 
     let (offset, target) = if let Some(keyword) = item_keyword {
         let parent = keyword.parent();
-        let def_kws = vec![FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
+        let def_kws = vec![CONST_DEF, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
         // Parent is not a definition, can't add visibility
         if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
             return None;
@@ -136,6 +136,11 @@ mod tests {
     }
 
     #[test]
+    fn change_visibility_const() {
+        check_assist(change_visibility, "<|>const FOO = 3u8;", "<|>pub(crate) const FOO = 3u8;");
+    }
+
+    #[test]
     fn change_visibility_handles_comment_attrs() {
         check_assist(
             change_visibility,
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index 22f88884f..f3167b4e5 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -112,16 +112,19 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
             Some((path, bound_ident)) => {
                 // If-let.
                 let match_expr = {
-                    let happy_arm = make::match_arm(
-                        once(
-                            make::tuple_struct_pat(
-                                path,
-                                once(make::bind_pat(make::name("it")).into()),
-                            )
-                            .into(),
-                        ),
-                        make::expr_path(make::path_from_name_ref(make::name_ref("it"))),
-                    );
+                    let happy_arm = {
+                        let pat = make::tuple_struct_pat(
+                            path,
+                            once(make::bind_pat(make::name("it")).into()),
+                        );
+                        let expr = {
+                            let name_ref = make::name_ref("it");
+                            let segment = make::path_segment(name_ref);
+                            let path = make::path_unqualified(segment);
+                            make::expr_path(path)
+                        };
+                        make::match_arm(once(pat.into()), expr)
+                    };
 
                     let sad_arm = make::match_arm(
                         // FIXME: would be cool to use `None` or `Err(_)` if appropriate
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 analyzer = ctx.source_analyzer(expr.syntax(), None);
-        (resolve_enum_def(ctx.db, &analyzer, &expr)?, analyzer.module()?)
-    };
+    let enum_def = resolve_enum_def(&ctx.sema, &expr)?;
+    let module = ctx.sema.scope(expr.syntax()).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(
-    db: &impl HirDatabase,
-    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() {
+fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
+    sema.type_of_expr(&expr)?.autoderef(sema.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 = analyzer.find_all_refs(&bind_pat);
+    let refs = ctx.sema.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::{
-        check_assist_range, check_assist_range_not_applicable, check_assist_range_target,
-    };
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_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(
-            introduce_variable,
-            "fn main() { 1 + /* <|>comment<|> */ 1; }",
-        );
+        check_assist_not_applicable(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(
-            introduce_variable,
-            "fn main() { loop { <|>break<|>; }; }",
-        );
+        check_assist_not_applicable(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(
-            introduce_variable,
-            "fn foo() -> u32 { <|>return 2 + 2<|>; }",
-            "2 + 2",
-        );
+        check_assist_target(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/handlers/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index 90793b5fc..86b235366 100644
--- a/crates/ra_assists/src/handlers/move_bounds.rs
+++ b/crates/ra_assists/src/handlers/move_bounds.rs
@@ -72,7 +72,11 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
 }
 
 fn build_predicate(param: ast::TypeParam) -> Option<ast::WherePred> {
-    let path = make::path_from_name_ref(make::name_ref(&param.name()?.syntax().to_string()));
+    let path = {
+        let name_ref = make::name_ref(&param.name()?.syntax().to_string());
+        let segment = make::path_segment(name_ref);
+        make::path_unqualified(segment)
+    };
     let predicate = make::where_pred(path, param.type_bound_list()?.bounds());
     Some(predicate)
 }
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index 2c0a1e126..7e4b83f13 100644
--- a/crates/ra_assists/src/handlers/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -1,5 +1,6 @@
 use ra_syntax::{
-    ast, AstToken,
+    ast::{self, HasStringValue},
+    AstToken,
     SyntaxKind::{RAW_STRING, STRING},
     TextUnit,
 };
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index eac452413..94f5d6c50 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,42 +1,12 @@
-use hir::{self, ModPath};
-use ra_syntax::{
-    ast::{self, NameOwner},
-    AstNode, Direction, SmolStr,
-    SyntaxKind::{PATH, PATH_SEGMENT},
-    SyntaxNode, TextRange, T,
-};
-use ra_text_edit::TextEditBuilder;
+use hir;
+use ra_syntax::{ast, AstNode, SmolStr, TextRange};
 
 use crate::{
     assist_ctx::{Assist, AssistCtx},
+    utils::insert_use_statement,
     AssistId,
 };
 
-/// Creates and inserts a use statement for the given path to import.
-/// The use statement is inserted in the scope most appropriate to the
-/// the cursor position given, additionally merged with the existing use imports.
-pub fn insert_use_statement(
-    // Ideally the position of the cursor, used to
-    position: &SyntaxNode,
-    // The statement to use as anchor (last resort)
-    anchor: &SyntaxNode,
-    path_to_import: &ModPath,
-    edit: &mut TextEditBuilder,
-) {
-    let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = position.ancestors().find_map(|n| {
-        if let Some(module) = ast::Module::cast(n.clone()) {
-            return module.item_list().map(|it| it.syntax().clone());
-        }
-        ast::SourceFile::cast(n).map(|it| it.syntax().clone())
-    });
-
-    if let Some(container) = container {
-        let action = best_action_for_target(container, anchor.clone(), &target);
-        make_assist(&action, &target, edit);
-    }
-}
-
 // Assist: replace_qualified_name_with_use
 //
 // Adds a use statement for a given fully-qualified name.
@@ -63,522 +33,25 @@ pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist>
         return None;
     }
 
-    let module = path.syntax().ancestors().find_map(ast::Module::cast);
-    let position = match module.and_then(|it| it.item_list()) {
-        Some(item_list) => item_list.syntax().clone(),
-        None => {
-            let current_file = path.syntax().ancestors().find_map(ast::SourceFile::cast)?;
-            current_file.syntax().clone()
-        }
-    };
-
     ctx.add_assist(
         AssistId("replace_qualified_name_with_use"),
         "Replace qualified path with use",
         |edit| {
-            replace_with_use(&position, &path, &segments, edit.text_edit_builder());
+            let path_to_import = hir_path.mod_path().clone();
+            insert_use_statement(path.syntax(), &path_to_import, edit.text_edit_builder());
+
+            if let Some(last) = path.segment() {
+                // Here we are assuming the assist will provide a correct use statement
+                // so we can delete the path qualifier
+                edit.delete(TextRange::from_to(
+                    path.syntax().text_range().start(),
+                    last.syntax().text_range().start(),
+                ));
+            }
         },
     )
 }
 
-fn collect_path_segments_raw(
-    segments: &mut Vec<ast::PathSegment>,
-    mut path: ast::Path,
-) -> Option<usize> {
-    let oldlen = segments.len();
-    loop {
-        let mut children = path.syntax().children_with_tokens();
-        let (first, second, third) = (
-            children.next().map(|n| (n.clone(), n.kind())),
-            children.next().map(|n| (n.clone(), n.kind())),
-            children.next().map(|n| (n.clone(), n.kind())),
-        );
-        match (first, second, third) {
-            (Some((subpath, PATH)), Some((_, T![::])), Some((segment, PATH_SEGMENT))) => {
-                path = ast::Path::cast(subpath.as_node()?.clone())?;
-                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
-            }
-            (Some((segment, PATH_SEGMENT)), _, _) => {
-                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
-                break;
-            }
-            (_, _, _) => return None,
-        }
-    }
-    // We need to reverse only the new added segments
-    let only_new_segments = segments.split_at_mut(oldlen).1;
-    only_new_segments.reverse();
-    Some(segments.len() - oldlen)
-}
-
-fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
-    let mut iter = segments.iter();
-    if let Some(s) = iter.next() {
-        buf.push_str(s);
-    }
-    for s in iter {
-        buf.push_str("::");
-        buf.push_str(s);
-    }
-}
-
-/// Returns the number of common segments.
-fn compare_path_segments(left: &[SmolStr], right: &[ast::PathSegment]) -> usize {
-    left.iter().zip(right).take_while(|(l, r)| compare_path_segment(l, r)).count()
-}
-
-fn compare_path_segment(a: &SmolStr, b: &ast::PathSegment) -> bool {
-    if let Some(kb) = b.kind() {
-        match kb {
-            ast::PathSegmentKind::Name(nameref_b) => a == nameref_b.text(),
-            ast::PathSegmentKind::SelfKw => a == "self",
-            ast::PathSegmentKind::SuperKw => a == "super",
-            ast::PathSegmentKind::CrateKw => a == "crate",
-            ast::PathSegmentKind::Type { .. } => false, // not allowed in imports
-        }
-    } else {
-        false
-    }
-}
-
-fn compare_path_segment_with_name(a: &SmolStr, b: &ast::Name) -> bool {
-    a == b.text()
-}
-
-#[derive(Clone, Debug)]
-enum ImportAction {
-    Nothing,
-    // Add a brand new use statement.
-    AddNewUse {
-        anchor: Option<SyntaxNode>, // anchor node
-        add_after_anchor: bool,
-    },
-
-    // To split an existing use statement creating a nested import.
-    AddNestedImport {
-        // how may segments matched with the target path
-        common_segments: usize,
-        path_to_split: ast::Path,
-        // the first segment of path_to_split we want to add into the new nested list
-        first_segment_to_split: Option<ast::PathSegment>,
-        // Wether to add 'self' in addition to the target path
-        add_self: bool,
-    },
-    // To add the target path to an existing nested import tree list.
-    AddInTreeList {
-        common_segments: usize,
-        // The UseTreeList where to add the target path
-        tree_list: ast::UseTreeList,
-        add_self: bool,
-    },
-}
-
-impl ImportAction {
-    fn add_new_use(anchor: Option<SyntaxNode>, add_after_anchor: bool) -> Self {
-        ImportAction::AddNewUse { anchor, add_after_anchor }
-    }
-
-    fn add_nested_import(
-        common_segments: usize,
-        path_to_split: ast::Path,
-        first_segment_to_split: Option<ast::PathSegment>,
-        add_self: bool,
-    ) -> Self {
-        ImportAction::AddNestedImport {
-            common_segments,
-            path_to_split,
-            first_segment_to_split,
-            add_self,
-        }
-    }
-
-    fn add_in_tree_list(
-        common_segments: usize,
-        tree_list: ast::UseTreeList,
-        add_self: bool,
-    ) -> Self {
-        ImportAction::AddInTreeList { common_segments, tree_list, add_self }
-    }
-
-    fn better(left: ImportAction, right: ImportAction) -> ImportAction {
-        if left.is_better(&right) {
-            left
-        } else {
-            right
-        }
-    }
-
-    fn is_better(&self, other: &ImportAction) -> bool {
-        match (self, other) {
-            (ImportAction::Nothing, _) => true,
-            (ImportAction::AddInTreeList { .. }, ImportAction::Nothing) => false,
-            (
-                ImportAction::AddNestedImport { common_segments: n, .. },
-                ImportAction::AddInTreeList { common_segments: m, .. },
-            )
-            | (
-                ImportAction::AddInTreeList { common_segments: n, .. },
-                ImportAction::AddNestedImport { common_segments: m, .. },
-            )
-            | (
-                ImportAction::AddInTreeList { common_segments: n, .. },
-                ImportAction::AddInTreeList { common_segments: m, .. },
-            )
-            | (
-                ImportAction::AddNestedImport { common_segments: n, .. },
-                ImportAction::AddNestedImport { common_segments: m, .. },
-            ) => n > m,
-            (ImportAction::AddInTreeList { .. }, _) => true,
-            (ImportAction::AddNestedImport { .. }, ImportAction::Nothing) => false,
-            (ImportAction::AddNestedImport { .. }, _) => true,
-            (ImportAction::AddNewUse { .. }, _) => false,
-        }
-    }
-}
-
-// Find out the best ImportAction to import target path against current_use_tree.
-// If current_use_tree has a nested import the function gets called recursively on every UseTree inside a UseTreeList.
-fn walk_use_tree_for_best_action(
-    current_path_segments: &mut Vec<ast::PathSegment>, // buffer containing path segments
-    current_parent_use_tree_list: Option<ast::UseTreeList>, // will be Some value if we are in a nested import
-    current_use_tree: ast::UseTree, // the use tree we are currently examinating
-    target: &[SmolStr],             // the path we want to import
-) -> ImportAction {
-    // We save the number of segments in the buffer so we can restore the correct segments
-    // before returning. Recursive call will add segments so we need to delete them.
-    let prev_len = current_path_segments.len();
-
-    let tree_list = current_use_tree.use_tree_list();
-    let alias = current_use_tree.alias();
-
-    let path = match current_use_tree.path() {
-        Some(path) => path,
-        None => {
-            // If the use item don't have a path, it means it's broken (syntax error)
-            return ImportAction::add_new_use(
-                current_use_tree
-                    .syntax()
-                    .ancestors()
-                    .find_map(ast::UseItem::cast)
-                    .map(|it| it.syntax().clone()),
-                true,
-            );
-        }
-    };
-
-    // This can happen only if current_use_tree is a direct child of a UseItem
-    if let Some(name) = alias.and_then(|it| it.name()) {
-        if compare_path_segment_with_name(&target[0], &name) {
-            return ImportAction::Nothing;
-        }
-    }
-
-    collect_path_segments_raw(current_path_segments, path.clone());
-
-    // We compare only the new segments added in the line just above.
-    // The first prev_len segments were already compared in 'parent' recursive calls.
-    let left = target.split_at(prev_len).1;
-    let right = current_path_segments.split_at(prev_len).1;
-    let common = compare_path_segments(left, &right);
-    let mut action = match common {
-        0 => ImportAction::add_new_use(
-            // e.g: target is std::fmt and we can have
-            // use foo::bar
-            // We add a brand new use statement
-            current_use_tree
-                .syntax()
-                .ancestors()
-                .find_map(ast::UseItem::cast)
-                .map(|it| it.syntax().clone()),
-            true,
-        ),
-        common if common == left.len() && left.len() == right.len() => {
-            // e.g: target is std::fmt and we can have
-            // 1- use std::fmt;
-            // 2- use std::fmt::{ ... }
-            if let Some(list) = tree_list {
-                // In case 2 we need to add self to the nested list
-                // unless it's already there
-                let has_self = list.use_trees().map(|it| it.path()).any(|p| {
-                    p.and_then(|it| it.segment())
-                        .and_then(|it| it.kind())
-                        .filter(|k| *k == ast::PathSegmentKind::SelfKw)
-                        .is_some()
-                });
-
-                if has_self {
-                    ImportAction::Nothing
-                } else {
-                    ImportAction::add_in_tree_list(current_path_segments.len(), list, true)
-                }
-            } else {
-                // Case 1
-                ImportAction::Nothing
-            }
-        }
-        common if common != left.len() && left.len() == right.len() => {
-            // e.g: target is std::fmt and we have
-            // use std::io;
-            // We need to split.
-            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
-            ImportAction::add_nested_import(
-                prev_len + common,
-                path,
-                Some(segments_to_split[0].clone()),
-                false,
-            )
-        }
-        common if common == right.len() && left.len() > right.len() => {
-            // e.g: target is std::fmt and we can have
-            // 1- use std;
-            // 2- use std::{ ... };
-
-            // fallback action
-            let mut better_action = ImportAction::add_new_use(
-                current_use_tree
-                    .syntax()
-                    .ancestors()
-                    .find_map(ast::UseItem::cast)
-                    .map(|it| it.syntax().clone()),
-                true,
-            );
-            if let Some(list) = tree_list {
-                // Case 2, check recursively if the path is already imported in the nested list
-                for u in list.use_trees() {
-                    let child_action = walk_use_tree_for_best_action(
-                        current_path_segments,
-                        Some(list.clone()),
-                        u,
-                        target,
-                    );
-                    if child_action.is_better(&better_action) {
-                        better_action = child_action;
-                        if let ImportAction::Nothing = better_action {
-                            return better_action;
-                        }
-                    }
-                }
-            } else {
-                // Case 1, split adding self
-                better_action = ImportAction::add_nested_import(prev_len + common, path, None, true)
-            }
-            better_action
-        }
-        common if common == left.len() && left.len() < right.len() => {
-            // e.g: target is std::fmt and we can have
-            // use std::fmt::Debug;
-            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
-            ImportAction::add_nested_import(
-                prev_len + common,
-                path,
-                Some(segments_to_split[0].clone()),
-                true,
-            )
-        }
-        common if common < left.len() && common < right.len() => {
-            // e.g: target is std::fmt::nested::Debug
-            // use std::fmt::Display
-            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
-            ImportAction::add_nested_import(
-                prev_len + common,
-                path,
-                Some(segments_to_split[0].clone()),
-                false,
-            )
-        }
-        _ => unreachable!(),
-    };
-
-    // If we are inside a UseTreeList adding a use statement become adding to the existing
-    // tree list.
-    action = match (current_parent_use_tree_list, action.clone()) {
-        (Some(use_tree_list), ImportAction::AddNewUse { .. }) => {
-            ImportAction::add_in_tree_list(prev_len, use_tree_list, false)
-        }
-        (_, _) => action,
-    };
-
-    // We remove the segments added
-    current_path_segments.truncate(prev_len);
-    action
-}
-
-fn best_action_for_target(
-    container: SyntaxNode,
-    anchor: SyntaxNode,
-    target: &[SmolStr],
-) -> ImportAction {
-    let mut storage = Vec::with_capacity(16); // this should be the only allocation
-    let best_action = container
-        .children()
-        .filter_map(ast::UseItem::cast)
-        .filter_map(|it| it.use_tree())
-        .map(|u| walk_use_tree_for_best_action(&mut storage, None, u, target))
-        .fold(None, |best, a| match best {
-            Some(best) => Some(ImportAction::better(best, a)),
-            None => Some(a),
-        });
-
-    match best_action {
-        Some(action) => action,
-        None => {
-            // We have no action and no UseItem was found in container so we find
-            // another item and we use it as anchor.
-            // If there are no items above, we choose the target path itself as anchor.
-            // todo: we should include even whitespace blocks as anchor candidates
-            let anchor = container
-                .children()
-                .find(|n| n.text_range().start() < anchor.text_range().start())
-                .or_else(|| Some(anchor));
-
-            let add_after_anchor = anchor
-                .clone()
-                .and_then(ast::Attr::cast)
-                .map(|attr| attr.kind() == ast::AttrKind::Inner)
-                .unwrap_or(false);
-            ImportAction::add_new_use(anchor, add_after_anchor)
-        }
-    }
-}
-
-fn make_assist(action: &ImportAction, target: &[SmolStr], edit: &mut TextEditBuilder) {
-    match action {
-        ImportAction::AddNewUse { anchor, add_after_anchor } => {
-            make_assist_add_new_use(anchor, *add_after_anchor, target, edit)
-        }
-        ImportAction::AddInTreeList { common_segments, tree_list, add_self } => {
-            // We know that the fist n segments already exists in the use statement we want
-            // to modify, so we want to add only the last target.len() - n segments.
-            let segments_to_add = target.split_at(*common_segments).1;
-            make_assist_add_in_tree_list(tree_list, segments_to_add, *add_self, edit)
-        }
-        ImportAction::AddNestedImport {
-            common_segments,
-            path_to_split,
-            first_segment_to_split,
-            add_self,
-        } => {
-            let segments_to_add = target.split_at(*common_segments).1;
-            make_assist_add_nested_import(
-                path_to_split,
-                first_segment_to_split,
-                segments_to_add,
-                *add_self,
-                edit,
-            )
-        }
-        _ => {}
-    }
-}
-
-fn make_assist_add_new_use(
-    anchor: &Option<SyntaxNode>,
-    after: bool,
-    target: &[SmolStr],
-    edit: &mut TextEditBuilder,
-) {
-    if let Some(anchor) = anchor {
-        let indent = ra_fmt::leading_indent(anchor);
-        let mut buf = String::new();
-        if after {
-            buf.push_str("\n");
-            if let Some(spaces) = &indent {
-                buf.push_str(spaces);
-            }
-        }
-        buf.push_str("use ");
-        fmt_segments_raw(target, &mut buf);
-        buf.push_str(";");
-        if !after {
-            buf.push_str("\n\n");
-            if let Some(spaces) = &indent {
-                buf.push_str(&spaces);
-            }
-        }
-        let position = if after { anchor.text_range().end() } else { anchor.text_range().start() };
-        edit.insert(position, buf);
-    }
-}
-
-fn make_assist_add_in_tree_list(
-    tree_list: &ast::UseTreeList,
-    target: &[SmolStr],
-    add_self: bool,
-    edit: &mut TextEditBuilder,
-) {
-    let last = tree_list.use_trees().last();
-    if let Some(last) = last {
-        let mut buf = String::new();
-        let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == T![,]);
-        let offset = if let Some(comma) = comma {
-            comma.text_range().end()
-        } else {
-            buf.push_str(",");
-            last.syntax().text_range().end()
-        };
-        if add_self {
-            buf.push_str(" self")
-        } else {
-            buf.push_str(" ");
-        }
-        fmt_segments_raw(target, &mut buf);
-        edit.insert(offset, buf);
-    } else {
-    }
-}
-
-fn make_assist_add_nested_import(
-    path: &ast::Path,
-    first_segment_to_split: &Option<ast::PathSegment>,
-    target: &[SmolStr],
-    add_self: bool,
-    edit: &mut TextEditBuilder,
-) {
-    let use_tree = path.syntax().ancestors().find_map(ast::UseTree::cast);
-    if let Some(use_tree) = use_tree {
-        let (start, add_colon_colon) = if let Some(first_segment_to_split) = first_segment_to_split
-        {
-            (first_segment_to_split.syntax().text_range().start(), false)
-        } else {
-            (use_tree.syntax().text_range().end(), true)
-        };
-        let end = use_tree.syntax().text_range().end();
-
-        let mut buf = String::new();
-        if add_colon_colon {
-            buf.push_str("::");
-        }
-        buf.push_str("{");
-        if add_self {
-            buf.push_str("self, ");
-        }
-        fmt_segments_raw(target, &mut buf);
-        if !target.is_empty() {
-            buf.push_str(", ");
-        }
-        edit.insert(start, buf);
-        edit.insert(end, "}".to_string());
-    }
-}
-
-fn replace_with_use(
-    container: &SyntaxNode,
-    path: &ast::Path,
-    target: &[SmolStr],
-    edit: &mut TextEditBuilder,
-) {
-    let action = best_action_for_target(container.clone(), path.syntax().clone(), target);
-    make_assist(&action, target, edit);
-    if let Some(last) = path.segment() {
-        // Here we are assuming the assist will provide a correct use statement
-        // so we can delete the path qualifier
-        edit.delete(TextRange::from_to(
-            path.syntax().text_range().start(),
-            last.syntax().text_range().start(),
-        ));
-    }
-}
-
 fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
     let mut ps = Vec::<SmolStr>::with_capacity(10);
     match path.kind() {
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index d7998b0d1..deeada2de 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -18,7 +18,7 @@ use ra_syntax::{TextRange, TextUnit};
 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 +63,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 +78,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 +164,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 +179,66 @@ mod helpers {
     }
 
     pub(crate) fn check_assist(assist: AssistHandler, before: &str, after: &str) {
-        let (before_cursor_pos, before) = extract_offset(before);
-        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);
+        check(assist, before, ExpectedResult::After(after));
     }
 
+    // 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);
-        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);
+        check(assist, before, ExpectedResult::Target(target));
     }
 
-    pub(crate) fn check_assist_range_target(assist: AssistHandler, before: &str, target: &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 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) {
+        check(assist, before, ExpectedResult::NotApplicable);
     }
 
-    pub(crate) fn check_assist_not_applicable(assist: AssistHandler, before: &str) {
-        let (before_cursor_pos, before) = extract_offset(before);
-        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));
-        assert!(assist.is_none());
+    enum ExpectedResult<'a> {
+        NotApplicable,
+        After(&'a str),
+        Target(&'a str),
     }
 
-    pub(crate) fn check_assist_range_not_applicable(assist: AssistHandler, before: &str) {
-        let (range, before) = extract_range(before);
+    fn check(assist: AssistHandler, before: &str, expected: ExpectedResult) {
+        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));
-        assert!(assist.is_none());
+        let sema = Semantics::new(&db);
+        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..d544caee7 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -1,16 +1,18 @@
 //! Assorted functions shared by several assists.
+pub(crate) mod insert_use;
 
+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 use insert_use::insert_use_statement;
+
 pub fn get_missing_impl_items(
-    db: &impl HirDatabase,
-    analyzer: &hir::SourceAnalyzer,
+    sema: &Semantics<RootDatabase>,
     impl_block: &ast::ImplBlock,
 ) -> Vec<hir::AssocItem> {
     // Names must be unique between constants and functions. However, type aliases
@@ -42,15 +44,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::TypeAlias(t) => !impl_type.contains(&t.name(db).to_string()),
+                hir::AssocItem::Function(f) => {
+                    !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 +64,7 @@ pub fn get_missing_impl_items(
 }
 
 pub(crate) fn resolve_target_trait(
-    db: &impl HirDatabase,
-    analyzer: &hir::SourceAnalyzer,
+    sema: &Semantics<RootDatabase>,
     impl_block: &ast::ImplBlock,
 ) -> Option<hir::Trait> {
     let ast_path = impl_block
@@ -70,7 +73,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_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
new file mode 100644
index 000000000..36fd2fc0b
--- /dev/null
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -0,0 +1,510 @@
+//! Handle syntactic aspects of inserting a new `use`.
+
+use hir::{self, ModPath};
+use ra_syntax::{
+    ast::{self, NameOwner},
+    AstNode, Direction, SmolStr,
+    SyntaxKind::{PATH, PATH_SEGMENT},
+    SyntaxNode, T,
+};
+use ra_text_edit::TextEditBuilder;
+
+/// Creates and inserts a use statement for the given path to import.
+/// The use statement is inserted in the scope most appropriate to the
+/// the cursor position given, additionally merged with the existing use imports.
+pub fn insert_use_statement(
+    // Ideally the position of the cursor, used to
+    position: &SyntaxNode,
+    path_to_import: &ModPath,
+    edit: &mut TextEditBuilder,
+) {
+    let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
+    let container = position.ancestors().find_map(|n| {
+        if let Some(module) = ast::Module::cast(n.clone()) {
+            return module.item_list().map(|it| it.syntax().clone());
+        }
+        ast::SourceFile::cast(n).map(|it| it.syntax().clone())
+    });
+
+    if let Some(container) = container {
+        let action = best_action_for_target(container, position.clone(), &target);
+        make_assist(&action, &target, edit);
+    }
+}
+
+fn collect_path_segments_raw(
+    segments: &mut Vec<ast::PathSegment>,
+    mut path: ast::Path,
+) -> Option<usize> {
+    let oldlen = segments.len();
+    loop {
+        let mut children = path.syntax().children_with_tokens();
+        let (first, second, third) = (
+            children.next().map(|n| (n.clone(), n.kind())),
+            children.next().map(|n| (n.clone(), n.kind())),
+            children.next().map(|n| (n.clone(), n.kind())),
+        );
+        match (first, second, third) {
+            (Some((subpath, PATH)), Some((_, T![::])), Some((segment, PATH_SEGMENT))) => {
+                path = ast::Path::cast(subpath.as_node()?.clone())?;
+                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
+            }
+            (Some((segment, PATH_SEGMENT)), _, _) => {
+                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
+                break;
+            }
+            (_, _, _) => return None,
+        }
+    }
+    // We need to reverse only the new added segments
+    let only_new_segments = segments.split_at_mut(oldlen).1;
+    only_new_segments.reverse();
+    Some(segments.len() - oldlen)
+}
+
+fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
+    let mut iter = segments.iter();
+    if let Some(s) = iter.next() {
+        buf.push_str(s);
+    }
+    for s in iter {
+        buf.push_str("::");
+        buf.push_str(s);
+    }
+}
+
+/// Returns the number of common segments.
+fn compare_path_segments(left: &[SmolStr], right: &[ast::PathSegment]) -> usize {
+    left.iter().zip(right).take_while(|(l, r)| compare_path_segment(l, r)).count()
+}
+
+fn compare_path_segment(a: &SmolStr, b: &ast::PathSegment) -> bool {
+    if let Some(kb) = b.kind() {
+        match kb {
+            ast::PathSegmentKind::Name(nameref_b) => a == nameref_b.text(),
+            ast::PathSegmentKind::SelfKw => a == "self",
+            ast::PathSegmentKind::SuperKw => a == "super",
+            ast::PathSegmentKind::CrateKw => a == "crate",
+            ast::PathSegmentKind::Type { .. } => false, // not allowed in imports
+        }
+    } else {
+        false
+    }
+}
+
+fn compare_path_segment_with_name(a: &SmolStr, b: &ast::Name) -> bool {
+    a == b.text()
+}
+
+#[derive(Clone, Debug)]
+enum ImportAction {
+    Nothing,
+    // Add a brand new use statement.
+    AddNewUse {
+        anchor: Option<SyntaxNode>, // anchor node
+        add_after_anchor: bool,
+    },
+
+    // To split an existing use statement creating a nested import.
+    AddNestedImport {
+        // how may segments matched with the target path
+        common_segments: usize,
+        path_to_split: ast::Path,
+        // the first segment of path_to_split we want to add into the new nested list
+        first_segment_to_split: Option<ast::PathSegment>,
+        // Wether to add 'self' in addition to the target path
+        add_self: bool,
+    },
+    // To add the target path to an existing nested import tree list.
+    AddInTreeList {
+        common_segments: usize,
+        // The UseTreeList where to add the target path
+        tree_list: ast::UseTreeList,
+        add_self: bool,
+    },
+}
+
+impl ImportAction {
+    fn add_new_use(anchor: Option<SyntaxNode>, add_after_anchor: bool) -> Self {
+        ImportAction::AddNewUse { anchor, add_after_anchor }
+    }
+
+    fn add_nested_import(
+        common_segments: usize,
+        path_to_split: ast::Path,
+        first_segment_to_split: Option<ast::PathSegment>,
+        add_self: bool,
+    ) -> Self {
+        ImportAction::AddNestedImport {
+            common_segments,
+            path_to_split,
+            first_segment_to_split,
+            add_self,
+        }
+    }
+
+    fn add_in_tree_list(
+        common_segments: usize,
+        tree_list: ast::UseTreeList,
+        add_self: bool,
+    ) -> Self {
+        ImportAction::AddInTreeList { common_segments, tree_list, add_self }
+    }
+
+    fn better(left: ImportAction, right: ImportAction) -> ImportAction {
+        if left.is_better(&right) {
+            left
+        } else {
+            right
+        }
+    }
+
+    fn is_better(&self, other: &ImportAction) -> bool {
+        match (self, other) {
+            (ImportAction::Nothing, _) => true,
+            (ImportAction::AddInTreeList { .. }, ImportAction::Nothing) => false,
+            (
+                ImportAction::AddNestedImport { common_segments: n, .. },
+                ImportAction::AddInTreeList { common_segments: m, .. },
+            )
+            | (
+                ImportAction::AddInTreeList { common_segments: n, .. },
+                ImportAction::AddNestedImport { common_segments: m, .. },
+            )
+            | (
+                ImportAction::AddInTreeList { common_segments: n, .. },
+                ImportAction::AddInTreeList { common_segments: m, .. },
+            )
+            | (
+                ImportAction::AddNestedImport { common_segments: n, .. },
+                ImportAction::AddNestedImport { common_segments: m, .. },
+            ) => n > m,
+            (ImportAction::AddInTreeList { .. }, _) => true,
+            (ImportAction::AddNestedImport { .. }, ImportAction::Nothing) => false,
+            (ImportAction::AddNestedImport { .. }, _) => true,
+            (ImportAction::AddNewUse { .. }, _) => false,
+        }
+    }
+}
+
+// Find out the best ImportAction to import target path against current_use_tree.
+// If current_use_tree has a nested import the function gets called recursively on every UseTree inside a UseTreeList.
+fn walk_use_tree_for_best_action(
+    current_path_segments: &mut Vec<ast::PathSegment>, // buffer containing path segments
+    current_parent_use_tree_list: Option<ast::UseTreeList>, // will be Some value if we are in a nested import
+    current_use_tree: ast::UseTree, // the use tree we are currently examinating
+    target: &[SmolStr],             // the path we want to import
+) -> ImportAction {
+    // We save the number of segments in the buffer so we can restore the correct segments
+    // before returning. Recursive call will add segments so we need to delete them.
+    let prev_len = current_path_segments.len();
+
+    let tree_list = current_use_tree.use_tree_list();
+    let alias = current_use_tree.alias();
+
+    let path = match current_use_tree.path() {
+        Some(path) => path,
+        None => {
+            // If the use item don't have a path, it means it's broken (syntax error)
+            return ImportAction::add_new_use(
+                current_use_tree
+                    .syntax()
+                    .ancestors()
+                    .find_map(ast::UseItem::cast)
+                    .map(|it| it.syntax().clone()),
+                true,
+            );
+        }
+    };
+
+    // This can happen only if current_use_tree is a direct child of a UseItem
+    if let Some(name) = alias.and_then(|it| it.name()) {
+        if compare_path_segment_with_name(&target[0], &name) {
+            return ImportAction::Nothing;
+        }
+    }
+
+    collect_path_segments_raw(current_path_segments, path.clone());
+
+    // We compare only the new segments added in the line just above.
+    // The first prev_len segments were already compared in 'parent' recursive calls.
+    let left = target.split_at(prev_len).1;
+    let right = current_path_segments.split_at(prev_len).1;
+    let common = compare_path_segments(left, &right);
+    let mut action = match common {
+        0 => ImportAction::add_new_use(
+            // e.g: target is std::fmt and we can have
+            // use foo::bar
+            // We add a brand new use statement
+            current_use_tree
+                .syntax()
+                .ancestors()
+                .find_map(ast::UseItem::cast)
+                .map(|it| it.syntax().clone()),
+            true,
+        ),
+        common if common == left.len() && left.len() == right.len() => {
+            // e.g: target is std::fmt and we can have
+            // 1- use std::fmt;
+            // 2- use std::fmt::{ ... }
+            if let Some(list) = tree_list {
+                // In case 2 we need to add self to the nested list
+                // unless it's already there
+                let has_self = list.use_trees().map(|it| it.path()).any(|p| {
+                    p.and_then(|it| it.segment())
+                        .and_then(|it| it.kind())
+                        .filter(|k| *k == ast::PathSegmentKind::SelfKw)
+                        .is_some()
+                });
+
+                if has_self {
+                    ImportAction::Nothing
+                } else {
+                    ImportAction::add_in_tree_list(current_path_segments.len(), list, true)
+                }
+            } else {
+                // Case 1
+                ImportAction::Nothing
+            }
+        }
+        common if common != left.len() && left.len() == right.len() => {
+            // e.g: target is std::fmt and we have
+            // use std::io;
+            // We need to split.
+            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
+            ImportAction::add_nested_import(
+                prev_len + common,
+                path,
+                Some(segments_to_split[0].clone()),
+                false,
+            )
+        }
+        common if common == right.len() && left.len() > right.len() => {
+            // e.g: target is std::fmt and we can have
+            // 1- use std;
+            // 2- use std::{ ... };
+
+            // fallback action
+            let mut better_action = ImportAction::add_new_use(
+                current_use_tree
+                    .syntax()
+                    .ancestors()
+                    .find_map(ast::UseItem::cast)
+                    .map(|it| it.syntax().clone()),
+                true,
+            );
+            if let Some(list) = tree_list {
+                // Case 2, check recursively if the path is already imported in the nested list
+                for u in list.use_trees() {
+                    let child_action = walk_use_tree_for_best_action(
+                        current_path_segments,
+                        Some(list.clone()),
+                        u,
+                        target,
+                    );
+                    if child_action.is_better(&better_action) {
+                        better_action = child_action;
+                        if let ImportAction::Nothing = better_action {
+                            return better_action;
+                        }
+                    }
+                }
+            } else {
+                // Case 1, split adding self
+                better_action = ImportAction::add_nested_import(prev_len + common, path, None, true)
+            }
+            better_action
+        }
+        common if common == left.len() && left.len() < right.len() => {
+            // e.g: target is std::fmt and we can have
+            // use std::fmt::Debug;
+            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
+            ImportAction::add_nested_import(
+                prev_len + common,
+                path,
+                Some(segments_to_split[0].clone()),
+                true,
+            )
+        }
+        common if common < left.len() && common < right.len() => {
+            // e.g: target is std::fmt::nested::Debug
+            // use std::fmt::Display
+            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
+            ImportAction::add_nested_import(
+                prev_len + common,
+                path,
+                Some(segments_to_split[0].clone()),
+                false,
+            )
+        }
+        _ => unreachable!(),
+    };
+
+    // If we are inside a UseTreeList adding a use statement become adding to the existing
+    // tree list.
+    action = match (current_parent_use_tree_list, action.clone()) {
+        (Some(use_tree_list), ImportAction::AddNewUse { .. }) => {
+            ImportAction::add_in_tree_list(prev_len, use_tree_list, false)
+        }
+        (_, _) => action,
+    };
+
+    // We remove the segments added
+    current_path_segments.truncate(prev_len);
+    action
+}
+
+fn best_action_for_target(
+    container: SyntaxNode,
+    anchor: SyntaxNode,
+    target: &[SmolStr],
+) -> ImportAction {
+    let mut storage = Vec::with_capacity(16); // this should be the only allocation
+    let best_action = container
+        .children()
+        .filter_map(ast::UseItem::cast)
+        .filter_map(|it| it.use_tree())
+        .map(|u| walk_use_tree_for_best_action(&mut storage, None, u, target))
+        .fold(None, |best, a| match best {
+            Some(best) => Some(ImportAction::better(best, a)),
+            None => Some(a),
+        });
+
+    match best_action {
+        Some(action) => action,
+        None => {
+            // We have no action and no UseItem was found in container so we find
+            // another item and we use it as anchor.
+            // If there are no items above, we choose the target path itself as anchor.
+            // todo: we should include even whitespace blocks as anchor candidates
+            let anchor = container.children().next().or_else(|| Some(anchor));
+
+            let add_after_anchor = anchor
+                .clone()
+                .and_then(ast::Attr::cast)
+                .map(|attr| attr.kind() == ast::AttrKind::Inner)
+                .unwrap_or(false);
+            ImportAction::add_new_use(anchor, add_after_anchor)
+        }
+    }
+}
+
+fn make_assist(action: &ImportAction, target: &[SmolStr], edit: &mut TextEditBuilder) {
+    match action {
+        ImportAction::AddNewUse { anchor, add_after_anchor } => {
+            make_assist_add_new_use(anchor, *add_after_anchor, target, edit)
+        }
+        ImportAction::AddInTreeList { common_segments, tree_list, add_self } => {
+            // We know that the fist n segments already exists in the use statement we want
+            // to modify, so we want to add only the last target.len() - n segments.
+            let segments_to_add = target.split_at(*common_segments).1;
+            make_assist_add_in_tree_list(tree_list, segments_to_add, *add_self, edit)
+        }
+        ImportAction::AddNestedImport {
+            common_segments,
+            path_to_split,
+            first_segment_to_split,
+            add_self,
+        } => {
+            let segments_to_add = target.split_at(*common_segments).1;
+            make_assist_add_nested_import(
+                path_to_split,
+                first_segment_to_split,
+                segments_to_add,
+                *add_self,
+                edit,
+            )
+        }
+        _ => {}
+    }
+}
+
+fn make_assist_add_new_use(
+    anchor: &Option<SyntaxNode>,
+    after: bool,
+    target: &[SmolStr],
+    edit: &mut TextEditBuilder,
+) {
+    if let Some(anchor) = anchor {
+        let indent = ra_fmt::leading_indent(anchor);
+        let mut buf = String::new();
+        if after {
+            buf.push_str("\n");
+            if let Some(spaces) = &indent {
+                buf.push_str(spaces);
+            }
+        }
+        buf.push_str("use ");
+        fmt_segments_raw(target, &mut buf);
+        buf.push_str(";");
+        if !after {
+            buf.push_str("\n\n");
+            if let Some(spaces) = &indent {
+                buf.push_str(&spaces);
+            }
+        }
+        let position = if after { anchor.text_range().end() } else { anchor.text_range().start() };
+        edit.insert(position, buf);
+    }
+}
+
+fn make_assist_add_in_tree_list(
+    tree_list: &ast::UseTreeList,
+    target: &[SmolStr],
+    add_self: bool,
+    edit: &mut TextEditBuilder,
+) {
+    let last = tree_list.use_trees().last();
+    if let Some(last) = last {
+        let mut buf = String::new();
+        let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == T![,]);
+        let offset = if let Some(comma) = comma {
+            comma.text_range().end()
+        } else {
+            buf.push_str(",");
+            last.syntax().text_range().end()
+        };
+        if add_self {
+            buf.push_str(" self")
+        } else {
+            buf.push_str(" ");
+        }
+        fmt_segments_raw(target, &mut buf);
+        edit.insert(offset, buf);
+    } else {
+    }
+}
+
+fn make_assist_add_nested_import(
+    path: &ast::Path,
+    first_segment_to_split: &Option<ast::PathSegment>,
+    target: &[SmolStr],
+    add_self: bool,
+    edit: &mut TextEditBuilder,
+) {
+    let use_tree = path.syntax().ancestors().find_map(ast::UseTree::cast);
+    if let Some(use_tree) = use_tree {
+        let (start, add_colon_colon) = if let Some(first_segment_to_split) = first_segment_to_split
+        {
+            (first_segment_to_split.syntax().text_range().start(), false)
+        } else {
+            (use_tree.syntax().text_range().end(), true)
+        };
+        let end = use_tree.syntax().text_range().end();
+
+        let mut buf = String::new();
+        if add_colon_colon {
+            buf.push_str("::");
+        }
+        buf.push_str("{");
+        if add_self {
+            buf.push_str("self, ");
+        }
+        fmt_segments_raw(target, &mut buf);
+        if !target.is_empty() {
+            buf.push_str(", ");
+        }
+        edit.insert(start, buf);
+        edit.insert(end, "}".to_string());
+    }
+}
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_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..3aa964fb6 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -26,9 +26,10 @@ macro_rules! impl_froms {
     }
 }
 
+mod semantics;
 pub mod db;
-pub mod source_analyzer;
-pub mod source_binder;
+mod source_analyzer;
+mod source_binder;
 
 pub mod diagnostics;
 
@@ -45,8 +46,8 @@ pub use crate::{
         StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
     },
     has_source::HasSource,
-    source_analyzer::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
-    source_binder::SourceBinder,
+    semantics::{original_range, Semantics, SemanticsScope},
+    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..4a9cb7b3e
--- /dev/null
+++ b/crates/ra_hir/src/semantics.rs
@@ -0,0 +1,405 @@
+//! 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::skip_trivia_token, ast, match_ast, AstNode, Direction, 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, ModuleDef, Name, Origin, Path,
+    PathResolution, ScopeDef, StructField, Trait, Type, TypeParam, VariantDef,
+};
+use hir_expand::ExpansionInfo;
+use ra_prof::profile;
+
+/// Primary API to get semantic information, like types, from syntax trees.
+pub struct Semantics<'db, DB> {
+    pub db: &'db DB,
+    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)
+    }
+
+    pub fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option<ModuleDef> {
+        self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
+    }
+
+    // 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 {
+    if let Some(range) = original_range_opt(db, node) {
+        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 };
+        }
+
+        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_opt(
+    db: &impl HirDatabase,
+    node: InFile<&SyntaxNode>,
+) -> Option<InFile<TextRange>> {
+    let expansion = node.file_id.expansion_info(db)?;
+
+    // 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 first = ascend_call_token(db, &expansion, node.with_value(first))?;
+
+        let last = skip_trivia_token(it.last_token()?, Direction::Prev)?;
+        let last = ascend_call_token(db, &expansion, node.with_value(last))?;
+
+        if (!single && first == last) || (first.file_id != last.file_id) {
+            return None;
+        }
+
+        Some(first.with_value(first.value.text_range().extend_to(&last.value.text_range())))
+    })?)
+}
+
+fn ascend_call_token(
+    db: &impl HirDatabase,
+    expansion: &ExpansionInfo,
+    token: InFile<SyntaxToken>,
+) -> Option<InFile<SyntaxToken>> {
+    let (mapped, origin) = expansion.map_token_up(token.as_ref())?;
+    if origin != Origin::Call {
+        return None;
+    }
+    if let Some(info) = mapped.file_id.expansion_info(db) {
+        return ascend_call_token(db, &info, mapped);
+    }
+    Some(mapped)
+}
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index efa3f8a79..c650a9e08 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -11,32 +11,31 @@ use either::Either;
 use hir_def::{
     body::{
         scope::{ExprScopes, ScopeId},
-        BodySourceMap,
+        Body, BodySourceMap,
     },
-    expr::{ExprId, PatId},
-    resolver::{self, resolver_for_scope, Resolver, TypeNs, ValueNs},
-    AsMacroCall, DefWithBodyId, TraitId,
+    expr::{ExprId, Pat, PatId},
+    resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
+    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,
-    ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+    db::HirDatabase, Adt, Const, EnumVariant, Function, Local, MacroDef, ModuleDef, Path, Static,
+    Struct, Trait, Type, TypeAlias, TypeParam,
 };
 
 /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
 /// original source files. It should not be used inside the HIR itself.
 #[derive(Debug)]
-pub struct SourceAnalyzer {
+pub(crate) struct SourceAnalyzer {
     file_id: HirFileId,
-    resolver: Resolver,
-    body_owner: Option<DefWithBody>,
+    pub(crate) resolver: Resolver,
+    body: Option<Arc<Body>>,
     body_source_map: Option<Arc<BodySourceMap>>,
     infer: Option<Arc<InferenceResult>>,
     scopes: Option<Arc<ExprScopes>>,
@@ -55,64 +54,20 @@ pub enum PathResolution {
     AssocItem(crate::AssocItem),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ScopeEntryWithSyntax {
-    pub(crate) name: Name,