34 files changed, 675 insertions, 369 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_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 b1f3f525d..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,
 }
@@ -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/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/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/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_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/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..553687e78 100644
--- a/docs/user/readme.adoc
+++ b/docs/user/readme.adoc
@@ -27,8 +27,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 +38,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.json b/editors/code/package.json
index a607c2148..ed1cae2ab 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",
@@ -233,11 +233,10 @@
                     "description": "Trace requests to the ra_lsp_server"
                 },
                 "rust-analyzer.lruCapacity": {
-                    "type": [
-                        "number",
-                        "null"
-                    ],
+                    "type": [ "null", "integer" ],
                     "default": null,
+                    "minimum": 0,
+                    "exclusiveMinimum": true,
                     "description": "Number of syntax trees rust-analyzer keeps in memory"
                 },
                 "rust-analyzer.displayInlayHints": {
@@ -246,9 +245,10 @@
                     "description": "Display additional type and parameter information in the editor"
                 },
                 "rust-analyzer.maxInlayHintLength": {
-                    "type": "number",
+                    "type": [ "null", "integer" ],
                     "default": 20,
-                    "exclusiveMinimum": 0,
+                    "minimum": 0,
+                    "exclusiveMinimum": true,
                     "description": "Maximum length for inlay hints"
                 },
                 "rust-analyzer.cargoFeatures.noDefaultFeatures": {
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 dcf9d0c06..efef820ab 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -2,7 +2,7 @@ import * as lc from 'vscode-languageclient';
 import * as vscode 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> {
@@ -11,11 +11,11 @@ export async function createClient(config: Config): Promise<null | lc.LanguageCl
     // It might be a good idea to test if the uri points to a file.
     const workspaceFolderPath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
 
-    const langServerPath = await ensureLanguageServerBinary(config.langServerBinarySource);
-    if (!langServerPath) return null;
+    const serverPath = await ensureServerBinary(config.serverSource);
+    if (!serverPath) return null;
 
     const run: lc.Executable = {
-        command: langServerPath,
+        command: serverPath,
         options: { cwd: workspaceFolderPath },
     };
     const serverOptions: lc.ServerOptions = {
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 8cd89e119..53e2a414b 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -24,6 +24,19 @@ export class Config {
     ]
     .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) {
@@ -31,7 +44,6 @@ export class Config {
         this.refreshConfig();
     }
 
-
     private refreshConfig() {
         this.cfg = vscode.workspace.getConfiguration(Config.rootSection);
         console.log("Using configuration:", this.cfg);
@@ -68,7 +80,7 @@ export class Config {
      * `platform` on GitHub releases. (It is also stored under the same name when
      * downloaded by the extension).
      */
-    get prebuiltLangServerFileName(): null | string {
+    get prebuiltServerFileName(): null | string {
         // See possible `arch` values here:
         // https://nodejs.org/api/process.html#process_process_arch
 
@@ -98,17 +110,17 @@ export class Config {
         }
     }
 
-    get langServerBinarySource(): null | BinarySource {
-        const langServerPath = RA_LSP_DEBUG ?? this.cfg.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.replaceTildeWithHomeDir(langServerPath)
+                path: Config.replaceTildeWithHomeDir(serverPath)
             };
         }
 
-        const prebuiltBinaryName = this.prebuiltLangServerFileName;
+        const prebuiltBinaryName = this.prebuiltServerFileName;
 
         if (!prebuiltBinaryName) return null;
 
@@ -116,6 +128,8 @@ export class Config {
             type: BinarySource.Type.GithubRelease,
             dir:  this.ctx.globalStoragePath,
             file: prebuiltBinaryName,
+            storage: this.ctx.globalState,
+            version: Config.extensionVersion,
             repo: {
                 name: "rust-analyzer",
                 owner: "rust-analyzer",
@@ -153,5 +167,5 @@ export class Config {
     }
 
     // for internal use
-    get withSysroot() { return this.cfg.get("withSysroot", false); }
+    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());
+}