57 files changed, 1835 insertions, 650 deletions

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index ff7a95ee1..eae4fbcb5 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -190,4 +190,4 @@ jobs:
       - name: Publish Extension
         working-directory: ./editors/code
         # token from https://dev.azure.com/rust-analyzer/
-        run: ./node_modules/vsce/out/vsce publish 0.1.$(date +%Y%m%d) --pat ${{ secrets.MARKETPLACE_TOKEN }}
+        run: npx vsce publish 0.1.$(date +%Y%m%d) --pat ${{ secrets.MARKETPLACE_TOKEN }}
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 55a2f10f2..b1bd98d4a 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -2,39 +2,61 @@
   // Use IntelliSense to learn about possible attributes.
   // Hover to view descriptions of existing attributes.
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+
+  // NOTE: --disable-extensions
+  // Disable all installed extensions to increase performance of the debug instance
+  // and prevent potential conflicts with other installed extensions.
+
   "version": "0.2.0",
   "configurations": [
     {
+      // Used for testing the extension with the installed LSP server.
       "name": "Run Extension",
       "type": "extensionHost",
       "request": "launch",
       "runtimeExecutable": "${execPath}",
       "args": [
+        "--disable-extensions",
         "--extensionDevelopmentPath=${workspaceFolder}/editors/code"
       ],
       "outFiles": [
         "${workspaceFolder}/editors/code/out/**/*.js"
       ],
-      "preLaunchTask": "Build Extension"
+      "preLaunchTask": "Build Extension",
+      "skipFiles": [
+        "<node_internals>/**/*.js"
+      ]
     },
     {
+      // Used for testing the extension with a local build of the LSP server (in `target/debug`).
       "name": "Run Extension (Dev Server)",
       "type": "extensionHost",
       "request": "launch",
       "runtimeExecutable": "${execPath}",
       "args": [
+        "--disable-extensions",
         "--extensionDevelopmentPath=${workspaceFolder}/editors/code"
       ],
       "outFiles": [
         "${workspaceFolder}/editors/code/out/**/*.js"
       ],
       "preLaunchTask": "Build Extension",
+      "skipFiles": [
+        "<node_internals>/**/*.js"
+      ],
       "env": {
         "__RA_LSP_SERVER_DEBUG": "${workspaceFolder}/target/debug/ra_lsp_server"
       }
     },
     {
-      "name": "Debug Lsp Server",
+      // Used to attach LLDB to a running LSP server.
+      // NOTE: Might require root permissions. For this run:
+      //
+      // `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope`
+      //
+      // Don't forget to set `debug = 2` in `Cargo.toml` before building the server
+
+      "name": "Attach To Server",
       "type": "lldb",
       "request": "attach",
       "program": "${workspaceFolder}/target/debug/ra_lsp_server",
diff --git a/Cargo.lock b/Cargo.lock
index f1651edaa..f44e514dd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1015,6 +1015,7 @@ name = "ra_cli"
 version = "0.1.0"
 dependencies = [
  "env_logger",
+ "itertools",
  "pico-args",
  "ra_batch",
  "ra_db",
@@ -1024,6 +1025,7 @@ dependencies = [
  "ra_ide",
  "ra_prof",
  "ra_syntax",
+ "rand 0.7.3",
 ]
 
 [[package]]
@@ -1174,7 +1176,6 @@ dependencies = [
  "ra_prof",
  "ra_syntax",
  "ra_text_edit",
- "rand 0.7.3",
  "rayon",
  "rustc-hash",
  "superslice",
diff --git a/Cargo.toml b/Cargo.toml
index e5620b1b7..c034e2424 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,3 +31,8 @@ opt-level = 0
 
 [patch.'crates-io']
 # rowan = { path = "../rowan" }
+
+[patch.'https://github.com/rust-lang/chalk.git']
+# chalk-solve = { path = "../chalk/chalk-solve" }
+# chalk-rust-ir = { path = "../chalk/chalk-rust-ir" }
+# chalk-ir = { path = "../chalk/chalk-ir" }
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 448697d31..ab21388c8 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::{db::HirDatabase, HasSource, InFile};
+use hir::{HasSource, InFile};
 use ra_syntax::{
     ast::{self, edit, make, AstNode, NameOwner},
     SmolStr,
@@ -6,6 +6,7 @@ use ra_syntax::{
 
 use crate::{
     ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
+    utils::{get_missing_impl_items, resolve_target_trait},
     Assist, AssistCtx, AssistId,
 };
 
@@ -103,11 +104,9 @@ 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 (trait_, trait_def) = {
-        let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
+    let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
 
-        resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
-    };
+    let trait_ = resolve_target_trait(ctx.db, &analyzer, &impl_node)?;
 
     let def_name = |item: &ast::ImplItem| -> Option<SmolStr> {
         match item {
@@ -118,11 +117,14 @@ fn add_missing_impl_members_inner(
         .map(|it| it.text().clone())
     };
 
-    let trait_items = trait_def.item_list()?.impl_items();
-    let impl_items = impl_item_list.impl_items().collect::<Vec<_>>();
-
-    let missing_items: Vec<_> = trait_items
-        .filter(|t| def_name(t).is_some())
+    let missing_items = get_missing_impl_items(ctx.db, &analyzer, &impl_node)
+        .iter()
+        .map(|i| match i {
+            hir::AssocItem::Function(i) => ast::ImplItem::FnDef(i.source(ctx.db).value),
+            hir::AssocItem::TypeAlias(i) => ast::ImplItem::TypeAliasDef(i.source(ctx.db).value),
+            hir::AssocItem::Const(i) => ast::ImplItem::ConstDef(i.source(ctx.db).value),
+        })
+        .filter(|t| def_name(&t).is_some())
         .filter(|t| match t {
             ast::ImplItem::FnDef(def) => match mode {
                 AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
@@ -130,8 +132,8 @@ fn add_missing_impl_members_inner(
             },
             _ => mode == AddMissingImplMembersMode::NoDefaultMethods,
         })
-        .filter(|t| impl_items.iter().all(|i| def_name(i) != def_name(t)))
-        .collect();
+        .collect::<Vec<_>>();
+
     if missing_items.is_empty() {
         return None;
     }
@@ -177,27 +179,6 @@ fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
     }
 }
 
-/// Given an `ast::ImplBlock`, resolves the target trait (the one being
-/// implemented) to a `ast::TraitDef`.
-fn resolve_target_trait_def(
-    db: &impl HirDatabase,
-    analyzer: &hir::SourceAnalyzer,
-    impl_block: &ast::ImplBlock,
-) -> Option<(hir::Trait, ast::TraitDef)> {
-    let ast_path = impl_block
-        .target_trait()
-        .map(|it| it.syntax().clone())
-        .and_then(ast::PathType::cast)?
-        .path()?;
-
-    match analyzer.resolve_path(db, &ast_path) {
-        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => {
-            Some((def, def.source(db).value))
-        }
-        _ => None,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 828a8e9e8..cb124eaf0 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -9,7 +9,7 @@ mod assist_ctx;
 mod marks;
 #[cfg(test)]
 mod doc_tests;
-mod utils;
+pub mod utils;
 pub mod ast_transform;
 
 use ra_db::FileRange;
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 0d5722295..6ff44c95c 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -1,10 +1,81 @@
 //! Assorted functions shared by several assists.
 
 use ra_syntax::{
-    ast::{self, make},
-    T,
+    ast::{self, make, NameOwner},
+    AstNode, T,
 };
 
+use hir::db::HirDatabase;
+use rustc_hash::FxHashSet;
+
+pub fn get_missing_impl_items(
+    db: &impl HirDatabase,
+    analyzer: &hir::SourceAnalyzer,
+    impl_block: &ast::ImplBlock,
+) -> Vec<hir::AssocItem> {
+    // Names must be unique between constants and functions. However, type aliases
+    // may share the same name as a function or constant.
+    let mut impl_fns_consts = FxHashSet::default();
+    let mut impl_type = FxHashSet::default();
+
+    if let Some(item_list) = impl_block.item_list() {
+        for item in item_list.impl_items() {
+            match item {
+                ast::ImplItem::FnDef(f) => {
+                    if let Some(n) = f.name() {
+                        impl_fns_consts.insert(n.syntax().to_string());
+                    }
+                }
+
+                ast::ImplItem::TypeAliasDef(t) => {
+                    if let Some(n) = t.name() {
+                        impl_type.insert(n.syntax().to_string());
+                    }
+                }
+
+                ast::ImplItem::ConstDef(c) => {
+                    if let Some(n) = c.name() {
+                        impl_fns_consts.insert(n.syntax().to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    resolve_target_trait(db, analyzer, impl_block).map_or(vec![], |target_trait| {
+        target_trait
+            .items(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::Const(c) => c
+                    .name(db)
+                    .map(|n| !impl_fns_consts.contains(&n.to_string()))
+                    .unwrap_or_default(),
+            })
+            .cloned()
+            .collect()
+    })
+}
+
+pub(crate) fn resolve_target_trait(
+    db: &impl HirDatabase,
+    analyzer: &hir::SourceAnalyzer,
+    impl_block: &ast::ImplBlock,
+) -> Option<hir::Trait> {
+    let ast_path = impl_block
+        .target_trait()
+        .map(|it| it.syntax().clone())
+        .and_then(ast::PathType::cast)?
+        .path()?;
+
+    match analyzer.resolve_path(db, &ast_path) {
+        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => Some(def),
+        _ => None,
+    }
+}
+
 pub(crate) fn invert_boolean_expression(expr: ast::Expr) -> ast::Expr {
     if let Some(expr) = invert_special_case(&expr) {
         return expr;
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index bcd408421..53d4876f6 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -6,8 +6,10 @@ authors = ["rust-analyzer developers"]
 publish = false
 
 [dependencies]
+itertools = "0.8.0"
 pico-args = "0.3.0"
 env_logger = { version = "0.7.1", default-features = false }
+rand = { version = "0.7.0", features = ["small_rng"] }
 
 ra_syntax = { path = "../ra_syntax" }
 ra_ide = { path = "../ra_ide" }
diff --git a/crates/ra_cli/src/analysis_bench.rs b/crates/ra_cli/src/analysis_bench.rs
index 5485a38ff..4835a68ce 100644
--- a/crates/ra_cli/src/analysis_bench.rs
+++ b/crates/ra_cli/src/analysis_bench.rs
@@ -2,6 +2,7 @@
 
 use std::{
     path::{Path, PathBuf},
+    str::FromStr,
     sync::Arc,
     time::Instant,
 };
@@ -14,12 +15,35 @@ use ra_ide::{Analysis, AnalysisChange, AnalysisHost, FilePosition, LineCol};
 
 use crate::Result;
 
+pub(crate) struct Position {
+    path: PathBuf,
+    line: u32,
+    column: u32,
+}
+
+impl FromStr for Position {
+    type Err = Box<dyn std::error::Error + Send + Sync>;
+    fn from_str(s: &str) -> Result<Self> {
+        let (path_line, column) = rsplit_at_char(s, ':')?;
+        let (path, line) = rsplit_at_char(path_line, ':')?;
+        Ok(Position { path: path.into(), line: line.parse()?, column: column.parse()? })
+    }
+}
+
+fn rsplit_at_char(s: &str, c: char) -> Result<(&str, &str)> {
+    let idx = s.rfind(':').ok_or_else(|| format!("no `{}` in {}", c, s))?;
+    Ok((&s[..idx], &s[idx + 1..]))
+}
+
 pub(crate) enum Op {
     Highlight { path: PathBuf },
-    Complete { path: PathBuf, line: u32, column: u32 },
+    Complete(Position),
+    GotoDef(Position),
 }
 
 pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
+    ra_prof::init();
+
     let start = Instant::now();
     eprint!("loading: ");
     let (mut host, roots) = ra_batch::load_cargo(path)?;
@@ -29,7 +53,7 @@ pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
     let file_id = {
         let path = match &op {
             Op::Highlight { path } => path,
-            Op::Complete { path, .. } => path,
+            Op::Complete(pos) | Op::GotoDef(pos) => &pos.path,
         };
         let path = std::env::current_dir()?.join(path).canonicalize()?;
         roots
@@ -49,7 +73,7 @@ pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
             .ok_or_else(|| format!("Can't find {:?}", path))?
     };
 
-    match op {
+    match &op {
         Op::Highlight { .. } => {
             let res = do_work(&mut host, file_id, |analysis| {
                 analysis.diagnostics(file_id).unwrap();
@@ -59,16 +83,30 @@ pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
                 println!("\n{}", res);
             }
         }
-        Op::Complete { line, column, .. } => {
+        Op::Complete(pos) | Op::GotoDef(pos) => {
+            let is_completion = match op {
+                Op::Complete(..) => true,
+                _ => false,
+            };
+
             let offset = host
                 .analysis()
                 .file_line_index(file_id)?
-                .offset(LineCol { line, col_utf16: column });
+                .offset(LineCol { line: pos.line - 1, col_utf16: pos.column });
             let file_postion = FilePosition { file_id, offset };
 
-            let res = do_work(&mut host, file_id, |analysis| analysis.completions(file_postion));
-            if verbose {
-                println!("\n{:#?}", res);
+            if is_completion {
+                let res =
+                    do_work(&mut host, file_id, |analysis| analysis.completions(file_postion));
+                if verbose {
+                    println!("\n{:#?}", res);
+                }
+            } else {
+                let res =
+                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_postion));
+                if verbose {
+                    println!("\n{:#?}", res);
+                }
             }
         }
     }
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 833235bff..6d2dd34c6 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -2,6 +2,9 @@
 
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
 
+use itertools::Itertools;
+use rand::{seq::SliceRandom, thread_rng};
+
 use hir::{
     db::{DefDatabase, HirDatabase},
     AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
@@ -19,6 +22,7 @@ pub fn run(
     path: &Path,
     only: Option<&str>,
     with_deps: bool,
+    randomize: bool,
 ) -> Result<()> {
     let db_load_time = Instant::now();
     let (mut host, roots) = ra_batch::load_cargo(path)?;
@@ -41,7 +45,11 @@ pub fn run(
             })
             .collect::<HashSet<_>>();
 
-    for krate in Crate::all(db) {
+    let mut krates = Crate::all(db);
+    if randomize {
+        krates.shuffle(&mut thread_rng());
+    }
+    for krate in krates {
         let module = krate.root_module(db).expect("crate without root module");
         let file_id = module.definition_source(db).file_id;
         if members.contains(&db.file_source_root(file_id.original_file(db))) {
@@ -50,6 +58,10 @@ pub fn run(
         }
     }
 
+    if randomize {
+        visit_queue.shuffle(&mut thread_rng());
+    }
+
     println!("Crates in this dir: {}", num_crates);
     let mut num_decls = 0;
     let mut funcs = Vec::new();
@@ -79,10 +91,14 @@ pub fn run(
     println!("Total functions: {}", funcs.len());
     println!("Item Collection: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
 
+    if randomize {
+        funcs.shuffle(&mut thread_rng());
+    }
+
     let inference_time = Instant::now();
     let mut bar = match verbosity {
-        Verbosity::Verbose | Verbosity::Normal => ProgressReport::new(funcs.len() as u64),
-        Verbosity::Quiet => ProgressReport::hidden(),
+        Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
+        _ => ProgressReport::new(funcs.len() as u64),
     };
 
     bar.tick();
@@ -92,7 +108,20 @@ pub fn run(
     let mut num_type_mismatches = 0;
     for f in funcs {
         let name = f.name(db);
-        let mut msg = format!("processing: {}", name);
+        let full_name = f
+            .module(db)
+            .path_to_root(db)
+            .into_iter()
+            .rev()
+            .filter_map(|it| it.name(db))
+            .chain(Some(f.name(db)))
+            .join("::");
+        if let Some(only_name) = only {
+            if name.to_string() != only_name && full_name != only_name {
+                continue;
+            }
+        }
+        let mut msg = format!("processing: {}", full_name);
         if verbosity.is_verbose() {
             let src = f.source(db);
             let original_file = src.file_id.original_file(db);
@@ -100,15 +129,15 @@ pub fn run(
             let syntax_range = src.value.syntax().text_range();
             write!(msg, " ({:?} {})", path, syntax_range).unwrap();
         }
-        bar.set_message(&msg);
-        if let Some(only_name) = only {
-            if name.to_string() != only_name {
-                continue;
-            }
+        if verbosity.is_spammy() {
+            bar.println(format!("{}", msg));
         }
+        bar.set_message(&msg);
         let f_id = FunctionId::from(f);
         let body = db.body(f_id.into());
         let inference_result = db.infer(f_id.into());
+        let (previous_exprs, previous_unknown, previous_partially_unknown) =
+            (num_exprs, num_exprs_unknown, num_exprs_partially_unknown);
         for (expr_id, _) in body.exprs.iter() {
             let ty = &inference_result[expr_id];
             num_exprs += 1;
@@ -125,6 +154,33 @@ pub fn run(
                     num_exprs_partially_unknown += 1;
                 }
             }
+            if only.is_some() && verbosity.is_spammy() {
+                // in super-verbose mode for just one function, we print every single expression
+                let (_, sm) = db.body_with_source_map(f_id.into());
+                let src = sm.expr_syntax(expr_id);
+                if let Some(src) = src {
+                    let original_file = src.file_id.original_file(db);
+                    let line_index = host.analysis().file_line_index(original_file).unwrap();
+                    let text_range = src.value.either(
+                        |it| it.syntax_node_ptr().range(),
+                        |it| it.syntax_node_ptr().range(),
+                    );
+                    let (start, end) = (
+                        line_index.line_col(text_range.start()),
+                        line_index.line_col(text_range.end()),
+                    );
+                    bar.println(format!(
+                        "{}:{}-{}:{}: {}",
+                        start.line + 1,
+                        start.col_utf16,
+                        end.line + 1,
+                        end.col_utf16,
+                        ty.display(db)
+                    ));
+                } else {
+                    bar.println(format!("unknown location: {}", ty.display(db)));
+                }
+            }
             if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
                 num_type_mismatches += 1;
                 if verbosity.is_verbose() {
@@ -164,6 +220,15 @@ pub fn run(
                 }
             }
         }
+        if verbosity.is_spammy() {
+            bar.println(format!(
+                "In {}: {} exprs, {} unknown, {} partial",
+                full_name,
+                num_exprs - previous_exprs,
+                num_exprs_unknown - previous_unknown,
+                num_exprs_partially_unknown - previous_partially_unknown
+            ));
+        }
         bar.inc(1);
     }
     bar.finish_and_clear();
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index 806612c2c..750cbab86 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -16,6 +16,7 @@ type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 
 #[derive(Clone, Copy)]
 pub enum Verbosity {
+    Spammy,
     Verbose,
     Normal,
     Quiet,
@@ -24,7 +25,13 @@ pub enum Verbosity {
 impl Verbosity {
     fn is_verbose(self) -> bool {
         match self {
-            Verbosity::Verbose => true,
+            Verbosity::Verbose | Verbosity::Spammy => true,
+            _ => false,
+        }
+    }
+    fn is_spammy(self) -> bool {
+        match self {
+            Verbosity::Spammy => true,
             _ => false,
         }
     }
@@ -86,14 +93,18 @@ fn main() -> Result<()> {
                 return Ok(());
             }
             let verbosity = match (
+                matches.contains(["-vv", "--spammy"]),
                 matches.contains(["-v", "--verbose"]),
                 matches.contains(["-q", "--quiet"]),
             ) {
-                (false, false) => Verbosity::Normal,
-                (false, true) => Verbosity::Quiet,
-                (true, false) => Verbosity::Verbose,
-                (true, true) => Err("Invalid flags: -q conflicts with -v")?,
+                (true, _, true) => Err("Invalid flags: -q conflicts with -vv")?,
+                (true, _, false) => Verbosity::Spammy,
+                (false, false, false) => Verbosity::Normal,
+                (false, false, true) => Verbosity::Quiet,
+                (false, true, false) => Verbosity::Verbose,
+                (false, true, true) => Err("Invalid flags: -q conflicts with -v")?,
             };
+            let randomize = matches.contains("--randomize");
             let memory_usage = matches.contains("--memory-usage");
             let only: Option<String> = matches.opt_value_from_str(["-o", "--only"])?;
             let with_deps: bool = matches.contains("--with-deps");
@@ -111,6 +122,7 @@ fn main() -> Result<()> {
                 path.as_ref(),
                 only.as_ref().map(String::as_ref),
                 with_deps,
+                randomize,
             )?;
         }
         "analysis-bench" => {
@@ -120,25 +132,16 @@ fn main() -> Result<()> {
             }
             let verbose = matches.contains(["-v", "--verbose"]);
             let path: String = matches.opt_value_from_str("--path")?.unwrap_or_default();
-            let highlight_path = matches.opt_value_from_str("--highlight")?;
-            let complete_path = matches.opt_value_from_str("--complete")?;
-            if highlight_path.is_some() && complete_path.is_some() {
-                panic!("either --highlight or --complete must be set, not both")
-            }
-            let op = if let Some(path) = highlight_path {
-                let path: String = path;
-                analysis_bench::Op::Highlight { path: path.into() }
-            } else if let Some(path_line_col) = complete_path {
-                let path_line_col: String = path_line_col;
-                let (path_line, column) = rsplit_at_char(path_line_col.as_str(), ':')?;
-                let (path, line) = rsplit_at_char(path_line, ':')?;
-                analysis_bench::Op::Complete {
-                    path: path.into(),
-                    line: line.parse()?,
-                    column: column.parse()?,
-                }
-            } else {
-                panic!("either --highlight or --complete must be set")
+            let highlight_path: Option<String> = matches.opt_value_from_str("--highlight")?;
+            let complete_path: Option<String> = matches.opt_value_from_str("--complete")?;
+            let goto_def_path: Option<String> = matches.opt_value_from_str("--goto-def")?;
+            let op = match (highlight_path, complete_path, goto_def_path) {
+                (Some(path), None, None) => analysis_bench::Op::Highlight { path: path.into() },
+                (None, Some(position), None) => analysis_bench::Op::Complete(position.parse()?),
+                (None, None, Some(position)) => analysis_bench::Op::GotoDef(position.parse()?),
+                _ => panic!(
+                    "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
+                ),
             };
             matches.finish().or_else(handle_extra_flags)?;
             analysis_bench::run(verbose, path.as_ref(), op)?;
@@ -171,8 +174,3 @@ fn read_stdin() -> Result<String> {
     std::io::stdin().read_to_string(&mut buff)?;
     Ok(buff)
 }
-
-fn rsplit_at_char(s: &str, c: char) -> Result<(&str, &str)> {
-    let idx = s.rfind(':').ok_or_else(|| format!("no `{}` in {}", c, s))?;
-    Ok((&s[..idx], &s[idx + 1..]))
-}
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index bb9a35c5d..94d5b4cfd 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -15,11 +15,9 @@ use hir_def::{
     },
     expr::{ExprId, PatId},
     resolver::{self, resolver_for_scope, Resolver, TypeNs, ValueNs},
-    DefWithBodyId, TraitId,
-};
-use hir_expand::{
-    hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
+    AsMacroCall, DefWithBodyId, TraitId,
 };
+use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile, MacroCallId};
 use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
 use ra_syntax::{
     ast::{self, AstNode},
@@ -363,12 +361,10 @@ impl SourceAnalyzer {
         db: &impl HirDatabase,
         macro_call: InFile<&ast::MacroCall>,
     ) -> Option<Expansion> {
-        let def = self.resolve_macro_call(db, macro_call)?.id;
-        let ast_id = AstId::new(
-            macro_call.file_id,
-            db.ast_id_map(macro_call.file_id).ast_id(macro_call.value),
-        );
-        Some(Expansion { macro_call_id: def.as_call_id(db, MacroCallKind::FnLike(ast_id)) })
+        let macro_call_id = macro_call.as_call_id(db, |path| {
+            self.resolver.resolve_path_as_macro(db, &path).map(|it| it.into())
+        })?;
+        Some(Expansion { macro_call_id })
     }
 }
 
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 142c52d35..010d35e55 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -7,9 +7,7 @@ use std::{mem, ops::Index, sync::Arc};
 
 use drop_bomb::DropBomb;
 use either::Either;
-use hir_expand::{
-    ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId,
-};
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroDefId};
 use ra_arena::{map::ArenaMap, Arena};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr};
@@ -23,7 +21,7 @@ use crate::{
     nameres::CrateDefMap,
     path::{ModPath, Path},
     src::HasSource,
-    DefWithBodyId, HasModule, Lookup, ModuleId,
+    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
 };
 
 pub(crate) struct Expander {
@@ -51,30 +49,26 @@ impl Expander {
         db: &DB,
         macro_call: ast::MacroCall,
     ) -> Option<(Mark, T)> {
-        let ast_id = AstId::new(
-            self.current_file_id,
-            db.ast_id_map(self.current_file_id).ast_id(&macro_call),
-        );
-
-        if let Some(path) = macro_call.path().and_then(|path| self.parse_mod_path(path)) {
-            if let Some(def) = self.resolve_path_as_macro(db, &path) {
-                let call_id = def.as_call_id(db, MacroCallKind::FnLike(ast_id));
-                let file_id = call_id.as_file();
-                if let Some(node) = db.parse_or_expand(file_id) {
-                    if let Some(expr) = T::cast(node) {
-                        log::debug!("macro expansion {:#?}", expr.syntax());
-
-                        let mark = Mark {
-                            file_id: self.current_file_id,
-                            ast_id_map: mem::take(&mut self.ast_id_map),
-                            bomb: DropBomb::new("expansion mark dropped"),
-                        };
-                        self.hygiene = Hygiene::new(db, file_id);
-                        self.current_file_id = file_id;
-                        self.ast_id_map = db.ast_id_map(file_id);
-
-                        return Some((mark, expr));
-                    }
+        let macro_call = InFile::new(self.current_file_id, &macro_call);
+
+        if let Some(call_id) =
+            macro_call.as_call_id(db, |path| self.resolve_path_as_macro(db, &path))
+        {
+            let file_id = call_id.as_file();
+            if let Some(node) = db.parse_or_expand(file_id) {
+                if let Some(expr) = T::cast(node) {
+                    log::debug!("macro expansion {:#?}", expr.syntax());
+
+                    let mark = Mark {
+                        file_id: self.current_file_id,
+                        ast_id_map: mem::take(&mut self.ast_id_map),
+                        bomb: DropBomb::new("expansion mark dropped"),
+                    };
+                    self.hygiene = Hygiene::new(db, file_id);
+                    self.current_file_id = file_id;
+                    self.ast_id_map = db.ast_id_map(file_id);
+
+                    return Some((mark, expr));
                 }
             }
         }
@@ -99,10 +93,6 @@ impl Expander {
         Path::from_src(path, &self.hygiene)
     }
 
-    fn parse_mod_path(&mut self, path: ast::Path) -> Option<ModPath> {
-        ModPath::from_src(path, &self.hygiene)
-    }
-
     fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &ModPath) -> Option<MacroDefId> {
         self.crate_def_map
             .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index feb3a300d..aa0b558b8 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -46,7 +46,10 @@ mod marks;
 
 use std::hash::Hash;
 
-use hir_expand::{ast_id_map::FileAstId, AstId, HirFileId, InFile, MacroDefId};
+use hir_expand::{
+    ast_id_map::FileAstId, db::AstDatabase, hygiene::Hygiene, AstId, HirFileId, InFile,
+    MacroCallId, MacroCallKind, MacroDefId,
+};
 use ra_arena::{impl_arena_id, RawId};
 use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_syntax::{ast, AstNode};
@@ -413,3 +416,61 @@ impl HasModule for StaticLoc {
         self.container.module(db)
     }
 }
+
+/// A helper trait for converting to MacroCallId
+pub trait AsMacroCall {
+    fn as_call_id(
+        &self,
+        db: &(impl db::DefDatabase + AstDatabase),
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId>;
+}
+
+impl AsMacroCall for InFile<&ast::MacroCall> {
+    fn as_call_id(
+        &self,
+        db: &(impl db::DefDatabase + AstDatabase),
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId> {
+        let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));
+        let h = Hygiene::new(db, self.file_id);
+        let path = path::ModPath::from_src(self.value.path()?, &h)?;
+
+        AstIdWithPath::new(ast_id.file_id, ast_id.value, path).as_call_id(db, resolver)
+    }
+}
+
+/// Helper wrapper for `AstId` with `ModPath`
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct AstIdWithPath<T: ast::AstNode> {
+    pub ast_id: AstId<T>,
+    pub path: path::ModPath,
+}
+
+impl<T: ast::AstNode> AstIdWithPath<T> {
+    pub fn new(file_id: HirFileId, ast_id: FileAstId<T>, path: path::ModPath) -> AstIdWithPath<T> {
+        AstIdWithPath { ast_id: AstId::new(file_id, ast_id), path }
+    }
+}
+
+impl AsMacroCall for AstIdWithPath<ast::MacroCall> {
+    fn as_call_id(
+        &self,
+        db: &impl AstDatabase,
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId> {
+        let def = resolver(self.path.clone())?;
+        Some(def.as_call_id(db, MacroCallKind::FnLike(self.ast_id.clone())))
+    }
+}
+
+impl AsMacroCall for AstIdWithPath<ast::ModuleItem> {
+    fn as_call_id(
+        &self,
+        db: &impl AstDatabase,
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId> {
+        let def = resolver(self.path.clone())?;
+        Some(def.as_call_id(db, MacroCallKind::Attr(self.ast_id.clone())))
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 6352c71ef..51c65a5d7 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -7,7 +7,7 @@ use hir_expand::{
     builtin_derive::find_builtin_derive,
     builtin_macro::find_builtin_macro,
     name::{name, AsName, Name},
-    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
 use ra_cfg::CfgOptions;
 use ra_db::{CrateId, FileId};
@@ -25,8 +25,9 @@ use crate::{
     path::{ImportAlias, ModPath, PathKind},
     per_ns::PerNs,
     visibility::Visibility,
-    AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
-    LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    AdtId, AsMacroCall, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId,
+    FunctionLoc, ImplLoc, Intern, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc,
+    TraitLoc, TypeAliasLoc, UnionLoc,
 };
 
 pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -99,11 +100,16 @@ struct ImportDirective {
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct MacroDirective {
     module_id: LocalModuleId,
-    ast_id: AstId<ast::MacroCall>,
-    path: ModPath,
+    ast_id: AstIdWithPath<ast::MacroCall>,
     legacy: Option<MacroCallId>,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct DeriveDirective {
+    module_id: LocalModuleId,
+    ast_id: AstIdWithPath<ast::ModuleItem>,
+}
+
 /// Walks the tree of module recursively
 struct DefCollector<'a, DB> {
     db: &'a DB,
@@ -112,7 +118,7 @@ struct DefCollector<'a, DB> {
     unresolved_imports: Vec<ImportDirective>,
     resolved_imports: Vec<ImportDirective>,
     unexpanded_macros: Vec<MacroDirective>,
-    unexpanded_attribute_macros: Vec<(LocalModuleId, AstId<ast::ModuleItem>, ModPath)>,
+    unexpanded_attribute_macros: Vec<DeriveDirective>,
     mod_dirs: FxHashMap<LocalModuleId, ModDir>,
     cfg_options: &'a CfgOptions,
 }
@@ -146,7 +152,7 @@ where
                 ReachedFixedPoint::Yes => break,
                 ReachedFixedPoint::No => i += 1,
             }
-            if i == 1000 {
+            if i == 10000 {
                 log::error!("name resolution is stuck");
                 break;
             }
@@ -515,16 +521,16 @@ where
                 return false;
             }
 
-            let resolved_res = self.def_map.resolve_path_fp_with_macro(
-                self.db,
-                ResolveMode::Other,
-                directive.module_id,
-                &directive.path,
-                BuiltinShadowMode::Module,
-            );
-
-            if let Some(def) = resolved_res.resolved_def.take_macros() {
-                let call_id = def.as_call_id(self.db, MacroCallKind::FnLike(directive.ast_id));
+            if let Some(call_id) = directive.ast_id.as_call_id(self.db, |path| {
+                let resolved_res = self.def_map.resolve_path_fp_with_macro(
+                    self.db,
+                    ResolveMode::Other,
+                    directive.module_id,
+                    &path,
+                    BuiltinShadowMode::Module,
+                );
+                resolved_res.resolved_def.take_macros()
+            }) {
                 resolved.push((directive.module_id, call_id));
                 res = ReachedFixedPoint::No;
                 return false;
@@ -532,12 +538,11 @@ where
 
             true
         });
-        attribute_macros.retain(|(module_id, ast_id, path)| {
-            let resolved_res = self.resolve_attribute_macro(path);
-
-            if let Some(def) = resolved_res {
-                let call_id = def.as_call_id(self.db, MacroCallKind::Attr(*ast_id));
-                resolved.push((*module_id, call_id));
+        attribute_macros.retain(|directive| {
+            if let Some(call_id) =
+                directive.ast_id.as_call_id(self.db, |path| self.resolve_attribute_macro(&path))
+            {
+                resolved.push((directive.module_id, call_id));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -833,20 +838,22 @@ where
                 };
                 let path = ModPath::from_tt_ident(ident);
 
-                let ast_id = AstId::new(self.file_id, def.kind.ast_id());
-                self.def_collector.unexpanded_attribute_macros.push((self.module_id, ast_id, path));
+                let ast_id = AstIdWithPath::new(self.file_id, def.kind.ast_id(), path);
+                self.def_collector
+                    .unexpanded_attribute_macros
+                    .push(DeriveDirective { module_id: self.module_id, ast_id });
             }
         }
     }
 
     fn collect_macro(&mut self, mac: &raw::MacroData) {
-        let ast_id = AstId::new(self.file_id, mac.ast_id);
+        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
 
         // Case 0: builtin macros
         if mac.builtin {
             if let Some(name) = &mac.name {
                 let krate = self.def_collector.def_map.krate;
-                if let Some(macro_id) = find_builtin_macro(name, krate, ast_id) {
+                if let Some(macro_id) = find_builtin_macro(name, krate, ast_id.ast_id) {
                     self.def_collector.define_macro(
                         self.module_id,
                         name.clone(),
@@ -862,7 +869,7 @@ where
         if is_macro_rules(&mac.path) {
             if let Some(name) = &mac.name {
                 let macro_id = MacroDefId {
-                    ast_id: Some(ast_id),
+                    ast_id: Some(ast_id.ast_id),
                     krate: Some(self.def_collector.def_map.krate),
                     kind: MacroDefKind::Declarative,
                 };
@@ -872,15 +879,13 @@ where
         }
 
         // Case 2: try to resolve in legacy scope and expand macro_rules
-        if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
-            self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
+        if let Some(macro_call_id) = ast_id.as_call_id(self.def_collector.db, |path| {
+            path.as_ident().and_then(|name| {
+                self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
+            })
         }) {
-            let macro_call_id =
-                macro_def.as_call_id(self.def_collector.db, MacroCallKind::FnLike(ast_id));
-
             self.def_collector.unexpanded_macros.push(MacroDirective {
                 module_id: self.module_id,
-                path: mac.path.clone(),
                 ast_id,
                 legacy: Some(macro_call_id),
             });
@@ -890,14 +895,12 @@ where
 
         // Case 3: resolve in module scope, expand during name resolution.
         // We rewrite simple path `macro_name` to `self::macro_name` to force resolve in module scope only.
-        let mut path = mac.path.clone();
-        if path.is_ident() {
-            path.kind = PathKind::Super(0);
+        if ast_id.path.is_ident() {
+            ast_id.path.kind = PathKind::Super(0);
         }
 
         self.def_collector.unexpanded_macros.push(MacroDirective {
             module_id: self.module_id,
-            path,
             ast_id,
             legacy: None,
         });
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index fe05642ae..1dc842f40 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -249,6 +249,8 @@ impl InferenceTable {
         match (ty1, ty2) {
             (Ty::Unknown, _) | (_, Ty::Unknown) => true,
 
+            (Ty::Placeholder(p1), Ty::Placeholder(p2)) if *p1 == *p2 => true,
+
             (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2)))
             | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2)))
             | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2)))
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index fc5ef36a5..42330b269 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -526,3 +526,25 @@ fn test() {
     "###
     );
 }
+
+#[test]
+fn coerce_placeholder_ref() {
+    // placeholders should unify, even behind references
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+struct S<T> { t: T }
+impl<TT> S<TT> {
+    fn get(&self) -> &TT {
+        &self.t
+    }
+}
+"#, true),
+        @r###"
+    [51; 55) 'self': &S<TT>
+    [64; 87) '{     ...     }': &TT
+    [74; 81) '&self.t': &TT
+    [75; 79) 'self': &S<TT>
+    [75; 81) 'self.t': TT
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 88af61e87..ff8e75b48 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -60,6 +60,9 @@ impl TraitSolver {
                     context.0.db.check_canceled();
                     let remaining = fuel.get();
                     fuel.set(remaining - 1);
+                    if remaining == 0 {
+                        log::debug!("fuel exhausted");
+                    }
                     remaining > 0
                 })
             }
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index fedc02e14..4bdc6ba23 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -15,6 +15,7 @@ mod complete_path;
 mod complete_scope;
 mod complete_postfix;
 mod complete_macro_in_item_position;
+mod complete_trait_impl;
 
 use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
@@ -74,5 +75,7 @@ pub(crate) fn completions(db: &RootDatabase, position: FilePosition) -> Option<C
     complete_pattern::complete_pattern(&mut acc, &ctx);
     complete_postfix::complete_postfix(&mut acc, &ctx);
     complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
+    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
+
     Some(acc)
 }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
new file mode 100644
index 000000000..6ff10c017
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -0,0 +1,436 @@
+//! Completion for associated items in a trait implementation.
+//!
+//! This module adds the completion items related to implementing associated
+//! items within a `impl Trait for Struct` block. The current context node
+//! must be within either a `FN_DEF`, `TYPE_ALIAS_DEF`, or `CONST_DEF` node
+//! and an direct child of an `IMPL_BLOCK`.
+//!
+//! # Examples
+//!
+//! Considering the following trait `impl`:
+//!
+//! ```ignore
+//! trait SomeTrait {
+//!     fn foo();
+//! }
+//!
+//! impl SomeTrait for () {
+//!     fn f<|>
+//! }
+//! ```
+//!
+//! may result in the completion of the following method:
+//!
+//! ```ignore
+//! # trait SomeTrait {
+//! #    fn foo();
+//! # }
+//!
+//! impl SomeTrait for () {
+//!     fn foo() {}<|>
+//! }
+//! ```
+
+use hir::{self, Docs, HasSource};
+use ra_assists::utils::get_missing_impl_items;
+use ra_syntax::{
+    ast::{self, edit},
+    AstNode, SyntaxKind, SyntaxNode, TextRange,
+};
+use ra_text_edit::TextEdit;
+
+use crate::{
+    completion::{
+        CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
+    },
+    display::FunctionSignature,
+};
+
+pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
+    let trigger = ctx.token.ancestors().find(|p| match p.kind() {
+        SyntaxKind::FN_DEF
+        | SyntaxKind::TYPE_ALIAS_DEF
+        | SyntaxKind::CONST_DEF
+        | SyntaxKind::BLOCK_EXPR => true,
+        _ => false,
+    });
+
+    let impl_block = trigger
+        .as_ref()
+        .and_then(|node| node.parent())
+        .and_then(|node| node.parent())
+        .and_then(|node| ast::ImplBlock::cast(node));
+
+    if let (Some(trigger), Some(impl_block)) = (trigger, impl_block) {
+        match trigger.kind() {
+            SyntaxKind::FN_DEF => {
+                for missing_fn in get_missing_impl_items(ctx.db, &ctx.analyzer, &impl_block)
+                    .iter()
+                    .filter_map(|item| match item {
+                        hir::AssocItem::Function(fn_item) => Some(fn_item),
+                        _ => None,
+                    })
+                {
+                    add_function_impl(&trigger, acc, ctx, &missing_fn);
+                }
+            }
+
+            SyntaxKind::TYPE_ALIAS_DEF => {
+                for missing_fn in get_missing_impl_items(ctx.db, &ctx.analyzer, &impl_block)
+                    .iter()
+                    .filter_map(|item| match item {
+                        hir::AssocItem::TypeAlias(type_item) => Some(type_item),
+                        _ => None,
+                    })
+                {
+                    add_type_alias_impl(&trigger, acc, ctx, &missing_fn);
+                }
+            }
+
+            SyntaxKind::CONST_DEF => {
+                for missing_fn in get_missing_impl_items(ctx.db, &ctx.analyzer, &impl_block)
+                    .iter()
+                    .filter_map(|item| match item {
+                        hir::AssocItem::Const(const_item) => Some(const_item),
+                        _ => None,
+                    })
+                {
+                    add_const_impl(&trigger, acc, ctx, &missing_fn);
+                }
+            }
+
+            _ => {}
+        }
+    }
+}
+
+fn add_function_impl(
+    fn_def_node: &SyntaxNode,
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    func: &hir::Function,
+) {
+    let display = FunctionSignature::from_hir(ctx.db, func.clone());
+
+    let fn_name = func.name(ctx.db).to_string();
+
+    let label = if func.params(ctx.db).len() > 0 {
+        format!("fn {}(..)", fn_name)
+    } else {
+        format!("fn {}()", fn_name)
+    };
+
+    let builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label.clone())
+        .lookup_by(fn_name)
+        .set_documentation(func.docs(ctx.db));
+
+    let completion_kind = if func.has_self_param(ctx.db) {
+        CompletionItemKind::Method
+    } else {
+        CompletionItemKind::Function
+    };
+
+    let snippet = format!("{} {{}}", display);
+
+    let range = TextRange::from_to(fn_def_node.text_range().start(), ctx.source_range().end());
+
+    builder.text_edit(TextEdit::replace(range, snippet)).kind(completion_kind).add_to(acc);
+}
+
+fn add_type_alias_impl(
+    type_def_node: &SyntaxNode,
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    type_alias: &hir::TypeAlias,
+) {
+    let alias_name = type_alias.name(ctx.db).to_string();
+
+    let snippet = format!("type {} = ", alias_name);
+
+    let range = TextRange::from_to(type_def_node.text_range().start(), ctx.source_range().end());
+
+    CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+        .text_edit(TextEdit::replace(range, snippet))
+        .lookup_by(alias_name)
+        .kind(CompletionItemKind::TypeAlias)
+        .set_documentation(type_alias.docs(ctx.db))
+        .add_to(acc);
+}
+
+fn add_const_impl(
+    const_def_node: &SyntaxNode,
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    const_: &hir::Const,
+) {
+    let const_name = const_.name(ctx.db).map(|n| n.to_string());
+
+    if let Some(const_name) = const_name {
+        let snippet = make_const_compl_syntax(&const_.source(ctx.db).value);
+
+        let range =
+            TextRange::from_to(const_def_node.text_range().start(), ctx.source_range().end());
+
+        CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+            .text_edit(TextEdit::replace(range, snippet))
+            .lookup_by(const_name)
+            .kind(CompletionItemKind::Const)
+            .set_documentation(const_.docs(ctx.db))
+            .add_to(acc);
+    }
+}
+
+fn make_const_compl_syntax(const_: &ast::ConstDef) -> String {
+    let const_ = edit::strip_attrs_and_docs(const_);
+
+    let const_start = const_.syntax().text_range().start();
+    let const_end = const_.syntax().text_range().end();
+
+    let start =
+        const_.syntax().first_child_or_token().map_or(const_start, |f| f.text_range().start());
+
+    let end = const_
+        .syntax()
+        .children_with_tokens()
+        .find(|s| s.kind() == SyntaxKind::SEMI || s.kind() == SyntaxKind::EQ)
+        .map_or(const_end, |f| f.text_range().start());
+
+    let len = end - start;
+    let range = TextRange::from_to(0.into(), len);
+
+    let syntax = const_.syntax().text().slice(range).to_string();
+
+    format!("{} = ", syntax.trim_end())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn complete(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Magic)
+    }
+
+    #[test]
+    fn single_function() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn f<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo()",
+                source_range: [141; 142),
+                delete: [138; 142),
+                insert: "fn foo() {}",
+                kind: Function,
+                lookup: "foo",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn hide_implemented_fn() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo();
+                fn foo_bar();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn foo() {}
+
+                fn f<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo_bar()",
+                source_range: [200; 201),
+                delete: [197; 201),
+                insert: "fn foo_bar() {}",
+                kind: Function,
+                lookup: "foo_bar",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn completes_only_on_top_level() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo();
+
+                fn foo_bar();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn foo() {
+                    <|>
+                }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"[]"###);
+    }
+
+    #[test]
+    fn generic_fn() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo<T>();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn f<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo()",
+                source_range: [144; 145),
+                delete: [141; 145),
+                insert: "fn foo<T>() {}",
+                kind: Function,
+                lookup: "foo",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn generic_constrait_fn() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo<T>() where T: Into<String>;
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn f<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo()",
+                source_range: [166; 167),
+                delete: [163; 167),
+                insert: "fn foo<T>()\nwhere T: Into<String> {}",
+                kind: Function,
+                lookup: "foo",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn associated_type() {
+        let completions = complete(
+            r"
+            trait Test {
+                type SomeType;
+            }
+
+            impl Test for () {
+                type S<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "type SomeType = ",
+                source_range: [124; 125),
+                delete: [119; 125),
+                insert: "type SomeType = ",
+                kind: TypeAlias,
+                lookup: "SomeType",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn associated_const() {
+        let completions = complete(
+            r"
+            trait Test {
+                const SOME_CONST: u16;
+            }
+
+            impl Test for () {
+                const S<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "const SOME_CONST: u16 = ",
+                source_range: [133; 134),
+                delete: [127; 134),
+                insert: "const SOME_CONST: u16 = ",
+                kind: Const,
+                lookup: "SOME_CONST",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn associated_const_with_default() {
+        let completions = complete(
+            r"
+            trait Test {
+                const SOME_CONST: u16 = 42;
+            }
+
+            impl Test for () {
+                const S<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "const SOME_CONST: u16 = ",
+                source_range: [138; 139),
+                delete: [132; 139),
+                insert: "const SOME_CONST: u16 = ",
+                kind: Const,
+                lookup: "SOME_CONST",
+            },
+        ]
+        "###);
+    }
+}
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 5a0407fd7..8678a3234 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -25,6 +25,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) use_item_syntax: Option<ast::UseItem>,
     pub(super) record_lit_syntax: Option<ast::RecordLit>,
     pub(super) record_lit_pat: Option<ast::RecordPat>,
+    pub(super) impl_block: Option<ast::ImplBlock>,
     pub(super) is_param: bool,
     /// If a name-binding or reference to a const in a pattern.
     /// Irrefutable patterns (like let) are excluded.
@@ -72,6 +73,7 @@ impl<'a> CompletionContext<'a> {
             use_item_syntax: None,
             record_lit_syntax: None,
             record_lit_pat: None,
+            impl_block: None,
             is_param: false,
             is_pat_binding: false,
             is_trivial_path: false,
@@ -148,6 +150,13 @@ impl<'a> CompletionContext<'a> {
             self.record_lit_syntax = find_node_at_offset(original_file.syntax(), self.offset);
         }
 
+        self.impl_block = self
+            .token
+            .parent()
+            .ancestors()
+            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
+            .find_map(ast::ImplBlock::cast);
+
         let top_node = name_ref
             .syntax()
             .ancestors()
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 689921f3f..f86f98be7 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -37,6 +37,7 @@ mod display;
 mod inlay_hints;
 mod expand;
 mod expand_macro;
+mod ssr;
 
 #[cfg(test)]
 mod marks;
@@ -71,8 +72,9 @@ pub use crate::{
     references::{
         Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult, SearchScope,
     },
-    runnables::{Runnable, RunnableKind},
+    runnables::{Runnable, RunnableKind, TestId},
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
+    ssr::SsrError,
     syntax_highlighting::HighlightedRange,
 };
 
@@ -464,6 +466,16 @@ impl Analysis {
         self.with_db(|db| references::rename(db, position, new_name))
     }
 
+    pub fn structural_search_replace(
+        &self,
+        query: &str,
+    ) -> Cancelable<Result<SourceChange, SsrError>> {
+        self.with_db(|db| {
+            let edits = ssr::parse_search_replace(query, db)?;
+            Ok(SourceChange::source_file_edits("ssr", edits))
+        })
+    }
+
     /// Performs an operation on that may be Canceled.
     fn with_db<F: FnOnce(&RootDatabase) -> T + std::panic::UnwindSafe, T>(
         &self,
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index b6b0c70f9..be2a67d0a 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir::InFile;
+use hir::{InFile, SourceBinder};
 use itertools::Itertools;
 use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
@@ -10,6 +10,7 @@ use ra_syntax::{
 };
 
 use crate::FileId;
+use std::fmt::Display;
 
 #[derive(Debug)]
 pub struct Runnable {
@@ -18,38 +19,84 @@ pub struct Runnable {
 }
 
 #[derive(Debug)]
+pub enum TestId {
+    Name(String),
+    Path(String),
+}
+
+impl Display for TestId {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            TestId::Name(name) => write!(f, "{}", name),
+            TestId::Path(path) => write!(f, "{}", path),
+        }
+    }
+}
+
+#[derive(Debug)]
 pub enum RunnableKind {
-    Test { name: String },
+    Test { test_id: TestId },
     TestMod { path: String },
-    Bench { name: String },
+    Bench { test_id: TestId },
     Bin,
 }
 
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     let parse = db.parse(file_id);
-    parse.tree().syntax().descendants().filter_map(|i| runnable(db, file_id, i)).collect()
+    let mut sb = SourceBinder::new(db);
+    parse.tree().syntax().descendants().filter_map(|i| runnable(db, &mut sb, file_id, i)).collect()
 }
 
-fn runnable(db: &RootDatabase, file_id: FileId, item: SyntaxNode) -> Option<Runnable> {
+fn runnable(
+    db: &RootDatabase,
+    source_binder: &mut SourceBinder<RootDatabase>,
+    file_id: FileId,
+    item: SyntaxNode,
+) -> Option<Runnable> {
     match_ast! {
         match item {
-            ast::FnDef(it) => { runnable_fn(it) },
-            ast::Module(it) => { runnable_mod(db, file_id, it) },
+            ast::FnDef(it) => { runnable_fn(db, source_binder, file_id, it) },
+            ast::Module(it) => { runnable_mod(db, source_binder, file_id, it) },
             _ => { None },
         }
     }
 }
 
-fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
-    let name = fn_def.name()?.text().clone();
-    let kind = if name == "main" {
+fn runnable_fn(
+    db: &RootDatabase,
+    source_binder: &mut SourceBinder<RootDatabase>,
+    file_id: FileId,
+    fn_def: ast::FnDef,
+) -> Option<Runnable> {
+    let name_string = fn_def.name()?.text().to_string();
+
+    let kind = if name_string == "main" {
         RunnableKind::Bin
-    } else if has_test_related_attribute(&fn_def) {
-        RunnableKind::Test { name: name.to_string() }
-    } else if fn_def.has_atom_attr("bench") {
-        RunnableKind::Bench { name: name.to_string() }
     } else {
-        return None;
+        let test_id = if let Some(module) = source_binder
+            .to_def(InFile::new(file_id.into(), fn_def.clone()))
+            .map(|def| def.module(db))
+        {
+            let path = module
+                .path_to_root(db)
+                .into_iter()
+                .rev()
+                .filter_map(|it| it.name(db))
+                .map(|name| name.to_string())
+                .chain(std::iter::once(name_string))
+                .join("::");
+            TestId::Path(path)
+        } else {
+            TestId::Name(name_string)
+        };
+
+        if has_test_related_attribute(&fn_def) {
+            RunnableKind::Test { test_id }
+        } else if fn_def.has_atom_attr("bench") {
+            RunnableKind::Bench { test_id }
+        } else {
+            return None;
+        }
     };
     Some(Runnable { range: fn_def.syntax().text_range(), kind })
 }
@@ -68,7 +115,12 @@ fn has_test_related_attribute(fn_def: &ast::FnDef) -> bool {
         .any(|attribute_text| attribute_text.contains("test"))
 }
 
-fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Option<Runnable> {
+fn runnable_mod(
+    db: &RootDatabase,
+    source_binder: &mut SourceBinder<RootDatabase>,
+    file_id: FileId,
+    module: ast::Module,
+) -> Option<Runnable> {
     let has_test_function = module
         .item_list()?
         .items()
@@ -76,13 +128,12 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
             ast::ModuleItem::FnDef(it) => Some(it),
             _ => None,
         })
-        .any(|f| f.has_atom_attr("test"));
+        .any(|f| has_test_related_attribute(&f));
     if !has_test_function {
         return None;
     }
     let range = module.syntax().text_range();
-    let mut sb = hir::SourceBinder::new(db);
-    let module = sb.to_def(InFile::new(file_id.into(), module))?;
+    let module = source_binder.to_def(InFile::new(file_id.into(), module))?;
 
     let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
     Some(Runnable { range, kind: RunnableKind::TestMod { path } })
@@ -121,13 +172,17 @@ mod tests {
             Runnable {
                 range: [22; 46),
                 kind: Test {
-                    name: "test_foo",
+                    test_id: Path(
+                        "test_foo",
+                    ),
                 },
             },
             Runnable {
                 range: [47; 81),
                 kind: Test {
-                    name: "test_foo",
+                    test_id: Path(
+                        "test_foo",
+                    ),
                 },
             },
         ]
@@ -160,7 +215,9 @@ mod tests {
             Runnable {
                 range: [28; 57),
                 kind: Test {
-                    name: "test_foo1",
+                    test_id: Path(
+                        "test_mod::test_foo1",
+                    ),
                 },
             },
         ]
@@ -195,7 +252,9 @@ mod tests {
             Runnable {
                 range: [46; 79),
                 kind: Test {
-                    name: "test_foo1",
+                    test_id: Path(
+                        "foo::test_mod::test_foo1",
+                    ),
                 },
             },
         ]
@@ -232,7 +291,9 @@ mod tests {
             Runnable {
                 range: [68; 105),
                 kind: Test {
-                    name: "test_foo1",
+                    test_id: Path(
+                        "foo::bar::test_mod::test_foo1",
+                    ),
                 },
             },
         ]
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 1cc55e78b..a02dbaf2f 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -16,6 +16,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .literal            { color: #BFEBBF; }
 .literal\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
 .variable\.mut     { color: #DCDCCC; text-decoration: underline; }
 
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 918fd4b97..95f038f00 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -16,6 +16,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .literal            { color: #BFEBBF; }
 .literal\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
 .variable\.mut     { color: #DCDCCC; text-decoration: underline; }
 
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
new file mode 100644
index 000000000..14eb0b8b2
--- /dev/null
+++ b/crates/ra_ide/src/ssr.rs
@@ -0,0 +1,324 @@
+//!  structural search replace
+
+use crate::source_change::SourceFileEdit;
+use ra_ide_db::RootDatabase;
+use ra_syntax::ast::make::expr_from_text;
+use ra_syntax::AstNode;
+use ra_syntax::SyntaxElement;
+use ra_syntax::SyntaxNode;
+use ra_text_edit::{TextEdit, TextEditBuilder};
+use rustc_hash::FxHashMap;
+use std::collections::HashMap;
+use std::str::FromStr;
+
+pub use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_ide_db::symbol_index::SymbolsDatabase;
+
+#[derive(Debug, PartialEq)]
+pub struct SsrError(String);
+
+impl std::fmt::Display for SsrError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "Parse error: {}", self.0)
+    }
+}
+
+impl std::error::Error for SsrError {}
+
+pub fn parse_search_replace(
+    query: &str,
+    db: &RootDatabase,
+) -> Result<Vec<SourceFileEdit>, SsrError> {
+    let mut edits = vec![];
+    let query: SsrQuery = query.parse()?;
+    for &root in db.local_roots().iter() {
+        let sr = db.source_root(root);
+        for file_id in sr.walk() {
+            dbg!(db.file_relative_path(file_id));
+            let matches = find(&query.pattern, db.parse(file_id).tree().syntax());
+            if !matches.matches.is_empty() {
+                edits.push(SourceFileEdit { file_id, edit: replace(&matches, &query.template) });
+            }
+        }
+    }
+    Ok(edits)
+}
+
+#[derive(Debug)]
+struct SsrQuery {
+    pattern: SsrPattern,
+    template: SsrTemplate,
+}
+
+#[derive(Debug)]
+struct SsrPattern {
+    pattern: SyntaxNode,
+    vars: Vec<Var>,
+}
+
+/// represents an `$var` in an SSR query
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct Var(String);
+
+#[derive(Debug)]
+struct SsrTemplate {
+    template: SyntaxNode,
+    placeholders: FxHashMap<SyntaxNode, Var>,
+}
+
+type Binding = HashMap<Var, SyntaxNode>;
+
+#[derive(Debug)]
+struct Match {
+    place: SyntaxNode,
+    binding: Binding,
+}
+
+#[derive(Debug)]
+struct SsrMatches {
+    matches: Vec<Match>,
+}
+
+impl FromStr for SsrQuery {
+    type Err = SsrError;
+
+    fn from_str(query: &str) -> Result<SsrQuery, SsrError> {
+        let mut it = query.split("==>>");
+        let pattern = it.next().expect("at least empty string").trim();
+        let mut template =
+            it.next().ok_or(SsrError("Cannot find delemiter `==>>`".into()))?.trim().to_string();
+        if it.next().is_some() {
+            return Err(SsrError("More than one delimiter found".into()));
+        }
+        let mut vars = vec![];
+        let mut it = pattern.split('$');
+        let mut pattern = it.next().expect("something").to_string();
+
+        for part in it.map(split_by_var) {
+            let (var, var_type, remainder) = part?;
+            is_expr(var_type)?;
+            let new_var = create_name(var, &mut vars)?;
+            pattern.push_str(new_var);
+            pattern.push_str(remainder);
+            template = replace_in_template(template, var, new_var);
+        }
+
+        let template = expr_from_text(&template).syntax().clone();
+        let mut placeholders = FxHashMap::default();
+
+        traverse(&template, &mut |n| {
+            if let Some(v) = vars.iter().find(|v| v.0.as_str() == n.text()) {
+                placeholders.insert(n.clone(), v.clone());
+                false
+            } else {
+                true
+            }
+        });
+
+        let pattern = SsrPattern { pattern: expr_from_text(&pattern).syntax().clone(), vars };
+        let template = SsrTemplate { template, placeholders };
+        Ok(SsrQuery { pattern, template })
+    }
+}
+
+fn traverse(node: &SyntaxNode, go: &mut impl FnMut(&SyntaxNode) -> bool) {
+    if !go(node) {
+        return;
+    }
+    for ref child in node.children() {
+        traverse(child, go);
+    }
+}
+
+fn split_by_var(s: &str) -> Result<(&str, &str, &str), SsrError> {
+    let end_of_name = s.find(":").ok_or(SsrError("Use $<name>:expr".into()))?;
+    let name = &s[0..end_of_name];
+    is_name(name)?;
+    let type_begin = end_of_name + 1;
+    let type_length = s[type_begin..].find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or(s.len());
+    let type_name = &s[type_begin..type_begin + type_length];
+    Ok((name, type_name, &s[type_begin + type_length..]))
+}
+
+fn is_name(s: &str) -> Result<(), SsrError> {
+    if s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
+        Ok(())
+    } else {
+        Err(SsrError("Name can contain only alphanumerics and _".into()))
+    }
+}
+
+fn is_expr(s: &str) -> Result<(), SsrError> {
+    if s == "expr" {
+        Ok(())
+    } else {
+        Err(SsrError("Only $<name>:expr is supported".into()))
+    }
+}
+
+fn replace_in_template(template: String, var: &str, new_var: &str) -> String {
+    let name = format!("${}", var);
+    template.replace(&name, new_var)
+}
+
+fn create_name<'a>(name: &str, vars: &'a mut Vec<Var>) -> Result<&'a str, SsrError> {
+    let sanitized_name = format!("__search_pattern_{}", name);
+    if vars.iter().any(|a| a.0 == sanitized_name) {
+        return Err(SsrError(format!("Name `{}` repeats more than once", name)));
+    }
+    vars.push(Var(sanitized_name));
+    Ok(&vars.last().unwrap().0)
+}
+
+fn find(pattern: &SsrPattern, code: &SyntaxNode) -> SsrMatches {
+    fn check(
+        pattern: &SyntaxElement,
+        code: &SyntaxElement,
+        placeholders: &[Var],
+        match_: &mut Match,
+    ) -> bool {
+        match (pattern, code) {
+            (SyntaxElement::Token(ref pattern), SyntaxElement::Token(ref code)) => {
+                pattern.text() == code.text()
+            }
+            (SyntaxElement::Node(ref pattern), SyntaxElement::Node(ref code)) => {
+                if placeholders.iter().find(|&n| n.0.as_str() == pattern.text()).is_some() {
+                    match_.binding.insert(Var(pattern.text().to_string()), code.clone());
+                    true
+                } else {
+                    pattern.green().children().count() == code.green().children().count()
+                        && pattern
+                            .children_with_tokens()
+                            .zip(code.children_with_tokens())
+                            .all(|(a, b)| check(&a, &b, placeholders, match_))
+                }
+            }
+            _ => false,
+        }
+    }
+    let kind = pattern.pattern.kind();
+    let matches = code
+        .descendants_with_tokens()
+        .filter(|n| n.kind() == kind)
+        .filter_map(|code| {
+            let mut match_ =
+                Match { place: code.as_node().unwrap().clone(), binding: HashMap::new() };
+            if check(
+                &SyntaxElement::from(pattern.pattern.clone()),
+                &code,
+                &pattern.vars,
+                &mut match_,
+            ) {
+                Some(match_)
+            } else {
+                None
+            }
+        })
+        .collect();
+    SsrMatches { matches }
+}
+
+fn replace(matches: &SsrMatches, template: &SsrTemplate) -> TextEdit {
+    let mut builder = TextEditBuilder::default();
+    for match_ in &matches.matches {
+        builder.replace(match_.place.text_range(), render_replace(&match_.binding, template));
+    }
+    builder.finish()
+}
+
+fn render_replace(binding: &Binding, template: &SsrTemplate) -> String {
+    let mut builder = TextEditBuilder::default();
+    for element in template.template.descendants() {
+        if let Some(var) = template.placeholders.get(&element) {
+            builder.replace(element.text_range(), binding[var].to_string())
+        }
+    }
+    builder.finish().apply(&template.template.text().to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ra_syntax::SourceFile;
+
+    fn parse_error_text(query: &str) -> String {
+        format!("{}", query.parse::<SsrQuery>().unwrap_err())
+    }
+
+    #[test]
+    fn parser_happy_case() {
+        let result: SsrQuery = "foo($a:expr, $b:expr) ==>> bar($b, $a)".parse().unwrap();
+        assert_eq!(&result.pattern.pattern.text(), "foo(__search_pattern_a, __search_pattern_b)");
+        assert_eq!(result.pattern.vars.len(), 2);
+        assert_eq!(result.pattern.vars[0].0, "__search_pattern_a");
+        assert_eq!(result.pattern.vars[1].0, "__search_pattern_b");
+        assert_eq!(&result.template.template.text(), "bar(__search_pattern_b, __search_pattern_a)");
+        dbg!(result.template.placeholders);
+    }
+
+    #[test]
+    fn parser_empty_query() {
+        assert_eq!(parse_error_text(""), "Parse error: Cannot find delemiter `==>>`");
+    }
+
+    #[test]
+    fn parser_no_delimiter() {
+        assert_eq!(parse_error_text("foo()"), "Parse error: Cannot find delemiter `==>>`");
+    }
+
+    #[test]
+    fn parser_two_delimiters() {
+        assert_eq!(
+            parse_error_text("foo() ==>> a ==>> b "),
+            "Parse error: More than one delimiter found"
+        );
+    }
+
+    #[test]
+    fn parser_no_pattern_type() {
+        assert_eq!(parse_error_text("foo($a) ==>>"), "Parse error: Use $<name>:expr");
+    }
+
+    #[test]
+    fn parser_invalid_name() {
+        assert_eq!(
+            parse_error_text("foo($a+:expr) ==>>"),
+            "Parse error: Name can contain only alphanumerics and _"
+        );
+    }
+
+    #[test]
+    fn parser_invalid_type() {
+        assert_eq!(
+            parse_error_text("foo($a:ident) ==>>"),
+            "Parse error: Only $<name>:expr is supported"
+        );
+    }
+
+    #[test]
+    fn parser_repeated_name() {
+        assert_eq!(
+            parse_error_text("foo($a:expr, $a:expr) ==>>"),
+            "Parse error: Name `a` repeats more than once"
+        );
+    }
+
+    #[test]
+    fn parse_match_replace() {
+        let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
+        let input = "fn main() { foo(1+2); }";
+
+        let code = SourceFile::parse(input).tree();
+        let matches = find(&query.pattern, code.syntax());
+        assert_eq!(matches.matches.len(), 1);
+        assert_eq!(matches.matches[0].place.text(), "foo(1+2)");
+        assert_eq!(matches.matches[0].binding.len(), 1);
+        assert_eq!(
+            matches.matches[0].binding[&Var("__search_pattern_x".to_string())].text(),
+            "1+2"
+        );
+
+        let edit = replace(&matches, &query.template);
+        assert_eq!(edit.apply(input), "fn main() { bar(1+2); }");
+    }
+}
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 174e13595..20c414ca1 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -365,6 +365,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .literal            { color: #BFEBBF; }
 .literal\\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
 .variable\\.mut     { color: #DCDCCC; text-decoration: underline; }
 
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index 716e88bc1..495fffb5a 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -22,7 +22,6 @@ fst = { version = "0.3.1", default-features = false }
 rustc-hash = "1.0"
 unicase = "2.2.0"
 superslice = "1.0.0"
-rand = { version = "0.7.0", features = ["small_rng"] }
 once_cell = "1.2.0"
 
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_lsp_server/src/cargo_target_spec.rs b/crates/ra_lsp_server/src/cargo_target_spec.rs
index 594caffe2..5fd1e7b6b 100644
--- a/crates/ra_lsp_server/src/cargo_target_spec.rs
+++ b/crates/ra_lsp_server/src/cargo_target_spec.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use ra_ide::{FileId, RunnableKind};
+use ra_ide::{FileId, RunnableKind, TestId};
 use ra_project_model::{self, ProjectWorkspace, TargetKind};
 
 use crate::{world::WorldSnapshot, Result};
@@ -13,13 +13,16 @@ pub(crate) fn runnable_args(
     let spec = CargoTargetSpec::for_file(world, file_id)?;
     let mut res = Vec::new();
     match kind {
-        RunnableKind::Test { name } => {
+        RunnableKind::Test { test_id } => {
             res.push("test".to_string());
             if let Some(spec) = spec {
                 spec.push_to(&mut res);
             }
             res.push("--".to_string());
-            res.push(name.to_string());
+            res.push(test_id.to_string());
+            if let TestId::Path(_) = test_id {
+                res.push("--exact".to_string());
+            }
             res.push("--nocapture".to_string());
         }
         RunnableKind::TestMod { path } => {
@@ -31,13 +34,16 @@ pub(crate) fn runnable_args(
             res.push(path.to_string());
             res.push("--nocapture".to_string());
         }
-        RunnableKind::Bench { name } => {
+        RunnableKind::Bench { test_id } => {
             res.push("bench".to_string());
             if let Some(spec) = spec {
                 spec.push_to(&mut res);
             }
             res.push("--".to_string());
-            res.push(name.to_string());
+            res.push(test_id.to_string());
+            if let TestId::Path(_) = test_id {
+                res.push("--exact".to_string());
+            }
             res.push("--nocapture".to_string());
         }
         RunnableKind::Bin => {
diff --git a/crates/ra_lsp_server/src/config.rs b/crates/ra_lsp_server/src/config.rs
index 2d7948d74..3314269ec 100644
--- a/crates/ra_lsp_server/src/config.rs
+++ b/crates/ra_lsp_server/src/config.rs
@@ -44,6 +44,8 @@ pub struct ServerConfig {
     /// Fine grained feature flags to disable specific features.
     pub feature_flags: FxHashMap<String, bool>,
 
+    pub rustfmt_args: Vec<String>,
+
     /// Cargo feature configurations.
     pub cargo_features: CargoFeatures,
 }
@@ -63,6 +65,7 @@ impl Default for ServerConfig {
             with_sysroot: true,
             feature_flags: FxHashMap::default(),
             cargo_features: Default::default(),
+            rustfmt_args: Vec::new(),
         }
     }
 }
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index c8a017c5c..ed2eaabd4 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -15,13 +15,8 @@ fn main() -> Result<()> {
 
 fn setup_logging() -> Result<()> {
     std::env::set_var("RUST_BACKTRACE", "short");
-
     env_logger::try_init()?;
-
-    ra_prof::set_filter(match std::env::var("RA_PROFILE") {
-        Ok(spec) => ra_prof::Filter::from_spec(&spec),
-        Err(_) => ra_prof::Filter::disabled(),
-    });
+    ra_prof::init();
     Ok(())
 }
 
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index ceff82fda..7ae2e1e6f 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -178,6 +178,7 @@ pub fn main_loop(
                     command: config.cargo_watch_command,
                     all_targets: config.cargo_watch_all_targets,
                 },
+                rustfmt_args: config.rustfmt_args,
             }
         };
 
@@ -526,6 +527,7 @@ fn on_request(
         .on::<req::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
         .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)?
         .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)?
+        .on::<req::Ssr>(handlers::handle_ssr)?
         .finish();
     Ok(())
 }
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 2e598fdcd..ae51141cb 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -590,6 +590,7 @@ pub fn handle_formatting(
     let end_position = TextUnit::of_str(&file).conv_with(&file_line_index);
 
     let mut rustfmt = process::Command::new("rustfmt");
+    rustfmt.args(&world.options.rustfmt_args);
     if let Some(&crate_id) = crate_ids.first() {
         // Assume all crates are in the same edition
         let edition = world.analysis().crate_edition(crate_id)?;
@@ -881,6 +882,11 @@ pub fn handle_document_highlight(
     ))
 }
 
+pub fn handle_ssr(world: WorldSnapshot, params: req::SsrParams) -> Result<req::SourceChange> {
+    let _p = profile("handle_ssr");
+    world.analysis().structural_search_replace(&params.arg)??.try_conv_with(&world)
+}
+
 pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> {
     let _p = profile("publish_diagnostics");
     let line_index = world.analysis().file_line_index(file_id)?;
@@ -918,9 +924,9 @@ fn to_lsp_runnable(
     let args = runnable_args(world, file_id, &runnable.kind)?;
     let line_index = world.analysis().file_line_index(file_id)?;
     let label = match &runnable.kind {
-        RunnableKind::Test { name } => format!("test {}", name),
+        RunnableKind::Test { test_id } => format!("test {}", test_id),
         RunnableKind::TestMod { path } => format!("test-mod {}", path),
-        RunnableKind::Bench { name } => format!("bench {}", name),
+        RunnableKind::Bench { test_id } => format!("bench {}", test_id),
         RunnableKind::Bin => "run binary".to_string(),
     };
     Ok(req::Runnable {
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index dc327f53d..7ff7f60b3 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -206,3 +206,16 @@ pub struct InlayHint {
     pub kind: InlayKind,
     pub label: String,
 }
+
+pub enum Ssr {}
+
+impl Request for Ssr {
+    type Params = SsrParams;
+    type Result = SourceChange;
+    const METHOD: &'static str = "rust-analyzer/ssr";
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct SsrParams {
+    pub arg: String,
+}
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index 1ee02b47c..d993c5fc4 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -34,6 +34,7 @@ pub struct Options {
     pub supports_location_link: bool,
     pub line_folding_only: bool,
     pub max_inlay_hint_length: Option<usize>,
+    pub rustfmt_args: Vec<String>,
     pub cargo_watch: CheckOptions,
 }
 
diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/ra_lsp_server/tests/heavy_tests/main.rs
index dff63a12d..9ca31cbcc 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/main.rs
@@ -147,7 +147,7 @@ fn main() {}
         },
         json!([
           {
-            "args": [ "test", "--package", "foo", "--test", "spam", "--", "test_eggs", "--nocapture" ],
+            "args": [ "test", "--package", "foo", "--test", "spam", "--", "test_eggs", "--exact", "--nocapture" ],
             "bin": "cargo",
             "env": { "RUST_BACKTRACE": "short" },
             "label": "test test_eggs",
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index d38ff397e..c0bfbc2ee 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -26,6 +26,13 @@ pub use crate::memory_usage::{Bytes, MemoryUsage};
 #[global_allocator]
 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 
+pub fn init() {
+    set_filter(match std::env::var("RA_PROFILE") {
+        Ok(spec) => Filter::from_spec(&spec),
+        Err(_) => Filter::disabled(),
+    });
+}
+
 /// Set profiling filter. It specifies descriptions allowed to profile.
 /// This is helpful when call stack has too many nested profiling scopes.
 /// Additionally filter can specify maximum depth of profiling scopes nesting.
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 862eb1172..89d1403e7 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -84,7 +84,7 @@ pub fn expr_prefix(op: SyntaxKind, expr: ast::Expr) -> ast::Expr {
     let token = token(op);
     expr_from_text(&format!("{}{}", token, expr.syntax()))
 }
-fn expr_from_text(text: &str) -> ast::Expr {
+pub fn expr_from_text(text: &str) -> ast::Expr {
     ast_from_text(&format!("const C: () = {};", text))
 }
 
diff --git a/docs/dev/debugging.md b/docs/dev/debugging.md
index 1ccf4dca2..e6b082156 100644
--- a/docs/dev/debugging.md
+++ b/docs/dev/debugging.md
@@ -1,44 +1,66 @@
-# Debugging vs Code plugin and the Language Server
+# Debugging VSCode plugin and the language server
 
-**NOTE:** the information here is mostly obsolete
+## Prerequisites
 
-Install [LLDB](https://lldb.llvm.org/) and the [LLDB Extension](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb).
+- Install [LLDB](https://lldb.llvm.org/) and the [LLDB Extension](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb).
+- Open the root folder in VSCode. Here you can access the preconfigured debug setups.
 
-Checkout rust rust-analyzer and open it in vscode.
+  <img height=150px src="https://user-images.githubusercontent.com/36276403/74611090-92ec5380-5101-11ea-8a41-598f51f3f3e3.png" alt="Debug options view">
+
+- Install all TypeScript dependencies
+  ```bash
+  cd editors/code
+  npm install
+  ```
+
+## Common knowledge
+
+* All debug configurations open a new `[Extension Development Host]` VSCode instance
+where **only** the `rust-analyzer` extension being debugged is enabled.
+* To activate the extension you need to open any Rust project folder in `[Extension Development Host]`.
 
-```
-$ git clone https://github.com/rust-analyzer/rust-analyzer.git --depth 1
-$ cd rust-analyzer
-$ code .
-```
 
-- To attach to the `lsp server` in linux you'll have to run:
+## Debug TypeScript VSCode extension
 
-  `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope`
+- `Run Extension` - runs the extension with the globally installed `ra_lsp_server` binary.
+- `Run Extension (Dev Server)` - runs extension with the locally built LSP server (`target/debug/ra_lsp_server`).
+
+TypeScript debugging is configured to watch your source edits and recompile.
+To apply changes to an already running debug process press <kbd>Ctrl+Shift+P</kbd> and run the following command in your `[Extension Development Host]`
+
+```
+> Developer: Reload Window
+```
 
-  This enables ptrace on non forked processes
+## Debug Rust LSP server
 
-- Ensure the dependencies for the extension are installed, run the `npm: install - editors/code` task in vscode.
+- When attaching a debugger to an already running `rust-analyzer` server on Linux you might need to enable `ptrace` for unrelated processes by running:
 
-- Launch the `Debug Extension`, this will build the extension and the `lsp server`.
+  ```
+  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
+  ```
 
-- A new instance of vscode with `[Extension Development Host]` in the title.
 
-  Don't worry about disabling `rls` all other extensions will be disabled but this one.
+- By default, the LSP server is built without debug information. To enable it, you'll need to change `Cargo.toml`:
+  ```toml
+    [profile.dev]
+    debug = 2
+  ```
 
-- In the new vscode instance open a rust project, and navigate to a rust file
+- Select `Run Extension (Dev Server)` to run your locally built `target/debug/ra_lsp_server`.
 
-- In the original vscode start an additional debug session (the three periods in the launch) and select `Debug Lsp Server`.
+- In the original VSCode window once again select the `Attach To Server` debug configuration.
 
-- A list of running processes should appear select the `ra_lsp_server` from this repo.
+- A list of running processes should appear. Select the `ra_lsp_server` from this repo.
 
 - Navigate to `crates/ra_lsp_server/src/main_loop.rs` and add a breakpoint to the `on_task` function.
 
-- Go back to the `[Extension Development Host]` instance and hover over a rust variable and your breakpoint should hit.
+- Go back to the `[Extension Development Host]` instance and hover over a Rust variable and your breakpoint should hit.
 
 ## Demo
 
-![demonstration of debugging](https://user-images.githubusercontent.com/1711539/51384036-254fab80-1b2c-11e9-824d-95f9a6e9cf4f.gif)
+- [Debugging TypeScript VScode extension](https://www.youtube.com/watch?v=T-hvpK6s4wM).
+- [Debugging Rust LSP server](https://www.youtube.com/watch?v=EaNb5rg4E0M).
 
 ## Troubleshooting
 
diff --git a/docs/user/readme.adoc b/docs/user/readme.adoc
index 867aae975..57a8cbe31 100644
--- a/docs/user/readme.adoc
+++ b/docs/user/readme.adoc
@@ -19,6 +19,13 @@ https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/readme.adoc
 In theory, one should be able to just install the server binary and have it automatically work with any editor.
 We are not there yet, so some editor specific setup is required.
 
+Additionally, rust-analyzer needs sources of the standard library.
+This commands adds them:
+
+```bash
+$ rustup component add rust-src
+```
+
 === VS Code
 
 This the best supported editor at the moment.
@@ -27,8 +34,9 @@ https://github.com/rust-analyzer/rust-analyzer/tree/master/editors/code[in tree]
 
 You can install the latest release of the plugin from
 https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer[the marketplace].
-By default, the plugin will download the latest version of the server as well.
+By default, the plugin will download the matching version of the server as well.
 
+// FIXME: update the image (its text has changed)
 image::https://user-images.githubusercontent.com/36276403/74103174-a40df100-4b52-11ea-81f4-372c70797924.png[]
 
 The server binary is stored in `~/.config/Code/User/globalStorage/matklad.rust-analyzer`.
@@ -37,9 +45,7 @@ Note that we only support the latest version of VS Code.
 
 ==== Updates
 
-The extension will be updated automatically as new versions become available.
-The server update functionality is in progress.
-For the time being, the workaround is to remove the binary from `globalStorage` and to restart the extension.
+The extension will be updated automatically as new versions become available. It will ask your permission to download the matching language server version binary if needed.
 
 ==== Building From Source
 
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index c74078735..22aa63c9d 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -1,6 +1,6 @@
 {
     "name": "rust-analyzer",
-    "version": "0.2.0-dev",
+    "version": "0.2.20200211-dev",
     "lockfileVersion": 1,
     "requires": true,
     "dependencies": {
@@ -77,9 +77,9 @@
             "dev": true
         },
         "@types/node": {
-            "version": "12.12.25",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.25.tgz",
-            "integrity": "sha512-nf1LMGZvgFX186geVZR1xMZKKblJiRfiASTHw85zED2kI1yDKHDwTKMdkaCbTlXoRKlGKaDfYywt+V0As30q3w==",
+            "version": "12.12.27",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.27.tgz",
+            "integrity": "sha512-odQFl/+B9idbdS0e8IxDl2ia/LP8KZLXhV3BUeI98TrZp0uoIzQPhGd+5EtzHmT0SMOIaPd7jfz6pOHLWTtl7A==",
             "dev": true
         },
         "@types/node-fetch": {
@@ -682,9 +682,9 @@
             }
         },
         "rollup": {
-            "version": "1.31.0",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.31.0.tgz",
-            "integrity": "sha512-9C6ovSyNeEwvuRuUUmsTpJcXac1AwSL1a3x+O5lpmQKZqi5mmrjauLeqIjvREC+yNRR8fPdzByojDng+af3nVw==",
+            "version": "1.31.1",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.31.1.tgz",
+            "integrity": "sha512-2JREN1YdrS/kpPzEd33ZjtuNbOuBC3ePfuZBdKEybvqcEcszW1ckyVqzcEiEe0nE8sqHK+pbJg+PsAgRJ8+1dg==",
             "dev": true,
             "requires": {
                 "@types/estree": "*",
diff --git a/editors/code/package.json b/editors/code/package.json
index db1fe5189..8f24a13f5 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -6,7 +6,7 @@
     "private": true,
     "icon": "icon.png",
     "//": "The real version is in release.yaml, this one just needs to be bigger",
-    "version": "0.2.0-dev",
+    "version": "0.2.20200211-dev",
     "publisher": "matklad",
     "repository": {
         "url": "https://github.com/rust-analyzer/rust-analyzer.git",
@@ -33,11 +33,11 @@
     "devDependencies": {
         "@rollup/plugin-commonjs": "^11.0.2",
         "@rollup/plugin-node-resolve": "^7.1.1",
-        "@types/node": "^12.12.25",
+        "@types/node": "^12.12.27",
         "@types/node-fetch": "^2.5.4",
         "@types/throttle-debounce": "^2.1.0",
         "@types/vscode": "^1.42.0",
-        "rollup": "^1.31.0",
+        "rollup": "^1.31.1",
         "tslib": "^1.10.0",
         "tslint": "^5.20.1",
         "typescript": "^3.7.5",
@@ -124,6 +124,11 @@
                 "command": "rust-analyzer.onEnter",
                 "title": "Enhanced enter key",
                 "category": "Rust Analyzer"
+            },
+            {
+                "command": "rust-analyzer.ssr",
+                "title": "Structural Search Replace",
+                "category": "Rust Analyzer"
             }
         ],
         "keybindings": [
@@ -182,9 +187,20 @@
                 },
                 "rust-analyzer.excludeGlobs": {
                     "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
                     "default": [],
                     "description": "Paths to exclude from analysis"
                 },
+                "rust-analyzer.rustfmtArgs": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": [],
+                    "description": "Additional arguments to rustfmt"
+                },
                 "rust-analyzer.useClientWatching": {
                     "type": "boolean",
                     "default": true,
@@ -197,6 +213,9 @@
                 },
                 "rust-analyzer.cargo-watch.arguments": {
                     "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
                     "description": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
                     "default": []
                 },
@@ -228,10 +247,12 @@
                 },
                 "rust-analyzer.lruCapacity": {
                     "type": [
-                        "number",
-                        "null"
+                        "null",
+                        "integer"
                     ],
                     "default": null,
+                    "minimum": 0,
+                    "exclusiveMinimum": true,
                     "description": "Number of syntax trees rust-analyzer keeps in memory"
                 },
                 "rust-analyzer.displayInlayHints": {
@@ -240,8 +261,13 @@
                     "description": "Display additional type and parameter information in the editor"
                 },
                 "rust-analyzer.maxInlayHintLength": {
-                    "type": "number",
+                    "type": [
+                        "null",
+                        "integer"
+                    ],
                     "default": 20,
+                    "minimum": 0,
+                    "exclusiveMinimum": true,
                     "description": "Maximum length for inlay hints"
                 },
                 "rust-analyzer.cargoFeatures.noDefaultFeatures": {
@@ -256,6 +282,9 @@
                 },
                 "rust-analyzer.cargoFeatures.features": {
                     "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
                     "default": [],
                     "description": "List of features to activate"
                 }
diff --git a/editors/code/rollup.config.js b/editors/code/rollup.config.js
index f8d320f46..337385a24 100644
--- a/editors/code/rollup.config.js
+++ b/editors/code/rollup.config.js
@@ -18,6 +18,7 @@ export default {
     external: [...nodeBuiltins, 'vscode'],
     output: {
         file: './out/main.js',
-        format: 'cjs'
+        format: 'cjs',
+        exports: 'named'
     }
 };
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index d2759969b..11894973c 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -1,45 +1,48 @@
 import * as lc from 'vscode-languageclient';
+import * as vscode from 'vscode';
 
-import { window, workspace } from 'vscode';
 import { Config } from './config';
-import { ensureLanguageServerBinary } from './installation/language_server';
+import { ensureServerBinary } from './installation/server';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 
 export async function createClient(config: Config): Promise<null | lc.LanguageClient> {
     // '.' Is the fallback if no folder is open
     // TODO?: Workspace folders support Uri's (eg: file://test.txt).
     // It might be a good idea to test if the uri points to a file.
-    const workspaceFolderPath = workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
+    const workspaceFolderPath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
 
-    const raLspServerPath = await ensureLanguageServerBinary(config.langServerSource);
-    if (!raLspServerPath) return null;
+    const serverPath = await ensureServerBinary(config.serverSource);
+    if (!serverPath) return null;
 
     const run: lc.Executable = {
-        command: raLspServerPath,
+        command: serverPath,
         options: { cwd: workspaceFolderPath },
     };
     const serverOptions: lc.ServerOptions = {
         run,
         debug: run,
     };
-    const traceOutputChannel = window.createOutputChannel(
+    const traceOutputChannel = vscode.window.createOutputChannel(
         'Rust Analyzer Language Server Trace',
     );
+    const cargoWatchOpts = config.cargoWatchOptions;
+
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: 'file', language: 'rust' }],
         initializationOptions: {
             publishDecorations: true,
             lruCapacity: config.lruCapacity,
             maxInlayHintLength: config.maxInlayHintLength,
-            cargoWatchEnable: config.cargoWatchOptions.enable,
-            cargoWatchArgs: config.cargoWatchOptions.arguments,
-            cargoWatchCommand: config.cargoWatchOptions.command,
-            cargoWatchAllTargets: config.cargoWatchOptions.allTargets,
+            cargoWatchEnable: cargoWatchOpts.enable,
+            cargoWatchArgs: cargoWatchOpts.arguments,
+            cargoWatchCommand: cargoWatchOpts.command,
+            cargoWatchAllTargets: cargoWatchOpts.allTargets,
             excludeGlobs: config.excludeGlobs,
             useClientWatching: config.useClientWatching,
             featureFlags: config.featureFlags,
             withSysroot: config.withSysroot,
             cargoFeatures: config.cargoFeatures,
+            rustfmtArgs: config.rustfmtArgs,
         },
         traceOutputChannel,
     };
diff --git a/editors/code/src/commands/index.ts b/editors/code/src/commands/index.ts
index aee969432..b5ebec117 100644
--- a/editors/code/src/commands/index.ts
+++ b/editors/code/src/commands/index.ts
@@ -12,6 +12,7 @@ export * from './parent_module';
 export * from './syntax_tree';
 export * from './expand_macro';
 export * from './runnables';
+export * from './ssr';
 
 export function collectGarbage(ctx: Ctx): Cmd {
     return async () => {
diff --git a/editors/code/src/commands/ssr.ts b/editors/code/src/commands/ssr.ts
new file mode 100644
index 000000000..6287bf47b
--- /dev/null
+++ b/editors/code/src/commands/ssr.ts
@@ -0,0 +1,36 @@
+import { Ctx, Cmd } from '../ctx';
+import { applySourceChange, SourceChange } from '../source_change';
+import * as vscode from 'vscode';
+
+export function ssr(ctx: Ctx): Cmd {
+    return async () => {
+        const client = ctx.client;
+        if (!client) return;
+
+        const options: vscode.InputBoxOptions = {
+            placeHolder: "foo($a:expr, $b:expr) ==>> bar($a, foo($b))",
+            prompt: "Enter request",
+            validateInput: (x: string) => {
+                if (x.includes('==>>')) {
+                    return null;
+                }
+                return "Enter request: pattern ==>> template"
+            }
+        }
+        const request = await vscode.window.showInputBox(options);
+
+        if (!request) return;
+
+        const ssrRequest: SsrRequest = { arg: request };
+        const change = await client.sendRequest<SourceChange>(
+            'rust-analyzer/ssr',
+            ssrRequest,
+        );
+
+        await applySourceChange(ctx, change);
+    };
+}
+
+interface SsrRequest {
+    arg: string;
+}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 418845436..c3fa788c7 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -16,45 +16,61 @@ export interface CargoFeatures {
     allFeatures: boolean;
     features: string[];
 }
-
 export class Config {
-    langServerSource!: null | BinarySource;
+    private static readonly rootSection = "rust-analyzer";
+    private static readonly requiresReloadOpts = [
+        "cargoFeatures",
+        "cargo-watch",
+    ]
+    .map(opt => `${Config.rootSection}.${opt}`);
+
+    private static readonly extensionVersion: string = (() => {
+        const packageJsonVersion = vscode
+            .extensions
+            .getExtension("matklad.rust-analyzer")!
+            .packageJSON
+            .version as string; // n.n.YYYYMMDD
+
+        const realVersionRegexp = /^\d+\.\d+\.(\d{4})(\d{2})(\d{2})/;
+        const [, yyyy, mm, dd] = packageJsonVersion.match(realVersionRegexp)!;
+
+        return `${yyyy}-${mm}-${dd}`;
+    })();
+
+    private cfg!: vscode.WorkspaceConfiguration;
+
+    constructor(private readonly ctx: vscode.ExtensionContext) {
+        vscode.workspace.onDidChangeConfiguration(this.onConfigChange, this, ctx.subscriptions);
+        this.refreshConfig();
+    }
 
-    highlightingOn = true;
-    rainbowHighlightingOn = false;
-    enableEnhancedTyping = true;
-    lruCapacity: null | number = null;
-    displayInlayHints = true;
-    maxInlayHintLength: null | number = null;
-    excludeGlobs: string[] = [];
-    useClientWatching = true;
-    featureFlags: Record<string, boolean> = {};
-    // for internal use
-    withSysroot: null | boolean = null;
-    cargoWatchOptions: CargoWatchOptions = {
-        enable: true,
-        arguments: [],
-        command: '',
-        allTargets: true,
-    };
-    cargoFeatures: CargoFeatures = {
-        noDefaultFeatures: false,
-        allFeatures: true,
-        features: [],
-    };
+    private refreshConfig() {
+        this.cfg = vscode.workspace.getConfiguration(Config.rootSection);
+        console.log("Using configuration:", this.cfg);
+    }
 
-    private prevEnhancedTyping: null | boolean = null;
-    private prevCargoFeatures: null | CargoFeatures = null;
-    private prevCargoWatchOptions: null | CargoWatchOptions = null;
+    private async onConfigChange(event: vscode.ConfigurationChangeEvent) {
+        this.refreshConfig();
 
-    constructor(ctx: vscode.ExtensionContext) {
-        vscode.workspace.onDidChangeConfiguration(_ => this.refresh(ctx), null, ctx.subscriptions);
-        this.refresh(ctx);
+        const requiresReloadOpt = Config.requiresReloadOpts.find(
+            opt => event.affectsConfiguration(opt)
+        );
+
+        if (!requiresReloadOpt) return;
+
+        const userResponse = await vscode.window.showInformationMessage(
+            `Changing "${requiresReloadOpt}" requires a reload`,
+            "Reload now"
+        );
+
+        if (userResponse === "Reload now") {
+            vscode.commands.executeCommand("workbench.action.reloadWindow");
+        }
     }
 
-    private static expandPathResolving(path: string) {
-        if (path.startsWith('~/')) {
-            return path.replace('~', os.homedir());
+    private static replaceTildeWithHomeDir(path: string) {
+        if (path.startsWith("~/")) {
+            return os.homedir() + path.slice("~".length);
         }
         return path;
     }
@@ -64,17 +80,14 @@ export class Config {
      * `platform` on GitHub releases. (It is also stored under the same name when
      * downloaded by the extension).
      */
-    private static prebuiltLangServerFileName(
-        platform: NodeJS.Platform,
-        arch: string
-    ): null | string {
+    get prebuiltServerFileName(): null | string {
         // See possible `arch` values here:
         // https://nodejs.org/api/process.html#process_process_arch
 
-        switch (platform) {
+        switch (process.platform) {
 
             case "linux": {
-                switch (arch) {
+                switch (process.arch) {
                     case "arm":
                     case "arm64": return null;
 
@@ -97,29 +110,26 @@ export class Config {
         }
     }
 
-    private static langServerBinarySource(
-        ctx: vscode.ExtensionContext,
-        config: vscode.WorkspaceConfiguration
-    ): null | BinarySource {
-        const langServerPath = RA_LSP_DEBUG ?? config.get<null | string>("raLspServerPath");
+    get serverSource(): null | BinarySource {
+        const serverPath = RA_LSP_DEBUG ?? this.cfg.get<null | string>("raLspServerPath");
 
-        if (langServerPath) {
+        if (serverPath) {
             return {
                 type: BinarySource.Type.ExplicitPath,
-                path: Config.expandPathResolving(langServerPath)
+                path: Config.replaceTildeWithHomeDir(serverPath)
             };
         }
 
-        const prebuiltBinaryName = Config.prebuiltLangServerFileName(
-            process.platform, process.arch
-        );
+        const prebuiltBinaryName = this.prebuiltServerFileName;
 
         if (!prebuiltBinaryName) return null;
 
         return {
             type: BinarySource.Type.GithubRelease,
-            dir: ctx.globalStoragePath,
+            dir:  this.ctx.globalStoragePath,
             file: prebuiltBinaryName,
+            storage: this.ctx.globalState,
+            version: Config.extensionVersion,
             repo: {
                 name: "rust-analyzer",
                 owner: "rust-analyzer",
@@ -127,158 +137,36 @@ export class Config {
         };
     }
 
+    // We don't do runtime config validation here for simplicity. More on stackoverflow:
+    // https://stackoverflow.com/questions/60135780/what-is-the-best-way-to-type-check-the-configuration-for-vscode-extension
+
+    get highlightingOn()        { return this.cfg.get("highlightingOn") as boolean; }
+    get rainbowHighlightingOn() { return this.cfg.get("rainbowHighlightingOn") as boolean; }
+    get lruCapacity()           { return this.cfg.get("lruCapacity") as null | number; }
+    get displayInlayHints()     { return this.cfg.get("displayInlayHints") as boolean; }
+    get maxInlayHintLength()    { return this.cfg.get("maxInlayHintLength") as number; }
+    get excludeGlobs()          { return this.cfg.get("excludeGlobs") as string[]; }
+    get useClientWatching()     { return this.cfg.get("useClientWatching") as boolean; }
+    get featureFlags()          { return this.cfg.get("featureFlags") as Record<string, boolean>; }
+    get rustfmtArgs()           { return this.cfg.get("rustfmtArgs") as string[]; }
+    
+    get cargoWatchOptions(): CargoWatchOptions {
+        return {
+            enable:     this.cfg.get("cargo-watch.enable") as boolean,
+            arguments:  this.cfg.get("cargo-watch.arguments") as string[],
+            allTargets: this.cfg.get("cargo-watch.allTargets") as boolean,
+            command:    this.cfg.get("cargo-watch.command") as string,
+        };
+    }
 
-    // FIXME: revisit the logic for `if (.has(...)) config.get(...)` set default
-    // values only in one place (i.e. remove default values from non-readonly members declarations)
-    private refresh(ctx: vscode.ExtensionContext) {
-        const config = vscode.workspace.getConfiguration('rust-analyzer');
-
-        let requireReloadMessage = null;
-
-        if (config.has('highlightingOn')) {
-            this.highlightingOn = config.get('highlightingOn') as boolean;
-        }
-
-        if (config.has('rainbowHighlightingOn')) {
-            this.rainbowHighlightingOn = config.get(
-                'rainbowHighlightingOn',
-            ) as boolean;
-        }
-
-        if (config.has('enableEnhancedTyping')) {
-            this.enableEnhancedTyping = config.get(
-                'enableEnhancedTyping',
-            ) as boolean;
-
-            if (this.prevEnhancedTyping === null) {
-                this.prevEnhancedTyping = this.enableEnhancedTyping;
-            }
-        } else if (this.prevEnhancedTyping === null) {
-            this.prevEnhancedTyping = this.enableEnhancedTyping;
-        }
-
-        if (this.prevEnhancedTyping !== this.enableEnhancedTyping) {
-            requireReloadMessage =
-                'Changing enhanced typing setting requires a reload';
-            this.prevEnhancedTyping = this.enableEnhancedTyping;
-        }
-
-        this.langServerSource = Config.langServerBinarySource(ctx, config);
-
-        if (config.has('cargo-watch.enable')) {
-            this.cargoWatchOptions.enable = config.get<boolean>(
-                'cargo-watch.enable',
-                true,
-            );
-        }
-
-        if (config.has('cargo-watch.arguments')) {
-            this.cargoWatchOptions.arguments = config.get<string[]>(
-                'cargo-watch.arguments',
-                [],
-            );
-        }
-
-        if (config.has('cargo-watch.command')) {
-            this.cargoWatchOptions.command = config.get<string>(
-                'cargo-watch.command',
-                '',
-            );
-        }
-
-        if (config.has('cargo-watch.allTargets')) {
-            this.cargoWatchOptions.allTargets = config.get<boolean>(
-                'cargo-watch.allTargets',
-                true,
-            );
-        }
-
-        if (config.has('lruCapacity')) {
-            this.lruCapacity = config.get('lruCapacity') as number;
-        }
-
-        if (config.has('displayInlayHints')) {
-            this.displayInlayHints = config.get('displayInlayHints') as boolean;
-        }
-        if (config.has('maxInlayHintLength')) {
-            this.maxInlayHintLength = config.get(
-                'maxInlayHintLength',
-            ) as number;
-        }
-        if (config.has('excludeGlobs')) {
-            this.excludeGlobs = config.get('excludeGlobs') || [];
-        }
-        if (config.has('useClientWatching')) {
-            this.useClientWatching = config.get('useClientWatching') || true;
-        }
-        if (config.has('featureFlags')) {
-            this.featureFlags = config.get('featureFlags') || {};
-        }
-        if (config.has('withSysroot')) {
-            this.withSysroot = config.get('withSysroot') || false;
-        }
-
-        if (config.has('cargoFeatures.noDefaultFeatures')) {
-            this.cargoFeatures.noDefaultFeatures = config.get(
-                'cargoFeatures.noDefaultFeatures',
-                false,
-            );
-        }
-        if (config.has('cargoFeatures.allFeatures')) {
-            this.cargoFeatures.allFeatures = config.get(
-                'cargoFeatures.allFeatures',
-                true,
-            );
-        }
-        if (config.has('cargoFeatures.features')) {
-            this.cargoFeatures.features = config.get(
-                'cargoFeatures.features',
-                [],
-            );
-        }
-
-        if (
-            this.prevCargoFeatures !== null &&
-            (this.cargoFeatures.allFeatures !==
-                this.prevCargoFeatures.allFeatures ||
-                this.cargoFeatures.noDefaultFeatures !==
-                this.prevCargoFeatures.noDefaultFeatures ||
-                this.cargoFeatures.features.length !==
-                this.prevCargoFeatures.features.length ||
-                this.cargoFeatures.features.some(
-                    (v, i) => v !== this.prevCargoFeatures!.features[i],
-                ))
-        ) {
-            requireReloadMessage = 'Changing cargo features requires a reload';
-        }
-        this.prevCargoFeatures = { ...this.cargoFeatures };
-
-        if (this.prevCargoWatchOptions !== null) {
-            const changed =
-                this.cargoWatchOptions.enable !== this.prevCargoWatchOptions.enable ||
-                this.cargoWatchOptions.command !== this.prevCargoWatchOptions.command ||
-                this.cargoWatchOptions.allTargets !== this.prevCargoWatchOptions.allTargets ||
-                this.cargoWatchOptions.arguments.length !== this.prevCargoWatchOptions.arguments.length ||
-                this.cargoWatchOptions.arguments.some(
-                    (v, i) => v !== this.prevCargoWatchOptions!.arguments[i],
-                );
-            if (changed) {
-                requireReloadMessage = 'Changing cargo-watch options requires a reload';
-            }
-        }
-        this.prevCargoWatchOptions = { ...this.cargoWatchOptions };
-
-        if (requireReloadMessage !== null) {
-            const reloadAction = 'Reload now';
-            vscode.window
-                .showInformationMessage(requireReloadMessage, reloadAction)
-                .then(selectedAction => {
-                    if (selectedAction === reloadAction) {
-                        vscode.commands.executeCommand(
-                            'workbench.action.reloadWindow',
-                        );
-                    }
-                });
-        }
+    get cargoFeatures(): CargoFeatures {
+        return {
+            noDefaultFeatures: this.cfg.get("cargoFeatures.noDefaultFeatures") as boolean,
+            allFeatures:       this.cfg.get("cargoFeatures.allFeatures") as boolean,
+            features:          this.cfg.get("cargoFeatures.features") as string[],
+        };
     }
+
+    // for internal use
+    get withSysroot() { return this.cfg.get("withSysroot", true) as boolean; }
 }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 70042a479..ff6245f78 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -60,6 +60,10 @@ export class Ctx {
         this.pushCleanup(d);
     }
 
+    get globalState(): vscode.Memento {
+        return this.extCtx.globalState;
+    }
+
     get subscriptions(): Disposable[] {
         return this.extCtx.subscriptions;
     }
@@ -87,15 +91,11 @@ export async function sendRequestWithRetry<R>(
     for (const delay of [2, 4, 6, 8, 10, null]) {
         try {
             return await (token ? client.sendRequest(method, param, token) : client.sendRequest(method, param));
-        } catch (e) {
-            if (
-                e.code === lc.ErrorCodes.ContentModified &&
-                delay !== null
-            ) {
-                await sleep(10 * (1 << delay));
-                continue;
+        } catch (err) {
+            if (delay === null || err.code !== lc.ErrorCodes.ContentModified) {
+                throw err;
             }
-            throw e;
+            await sleep(10 * (1 << delay));
         }
     }
     throw 'unreachable';
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 1c019a51b..3896878cd 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -13,7 +13,7 @@ export function activateInlayHints(ctx: Ctx) {
 
     vscode.workspace.onDidChangeTextDocument(
         async event => {
-            if (event.contentChanges.length !== 0) return;
+            if (event.contentChanges.length === 0) return;
             if (event.document.languageId !== 'rust') return;
             await hintsUpdater.refresh();
         },
@@ -27,7 +27,9 @@ export function activateInlayHints(ctx: Ctx) {
         ctx.subscriptions
     );
 
-    ctx.onDidRestart(_ => hintsUpdater.setEnabled(ctx.config.displayInlayHints));
+    // We pass async function though it will not be awaited when called,
+    // thus Promise rejections won't be handled, but this should never throw in fact...
+    ctx.onDidRestart(async _ => hintsUpdater.setEnabled(ctx.config.displayInlayHints));
 }
 
 interface InlayHintsParams {
@@ -36,7 +38,7 @@ interface InlayHintsParams {
 
 interface InlayHint {
     range: vscode.Range;
-    kind: string;
+    kind: "TypeHint" | "ParameterHint";
     label: string;
 }
 
@@ -53,7 +55,7 @@ const parameterHintDecorationType = vscode.window.createTextEditorDecorationType
 });
 
 class HintsUpdater {
-    private pending: Map<string, vscode.CancellationTokenSource> = new Map();
+    private pending = new Map<string, vscode.CancellationTokenSource>();
     private ctx: Ctx;
     private enabled: boolean;
 
@@ -62,30 +64,36 @@ class HintsUpdater {
         this.enabled = ctx.config.displayInlayHints;
     }
 
-    async setEnabled(enabled: boolean) {
+    async setEnabled(enabled: boolean): Promise<void> {
         if (this.enabled == enabled) return;
         this.enabled = enabled;
 
         if (this.enabled) {
-            await this.refresh();
-        } else {
-            this.allEditors.forEach(it => {
-                this.setTypeDecorations(it, []);
-                this.setParameterDecorations(it, []);
-            });
+            return await this.refresh();
         }
+        this.allEditors.forEach(it => {
+            this.setTypeDecorations(it, []);
+            this.setParameterDecorations(it, []);
+        });
     }
 
     async refresh() {
         if (!this.enabled) return;
-        const promises = this.allEditors.map(it => this.refreshEditor(it));
-        await Promise.all(promises);
+        await Promise.all(this.allEditors.map(it => this.refreshEditor(it)));
+    }
+
+    private get allEditors(): vscode.TextEditor[] {
+        return vscode.window.visibleTextEditors.filter(
+            editor => editor.document.languageId === 'rust',
+        );
     }
 
     private async refreshEditor(editor: vscode.TextEditor): Promise<void> {
         const newHints = await this.queryHints(editor.document.uri.toString());
         if (newHints == null) return;
-        const newTypeDecorations = newHints.filter(hint => hint.kind === 'TypeHint')
+
+        const newTypeDecorations = newHints
+            .filter(hint => hint.kind === 'TypeHint')
             .map(hint => ({
                 range: hint.range,
                 renderOptions: {
@@ -96,7 +104,8 @@ class HintsUpdater {
             }));
         this.setTypeDecorations(editor, newTypeDecorations);
 
-        const newParameterDecorations = newHints.filter(hint => hint.kind === 'ParameterHint')
+        const newParameterDecorations = newHints
+            .filter(hint => hint.kind === 'ParameterHint')
             .map(hint => ({
                 range: hint.range,
                 renderOptions: {
@@ -108,12 +117,6 @@ class HintsUpdater {
         this.setParameterDecorations(editor, newParameterDecorations);
     }
 
-    private get allEditors(): vscode.TextEditor[] {
-        return vscode.window.visibleTextEditors.filter(
-            editor => editor.document.languageId === 'rust',
-        );
-    }
-
     private setTypeDecorations(
         editor: vscode.TextEditor,
         decorations: vscode.DecorationOptions[],
@@ -137,12 +140,14 @@ class HintsUpdater {
     private async queryHints(documentUri: string): Promise<InlayHint[] | null> {
         const client = this.ctx.client;
         if (!client) return null;
+
         const request: InlayHintsParams = {
             textDocument: { uri: documentUri },
         };
         const tokenSource = new vscode.CancellationTokenSource();
-        const prev = this.pending.get(documentUri);
-        if (prev) prev.cancel();
+        const prevHintsRequest = this.pending.get(documentUri);
+        prevHintsRequest?.cancel();
+
         this.pending.set(documentUri, tokenSource);
         try {
             return await sendRequestWithRetry<InlayHint[] | null>(
diff --git a/editors/code/src/installation/download_artifact.ts b/editors/code/src/installation/download_artifact.ts
new file mode 100644
index 000000000..de655f8f4
--- /dev/null
+++ b/editors/code/src/installation/download_artifact.ts
@@ -0,0 +1,58 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import { promises as fs } from "fs";
+import { strict as assert } from "assert";
+
+import { ArtifactReleaseInfo } from "./interfaces";
+import { downloadFile } from "./download_file";
+import { throttle } from "throttle-debounce";
+
+/**
+ * Downloads artifact from given `downloadUrl`.
+ * Creates `installationDir` if it is not yet created and put the artifact under
+ * `artifactFileName`.
+ * Displays info about the download progress in an info message printing the name
+ * of the artifact as `displayName`.
+ */
+export async function downloadArtifact(
+    {downloadUrl, releaseName}: ArtifactReleaseInfo,
+    artifactFileName: string,
+    installationDir: string,
+    displayName: string,
+) {
+    await fs.mkdir(installationDir).catch(err => assert.strictEqual(
+        err?.code,
+        "EEXIST",
+        `Couldn't create directory "${installationDir}" to download `+
+        `${artifactFileName} artifact: ${err.message}`
+    ));
+
+    const installationPath = path.join(installationDir, artifactFileName);
+
+    console.time(`Downloading ${artifactFileName}`);
+    await vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            cancellable: false, // FIXME: add support for canceling download?
+            title: `Downloading ${displayName} (${releaseName})`
+        },
+        async (progress, _cancellationToken) => {
+            let lastPrecentage = 0;
+            const filePermissions = 0o755; // (rwx, r_x, r_x)
+            await downloadFile(downloadUrl, installationPath, filePermissions, throttle(
+                200,
+                /* noTrailing: */ true,
+                (readBytes, totalBytes) => {
+                    const newPercentage = (readBytes / totalBytes) * 100;
+                    progress.report({
+                        message: newPercentage.toFixed(0) + "%",
+                        increment: newPercentage - lastPrecentage
+                    });
+
+                    lastPrecentage = newPercentage;
+                })
+            );
+        }
+    );
+    console.timeEnd(`Downloading ${artifactFileName}`);
+}
diff --git a/editors/code/src/installation/fetch_latest_artifact_metadata.ts b/editors/code/src/installation/fetch_artifact_release_info.ts
index 7e3700603..7d497057a 100644
--- a/editors/code/src/installation/fetch_latest_artifact_metadata.ts
+++ b/editors/code/src/installation/fetch_artifact_release_info.ts
@@ -1,26 +1,32 @@
 import fetch from "node-fetch";
-import { GithubRepo, ArtifactMetadata } from "./interfaces";
+import { GithubRepo, ArtifactReleaseInfo } from "./interfaces";
 
 const GITHUB_API_ENDPOINT_URL = "https://api.github.com";
 
+
 /**
- * Fetches the latest release from GitHub `repo` and returns metadata about
- * `artifactFileName` shipped with this release or `null` if no such artifact was published.
+ * Fetches the release with `releaseTag` (or just latest release when not specified)
+ * from GitHub `repo` and returns metadata about `artifactFileName` shipped with
+ * this release or `null` if no such artifact was published.
  */
-export async function fetchLatestArtifactMetadata(
-    repo: GithubRepo, artifactFileName: string
-): Promise<null | ArtifactMetadata> {
+export async function fetchArtifactReleaseInfo(
+    repo: GithubRepo, artifactFileName: string, releaseTag?: string
+): Promise<null | ArtifactReleaseInfo> {
 
     const repoOwner = encodeURIComponent(repo.owner);
     const repoName  = encodeURIComponent(repo.name);
 
-    const apiEndpointPath = `/repos/${repoOwner}/${repoName}/releases/latest`;
+    const apiEndpointPath = releaseTag
+        ? `/repos/${repoOwner}/${repoName}/releases/tags/${releaseTag}`
+        : `/repos/${repoOwner}/${repoName}/releases/latest`;
+
     const requestUrl = GITHUB_API_ENDPOINT_URL + apiEndpointPath;
 
     // We skip runtime type checks for simplicity (here we cast from `any` to `GithubRelease`)
 
     console.log("Issuing request for released artifacts metadata to", requestUrl);
 
+    // FIXME: handle non-ok response
     const response: GithubRelease = await fetch(requestUrl, {
             headers: { Accept: "application/vnd.github.v3+json" }
         })
diff --git a/editors/code/src/installation/interfaces.ts b/editors/code/src/installation/interfaces.ts
index 8039d0b90..e40839e4b 100644
--- a/editors/code/src/installation/interfaces.ts
+++ b/editors/code/src/installation/interfaces.ts
@@ -1,3 +1,5 @@
+import * as vscode from "vscode";
+
 export interface GithubRepo {
     name: string;
     owner: string;
@@ -6,7 +8,7 @@ export interface GithubRepo {
 /**
  * Metadata about particular artifact retrieved from GitHub releases.
  */
-export interface ArtifactMetadata {
+export interface ArtifactReleaseInfo {
     releaseName: string;
     downloadUrl: string;
 }
@@ -50,6 +52,17 @@ export namespace BinarySource {
          * and in local `.dir`.
          */
         file: string;
+
+        /**
+         * Tag of github release that denotes a version required by this extension.
+         */
+        version: string;
+
+        /**
+         * Object that provides `get()/update()` operations to store metadata
+         * about the actual binary, e.g. its actual version.
+         */
+        storage: vscode.Memento;
     }
 
 }
diff --git a/editors/code/src/installation/language_server.ts b/editors/code/src/installation/language_server.ts
deleted file mode 100644
index 4797c3f01..000000000
--- a/editors/code/src/installation/language_server.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import * as vscode from "vscode";
-import * as path from "path";
-import { strict as assert } from "assert";
-import { promises as fs } from "fs";
-import { promises as dns } from "dns";
-import { spawnSync } from "child_process";
-import { throttle } from "throttle-debounce";
-
-import { BinarySource } from "./interfaces";
-import { fetchLatestArtifactMetadata } from "./fetch_latest_artifact_metadata";
-import { downloadFile } from "./download_file";
-
-export async function downloadLatestLanguageServer(
-    {file: artifactFileName, dir: installationDir, repo}: BinarySource.GithubRelease
-) {
-    const { releaseName, downloadUrl } = (await fetchLatestArtifactMetadata(
-        repo, artifactFileName
-    ))!;
-
-    await fs.mkdir(installationDir).catch(err => assert.strictEqual(
-        err?.code,
-        "EEXIST",
-        `Couldn't create directory "${installationDir}" to download `+
-        `language server binary: ${err.message}`
-    ));
-
-    const installationPath = path.join(installationDir, artifactFileName);
-
-    console.time("Downloading ra_lsp_server");
-    await vscode.window.withProgress(
-        {
-            location: vscode.ProgressLocation.Notification,
-            cancellable: false, // FIXME: add support for canceling download?
-            title: `Downloading language server (${releaseName})`
-        },
-        async (progress, _cancellationToken) => {
-            let lastPrecentage = 0;
-            const filePermissions = 0o755; // (rwx, r_x, r_x)
-            await downloadFile(downloadUrl, installationPath, filePermissions, throttle(
-                200,
-                /* noTrailing: */ true,
-                (readBytes, totalBytes) => {
-                    const newPercentage = (readBytes / totalBytes) * 100;
-                    progress.report({
-                        message: newPercentage.toFixed(0) + "%",
-                        increment: newPercentage - lastPrecentage
-                    });
-
-                    lastPrecentage = newPercentage;
-                })
-            );
-        }
-    );
-    console.timeEnd("Downloading ra_lsp_server");
-}
-export async function ensureLanguageServerBinary(
-    langServerSource: null | BinarySource
-): Promise<null | string> {
-
-    if (!langServerSource) {
-        vscode.window.showErrorMessage(
-            "Unfortunately we don't ship binaries for your platform yet. " +
-            "You need to manually clone rust-analyzer repository and " +
-            "run `cargo xtask install --server` to build the language server from sources. " +
-            "If you feel that your platform should be supported, please create an issue " +
-            "about that [here](https://github.com/rust-analyzer/rust-analyzer/issues) and we " +
-            "will consider it."
-        );
-        return null;
-    }
-
-    switch (langServerSource.type) {
-        case BinarySource.Type.ExplicitPath: {
-            if (isBinaryAvailable(langServerSource.path)) {
-                return langServerSource.path;
-            }
-
-            vscode.window.showErrorMessage(
-                `Unable to run ${langServerSource.path} binary. ` +
-                `To use the pre-built language server, set "rust-analyzer.raLspServerPath" ` +
-                "value to `null` or remove it from the settings to use it by default."
-            );
-            return null;
-        }
-        case BinarySource.Type.GithubRelease: {
-            const prebuiltBinaryPath = path.join(langServerSource.dir, langServerSource.file);
-
-            if (isBinaryAvailable(prebuiltBinaryPath)) {
-                return prebuiltBinaryPath;
-            }
-
-            const userResponse = await vscode.window.showInformationMessage(
-                "Language server binary for rust-analyzer was not found. " +
-                "Do you want to download it now?",
-                "Download now", "Cancel"
-            );
-            if (userResponse !== "Download now") return null;
-
-            try {
-                await downloadLatestLanguageServer(langServerSource);
-            } catch (err) {
-                vscode.window.showErrorMessage(
-                    `Failed to download language server from ${langServerSource.repo.name} ` +
-                    `GitHub repository: ${err.message}`
-                );
-
-                console.error(err);
-
-                dns.resolve('example.com').then(
-                    addrs => console.log("DNS resolution for example.com was successful", addrs),
-                    err => {
-                        console.error(
-                            "DNS resolution for example.com failed, " +
-                            "there might be an issue with Internet availability"
-                        );
-                        console.error(err);
-                    }
-                );
-
-                return null;
-            }
-
-            if (!isBinaryAvailable(prebuiltBinaryPath)) assert(false,
-                `Downloaded language server binary is not functional.` +
-                `Downloaded from: ${JSON.stringify(langServerSource)}`
-            );
-
-
-            vscode.window.showInformationMessage(
-                "Rust analyzer language server was successfully installed 🦀"
-            );
-
-            return prebuiltBinaryPath;
-        }
-    }
-
-    function isBinaryAvailable(binaryPath: string) {
-        const res = spawnSync(binaryPath, ["--version"]);
-
-        // ACHTUNG! `res` type declaration is inherently wrong, see
-        // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/42221
-
-        console.log("Checked binary availablity via --version", res);
-        console.log(binaryPath, "--version output:", res.output?.map(String));
-
-        return res.status === 0;
-    }
-}
diff --git a/editors/code/src/installation/server.ts b/editors/code/src/installation/server.ts
new file mode 100644
index 000000000..80cb719e3
--- /dev/null
+++ b/editors/code/src/installation/server.ts
@@ -0,0 +1,124 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import { strict as assert } from "assert";
+import { promises as dns } from "dns";
+import { spawnSync } from "child_process";
+
+import { BinarySource } from "./interfaces";
+import { fetchArtifactReleaseInfo } from "./fetch_artifact_release_info";
+import { downloadArtifact } from "./download_artifact";
+
+export async function ensureServerBinary(source: null | BinarySource): Promise<null | string> {
+    if (!source) {
+        vscode.window.showErrorMessage(
+            "Unfortunately we don't ship binaries for your platform yet. " +
+            "You need to manually clone rust-analyzer repository and " +
+            "run `cargo xtask install --server` to build the language server from sources. " +
+            "If you feel that your platform should be supported, please create an issue " +
+            "about that [here](https://github.com/rust-analyzer/rust-analyzer/issues) and we " +
+            "will consider it."
+        );
+        return null;
+    }
+
+    switch (source.type) {
+        case BinarySource.Type.ExplicitPath: {
+            if (isBinaryAvailable(source.path)) {
+                return source.path;
+            }
+
+            vscode.window.showErrorMessage(
+                `Unable to run ${source.path} binary. ` +
+                `To use the pre-built language server, set "rust-analyzer.raLspServerPath" ` +
+                "value to `null` or remove it from the settings to use it by default."
+            );
+            return null;
+        }
+        case BinarySource.Type.GithubRelease: {
+            const prebuiltBinaryPath = path.join(source.dir, source.file);
+
+            const installedVersion: null | string = getServerVersion(source.storage);
+            const requiredVersion: string = source.version;
+
+            console.log("Installed version:", installedVersion, "required:", requiredVersion);
+
+            if (isBinaryAvailable(prebuiltBinaryPath) && installedVersion == requiredVersion) {
+                // FIXME: check for new releases and notify the user to update if possible
+                return prebuiltBinaryPath;
+            }
+
+            const userResponse = await vscode.window.showInformationMessage(
+                `Language server version ${source.version} for rust-analyzer is not installed. ` +
+                "Do you want to download it now?",
+                "Download now", "Cancel"
+            );
+            if (userResponse !== "Download now") return null;
+
+            if (!await downloadServer(source)) return null;
+
+            return prebuiltBinaryPath;
+        }
+    }
+}
+
+async function downloadServer(source: BinarySource.GithubRelease): Promise<boolean> {
+    try {
+        const releaseInfo = (await fetchArtifactReleaseInfo(source.repo, source.file, source.version))!;
+
+        await downloadArtifact(releaseInfo, source.file, source.dir, "language server");
+        await setServerVersion(source.storage, releaseInfo.releaseName);
+    } catch (err) {
+        vscode.window.showErrorMessage(
+            `Failed to download language server from ${source.repo.name} ` +
+            `GitHub repository: ${err.message}`
+        );
+
+        console.error(err);
+
+        dns.resolve('example.com').then(
+            addrs => console.log("DNS resolution for example.com was successful", addrs),
+            err => {
+                console.error(
+                    "DNS resolution for example.com failed, " +
+                    "there might be an issue with Internet availability"
+                );
+                console.error(err);
+            }
+        );
+        return false;
+    }
+
+    if (!isBinaryAvailable(path.join(source.dir, source.file))) assert(false,
+        `Downloaded language server binary is not functional.` +
+        `Downloaded from: ${JSON.stringify(source, null, 4)}`
+    );
+
+    vscode.window.showInformationMessage(
+        "Rust analyzer language server was successfully installed 🦀"
+    );
+
+    return true;
+}
+
+function isBinaryAvailable(binaryPath: string): boolean {
+    const res = spawnSync(binaryPath, ["--version"]);
+
+    // ACHTUNG! `res` type declaration is inherently wrong, see
+    // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/42221
+
+    console.log("Checked binary availablity via --version", res);
+    console.log(binaryPath, "--version output:", res.output?.map(String));
+
+    return res.status === 0;
+}
+
+function getServerVersion(storage: vscode.Memento): null | string {
+    const version = storage.get<null | string>("server-version", null);
+    console.log("Get server-version:", version);
+    return version;
+}
+
+async function setServerVersion(storage: vscode.Memento, version: string): Promise<void> {
+    console.log("Set server-version:", version);
+    await storage.update("server-version", version.toString());
+}
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 5efce41f4..5a99e96f0 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -22,6 +22,7 @@ export async function activate(context: vscode.ExtensionContext) {
     ctx.registerCommand('run', commands.run);
     ctx.registerCommand('reload', commands.reload);
     ctx.registerCommand('onEnter', commands.onEnter);
+    ctx.registerCommand('ssr', commands.ssr)
 
     // Internal commands which are invoked by the server.
     ctx.registerCommand('runSingle', commands.runSingle);
diff --git a/editors/code/src/status_display.ts b/editors/code/src/status_display.ts
index 51dbf388b..993e79d70 100644
--- a/editors/code/src/status_display.ts
+++ b/editors/code/src/status_display.ts
@@ -66,9 +66,9 @@ class StatusDisplay implements Disposable {
 
     refreshLabel() {
         if (this.packageName) {
-            this.statusBarItem!.text = `${spinnerFrames[this.i]} cargo ${this.command} [${this.packageName}]`;
+            this.statusBarItem.text = `${spinnerFrames[this.i]} cargo ${this.command} [${this.packageName}]`;
         } else {
-            this.statusBarItem!.text = `${spinnerFrames[this.i]} cargo ${this.command}`;
+            this.statusBarItem.text = `${spinnerFrames[this.i]} cargo ${this.command}`;
         }
     }
 
diff --git a/xtask/src/install.rs b/xtask/src/install.rs
index 540a66130..00bbabce4 100644
--- a/xtask/src/install.rs
+++ b/xtask/src/install.rs
@@ -127,7 +127,7 @@ fn install_client(ClientOpt::VsCode: ClientOpt) -> Result<()> {
     if !installed_extensions.contains("rust-analyzer") {
         bail!(
             "Could not install the Visual Studio Code extension. \
-             Please make sure you have at least NodeJS 10.x together with the latest version of VS Code installed and try again."
+             Please make sure you have at least NodeJS 12.x together with the latest version of VS Code installed and try again."
         );
     }